Java Code Examples for org.neo4j.driver.types.Node#id()

@Test
void findEntityWithBidirectionalRelationship(@Autowired BidirectionalStartRepository repository) {

	long startId;

	try (Session session = createSession()) {
		Record record = session
			.run("CREATE (n:BidirectionalStart{name:'Ernie'})-[:CONNECTED]->(e:BidirectionalEnd{name:'Bert'}), "
				+ "(e)<-[:ANOTHER_CONNECTION]-(anotherStart:BidirectionalStart{name:'Elmo'})"
				+ "RETURN n").single();

		Node startNode = record.get("n").asNode();
		startId = startNode.id();
	}

	Optional<BidirectionalStart> entityOptional = repository.findById(startId);
	assertThat(entityOptional).isPresent();
	BidirectionalStart entity = entityOptional.get();
	assertThat(entity.getEnds()).hasSize(1);

	BidirectionalEnd end = entity.getEnds().iterator().next();
	assertThat(end.getAnotherStart()).isNotNull();
	assertThat(end.getAnotherStart().getName()).isEqualTo("Elmo");

}
 

@Test
void findEntityWithBidirectionalRelationshipFromIncomingSide(@Autowired BidirectionalEndRepository repository) {

	long endId;

	try (Session session = createSession()) {
		Record record = session
			.run("CREATE (n:BidirectionalStart{name:'Ernie'})-[:CONNECTED]->(e:BidirectionalEnd{name:'Bert'}) "
				+ "RETURN e").single();

		Node endNode = record.get("e").asNode();
		endId = endNode.id();
	}

	Optional<BidirectionalEnd> entityOptional = repository.findById(endId);
	assertThat(entityOptional).isPresent();
	BidirectionalEnd entity = entityOptional.get();
	assertThat(entity.getStart()).isNotNull();

}
 

@Test
void findEntityWithRelationshipWithAssignedId(@Autowired PetRepository repository) {

	long petNodeId;

	try (Session session = createSession()) {
		Record record = session
			.run("CREATE (p:Pet{name:'Jerry'})-[:Has]->(t:Thing{theId:'t1', name:'Thing1'}) "
				+ "RETURN p, t").single();

		Node petNode = record.get("p").asNode();
		petNodeId = petNode.id();
	}

	Pet pet = repository.findById(petNodeId).get();
	ThingWithAssignedId relatedThing = pet.getThings().get(0);
	assertThat(relatedThing.getTheId()).isEqualTo("t1");
	assertThat(relatedThing.getName()).isEqualTo("Thing1");
}
 

@Test
void loadEntityWithBidirectionalRelationship(@Autowired BidirectionalStartRepository repository) {

	long startId;

	try (Session session = createSession()) {
		Record record = session
			.run("CREATE (n:BidirectionalStart{name:'Ernie'})-[:CONNECTED]->(e:BidirectionalEnd{name:'Bert'}) "
				+ "RETURN n").single();

		Node startNode = record.get("n").asNode();
		startId = startNode.id();
	}

	StepVerifier.create(repository.findById(startId))
		.assertNext(entity -> {
			assertThat(entity.getEnds()).hasSize(1);
		})
		.verifyComplete();
}
 

@Test
void loadEntityWithBidirectionalRelationshipFromIncomingSide(@Autowired BidirectionalEndRepository repository) {

	long endId;

	try (Session session = createSession()) {
		Record record = session
			.run("CREATE (n:BidirectionalStart{name:'Ernie'})-[:CONNECTED]->(e:BidirectionalEnd{name:'Bert'}) "
				+ "RETURN e").single();

		Node endNode = record.get("e").asNode();
		endId = endNode.id();
	}

	StepVerifier.create(repository.findById(endId))
		.assertNext(entity -> {
			assertThat(entity.getStart()).isNotNull();
		})
		.verifyComplete();
}
 

