Polishing.

Simplify tests.

See #4029
Original pull request: #4030

Author: mp911de

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

@@ -15,31 +15,38 @@
  */
 package org.springframework.data.jpa.repository.aot;
 
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.when;
+import static org.assertj.core.api.Assertions.*;
+import static org.assertj.core.api.InstanceOfAssertFactories.*;
+import static org.mockito.Mockito.*;
 
+import jakarta.persistence.Entity;
 import jakarta.persistence.EntityManagerFactory;
+import jakarta.persistence.Id;
+
+import java.lang.reflect.Method;
+import java.util.Collection;
+import java.util.Collections;
 
-import org.assertj.core.api.InstanceOfAssertFactories;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
-import org.springframework.core.annotation.MergedAnnotation;
+
+import org.springframework.core.annotation.MergedAnnotations;
+import org.springframework.data.jpa.provider.QueryExtractor;
 import org.springframework.data.jpa.repository.Query;
-import org.springframework.data.jpa.repository.query.JpaEntityMetadata;
 import org.springframework.data.jpa.repository.query.JpaQueryMethod;
 import org.springframework.data.jpa.repository.query.QueryEnhancerSelector;
-import org.springframework.data.jpa.repository.support.JpaEntityInformation;
 import org.springframework.data.projection.SpelAwareProxyProjectionFactory;
+import org.springframework.data.repository.Repository;
+import org.springframework.data.repository.config.AotRepositoryInformation;
 import org.springframework.data.repository.config.RepositoryConfigurationSource;
 import org.springframework.data.repository.core.RepositoryInformation;
-import org.springframework.data.repository.query.ReturnedType;
+import org.springframework.data.repository.core.support.AbstractRepositoryMetadata;
 
 /**
  * Unit tests for {@link QueriesFactory}.
  *
  * @author Christoph Strobl
+ * @author Mark Paluch
  */
 class QueriesFactoryUnitTests {
 
@@ -48,36 +55,42 @@ class QueriesFactoryUnitTests {
 	@BeforeEach
 	void setUp() {
 
-		RepositoryConfigurationSource configSource = Mockito.mock(RepositoryConfigurationSource.class);
-		EntityManagerFactory entityManagerFactory = Mockito.mock(EntityManagerFactory.class);
+		RepositoryConfigurationSource configSource = mock(RepositoryConfigurationSource.class);
+		EntityManagerFactory entityManagerFactory = mock(EntityManagerFactory.class);
 
 		factory = new QueriesFactory(configSource, entityManagerFactory, this.getClass().getClassLoader());
 	}
 
 	@Test // GH-4029
-	@SuppressWarnings({ "rawtypes", "unchecked" })
-	void stringQueryShouldResolveEntityNameFromJakartaAnnotationIfPresent() {
-
-		RepositoryInformation repositoryInformation = Mockito.mock(RepositoryInformation.class);
-		JpaEntityMetadata<?> entityMetadata = Mockito.mock(JpaEntityInformation.class);
-		when(entityMetadata.getEntityName()).thenReturn("CustomNamed");
+	void stringQueryShouldResolveEntityNameFromJakartaAnnotationIfPresent() throws NoSuchMethodException {
 
-		MergedAnnotation<Query> queryAnnotation = Mockito.mock(MergedAnnotation.class);
-		when(queryAnnotation.isPresent()).thenReturn(true);
-		when(queryAnnotation.getString(eq("value"))).thenReturn("select t from #{#entityName} t");
-		when(queryAnnotation.getBoolean(eq("nativeQuery"))).thenReturn(false);
-		when(queryAnnotation.getString("countQuery")).thenReturn("select count(t) from #{#entityName} t");
+		RepositoryInformation repositoryInformation = new AotRepositoryInformation(
+				AbstractRepositoryMetadata.getMetadata(MyRepository.class), MyRepository.class, Collections.emptyList());
 
-		JpaQueryMethod queryMethod = Mockito.mock(JpaQueryMethod.class);
-		when(queryMethod.getEntityInformation()).thenReturn((JpaEntityMetadata) entityMetadata);
+		Method method = MyRepository.class.getMethod("someFind");
+		JpaQueryMethod queryMethod = new JpaQueryMethod(method, repositoryInformation,
+				new SpelAwareProxyProjectionFactory(), mock(QueryExtractor.class));
 
 		AotQueries generatedQueries = factory.createQueries(repositoryInformation,
-				ReturnedType.of(Object.class, Object.class, new SpelAwareProxyProjectionFactory()),
-				QueryEnhancerSelector.DEFAULT_SELECTOR, queryAnnotation, queryMethod);
+				queryMethod.getResultProcessor().getReturnedType(), QueryEnhancerSelector.DEFAULT_SELECTOR,
+				MergedAnnotations.from(method).get(Query.class), queryMethod);
 
-		assertThat(generatedQueries.result()).asInstanceOf(InstanceOfAssertFactories.type(StringAotQuery.class))
+		assertThat(generatedQueries.result()).asInstanceOf(type(StringAotQuery.class))
 				.extracting(StringAotQuery::getQueryString).isEqualTo("select t from CustomNamed t");
-		assertThat(generatedQueries.count()).asInstanceOf(InstanceOfAssertFactories.type(StringAotQuery.class))
+		assertThat(generatedQueries.count()).asInstanceOf(type(StringAotQuery.class))
 				.extracting(StringAotQuery::getQueryString).isEqualTo("select count(t) from CustomNamed t");
 	}
+
+	interface MyRepository extends Repository<MyEntity, Long> {
+
+		@Query("select t from #{#entityName} t")
+		Collection<MyEntity> someFind();
+	}
+
+	@Entity(name = "CustomNamed")
+	static class MyEntity {
+
+		@Id Long id;
+
+	}
 }