java - starter - spring boot test repository

Revertir la transacción después de @Test

Question

En primer lugar, he encontrado muchos hilos en StackOverflow sobre esto, pero ninguno de ellos realmente me ayudó, así que lamento preguntar posiblemente una pregunta duplicada.

Estoy ejecutando pruebas JUnit usando spring-test, mi código se ve así

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {})
public class StudentSystemTest {
@Autowired
private StudentSystem studentSystem;
@Before
public void initTest() {
// set up the database, create basic structure for testing
}
@Test
public void test1() {
}
...
}

Mi problema es que quiero que mis pruebas NO influyan en otras pruebas. Entonces me gustaría crear algo así como deshacer para cada prueba. He buscado mucho para esto, pero no he encontrado nada hasta ahora. Estoy usando Hibernate y MySql para esto

Answer 1

Debe ejecutar su prueba con un contexto de sprint y un administrador de transacciones, por ejemplo,

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"/your-applicationContext.xml"})
@TransactionConfiguration(transactionManager="txMgr")
public class StudentSystemTest {
@Test
public void testTransactionalService() {
// test transactional service
}
@Test
@Transactional
public void testNonTransactionalService() {
// test non-transactional service
}
}

Vea el capítulo 10. Testing de la referencia de resorte para más detalles.

Answer 2

Las respuestas que mencionan agregar @Transactional son correctas, pero para simplificar, podría hacer que su clase de prueba extends AbstractTransactionalJUnit4SpringContextTests .

Answer 3

Lo sé, estoy demasiado tarde para publicar una respuesta, pero espero que pueda ayudar a alguien. Además, acabo de resolver este problema que tuve con mis pruebas. Esto es lo que tuve en mi prueba:

Mi clase de prueba

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "path-to-context" })
@Transactional
public class MyIntegrationTest

Contexto xml

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>

Todavía tenía el problema de que la base de datos no se limpiaba automáticamente.

El problema se resolvió cuando agregué la siguiente propiedad a BasicDataSource

<property name="defaultAutoCommit" value="false" />

Espero eso ayude.

Answer 4

Puede deshabilitar la reversión:

@TransactionConfiguration(defaultRollback = false)

Ejemplo:

@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = Application.class)
@Transactional
@TransactionConfiguration(defaultRollback = false)
public class Test {
@PersistenceContext
private EntityManager em;
@org.junit.Test
public void menge() {
PersistentObject object = new PersistentObject();
em.persist(object);
em.flush();
}
}

Answer 5

Solo agrega la anotación @Transactional encima de tu prueba:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"testContext.xml"})
@Transactional
public class StudentSystemTest {

Por defecto, Spring iniciará una nueva transacción en torno a su método de prueba y @Before / @Before callbacks, retrocediendo al final. Funciona de manera predeterminada, es suficiente tener algún administrador de transacciones en el contexto.

De: 10.3.5.4 Gestión de transacciones (mina en negrita):

En el marco TestContext, TransactionalTestExecutionListener administra las transacciones. Tenga en cuenta que TransactionalTestExecutionListener está configurado de manera predeterminada , incluso si no declara explícitamente @TestExecutionListeners en su clase de prueba. Sin embargo, para habilitar el soporte para las transacciones, debe proporcionar un bean PlatformTransactionManager en el contexto de la aplicación cargado por la semántica de @ContextConfiguration . Además, debe declarar @Transactional a nivel de clase o método para sus pruebas .

Answer 6

Aparte: el intento de enmendar la respuesta de Tomasz Nurkiewicz fue rechazado:

Esta edición no hace que la publicación sea aún más fácil de leer, más fácil de encontrar, más precisa o más accesible. Los cambios son completamente superfluos o perjudican activamente la legibilidad.

link correcto y permanente a la sección relevante de la documentación sobre pruebas de integración.

Para habilitar el soporte para transacciones, debe configurar un bean PlatformTransactionManager en el ApplicationContext que se carga a través de la semántica de @ContextConfiguration .

@Configuration @PropertySource("application.properties") public class Persistence { @Autowired Environment env; @Bean DataSource dataSource() { return new DriverManagerDataSource( env.getProperty("datasource.url"), env.getProperty("datasource.user"), env.getProperty("datasource.password") ); } @Bean PlatformTransactionManager transactionManager() { return new DataSourceTransactionManager(dataSource()); } }

Además, debe declarar la anotación @Transactional de Spring a nivel de clase o método para sus pruebas.

@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(classes = {Persistence.class, SomeRepository.class}) @Transactional public class SomeRepositoryTest { ... }

Anotar un método de prueba con @Transactional hace que la prueba se ejecute dentro de una transacción que, de forma predeterminada, se retrotraerá automáticamente después de la finalización de la prueba. Si una clase de prueba se anota con @Transactional , cada método de prueba dentro de esa jerarquía de clase se ejecutará dentro de una transacción.