se moquer ou de stub pour les chaînes d'appel

protected int parseExpire(CacheContext ctx) throws AttributeDefineException {
    Method targetMethod = ctx.getTargetMethod();
    CacheEnable cacheEnable = targetMethod.getAnnotation(CacheEnable.class);
    ExpireExpr cacheExpire = targetMethod.getAnnotation(ExpireExpr.class);
    //check for duplicate setting
    if (cacheEnable.expire() != CacheAttribute.DO_NOT_EXPIRE && cacheExpire != null) {
        throw new AttributeDefineException("expire are defined both in @CacheEnable and @ExpireExpr");
    }
    //expire time defined in @CacheEnable or @ExpireExpr
    return cacheEnable.expire() != CacheAttribute.DO_NOT_EXPIRE ? cacheEnable.expire() : parseExpireExpr(cacheExpire, ctx.getArgument());
}

qui est la méthode de test ,

Method targetMethod = ctx.getTargetMethod();
CacheEnable cacheEnable = targetMethod.getAnnotation(CacheEnable.class);

J'ai, à se moquer de trois CacheContext,Méthode et CacheEnable.
Est-il une idée pour faire le test cas beaucoup plus simple?

InformationsquelleAutor jilen | 2011-10-28

136

Mockito peut gérer enchaîné talons:
```
Foo mock = mock(Foo.class, RETURNS_DEEP_STUBS);

//note that we're stubbing a chain of methods here: getBar().getName()
when(mock.getBar().getName()).thenReturn("deep");

//note that we're chaining method calls: getBar().getName()
assertEquals("deep", mock.getBar().getName());
```
Autant que je sache, la première méthode de la chaîne renvoie une maquette, qui est mis en place pour retourner votre valeur sur le deuxième enchaîné appel de méthode.

