¿Por qué mi simulacro parcial tiene todos los métodos virtuales burlados, incluso si no se establecen expectativas?

Question

Tengo un control de usuario que hace alguna validación en el método ValidateChildren que me gustaría probar. He creado una simulación parcial del control de usuario, pero aunque no estoy estableciendo ninguna expectativa sobre el método ValidateChildren, simplemente lo llamo, simplemente se omite y el código dentro del método nunca se ejecuta. Para probar y entender lo que está pasando, creé una prueba simple, como esta:

public class Foo
{        
    public virtual bool Method1()
    {
        throw new NotImplementedException();
    }

    public virtual bool Method2()
    {
        return Method1();
    }
}

y usa esto para probarlo:

[Test]
public void TestFooMethods ()
{
    MockRepository m = new MockRepository();
    Foo foo = m.PartialMock<Foo>();

    RhinoMocksExtensions.Expect<Foo,bool>(
                             foo, 
                             delegate (Foo obj)
                             {
                                 return obj.Method1();
                             }
                         ).Return(true);

    Assert.IsTrue (foo.Method2());
}

ahora esperaría que foo.Method1 sea burlado y foo.Method2 no sea. Pero esto siempre devuelve falso, y si trato de avanzar en el depurador foo.Method2 () se pasa por alto, y no puedo entrar en él.

¿Alguna idea de por qué?

Answer 1

Bien, después de jugar un poco más (tal vez solo anotar el problema me ayudó a pensar más claramente al respecto) creo que he encontrado la solución.

parece que necesito llamar:

RhinoMocksExtensions.Replay (foo);

antes de llamar

Assert.IsTrue (foo.Method2 ());

Quizás Rhino se deba explicar explícitamente cuando se usan métodos virtuales y no se establecen expectativas. No estoy seguro de por qué. Si alguien sabe el razonamiento detrás de esto, me encantaría saberlo.

De todos modos todo parece estar funcionando, así que días felices.

Answer 2

Si se burla de un objeto, anulará todos los métodos abstractos / virtuales, independientemente del tipo de simulacro. Sin embargo, lo que puede hacer es hacer una expectativa sobre su método y decirle que ejecute el método original que está anulando mediante:

CallOriginalMethod(OriginalCallOptions.CreateExpectation);

No está utilizando Rhino Mocks de la forma en que se diseñó, lo que también podría causarle problemas. He reescrito su prueba de la forma en que debería escribirse utilizando C # 3.0 y lambda y métodos de extensión:

[TestMethod]
public void TestFooMethods()
{
    //Generate a new Mock to test against
    Foo foo = MockRepository.GenerateMock<Foo>();

    //Expect a call to Method1 on object foo and return true
    foo.Expect(f => f.Method1()).Return(true);
    //Expect a call to Method2 on object foo and call the original method
    foo.Expect(f => f.Method2()).CallOriginalMethod(OriginalCallOptions.CreateExpectation);

    Assert.IsTrue(foo.Method2());

    //Verify all our expectations on foo
    foo.VerifyAllExpectations();
}