Java: Comment puis-je simuler une méthode d'un champ lorsque ce champ n'est pas exposé?

J'utilise la version 6 de Java, JUnit 4.8.1, et l'écriture d'une application console. Ma demande a un membre de domaine qui n'est pas exposé ...

public class MyApp { 
    ...
    private OpportunitiesService m_oppsSvc;

    private void initServices() { 
        …
        m_oppsSvc = new OpportunitiesServiceImpl(…);
    }
    ...
}

Je veux de se moquer d'un comportement, tels que, chaque fois qu'une méthode de mon service est appelée (par exemple m_oppsSvc.getResults()), le même résultat est toujours retourné. Comment dois-je faire? Il n'y a pas de méthode de définition du champ. Je suis actuellement en train de travailler avec Mockito 1.8.4. Est-il possible de faire cela avec Mockito ou certains autres se moquer de cadre?

Pouvez-vous ne pas créer une méthode de définition?
Double Possible de Comment avez-vous test de l'unité méthodes privées?
Qu'essayez-vous de test? est getResults() public? A-t-elle un champ privé associé avec elle, ou est-il calculé au moment de l'exécution? Selon les réponses, vous pouvez être en mesure d'utiliser un "espion" ou moqueur pourrait pas avoir quelque chose à faire avec elle et vous pouvez utiliser quelque chose comme org.springframework.test.util.ReflectionTestUtils simplement de définir le domaine privé de la valeur que vous souhaitez.

OriginalL'auteur Dave | 2012-07-20

12

C'est ce que vous voulez:
```
@RunWith(MockitoJUnitRunner.class)
public class MyAppTest { 

    @Mock private OpportunitiesService mocked_m_oppsSvc;
    @InjectMocks MyApp myApp;

    @Test public void when_MyApp_uses_OpportunititesService_then_verify_something() { 
        //given
        given( mocked_m_oppsSvc.whatever()).willReturn(...);

        //when
        myApp.isUsingTheOpportunitiesService(...);

        //then
        verify...
        assertThat...
    }
}
```
À l'aide de: Mockito 1.9.0, BDD style, ~~FEST-Assert~~ AssertJ.

Espère que cela aide 🙂

prend en charge uniquement l'injection par mutateur.
peut également injecter des champs privés.
Javadoc est incorrect, il est toujours pris en charge champs privés d'injection. Ensuite, l'injection par mutateur, puis constructeur injection dans 1.9.0. Vérifier InjectmMocks la Javadoc dans la version 1.9.0 docs.mockito.googlecode.com/hg/1.9.0/org/mockito/...
Réponse correcte. Mais je pense que le problème avec le code qu'il se casse "de code de tests" règles de création d'objets et de ne pas les obtenir à partir de la construction.
Ouais d'accord, c'est défendable ; cependant, avec aujourd'hui l'injection de la technique (@Inject (JSR 330), @Autowired (Printemps), @Context (CXF), etc.), vous peuvent ne pas être visibles de l'extérieur dépendances comme dans le constructeur ou avec des organismes de normalisation.

OriginalL'auteur Brice
7

Étant donné que vous êtes déjà à l'aide de mockito, pourquoi ne pas simplement utiliser la réflexion:
```
@RunWith(MockitoJUnitRunner.class)
public class MyApp { 

    @Mock
    private OpportunitiesService m_oppsSvc;

    private MyApp myApp;


    @Before
    public void before() throws Exception {
       myApp = new MyApp();
       Field f = MyApp.class.getDeclaredField("m_oppsSvc");
       f.setAccessible(true);
       f.set(myApp, m_oppsSvc);
    }
}
```
C'est un peu moche, mais il fera l'affaire. Notez que cela peut ne pas être le moyen le plus efficace de le faire avec Mockito, mais il faudra travailler.

Il y a aussi Powermock qui devrait vous permettre de le faire à l'aide de la Whitebox classe. Je ne rentrerai pas dans le détail de Powermock mais voici l'appel à injecter le domaine privé de la valeur, ce qui devrait être un simulacre de l'objet:
```
Whitebox.setInternalState(myApp, "m_oppsSvc", m_oppsSvc);
```
OriginalL'auteur Matt
6

Vous devriez envisager de tentatives pour se moquer d'un champ privé un l'odeur. C'est un signe que soit ce que vous essayez de faire est incorrect ou que votre code est structuré de manière incorrecte. Vous devriez seulement besoin de se moquer de méthodes publiques ou de l'injection de dépendances

Dans le code que vous avez donné, vous devriez envisager l'injection de OpportunitiesService comme suit:
```
public class MyApp { 
    ...
    private OpportunitiesService m_oppsSvc;

    public MyApp(OpportunitiesService oppsSvc) {
        this.m_oppsSvc = oppsSvc;
    }
    ...
}
```
Dans votre test, vous pouvez ensuite l'injecter une maquette comme suit:
```
OpportunitiesService mockOpportunitiesService =
    Mockito.mock(OpportunitiesService.class);
Mockit.when(mockOpportunitiesService.someMethod()).thenReturn(someValue);
MyApp app = new MyApp(mockOpportunitiesService);
```
OriginalL'auteur munyengm

Vous pouvez le faire facilement avec JMockit:

public class MyAppTest
{
    @Tested MyApp myApp;

    @Test
    public testSomething(final @Capturing OpportunitiesService mockService)
    {
        new NonStrictExpectations() {{
            mockService.getResults(); result = asList("a", "b", "C");
            //record other expectations, if needed
        }};

        myApp.whateverMethodIWantToTest();

        new Verifications() {{
            mockService.doSomething(anyInt);
            //verify other expectations, if needed
        }};
    }
}

Même si la mise en œuvre de la classe OpportunitiesServiceImpl n'est pas mentionné dans le code de test, de ses instances (n'importe quel nombre d'entre eux) va encore bien rire.

OriginalL'auteur Rogério

-1

Généralement, vous devriez utiliser l'injection de dépendance et de passer de la maquette de l'objet (de type OppportunitiesServiceImpl) via le constructeur, un setter ou directement à la méthode (getResults). Vous pourriez avoir besoin pour extraire une interface pour OpportunitiesServiceImpl premier.

OriginalL'auteur Peter Smith
-1

Généralement, ce problème est résolu grâce à l'utilisation de l'injection de dépendance. Régulièrement (de la production), le mode de votre conteneur d'injection de dépendance (par exemple, de Printemps ou Guice) qui permettra d'injecter une instance de OpportunitiesService en MyApp par le biais de votre constructeur ou par l'intermédiaire d'un setter.

Puis, quand vous faites des tests, vous pouvez "injecter" un simulacre d'instance manuellement à l'aide de la même setter ou argument du constructeur.

Au lieu de faire
```
m_oppsSvc = new OpportunitiesServiceImpl(…);
```
Essayer de Passer OpportunitesService par MyApp'constructeur

OriginalL'auteur Jack Edmonds

Vous devez vous connecter pour publier un commentaire.