GH-2139 - Fix classcast exception for paginated projections.

We used the ResultProcessor wrong. It must be applied on the whole page
or slice, and not on the intermediate result (collection).

This closes #2139.

Author: michael-simons

src/main/java/org/springframework/data/neo4j/repository/query/AbstractNeo4jQuery.java

@@ -94,18 +94,15 @@ public final Object execute(Object[] parameters) {
 					(EntityInstanceWithSource) OptionalUnwrappingConverter.INSTANCE.convert(source));
 		}
 
-		Object processedResult = resultProcessor.processResult(rawResult, preparingConverter);
-
 		if (queryMethod.isPageQuery()) {
-			return createPage(parameterAccessor, (List<?>) processedResult);
+			rawResult = createPage(parameterAccessor, (List<?>) rawResult);
 		} else if (queryMethod.isSliceQuery()) {
-			return createSlice(incrementLimit, parameterAccessor, (List<?>) processedResult);
-		} else {
-			return processedResult;
+			rawResult = createSlice(incrementLimit, parameterAccessor, (List<?>) rawResult);
 		}
+		return resultProcessor.processResult(rawResult, preparingConverter);
 	}
 
-	private Page<?> createPage(Neo4jParameterAccessor parameterAccessor, List<?> processedResult) {
+	private Page<?> createPage(Neo4jParameterAccessor parameterAccessor, List<?> rawResult) {
 
 		LongSupplier totalSupplier = () -> {
 
@@ -115,26 +112,26 @@ private Page<?> createPage(Neo4jParameterAccessor parameterAccessor, List<?> pro
 
 			return neo4jOperations.toExecutableQuery(countQuery).getRequiredSingleResult();
 		};
-		return PageableExecutionUtils.getPage(processedResult, parameterAccessor.getPageable(), totalSupplier);
+		return PageableExecutionUtils.getPage(rawResult, parameterAccessor.getPageable(), totalSupplier);
 	}
 
-	private Slice<?> createSlice(boolean incrementLimit, Neo4jParameterAccessor parameterAccessor, List<?> processedResults) {
+	private Slice<?> createSlice(boolean incrementLimit, Neo4jParameterAccessor parameterAccessor, List<?> rawResult) {
 
 		Pageable pageable = parameterAccessor.getPageable();
 
 		if (incrementLimit) {
-			return new SliceImpl<>(
-					processedResults.subList(0, Math.min(processedResults.size(), pageable.getPageSize())),
+			 return new SliceImpl<>(
+					rawResult.subList(0, Math.min(rawResult.size(), pageable.getPageSize())),
 					PageRequest.of(pageable.getPageNumber(), pageable.getPageSize(), pageable.getSort()),
-					processedResults.size() > pageable.getPageSize()
+					rawResult.size() > pageable.getPageSize()
 			);
 		} else {
 			PreparedQuery<Long> countQuery = getCountQuery(parameterAccessor)
 					.orElseGet(() -> prepareQuery(Long.class, Collections.emptyList(), parameterAccessor,
 							Neo4jQueryType.COUNT, null, UnaryOperator.identity()));
 			long total = neo4jOperations.toExecutableQuery(countQuery).getRequiredSingleResult();
 			return new SliceImpl<>(
-					processedResults,
+					rawResult,
 					pageable,
 					pageable.getOffset() + pageable.getPageSize() < total
 			);

src/test/java/org/springframework/data/neo4j/integration/imperative/ProjectionIT.java

@@ -17,16 +17,24 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 
+import java.util.AbstractMap;
 import java.util.Collection;
+import java.util.Map;
 
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.Session;
 import org.neo4j.driver.Transaction;
+import org.neo4j.driver.Values;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Slice;
+import org.springframework.data.domain.Sort;
 import org.springframework.data.neo4j.config.AbstractNeo4jConfig;
 import org.springframework.data.neo4j.integration.shared.common.NamesOnly;
 import org.springframework.data.neo4j.integration.shared.common.NamesOnlyDto;
@@ -40,11 +48,13 @@
 
 /**
  * @author Gerrit Meier
+ * @author Michael J. Simons
  */
 @Neo4jIntegrationTest
 class ProjectionIT {
 
 	private static final String FIRST_NAME = "Hans";
+	private static final String FIRST_NAME2 = "Lieschen";
 	private static final String LAST_NAME = "Mueller";
 	private static final String CITY = "Braunschweig";
 
@@ -64,8 +74,15 @@ void setup() {
 
 		transaction.run("MATCH (n) detach delete n");
 
-		transaction.run("CREATE (:Person{firstName:'" + FIRST_NAME + "', lastName:'" + LAST_NAME + "'})" + "-[:LIVES_AT]->"
-				+ "(:Address{city:'" + CITY + "'})");
+		for (Map.Entry<String, String> person : new Map.Entry[] {
+				new AbstractMap.SimpleEntry(FIRST_NAME, LAST_NAME),
+				new AbstractMap.SimpleEntry(FIRST_NAME2, LAST_NAME),
+		}) {
+			transaction.run(" MERGE (address:Address{city: $city})"
+							+ "CREATE (:Person{firstName: $firstName, lastName: $lastName})"
+							+ "-[:LIVES_AT]-> (address)",
+					Values.parameters("firstName", person.getKey(), "lastName", person.getValue(), "city", CITY));
+		}
 
 		transaction.commit();
 		transaction.close();
@@ -74,16 +91,14 @@ void setup() {
 
 	@Test
 	void loadNamesOnlyProjection(@Autowired ProjectionPersonRepository repository) {
-		Collection<NamesOnly> people = repository.findByLastName(LAST_NAME);
-		assertThat(people).hasSize(1);
 
-		NamesOnly person = people.iterator().next();
-		assertThat(person.getFirstName()).isEqualTo(FIRST_NAME);
-		assertThat(person.getLastName()).isEqualTo(LAST_NAME);
+		Collection<NamesOnly> people = repository.findByLastName(LAST_NAME);
+		assertThat(people).hasSize(2);
 
-		String expectedFullName = FIRST_NAME + " " + LAST_NAME;
-		assertThat(person.getFullName()).isEqualTo(expectedFullName);
+		assertThat(people).extracting(NamesOnly::getFirstName).containsExactlyInAnyOrder(FIRST_NAME, FIRST_NAME2);
+		assertThat(people).extracting(NamesOnly::getLastName).containsOnly(LAST_NAME);
 
+		assertThat(people).extracting(NamesOnly::getFullName).containsExactlyInAnyOrder(FIRST_NAME + " " + LAST_NAME, FIRST_NAME2 + " " + LAST_NAME);
 	}
 
 	@Test
@@ -153,10 +168,34 @@ void findDynamicProjectionForNamesOnlyDto(@Autowired ProjectionPersonRepository
 
 	}
 
+	@Test // GH-2139
+	void projectionsShouldBePaginatable(@Autowired ProjectionPersonRepository repository) {
+
+		Page<NamesOnly> people = repository.findAllProjectedBy(PageRequest.of(1, 1, Sort.by("firstName").descending()));
+		assertThat(people.hasPrevious()).isTrue();
+		assertThat(people.hasNext()).isFalse();
+		assertThat(people).hasSize(1);
+		assertThat(people).extracting(NamesOnly::getFullName).containsExactly(FIRST_NAME + " " + LAST_NAME);
+	}
+
+	@Test // GH-2139
+	void projectionsShouldBeSliceable(@Autowired ProjectionPersonRepository repository) {
+
+		Slice<NamesOnly> people = repository.findSliceProjectedBy(PageRequest.of(1, 1, Sort.by("firstName").descending()));
+		assertThat(people.hasPrevious()).isTrue();
+		assertThat(people.hasNext()).isFalse();
+		assertThat(people).hasSize(1);
+		assertThat(people).extracting(NamesOnly::getFullName).containsExactly(FIRST_NAME + " " + LAST_NAME);
+	}
+
 	interface ProjectionPersonRepository extends Neo4jRepository<Person, Long> {
 
 		Collection<NamesOnly> findByLastName(String lastName);
 
+		Page<NamesOnly> findAllProjectedBy(Pageable pageable);
+
+		Slice<NamesOnly> findSliceProjectedBy(Pageable pageable);
+
 		Collection<PersonSummary> findByFirstName(String firstName);
 
 		Collection<NamesOnlyDto> findByFirstNameAndLastName(String firstName, String lastName);
@@ -175,5 +214,4 @@ public Driver driver() {
 		}
 
 	}
-
 }

src/test/kotlin/org/springframework/data/neo4j/integration/shared/common/KotlinPerson.kt

@@ -28,8 +28,10 @@ import org.springframework.data.neo4j.core.schema.TargetNode
  * @author Michael J. Simons
  */
 @Node
-data class KotlinPerson(@Id @GeneratedValue val id: Long, val name: String,
-                        @Relationship("WORKS_IN") val clubs:List<KotlinClubRelationship>)
+data class KotlinPerson(@Id @GeneratedValue val id: Long?, val name: String,
+						@Relationship("WORKS_IN") val clubs: List<KotlinClubRelationship>) {
+	constructor(name: String, clubs: List<KotlinClubRelationship>) : this(null, name, clubs)
+}
 
 @RelationshipProperties
 data class KotlinClubRelationship(@Id @GeneratedValue val id: Long, val since: Int, @TargetNode val club: KotlinClub)