Pourquoi toutes les méthodes virtuelles sont-elles moquées dans ma maquette partielle, même si aucune attente n'est définie?

Question

J'ai un contrôle utilisateur qui effectue une validation dans la méthode ValidateChildren que je voudrais tester. J'ai créé une maquette partielle du contrôle utilisateur, mais bien que je ne définisse pas d'attentes pour la méthode ValidateChildren, je l'appelle simplement, elle est simplement ignorée et le code à l'intérieur de la méthode ne s'exécute jamais. Pour essayer de comprendre ce qui se passe, j’ai créé un test simple, comme suit:

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

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

et utilisez-le pour le tester:

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

maintenant je m'attendrais à ce que foo.Method1 soit moqué et foo.Method2 ne le soit pas. Mais cela retourne toujours faux, et si j’essaie d’intervenir dans le débogueur foo.Method2 () est dépassé, et je ne peux pas intervenir.

Des idées pourquoi?

Answer 1

D'accord, après avoir joué un peu plus (peut-être que noter le problème m'a aidé à réfléchir plus clairement à ce sujet), je pense avoir trouvé la solution.

il semble que je doive appeler:

RhinoMocksExtensions.Replay (foo);

avant d'appeler

Assert.IsTrue (foo.Method2 ());

Peut-être que Rhino doit faire l’objet d’une explication explicite lorsque des méthodes virtuelles sont utilisées et non pour définir des attentes. Pas certain de pourquoi. Si quelqu'un connaissait le raisonnement derrière cela, j'aimerais bien le savoir.

Quoi qu’il en soit, tout semble fonctionner, jours heureux.

Answer 2

Si vous simulez un objet, il remplacera toutes les méthodes abstraites / virtuelles, quel que soit le type de simulacre. Ce que vous pouvez faire, c’est espérer votre méthode et lui dire d’exécuter la méthode originale qu’elle remplace en utilisant:

CallOriginalMethod(OriginalCallOptions.CreateExpectation);

Vous n’utilisez pas Rhino Mocks de la manière dont il a été conçu, ce qui pourrait également vous causer des ennuis. J'ai réécrit votre test de la manière dont il devrait être écrit en utilisant les méthodes C # 3.0, lambda et extension:

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