Transakcja wycofania po @Test

Po pierwsze, znalazłem wiele wątków na ten temat w StackOverflow, ale żaden z nich tak naprawdę mi nie pomógł, więc przepraszam, że zadaję prawdopodobnie zduplikowane pytanie.

Przeprowadzam testy JUnit za pomocą testu sprężynowego, mój kod wygląda następująco

@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() {
    }    
    ...  
}

Mój problem polega na tym, że chcę, aby moje testy NIE wpływały na inne testy. Chciałbym więc stworzyć coś takiego jak wycofywanie zmian dla każdego testu. Szukałem dużo tego, ale jak dotąd nic nie znalazłem. Używam do tego Hibernate i MySql

Po prostu dodaj @Transactionaladnotację na górze testu:

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

Domyślnie Spring rozpocznie nową transakcję otaczającą twoją metodę testową i @Before/ @Aftercallbacki, wycofując na koniec. Domyślnie działa, wystarczy mieć w kontekście jakiegoś menedżera transakcji.

Od: 10.3.5.4 Zarządzanie transakcjami (moje pogrubienie):

W strukturze TestContext transakcje są zarządzane przez TransactionalTestExecutionListener. Zauważ, że TransactionalTestExecutionListenerjest to skonfigurowane domyślnie , nawet jeśli nie deklarujesz jawnie @TestExecutionListenersswojej klasy testowej. Aby jednak umożliwić obsługę transakcji, należy podać PlatformTransactionManagerkomponent bean w kontekście aplikacji ładowanym przez @ContextConfigurationsemantykę. Ponadto w przypadku testów należy zadeklarować @Transactionalna poziomie klasy lub metody .

Na boku: odrzucono próbę zmiany odpowiedzi Tomasza Nurkiewicza:

Ta zmiana nie czyni posta nawet odrobinę bardziej czytelnym, łatwiejszym do znalezienia, dokładniejszym ani bardziej dostępnym. Zmiany są albo całkowicie zbędne, albo aktywnie szkodzą czytelności.

Prawidłowy i stały link do odpowiedniej sekcji dokumentacji dotyczącej testów integracyjnych.

Aby włączyć obsługę transakcji, należy skonfigurować PlatformTransactionManagerkomponent bean w ApplicationContextładowanym za pośrednictwem @ContextConfigurationsemantyki.

@Konfiguracja
@PropertySource ("application.properties")
public class Persistence {
    @Autowired
    Środowisko env;

    @Fasola
    DataSource dataSource () {
        zwraca nowe DriverManagerDataSource (
                env.getProperty ("datasource.url"),
                env.getProperty ("datasource.user"),
                env.getProperty ("datasource.password")
        );
    }

    @Fasola
    PlatformTransactionManager transactionManager () {
        zwraca nowe DataSourceTransactionManager (dataSource ());
    }
}

Ponadto musisz zadeklarować @Transactionaladnotację Springa na poziomie klasy lub metody dla swoich testów.

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

Dodanie adnotacji do metody testowej @Transactionalpowoduje, że test jest uruchamiany w ramach transakcji, która domyślnie zostanie automatycznie wycofana po zakończeniu testu. Jeśli klasa testowa jest opatrzona adnotacją @Transactional, każda metoda testowa w ramach tej hierarchii klas zostanie uruchomiona w ramach transakcji.

Odpowiedzi dotyczące dodawania @Transactionalsą poprawne, ale dla uproszczenia możesz po prostu mieć swoją klasę testową extends AbstractTransactionalJUnit4SpringContextTests.

Wiem, jestem za późno, aby opublikować odpowiedź, ale mam nadzieję, że może to komuś pomóc. Poza tym właśnie rozwiązałem ten problem, który miałem z moimi testami. Oto, co miałem w moim teście:

Moja klasa testowa

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

Context 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>

Nadal miałem problem, że baza danych nie była czyszczona automatycznie.

Problem został rozwiązany, gdy dodałem następującą właściwość do BasicDataSource

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

Mam nadzieję, że to pomoże.

Musisz uruchomić swój test z kontekstem Springa i menedżerem transakcji, np.

@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
     }
}

Więcej informacji można znaleźć w rozdziale 3.5.8. Transaction ManagementŹródła wiosenne.

Oprócz dodawania @Transactionalna @Testmetody, trzeba także dodać@Rollback(false)

Możesz wyłączyć wycofywanie zmian:

@TransactionConfiguration(defaultRollback = false)

Przykład:

@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();
    }
}