Auffüllen Spring @Wert während der Unit-Test

Ich versuche zu schreiben, ein Unit-Test für eine einfache bean, die sich auch in meinem Programm zum validieren von Formularen. Die Bohne ist versehen mit @Component und hat eine Klasse variable, die initialisiert wird mit @Value("${this.property.value}") private String thisProperty;

Möchte ich schreiben unit-tests für die Validierung von Methoden innerhalb dieser Klasse, jedoch, wenn es möglich ist möchte ich das tun, ohne die Nutzung der properties-Datei. Meine Argumentation hinter diesem ist, dass wenn der Wert ich ziehe aus der properties-Datei ändert, würde ich wie dass zu nicht auf meinem test-Fall. Mein test-case wird getestet, der code validiert den Wert, nicht den Wert selbst.

Gibt es einen Weg, um Java-code in meinem test-Klasse zu initialisieren, Java-Klasse, und füllen Sie den Frühling @Value-Eigenschaft haben, in dieser Klasse dann verwenden, um das ganze zu testen?

Habe ich diese Wie zu sein scheint, dass in der Nähe, aber immer noch verwendet eine Eigenschaften-Datei. Eher würde ich es sein, Java-code.

Dank

InformationsquelleAutor der Frage Kyle | 2013-06-27

121

Wenn möglich, würde ich versuchen so zu schreiben, diesen test ohne Feder Kontext. Wenn Sie diese Klasse erstellt haben, die in Ihrem test ohne Feder, dann haben Sie die volle Kontrolle über seine Felder.

Um die @value Feld können Sie verwenden Federn ReflectionTestUtils - es hat eine Methode setField zu setzen private Felder.

@siehe JavaDoc: ReflectionTestUtils.setField(java.lang.Object, java.lang.String, java.lang.Objekt)

InformationsquelleAutor der Antwort Ralph

Seit dem Frühjahr 4.1 Sie können Eigenschaftswerte nur im code mithilfe org.springframework.test.context.TestPropertySource annotation auf Unit-Tests-Klasse-Niveau. Man könnte diesen Ansatz auch für die Injektion von Eigenschaften in der abhängigen bean-Instanzen

Beispielsweise

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = FooTest.Config.class)
@TestPropertySource(properties = {
    "some.bar.value=testValue",
})
public class FooTest {

  @Value("${some.bar.value}")
  String bar;

  @Test
  public void testValueSetup() {
    assertEquals("testValue", bar);
  }


  @Configuration
  static class Config {

    @Bean
    public static PropertySourcesPlaceholderConfigurer propertiesResolver() {
        return new PropertySourcesPlaceholderConfigurer();
    }

  }

}

Hinweis: Es ist notwendig Instanz von org.springframework.context.support.PropertySourcesPlaceholderConfigurer im Frühjahr Kontext

Bearbeiten 24-08-2017: Wenn Sie SpringBoot 1.4.0 und höher könnten Sie initialisieren tests mit @SpringBootTest und @SpringBootConfiguration Anmerkungen. Mehr info hier

Im Falle von SpringBoot wir haben folgenden code

@SpringBootTest
@SpringBootConfiguration
@RunWith(SpringJUnit4ClassRunner.class)
@TestPropertySource(properties = {
    "some.bar.value=testValue",
})
public class FooTest {

  @Value("${some.bar.value}")
  String bar;

  @Test
  public void testValueSetup() {
    assertEquals("testValue", bar);
  }

}

InformationsquelleAutor der Antwort Dmytro Boichenko

Wenn Sie möchten, können Sie noch Ihre Prüfungen im Spring-Kontext und legen Sie die erforderlichen Eigenschaften in Spring-Konfiguration-Klasse. Wenn Sie JUnit, verwenden Sie SpringJUnit4ClassRunner und definieren gewidmet configuration-Klasse für Ihre tests so:

Die Klasse unter test:

@Component
public SomeClass {

    @Autowired
    private SomeDependency someDependency;

    @Value("${someProperty}")
    private String someProperty;
}

Die test-Klasse:

@RunWith(SpringJUnit4ClassRunner.class) 
@ContextConfiguration(classes = SomeClassTestsConfig.class)
public class SomeClassTests {

    @Autowired
    private SomeClass someClass;

    @Autowired
    private SomeDependency someDependency;

    @Before
    public void setup() {
       Mockito.reset(someDependency);

    @Test
    public void someTest() { ... }
}

Und die configuration-Klasse für diesen test:

@Configuration
public class SomeClassTestsConfig {

    @Bean
    public static PropertySourcesPlaceholderConfigurer properties() throws Exception {
        final PropertySourcesPlaceholderConfigurer pspc = new PropertySourcesPlaceholderConfigurer();
        Properties properties = new Properties();

        properties.setProperty("someProperty", "testValue");

        pspc.setProperties(properties);
        return pspc;
    }
    @Bean
    public SomeClass getSomeClass() {
        return new SomeClass();
    }

