Überprüfen Sie ein Ereignis ausgelöst wurde, indem Sie verspottet Objekt

Question

In meinem unit-test-wie kann ich überprüfen, ob ein Ereignis ausgelöst wird, durch das verspottete Objekt.

Ich habe eine Ansicht(UI) --> ViewModel --> DataProvider --> ServiceProxy.ServiceProxy macht async-Aufruf-Service-Betrieb.Wenn der asynchrone Vorgang abgeschlossen ist eine Methode, die auf der DataProvider wird aufgerufen (callback-Methode übergeben wird als parameter der Methode).Die callback-Methode dann zu erhöhen, und Ereignis, welches ViewModel zu hören.

Für ViewModel zu testen, habe ich die mock-Provider, und überprüfen Sie, ob-handler existiert für Ereignis-ausgelöst durch DataProvider.Beim testen DataProvider ich verspotte ServiceProxy, aber wie kann ich testen, dass die callback-Methode wird aufgerufen und das Ereignis wird ausgelöst.

Ich bin mit RhinoMock 3.5-und AAA-syntax

Vielen Dank

-- DataProvider --

public partial class DataProvider
{
    public event EventHandler<EntityEventArgs<ProductDefinition>> GetProductDefinitionCompleted;

    public void GetProductDefinition()
    {
        var service = IoC.Resolve<IServiceProxy>();
        service.GetProductDefinitionAsync(GetProductDefinitionAsyncCallback);
    }

    private void GetProductDefinitionAsyncCallback(ProductDefinition productDefinition, ServiceError error)
    {
        OnGetProductDefinitionCompleted(this, new EntityEventArgs<ProductDefinition>(productDefinition, error));
    }

    protected void OnGetProductDefinitionCompleted(object sender, EntityEventArgs<ProductDefinition> e)
    {
        if (GetProductDefinitionCompleted != null)
            GetProductDefinitionCompleted(sender, e);
    }
}

-- ServiceProxy --

public class ServiceProxy : ClientBase<IService>, IServiceProxy
{
    public void GetProductDefinitionAsync(Action<ProductDefinition, ServiceError> callback)
    {
        Channel.BeginGetProductDefinition(EndGetProductDefinition, callback);
    }

    private void EndGetProductDefinition(IAsyncResult result)
    {
        Action<ProductDefinition, ServiceError> callback =
            result.AsyncState as Action<ProductDefinition, ServiceError>;

        ServiceError error;
        ProductDefinition results = Channel.EndGetProductDefinition(out error, result);

        if (callback != null)
            callback(results, error);
    }
}

Answer 1

Es klingt wie Sie haben zwei verschiedene unit-tests zu schreiben:

1. Service-Proxy-unit test:Dieser test soll sicherstellen, dass der Rückruf gesendet, um die ServiceProxy aufgerufen wird, werden nach Abschluss des async Aufrufs.

2. Data Provider unit-test:Dieser test soll sicherstellen, dass, wenn eine bestimmte Methode aufgerufen wird, wird ein Ereignis ausgelöst wird (vorausgesetzt, es gab einige Abonnenten).

Welche suchst du Hilfe?

EDIT:

Für Punkt 1, ich sehe nicht, dass Sie müssten jede spöttisch.Geben Sie einfach einen Rückruf, legt einige Variablen auf true, wenn Sie aufgerufen wird:

// arrange
IServiceProxy serviceProxy = new ServiceProxy();
bool callbackMade;

// act
serviceProxy.GetDataAsync(() => callbackMade = true);

// assert
Assert.IsTrue(callbackMade);

Für Element #2, wieder, dann abonnieren Sie das Ereignis in Ihrem unit-test und stellen Sie sicher, dass das Ereignis aufgerufen wird:

// arrange
DataProvider dp = new DataProvider();
bool eventRaised;
dp.DataReturned += (s,e) => eventRaised = true;

// act
dp.DoSomethingThatShouldRaiseEvent();

// assert
Assert.IsTrue(eventRaised)

Ich weiß nicht, die Unterschriften Ihres events/callbacks, so dass ich nur einige Vermutungen.

Answer 2

Das folgende Beispiel richtet eine ein IService Stub, der einfach jeden Rückruf aufruft, der an ihn weitergegeben wird, wenn IService.AsyncOperationWithCallBack(Action callback) wird genannt.

// arrange
var serviceStub = MockRepository.GenerateStub<IService>();
serviceStub.Stub(x => x.AsyncOperationWithCallBack(Arg<Action>.Is.NotNull))
    .WhenCalled(
        invokation =>
        {
            var callback = (Action)invokation.Arguments[0];
            callback();
        });

var dataProvider = new DataProvider(serviceStub);  

// act
bool raised = false;
dataProvider.MyEvent += delegate { raised = true; };
dataProvider.DoSomething();

// assert
serviceStub.AssertWasCalled(
    x=>x.AsyncOperationWithCallBack(Arg<Action>.Is.NotNull));
Assert.IsTrue(raised);