Mockito lorsque().thenReturn appelle la méthode inutilement

Je travaille un peu sur un hérité de code.
J'ai écrit un test qui est censé attraper NullPointerException (pour qu'il essaie d'appeler une méthode de l'objet null)

@Test(expected=NullPointerException.class)
public void checkXRequirement_NullProduct_AddAction_ShouldThrowNullPointerException() throws CustomException {
  Site site = mock(Site.class);
  Product product = null;
  when(BasketHelper.getAction(request)).thenReturn(0);
  when(BasketHelper.getActionProduct(site, request)).thenReturn(product);
  BasketHelper.requiresX(request, site);

}

Les Méthodes et les Variables:

public static final int ACTION_ADD = 0;
public static final int ACTION_DELETE = 1;

protected static int getAction(HttpServletRequest a_request) {
  String sBuyProduct = a_request.getParameter(ATTRIBUTE_NAME_BUY_PRODUCT);
  String sBuyProduct = a_request.getParameter(ATTRIBUTE_NAME_BUY_PRODUCT);

  if (sBuyProduct != null) iAction = ACTION_ADD;
  else (sDelProduct != null) iAction = ACTION_DELETE;

  return iBasketAction
}

protected static Product getActionProduct(Site a_site, HttpServletRequest a_request) {

    String sBuyProduct = a_request.getParameter(ATTRIBUTE_NAME_BUY_PRODUCT);
    String sDelProduct = a_request.getParameter(ATTRIBUTE_NAME_DEL_PRODUCT);
    String sProduct = null;

    switch (getBasketAction(a_request)) {
        case BASKET_ACTION_ADD:
        sProduct = sBuyProduct;
    break;
        case BASKET_ACTION_DELETE:
        sProduct = sDelProduct;
    break;
    }

    int iProductId;
    try {
        iProductId = Integer.parseInt(sProduct);
    } catch (NumberFormatException nbrEx) {
        return null;
    }

    Product prod = getProductById(iProductId);

    if (prod.isMasterProduct()) {
        prod = getChildProduct(prod, a_site, a_request);
    }

    return prod;
}


public static boolean requiresX(HttpServletRequest request, Site site) throws CustomException {
  try{
    if (getAction(request) == ACTION_ADD) { 
    Product prod = getActionProduct(site, request);
    return prod.getType().isRequiredX();
    }  
  } catch(NullPointerException exception) {
    log.error("Error Message", exception);
  }
  return false;
}

JUnit résultat de l'exécution du test est un échec avec la trace de la pile d':

java.lang.Exception: Unexpected exception, expected<java.lang.NullPointerException> but was<org.mockito.exceptions.misusing.WrongTypeOfReturnValue>
Caused by: org.mockito.exceptions.misusing.WrongTypeOfReturnValue: 
Integer cannot be returned by getParameter()
getParameter() should return String#

Dois-je l'interpréter comment quand().thenReturn est censé travailler ici? Je veux juste getAction pour retourner 0 et getActionProduct à retourner la valeur null à chaque fois qu'il est appelé. Clairement getParameter() est appelée et je ne sais pas exactement pourquoi.

Pouvez-vous montrer getProduct()?
Dans d'autres nouvelles.... Je peux voir pourquoi vous écrivez ce genre de test pour reproduire un problème. Cependant, le véritable test ici doit être de vérifier que si les product est null, la requiresX méthode n'est pas appelée. À moins que votre hérité de code à l'aide de la npe pour contrôler le flux de code? Dans ce cas - rip que trop.
Je pense que vous avez raison. l'évolution de la condition dans requiresX méthode est probablement une bonne idée.

OriginalL'auteur Krzysztof Jarzyna | 2013-08-20

  1. 14

    Mockito ne peut plus se moquer méthode statique. Votre lorsque l'enregistrement n'est pas valide:

      when(BasketHelper.getAction(request)).thenReturn(0);
  when(BasketHelper.getActionProduct(site, request)).thenReturn(product);

    Qui est une autre raison pour laquelle nous voulons réduire l'utilisation de la méthode statique comme il est difficile de se moquer.

    Il n'y a pas de moyen plus facile de se moquer du comportement si votre classe reste comme ça. Toutefois, si vous souhaitez modifier votre design et le rendre à la fois des méthodes non statiques. La bonne façon d'utiliser le mot "quand" est à appliquer le vérifier sur moqué de l'objet. Par exemple:

      BasketHelper basketHelper = mock(BasketHelper.class);
  when(basketHelper.getAction(request)).thenReturn(0);
  when(basketHelper.getActionProduct(site, request)).thenReturn(product);

    Mais encore une fois, cela ne fonctionne que si vous re-conçu avec votre classe getAction et getProduct méthode NON-STATIQUE.

    Je me souviens il y a quelques autres framework de test qui prend en charge les moqueries méthode statique.

    Je pense que PowerMock permet de se moquer de méthodes statiques. Je devrais peut-être regarder. Merci
    Regarde comme il est 🙂 Bonne chance avec elle.
    Vous pourriez regarder dans PowerMock. Ou vous pouvez restructurer le code d'éviter l'utilisation de méthodes statiques. Je vous recommande le dernier.
    Upvoted cette réponse en raison de la recommandation de s'éloigner de la statique. Pour de plus amples voiture à la maison le point, veuillez consulter Misko Hevery l'article de Méthodes Statiques sont Mort pour la Testabilité. Fondamentalement, vous avez besoin d'un "filon" pour injecter le comportement désiré...qui statiques ne permettent pas (sans quelque chose comme PowerMock). Allez sur youtube pour ses entretiens a bien! lien vers la liste de lecture
    Aussi, ne pas toujours compter sur des outils comme PowerMock de "forcer" un test unitaire. Si vous avez besoin d'un outil spécial, comme cela, alors il y a probablement un moyen d'améliorer votre conception. En d'autres termes, essayez de refactoriser de test de l'unité de sorte que vous pouvez tester sans PowerMock. Si vous êtes incapable de le faire (en raison de certaines contraintes), n'hésitez pas à l'utiliser. Plats à emporter - être- juste parce que PowerMock, des outils existent ne vous donne PAS une excuse pour écrire dure de test de code! 🙂

    OriginalL'auteur KKKCoder

  2. 1

    Vous pouvez utiliser PowerMock. D'abord créer des maquettes de la classe sur lequel vous appelez les méthodes statiques -

    mockStatic(BasketHelper.class);

    Alors définir vos talons -

    when(BasketHelper.getAction(request)).thenReturn(0);
when(BasketHelper.getActionProduct(site, request)).thenReturn(product);

    OriginalL'auteur Saurabh

  3. 0

    Cela peut aider d'autres personnes qui utilisent les annotations. Si vous êtes à l'aide d'annotations, peut-être vous avez besoin d'utiliser @Maquette au lieu de @InjectMocks. Parce que @InjectMocks fonctionne comme @Spy et @Mock ensemble. Et @Spy garde la trace récemment signé des méthodes et vous pouvez sentir que des données incorrectes sont retournés/subbed.
    Cochez les deux:

    https://groups.google.com/forum/?fromgroups#!topic/mockito/9WUvkhZUy90

    http://code.google.com/p/mockito/issues/detail?id=127

    OriginalL'auteur dillip pattnaik

  4. 0

    J'ai couru à travers ce fil, tout en essayant de résoudre le même problème dans mes tests.

    Dans le cas où d'autres voient cette question et à la fin jusqu'ici...Dans mon cas il a été causé par la non-utilisation de l' @PrepareForTest annotation pour la classe de soutien.

    OriginalL'auteur John Dilley