    @Bean
    public SomeDependency getSomeDependency() {
        //Mockito used here for mocking dependency
        return Mockito.mock(SomeDependency.class);
    }
}

Having sagte, ich würde nicht empfehlen, diesen Ansatz, habe ich nur noch es hier zur Referenz. Meiner Meinung nach wesentlich bessere Möglichkeit ist die Verwendung von Mockito Läufer. In diesem Fall werden Sie nicht laufen tests innerhalb Frühjahr an alle, die viel klarer und einfacher.

InformationsquelleAutor der Antwort Lukasz Korzybski

Diese scheint zu funktionieren, obwohl es immer noch ein bisschen Ausführlicher (ich würde gerne etwas noch kürzer):

@BeforeClass
public static void beforeClass() {
    System.setProperty("some.property", "<value>");
}

//Optionally:
@AfterClass
public static void afterClass() {
    System.clearProperty("some.property");
}

InformationsquelleAutor der Antwort john16384

Hinzufügen PropertyPlaceholderConfigurer in der Konfiguration ist, für mich zu arbeiten.

@Configuration
@ComponentScan
@EnableJpaRepositories
@EnableTransactionManagement
public class TestConfiguration {
@Bean
public DataSource dataSource() {
    EmbeddedDatabaseBuilder builder = new EmbeddedDatabaseBuilder();
    builder.setType(EmbeddedDatabaseType.DERBY);
    return builder.build();
}

@Bean
public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
    LocalContainerEntityManagerFactoryBean entityManagerFactoryBean = new LocalContainerEntityManagerFactoryBean();
    entityManagerFactoryBean.setDataSource(dataSource());
    entityManagerFactoryBean.setPackagesToScan(new String[] { "com.test.model" });
    //Use hibernate
    JpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
    entityManagerFactoryBean.setJpaVendorAdapter(vendorAdapter);
    entityManagerFactoryBean.setJpaProperties(getHibernateProperties());
    return entityManagerFactoryBean;
}

private Properties getHibernateProperties() {
    Properties properties = new Properties();
    properties.put("hibernate.show_sql", "false");
    properties.put("hibernate.dialect", "org.hibernate.dialect.DerbyDialect");
    properties.put("hibernate.hbm2ddl.auto", "update");
    return properties;
}

@Bean
public JpaTransactionManager transactionManager() {
    JpaTransactionManager transactionManager = new JpaTransactionManager();
    transactionManager.setEntityManagerFactory(entityManagerFactory().getObject());
    return transactionManager;
}

@Bean
PropertyPlaceholderConfigurer propConfig() {
    PropertyPlaceholderConfigurer placeholderConfigurer = new PropertyPlaceholderConfigurer();
    placeholderConfigurer.setLocation(new ClassPathResource("application_test.properties"));
    return placeholderConfigurer;
}

}

Und in der test-Klasse

@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = TestConfiguration.class)
public class DataServiceTest {

@Autowired
private DataService dataService;

@Autowired
private DataRepository dataRepository;

@Value("${Api.url}")
private String baseUrl;

@Test
public void testUpdateData() {
    List<Data> datas = (List<Data>) dataRepository.findAll();
    assertTrue(datas.isEmpty());
    dataService.updateDatas();
    datas = (List<Data>) dataRepository.findAll();
    assertFalse(datas.isEmpty());
}

}

InformationsquelleAutor der Antwort fjkjava

4

Machen Sie Ihre Klasse getestet werden sowohl einheitliche und integration

Schreiben zu können, die Reine unit-tests (also ohne laufen, spring-container) und integration tests für die Frühjahr-component-Klasse, die Sie haben, um diese Klasse verwendbar mit oder ohne Feder.

Läuft ein Behälter in einem Gerät testen, wenn es nicht erforderlich ist, ist eine schlechte Praxis verlangsamt der lokalen builds : das wollen Sie nicht.

Ich fügte hinzu, diese Antwort, weil keine Antwort hier scheint zu zeigen, diese Unterscheidung, und so berufen Sie sich auf einem Laufenden container systematisch.

Also ich denke, dass, sollten Sie diese Eigenschaft definiert als eine interne der Klasse :
```
@Component
public class Foo{   
    @Value("${property.value}") private String property;
    //...
}
```
in einen Konstruktor-parameter, der injiziert werden, die von Frühling :
```
@Component
public class Foo{   
    private String property;

    public Foo(@Value("${property.value}") String property){
       this.property = property;
    }

    //...         
}
```
Unit-test-Beispiel

Können Sie instanziieren Foo ohne Feder und injizieren einen beliebigen Wert für property Dank der Konstruktor :
```
public class FooTest{

   Foo foo = new Foo("dummyValue");

   @Test
   public void doThat(){
      ...
   }
}
```
Integration test Beispiel

Können Sie injizieren von Eigentum im Zusammenhang mit Spring Boot in dieser einfachen Weise Dank der properties Attribut @SpringBootTest :
```
@SpringBootTest(properties="property.value=dummyValue")
public class FooTest{

   @Autowired
   Foo foo;

   @Test
   public void doThat(){
       ...
   }    
}
```
Könnten Sie als alternative @TestPropertySource aber es fügt eine zusätzliche Anmerkung :
```
@SpringBootTest
@TestPropertySource("property.value=dummyValue")
public class FooTest{ ...}
```
Mit Feder (ohne Feder-Boot), sollte es ein wenig komplizierter, aber ich habe nicht verwenden ein Frühling ohne Spring Boot aus eine lange Zeit, die ich nicht lieber sagen, eine dumme Sache.

InformationsquelleAutor der Antwort davidxxx

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.