Perché la mia simulazione parziale ha deriso tutti i metodi virtuali, anche se non ci sono aspettative?

Question

Ho un controllo utente che esegue alcune convalide nel metodo ValidateChildren che vorrei testare. Ho creato una derisione parziale del controllo utente, ma anche se non sto ponendo aspettative sul metodo ValidateChildren, lo sto semplicemente chiamando, viene semplicemente ignorato e il codice all'interno del metodo non viene mai eseguito. Per cercare di capire cosa sta succedendo ho creato un semplice test, in questo modo:

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

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

e usalo per testarlo:

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

ora mi aspetterei che foo.Method1 sia deriso e foo.Method2 non lo sia. Ma questo restituisce sempre falso, e se provo ad entrare nel debugger foo.Method2 () viene scavalcato e non posso intervenire.

Qualche idea sul perché?

Answer 1

Ok, dopo aver giocato ancora un po '(forse solo scrivere il problema mi ha aiutato a pensarci più chiaramente) Penso di aver trovato la soluzione.

sembra che devo chiamare:

RhinoMocksExtensions.Replay (foo);

prima di chiamare

Assert.IsTrue (foo.Method2 ());

Forse le derisioni di Rhino devono essere esplicitamente raccontate quando si usano metodi virtuali e non si creano aspettative. Non so perché. Se qualcuno conosce il ragionamento alla base di questo mi piacerebbe saperlo.

Comunque tutto sembra funzionare, quindi giorni felici.

Answer 2

Se deridi un oggetto, questo sovrascriverà tutti i metodi astratti / virtuali indipendentemente dal tipo di derisione. Quello che puoi fare però è aspettarti il ??tuo metodo e dirgli di eseguire il metodo originale che sta scavalcando usando:

CallOriginalMethod(OriginalCallOptions.CreateExpectation);

Non stai usando Rhino Mock nel modo in cui è stato progettato, il che potrebbe anche causare problemi. Ho riscritto il tuo test nel modo in cui dovrebbe essere scritto usando i metodi C # 3.0 e lambda ed estensione:

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