GH-1906 - Ensure that self referential path structures work correctly.

This closes #1906.

Author: michael-simons

src/test/java/org/springframework/data/neo4j/integration/movies/imperative/AdvancedMappingIT.java

@@ -17,13 +17,12 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 
-import java.io.BufferedReader;
 import java.io.IOException;
-import java.io.InputStreamReader;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
@@ -37,7 +36,10 @@
 import org.springframework.data.neo4j.config.AbstractNeo4jConfig;
 import org.springframework.data.neo4j.core.Neo4jTemplate;
 import org.springframework.data.neo4j.integration.movies.shared.Actor;
+import org.springframework.data.neo4j.integration.movies.shared.CypherUtils;
 import org.springframework.data.neo4j.integration.movies.shared.Movie;
+import org.springframework.data.neo4j.integration.movies.shared.Organisation;
+import org.springframework.data.neo4j.integration.movies.shared.Partner;
 import org.springframework.data.neo4j.integration.movies.shared.Person;
 import org.springframework.data.neo4j.repository.Neo4jRepository;
 import org.springframework.data.neo4j.repository.config.EnableNeo4jRepositories;
@@ -61,37 +63,16 @@ class AdvancedMappingIT {
 	@BeforeAll
 	static void setupData(@Autowired Driver driver) throws IOException {
 
-		try (BufferedReader moviesReader = new BufferedReader(
-				new InputStreamReader(AdvancedMappingIT.class.getResourceAsStream("/data/movies.cypher")));
-				Session session = driver.session()) {
+		try (Session session = driver.session()) {
 			session.run("MATCH (n) DETACH DELETE n").consume();
-			String moviesCypher = moviesReader.lines().collect(Collectors.joining(" "));
-			session.run(moviesCypher).consume();
-			session.run("MATCH (l1:Person {name: 'Lilly Wachowski'})\n"
-						+ "MATCH (l2:Person {name: 'Lana Wachowski'})\n"
-						+ "CREATE (l1) - [s:IS_SIBLING_OF] -> (l2)\n"
-						+ "RETURN *").consume();
-			session.run("MATCH (m1:Movie {title: 'The Matrix'})\n"
-						+ "MATCH (m2:Movie {title: 'The Matrix Reloaded'})\n"
-						+ "MATCH (m3:Movie {title: 'The Matrix Revolutions'})\n"
-						+ "CREATE (m2) - [:IS_SEQUEL_OF] -> (m1)\n"
-						+ "CREATE (m3) - [:IS_SEQUEL_OF] -> (m2)\n"
-						+ "RETURN *").consume();
-			session.run("MATCH (m1:Movie {title: 'The Matrix'})\n"
-						+ "MATCH (m2:Movie {title: 'The Matrix Reloaded'})\n"
-						+ "CREATE (p:Person {name: 'Gloria Foster'})\n"
-						+ "CREATE (p) -[:ACTED_IN {roles: ['The Oracle']}] -> (m1)\n"
-						+ "CREATE (p) -[:ACTED_IN {roles: ['The Oracle']}] -> (m2)\n"
-						+ "RETURN *").consume();
-			session.run("MATCH (m3:Movie {title: 'The Matrix Revolutions'})\n"
-						+ "CREATE (p:Person {name: 'Mary Alice'})\n"
-						+ "CREATE (p) -[:ACTED_IN {roles: ['The Oracle']}] -> (m3)\n"
-						+ "RETURN *").consume();
+			CypherUtils.loadCypherFromResource("/data/movies.cypher", session);
+			CypherUtils.loadCypherFromResource("/data/orgstructure.cypher", session);
 		}
 	}
 
 	interface MovieProjectionWithActorProjection {
 		String getTitle();
+
 		List<ActorProjection> getActors();
 
 		interface ActorProjection {
@@ -141,6 +122,38 @@ interface MovieRepository extends Neo4jRepository<Movie, String> {
 		List<Movie> customPathQueryMoviesFind(@Param("title") String title);
 	}
 
+	@Test // GH-1906
+	void nestedSelfRelationshipsFromCustomQueryShouldWork(@Autowired Neo4jTemplate template) {
+
+		Optional<Partner> optionalPartner = template.findOne(
+				"MATCH p=(partner:Partner {code: $partnerCode})-[:CHILD_ORGANISATIONS*0..4]->(org:Organisation) \n"
+				+ "UNWIND nodes(p) as node UNWIND relationships(p) as rel\n"
+				+ "RETURN partner, collect(distinct node), collect(distinct rel)",
+				Collections.singletonMap("partnerCode", "partner-one"), Partner.class);
+
+		assertThat(optionalPartner).hasValueSatisfying(p -> {
+			assertThat(p.getName()).isEqualTo("partner one");
+
+			assertThat(p.getOrganisations()).hasSize(1);
+			Organisation org1 = p.getOrganisations().get(0);
+
+			assertThat(org1.getCode()).isEqualTo("org-1");
+			Map<String, Organisation> org1Childs = org1.getOrganisations().stream()
+					.collect(Collectors.toMap(Organisation::getCode, Function.identity()));
+			assertThat(org1Childs).hasSize(2);
+
+			assertThat(org1Childs).hasEntrySatisfying("org-2", o -> assertThat(o.getOrganisations()).hasSize(1));
+			assertThat(org1Childs).hasEntrySatisfying("org-6", o -> assertThat(o.getOrganisations()).isEmpty());
+
+			Organisation org3 = org1Childs.get("org-2").getOrganisations().get(0);
+			assertThat(org3.getCode()).isEqualTo("org-3");
+
+			Map<String, Organisation> org3Childs = org3.getOrganisations().stream()
+					.collect(Collectors.toMap(Organisation::getCode, Function.identity()));
+			assertThat(org3Childs).containsKeys("org-4", "org-5");
+		});
+	}
+
 	@Test // GH-2117
 	void bothCyclicAndNonCyclicRelationshipsAreExcludedFromProjections(@Autowired MovieRepository movieRepository) {
 
@@ -164,12 +177,14 @@ void bothCyclicAndNonCyclicRelationshipsAreExcludedFromDTOProjections(@Autowired
 	}
 
 	@Test // GH-2117
-	void bothCyclicAndNonCyclicRelationshipsAreExcludedFromProjectionsWithProjections(@Autowired MovieRepository movieRepository) {
+	void bothCyclicAndNonCyclicRelationshipsAreExcludedFromProjectionsWithProjections(
+			@Autowired MovieRepository movieRepository) {
 
 		// The movie domain is a good fit for this test
 		// as the cyclic dependencies is pretty slow to retrieve from Neo4j
 		// this does OOM in most setups.
-		MovieProjectionWithActorProjection projection = movieRepository.findProjectionWithProjectionByTitle("The Matrix");
+		MovieProjectionWithActorProjection projection = movieRepository
+				.findProjectionWithProjectionByTitle("The Matrix");
 		assertThat(projection.getTitle()).isNotNull();
 		assertThat(projection.getActors()).isNotEmpty();
 	}
@@ -192,15 +207,18 @@ void bothStartAndEndNodeOfPathsMustBeLookedAt(@Autowired Neo4jTemplate template)
 	@Test // GH-2114
 	void directionAndTypeLessPathMappingShouldWork(@Autowired Neo4jTemplate template) {
 
-		List<Person> people = template.findAll("MATCH p=(:Person)-[]-(:Person) RETURN p", Collections.emptyMap(), Person.class);
+		List<Person> people = template
+				.findAll("MATCH p=(:Person)-[]-(:Person) RETURN p", Collections.emptyMap(), Person.class);
 		assertThat(people).hasSize(6);
 	}
 
 	@Test // GH-2114
 	void mappingOfAPathWithOddNumberOfElementsShouldWorkFromStartToEnd(@Autowired Neo4jTemplate template) {
 
 		Map<String, Movie> movies = template
-				.findAll("MATCH p=shortestPath((:Person {name: 'Mary Alice'})-[*]-(:Person {name: 'Emil Eifrem'})) RETURN p", Collections.emptyMap(), Movie.class)
+				.findAll(
+						"MATCH p=shortestPath((:Person {name: 'Mary Alice'})-[*]-(:Person {name: 'Emil Eifrem'})) RETURN p",
+						Collections.emptyMap(), Movie.class)
 				.stream().collect(Collectors.toMap(Movie::getTitle, Function.identity()));
 		assertThat(movies).hasSize(3);
 
@@ -217,7 +235,9 @@ void mappingOfAPathWithOddNumberOfElementsShouldWorkFromStartToEnd(@Autowired Ne
 	void mappingOfAPathWithEventNumberOfElementsShouldWorkFromStartToEnd(@Autowired Neo4jTemplate template) {
 
 		Map<String, Movie> movies = template
-				.findAll("MATCH p=shortestPath((:Movie {title: 'The Matrix Revolutions'})-[*]-(:Person {name: 'Emil Eifrem'})) RETURN p", Collections.emptyMap(), Movie.class)
+				.findAll(
+						"MATCH p=shortestPath((:Movie {title: 'The Matrix Revolutions'})-[*]-(:Person {name: 'Emil Eifrem'})) RETURN p",
+						Collections.emptyMap(), Movie.class)
 				.stream().collect(Collectors.toMap(Movie::getTitle, Function.identity()));
 		assertThat(movies).hasSize(3);
 

src/test/java/org/springframework/data/neo4j/integration/movies/reactive/ReactiveAdvancedMappingIT.java

@@ -15,6 +15,21 @@
  */
 package org.springframework.data.neo4j.integration.movies.reactive;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Test;
@@ -26,6 +41,7 @@
 import org.springframework.data.neo4j.config.AbstractReactiveNeo4jConfig;
 import org.springframework.data.neo4j.core.ReactiveNeo4jTemplate;
 import org.springframework.data.neo4j.integration.movies.shared.Actor;
+import org.springframework.data.neo4j.integration.movies.shared.CypherUtils;
 import org.springframework.data.neo4j.integration.movies.shared.Movie;
 import org.springframework.data.neo4j.integration.movies.shared.Person;
 import org.springframework.data.neo4j.repository.ReactiveNeo4jRepository;
@@ -35,25 +51,10 @@
 import org.springframework.data.neo4j.test.Neo4jIntegrationTest;
 import org.springframework.data.repository.query.Param;
 import org.springframework.transaction.annotation.EnableTransactionManagement;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-import reactor.test.StepVerifier;
-
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.function.Function;
-import java.util.stream.Collectors;
-
-import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * @author Gerrit Meier
+ * @author Michael J. Simons
  */
 @Tag(Neo4jExtension.NEEDS_REACTIVE_SUPPORT)
 @Neo4jIntegrationTest
@@ -64,32 +65,9 @@ class ReactiveAdvancedMappingIT {
 	@BeforeAll
 	static void setupData(@Autowired Driver driver) throws IOException {
 
-		try (BufferedReader moviesReader = new BufferedReader(
-				new InputStreamReader(ReactiveAdvancedMappingIT.class.getResourceAsStream("/data/movies.cypher")));
-             Session session = driver.session()) {
+		try (Session session = driver.session()) {
 			session.run("MATCH (n) DETACH DELETE n").consume();
-			String moviesCypher = moviesReader.lines().collect(Collectors.joining(" "));
-			session.run(moviesCypher).consume();
-			session.run("MATCH (l1:Person {name: 'Lilly Wachowski'})\n"
-						+ "MATCH (l2:Person {name: 'Lana Wachowski'})\n"
-						+ "CREATE (l1) - [s:IS_SIBLING_OF] -> (l2)\n"
-						+ "RETURN *").consume();
-			session.run("MATCH (m1:Movie {title: 'The Matrix'})\n"
-						+ "MATCH (m2:Movie {title: 'The Matrix Reloaded'})\n"
-						+ "MATCH (m3:Movie {title: 'The Matrix Revolutions'})\n"
-						+ "CREATE (m2) - [:IS_SEQUEL_OF] -> (m1)\n"
-						+ "CREATE (m3) - [:IS_SEQUEL_OF] -> (m2)\n"
-						+ "RETURN *").consume();
-			session.run("MATCH (m1:Movie {title: 'The Matrix'})\n"
-						+ "MATCH (m2:Movie {title: 'The Matrix Reloaded'})\n"
-						+ "CREATE (p:Person {name: 'Gloria Foster'})\n"
-						+ "CREATE (p) -[:ACTED_IN {roles: ['The Oracle']}] -> (m1)\n"
-						+ "CREATE (p) -[:ACTED_IN {roles: ['The Oracle']}] -> (m2)\n"
-						+ "RETURN *").consume();
-			session.run("MATCH (m3:Movie {title: 'The Matrix Revolutions'})\n"
-						+ "CREATE (p:Person {name: 'Mary Alice'})\n"
-						+ "CREATE (p) -[:ACTED_IN {roles: ['The Oracle']}] -> (m3)\n"
-						+ "RETURN *").consume();
+			CypherUtils.loadCypherFromResource("/data/movies.cypher", session);
 		}
 	}
 

src/test/java/org/springframework/data/neo4j/integration/movies/shared/CypherUtils.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2011-2021 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.neo4j.integration.movies.shared;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.stream.Collectors;
+
+import org.neo4j.driver.Session;
+
+/**
+ * @author Michael J. Simons
+ */
+public final class CypherUtils {
+
+	public static void loadCypherFromResource(String resource, Session session) throws IOException {
+		try (BufferedReader moviesReader = new BufferedReader(
+				new InputStreamReader(CypherUtils.class.getResourceAsStream(resource)))) {
+			for (String statement : moviesReader.lines().collect(Collectors.joining(" ")).split(";")) {
+				session.run(statement).consume();
+			}
+		}
+	}
+
+	private CypherUtils() {
+	}
+}

src/test/java/org/springframework/data/neo4j/integration/movies/shared/Organisation.java

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2011-2021 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.neo4j.integration.movies.shared;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.springframework.data.neo4j.core.schema.GeneratedValue;
+import org.springframework.data.neo4j.core.schema.Id;
+import org.springframework.data.neo4j.core.schema.Node;
+import org.springframework.data.neo4j.core.schema.Relationship;
+
+/**
+ * @soundtrack Guns n' Roses - Appetite For Destruction
+ */
+@Node
+public class Organisation {
+
+	@Id
+	@GeneratedValue
+	private Long id;
+	private final String partnerCode;
+	private final String code;
+	private final String name;
+	private final String type;
+
+	@Relationship(type = "CHILD_ORGANISATIONS")
+	private final List<Organisation> organisations;
+
+	public Organisation(String partnerCode, String code, String name, String type,
+			List<Organisation> organisations) {
+		this.partnerCode = partnerCode;
+		this.code = code;
+		this.name = name;
+		this.type = type;
+		this.organisations = organisations;
+	}
+
+	public Organisation withId(Long newId) {
+		if (this.id == newId) {
+			return this;
+		}
+		Organisation o = new Organisation(this.partnerCode, this.code, this.name, this.type, this.organisations);
+		o.id = newId;
+		return o;
+	}
+
+	public Long getId() {
+		return id;
+	}
+
+	public String getPartnerCode() {
+		return partnerCode;
+	}
+
+	public String getCode() {
+		return code;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public String getType() {
+		return type;
+	}
+
+	public List<Organisation> getOrganisations() {
+		return organisations == null ? Collections.emptyList() : Collections.unmodifiableList(organisations);
+	}
+
+	@Override public String toString() {
+		return "Organisation{" +
+			   "id=" + id +
+			   ", partnerCode='" + partnerCode + '\'' +
+			   ", code='" + code + '\'' +
+			   ", name='" + name + '\'' +
+			   ", type='" + type + '\'' +
+			   ", organisations=" + organisations +
+			   '}';
+	}
+}