Transaktsiyani boshqarish

TestContext freymvorkida transaktsiyalar TransactionalTestExecutionListener orqali boshqariladi, bu esa sukut bo'yicha o'rnatilgan, agar test sinfingizda aniq @TestExecutionListeners e'lon qilinmagan bo'lsa ham. Ammo, transaktsiyalarni qo'llab-quvvatlash vositalarini faollashtirish uchun siz o'zingizning ApplicationContext ichida PlatformTransactionManager bini sozlashingiz kerak, bu esa @ContextConfiguration annotatsiyasi semantikasi bilan yuklanadi (ko'proq ma'lumot keyinroq beriladi). Shu bilan birga, testlaringiz uchun @Transactional annotatsiyasini Spring'dan, sinf darajasida yoki metod darajasida e'lon qilishingiz kerak.

Testlar orqali boshqariladigan transaktsiyalar

Testlar orqali boshqariladigan transaktsiyalar – bu deklarativ ravishda TransactionalTestExecutionListener yoki dasturiy ravishda TestTransaction orqali boshqariladigan transaktsiyalar (keyinroq tushuntiriladi). Bunday transaktsiyalarni Spring tomonidan boshqariladigan (testlar uchun yuklanadigan ApplicationContext ichida to'g'ridan-to'g'ri freymvork orqali boshqariladigan) yoki dastur tomonidan boshqariladigan transaktsiyalar bilan aralashtirmaslik kerak (testlar orqali chaqiriladigan dastur kodida dasturiy ravishda boshqariladigan). Spring va dastur boshqaruvidagi transaktsiyalar odatda testlar orqali boshqariladigan transaktsiyalarda ishtirok etadi. Ammo, Spring yoki dastur boshqaruvidagi transaktsiyalar REQUIRED yoki SUPPORTSdan boshqa tarqalish turidan foydalanib sozlangan bo'lsa, ehtiyot bo'lish kerak (ko'proq ma'lumot uchun transaktsiyalar tarqalishi bo'limiga qarang).

Transaktsiyalarni faollashtirish va o'chirish

Test metodini @Transactional yordamida annotatsiya qilish testning transaktsiyada boshlanishiga olib keladi, bu esa sukut bo'yicha test tugagandan keyin avtomatik ravishda qaytariladi. Agar test sinfi @Transactional annotatsiyasi bilan belgilangan bo'lsa, unda ushbu sinf iyerarxiyasidagi har bir test metodi transaktsiya doirasida bajariladi. @Transactional bilan annotatsiya qilinmagan test metodlari (sinf yoki metod darajasida) transaktsiya doirasida bajarilmaydi. Eslatma bering, @Transactiona.l annotatsiyasi testlar hayotiy tsikli metodlari uchun qo'llab-quvvatlanmaydi – misol uchun, JUnit Jupiter'dan @BeforeAll, @BeforeEach yordamida belgilangan metodlar va h.k. Bundan tashqari, propagation atributi NOT_SUPPORTED yoki NEVERga o'rnatilgan @Transactional bilan belgilangan testlar transaktsiya doirasida bajarilmaydi.

Eslatma bering, AbstractTransactionalJUnit4SpringContextTests va AbstractTransactionalTestNGSpringContextTests sinf darajasida transaktsiyalarni qo'llab-quvvatlash uchun oldindan o'rnatilgan.

Quyidagi misolda Hibernate asosidagi UserRepository uchun integratsion test yozish uchun umumiy stsenariy ko'rsatilgan:

@SpringJUnitConfig(TestConfig.class)
@Transactional
class HibernateUserRepositoryTests {
    @Autowired
    HibernateUserRepository repository;
    @Autowired
    SessionFactory sessionFactory;
    JdbcTemplate jdbcTemplate;
    @Autowired
    void setDataSource(DataSource dataSource) {
        this.jdbcTemplate = new JdbcTemplate(dataSource);
    }
    @Test
    void createUser() {
        // Test bazasidagi boshlang'ich holatni kuzatamiz:
        final int count = countRowsInTable("user");
        User user = new User(...);
        repository.save(user);
        // Test davomida noto'g'ri ishlashlardan qochish uchun qo'lda qaytarish kerak
        sessionFactory.getCurrentSession().flush();
        assertNumUsers(count + 1);
    }
    private int countRowsInTable(String tableName) {
        return JdbcTestUtils.countRowsInTable(this.jdbcTemplate, tableName);
    }
    private void assertNumUsers(int expected) {
        assertEquals("Number of rows in the [user] table.", expected, countRowsInTable("user"));
    }
}

@SpringJUnitConfig(TestConfig::class)
@Transactional
class HibernateUserRepositoryTests {
    @Autowired
    lateinit var repository: HibernateUserRepository
    @Autowired
    lateinit var sessionFactory: SessionFactory
    lateinit var jdbcTemplate: JdbcTemplate
    @Autowired
    fun setDataSource(dataSource: DataSource) {
        this.jdbcTemplate = JdbcTemplate(dataSource)
    }
    @Test
    fun createUser() {
        // Test bazasidagi boshlang'ich holatni kuzatamiz:
        val count = countRowsInTable("user")
        val user = User()
        repository.save(user)
        // Test davomida noto'g'ri ishlashlardan qochish uchun qo'lda qaytarish kerak
        sessionFactory.getCurrentSession().flush()
        assertNumUsers(count + 1)
    }
    private fun countRowsInTable(tableName: String): Int {
        return JdbcTestUtils.countRowsInTable(jdbcTemplate, tableName)
    }
    private fun assertNumUsers(expected: Int) {
        assertEquals("Number of rows in the [user] table.", expected, countRowsInTable("user"))
    }
}

"Transaktsiyalarni qaytarish va tasdiqlash mantiqi" bobida tushuntirilgandek, createUser() metodidan keyin ma'lumotlar bazasini tozalash talab qilinmaydi, chunki TransactionalTestExecutionListener tomonidan kiritilgan o'zgarishlar avtomatik ravishda qaytariladi.

Transaktsiyani qaytarish va tasdiqlash mantiqi

Sukut bo'yicha test transaktsiyalari avtomatik ravishda test tugagandan keyin qaytariladi; ammo transaktsiyalarni tasdiqlash va qaytarish mantiqini @Commit va @Rollback annotatsiyalari yordamida deklarativ tarzda sozlash mumkin. Qo'shimcha ma'lumot uchun annotatsiyalarni qo'llab-quvvatlashga bag'ishlangan bobga qarang.

Dasturiy transaktsiyalarni boshqarish

Siz TestTransactiondagi statik metodlarni qo'llab-quvvatlash orqali testlar orqali boshqariladigan transaktsiyalar bilan dasturiy tarzda o'zaro ta'sir qilishingiz mumkin. Masalan, siz TestTransactionni test metodlari ichida, "oldin" va "keyin" metodlarida joriy test orqali boshqariladigan transaktsiyani ishga tushirish yoki tugatish yoki joriy test orqali boshqariladigan transaktsiyani qaytarish yoki tasdiqlashga sozlash uchun ishlatishingiz mumkin. TestTransactionni qo'llab-quvvatlash har doim faollashgan TransactionalTestExecutionListener eshituvchisi bo'lsa avtomatik ravishda mavjud.

Quyidagi misolda TestTransactionning ba'zi xususiyatlari ko'rsatilgan. Ko'proq ma'lumot uchun TestTransactionning javadociga qarang.

@ContextConfiguration(classes = TestConfig.class)
public class ProgrammaticTransactionManagementTests extends
        AbstractTransactionalJUnit4SpringContextTests {
    @Test
    public void transactionalTest() {
        // Test bazasidagi boshlang'ich holatni tasdiqlaymiz:
        assertNumUsers(2);
        deleteFromTables("user");
        // Ma'lumotlar bazasidagi o'zgarishlar tasdiqlanadi!
        TestTransaction.flagForCommit();
        TestTransaction.end();
        assertFalse(TestTransaction.isActive());
        assertNumUsers(0);
        TestTransaction.start();
        // Ma'lumotlar bazasida boshqa harakatlar amalga oshiramiz, bu 
        // test tugagandan so'ng avtomatik ravishda qaytariladi...
    }
    protected void assertNumUsers(int expected) {
        assertEquals("Number of rows in the [user] table.", expected, countRowsInTable("user"));
    }
}

@ContextConfiguration(classes = [TestConfig::class])
class ProgrammaticTransactionManagementTests : AbstractTransactionalJUnit4SpringContextTests() {
    @Test
    fun transactionalTest() {
        // Test bazasidagi boshlang'ich holatni tasdiqlaymiz:
        assertNumUsers(2)
        deleteFromTables("user")
        // Ma'lumotlar bazasidagi o'zgarishlar tasdiqlanadi!
        TestTransaction.flagForCommit()
        TestTransaction.end()
        assertFalse(TestTransaction.isActive())
        assertNumUsers(0)
        TestTransaction.start()
        // Ma'lumotlar bazasida boshqa harakatlar amalga oshiramiz, bu 
        // test tugagandan so'ng avtomatik ravishda qaytariladi...
    }
    protected fun assertNumUsers(expected: Int) {
        assertEquals("Number of rows in the [user] table.", expected, countRowsInTable("user"))
    }
}

Transaktsiya tashqarisida kodni bajarish

Ba'zan tranzaktsion test metodidan oldin yoki undan keyin muayyan kodni bajarish lozim, lekin tranzaktsion kontekst tashqarisida – masalan, testni ishga tushirishdan oldin ma'lumotlar bazasining boshlang'ich holatini tekshirish yoki test tugagandan so'ng tranzaktsion tasdiqlashning kutilgan xatti-harakatini tekshirish (agar test tranzaktsiyani tasdiqlashga sozlangan bo'lsa). TransactionalTestExecutionListener bunday stsenariylar uchun @BeforeTransaction va @AfterTransactio.n annotatsiyalarini qo'llab-quvvatlaydi. Siz ushbu annotatsiyalardan birini test sinfidagi har qanday void metodiga yoki test interfeysidagi har qanday sukut bo'yicha void metodiga belgilashingiz mumkin, va eshituvchi TransactionalTestExecutionListener sizning metodingiz "tranzaktsiyadan oldin" yoki "tranzaktsiyadan keyin" kerakli vaqtda ishga tushishini ta'minlaydi.

Transaktsiyalar menejerini sozlash

TransactionalTestExecutionListener test uchun Spring ichidagi ApplicationContextda PlatformTransactionManager binini aniqlashini kutadi. Agar ApplicationContext testida bir nechta PlatformTransactionManager mavjud bo'lsa, siz "@Transactional("myTxMgr")" yoki "@Transactional(transactionManager = "myTxMgr")" annotatsiyasini ko'rsatish orqali kvalifikator e'lon qilishingiz yoki TransactionManagementConfigurerni @Configuration annotatsiyasi bilan belgilangan sinf orqali amalga oshirishi mumkin. Ko'proq ma'lumot uchun test ApplicationContextda transaktsiyalar menejerini topish uchun ishlatiladigan algoritmga ko'proq ma'lumot olish uchun javadoc of TestContextTransactionUtils.retrieveTransactionManager()ga qarang.

Barcha transaktsiyaga aloqador annotatsiyalarni ko'rsatish

Quyidagi misolda JUnit Jupiter asosida tasavvuriy integratsion test stsenariysi ko'rsatilgan, bunda transaktsiyaga aloqador barcha annotatsiyalar ajratilgan. Bu misol eng yaxshi amaliyotni emas, balki ushbu annotatsiyalardan qanday foydalanishni ko'rsatish vazifasini bajaradi. Qo'shimcha ma'lumot va sozlamalarni ko'rsatish uchun annotatsiyalarni qo'llab-quvvatlashga bog'ishlangan bo'limga qarang. Transaktsiyalarni boshqarish uchun @Sql annotatsiyasi yorlig'i bo'limi @Sql annotatsiyasini ishlatish orqali sukut bo'yicha transaktsiyani qaytarishni amalga oshirish uchun deklarativ SQL ssenariyini ishlatish bo'yicha qo'shimcha misolni o'z ichiga oladi. Quyidagi misolda muhim annotatsiyalar ko'rsatilgan:

@SpringJUnitConfig
@Transactional(transactionManager = "txMgr")
@Commit
class FictitiousTransactionalTest {
    @BeforeTransaction
    void verifyInitialDatabaseState() {
        // Tranzaktsiya boshlanishidan oldin boshlang'ich holatni tekshirish mantiqi
    }
    @BeforeEach
    void setUpTestDataWithinTransaction() {
        // Tranzaktsiya doirasida test ma'lumotlarini o'rnatamiz
    }
    @Test
    // Sinf darajasida @Commit annotatsiyasini sozlashni bekor qiladi
    @Rollback
    void modifyDatabaseWithinTransaction() {
        // Test ma'lumotlaridan foydalanadigan va ma'lumotlar bazasi holatini o'zgartiradigan mantiq
    }
    @AfterEach
    void tearDownWithinTransaction() {
        // Tranzaktsiya ichida "buzg'unchilik (tear down)" mantiqini ishga tushiramiz
    }
    @AfterTransaction
    void verifyFinalDatabaseState() {
        // Tranzaktsiya qaytarilishidan keyin yakuniy holatni tekshirish mantiqi
    }
}

@SpringJUnitConfig
@Transactional(transactionManager = "txMgr")
@Commit
class FictitiousTransactionalTest {
    @BeforeTransaction
    fun verifyInitialDatabaseState() {
        // Tranzaktsiya boshlanishidan oldin boshlang'ich holatni tekshirish mantiqi
    }
    @BeforeEach
    fun setUpTestDataWithinTransaction() {
        // Tranzaktsiya doirasida test ma'lumotlarini o'rnatamiz
    }
    @Test
    // Sinf darajasida @Commit annotatsiyasini sozlashni bekor qiladi
    @Rollback
    fun modifyDatabaseWithinTransaction() {
        // Test ma'lumotlaridan foydalanadigan va ma'lumotlar bazasi holatini o'zgartiradigan mantiq
    }
    @AfterEach
    fun tearDownWithinTransaction() {
        // Tranzaktsiya ichida "buzg'unchilik (tear down)" mantiqini ishga tushiramiz
    }
    @AfterTransaction
    fun verifyFinalDatabaseState() {
        // Tranzaktsiya qaytarilishidan keyin yakuniy holatni tekshirish mantiqi
    }
}

// ...
@Autowired
SessionFactory sessionFactory;
@Transactional
@Test // Kutgan istisno yo'q!
public void falsePositive() {
    updateEntityInHibernateSession();
    // Noto'g'ri natija: istisno Hibernate sessiyasi
    // tugatgandan keyin (ya'ni ishlab chiqarish kodida) vujudga keladi
}
@Transactional
@Test(expected = ...)
public void updateWithSessionFlush() {
    updateEntityInHibernateSession();
    // Test davomida noto'g'ri ishlashlardan qochish uchun qo'lda qaytarish kerak
    sessionFactory.getCurrentSession().flush();
}
// ...

// ...
@Autowired
lateinit var sessionFactory: SessionFactory
@Transactional
@Test // Kutgan istisno yo'q!
fun falsePositive() {
    updateEntityInHibernateSession()
    // Noto'g'ri natija: istisno Hibernate sessiyasi
    // tugatgandan keyin (ya'ni ishlab chiqarish kodida) vujudga keladi
}
@Transactional
@Test(expected = ...)
fun updateWithSessionFlush() {
    updateEntityInHibernateSession()
    // Test davomida noto'g'ri ishlashlardan qochish uchun qo'lda qaytarish kerak
    sessionFactory.getCurrentSession().flush()
}
// ...

// ...
@PersistenceContext
EntityManager entityManager;
@Transactional
@Test // Kutgan istisno yo'q!
public void falsePositive() {
    updateEntityInJpaPersistenceContext();
    // Noto'g'ri natija: istisno
    // JPA'dan EntityManager tugatgandan keyin
    // (ya'ni ishlab chiqarish kodida) vujudga keladi
}
@Transactional
@Test(expected = ...)
public void updateWithEntityManagerFlush() {
    updateEntityInJpaPersistenceContext();
    // Test davomida noto'g'ri ishlashlardan qochish uchun qo'lda qaytarish kerak
    entityManager.flush();
}
// ...

// ...
@PersistenceContext
lateinit var entityManager:EntityManager
@Transactional
@Test // Kutgan istisno yo'q!
fun falsePositive() {
    updateEntityInJpaPersistenceContext()
    // Noto'g'ri natija: istisno
    // JPA'dan EntityManager tugatgandan keyin
    // (ya'ni ishlab chiqarish kodida) vujudga keladi
}
@Transactional
@Test(expected = ...)
void updateWithEntityManagerFlush() {
    updateEntityInJpaPersistenceContext()
    // Test davomida noto'g'ri ishlashlardan qochish uchun qo'lda qaytarish kerak
    entityManager.flush()
}
// ...

// ...
@Autowired
JpaPersonRepository repo;
@PersistenceContext
EntityManager entityManager;
@Transactional
@Test
void savePerson() {
    // EntityManager#persist(...) @PrePersist'ga olib keladi, lekin @PostPersist emas
    repo.save(new Person("Jane"));
    // @PostPersist annotatsiyasi bilan callbackni amalga oshirish uchun qo'lda qaytarish kerak
    entityManager.flush();
    // @PostPersist annotatsiyasi bilan callbackni ishlatadigan test kodi
    // chaqirildi...
}
// ...

// ...
@Autowired
lateinit var repo: JpaPersonRepository
@PersistenceContext
lateinit var entityManager: EntityManager
@Transactional
@Test
fun savePerson() {
    // EntityManager#persist(...) @PrePersist'ga olib keladi, lekin @PostPersist emas
    repo.save(Person("Jane"))
    // @PostPersist annotatsiyasi bilan callbackni amalga oshirish uchun qo'lda qaytarish kerak
    entityManager.flush()
    // @PostPersist annotatsiyasi bilan callbackni ishlatadigan test kodi
    // chaqirildi...
}
// ...