@Test
void loadEntityWithRelationshipWithAssignedId(@Autowired ReactivePetRepository repository) {

	long petNodeId;

	try (Session session = createSession()) {
		Record record = session
			.run("CREATE (p:Pet{name:'Jerry'})-[:Has]->(t:Thing{theId:'t1', name:'Thing1'}) "
				+ "RETURN p, t").single();

		Node petNode = record.get("p").asNode();
		petNodeId = petNode.id();
	}

	StepVerifier.create(repository.findById(petNodeId))
		.assertNext(pet -> {
			ThingWithAssignedId relatedThing = pet.getThings().get(0);
			assertThat(relatedThing.getTheId()).isEqualTo("t1");
			assertThat(relatedThing.getName()).isEqualTo("Thing1");
		})
		.verifyComplete();
}
 

@Test
void findEntityWithRelationshipViaQuery(@Autowired RelationshipRepository repository) {

	long personId;
	long hobbyNodeId;
	long petNode1Id;
	long petNode2Id;

	try (Session session = createSession()) {
		Record record = session
			.run("CREATE (n:PersonWithRelationship{name:'Freddie'})-[:Has]->(h1:Hobby{name:'Music'}), "
				+ "(n)-[:Has]->(p1:Pet{name: 'Jerry'}), (n)-[:Has]->(p2:Pet{name: 'Tom'}) "
				+ "RETURN n, h1, p1, p2").single();

		Node personNode = record.get("n").asNode();
		Node hobbyNode1 = record.get("h1").asNode();
		Node petNode1 = record.get("p1").asNode();
		Node petNode2 = record.get("p2").asNode();

		personId = personNode.id();
		hobbyNodeId = hobbyNode1.id();
		petNode1Id = petNode1.id();
		petNode2Id = petNode2.id();
	}

	PersonWithRelationship loadedPerson = repository.getPersonWithRelationshipsViaQuery();
	assertThat(loadedPerson.getName()).isEqualTo("Freddie");
	assertThat(loadedPerson.getId()).isEqualTo(personId);
	Hobby hobby = loadedPerson.getHobbies();
	assertThat(hobby).isNotNull();
	assertThat(hobby.getId()).isEqualTo(hobbyNodeId);
	assertThat(hobby.getName()).isEqualTo("Music");

	List<Pet> pets = loadedPerson.getPets();
	Pet comparisonPet1 = new Pet(petNode1Id, "Jerry");
	Pet comparisonPet2 = new Pet(petNode2Id, "Tom");
	assertThat(pets).containsExactlyInAnyOrder(comparisonPet1, comparisonPet2);

}
 

public Movie save(Movie movie) {
	try (Session session = driver.session()) {
		Record r = session.run("CREATE (m:Movie {title: $title, tagline: $tagline}) RETURN m", Values.parameters("title", movie.getTitle(), "tagline", movie.getTagline()))
			.single();
		Node movieNode = r.get("m").asNode();
		return new Movie(movieNode.id(), movieNode.get("title").asString(), movieNode.get("tagline").asString());
	}
}
 

