DependencyInjectionTestExecutionListener seems to prevent transactions from working in tests

[ofir-popowski]

I hope this is also the right place to ask about this, I know that some things should go under spring-data-commons, I don't mind this being moved of course

I'm using spring-data-jpa, in a column discriminator based multi-tenant environment (so all of our @Entitys have @TenantId). For some tests (relying on @DataJpaTest, we would like to switch which tenant is the current one, so I have something like this:

@TestComponent
@Primary
class TestTenantIdentifierResolver : CurrentTenantIdentifierResolver<String>, HibernatePropertiesCustomizer {

  var currentTenant: String? = null

  override fun resolveCurrentTenantIdentifier(): String {
    return currentTenant
  }

  override fun validateExistingCurrentSessions(): Boolean {
    return true
  }

  override fun isRoot(tenantId: String): Boolean {
    return tenantId == "my-root-tenant"
  }

  override fun customize(hibernateProperties: MutableMap<String, Any>) {
    hibernateProperties[AvailableSettings.MULTI_TENANT_IDENTIFIER_RESOLVER] = this
  }
}

This initially didn't work, as @Autowired testTenantIdentifierResolver and calling currentTenant = "a tenant" did nothing, the tenant hasn't actually changed in the rest of the test method.
I went back to the original how-to guide about this, and noticed that I was missing @TestExecutionListeners(listeners = [DependencyInjectionTestExecutionListener::class]) on top of my test class.

When I added this annotation, changing the tenant worked as expected, and tests were successful.

But it did have a bad side effect, all of the tests that were lazily fetching collections started to fail with could not initialize proxy - no Session, and no matter what I did they kept failing. Only removing the @TestExecutionListeners annotation made it possible for collections to be lazily fetched again

Is there a way to configure a @DataJpaTest that could support both tenant resolution and still support lazy loading collections?

reproduced example here https://github.com/ofir-popowski/tenant-resolver-issue

[mp911de]

DependencyInjectionTestExecutionListener is not required because @DataJpaTest's @ExtendWith({SpringExtension.class}) takes care of this. By declaring @TestExecutionListeners mergeMode() MergeMode.REPLACE_DEFAULTS is applied, meaning that all default listeners are omitted.

I'm not fully sure why the blog post mentions DependencyInjectionTestExecutionListener, I can imagine the time of the blog post was written, constructor creation with dependency injection wasn't possible with JUnit.

The underlying issue why lazy loading fails exceptionally is that there is not surrounding transaction. A transaction is being started with findAll(). The transaction is also cleaned up and so the original Hibernate session is closed.

Let me know if that makes sense and if you need further guidance.

[ofir-popowski]

First thank you for your detailed response, it is appreciated :)

I'm not fully sure why the blog post mentions DependencyInjectionTestExecutionListener, I can imagine the time of the blog post was written, constructor creation with dependency injection wasn't possible with JUnit.

Without the DependencyInjectionTestExecutionListener trying to set the tenantId during a test method has no effect, so calling tenantIdentifierResolver.currentTenant = tenantId ends up with the resolveCurrentTenantIdentifier() returning null (or a default value)
I'm relying on this functionality to switch tenants during a test method (for example from root tenant to regular one)

It felt like something here isn't working as it should, or perhaps I'm trying to do something that is not fully supported (which is why I've opened an issue instead of asking on SO)

I posted an example of this in my reproduced example, you can see it here https://github.com/ofir-popowski/tenant-resolver-issue/blob/main/src/test/kotlin/com/example/tenantresolverissue/ResolverDoesNothingTest.kt

If this is working as intended and I'm misunderstanding how these features combine together, I could go ahead and ask on SO as per the label

[mp911de]

Thanks for pointing that out. When omitting @TestExecutionListeners, then Spring's transactional listener is being used. @DataJpaTest is marked as @Transactional. The effect now is that once a test method is entered, a transaction is started. The transaction is associated with a Hibernate session. Upon session creation, the current tenant is obtained and held during the entire Transaction.

This means that even if you change the current tenant in your @Test method, the change isn't propagated to Hibernate as the tenant is obtained already on session creation.

That means for you, that you should not use managed transactions. You can achieve that through annotating your test class with @Transactional(propagation = Propagation.NOT_SUPPORTED). Everything that should run inside a transaction, should then run within TransactionTemplate to manually define the transactional scope.

Since you're interacting with details that affect the entire transaction, you need to set up these before a transaction is started.

[ofir-popowski]

Thank you very much for explaining that, this fixed my issue! It's a bit clunky to use, but it works

I'm going to TL;DR just in case someone runs into this question, if you need to switch tenants in a @DataJpaTest:

1. Do not use the DependencyInjectionTestExecutionListener from the how-to guide
2. Annotate your class or test method with @Transactional(propagation = Propagation.NOT_SUPPORTED)
3. Add @Autowired TransactionTemplate
4. Switching the tenant should be done outside of a transaction
5. Use transactionTemplate.execute { ... } blocks if you need to assert on lazy-loaded collections like @OneToMany