Se moquant d'un objet de classe à l'aide de Mockito et PowerMockito

Est-il possible de se moquer d'un objet de classe à l'aide de Mockito et/ou PowerMockito?

Quelque chose comme:

Class<Runnable> mockRunnableClass = mock(Class<Runnable>.class);

Oui... qui me dit Que la façon de se moquer d'une classe finale, mais il se complique pas me dire comment faire pour se moquer de la Classe de l'objet.
Java génériques du type d'utilisation de l'effacement, de sorte Class<Runnable>.class est incorrect. Class est final, mais vous pouvez utiliser PowerMock de toute façon.
Quelle est votre cas d'utilisation que vous souhaitez à se moquer de "Classe"? La classe est assez commun - juste curieux.
Puis ce qui se passe si votre l'essai révèle un bug? Vous n'êtes pas autorisé à réparer?
Je ne prétends pas à la documentation qui l'affirme, il n'. J'ai été citant. Mockito n'est pas destiné à soutenir partielle de moqueries. Aussi, je n'ai jamais dit que je ne pouvais pas changer le code pour corriger un bug. Correction d'un bug et l'évolution d'une classe d'interface sont deux choses très différentes. Le deuxième impact sur tous les utilisateurs de la classe et les oblige à réécrire leur code. Vous ne connaissez pas le contexte de ce que je fais, donc merci de ne pas me licencier quand je dis refactoring n'est pas une option.

OriginalL'auteur LandonSchropp | 2012-08-29

2

Une alternative à se moquant de Classe pourrait être d'utiliser une Usine à la place. Je sais que vous êtes inquiet au sujet de refactoring, mais cela pourrait se faire sans modification de l'API publique de la classe. Vous n'avez pas fourni beaucoup de code pour comprendre la classe que vous essayez de tester, mais voici un exemple de refactoring sans modification de l'API. Il est trivial de classe, mais il peut vous donner une idée.
```
public class Instantiator {

  public Runnable getNewInstance(Class<Runnable> runnableClass) throws Exception {
    return runnableClass.newInstance();
  }
}
```
Bien sûr, la chose la plus facile à faire pour tester cette petite classe serait d'utiliser un véritable classe Runnable, mais si vous avez essayé de se moquer de la Classe, vous rencontrerez des problèmes que vous rencontrez. Donc, vous pouvez refactoriser le code ainsi:
```
public class PassThruFactory {
  public Object newInstance(Class<?> clazz) throws Exception {
    return clazz.newInstance();
  }
}

public class Instantiator {
  private PassThruFactory factory = new PassThruFactory();

  public Runnable getNewInstance(Class<Runnable> runnableClass) throws Exception {
    return (Runnable)factory.newInstance(runnableClass);
  }
}
```
Maintenant Instantiator fait exactement la (trivialement simple), chose qu'il faisait avant avec la même API publique et aucun besoin de n'importe quel client de la classe spécifique à effectuer l'injection de leur propre. Toutefois, si vous souhaitez de se moquer de l'usine de la classe et de l'injecter, c'est très facile à faire.

Bon appel sur l'utilisation de l'usine.

OriginalL'auteur jhericks
2

pourquoi pas à l'aide d'un agent si vous ne pouvez pas refactoriser le code il n'y a pas beaucoup d'options, comme @jherics dit, java système de classes sont chargées par le chargeur de classe de bootstrap et powermock ne pouvez pas redéfinir leur code binaire.

Cependant Powermock maintenant coms avec un agent, qui va permettre au système de classes se moquer. Vérifier ici pour une explication complète.

L'idée principale est de modifier votre commande en java et d'ajouter :
```
-javaagent: path/to/powermock-module-javaagent-1.4.12.jar
```
La chose de base que cet agent est en train de faire est de definalize classes, pour permettre aux futurs moqueur dans un test spécifique, c'est pourquoi vous aurez besoin d'utiliser des types particuliers de communiquer avec l'agent, par exemple avec JUnit :
```
@Rule PowerMockRule rule = new PowerMockRule(); //found in the junit4 rule agent jar
```
TestNG est également pris en charge. Il suffit de cocher la page wiki pour plus d'informations.

Espère que ça aide.

Cela ressemble à cela pourrait fonctionner, mais notre processus d'amorçage est très compliqué. La modification de la Java agent n'est pas une option.

OriginalL'auteur Brice
2

La première, comme indiqué dans les commentaires, vous aurez besoin de faire:
```
Class<Runnable> mockRunnableaClass = (Class<Runnable>)mock(Class.class);
```
Mais qui ne fonctionne pas de la manière habituelle en raison d'une limitation avec PowerMock. Vous ne pouvez pas simplement se moquer de classes de java.lang, java.net, java.io ou d'autres classes de système parce qu'ils sont chargés par Java bootstrap chargeur de classe et ne peut pas être byte-code manipulés par PowerMock du chargeur de classe. (Voir PowerMock FAQ #4.) Comme de PowerMock 1.2.5, vous pouvez contourner ce problème. Si la classe que vous voulais tester:
```
public class ClassToTest {
  private Class<Runnable> runnableClass;

  public void setRunnableClass(Class<Runnable> runnableClass) {
    this.runnableClass = runnableClass;
  }

  public Runnable foo() {
    return runnableClass.newInstance();
  }
}
```
Alors vous feriez cela:
```
@RunWith(PowerMockRunner.class)
@PrepareForTest({ ClassToTest.class }) //Prepare the calling class for test
public class SystemClassUserTest {

  @Test
  public void testFoo() throws Exception {
    Class<Runnable> mockClass = (Class<Runnable>) mock(Class.class);
    Runnable mockRunnable = mock(Runnable.class);

    ClassToTest objectUT = new ClassToTest();
    objectUT.setRunnableClass(mockClass);

    when(mockClass.newInstance()).thenReturn(mockRunnable);
    assertThat(objectUT.foo(), is(sameInstance(mockRunnable);
  }
}
```
Le ci-dessus ne fonctionne pas. Quand je l'appelle PowerMockito.mock(Class.class), le lanceur de test renvoie une instance de IllegalAccessError.
Je n'ai pas fait de test, il est donc possible que Class est trop fondamentaux pour se moquer. Quelle est la version de PowerMock utilisez-vous?
1.4.10 je crois. J'ai peur que vous ayez raison. Cela pourrait être l'un de ces cas où il n'est tout simplement pas possible à proprement tester le code.

OriginalL'auteur jhericks

Comment à ce sujet. la création d'une méthode d'obtenir de la a un Objet (MS) dans la classe PCService et puis s'en moquer.

public class PCService implements PCServiceIf {
    public MSIf getMS() {
        return ms;
    }

    private MSIf ms = new MS();
    public boolean isMovieAccessibleToMyLevel(String myLevel, String movieId)  {
        return  getMS().getPCL(movieId);
    }
}


@Test
public void testIsMovieAccessibleToMyLevelMock()  {
    msMock = mock(MS.class);
    spy  = spy(new PCService());

    doReturn(msMock).when(spy).getMS();
    when(msMock.getPCL(movieId)).thenReturn(value);
    when(spy.getMS().getPCL(movieId)).thenReturn(value);
    assertTrue(spy.isMovieAccessibleToMyLevel("PG", movieId) == true);
}

OriginalL'auteur Mike

Vous devez vous connecter pour publier un commentaire.