private Edge loadEdge(Record record) {
    // relationship
    Relationship relationship = record.get(1).asRelationship();
    // edge id
    Object edgeId = edgeIdProvider.get(relationship);
    // check edge has been deleted
    if (!deletedEdges.contains(edgeId)) {
        // check we have record in memory
        Neo4JEdge edge = edges.get(edgeId);
        if (edge == null) {
            // nodes
            Node firstNode = record.get(0).asNode();
            Node secondNode = record.get(2).asNode();
            // node ids
            Object firstNodeId = vertexIdProvider.get(firstNode);
            Object secondNodeId = vertexIdProvider.get(secondNode);
            // check edge has been deleted (one of the vertices was deleted) or the vertices are not in the read partition
            if (deletedVertices.contains(firstNodeId) || deletedVertices.contains(secondNodeId) || !partition.containsVertex(StreamSupport.stream(firstNode.labels().spliterator(), false).collect(Collectors.toSet())) || !partition.containsVertex(StreamSupport.stream(secondNode.labels().spliterator(), false).collect(Collectors.toSet())))
                return null;
            // check we have first vertex in memory
            Neo4JVertex firstVertex = vertices.get(firstNodeId);
            if (firstVertex == null) {
                // create vertex
                firstVertex = new Neo4JVertex(graph, this, vertexIdProvider, edgeIdProvider, firstNode);
                // register it
                registerVertex(firstVertex);
            }
            // check we have second vertex in memory
            Neo4JVertex secondVertex = vertices.get(secondNodeId);
            if (secondVertex == null) {
                // create vertex
                secondVertex = new Neo4JVertex(graph, this, vertexIdProvider, edgeIdProvider, secondNode);
                // register it
                registerVertex(secondVertex);
            }
            // find out start and end of the relationship (edge could come in either direction)
            Neo4JVertex out = relationship.startNodeId() == firstNode.id() ? firstVertex : secondVertex;
            Neo4JVertex in = relationship.endNodeId() == firstNode.id() ? firstVertex : secondVertex;
            // create edge
            edge = new Neo4JEdge(graph, this, edgeIdProvider, out, relationship, in);
            // register with adjacent vertices
            out.addOutEdge(edge);
            in.addInEdge(edge);
            // register edge
            return registerEdge(edge);
        }
        // return edge
        return edge;
    }
    // skip edge
    return null;
}
 

@Test
void findEntityWithRelationship(@Autowired RelationshipRepository repository) {

	long personId;
	long clubId;
	long hobbyNode1Id;
	long hobbyNode2Id;
	long petNode1Id;
	long petNode2Id;

	try (Session session = createSession()) {
		Record record = session
			.run("CREATE (n:PersonWithRelationship{name:'Freddie'})-[:Has]->(h1:Hobby{name:'Music'}), "
				+ "(n)-[:Has]->(p1:Pet{name: 'Jerry'}), (n)-[:Has]->(p2:Pet{name: 'Tom'}), "
				+ "(n)<-[:Has]-(c:Club{name:'ClownsClub'}), "
				+ "(p1)-[:Has]->(h2:Hobby{name:'sleeping'}), "
				+ "(p1)-[:Has]->(p2)"
				+ "RETURN n, h1, h2, p1, p2, c").single();

		Node personNode = record.get("n").asNode();
		Node clubNode = record.get("c").asNode();
		Node hobbyNode1 = record.get("h1").asNode();
		Node hobbyNode2 = record.get("h2").asNode();
		Node petNode1 = record.get("p1").asNode();
		Node petNode2 = record.get("p2").asNode();

		personId = personNode.id();
		clubId = clubNode.id();
		hobbyNode1Id = hobbyNode1.id();
		hobbyNode2Id = hobbyNode2.id();
		petNode1Id = petNode1.id();
		petNode2Id = petNode2.id();
	}

	PersonWithRelationship loadedPerson = repository.findById(personId).get();
	assertThat(loadedPerson.getName()).isEqualTo("Freddie");
	Hobby hobby = loadedPerson.getHobbies();
	assertThat(hobby).isNotNull();
	assertThat(hobby.getId()).isEqualTo(hobbyNode1Id);
	assertThat(hobby.getName()).isEqualTo("Music");

	Club club = loadedPerson.getClub();
	assertThat(club).isNotNull();
	assertThat(club.getId()).isEqualTo(clubId);
	assertThat(club.getName()).isEqualTo("ClownsClub");

	List<Pet> pets = loadedPerson.getPets();
	Pet comparisonPet1 = new Pet(petNode1Id, "Jerry");
	Pet comparisonPet2 = new Pet(petNode2Id, "Tom");
	assertThat(pets).containsExactlyInAnyOrder(comparisonPet1, comparisonPet2);

	Pet pet1 = pets.get(pets.indexOf(comparisonPet1));
	Pet pet2 = pets.get(pets.indexOf(comparisonPet2));
	Hobby petHobby = pet1.getHobbies().iterator().next();
	assertThat(petHobby.getId()).isEqualTo(hobbyNode2Id);
	assertThat(petHobby.getName()).isEqualTo("sleeping");

	assertThat(pet1.getFriends()).containsExactly(pet2);

}
 

