Verificar un evento fue planteado por objeto burlado

Question

En mi prueba unitaria, ¿cómo puedo verificar que el objeto burlado plantee un evento?

Tengo una vista (UI) -> ViewModel -> DataProvider -> ServiceProxy. ServiceProxy hace una llamada asíncrata a la operación de serio. Cuando la operación Async se completa un método en Dataprovider (se llama (el método de devolución de llamada se pasa como un parámetro de método). El método de devolución de llamada luego recauda y evento que ViewModel está escuchando.

Para la prueba de ViewModel, me simule DataProvider y verifique que el controlador exista para el evento planteado por Dataprovider. Al probar Dataprovider, me burlo de ServiceProxy, pero ¿cómo puedo probar ese método de devolución de llamada y se plantea el evento?

Estoy usando sintaxis de Rhinomock 3.5 y AAA

Gracias

-- Proveedor de datos --

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

Parece que tienes dos pruebas unitarias diferentes para escribir:

1. Prueba de unidad de proxy de servicio: esta prueba se asegurará de que la devolución de llamada enviada al ServiceProxy se llame al finalizar la llamada Async.

2. Prueba de unidad del proveedor de datos: esta prueba se asegurará de que cuando se llame cierto método, se plantea un evento (suponiendo que hubo algunos suscriptores).

¿En cuál estás buscando ayuda?

EDITAR:

Para el artículo n. ° 1, no veo que necesitaría burlarse. Simplemente proporcione una devolución de llamada que establezca alguna variable en True cuando se llama:

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

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

// assert
Assert.IsTrue(callbackMade);

Para el artículo #2, nuevamente, suscríbase al evento en su prueba unitaria y asegúrese de que se llame el evento:

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

// act
dp.DoSomethingThatShouldRaiseEvent();

// assert
Assert.IsTrue(eventRaised)

No conozco las firmas de sus eventos/devoluciones de llamada, así que acabo de hacer algunas conjeturas.

Answer 2

El siguiente ejemplo establece un IService stub que simplemente invocará cualquier devolución de llamada que se le pase cuando IService.AsyncOperationWithCallBack(Action callback) se llama.

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