Prevent access to EntityManager when looking up PersistenceProvider.

Signed-off-by: Ariel Morelli Andres <[email protected]>

Closes: #3425
Original pull request: #3885

Author: ari-spf

spring-data-jpa/src/main/java/org/springframework/data/jpa/provider/PersistenceProvider.java

@@ -56,6 +56,7 @@
  * @author Jens Schauder
  * @author Greg Turnquist
  * @author Yuriy Tsarkov
+ * @author Ariel Morelli Andres (Atlassian US, Inc.)
  */
 public enum PersistenceProvider implements QueryExtractor, ProxyIdAccessor, QueryComment {
 
@@ -316,15 +317,15 @@ public static PersistenceProvider fromEntityManager(EntityManager em) {
 	}
 
 	/**
-	 * Determines the {@link PersistenceProvider} from the given {@link EntityManager}. If no special one can be
+	 * Determines the {@link PersistenceProvider} from the given {@link EntityManagerFactory}. If no special one can be
 	 * determined {@link #GENERIC_JPA} will be returned.
 	 *
 	 * @param emf must not be {@literal null}.
 	 * @return will never be {@literal null}.
 	 */
 	public static PersistenceProvider fromEntityManagerFactory(EntityManagerFactory emf) {
 
-		Assert.notNull(emf, "EntityManager must not be null");
+		Assert.notNull(emf, "EntityManagerFactory must not be null");
 
 		Class<?> entityManagerType = emf.getPersistenceUnitUtil().getClass();
 		PersistenceProvider cachedProvider = CACHE.get(entityManagerType);

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/query/AbstractJpaQuery.java

@@ -24,7 +24,6 @@
 import jakarta.persistence.TypedQuery;
 
 import java.lang.reflect.Constructor;
-import java.util.AbstractMap;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.function.UnaryOperator;

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/support/Querydsl.java

@@ -40,7 +40,6 @@
 import com.querydsl.jpa.JPQLTemplates;
 import com.querydsl.jpa.impl.AbstractJPAQuery;
 import com.querydsl.jpa.impl.JPAQuery;
-import org.jspecify.annotations.Nullable;
 
 /**
  * Helper instance to ease access to Querydsl JPA query API.
@@ -87,7 +86,8 @@ public <T> AbstractJPAQuery<T, JPAQuery<T>> createQuery() {
 	 * Obtains the {@link JPQLTemplates} for the configured {@link EntityManager}. Can return {@literal null} to use the
 	 * default templates.
 	 *
-	 * @return the {@link JPQLTemplates} for the configured {@link EntityManager}, {@link JPQLTemplates#DEFAULT} by default.
+	 * @return the {@link JPQLTemplates} for the configured {@link EntityManager}, {@link JPQLTemplates#DEFAULT} by
+	 *         default.
 	 * @since 3.5
 	 */
 	public JPQLTemplates getTemplates() {

spring-data-jpa/src/test/java/org/springframework/data/jpa/repository/CrudMethodMetadataUnitTests.java

@@ -17,9 +17,6 @@
 
 import static org.mockito.Mockito.*;
 
-import java.util.Collections;
-import java.util.Map;
-
 import jakarta.persistence.EntityManager;
 import jakarta.persistence.EntityManagerFactory;
 import jakarta.persistence.LockModeType;
@@ -28,6 +25,9 @@
 import jakarta.persistence.criteria.CriteriaQuery;
 import jakarta.persistence.metamodel.Metamodel;
 
+import java.util.Collections;
+import java.util.Map;
+
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;

spring-data-jpa/src/test/java/org/springframework/data/jpa/repository/HibernateCurrentTenantIdentifierResolver.java

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2011-2025 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.jpa.repository;
+
+import java.util.Optional;
+
+import org.hibernate.context.spi.CurrentTenantIdentifierResolver;
+import org.jspecify.annotations.Nullable;
+
+/**
+ * {@code CurrentTenantIdentifierResolver} instance for testing
+ *
+ * @author Ariel Morelli Andres (Atlassian US, Inc.)
+ */
+public class HibernateCurrentTenantIdentifierResolver implements CurrentTenantIdentifierResolver<String> {
+	private static final ThreadLocal<@Nullable String> CURRENT_TENANT_IDENTIFIER = new ThreadLocal<>();
+
+	public static void setTenantIdentifier(String tenantIdentifier) {
+		CURRENT_TENANT_IDENTIFIER.set(tenantIdentifier);
+	}
+
+	public static void removeTenantIdentifier() {
+		CURRENT_TENANT_IDENTIFIER.remove();
+	}
+
+	@Override
+	public String resolveCurrentTenantIdentifier() {
+		return Optional.ofNullable(CURRENT_TENANT_IDENTIFIER.get())
+				.orElseThrow(() -> new IllegalArgumentException("Could not resolve current tenant identifier"));
+	}
+
+	@Override
+	public boolean validateExistingCurrentSessions() {
+		return true;
+	}
+}

spring-data-jpa/src/test/java/org/springframework/data/jpa/repository/HibernateMultitenancyTests.java

@@ -0,0 +1,88 @@
+/*
+ * Copyright 2011-2025 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.jpa.repository;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.assertj.core.api.Assumptions.*;
+
+import java.util.List;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.FilterType;
+import org.springframework.context.annotation.ImportResource;
+import org.springframework.data.jpa.domain.sample.Role;
+import org.springframework.data.jpa.provider.PersistenceProvider;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+import org.springframework.data.jpa.repository.sample.RoleRepository;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+import org.springframework.transaction.annotation.Transactional;
+
+import jakarta.persistence.EntityManager;
+
+/**
+ * Tests for repositories that use multi-tenancy. This tests verifies that repositories can be created an injected
+ * despite not having a tenant available at creation time
+ *
+ * @author Ariel Morelli Andres (Atlassian US, Inc.)
+ */
+@ExtendWith(SpringExtension.class)
+@ContextConfiguration()
+class HibernateMultitenancyTests {
+
+	@Autowired RoleRepository roleRepository;
+	@Autowired EntityManager em;
+
+	@AfterEach
+	void tearDown() {
+		HibernateCurrentTenantIdentifierResolver.removeTenantIdentifier();
+	}
+
+	@Test
+	void testPersistenceProviderFromFactoryWithoutTenant() {
+		PersistenceProvider provider = PersistenceProvider.fromEntityManagerFactory(em.getEntityManagerFactory());
+		assumeThat(provider).isEqualTo(PersistenceProvider.HIBERNATE);
+	}
+
+	@Test
+	void testRepositoryWithTenant() {
+		HibernateCurrentTenantIdentifierResolver.setTenantIdentifier("tenant-id");
+		assertThatNoException().isThrownBy(() -> roleRepository.findAll());
+	}
+
+	@Test
+	void testRepositoryWithoutTenantFails() {
+		assertThatThrownBy(() -> roleRepository.findAll()).isInstanceOf(RuntimeException.class);
+	}
+
+	@Transactional
+	List<Role> insertAndQuery() {
+		roleRepository.save(new Role("DRUMMER"));
+		roleRepository.flush();
+		return roleRepository.findAll();
+	}
+
+	@ImportResource({ "classpath:multitenancy-test.xml" })
+	@Configuration
+	@EnableJpaRepositories(basePackageClasses = HibernateRepositoryTests.class, considerNestedRepositories = true,
+			includeFilters = @ComponentScan.Filter(classes = { RoleRepository.class }, type = FilterType.ASSIGNABLE_TYPE))
+	static class TestConfig {}
+}

spring-data-jpa/src/test/java/org/springframework/data/jpa/repository/query/AbstractStringBasedJpaQueryUnitTests.java

@@ -18,6 +18,7 @@
 import static org.mockito.Mockito.*;
 
 import jakarta.persistence.EntityManager;
+import jakarta.persistence.EntityManagerFactory;
 import jakarta.persistence.metamodel.Metamodel;
 
 import java.lang.reflect.Method;
@@ -52,6 +53,7 @@
  *
  * @author Christoph Strobl
  * @author Mark Paluch
+ * @author Ariel Morelli Andres
  */
 class AbstractStringBasedJpaQueryUnitTests {
 
@@ -137,10 +139,12 @@ static class InvocationCapturingStringQueryStub extends AbstractStringBasedJpaQu
 				public EntityManager get() {
 
 					EntityManager em = Mockito.mock(EntityManager.class);
+					EntityManagerFactory emf = Mockito.mock(EntityManagerFactory.class);
 
 					Metamodel meta = mock(Metamodel.class);
 					when(em.getMetamodel()).thenReturn(meta);
 					when(em.getDelegate()).thenReturn(new Object()); // some generic jpa
+					when(em.getEntityManagerFactory()).thenReturn(emf);
 
 					return em;
 				}

spring-data-jpa/src/test/java/org/springframework/data/jpa/repository/query/NamedQueryUnitTests.java

@@ -36,7 +36,6 @@
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.jpa.provider.QueryExtractor;
-import org.springframework.data.jpa.repository.QueryRewriter;
 import org.springframework.data.projection.ProjectionFactory;
 import org.springframework.data.projection.SpelAwareProxyProjectionFactory;
 import org.springframework.data.repository.core.RepositoryMetadata;

spring-data-jpa/src/test/java/org/springframework/data/jpa/repository/query/NativeJpaQueryUnitTests.java

@@ -71,11 +71,9 @@ void shouldApplySorting() {
 				queryExtractor);
 
 		NativeJpaQuery query = new NativeJpaQuery(queryMethod, em, queryMethod.getRequiredDeclaredQuery(),
-				queryMethod.getDeclaredCountQuery(),
-				new JpaQueryConfiguration(QueryRewriterProvider.simple(), QueryEnhancerSelector.DEFAULT_SELECTOR,
-						ValueExpressionDelegate.create(), EscapeCharacter.DEFAULT));
-		QueryProvider sql = query.getSortedQuery(Sort.by("foo", "bar"),
-				queryMethod.getResultProcessor().getReturnedType());
+				queryMethod.getDeclaredCountQuery(), new JpaQueryConfiguration(QueryRewriterProvider.simple(),
+						QueryEnhancerSelector.DEFAULT_SELECTOR, ValueExpressionDelegate.create(), EscapeCharacter.DEFAULT));
+		QueryProvider sql = query.getSortedQuery(Sort.by("foo", "bar"), queryMethod.getResultProcessor().getReturnedType());
 
 		assertThat(sql.getQueryString()).isEqualTo("SELECT e FROM Employee e order by e.foo asc, e.bar asc");
 	}

spring-data-jpa/src/test/java/org/springframework/data/jpa/repository/support/JpaRepositoryFragmentsContributorUnitTests.java

@@ -19,6 +19,7 @@
 import static org.mockito.Mockito.*;
 
 import jakarta.persistence.EntityManager;
+import jakarta.persistence.EntityManagerFactory;
 
 import java.util.Iterator;
 
@@ -40,6 +41,7 @@
  * Unit tests for {@link JpaRepositoryFragmentsContributor}.
  *
  * @author Mark Paluch
+ * @author Ariel Morelli Andres
  */
 class JpaRepositoryFragmentsContributorUnitTests {
 
@@ -53,7 +55,9 @@ void composedContributorShouldCreateFragments() {
 		when(entityPathResolver.createPath(any())).thenReturn((EntityPath) QCustomer.customer);
 
 		EntityManager entityManager = mock(EntityManager.class);
+		EntityManagerFactory emf = mock(EntityManagerFactory.class);
 		when(entityManager.getDelegate()).thenReturn(entityManager);
+		when(entityManager.getEntityManagerFactory()).thenReturn(emf);
 
 		RepositoryComposition.RepositoryFragments fragments = contributor.contribute(
 				AbstractRepositoryMetadata.getMetadata(QuerydslUserRepository.class),

spring-data-jpa/src/test/java/org/springframework/data/jpa/repository/support/SimpleJpaRepositoryUnitTests.java

@@ -31,7 +31,6 @@
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.util.Arrays;
-import java.util.Optional;
 import java.util.stream.Stream;
 
 import org.junit.jupiter.api.BeforeEach;
@@ -44,7 +43,6 @@
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.mockito.junit.jupiter.MockitoSettings;
 import org.mockito.quality.Strictness;
-
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.jpa.domain.Specification;
 import org.springframework.data.jpa.domain.sample.User;
@@ -61,6 +59,7 @@
  * @author Jens Schauder
  * @author Greg Turnquist
  * @author Yanming Zhou
+ * @author Ariel Morelli Andres (Atlassian US, Inc.)
  */
 @ExtendWith(MockitoExtension.class)
 @MockitoSettings(strictness = Strictness.LENIENT)
@@ -85,6 +84,9 @@ class SimpleJpaRepositoryUnitTests {
 	void setUp() {
 
 		when(em.getDelegate()).thenReturn(em);
+		when(em.getEntityManagerFactory()).thenReturn(entityManagerFactory);
+
+		when(entityManagerFactory.getPersistenceUnitUtil()).thenReturn(persistenceUnitUtil);
 
 		when(information.getJavaType()).thenReturn(User.class);
 		when(em.getCriteriaBuilder()).thenReturn(builder);

spring-data-jpa/src/test/resources/multitenancy-test.xml

@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xmlns:jdbc="http://www.springframework.org/schema/jdbc"
+	xsi:schemaLocation="http://www.springframework.org/schema/jdbc https://www.springframework.org/schema/jdbc/spring-jdbc.xsd
+		http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd">
+	
+	<import resource="hibernate.xml" />
+	
+	<bean id="entityManagerFactory"
+		class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
+		<property name="dataSource" ref="dataSource" />
+		<property name="persistenceUnitName" value="spring-data-jpa" />
+		<property name="jpaVendorAdapter" ref="vendorAdaptor" />
+		<property name="jpaProperties">
+			<props>
+				<prop key="hibernate.tenant_identifier_resolver">
+					org.springframework.data.jpa.repository.HibernateCurrentTenantIdentifierResolver
+				</prop>
+			</props>
+		</property>
+	</bean>
+	
+	<bean id="abstractVendorAdaptor" abstract="true">
+		<property name="generateDdl" value="true" />
+		<property name="database" value="HSQL" />
+	</bean>
+	
+	<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
+		<property name="entityManagerFactory" ref="entityManagerFactory" />
+	</bean>	
+
+	<bean name="sampleEvaluationContextExtension" class="org.springframework.data.jpa.repository.sample.SampleEvaluationContextExtension"/>
+	
+	<jdbc:embedded-database id="dataSource" type="HSQL" generate-name="true">
+		<jdbc:script execution="INIT" separator="/;" location="classpath:scripts/hsqldb-init.sql"/>
+		<jdbc:script execution="INIT" separator="/;" location="classpath:scripts/schema-stored-procedures.sql"/>
+	</jdbc:embedded-database>
+
+</beans>