Comment affirmer qu'une méthode n'est appelée qu'une seule fois?

Question

[Subject(typeof(OnceADayProcessor))]
public class When_processing_process_twice
{
    private static ICanBeProcessedOnceADay ProcessedOnceADay;

    private Establish context = () => { OnceADayProcessor.Now = () => new DateTime(2011, 1, 1, 0, 0, 0, 0); };

    private Because of = () =>
                             {
                                 ProcessedOnceADay = MockRepository.GenerateMock<ICanBeProcessedOnceADay>();
                                 ProcessedOnceADay.Process();
                                 ProcessedOnceADay.Process();
                             };

    private It should_execute = () => ProcessedOnceADay.AssertWasCalled(x => x.Expect(p => p.Process()));
    private It should_execute_only_once = () => ProcessedOnceADay.AssertWasNotCalled(x => x.Expect(p => p.Process()));
}

solution modifiée:

[Subject(typeof(OnceADayProcessor))]
public class When_processing_a_process_twice_at_the_same_day
{
    static ICanBeProcessedOnceADay canBeProcessedOnceADay;

    Establish context = () =>
    {
        canBeProcessedOnceADay = A.Fake<ICanBeProcessedOnceADay>();
    };

    Because of = () =>
    {
        OnceADayProcessor.Process(canBeProcessedOnceADay);
        OnceADayProcessor.Process(canBeProcessedOnceADay);
    };

    It should_execute_only_once = () => 
        A.CallTo(() => canBeProcessedOnceADay.Process()).MustHaveHappened(Repeated.Exactly.Once);
}

Answer 1

var mock = MockRepository.GenerateMock<ICanBeProcessedOnceADay>();
mock.Expect(a => a.Process()).Repeat.Times(1);
...
mock.VerifyAllExpectations();

Answer 2

Je remplacerais les appels à stub.Expect() et stub.VerifyAllExpectations() par stub.AssertWasCalled(x => x.Process(), o => o.Repeat.Once()) dans le It.Si vous avez plus d'une attente par rapport au stub, vous pouvez ensuite placer chaque assertion dans un It et les faire échouer (ou réussir) indépendamment les unes des autres.

La création du stub irait dans Establish (essentiellement, la création de toutes les dépendances et le système sous test fait partie de la phase "arranger" des tests unitaires).

Pensez également à ne pas utiliser GenerateMock, mais GenerateStub car des simulations conduiront probablement à des tests fragiles lorsque vous appelez d'autres méthodes que celles spécifiées avec Expect.Les bibliothèques comme FakeItEasy fournissent généralement des API meilleures et plus découvrables, sont plus faciles à apprendre et vous feront tomber dans le «gouffre du succès».

Answer 3

Si vous voulez vous assurer qu'une méthode n'est appelée qu'une seule fois, vous avez besoin d'un simulacre strict:

var mock = MockRepository.GenerateStrictMock<IShouldOnlyBeCalledOnce>();
mock.Expect(a => a.Process()).Repeat.Once();

sut.Process(mock)

mock.VerifyAllExpectations();

Si vous utilisez juste GenerateMock, il effectuera une vérification "au moins".Cela vaut également pour Repeats.Times (x).