GH-2639 - Fix relationship detection in converter.

In an inheritance situation, SDN might not search in the result
for the right name of the list of relationships from the generic query.

Closes #2639

Author: meistermeier

src/main/java/org/springframework/data/neo4j/core/mapping/DefaultNeo4jEntityConverter.java

@@ -299,10 +299,10 @@ private static MapAccessor mergeRootNodeWithRecord(Node node, MapAccessor record
 	private <ET> ET map(MapAccessor queryResult, MapAccessor allValues, Neo4jPersistentEntity<ET> nodeDescription) {
 		Collection<Relationship> relationshipsFromResult = extractRelationships(allValues);
 		Collection<Node> nodesFromResult = extractNodes(allValues);
-		return map(queryResult, nodeDescription, null, null, relationshipsFromResult, nodesFromResult);
+		return map(queryResult, nodeDescription, nodeDescription, null, null, relationshipsFromResult, nodesFromResult);
 	}
 
-	private <ET> ET map(MapAccessor queryResult, Neo4jPersistentEntity<ET> nodeDescription,
+	private <ET> ET map(MapAccessor queryResult, Neo4jPersistentEntity<ET> nodeDescription, NodeDescription<?> genericTargetNodeDescription,
 			@Nullable Object lastMappedEntity, @Nullable RelationshipDescription relationshipDescription, Collection<Relationship> relationshipsFromResult, Collection<Node> nodesFromResult) {
 
 		// if the given result does not contain an identifier to the mapped object cannot get temporarily saved
@@ -327,7 +327,7 @@ private <ET> ET map(MapAccessor queryResult, Neo4jPersistentEntity<ET> nodeDescr
 			Neo4jPersistentEntity<ET> concreteNodeDescription = (Neo4jPersistentEntity<ET>) nodeDescriptionAndLabels
 					.getNodeDescription();
 
-			ET instance = instantiate(concreteNodeDescription, queryResult,
+			ET instance = instantiate(concreteNodeDescription, genericTargetNodeDescription, queryResult,
 					nodeDescriptionAndLabels.getDynamicLabels(), lastMappedEntity, relationshipsFromResult, nodesFromResult);
 
 			knownObjects.removeFromInCreation(internalId);
@@ -475,7 +475,7 @@ private boolean containsOnePlainNode(MapAccessor queryResult) {
 				.filter(value -> value.hasType(nodeType)).count() == 1L;
 	}
 
-	private <ET> ET instantiate(Neo4jPersistentEntity<ET> nodeDescription, MapAccessor values,
+	private <ET> ET instantiate(Neo4jPersistentEntity<ET> nodeDescription, NodeDescription<?> genericNodeDescription, MapAccessor values,
 			Collection<String> surplusLabels, @Nullable Object lastMappedEntity,
 			Collection<Relationship> relationshipsFromResult, Collection<Node> nodesFromResult) {
 
@@ -496,12 +496,12 @@ public <T> T getParameterValue(Parameter<T, Neo4jPersistentProperty> parameter)
 					// If we cannot find any value it does not mean that there isn't any.
 					// The result set might contain associations not named CONCRETE_TYPE_TARGET but ABSTRACT_TYPE_TARGET.
 					// For this we bubble up the hierarchy of NodeDescriptions.
-					result = createInstanceOfRelationships(matchingProperty, values, relationshipDescription, nodeDescription, relationshipsFromResult, nodesFromResult)
+					result = createInstanceOfRelationships(matchingProperty, values, relationshipDescription, nodeDescription, genericNodeDescription, relationshipsFromResult, nodesFromResult)
 							.orElseGet(() -> {
 								NodeDescription<?> parentNodeDescription = nodeDescription.getParentNodeDescription();
 								T resultValue = null;
 								while (parentNodeDescription != null) {
-									Optional<Object> value = createInstanceOfRelationships(matchingProperty, values, relationshipDescription, parentNodeDescription, relationshipsFromResult, nodesFromResult);
+									Optional<Object> value = createInstanceOfRelationships(matchingProperty, values, relationshipDescription, parentNodeDescription, parentNodeDescription, relationshipsFromResult, nodesFromResult);
 									if (value.isPresent()) {
 										resultValue = (T) value.get();
 										break;
@@ -594,7 +594,7 @@ private AssociationHandler<Neo4jPersistentProperty> populateFrom(MapAccessor que
 					&& propertyValueNotNull;
 
 			if (populatedCollection) {
-				createInstanceOfRelationships(persistentProperty, queryResult, (RelationshipDescription) association, baseDescription, relationshipsFromResult, nodesFromResult, false)
+				createInstanceOfRelationships(persistentProperty, queryResult, (RelationshipDescription) association, baseDescription, baseDescription, relationshipsFromResult, nodesFromResult, false)
 						.ifPresent(value -> {
 							Collection<?> providedCollection = (Collection<?>) value;
 							Collection<?> existingValue = (Collection<?>) propertyValue;
@@ -617,7 +617,7 @@ private AssociationHandler<Neo4jPersistentProperty> populateFrom(MapAccessor que
 				return;
 			}
 
-			createInstanceOfRelationships(persistentProperty, queryResult, (RelationshipDescription) association, baseDescription, relationshipsFromResult, nodesFromResult)
+			createInstanceOfRelationships(persistentProperty, queryResult, (RelationshipDescription) association, baseDescription, baseDescription, relationshipsFromResult, nodesFromResult)
 					.ifPresent(value -> propertyAccessor.setProperty(persistentProperty, value));
 		};
 	}
@@ -641,13 +641,13 @@ private void mergeCollections(RelationshipDescription relationshipDescription, C
 	}
 
 	private Optional<Object> createInstanceOfRelationships(Neo4jPersistentProperty persistentProperty, MapAccessor values,
-														   RelationshipDescription relationshipDescription, NodeDescription<?> baseDescription, Collection<Relationship> relationshipsFromResult,
+														   RelationshipDescription relationshipDescription, NodeDescription<?> baseDescription, NodeDescription<?> genericNodeDescription, Collection<Relationship> relationshipsFromResult,
 														   Collection<Node> nodesFromResult) {
-		return createInstanceOfRelationships(persistentProperty, values, relationshipDescription, baseDescription, relationshipsFromResult, nodesFromResult, true);
+		return createInstanceOfRelationships(persistentProperty, values, relationshipDescription, baseDescription, genericNodeDescription, relationshipsFromResult, nodesFromResult, true);
 	}
 
 	private Optional<Object> createInstanceOfRelationships(Neo4jPersistentProperty persistentProperty, MapAccessor values,
-		   RelationshipDescription relationshipDescription, NodeDescription<?> baseDescription, Collection<Relationship> relationshipsFromResult,
+		   RelationshipDescription relationshipDescription, NodeDescription<?> baseDescription, NodeDescription<?> genericNodeDescription, Collection<Relationship> relationshipsFromResult,
 		   Collection<Node> nodesFromResult, boolean fetchMore) {
 
 		String typeOfRelationship = relationshipDescription.getType();
@@ -681,7 +681,7 @@ private Optional<Object> createInstanceOfRelationships(Neo4jPersistentProperty p
 			mappedObjectHandler = (type, mappedObject) -> value.add(mappedObject);
 		}
 
-		String collectionName = relationshipDescription.generateRelatedNodesCollectionName(baseDescription);
+		String collectionName = relationshipDescription.generateRelatedNodesCollectionName(genericNodeDescription);
 
 		Value list = values.get(collectionName);
 
@@ -728,23 +728,24 @@ private Optional<Object> createInstanceOfRelationships(Neo4jPersistentProperty p
 						if (fetchMore) {
 							mappedObject = sourceNodeId != null && sourceNodeId.equals(targetNodeId)
 									? knownObjects.getObject("N" + sourceNodeId)
-									: map(possibleValueNode, concreteTargetNodeDescription, null, null, relationshipsFromResult, nodesFromResult);
+									: map(possibleValueNode, concreteTargetNodeDescription, genericNodeDescription, null, null, relationshipsFromResult, nodesFromResult);
 						} else {
 							Object objectFromStore = knownObjects.getObject("N" + targetNodeId);
 							mappedObject = objectFromStore != null
 								? objectFromStore
-								: map(possibleValueNode, concreteTargetNodeDescription, null, null, relationshipsFromResult, nodesFromResult);
+								: map(possibleValueNode, concreteTargetNodeDescription, genericNodeDescription, null, null, relationshipsFromResult, nodesFromResult);
 						}
 
 						if (relationshipDescription.hasRelationshipProperties()) {
 							Object relationshipProperties;
+							Neo4jPersistentEntity<?> relationshipPropertiesEntity = (Neo4jPersistentEntity<?>) relationshipDescription.getRelationshipPropertiesEntity();
 							if (fetchMore) {
-								relationshipProperties = map(possibleRelationship, (Neo4jPersistentEntity<?>) relationshipDescription.getRelationshipPropertiesEntity(), mappedObject, relationshipDescription, relationshipsFromResult, nodesFromResult);
+								relationshipProperties = map(possibleRelationship, relationshipPropertiesEntity, relationshipPropertiesEntity, mappedObject, relationshipDescription, relationshipsFromResult, nodesFromResult);
 							} else {
 								Object objectFromStore = knownObjects.getObject(getInternalId(possibleRelationship, relationshipDescription.getDirection().name()));
 								relationshipProperties = objectFromStore != null
 									? objectFromStore
-									: map(possibleRelationship, (Neo4jPersistentEntity<?>) relationshipDescription.getRelationshipPropertiesEntity(), mappedObject, relationshipDescription, relationshipsFromResult, nodesFromResult);
+									: map(possibleRelationship, relationshipPropertiesEntity, relationshipPropertiesEntity, mappedObject, relationshipDescription, relationshipsFromResult, nodesFromResult);
 							}
 							relationshipsAndProperties.add(relationshipProperties);
 							mappedObjectHandler.accept(possibleRelationship.type(), relationshipProperties);
@@ -764,29 +765,30 @@ private Optional<Object> createInstanceOfRelationships(Neo4jPersistentProperty p
 
 				Object valueEntry;
 				if (fetchMore) {
-					valueEntry = map(relatedEntity, concreteTargetNodeDescription, null, null, relationshipsFromResult, nodesFromResult);
+					valueEntry = map(relatedEntity, concreteTargetNodeDescription, genericNodeDescription, null, null, relationshipsFromResult, nodesFromResult);
 				} else {
 					Object objectFromStore = knownObjects.getObject(getInternalId(relatedEntity, null));
 					valueEntry = objectFromStore != null
 						? objectFromStore
-						: map(relatedEntity, concreteTargetNodeDescription, null, null, relationshipsFromResult, nodesFromResult);
+						: map(relatedEntity, concreteTargetNodeDescription, genericNodeDescription, null, null, relationshipsFromResult, nodesFromResult);
 				}
 
 				if (relationshipDescription.hasRelationshipProperties()) {
-					String sourceLabel = relationshipDescription.getSource().getMostAbstractParentLabel(baseDescription);
+					String sourceLabel = relationshipDescription.getSource().getMostAbstractParentLabel(genericNodeDescription);
 					String relationshipSymbolicName = sourceLabel
 													  + RelationshipDescription.NAME_OF_RELATIONSHIP + targetLabel;
 					Relationship relatedEntityRelationship = relatedEntity.get(relationshipSymbolicName)
 							.asRelationship();
 
 					Object relationshipProperties;
+					Neo4jPersistentEntity<?> relationshipPropertiesEntity = (Neo4jPersistentEntity<?>) relationshipDescription.getRelationshipPropertiesEntity();
 					if (fetchMore) {
-						relationshipProperties = map(relatedEntityRelationship, (Neo4jPersistentEntity<?>) relationshipDescription.getRelationshipPropertiesEntity(), valueEntry, relationshipDescription, relationshipsFromResult, nodesFromResult);
+						relationshipProperties = map(relatedEntityRelationship, relationshipPropertiesEntity, relationshipPropertiesEntity, valueEntry, relationshipDescription, relationshipsFromResult, nodesFromResult);
 					} else {
 						Object objectFromStore = knownObjects.getObject(getInternalId(relatedEntityRelationship, relationshipDescription.getDirection().name()));
 						relationshipProperties = objectFromStore != null
 							? objectFromStore
-							: map(relatedEntityRelationship, (Neo4jPersistentEntity<?>) relationshipDescription.getRelationshipPropertiesEntity(), valueEntry, relationshipDescription, relationshipsFromResult, nodesFromResult);
+							: map(relatedEntityRelationship, relationshipPropertiesEntity, relationshipPropertiesEntity, valueEntry, relationshipDescription, relationshipsFromResult, nodesFromResult);
 					}
 
 					relationshipsAndProperties.add(relationshipProperties);

src/test/java/org/springframework/data/neo4j/integration/issues/gh2639/Company.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2011-2022 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.issues.gh2639;
+
+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;
+
+import java.util.List;
+import java.util.StringJoiner;
+
+/**
+ * Root node
+ */
+@Node
+public class Company {
+
+	@Id
+	@GeneratedValue
+	private Long id;
+
+	private final String name;
+	@Relationship(type = "EMPLOYEE")
+	private final List<Person> employees;
+
+
+	public Company(String name, List<Person> employees) {
+		this.name = name;
+		this.employees = employees;
+	}
+
+	public void addEmployee(Person person) {
+		employees.add(person);
+	}
+
+	public List<Person> getEmployees() {
+		return employees;
+	}
+
+	@Override
+	public String toString() {
+		return new StringJoiner(", ", Company.class.getSimpleName() + "[", "]")
+				.add("id=" + id)
+				.add("name='" + name + "'")
+				.add("employees=" + employees)
+				.toString();
+	}
+}

src/test/java/org/springframework/data/neo4j/integration/issues/gh2639/CompanyRepository.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2011-2022 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.issues.gh2639;
+
+import org.springframework.data.neo4j.repository.Neo4jRepository;
+
+/**
+ * Fetch the root node by name.
+ */
+public interface CompanyRepository extends Neo4jRepository<Company, Long> {
+
+	Company findByName(String name);
+
+}

src/test/java/org/springframework/data/neo4j/integration/issues/gh2639/Developer.java

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2011-2022 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.issues.gh2639;
+
+import org.springframework.data.neo4j.core.schema.Node;
+
+import java.util.List;
+import java.util.StringJoiner;
+
+/**
+ * Developer holds the specific relationship we are trying to map
+ * in this test case.
+ */
+@Node
+public class Developer extends Person {
+
+	private final List<LanguageRelationship> programmingLanguages;
+	private final String name;
+
+	public Developer(String name, List<LanguageRelationship> programmingLanguages) {
+		this.name = name;
+		this.programmingLanguages = programmingLanguages;
+	}
+
+	public List<LanguageRelationship> getProgrammingLanguages() {
+		return programmingLanguages;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	@Override
+	public String toString() {
+		return new StringJoiner(", ", Developer.class.getSimpleName() + "[", "]")
+        .add("name='" + name + "'")
+				.add("programmingLanguages=" + programmingLanguages)
+				.toString();
+	}
+}

src/test/java/org/springframework/data/neo4j/integration/issues/gh2639/Enterprise.java

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2011-2022 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.issues.gh2639;
+
+import org.springframework.data.neo4j.core.schema.Node;
+
+import java.util.Objects;
+
+/**
+ * @author Gerrit Meier
+ */
+@Node
+public class Enterprise extends Inventor {
+
+	final String someEnterpriseProperty;
+
+	public Enterprise(String name, String someEnterpriseProperty) {
+		super(name);
+		this.someEnterpriseProperty = someEnterpriseProperty;
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) {
+			return true;
+		}
+		if (o == null || getClass() != o.getClass()) {
+			return false;
+		}
+		Enterprise that = (Enterprise) o;
+		return someEnterpriseProperty.equals(that.someEnterpriseProperty);
+	}
+
+	@Override
+	public int hashCode() {
+		return Objects.hash(someEnterpriseProperty);
+	}
+}