L'utilisation correcte de expectLastCall().une fois() dans EasyMock

Je suis en train d'écrire un test unitaire pour une méthode particulière. La méthode contient des appels à d'autres méthodes dans une classe DAO qui je suis moqueur avec EasyMock.

Je tiens à affirmer que l'un de ces DAO les méthodes de la classe est appelée une fois, qui est ce que je suppose expectLastCall().une fois que() est pour. La méthode en question renvoie void.

Le test j'ai passe actuellement, je veux juste m'assurer que ma logique est correcte, puisque je n'ai pas utilisé EasyMock avant. J'ai utilisé cette question comme une référence: EasyMock attentes avec des méthodes void

Donc, voici le code:

    @Before
    public void setUp() throws Exception{
    this.fooService = new FooService();
    this.fooMock = createStrictMock(FooDAO.class);
    }

    @Test
    public void test_fooTest(){

    String arg1 = "arg1";
    String arg2 = "arg2";
    this.fooService.setFooDAO(fooMock);
    expect(this.fooMock.someMethod(arg1, arg2)).andReturn(something);
    fooMock.methodThatShouldBeCalledOnce(EasyMock.<Object>anyObject());
    EasyMock.expectLastCall().once();
    replay(this.fooMock);
    this.fooService.methodUnderTest(someArg, someArg2);
    verify(this.fooMock);

    }

Ce que je pense, ce n'est affirmer qu'il y a un appel à methodThatShouldBeCalledOnce et qu'il se produit seulement une fois. Je n'ai pas vraiment de soins sur someMethod mais bien sûr EasyMock se plaint si il n'est pas dit de l'attendre.

Merci!

InformationsquelleAutor user1088166 | 2013-03-06
  1. 1

    Qui semble correct pour moi. Vous pouvez facilement vérifier par vous-même en retrait de l'appel à la méthode void et vérifier que le test échoue, ou par l'ajout d'un deuxième appel à la méthode void et de voir que le test échoue également.

    • Oui, il échoue dans ces deux scénarios, merci.
    InformationsquelleAutor JB Nizet
  2. 1

    Si vous n'avez pas de soins sur certaines méthodes, vous devez créer une belle maquette. Alors, en effet, il n'y a pas besoin d'appeler expectLastCall. Il est implicite mais peut être une bonne pratique pour la rendre évident que vous êtes se moquant d'une méthode. une fois (n'est pas non plus nécessaire, car c'est la valeur par défaut.

    Donc, si un reformuler, à l'aide d'un gentil mick, le retrait implicite des appels, en ajoutant de la statique des importations et de ne pas ajouter redondant "ce", vous devriez obtenir:

    @Before
public void setUp() throws Exception{
   fooService = new FooService();
   fooMock = createNiceMock(FooDAO.class);
   fooService.setFooDAO(fooMock);
}

@Test
public void test_fooTest(){  
   fooMock.methodThatShouldBeCalledOnce(anyObject());

   replay(fooMock); //or replayAll() if you extend EasyMockSupport

   fooService.methodUnderTest(someArg, someArg2);
   verify(fooMock); //or verifyAll() if you extend EasyMockSupport
}
    InformationsquelleAutor Henri