Mockito les auteurs de noter que ce devrait être utilisé uniquement pour le code de legs. Une meilleure chose à faire autrement, c'est pousser le comportement dans votre CacheContext et de fournir toutes les informations dont il a besoin pour faire le travail lui-même. La quantité d'informations que vous êtes en tirant à partir CacheContext suggère que votre classe a envie de fonctionnalité.
- Eh bien, Szczepan créé Mockito parce qu'il m'a vu, et plusieurs autres, le déploiement de nos propres se moque de la main au lieu d'utiliser EasyMock, et a décidé que les objets fantaisie, devrait mieux fonctionner pour les BDD - alors, évidemment, je préfère Mockito! Mais il fourchue EasyMock à le faire, donc, pour cette raison, oui, EasyMock est grande. Nous sommes sur les épaules de géants...
- Ce qui est intéressant et je upvoted. Mais ne pouvez-vous pas simplement utiliser Foo foo=mock(Foo.class); Bar bar=mock(Bar.class); when(foo.getBar()).thenReturn(bar); when(bar.getName()).thenReturn("deep")'. À mes yeux, c'est facile à lire et ne nécessite pas la compréhension de la notion de "PROFONDEUR" buter. (Btw, j'aime Mockito.)
- Yep. Je pense que cela pourrait être utile si votre prochain legacy code étape consiste à déplacer l'une des méthodes à la bonne place (ce qui élimine entièrement le problème, mais serait la cause de cette façon de faire les choses à besoin de grandes quantités de fixation par la suite).
- Mais est-il toujours envie de fonctionnalité? J'ai un dto arbre qui organise mon grand les données dans la mémoire. J'ai d'autres classes que lire les données de cet arbre et de faire des opérations sur celles-ci. Pour les tester, j'ai besoin de se moquer de la dto - BTW, je peux créer la dto, mais il est tout aussi lourd de profondeur stubbing m'aide vraiment dans ce cas. Dois-je raté quelque chose ici? puis-je faire de mon mieux?
- Il n'est pas toujours envie de fonctionnalité. Dans votre cas, je regarderais la création d'une sorte de modèle MVP, où un modèle est présenté dans un DTO de la couche de persistance. Maintenant, vous avez un objet riche, et pas seulement un DTO. Des modèles comme MVP, sont applicables à la persistance de l'Isu!
- Cela ne fonctionne pas si l'une de la chaîne retourne un type générique. Quelqu'un d'autre faire face à ce problème?
- Peut-être que de le soumettre à la Mockito de l'équipe? github.com/mockito/mockito/issues
- Feture envie définition a été déplacé ici: github.com/troessner/reek/blob/master/docs/Feature-Envy.md
- Cela ressemble à un joli petit outil; je n'ai pas rencontré de Lattes avant. Et quelle fantastique nom... 😀
- Pourriez-vous point pour certains de source officielle, où les auteurs affirment que la profonde talons ne doivent être utilisés pour le code de legs?
- Il est en fait dans la source officielle. Comme dans le code source. "S'il vous plaît noter que dans la plupart des scénarios, une maquette de retour d'une maquette qui est mal." Aussi: AVERTISSEMENT: Cette fonctionnalité est rarement nécessaire pour les réguliers propre code! Laisser pour héritage code. Se moquant d'un simulacre de retour d'une maquette, de retour d'une maquette, (...), de retour quelque chose de significatif allusion à la violation de la Loi de Déméter ou de se moquer d'un objet de valeur (bien connu anti-modèle). github.com/mockito/mockito/blob/master/src/main/java/org/... (la plupart à la ligne 1393).
- Juste point de. Bien que autour de un niveau, de le faire peut être acceptable, mais je comprends que la méthode est sans doute largement abusé. Je me demande si c'est un candidat pour l'autodérision.
- Emballage des tests autour de l'héritage de code est une partie importante d'être en mesure de refactoriser le code en toute sécurité. Il n'y a rien de mal à avoir comme une étape intermédiaire pour un nettoyeur de base de code.
- Ayant dit cela, je suis en utilisant RETURNS_DEEP_STUBS au moment de la sauvegarde d'une interface complexe avec certaines méthodes de l'avant d'une hashmap que je ne veux pas être l'objet de moqueries, à l'aide de Kotlin et le "par" mot-clé... alors peut-être il y a plus d'utilisations pour ces jours-ci.
- Le lien en haut de la réponse est cassé.
- Merci; fixe.
- J'ai fini par utiliser RETURNS_SELF, puisque les docs décourager RETURNS_DEEP_STUBS
- Le RETURNS_SELF est utile si vous êtes en train de créer les constructeurs (qui normalement retourner eux-mêmes de sorte que vous pouvez continuer à ajouter des choses). Dans le cas des OP cas, il ne correspond pas à la signature ou de l'intention. RETURNS_DEEP_STUBS est la bonne chose à utiliser, surtout si l'intention est d'envelopper quelque chose dans un test alors que le refactoring. Les docs ne fait pas de décourager RETURNS_DEEP_STUBS; ils découragent l'anti-modèle, ce qui nécessite en premier lieu (violation de la Loi de Déméter, aka envie de fonctionnalité).
- Comment réaliser cela avec @Mock annotation?
- Je devine à partir de cette documentation qu'il serait @Mock(reponse = RETURNS_DEEP_STUBS) - lui donner un aller et laissez-nous savoir! statique.javadoc.io/org.mockito/mockito-core/2.2.28/org/mockito/...
InformationsquelleAutor Lunivore
3

Ma suggestion de faire de votre cas de test le plus simple est de revoir votre méthode.

À chaque fois que je me retrouve à avoir de la difficulté à tester une méthode, c'est une odeur de code pour moi, et je me demande pourquoi est-il difficile à tester. Et si le code est difficile à tester, il est sans doute difficile à utiliser et à entretenir.

Dans ce cas, c'est parce que vous avez une méthode de la chaîne qui va de plusieurs niveaux de profondeur. Peut-être passer dans le ctx, cacheEnable, et cacheExpire en tant que paramètres.
- Oui, mais ces champs sont de l'aop contexte au moment de l'exécution, il est difficile de simplifier l'environnement.
- TThere sont des techniques pour ce faire, dans JMockit. Vous pouvez se moquer des champs dans vos objets simualting AOP domaine de l'injection. Ou vous pouvez utiliser deencapsulation techniques de l'initialisation de provate champs avec moqué des instances
InformationsquelleAutor Doug R
2

J'ai trouvé JMockit plus facile à utiliser sna basculé complètement. Voir des cas de test à utiliser:

https://github.com/ko5tik/andject/blob/master/src/test/java/de/pribluda/android/andject/ViewInjectionTest.java

Ici, j'ai simulé à l'écart de l'Activité de la classe de base, ce qui est à venir à partir d'Android SKD et complètement
écrasé. Avec JMockit vous pouvez vous moquer de thingis tha sont définitives, privé, abstrait ou tout autre chose.

Dans votre cas de test, il devrait ressembler à:
```
public void testFoo(@Mocked final Method targetMethod, 
                    @Mocked  final CacheContext context,
                    @Mocked final  CacheExpire ce) {
    new Expectations() {
       {
           //specify expected sequence of infocations here

           context.getTargetMethod(); returns(method);
       }
    };

    //call your method
    assertSomething(objectUndertest.cacheExpire(context))
```
- pense pour votre réponse, mais je suis en utilisant mockito,de toute façon.
- Notez que JMockit a une annotation spécifiquement pour les chaînes d'appels: @Cascading. Aussi, dans des cas comme cela, vous voudrez probablement utiliser NonStrictExpectations au lieu de Expectations, en supposant que les appels de méthodes fantaisie n'a pas besoin d'être vérifié.
- Merci, j'ai manqué cette annotation 😉 Allé simplifier mes tests unitaires
InformationsquelleAutor Konstantin Pribluda

Juste au cas où vous êtes à l'aide de Kotlin. MockK ne dit rien à propos de l'enchaînement d'être une mauvaise pratique et facilement vous permet de faire des cette.

val car = mockk<Car>()

every { car.door(DoorType.FRONT_LEFT).windowState() } returns WindowState.UP

car.door(DoorType.FRONT_LEFT) //returns chained mock for Door
car.door(DoorType.FRONT_LEFT).windowState() //returns WindowState.UP

verify { car.door(DoorType.FRONT_LEFT).windowState() }

confirmVerified(car)

Yep, très bonne chose, aide vraiment à réduire la quantité de code réutilisable.

InformationsquelleAutor yuranos87

Vous devez vous connecter pour publier un commentaire.