public static Fruit from(Node node) {
    return new Fruit(node.id(), node.get("name").asString());
}
 

private static Movie mapToMovie(Record r) {
	Node movieNode = r.get("m").asNode();
	return new Movie(movieNode.id(), movieNode.get("title").asString(), movieNode.get("tagline").asString());
}
 

@Test
void loadEntityWithRelationshipWithPropertiesFromCustomQuery(@Autowired ReactivePersonWithRelationshipWithPropertiesRepository repository) {

		long personId;
		long hobbyNode1Id;
		long hobbyNode2Id;

		try (Session session = createSession()) {
			Record record = session
				.run("CREATE (n:PersonWithRelationshipWithProperties{name:'Freddie'}),"
					+ " (n)-[l1:LIKES"
					+ "{since: 1995, active: true, localDate: date('1995-02-26'), myEnum: 'SOMETHING', point: point({x: 0, y: 1})}"
					+ "]->(h1:Hobby{name:'Music'}),"
					+ " (n)-[l2:LIKES"
					+ "{since: 2000, active: false, localDate: date('2000-06-28'), myEnum: 'SOMETHING_DIFFERENT', point: point({x: 2, y: 3})}"
					+ "]->(h2:Hobby{name:'Something else'})"
					+ "RETURN n, h1, h2").single();

			Node personNode = record.get("n").asNode();
			Node hobbyNode1 = record.get("h1").asNode();
			Node hobbyNode2 = record.get("h2").asNode();

			personId = personNode.id();
			hobbyNode1Id = hobbyNode1.id();
			hobbyNode2Id = hobbyNode2.id();
		}

		StepVerifier.create(repository.loadFromCustomQuery(personId))
			.assertNext(person -> {
				assertThat(person.getName()).isEqualTo("Freddie");

				Hobby hobby1 = new Hobby();
				hobby1.setName("Music");
				hobby1.setId(hobbyNode1Id);
				LikesHobbyRelationship rel1 = new LikesHobbyRelationship(1995);
				rel1.setActive(true);
				rel1.setLocalDate(LocalDate.of(1995, 2, 26));
				rel1.setMyEnum(LikesHobbyRelationship.MyEnum.SOMETHING);
				rel1.setPoint(new CartesianPoint2d(0d, 1d));

				Hobby hobby2 = new Hobby();
				hobby2.setName("Something else");
				hobby2.setId(hobbyNode2Id);
				LikesHobbyRelationship rel2 = new LikesHobbyRelationship(2000);
				rel2.setActive(false);
				rel2.setLocalDate(LocalDate.of(2000, 6, 28));
				rel2.setMyEnum(LikesHobbyRelationship.MyEnum.SOMETHING_DIFFERENT);
				rel2.setPoint(new CartesianPoint2d(2d, 3d));

				assertThat(person.getHobbies()).contains(MapEntry.entry(hobby1, rel1), MapEntry.entry(hobby2, rel2));
			})
			.verifyComplete();

	}
 

