Simuler un Eureka Feindre Client pour Unittesting

je suis à l'aide de printemps du nuage d'eureka et de feindre de communiquer entre certains services (disons A et B). Maintenant j'aimerai unittest ma couche de service d'un service unique (Un). Le problème, c'est que ce service (Un) est à l'aide d'une feindre client demande un peu d'information sur les autres services (B).

De l'exécution de l'unittests sans aucune configuration spéciale jette l'exception suivante: java.lang.RuntimeException: com.netflix.client.ClientException: Load balancer does not have available server for client: service-b => mais je ne veux pas n'importe quel serveur à exécuter.

Ma question est: Est-il un moyen de se moquer de l'feindre client, afin que je puisse unittest mon service (A) sans exécuter d'eureka instance et de service (B)?

Edit:
J'ai fini par créer un stub pour l'feindre client. Le talon est marqué comme une composante fondamentale de la force de printemps de l'instanciation de la stub dans mes tests.
C'est la solution que j'ai trouvé.

//the feign client
@FeignClient("user") 
public interface UserClient { 
    UserEntity getUser(); 
}

//the implementation i use for the tests 
@Component 
@Primary //mark as primary implementation
public class UserClientTestImpl implements UserClient { 
    @Override public UserEntity getUser() { 
        return someKindOfUser; 
    } 
}

OriginalL'auteur Kamil Szuster | 2015-12-21

  1. 5

    La question est ... avez-vous encore besoin de se moquer? Je vois souvent que les gens parlent de "fantaisie" que la première solution à tout ce qui "ne devrait pas faire partie de l'unité de test". Moqueur est une technique, pas la solution à tout. (voir ici).

    Si vous êtes encore au début de votre code, il suffit de refactoriser et d'utiliser quelque chose d'autre au lieu de dépendre de béton instance de la Feindre Client. Vous pouvez utiliser une interface, une classe abstraite, un trait de caractère ou ce que vous voulez. Ne dépendent pas de l'objet lui-même, sinon il faut "s'en moquer".

    public interface IWebClient {
  public String get(...);
  public String post(...);
}

    À la question: mais je vais avoir un autre code qui permettra de faire exactement la même chose (sauf qu'il va être sur le béton instance de Feindre), que dois-je faire ensuite?
    Eh bien, vous pouvez écrire un test fonctionnel et de l'appel d'une instance de serveur web que vous pouvez configurer localement ou à l'utilisation Wiremock, comme mentionné par Marcin Grzejszczak dans l'une des réponses.

    public class FeignClientWrapper implements IWebClient {
  private feign = something

  public String get() {
    feign.get( ... ) 
  }

  public String post() {
    feign.post( ... ) 
  }
}

    Les tests unitaires sont utilisés pour tester les algorithmes, si/d'autre, des boucles: comment unités travail. Ne pas écrire de code pour faire se moque fit - il doit être dans l'autre sens: votre code doit avoir moins de dépendances, et vous devriez se moquer seulement lorsque vous en avez besoin pour vérifier le comportement (sinon, vous pouvez utiliser un tampon ou un faux objet): avez-vous besoin de vérifier le comportement? Avez-vous besoin de tester qu'une méthode est appelée dans votre code? Ou qu'une méthode est appelée, avec X, Y, et Z pour 3 fois de suite? Bien, alors oui, se moquant est ok.

    Sinon, utilisez un faux objet: ce que vous voulez, c'est de "tester" l'appel/réponse et peut-être le code d'état. Tous vous voulez probablement, c'est pour tester le fonctionnement de votre code réagit aux différentes sorties (par exemple, le champ "erreur" est présent ou non dans une réponse JSON), les différents codes d'état (en supposant que la documentation du Client est en droit: 200 OK quand OBTENIR, 201 lors de la POSTE, etc).

    C'est la solution que j'ai trouvé jusqu'à présent: Le feindre de l'interface @FeignClient("user") public interface UserClient { //some feign annotations UserEntity getUser(); } La mise en œuvre-je utiliser pour les tests @Component @Primary public class UserClientTestImpl implements UserClient { @Override public UserEntity getUser() { return someKindOfUser; } }, Fondamentalement, de son la méthode que vous avez mentionné @taux de marge.
    Pourriez-vous publier le code dans votre question? C'est dur à lire le code dans les commentaires 😀 je suis heureux, il a aidé. Lorsque vous souhaitez tester le comportement, vous pouvez utiliser les moqueries. Si vous voulez tester la "connexion", le programme d'installation d'un petit serveur! 😛

    OriginalL'auteur Markon

  2. 2

    Si vous avez besoin d'utiliser une maquette vous pouvez utiliser Wiremock à talon la réponse pour une demande donnée - http://wiremock.org/stubbing.html. De cette façon, vous permettra de faire des tests d'intégration avec de vraies requêtes HTTP envoyées. Pour les tests unitaires, la réponse de @taux de marge est très bonne.

    OriginalL'auteur Marcin Grzejszczak

  3. 2

    Se moquant d'un feindre client est vraiment utile dans microservice composant tests. Vous souhaitez tester un microservice, sans avoir à démarrer tous les autres microservices. Si vous êtes à l'aide de Printemps (et on dirait que vous êtes), @MockBean annotation avec un peu de Mockito code du travail.

    @RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = 
SpringBootTest.WebEnvironment.DEFINED_PORT)
public class TestYourComponent {
    @Configuration
    @Import({YourConfiguration.class})
    public static class TestConfiguration {
    }

    @MockBean
    private UserClient userClient;

    @Test
    public void someTest()
    {
        //...
        mockSomeBehavior();
        //...
    }

    private void mockSomeBehavior() {
        Mockito.doReturn(someKindOfUser).when(userClient).getUser();
    }
}
    En général, ce n'est pas ce qu'un test unitaire doit faire. Vous pouvez vraiment voir ce, même en regardant les dépendances pour vos tests: SpringBootTest devrait sonner une cloche ici, parce que vous êtes à l'initialisation de l'ensemble de la springboot contexte (+ tous les haricots, etc.). De quoi avez-vous besoin de cela dans un Test Unitaire? C'est plus sur l'intégration des composants de test" que les tests unitaires.
    si vous lisez ce que j'ai écrit, vous verrez que je parle d'un composant de test, pas un test unitaire. Peut-être que vous vouliez répondre à la question initiale, qui ne demande à être sur les tests unitaires? ...même si, il est assez clair que le premier interlocuteur des moyens de la composante test de trop, même s'ils utilisent la mauvaise parole.
    oui, je sais que c'est à propos de la composante test. Je voulais juste ajouter quelque chose à votre réponse, car je vois de plus en plus de confusion de personnes qui demandent des composants de tests (comme celui que vous avez écrit) des tests unitaires. Et je sais aussi que vous savez la différence 🙂

    OriginalL'auteur Myrle Krantz