Verify un événement a été soulevée par objet moqua

Question

Dans mon test unitaire comment puis-je vérifier qu'un événement est déclenché par l'objet raillé.

J'ai une vue (UI) -> ViewModel -> DataProvider -> ServiceProxy. ServiceProxy fait appel à un fonctionnement async serivce. Lorsque l'opération est terminée async une méthode sur DataProvider est appelé (méthode de rappel est transmise en tant que paramètre de la méthode). La méthode de rappel puis relevez et événement qui ViewModel écoute.

Pour le test ViewModel je me moque DataProvider et vérifiez que gestionnaire existe pour l'événement soulevé par DataProvider. Lors du test DataProvider je me moque ServiceProxy, mais comment puis-je tester cette méthode de rappel est appelée et événement est déclenché.

J'utilise RhinoMock 3.5 et la syntaxe AAA

Merci

- 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

Il semble que vous avez deux tests unitaires différents pour l'écriture:

1. Service Proxy test unitaire. Ce test fera en sorte que le rappel envoyé à l'ServiceProxy sera appelé à la fin de l'appel async

2. données test unitaire du fournisseur. Ce test fera en sorte que quand une certaine méthode est appelée, un événement est élevé (en supposant qu'il y avait des abonnés)

Lequel êtes-vous à la recherche d'aide?

EDIT:

Pour le point 1, je ne vois pas que vous auriez besoin de moqueries. Il suffit de fournir un rappel que les ensembles une variable à true lorsque appelé:

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

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

// assert
Assert.IsTrue(callbackMade);

Pour le point 2, encore une fois, suffit de souscrire à l'événement dans votre test unitaire et assurez-vous que l'événement est appelé:

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

// act
dp.DoSomethingThatShouldRaiseEvent();

// assert
Assert.IsTrue(eventRaised)

Je ne sais pas les signatures de vos événements / callbacks donc je viens de faire quelques suppositions.

Answer 2

Les jeux par exemple le suivi d'un talon de IService qui va simplement se prévaloir de tout rappel qui est passé à quand IService.AsyncOperationWithCallBack(Action callback) est appelé.

// 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);