Support rollbackFor attribute of @Transactional in the TestContext framework

[yanjuning]

Description

Transactional test methods wouldn't rollback for exception，when annotated by @Commit or @Rollback(false).

For example, the following roleService.saveOrUpdate(sysRole) would commit.

@RunWith(SpringRunner.class)
@SpringBootTest
@Transactional(rollbackFor = Exception.class)
@Commit
public class UserServiceTest {
    @Autowired
    private RoleService roleService;
    @Test
    public void testRollBack() {
        SysRole sysRole = new SysRole("General");
        roleService.saveOrUpdate(sysRole);
        throw new RuntimeException("ALWAYS_THROW");
    }
}

This would cause partial DML operation commit.

Suggestion

The following code snippet force commit or rollback according to flaggedForRollback

// class org.springframework.test.context.transaction.TransactionContext#endTransaction
if (this.flaggedForRollback) {
    this.transactionManager.rollback(this.transactionStatus);
} else {
    this.transactionManager.commit(this.transactionStatus);
}

I would like to make some changes, determine if there is a matching exception in the testContext.

[sbrannen]

That's an interesting use case. This has been the behavior of test-managed transactions since over a decade, though no one has ever raised this issue before.

In summary, you are asking for the TestContext framework to honor the rollbackFor attribute of @Transactional for exceptions thrown during test method execution.

Is that correct?

Note to self: the rollbackFor configuration is honored in production code in TransactionAspectSupport#completeTransactionAfterThrowing(...).

[yanjuning]

Yes, it's correct.

The problem appears very accidentally. May I submit a pull request to make the SpringTest framework to honor the rollbackFor attribute of @Transactional?

[sbrannen]

Yes, it's correct.

Thanks for the confirmation.

The problem appears very accidentally. May I submit a pull request to make the SpringTest framework to honor the rollbackFor attribute of @Transactional?

Please hold off on submitting a PR until the team decides if we want to support this feature.

Tentatively slated for 5.2 RC1 for consideration.

[yanjuning]

Got it, thanks,

[sbrannen]

Team Decision:

We have decided not to support the rollbackFor attribute of @Transactional in the TestContext framework.

Rationale: Spring's testing support has never honored the rollbackFor attribute of @Transactional. Doing so now would be a potentially breaking change for any code base that has that attribute set, since it has always been ignored.

Workaround: use the TestTransaction API instead. It is intended exactly for such power user cases. Examples will be posted separately.

In any case, the documentation can be improved with regard to which attributes in @Transactional are supported in tests. So I will leave this issue open in order to address that.

[sbrannen]

To achieve the desired behavior, you need to introduce a try-catch block within your test method. Within the catch-block you need to invoke TestTransaction.flagForRollback() to signal to the testing framework that the current test-managed transaction should be rolled back instead of committed. In addition, you still need to throw the original exception in order to allow the test method to fail.

The following JUnit Jupiter based test class demonstrates how to do this.

• serviceMethod() simulates a service that modifies the database and throws a business exception.
• customRollbackWithTestTransactionApi() demonstates how to use the TestTransaction API directly.
• customRollbackForApi() demonstrates that you can implement your own custom "rollback for" DSL to encapsulate the use of the TestTransaction API and the try-catch block.
• afterTransaction() effectively asserts that the transaction was not committed.

When executing this test class, we see the following output to SYS_OUT.

Number of users in DB before transaction: 0
Number of users in DB after transaction: 0
Number of users in DB before transaction: 0
Number of users in DB after transaction: 0

The code is split into chunks to avoid the need to scroll.

@SpringJUnitConfig
@Transactional
@Commit
class CommittedTransactionalTests {

	@Autowired
	JdbcTemplate jdbcTemplate;

	@Test
	void customRollbackWithTestTransactionApi() throws Throwable {
		try {
			serviceMethod();
		}
		catch (Throwable t) {
			TestTransaction.flagForRollback();
			throw t;
		}
	}

	@Test
	void customRollbackForApi() throws Throwable {
		// rollbackFor(FileNotFoundException.class, () -> serviceMethod());
		rollbackFor(Exception.class, () -> serviceMethod());
	}

	@BeforeTransaction
	void beforeTransaction() {
		assertZeroUsers("before");
	}

	@AfterTransaction
	void afterTransaction() {
		assertZeroUsers("after");
	}

	void assertZeroUsers(String phase) {
		int numUsers = JdbcTestUtils.countRowsInTable(this.jdbcTemplate, "user");
		System.out.printf("Number of users in DB %s transaction: %d%n", phase, numUsers);
		assertThat(numUsers).isEqualTo(0);
	}

	static void rollbackFor(Class<? extends Throwable> exceptionType, Executable executable) throws Throwable {
		try {
			executable.execute();
		}
		catch (Throwable t) {
			if (exceptionType.isInstance(t)) {
				TestTransaction.flagForRollback();
			}
			throw t;
		}
	}

	@FunctionalInterface
	interface Executable {
		void execute() throws Throwable;
	}

	private void serviceMethod() throws Exception {
		this.jdbcTemplate.update("INSERT INTO user VALUES('Dilbert')");
		throw new Exception("Business Exception");
	}

	@Configuration
	static class Config {

		@Bean
		JdbcTemplate jdbcTemplate(DataSource dataSource) {
			return new JdbcTemplate(dataSource);
		}

		@Bean
		PlatformTransactionManager transactionManager(DataSource dataSource) {
			return new DataSourceTransactionManager(dataSource);
		}

		@Bean
		DataSource dataSource() {
			return new EmbeddedDatabaseBuilder()
				.generateUniqueName(true)
				.addScript("classpath:/test-schema.sql")
				.build();
		}
	}
}

[sbrannen]

Superseded by gh-23149

[yanjuning]

It works for me though the way to support rollback is not such straightforward.

Thanks for detailed instructions.