test - pruebas junit en java

¿Cómo ejecutar JUnit SpringJUnit4ClassRunner con Parametrized?

Question

El siguiente código no es válido debido a la anotación duplicada @RunWith :

@RunWith(SpringJUnit4ClassRunner.class)
@RunWith(Parameterized.class)
@SpringApplicationConfiguration(classes = {ApplicationConfigTest.class})
public class ServiceTest {
}

Pero, ¿cómo puedo usar estas dos anotaciones en conjunto?

Answer 1

Maneje el contexto de la aplicación usted mismo

Lo que funcionó para mí fue tener una clase de prueba @RunWith(Parameterized.class) que administraba el contexto de la aplicación "a mano".

Para hacer eso, creé un contexto de aplicación con la misma colección de cadenas que estaría en @ContextConfiguration . Entonces, en lugar de tener

@ContextConfiguration(locations = { "classpath:spring-config-file1.xml",
"classpath:spring-config-file2.xml" })

yo tenía

ApplicationContext ctx = new ClassPathXmlApplicationContext(new String[] {
"classpath:spring-config-file1.xml", "classpath:spring-config-file2.xml" });

Y para cada @Autowired que necesitaba, lo obtuve a mano del contexto creado:

SomeClass someBean = ctx.getBean("someClassAutowiredBean", SomeClass.class);

No olvides cerrar el contexto al final:

((ClassPathXmlApplicationContext) ctx).close();

Answer 2

Hay al menos 2 opciones para hacer eso:

1. Siguiendo http://www.blog.project13.pl/index.php/coding/1077/runwith-junit4-with-both-springjunit4classrunner-and-parameterized/

   Su prueba debe parecerse a esto:

    @RunWith(Parameterized.class)
   @ContextConfiguration(classes = {ApplicationConfigTest.class})
   public class ServiceTest {
   private TestContextManager testContextManager;
   @Before
   public void setUpContext() throws Exception {
   //this is where the magic happens, we actually do "by hand" what the spring runner would do for us,
   // read the JavaDoc for the class bellow to know exactly what it does, the method names are quite accurate though
   this.testContextManager = new TestContextManager(getClass());
   this.testContextManager.prepareTestInstance(this);
   }
   ...
   }

2. Hay un proyecto github https://github.com/mmichaelis/spring-aware-rule , que se basa en el blog anterior, pero agrega soporte de forma generalizada

   @SuppressWarnings("InstanceMethodNamingConvention")
   @ContextConfiguration(classes = {ServiceTest.class})
   public class SpringAwareTest {
   @ClassRule
   public static final SpringAware SPRING_AWARE = SpringAware.forClass(SpringAwareTest.class);
   @Rule
   public TestRule springAwareMethod = SPRING_AWARE.forInstance(this);
   @Rule
   public TestName testName = new TestName();
   ...
   }

Entonces puede tener una clase básica implementando uno de los enfoques, y todas las pruebas heredadas de él.

Answer 3

Hay otra solución con JUnit 4.12 sin la necesidad de Spring 4.2+.

JUnit 4.12 presenta ParametersRunnerFactory que permiten combinar la prueba parametrizada y la inyección de Spring.

public class SpringParametersRunnerFactory implements ParametersRunnerFactory {
@Override
public Runner createRunnerForTestWithParameters(TestWithParameters test) throws InitializationError {
final BlockJUnit4ClassRunnerWithParameters runnerWithParameters = new BlockJUnit4ClassRunnerWithParameters(test);
return new SpringJUnit4ClassRunner(test.getTestClass().getJavaClass()) {
@Override
protected Object createTest() throws Exception {
final Object testInstance = runnerWithParameters.createTest();
getTestContextManager().prepareTestInstance(testInstance);
return testInstance;
}
};
}
}

La fábrica se puede agregar a la clase de prueba para brindar soporte completo de Spring, como la transacción de prueba , reiniciar el contexto sucio y la prueba de servlet .

@UseParametersRunnerFactory(SpringParametersRunnerFactory.class)
@RunWith(Parameterized.class)
@ContextConfiguration(locations = {"/test-context.xml", "/mvc-context.xml"})
@WebAppConfiguration
@Transactional
@TransactionConfiguration
public class MyTransactionalTest {
@Autowired
private WebApplicationContext context;
...
}

Si necesita el contexto Spring dentro del método estático @Parameters para proporcionar parámetros para probar instancias, consulte mi respuesta aquí. ¿Cómo puedo usar el corredor de prueba JUnit parametrizado con un campo que se inyecta usando Spring? .

Answer 4

Puede usar SpringClassRule y SpringMethodRule, suministrados con Spring

import org.junit.ClassRule;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.springframework.test.context.junit4.rules.SpringClassRule;
import org.springframework.test.context.junit4.rules.SpringMethodRule;
@RunWith(Parameterized.class)
@ContextConfiguration(...)
public class MyTest {
@ClassRule
public static final SpringClassRule SPRING_CLASS_RULE = new SpringClassRule();
@Rule
public final SpringMethodRule springMethodRule = new SpringMethodRule();
...