@Test
void loadEntityWithRelationshipWithProperties(@Autowired ReactivePersonWithRelationshipWithPropertiesRepository repository) {

	long personId;
	long hobbyNode1Id;
	long hobbyNode2Id;

	try (Session session = createSession()) {
		Record record = session
			.run("CREATE (n:PersonWithRelationshipWithProperties{name:'Freddie'}),"
				+ " (n)-[l1:LIKES"
				+ "{since: 1995, active: true, localDate: date('1995-02-26'), myEnum: 'SOMETHING', point: point({x: 0, y: 1})}"
				+ "]->(h1:Hobby{name:'Music'}),"
				+ " (n)-[l2:LIKES"
				+ "{since: 2000, active: false, localDate: date('2000-06-28'), myEnum: 'SOMETHING_DIFFERENT', point: point({x: 2, y: 3})}"
				+ "]->(h2:Hobby{name:'Something else'})"
				+ "RETURN n, h1, h2").single();

		Node personNode = record.get("n").asNode();
		Node hobbyNode1 = record.get("h1").asNode();
		Node hobbyNode2 = record.get("h2").asNode();

		personId = personNode.id();
		hobbyNode1Id = hobbyNode1.id();
		hobbyNode2Id = hobbyNode2.id();
	}

	StepVerifier.create(repository.findById(personId))
		.assertNext(person -> {
			assertThat(person.getName()).isEqualTo("Freddie");

			Hobby hobby1 = new Hobby();
			hobby1.setName("Music");
			hobby1.setId(hobbyNode1Id);
			LikesHobbyRelationship rel1 = new LikesHobbyRelationship(1995);
			rel1.setActive(true);
			rel1.setLocalDate(LocalDate.of(1995, 2, 26));
			rel1.setMyEnum(LikesHobbyRelationship.MyEnum.SOMETHING);
			rel1.setPoint(new CartesianPoint2d(0d, 1d));

			Hobby hobby2 = new Hobby();
			hobby2.setName("Something else");
			hobby2.setId(hobbyNode2Id);
			LikesHobbyRelationship rel2 = new LikesHobbyRelationship(2000);
			rel2.setActive(false);
			rel2.setLocalDate(LocalDate.of(2000, 6, 28));
			rel2.setMyEnum(LikesHobbyRelationship.MyEnum.SOMETHING_DIFFERENT);
			rel2.setPoint(new CartesianPoint2d(2d, 3d));

			assertThat(person.getHobbies()).contains(MapEntry.entry(hobby1, rel1), MapEntry.entry(hobby2, rel2));
		})
		.verifyComplete();

}
 

@Test
void loadEntityWithRelationshipViaQuery(@Autowired ReactiveRelationshipRepository repository) {

	long personId;
	long hobbyNodeId;
	long petNode1Id;
	long petNode2Id;

	try (Session session = createSession()) {
		Record record = session
			.run("CREATE (n:PersonWithRelationship{name:'Freddie'})-[:Has]->(h1:Hobby{name:'Music'}), "
				+ "(n)-[:Has]->(p1:Pet{name: 'Jerry'}), (n)-[:Has]->(p2:Pet{name: 'Tom'}) "
				+ "RETURN n, h1, p1, p2").single();

		Node personNode = record.get("n").asNode();
		Node hobbyNode1 = record.get("h1").asNode();
		Node petNode1 = record.get("p1").asNode();
		Node petNode2 = record.get("p2").asNode();

		personId = personNode.id();
		hobbyNodeId = hobbyNode1.id();
		petNode1Id = petNode1.id();
		petNode2Id = petNode2.id();
	}

	StepVerifier.create(repository.getPersonWithRelationshipsViaQuery())
		.assertNext(loadedPerson -> {
			assertThat(loadedPerson.getName()).isEqualTo("Freddie");
			assertThat(loadedPerson.getId()).isEqualTo(personId);
			Hobby hobby = loadedPerson.getHobbies();
			assertThat(hobby).isNotNull();
			assertThat(hobby.getId()).isEqualTo(hobbyNodeId);
			assertThat(hobby.getName()).isEqualTo("Music");

			List<Pet> pets = loadedPerson.getPets();
			Pet comparisonPet1 = new Pet(petNode1Id, "Jerry");
			Pet comparisonPet2 = new Pet(petNode2Id, "Tom");
			assertThat(pets).containsExactlyInAnyOrder(comparisonPet1, comparisonPet2);
		})
		.verifyComplete();
}
 

