Comment puis-je simuler un autocâblés @Valeur du champ au Printemps avec Mockito?

Je suis en utilisant le Printemps 3.1.4.LIBÉRATION et Mockito 1.9.5. Dans mon Printemps de classe que j'ai:

@Value("#{myProps['default.url']}")
private String defaultUrl;

@Value("#{myProps['default.password']}")
private String defaultrPassword;

//...

De mon JUnit test, j'ai actuellement configuré comme suit:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({ "classpath:test-context.xml" })
public class MyTest 
{

Je voudrais simuler une valeur de mon "defaultUrl" sur le terrain. Notez que je ne veux pas de se moquer des valeurs pour les autres domaines — que j'aimerais garder ceux qu'ils sont, seul le "defaultUrl" sur le terrain. Notez également que je n'ai pas explicite "setter" de méthodes (p. ex. setDefaultUrl) dans ma classe et je ne veux pas créer tout simplement à des fins de test.

Compte tenu de cela, comment puis-je simuler une valeur pour un champ?

InformationsquelleAutor Dave | 2014-04-18

120

Vous pouvez utiliser la magie du Printemps ReflectionTestUtils.setField afin d'éviter de faire toutes les modifications que ce soit à votre code.

Découvrez cette tutoriel pour plus d'informations, bien que vous n'aurez probablement pas besoin, puisque la méthode est très facile à utiliser

Mise à JOUR

Depuis l'introduction de Printemps 4.2.RC1, il est maintenant possible de définir un champ statique, sans avoir à fournir une instance de la classe. Voir cette partie de la documentation et cette commettre.
- Juste en cas de lien mort: utilisation ReflectionTestUtils.setField(bean, "fieldName", "value"); avant d'appeler votre bean méthode lors de l'essai.
- Une bonne solution pour se moquer des propriétés qui sont de la récupération à partir d'un fichier de propriétés.
InformationsquelleAutor geoand

C'est maintenant la troisième fois que j'ai cherché moi-même à cette SORTE de post que j'oublie toujours comment simuler un @champ de Valeur. Si l'on a accepté la réponse est correcte, j'ai toujours besoin d'un peu de temps pour obtenir le "setField" appel, au moins pour moi, je coller un exemple extrait ici:

De Production de classe:

@Value("#{myProps[‘some.default.url']}")
private String defaultUrl;

De la classe de Test:

import org.springframework.test.util.ReflectionTestUtils;

ReflectionTestUtils.setField(instanceUnderTest, "defaultUrl", "http://foo");
//Note: Don't use MyClassUnderTest.class, use the instance you are testing itself
//Note: Don't use the referenced string "#{myProps[‘some.default.url']}", 
//      but simply the FIELDs name ("defaultUrl")

InformationsquelleAutor BAERUS

Vous pouvez aussi simuler votre propriété de configuration dans votre classe de test

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({ "classpath:test-context.xml" })
public class MyTest 
{ 
   @Configuration
   public static class MockConfig{
       @Bean
       public Properties myProps(){
             Properties properties = new Properties();
             properties.setProperty("default.url", "myUrl");
             properties.setProperty("property.value2", "value2");
             return properties;
        }
   }
   @Value("#{myProps['default.url']}")
   private String defaultUrl;

   @Test
   public void testValue(){
       Assert.assertEquals("myUrl", defaultUrl);
   }
}

InformationsquelleAutor Manuel Quinones

18

Je voudrais suggérer une solution connexe, qui est de passer le @Valueannotée champs en tant que paramètres au constructeur, au lieu d'utiliser le ReflectionTestUtils classe.

Au lieu de cela:
```
public class Foo {

    @Value("${foo}")
    private String foo;
}
```
et
```
public class FooTest {

    @InjectMocks
    private Foo foo;

    @Before
    public void setUp() {
        ReflectionTestUtils.setField(Foo.class, "foo", "foo");
    }

    @Test
    public void testFoo() {
        //stuff
    }
}
```
Ce faire:
```
public class Foo {

    private String foo;

    public Foo(@Value("${foo}") String foo) {
        this.foo = foo;
    }
}
```
et
```
public class FooTest {

    private Foo foo;

    @Before
    public void setUp() {
        foo = new Foo("foo");
    }

    @Test
    public void testFoo() {
        //stuff
    }
}
```
Avantages de cette approche: 1) nous pouvons instancier la classe Foo sans une dépendance conteneur (c'est juste un constructeur), et 2) nous ne sommes pas de couplage notre test pour nos détails de mise en œuvre (réflexion liens nous le nom du champ à l'aide d'une chaîne, ce qui pourrait causer un problème si on change le nom du champ).
- inconvénient: Si quelqu'un mess avec l'annotation, par exemple, utilise une propriété 'bar' au lieu de 'foo', votre test fonctionne toujours. Je viens d'avoir ce cas.
- C'est juste un point, en général, pour l'OP question, mais la question vous soulevez n'est pas meilleur ou pour le pire à l'aide de la réflexion utils vs constructeur. Le point de cette réponse est la prise en considération de constructeur sur la réflexion util (la accepté de répondre). Marque, merci pour la réponse, j'apprécie la facilité et la propreté de ce tweak.
InformationsquelleAutor Mark

Vous pouvez utiliser cette magie du Printemps de Test annotation :

@TestPropertySource(properties = { "my.spring.property=20" })

voir
org.springframework.test.contexte.TestPropertySource

Par exemple, c'est la classe de test :

@ContextConfiguration(classes = { MyTestClass.Config.class })
@TestPropertySource(properties = { "my.spring.property=20" })
public class MyTestClass {

  public static class Config {
    @Bean
    MyClass getMyClass() {
      return new MyClass ();
    }
  }

  @Resource
  private MyClass myClass ;

  @Test
  public void myTest() {
   ...

Et c'est la classe avec la propriété :

@Component
public class MyClass {

  @Value("${my.spring.property}")
  private int mySpringProperty;
   ...

InformationsquelleAutor Thibault

6

J'ai utilisé le code ci-dessous et cela a fonctionné pour moi:
```
@InjectMocks
private ClassABC classABC = new ClassABC();

@Before
public void setUp() {
    ReflectionTestUtils.setField(classABC, "constantFromConfigFile", 3);
}
```
Référence: https://www.jeejava.com/mock-an-autowired-value-field-in-spring-with-junit-mockito/
- La seule solution qui a fonctionné pour moi. Merci beaucoup.
InformationsquelleAutor Mendon Ashwini

Notez également que je n'ai pas explicite "setter" de méthodes (p. ex. setDefaultUrl) dans ma classe et je ne veux pas créer tout simplement à des fins de test.

Une façon de résoudre ce problème est de changer votre classe à utiliser Constructeur Injection, qui est utilisée pour les tests de Printemps et d'injection. Pas plus de réflexion 🙂

Ainsi, vous pouvez passer n'importe quel Chaîne à l'aide du constructeur:

class MySpringClass {

    private final String defaultUrl;
    private final String defaultrPassword;

    public MySpringClass (
         @Value("#{myProps['default.url']}") String defaultUrl, 
         @Value("#{myProps['default.password']}") String defaultrPassword) {
        this.defaultUrl = defaultUrl;
        this.defaultrPassword= defaultrPassword;
    }

}

Et dans votre test, il suffit de l'utiliser:

MySpringClass MySpringClass  = new MySpringClass("anyUrl", "anyPassword");

InformationsquelleAutor Dherik

Vous devez vous connecter pour publier un commentaire.