Se moquant de deux objets de même type avec Mockito

Je suis en train d'écrire des tests unitaires à l'aide de Mockito et je vais avoir des problèmes pour se moquer de la injecté classes. Le problème, c'est que deux des injecté classes sont du même type, et seulement différenciés par leur @Qualifier annotation. Si j'ai essayé de tout simplement se moquer de SomeClass.class, que la maquette n'est pas injecté et que cet objet est null dans mes tests. Comment puis-je me moquer de ces objets?

public class ProfileDAL {

    @Inject
    @Qualifier("qualifierA")
    private SomeClass someClassA ;

    @Inject
    @Qualifier("qualifierB")
    private SomeClass someClassB ;

    //...various code, not important
}

@RunWith(MockitoJUnitRunner.class)
public class ProfileDALLOMImplTest {

    @InjectMocks
    private ProfileDALLOMImpl profileDALLOMImpl = new ProfileDALLOMImpl();

    @Mock
    private SomeClass someClassA;
    @Mock
    private SomeClass someClassB;

    private SomeResult mockSomeResult = mock(SomeResult.class);

    @Test
    public void testSomeMethod() {
        when(someClassA .getSomething(any(SomeArgment.class)).thenReturn(mockSomeResult);
        Int result = profileDALLOMImpl.someTest(This isn't relevant);
    }

 }
Comment est-ce que votre code de test ? J'ai toujours explicitement appel Mockito.mock(SomeClass.class) pour créer mon se moque, en laissant de mes tests d'unité de la magie fournis par des annotations. Vous devriez être en mesure de faire de même, si vous injecter des dépendances par le constructeur ou les setters. Est-il une bonne raison, ce n'est pas le cas ?
Pourriez-vous éventuellement démontrer l'injection de ces dépendances, sans l'utilisation de @InjectMocks? J'ai mis à jour mon Q pour montrer comment mon test est mis en place.

OriginalL'auteur tamuren | 2013-03-18

  1. 9

    J'ai essayé moqueur deux objets du même type avec Mockito 1.9.5 utilisation de JUnit et il fonctionne.

    Voir: http://static.javadoc.io/org.mockito/mockito-core/1.9.5/org/mockito/InjectMocks.html

    Type d'infos de la doc:

    "Champ d'injection; se moque va d'abord être résolus par type, puis, s'il y a plusieurs biens du même type, par le match du nom du champ et la simulation de nom."

    Et ce qui semble dire que vous devriez faire de la simulation de correspondance de nom le nom de champ pour tous vos se moque quand vous avez deux du même type:

    "Note 1: Si vous avez des champs du même type (ou même d'effacement), il est préférable de nommer tous les @Mock annoté champs avec les champs correspondants, sinon Mockito pourrait se confondre et l'injection ne se produira pas."

    Peut-être ce dernier est à vous mordre?

    OriginalL'auteur splonk

  2. 1

    Juste confirmé ce que Splonk souligné et il fonctionne de cette manière dans Mockito 1.9.5, dès que j'ai enlevé un des moqué des classes, il a échoué.

    Donc, dans votre cas, assurez-vous d'avoir à la fois de la moqué de classes avec le même nom que la classe dans votre test:

    @Mock
private SomeClass someClassA;
@Mock
private SomeClass someClassB;

    OriginalL'auteur hesparza

  3. 0

    Si vous n'utilisez pas d'annotation, vous obtenez quelque chose comme

    public class MyClass {
    private MyDependency myDependency;

    public void setMyDependency(MyDependency myDependency){
        this.myDependency = myDependency;
    }
}

    et

    import org.junit.Before;
import org.junit.Test;

import static org.mockito.Mockito.*;

public class MyTest {

    private MyClass myClass;
    private MyDependency myDependency;

    @Before
    public void setUp(){
        myClass = new MyClass();
        myDependency = mock(MyDependency.class);
        myClass.setMyDependency(myDependency);
    }

    @Test
    public void test(){
        //Given

        //When

        //Then
    }
}

    Vous pouvez faire de même si votre objet a ses dépendances spécifiées par le constructeur, plutôt que par le biais de setter. Je suppose que votre infrastructure d'injection de dépendance peut annoter les poseurs de la même façon que vous annoter des champs privés, mais maintenant, vos tests ne repose pas sur des framework injection de dépendance.

    Je ne peux pas défier l'aide de l'injection de dépendance cadre. C'est une décision de conception n'est pas dans mes mains.

    OriginalL'auteur rcomblen