@Test
void loadEntityWithRelationshipToTheSameNode(@Autowired ReactiveRelationshipRepository repository) {

	long personId;
	long hobbyNode1Id;
	long petNode1Id;

	try (Session session = createSession()) {
		Record record = session
			.run("CREATE (n:PersonWithRelationship{name:'Freddie'})-[:Has]->(h1:Hobby{name:'Music'}), "
				+ "(n)-[:Has]->(p1:Pet{name: 'Jerry'}), "
				+ "(p1)-[:Has]->(h1)"
				+ "RETURN n, h1, p1").single();

		Node personNode = record.get("n").asNode();
		Node hobbyNode1 = record.get("h1").asNode();
		Node petNode1 = record.get("p1").asNode();

		personId = personNode.id();
		hobbyNode1Id = hobbyNode1.id();
		petNode1Id = petNode1.id();
	}

	StepVerifier.create(repository.findById(personId))
		.assertNext(loadedPerson -> {

			assertThat(loadedPerson.getName()).isEqualTo("Freddie");
			Hobby hobby = loadedPerson.getHobbies();
			assertThat(hobby).isNotNull();
			assertThat(hobby.getId()).isEqualTo(hobbyNode1Id);
			assertThat(hobby.getName()).isEqualTo("Music");

			List<Pet> pets = loadedPerson.getPets();
			Pet comparisonPet1 = new Pet(petNode1Id, "Jerry");
			assertThat(pets).containsExactlyInAnyOrder(comparisonPet1);

			Pet pet1 = pets.get(pets.indexOf(comparisonPet1));
			Hobby petHobby = pet1.getHobbies().iterator().next();
			assertThat(petHobby.getName()).isEqualTo("Music");

			assertThat(petHobby).isSameAs(hobby);
		})
		.verifyComplete();
}
 

@Test
void loadEntityWithRelationship(@Autowired ReactiveRelationshipRepository repository) {

	long personId;
	long clubId;
	long hobbyNode1Id;
	long hobbyNode2Id;
	long petNode1Id;
	long petNode2Id;

	try (Session session = createSession()) {
		Record record = session
			.run("CREATE (n:PersonWithRelationship{name:'Freddie'})-[:Has]->(h1:Hobby{name:'Music'}), "
				+ "(n)-[:Has]->(p1:Pet{name: 'Jerry'}), (n)-[:Has]->(p2:Pet{name: 'Tom'}), "
				+ "(n)<-[:Has]-(c:Club{name:'ClownsClub'}), "
				+ "(p1)-[:Has]->(h2:Hobby{name:'sleeping'}), "
				+ "(p1)-[:Has]->(p2)"
				+ "RETURN n, h1, h2, p1, p2, c").single();

		Node personNode = record.get("n").asNode();
		Node clubNode = record.get("c").asNode();
		Node hobbyNode1 = record.get("h1").asNode();
		Node hobbyNode2 = record.get("h2").asNode();
		Node petNode1 = record.get("p1").asNode();
		Node petNode2 = record.get("p2").asNode();

		personId = personNode.id();
		clubId = clubNode.id();
		hobbyNode1Id = hobbyNode1.id();
		hobbyNode2Id = hobbyNode2.id();
		petNode1Id = petNode1.id();
		petNode2Id = petNode2.id();
	}

	StepVerifier.create(repository.findById(personId))
		.assertNext(loadedPerson -> {

			assertThat(loadedPerson.getName()).isEqualTo("Freddie");
			Hobby hobby = loadedPerson.getHobbies();
			assertThat(hobby).isNotNull();
			assertThat(hobby.getId()).isEqualTo(hobbyNode1Id);
			assertThat(hobby.getName()).isEqualTo("Music");

			Club club = loadedPerson.getClub();
			assertThat(club).isNotNull();
			assertThat(club.getId()).isEqualTo(clubId);
			assertThat(club.getName()).isEqualTo("ClownsClub");

			List<Pet> pets = loadedPerson.getPets();
			Pet comparisonPet1 = new Pet(petNode1Id, "Jerry");
			Pet comparisonPet2 = new Pet(petNode2Id, "Tom");
			assertThat(pets).containsExactlyInAnyOrder(comparisonPet1, comparisonPet2);

			Pet pet1 = pets.get(pets.indexOf(comparisonPet1));
			Pet pet2 = pets.get(pets.indexOf(comparisonPet2));
			Hobby petHobby = pet1.getHobbies().iterator().next();
			assertThat(petHobby.getId()).isEqualTo(hobbyNode2Id);
			assertThat(petHobby.getName()).isEqualTo("sleeping");

			assertThat(pet1.getFriends()).containsExactly(pet2);
		})
		.verifyComplete();
}
 

