À l'aide de Mockito annotations avec le printemps

Je suis à l'aide de printemps dans mon application et je veux écrire des tests unitaires pour toutes mes classes. J'appelle quelques-uns des services web externes à partir de mon application et je veux se moquer d'eux à l'aide de Mockito depuis je veux juste tester mon fonctionnalités.

Permet de dire que j'ai le scénario suivant

C'est mon webservice interface

public interface MyWebService {
    public String getSomeData(int id);
}

- Je utiliser le service ci-dessus, de cette façon

public interface MyService {
    int doSomethingElse(String str);
}

public class MyServiceImpl implements MyService {

    private MyWebService myWebService;

    int doSomethingElse(String str) {
        .....
        myWebService.getSomeData(id);
        ...
    }
}

public interface MyService1 {
    Stirng methodToBeTested();
}


public class Class1 implements MyService1{
    @Resource
    private MyService myService;

    public Stirng methodToBeTested() {
        myService.doSomethingElse("..");
    }
}

J'ai écrit le uint cas de test comme ci-dessous. Je suis d'espionnage MyService, afin d'exécuter le test de l'unité.

public class class1Test {

    @Spy
    MyService myService;

    @Resource
    @InjectMocks
    Class1 class1;

    public void setUPTest() {
        MockitoAnnotations.initMocks(this);
    Mockito.doReturn(123).when(myService).doSomethingElse("someString");
    }

    @Test
    public void methodToBeTestedTest() {
        this.setUPTest();
            ...
            class1.methodToBeTested();
    }

}

Quand je lance le test, ce que je vois, c'est que, j'obtiens la valeur de la webservice place de ce que je mentionne tout en écrasant.

Quelqu'un peut-il m'aider?

Voir aussi stackoverflow.com/questions/2457239/...

OriginalL'auteur rahul | 2013-03-26

J'ai résolu ce problème en utilisant spring java config. J'ai étendu mon fichier de config par défaut dans mon test du fichier de config.

    @Configuration
    public class TestConfig extends DefaultConfig {

      @Bean
      public MyService myService() {
        return Mockito.spy(new MyServiceImpl());
      }
    }

Maintenant, ma classe de test qui va comme ceci

public class class1Test {

    @Resource
    MyService myService;

    @Resource
    Class1 class1;

    public void setUPTest() {
        MockitoAnnotations.initMocks(this);
    Mockito.doReturn(123).when(myService).doSomethingElse("someString");
    }

    @Test
    public void methodToBeTestedTest() {
        this.setUPTest();
            ...
            class1.methodToBeTested();
    }

}

OriginalL'auteur rahul

3

Un @Spy est utilisé pour espionner ce qui se passe lors de l'appel de services (et utile pour, par exemple. affirmer la présence ou l'absence de transitives des invocations de méthode), ce que vous voulez, c'est le @Mock annotation:
```
public class class1Test {
    @Mock MyService myService;
    ...
```
Ainsi, dans tout le myService méthodes de retourner null, barre de ceux que vous surcharger avec doReturn/when.

D'ailleurs, plutôt que d'appeler setUpTest() de vos méthodes de test, vous devez annoter avec @Before.

Acclamations,

J'ai utilisé espion ici, car il existe d'autres méthodes de MyService qui dosent besoin d'être écrasé.(Ceci est juste un exemple de code qui ressemble à la mienne)

OriginalL'auteur Anders R. Bystrup
3

Pour remplacer votre Bean avec fantaisie dans certains test de l'utilisation Springockito ou mieux Springockito-annotations.

Quelque chose comme cela devrait fonctionner:
```
@ContextConfiguration(loader = SpringockitoContextLoader.class,
    locations = "classpath:/context.xml")
public class SpringockitoAnnotationsMocksIntegrationTest extends AbstractJUnit4SpringContextTests {

    @WrapWithSpy
    private MyService innerBean;

    @Resource  
    Class1 class1;

    public void setUPTest() {        
        Mockito.doReturn(123).when(myService).doSomethingElse("someString");
    }

    @Test
    public void methodToBeTestedTest() {
    this.setUPTest();
        ...
        class1.methodToBeTested();
    }
```
}

J'ai vu le lien ci-dessus. Comment puis-je injecter "myService" espion "class1" à l'aide de springockito. Dans Class1, "MyService" est privée et n'a pas de setter.
mis à jour. Si dans votre contexte réel myService est injecté à Class1 - il sera injecté avec WrapWithSpy trop.
Je suis à l'aide de spring java config pour l'initialisation de haricots, springockito dosent la soutenir.
semble fonctionner avec SpringockitoAnnotatedContextLoader.class
Merci! Qui a résolu mon problème. Mais j'ai utilisé "ReplaceWithMock" avec "Autocâblés" annotations combinaison espionner un véritable printemps de haricot.

OriginalL'auteur Michail Nikolaev
2

Voulez-vous dire anyString() plutôt que de "someString" dans votre setUp méthode? Cela peut aussi être eq("someString") si vous appelez votre méthode avec une chaîne de caractères.

À partir de ma compréhension de Mockito je n'utilise pas fait car ils ont probablement indiquer une classe de problèmes de conception. Pourquoi ne pas vous @Mock l'ensemble de MyService, donc;
```
@Mock MyService myService;


public void setUpTest() {
    MockitoAnnotations.initMocks(this);
    when(myService.doSomethingElse(anyString)).thenReturn(123);
}
```
J'ai eu une semblable conception de classe jusqu'à ce que je suis venu à tester lorsque j'ai réalisé ma classe était en train de faire trop de choses, rendant difficile l'unité de test. Pensez à diviser le web-service du travail à une classe de gestionnaire. De cette façon, vous pouvez construire votre classe avec la maquette ed gestionnaire et de faire disparaître la @Spy. Tous les appels à la ws peut alors être simplement moqué avec l'option de non-espionnage de l'outillage.
Qui permettrait de résoudre le problème, mais le plus triste, c'est que je ne peux pas changer l'origine de la mise en œuvre de MyService ou MyServiceImpl.
Ah oui, vous avez raison d'utiliser un espion alors. Je n'avais pas conscience. Ils sont particulièrement utiles lorsqu'il s'agit de la 3e partie/legacy code. Mon avis sur le Rapprochement de rendement de mieux se moquant de résultats?
Pas de. Le seul problème, je suis confronté à est ici avec "@Resource" et "@InjectMocks" utilisé sur le même variable. La variable est initialisée d'abord avec "@Ressource", alors l'injection dosent arriver.

OriginalL'auteur OceanLife

Modifié,

    public class class1Test {

    @Mock
    private MyService myService;

    private Class1 class1;

    @Before
    public void onceBeforeEachTest() {
        MockitoAnnotations.initMocks(this);
         this.class1 = new Class1(myService); 
        Mockito.when(myService).doSomethingElse(anyString()).thenReturn(123);
    }

    @Test
    public void methodToBeTestedTest() {
            class1.methodToBeTested();
    }
}

Je n'ai pas un constructeur qui prend un objet en tant que paramètre.

OriginalL'auteur Sajan Chandran

Cela devrait convient à votre besoin:

@RunWith(MockitoJunitRunner.class)
public class class1Test {

    @Mock
    private MyService myService;

    private Class1 class1;

    @Before
    public void setUp() {
        this.class1 = new Class1(myService); //creates this constructor.
    }

    @Test
    public void methodToBeTestedTest() {
        this.class1.methodToBeTested();
        Mockito.verify(this.myService).doSomethingElse(/* put expected arg here */);
    }
}

Voir aussi la officiel doc.

OriginalL'auteur

Vous devez vous connecter pour publier un commentaire.