método de devolución de llamada Prueba RhinoMocks

Question

Tengo una clase de proxy de servicio que hace la llamada asyn a la operación del servicio. Yo uso un método de devolución de llamada para pasar los resultados de vuelta a mi modelo de vista.

Hacer pruebas funcionales de vista del modelo, que puede burlarse de proxy de servicio para garantizar métodos se llaman en el proxy, pero ¿cómo puedo garantizar que el método de devolución de llamada se llama así?

Con RhinoMocks puedo comprobar que los eventos son manipulados y eventos evento plantean en el objeto burlado, pero ¿cómo puedo probar devoluciones de llamada?

modelo de vista:

public class MyViewModel
{
    public void GetDataAsync()
    {
        // Use DI framework to get the object
        IMyServiceClient myServiceClient = IoC.Resolve<IMyServiceClient>();
        myServiceClient.GetData(GetDataAsyncCallback);
    }

    private void GetDataAsyncCallback(Entity entity, ServiceError error)
    {
        // do something here...
    }

}

ServiceProxy:

public class MyService : ClientBase<IMyService>, IMyServiceClient
{
    // Constructor
    public NertiAdminServiceClient(string endpointConfigurationName, string remoteAddress)
        :
            base(endpointConfigurationName, remoteAddress)
    {
    }

    // IMyServiceClient member.
    public void GetData(Action<Entity, ServiceError> callback)
    {
        Channel.BeginGetData(EndGetData, callback);
    }

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

        ServiceError error;
        Entity results = Channel.EndGetData(out error, result);

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

Gracias

Answer 1

jugado un poco con esto un poco y creo que puede tener lo que estás buscando. En primer lugar, voy a mostrar el código de MSTest que hice para verificar lo siguiente:

[TestClass]
public class UnitTest3
{
    private delegate void MakeCallbackDelegate(Action<Entity, ServiceError> callback);

    [TestMethod]
    public void CallbackIntoViewModel()
    {
        var service = MockRepository.GenerateStub<IMyServiceClient>();
        var model = new MyViewModel(service);

        service.Stub(s => s.GetData(null)).Do(
            new MakeCallbackDelegate(c => model.GetDataCallback(new Entity(), new ServiceError())));
        model.GetDataAsync(null);
    }
}

public class MyViewModel
{
    private readonly IMyServiceClient client;

    public MyViewModel(IMyServiceClient client)
    {
        this.client = client;
    }

    public virtual void GetDataAsync(Action<Entity, ServiceError> callback)
    {
        this.client.GetData(callback);
    }

    internal void GetDataCallback(Entity entity, ServiceError serviceError)
    {

    }
}

public interface IMyServiceClient
{
    void GetData(Action<Entity, ServiceError> callback);
}

public class Entity
{
}

public class ServiceError
{
}

Se dará cuenta de algunas cosas:

1. Hice su devolución de llamada interna. Tendrá que utilizar el atributo InternalsVisisbleTo () para que su ViewModel expone conjunto de internos a las pruebas unitarias (no estoy loco por esto, pero sucede en casos raros como este).

2. Yo uso Rhino.Mocks "Do" para ejecutar la devolución de llamada cuando se llama el GetData. No está usando la llamada de retorno, pero esto es realmente más de una prueba de integración. Asumo que tienes una prueba de unidad modelo de vista para asegurarse de que la devolución de llamada verdadera pasado a GetData se ejecuta en el momento apropiado.

3. Obviamente, tendrá que crear / ramal simulacro Entidad y ServiceError objetos en lugar de simplemente new'ing arriba como lo hice.