@Test
void findEntityWithRelationshipWithPropertiesFromCustomQuery(
	@Autowired PersonWithRelationshipWithPropertiesRepository repository) {

	long personId;
	long hobbyNode1Id;
	long hobbyNode2Id;

	try (Session session = createSession()) {
		Record record = session
			.run("CREATE (n:PersonWithRelationshipWithProperties{name:'Freddie'}),"
				+ " (n)-[l1:LIKES"
				+ "{since: 1995, active: true, localDate: date('1995-02-26'), myEnum: 'SOMETHING', point: point({x: 0, y: 1})}"
				+ "]->(h1:Hobby{name:'Music'}),"
				+ " (n)-[l2:LIKES"
				+ "{since: 2000, active: false, localDate: date('2000-06-28'), myEnum: 'SOMETHING_DIFFERENT', point: point({x: 2, y: 3})}"
				+ "]->(h2:Hobby{name:'Something else'})"
				+ "RETURN n, h1, h2").single();

		Node personNode = record.get("n").asNode();
		Node hobbyNode1 = record.get("h1").asNode();
		Node hobbyNode2 = record.get("h2").asNode();

		personId = personNode.id();
		hobbyNode1Id = hobbyNode1.id();
		hobbyNode2Id = hobbyNode2.id();
	}

	PersonWithRelationshipWithProperties person = repository.loadFromCustomQuery(personId);
	assertThat(person.getName()).isEqualTo("Freddie");

	Hobby hobby1 = new Hobby();
	hobby1.setName("Music");
	hobby1.setId(hobbyNode1Id);
	LikesHobbyRelationship rel1 = new LikesHobbyRelationship(1995);
	rel1.setActive(true);
	rel1.setLocalDate(LocalDate.of(1995, 2, 26));
	rel1.setMyEnum(LikesHobbyRelationship.MyEnum.SOMETHING);
	rel1.setPoint(new CartesianPoint2d(0d, 1d));

	Hobby hobby2 = new Hobby();
	hobby2.setName("Something else");
	hobby2.setId(hobbyNode2Id);
	LikesHobbyRelationship rel2 = new LikesHobbyRelationship(2000);
	rel2.setActive(false);
	rel2.setLocalDate(LocalDate.of(2000, 6, 28));
	rel2.setMyEnum(LikesHobbyRelationship.MyEnum.SOMETHING_DIFFERENT);
	rel2.setPoint(new CartesianPoint2d(2d, 3d));

	assertThat(person.getHobbies()).contains(MapEntry.entry(hobby1, rel1), MapEntry.entry(hobby2, rel2));
}
 

