Mockito: comment tester qu'un constructeur a été appelé?

Je suis à l'aide de Mockito à des méthodes d'essai au sein de mon application Java.

Comment puis-je vérifier qu'un constructeur a été appelé une fois?

Je suis en train de faire une vérification similaire à ceci:

verify(myClass, times(1)).doSomething(anotherObject);

Mais je ne peux pas vérifier que le constructeur a été appelé comme il n'a pas une méthode similaire, par exemple doSomething().

Euh, vous ne pouvez pas obtenir un Objet si vous n'appelez pas ça du constructeur; c'est une fonctionnalité du langage.
veuillez expliquer ce que vous entendez
Vous devez décrire ce que c'est que vous êtes réellement en train de tester, qui vous a fait penser que vous besoin de se moquer d'un constructeur. Je ne serais pas surpris s'il n'y a pas de réel besoin d'elle.

OriginalL'auteur java123999 | 2016-08-09

  1. 11

    Cela ne peut être fait avec Mockito, puisque l'objet en cours de création n'est pas un moqué de l'objet. Cela signifie également que vous ne serez pas en mesure de vérifier quoi que ce soit sur ce nouvel objet.

    J'ai travaillé autour de ce scénario dans le passé à l'aide d'un Factory pour créer l'objet plutôt que newing. Vous êtes alors en mesure de se moquer de l' Factory pour retourner l'objet requis pour votre test.

    Que vous êtes heureux de changer votre conception en fonction de vos tests est à vous!

    Cela semble la meilleure correction. Mauvais oeil en utilisant une Fabrique de classe à l'avenir à résoudre ce
    L'introduction d'une usine pour contourner une limitation dans le moqueur de la bibliothèque... c'est évidemment pas une bonne solution. Au lieu de cela, je suggère d'éviter la nécessité supposée de se moquer de la classe instanciée à partir de la CUS. Généralement, un test mieux sans se moquant est possible.

    OriginalL'auteur StuPointerException

  2. 16

    Vous pouvez le faire avec Mockito et PowerMockito.

    Dire que vous avez ClassUnderTest avec un constructeur 

    public class ClassUnderTest {
    String name;
    boolean condition;

    public ClassUnderTest(String name, boolean condition) {
       this.name = name;
       this.condition = condition;
       init();
    }

    ...
}

    Et une autre classe que les appels constructeur

    public class MyClass {

    public MyClass() { } 

    public void createCUTInstance() {
       //...
       ClassUnderTest cut = new ClassUnderTest("abc", true);
       //...
    }

    ...
}

    À la classe de Test nous pourrions...

    (1) l'utilisation PowerMockRunner et de citer les deux classes de cibles ci-dessus dans le PrepareForTest annotation:

    @RunWith(PowerMockRunner.class)
@PrepareForTest({ ClassUnderTest.class, MyClass.class })
public class TestClass {

    (2) intercepter le constructeur de retourner un objet fantaisie:

    @Before
public void setup() {
    ClassUnderTest cutMock = Mockito.mock(ClassUnderTest.class);
    PowerMockito.whenNew(ClassUnderTest.class)
                .withArguments(Matchers.anyString(), Matchers.anyBoolean())
                .thenReturn(cutMock);
}

    (3) de valider l'appel du constructeur:

    @Test
public void testMethod() {
    //prepare
    MyClasss myClass = new MyClass();

    //execute
    myClass.createCUTInstance();

    //checks if the constructor has been called once and with the expected argument values:
    String name = "abc";
    String condition = true;
    PowerMockito.verifyNew(ClassUnderTest.class).withArguments(name, condition);
}
    Je pense que la séquence des deux dernières lignes de votre testMethod() doit swap. comme ceci: nouvelle ClassUnderTest(nom, prénom, état); PowerMockito.verifyNew(ClassUnderTest.class);
    merci beaucoup pour appeler mon attention sur cette méthode d'essai! En vérité, que les précédentes dernière commande n'était pas vraiment nécessaire. L'idée originale était de tester l'appel du constructeur avec certaines valeurs d'argument, dans une méthode en vertu de test appelé à l'exécution de la phase. J'ai juste réécrit le code pour exprimer mon intention de départ. J'espère que c'est plus clair maintenant.

    OriginalL'auteur Jose Tepedino

  3. 2

    verify() méthode attend pour se moquaient de l'objet(objet déjà créé). Et constructor ne peut pas être appelé sur created object.

    OriginalL'auteur Rudziankoŭ

  4. 1

    Ce n'est pas possible avec Mockito et sonne comme une mauvaise conception.

    Vous pouvez utiliser une usine et de le transmettre à l'objet sous test. Après cela, vous pouvez facilement se moquer de l'usine et de vérifier que sa méthode de création a été appelé.

    Directement par la création d'objets dans votre code, vous devez faire un dépendance matérielle à des implémentations concrètes, ce qui rend le code plus difficile et parfois impossible, de test de l'unité. Ce point est abordé avec l'Injection de Dépendance (DI) et l'Inversion de Contrôle (IoC).

    OriginalL'auteur vbuhlev

  5. 0

    Un constructeur de ne pas renvoyer un objet, si elle n'a pas... et si elle échoue, le programme sera plus susceptible de se bloquer.

    Difficile je suppose que ce serait-il le faire: 

    Object obj = null;

obj = new Object();

if (obj == null) {
  //... Didn't Work
} else {
  //... Worked
}
    L'OP n'est pas en train de demander comment faire pour vérifier que le constructeur travaille, mais comment vérifier qu'un autre code, en effet, appelle le constructeur.

    OriginalL'auteur Olian04

  6. 0

    vous ne serez pas en mesure de se moquer de l'constructeur avec mockito, mais à l'aide de powermockito vous devriez être en mesure de puis de le vérifier. L'installation serait quelque chose comme ceci

    public class MyClass{

   public MyClass(String name){}

   public void doSomethingUseFul(){
      //.......
   }

}

public class Helper {

   public void goHelp(){
       new MyClass("apple").doSomethingUseFul();
   } 

}

    //Maquette

        @RunWith(PowerMockRunner.class)
    @PrepareForTest(MyClass.class)
    public class MockMyClass {
    @InjectMocks
    private Helper helper;

        @Test
        public void testDoSomethingUseFul() {
             MyClass  c = mock(MyClass.class); 
             doNothing().when(c).doSomethingUseFul();
             PowerMockito.whenNew(MyClass. class).withArguments(anyString()).thenReturn(c);
             helper.goHelp(); 
             verifyNew(MyClass.class).withArguments(anyString())


        }
    }

    OriginalL'auteur kuhajeyan