Por que a minha simulação parcial tem todos os métodos virtuais zombaram, mesmo que não as expectativas são definidas?

Question

Eu tenho um controle de usuário que faz alguma validação no método ValidateChildren que eu gostaria de teste. Eu criei um mock parcial do controle de usuário, mas embora eu não ponho qualquer expectativa sobre o método ValidateChildren, estou simplesmente chamando-o, ele simplesmente é ignorado e o código dentro do método nunca é executado. Para tentar entender o que está acontecendo, eu criei um teste simples, assim:

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

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

e usar isso para testá-lo:

[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());
}

Agora eu esperaria foo.Method1 a ser escarnecido e foo.Method2 não ser. Mas isso sempre retorna false, e se eu tentar e passo através do depurador foo.Method2 () é pisou em cima, e eu não posso entrar nele.

Todas as ideias por quê?

Answer 1

Ok, depois de pouco mais de brincar (talvez apenas escrever o baixo problema me ajudou a pensar mais claramente sobre isso) Eu acho que encontrei a solução.

parece que eu preciso chamar:

RhinoMocksExtensions.Replay (foo);

antes que eu chame

Assert.IsTrue (foo.Method2 ());

Talvez simulações Rhino precisa ser dito explicitamente quando os métodos virtuais estão sendo usados ??e não a criação de expectativas. Não sei por que. Se alguém souber o raciocínio por trás disso eu adoraria saber.

De qualquer forma, tudo parece estar funcionando, dias tão felizes.

Answer 2

Se você zombar de um objeto que ele irá substituir todos os métodos abstractos / virtuais, independentemente do tipo de simulação. O que você pode fazer, porém, é fazer uma expectativa sobre o seu método e dizer-lhe para executar o método original que está substituindo usando:

CallOriginalMethod(OriginalCallOptions.CreateExpectation);

Você não está usando Rhino Mocks do jeito que era projeto que também poderia estar causando-lhe problemas. Tenho re-escrito o seu teste na forma como ele deve ser escrito usando C # 3.0 e lambda e extensão métodos:

[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();
}