@Test
void findEntityWithRelationshipWithProperties(
	@Autowired PersonWithRelationshipWithPropertiesRepository repository) {

	long personId;
	long hobbyNode1Id;
	long hobbyNode2Id;

	try (Session session = createSession()) {
		Record record = session
			.run("CREATE (n:PersonWithRelationshipWithProperties{name:'Freddie'}),"
				+ " (n)-[l1:LIKES"
				+ "{since: 1995, active: true, localDate: date('1995-02-26'), myEnum: 'SOMETHING', point: point({x: 0, y: 1})}"
				+ "]->(h1:Hobby{name:'Music'}),"
				+ " (n)-[l2:LIKES"
				+ "{since: 2000, active: false, localDate: date('2000-06-28'), myEnum: 'SOMETHING_DIFFERENT', point: point({x: 2, y: 3})}"
				+ "]->(h2:Hobby{name:'Something else'})"
				+ "RETURN n, h1, h2").single();

		Node personNode = record.get("n").asNode();
		Node hobbyNode1 = record.get("h1").asNode();
		Node hobbyNode2 = record.get("h2").asNode();

		personId = personNode.id();
		hobbyNode1Id = hobbyNode1.id();
		hobbyNode2Id = hobbyNode2.id();
	}

	Optional<PersonWithRelationshipWithProperties> optionalPerson = repository.findById(personId);
	assertThat(optionalPerson).isPresent();
	PersonWithRelationshipWithProperties person = optionalPerson.get();
	assertThat(person.getName()).isEqualTo("Freddie");

	Hobby hobby1 = new Hobby();
	hobby1.setName("Music");
	hobby1.setId(hobbyNode1Id);
	LikesHobbyRelationship rel1 = new LikesHobbyRelationship(1995);
	rel1.setActive(true);
	rel1.setLocalDate(LocalDate.of(1995, 2, 26));
	rel1.setMyEnum(LikesHobbyRelationship.MyEnum.SOMETHING);
	rel1.setPoint(new CartesianPoint2d(0d, 1d));

	Hobby hobby2 = new Hobby();
	hobby2.setName("Something else");
	hobby2.setId(hobbyNode2Id);
	LikesHobbyRelationship rel2 = new LikesHobbyRelationship(2000);
	rel2.setActive(false);
	rel2.setLocalDate(LocalDate.of(2000, 6, 28));
	rel2.setMyEnum(LikesHobbyRelationship.MyEnum.SOMETHING_DIFFERENT);
	rel2.setPoint(new CartesianPoint2d(2d, 3d));

	assertThat(person.getHobbies()).contains(MapEntry.entry(hobby1, rel1), MapEntry.entry(hobby2, rel2));
}
 

@Test
void findEntityWithRelationshipToTheSameNode(@Autowired RelationshipRepository repository) {

	long personId;
	long hobbyNode1Id;
	long petNode1Id;

	try (Session session = createSession()) {
		Record record = session
			.run("CREATE (n:PersonWithRelationship{name:'Freddie'})-[:Has]->(h1:Hobby{name:'Music'}), "
				+ "(n)-[:Has]->(p1:Pet{name: 'Jerry'}), "
				+ "(p1)-[:Has]->(h1)"
				+ "RETURN n, h1, p1").single();

		Node personNode = record.get("n").asNode();
		Node hobbyNode1 = record.get("h1").asNode();
		Node petNode1 = record.get("p1").asNode();

		personId = personNode.id();
		hobbyNode1Id = hobbyNode1.id();
		petNode1Id = petNode1.id();
	}

	PersonWithRelationship loadedPerson = repository.findById(personId).get();
	assertThat(loadedPerson.getName()).isEqualTo("Freddie");
	Hobby hobby = loadedPerson.getHobbies();
	assertThat(hobby).isNotNull();
	assertThat(hobby.getId()).isEqualTo(hobbyNode1Id);
	assertThat(hobby.getName()).isEqualTo("Music");

	List<Pet> pets = loadedPerson.getPets();
	Pet comparisonPet1 = new Pet(petNode1Id, "Jerry");
	assertThat(pets).containsExactlyInAnyOrder(comparisonPet1);

	Pet pet1 = pets.get(pets.indexOf(comparisonPet1));
	Hobby petHobby = pet1.getHobbies().iterator().next();
	assertThat(petHobby.getName()).isEqualTo("Music");

	assertThat(petHobby).isSameAs(hobby);

}