Spring Data Neo4j

https://github.com/spring-projects/spring-data-neo4j
Admin
Spring Data Neo4j is a Spring Data project that provides Next generation Object-Graph-Mapping with...
Tokens:72,537
Snippets:506
Trust Score:9.7
License:Apache-2.0
Update:1 month ago
Show doc for...
Tokens:
Raw
### findByExample in Action

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/faq.adoc

Shows how to use Example.of with an entity and ExampleMatcher to perform find-by-example queries. The example creates an Example from a MovieEntity and uses findAll with it. It also demonstrates using ExampleMatcher.matchingAny() with a matcher for the title property using CONTAINING string matcher.

```java
Example<MovieEntity> movieExample = Example.of(new MovieEntity("The Matrix", null));
Flux<MovieEntity> movies = this.movieRepository.findAll(movieExample);

movieExample = Example.of(
    new MovieEntity("Matrix", null),
    ExampleMatcher
        .matchingAny()
        .withMatcher(
            "title",
            ExampleMatcher.GenericPropertyMatcher.of(ExampleMatcher.StringMatcher.CONTAINING)
        )
);
movies = this.movieRepository.findAll(movieExample);
```

--------------------------------

### Verify JDK version

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/appendix/build.adoc

Checks the installed JDK version. The output should be similar to the example.

```console
$ java -version
java version "18.0.1" 2022-04-19
Java(TM) SE Runtime Environment (build 18.0.1+10-24)
Java HotSpot(TM) 64-Bit Server VM (build 18.0.1+10-24, mixed mode, sharing)
```

--------------------------------

### Using Neo4j 3.5 test harness

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/testing/testing-with-spring-boot.adoc

Example test class using @DataNeo4jTest with the Neo4j 3.5 test harness. It starts an in-process server in @BeforeAll, closes it in @AfterAll, and uses @DynamicPropertySource to configure the connection.

```java
import static org.assertj.core.api.Assertions.assertThat;

import java.util.Optional;

import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.neo4j.harness.ServerControls;
import org.neo4j.harness.TestServerBuilders;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.data.neo4j.DataNeo4jTest;
import org.springframework.data.neo4j.core.Neo4jClient;
import org.springframework.test.context.DynamicPropertyRegistry;
import org.springframework.test.context.DynamicPropertySource;

@DataNeo4jTest
class MovieRepositoryTest {

	private static ServerControls embeddedDatabaseServer;

	@BeforeAll
	static void initializeNeo4j() {

		embeddedDatabaseServer = TestServerBuilders.newInProcessBuilder() // <.>
			.newServer();
	}

	@AfterAll
	static void stopNeo4j() {

		embeddedDatabaseServer.close(); // <.>
	}

	@DynamicPropertySource  // <.>
	static void neo4jProperties(DynamicPropertyRegistry registry) {


```

--------------------------------

### TemplateExampleTest.java - Imperative Neo4jTemplate example

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/faq.adoc

Canonical movie example using the imperative Neo4jTemplate. Shows imports for testing with Spring Boot and Neo4j integration.

```java
import java.util.Collections;
import java.util.Optional;

import org.junit.jupiter.api.Test;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.data.neo4j.DataNeo4jTest;
import org.springframework.data.neo4j.core.Neo4jTemplate;
import org.springframework.data.neo4j.documentation.domain.MovieEntity;
import org.springframework.data.neo4j.documentation.domain.PersonEntity;
import org.springframework.data.neo4j.documentation.domain.Roles;
import org.springframework.data.neo4j.test.Neo4jIntegrationTest;
```

--------------------------------

### Verify full build with Maven wrapper

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/CONTRIBUTING.adoc

Starts the full build, including all tests and validations, using Maven and the ./mvnw wrapper.

```bash
./mvnw verify
```

--------------------------------

### Example of a domain type

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/appendix/neo4j-client.adoc

Shows a domain class example with Director and Movie classes, used for mapping domain objects to parameters.

```java
public class Director {

    private final String name;

    private final List<Movie> movies;

    Director(String name, List<Movie> movies) {
        this.name = name;
        this.movies = new ArrayList<>(movies);
    }

    public String getName() {
        return name;
    }

    public List<Movie> getMovies() {
        return Collections.unmodifiableList(movies);
    }
}

public class Movie {

    private final String title;

    public Movie(String title) {
        this.title = title;
    }

    public String getTitle() {
        return title;
    }
}

```

--------------------------------

### Maven dependency for Spring Boot starter

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/README.adoc

Add the Spring Boot starter for Spring Data Neo4j to your Maven pom.xml. This is the recommended way to get started with Spring Boot.

```xml
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-neo4j</artifactId>
</dependency>
```

--------------------------------

### Java: Domain model for path query example

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/appendix/custom-queries.adoc

Domain model classes (SomeEntity and SomeRelation) used in the path query example. Constructors and accessors omitted for brevity.

```java
include::example$integration/issues/gh2210/SomeEntity.java[tag=custom-query.paths.dm]

include::example$integration/issues/gh2210/SomeRelation.java[tag=custom-query.paths.dm]
```

--------------------------------

### Cypher path assignment example

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/faq.adoc

Shows how to assign a path to a variable in Cypher using the assignment operator. This is a basic syntax example for naming paths.

```cypher
p = (a)-[*3..5]->(b)
```

--------------------------------

### Using a mapping function for binding domain objects

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/appendix/neo4j-client.adoc

Shows an example of creating a Director instance with a list of Movie objects, used for binding domain objects to query parameters.

```java
Director joseph = new Director("Joseph Kosinski",
        Arrays.asList(new Movie("Tron Legacy"), new Movie("Top Gun: Maverick")));

```

--------------------------------

### ReactiveTemplateExampleTest.java - Saving and reading entities with ReactiveNeo4jTemplate

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/faq.adoc

Reactive version of the template example using @DataNeo4jTest, Testcontainers, and ReactiveNeo4jTemplate. Demonstrates saving and verifying entities with StepVerifier.

```java
import java.util.Collections;

import org.junit.jupiter.api.Test;
import org.testcontainers.neo4j.Neo4jContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;
import reactor.test.StepVerifier;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.data.neo4j.DataNeo4jTest;
import org.springframework.data.neo4j.core.ReactiveNeo4jTemplate;
import org.springframework.data.neo4j.documentation.domain.MovieEntity;
import org.springframework.data.neo4j.documentation.domain.PersonEntity;
import org.springframework.data.neo4j.documentation.domain.Roles;
import org.springframework.test.context.DynamicPropertyRegistry;
import org.springframework.test.context.DynamicPropertySource;

@Testcontainers
@DataNeo4jTest
class ReactiveTemplateExampleTest {

	@Container
	private static Neo4jContainer neo4jContainer = new Neo4jContainer("neo4j:5");

	@DynamicPropertySource
	static void neo4jProperties(DynamicPropertyRegistry registry) {
		registry.add("org.neo4j.driver.uri", neo4jContainer::getBoltUrl);
		registry.add("org.neo4j.driver.authentication.username", () -> "neo4j");
		registry.add("org.neo4j.driver.authentication.password", neo4jContainer::getAdminPassword);
	}

	@Test
	void shouldSaveAndReadEntities(@Autowired ReactiveNeo4jTemplate neo4jTemplate) {

		MovieEntity movie = new MovieEntity("The Love Bug",
				"A movie that follows the adventures of Herbie, Herbie's driver, Jim Douglas (Dean Jones), and Jim's love interest, Carole Bennett (Michele Lee)");

		Roles role1 = new Roles(new PersonEntity(1931, "Dean Jones"), Collections.singletonList("Didi"));
		Roles role2 = new Roles(new PersonEntity(1942, "Michele Lee"), Collections.singletonList("Michi"));
		movie.getActorsAndRoles().add(role1);
		movie.getActorsAndRoles().add(role2);

		StepVerifier.create(neo4jTemplate.save(movie)).expectNextCount(1L).verifyComplete();

		StepVerifier.create(neo4jTemplate.findById("Dean Jones", PersonEntity.class).map(PersonEntity::getBorn))
			.expectNext(1931)
			.verifyComplete();

		StepVerifier.create(neo4jTemplate.count(PersonEntity.class)).expectNext(2L).verifyComplete();
	}

}
```

--------------------------------

### TemplateExampleTest.java - Saving and reading entities with Neo4jTemplate

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/faq.adoc

Example test class using @DataNeo4jTest and Neo4jTemplate to save a MovieEntity with relationships and verify retrieval by ID and count. Demonstrates the imperative template API.

```java
import static org.assertj.core.api.Assertions.assertThat;

@Neo4jIntegrationTest
@DataNeo4jTest
public class TemplateExampleTest {

	@Test
	void shouldSaveAndReadEntities(@Autowired Neo4jTemplate neo4jTemplate) {

		MovieEntity movie = new MovieEntity("The Love Bug",
				"A movie that follows the adventures of Herbie, Herbie's driver, "
						+ "Jim Douglas (Dean Jones), and Jim's love interest, " + "Carole Bennett (Michele Lee)");

		Roles roles1 = new Roles(new PersonEntity(1931, "Dean Jones"), Collections.singletonList("Didi"));
		Roles roles2 = new Roles(new PersonEntity(1942, "Michele Lee"), Collections.singletonList("Michi"));
		movie.getActorsAndRoles().add(roles1);
		movie.getActorsAndRoles().add(roles2);

		MovieEntity result = neo4jTemplate.save(movie);
		assertThat(result.getActorsAndRoles()).allSatisfy(relationship -> assertThat(relationship.getId()).isNotNull());

		Optional<PersonEntity> person = neo4jTemplate.findById("Dean Jones", PersonEntity.class);
		assertThat(person).map(PersonEntity::getBorn).hasValue(1931);

		assertThat(neo4jTemplate.count(PersonEntity.class)).isEqualTo(2L);
	}

}
```

--------------------------------

### Enabling the Neo4j CDI extension in a SE container

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/faq.adoc

Shows how to initialize a CDI SE container with the Neo4jCdiExtension. The example uses SeContainerInitializer to disable discovery, add the extension, add bean classes, and add packages, then retrieves a repository from the container.

```java
import javax.enterprise.inject.se.SeContainer;
import javax.enterprise.inject.se.SeContainerInitializer;

import org.springframework.data.neo4j.config.Neo4jCdiExtension;

public class SomeClass {
    void someMethod() {
        try (SeContainer container = SeContainerInitializer.newInstance()
                .disableDiscovery()
                .addExtensions(Neo4jCdiExtension.class)
                .addBeanClasses(YourDriverFactory.class)
                .addPackages(Package.getPackage("your.domain.package"))
            .initialize()
        ) {
            SomeRepository someRepository = container.select(SomeRepository.class).get();
        }
    }
}
```

--------------------------------

### Person class with constructor and property access

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/object-mapping/sdc-object-mapping.adoc

Example domain class Person with a no-argument constructor, a constructor with arguments, a wither method, and a setter for lastname. Demonstrates property population internals.

```java
class Person {

  private final Long id;
  private String firstname;
  private @AccessType(Type.PROPERTY) String lastname;

  Person() {
    this.id = null;
  }

  Person(Long id, String firstname, String lastname) {
    // Field assignments
  }

  Person withId(Long id) {
    return new Person(id, this.firstname, this.lastame);
  }

  void setLastname(String lastname) {
    this.lastname = lastname;
  }
}
```

--------------------------------

### The PersonEntity

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/object-mapping/metadata-based-mapping.adoc

Complete example of a PersonEntity class. The code is included from an external file and is not shown inline.

```java
include::example$documentation/domain/PersonEntity.java[tags=mapping.annotations]
```

--------------------------------

### Cypher: Example of collected lists format

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/appendix/custom-queries.adoc

Shows the format of lists produced by the collect statement in the previous example: a list of lists of relationships.

```cypher
[[rel1, rel2], [rel3, rel4]]
```

--------------------------------

### Example class using Neo4j-OGM automatic index manager

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/appendix/migrating.adoc

A Java class that uses Neo4j-OGM annotations (@Index, @CompositeIndex, @Required) which have been removed without replacement. This example is provided to illustrate what needs to be migrated.

```java
import org.neo4j.ogm.annotation.CompositeIndex;
import org.neo4j.ogm.annotation.GeneratedValue;
import org.neo4j.ogm.annotation.Id;
import org.neo4j.ogm.annotation.Index;
import org.neo4j.ogm.annotation.Required;
```

--------------------------------

### Start a local Neo4j instance inside Docker

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/getting-started.adoc

Runs a Docker container with Neo4j, publishing ports 7474 and 7687, and sets the password to 'secret'. Access the browser at http://localhost:7474 and run ':play movies' to load test data.

```console
docker run --publish=7474:7474 --publish=7687:7687 -e 'NEO4J_AUTH=neo4j/secret' neo4j:{docs-neo4j-docker-version}
```

--------------------------------

### FindByExample with negated values

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/faq.adoc

Uses ExampleMatcher with a transformer to negate a property match, turning an '=' into a '<>' operation. The example creates an Example for MovieEntity, matching any property with CONTAINING, and transforms the 'title' property to not match. The resulting Flux contains all movies whose title does not contain 'Matrix'.

```java
Example<MovieEntity> movieExample = Example.of(
    new MovieEntity("Matrix", null),
    ExampleMatcher
        .matchingAny()
        .withMatcher(
            "title",
            ExampleMatcher.GenericPropertyMatcher.of(ExampleMatcher.StringMatcher.CONTAINING)
        )
       .withTransformer("title", Neo4jPropertyValueTransformers.notMatching())
);
Flux<MovieEntity> allMoviesThatNotContainMatrix = this.movieRepository.findAll(movieExample);
```

--------------------------------

### Custom base repository example

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/faq.adoc

Shows a custom base repository implementation that forbids the findAll method. The repository class must have a constructor taking Neo4jOperations and entity information. Enable it with @EnableNeo4jRepositories(repositoryBaseClass = MyRepositoryImpl.class).

```java
include::example$integration/imperative/CustomBaseRepositoryIT.java[tags=custom-base-repository]
```

--------------------------------

### Delegate database interaction to an imperative StatementRunner

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/appendix/neo4j-client.adoc

Shows how to use `delegateTo` with an imperative `StatementRunner` to execute a query and return an `Optional<Long>`. The example counts nodes and returns the result, with an optional database selection commented out.

```java
Optional<Long> result = client
    .delegateTo((StatementRunner runner) -> {
        // Do as many interactions as you want
        long numberOfNodes = runner.run("MATCH (n) RETURN count(n) as cnt")
            .single().get("cnt").asLong();
        return Optional.of(numberOfNodes);
    })
    // .in("aDatabase") // <.>
    .run();
```

--------------------------------

### Java: Repository method with standard parameter

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/appendix/custom-queries.adoc

Example of a repository method using a named parameter in a custom query. Requires compiling with -parameters for named parameters to work without annotations; alternatively use @Param or parameter index.

```java
include::example$documentation/repositories/domain_events/ARepository.java[tags=standard-parameter]
```

--------------------------------

### Delegate database interaction to a reactive RxStatementRunner

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/appendix/neo4j-client.adoc

Demonstrates using `delegateTo` with a reactive `RxStatementRunner` to execute a query and map the result to a count of deleted nodes. The example includes an optional database selection comment.

```java
Mono<Integer> result = client
    .delegateTo((RxStatementRunner runner) ->
        Mono.from(runner.run("MATCH (n:Unused) DELETE n").summary())
            .map(ResultSummary::counters)
            .map(SummaryCounters::nodesDeleted))
    // .in("aDatabase") // <.>
    .run();
```

--------------------------------

### Neo4j 3.5 test harness dependencies

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/testing/testing-with-spring-boot.adoc

Maven dependency for the Neo4j 3.5 test harness, required for the example using @DataNeo4jTest with the harness.

```xml
<dependency>
    <groupId>org.neo4j.test</groupId>
    <artifactId>neo4j-harness</artifactId>
    <version>{docs-neo4j-3-version}</version>
    <scope>test</scope>
</dependency>
```

--------------------------------

### Change Neo4j Java Driver version with Spring Boot

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/faq.adoc

Change the Neo4j Java Driver version using Spring Boot's dependency management. The Maven example sets the version in pom.xml, while the Gradle example sets it in gradle.properties.

```xml
<properties>
  <neo4j-java-driver.version>5.4.0</neo4j-java-driver.version>
</properties>
```

```properties
neo4j-java-driver.version = 5.4.0
```

--------------------------------

### Bind parameters with a custom mapping function

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/appendix/neo4j-client.adoc

Uses the `with` method on the reactive client to provide a binder function that maps a domain object to query parameters. The example binds a `Director` object to `$name` and `$movies` parameters for a MERGE query.

```java
Mono<ResultSummary> summary = client
    .query(""
        + "MERGE (p:Person {name: $name}) "
        + "WITH p UNWIND $movies as movie "
        + "MERGE (m:Movie {title: movie}) "
        + "MERGE (p) - [o:DIRECTED] -> (m) "
    )
    .bind(joseph).with(director -> { // <.>
        Map<String, Object> mappedValues = new HashMap<>();
        List<String> movies = director.getMovies().stream()
            .map(Movie::getTitle).collect(Collectors.toList());
        mappedValues.put("name", director.getName());
        mappedValues.put("movies", movies);
        return mappedValues;
    })
    .run();
```

--------------------------------

### Reactive Spring Data repository example

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/README.adoc

A quick teaser of a reactive application using Spring Data Repositories in Java, showing a @Node entity, a repository interface, and a service that saves and retrieves Person entities.

```java
@Node
public class Person {
    private Long id;
    private String name;

    public Person(String name) {
        this.name = name;
    }
}

@Repository
interface PersonRepository extends ReactiveNeo4jRepository<Person, Long> {

    Flux<Person> findAllByName(String name);

    Flux<Person> findAllByNameLike(String name);
}

@Service
class MyService {

    @Autowired
    private final PersonRepository repository;

    @Transactional
    public Flux<Person> doWork() {

        Person emil = new Person("Emil");
        Person gerrit = new Person("Gerrit");
        Person michael = new Person("Michael");

        // Persist entities and relationships to graph database
        return this.repository.saveAll(Flux.just(emil, gerrit, michael));
    }
}
```

--------------------------------

### MovieEntity.java with mapping annotations

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/getting-started.adoc

Example immutable entity using @Node, @Id, @Property, and relationship annotations. The include directive is not expanded; the actual code is not visible on this page.

```java
include::example$documentation/domain/MovieEntity.java[tags=mapping.annotations]
```

--------------------------------

### Multi-level projection example

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/projections/sdn-projections.adoc

Defines an interface-based projection with nested subprojections. The projection logic does not follow cycles, even if modeled, and only creates cycle-free queries. Multi-level projections are bounded to the entities they should project, and RelationshipProperties are treated as entities.

```java
interface ProjectionWithNestedProjection {

    String getName();

    List<Subprojection1> getLevel1();

    interface Subprojection1 {
        String getName();
        List<Subprojection2> getLevel2();
    }

    interface Subprojection2 {
        String getName();
    }
}
```

--------------------------------

### Domain model context: Person and Group entities

Source: https://github.com/spring-projects/spring-data-neo4j/wiki/Repository-query-methods

Defines the Person and Group domain classes with indexed properties and relationships, used as the context for query method examples.

```java
class Person {
    
  @Indexed
  private String name;
  private String age;

  @RelatedTo(type="members",direction=INCOMING)
  private Group group;

  // Getters and setters here
}

class Group {
    
  @Indexed
  private String name;

  @RelatedTo(type = "members", direction = Direction.OUTGOING)
  private Set<Person> members;
      
  // Getters and setters here
}
```

--------------------------------

### Cypher: Reduce nodes and relationships from paths

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/appendix/custom-queries.adoc

Uses the reduce function to flatten nodes and relationships from multiple paths into collections. Returns a tuple similar to the one-record example but with mixed relationship types or nodes.

```cypher
MATCH p=(m:Movie{title: 'The Matrix'})<-[:ACTED_IN]-(:Person)-[:ACTED_IN*..0]->(:Movie)
WITH collect(p) as paths, m
WITH m,
reduce(a=[], node in reduce(b=[], c in [aa in paths | nodes(aa)] | b + c) | case when node in a then a else a + node end) as nodes,
reduce(d=[], relationship in reduce(e=[], f in [dd in paths | relationships(dd)] | e + f) | case when relationship in d then d else d + relationship end) as relationships
RETURN m, relationships, nodes;
```

--------------------------------

### User Selection Provider Bean for Impersonation

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/faq.adoc

This bean provides a UserSelectionProvider that impersonates a user named 'someUser'. It is used in bootless imperative and reactive configurations to enable user impersonation in multi-tenant setups.

```java
import org.springframework.data.neo4j.core.UserSelection;
import org.springframework.data.neo4j.core.UserSelectionProvider;

public class CustomConfig {

    @Bean
    public UserSelectionProvider getUserSelectionProvider() {
        return () -> UserSelection.impersonate("someUser");
    }
}
```

--------------------------------

### Test setup without Spring Boot using AbstractNeo4jConfig

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/testing/testing-without-spring-boot.adoc

JUnit 5 integration test configuration for Spring Data Neo4j without Spring Boot. Extends AbstractNeo4jConfig, enables Neo4j repositories and transaction management, and defines a Driver bean connecting to a test server. The driver() method should provide a connection to your test server or container.

```java
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.neo4j.driver.AuthTokens;
import org.neo4j.driver.Driver;
import org.neo4j.driver.GraphDatabase;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.neo4j.config.AbstractNeo4jConfig;
import org.springframework.data.neo4j.core.Neo4jTemplate;
import org.springframework.data.neo4j.repository.config.EnableNeo4jRepositories;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@ExtendWith(SpringExtension.class)
class YourIntegrationTest {

	@Test
	void thingsShouldWork(@Autowired Neo4jTemplate neo4jTemplate) {
		// Add your test
	}

	@Configuration
	@EnableNeo4jRepositories(considerNestedRepositories = true)
	@EnableTransactionManagement
	static class Config extends AbstractNeo4jConfig {

		@Bean
		public Driver driver() {
			return GraphDatabase.driver("bolt://yourtestserver:7687", AuthTokens.none()); // <.>
		}
	}
}
```

--------------------------------

### Fragments using the plain driver

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/faq.adoc

Shows low-level interactions with the Neo4j Java-Driver for bulk operations like deleting subgraphs. The example uses a driver-managed transaction and returns the number of deleted nodes and relationships. Note: this interaction does not run in a Spring transaction.

```java
include::example$documentation/repositories/custom_queries/LowlevelInteractions.java[lines=18..]
```

```java
include::example$documentation/repositories/custom_queries/LowlevelInteractionsImpl.java[lines=18..]
```

--------------------------------

### Rich relationship mapping with @Relationship and Member POJO

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/etc/adr/general-discussion.adoc

Shows how to map a relationship with properties by annotating a field with @Relationship and using a POJO (Member) to hold the relationship properties. The Member class contains references to the start node (SoloArtistEntity) and two Year properties for the relationship's attributes.

```java
@Relationship("HAS_MEMBER", endNodeType = SoloArtistEntity.class)
private List<Member> member = new ArrayList<>();
```

```java
public static class Member {

	private SoloArtistEntity artist;

	private Year joinedIn;

	private Year leftIn;
}
```

--------------------------------

### Imperative health indicator method addHealthDetails

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/faq.adoc

Adds server and database details to a Spring Boot Health.Builder. Uses ResultSummary to get server and database info, and includes the database name if present.

```java
static void addHealthDetails(Health.Builder builder, String edition, ResultSummary resultSummary) {
		ServerInfo serverInfo = resultSummary.server();
		builder.up()
            .withDetail(
            	"server", serverInfo.version() + "@" + serverInfo.address())
            .withDetail("edition", edition);
		DatabaseInfo databaseInfo = resultSummary.database();
		if (StringUtils.hasText(databaseInfo.name())) {
			builder.withDetail("database", databaseInfo.name());
		}
	}
```

--------------------------------

### Making selected repository methods read-only

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/faq.adoc

Annotate individual repository methods with @Transactional(readOnly = true) to mark them as read-only. The example shows a derived finder and a custom @Query method, with notes explaining why read-only is not the default for custom queries.

```java
import org.springframework.data.neo4j.repository.Neo4jRepository;
import org.springframework.data.neo4j.repository.query.Query;
import org.springframework.transaction.annotation.Transactional;

interface PersonRepository extends Neo4jRepository<Person, Long> {

  @Transactional(readOnly = true)
  Person findOneByName(String name); // <.>

  @Transactional(readOnly = true)
  @Query("""
    CALL apoc.search.nodeAll('{Person: "name",Movie: ["title","tagline"]}','contains','her')
    YIELD node AS n RETURN n""")
  Person findByCustomQuery(); // <.>
}
```

--------------------------------

### Build with default settings on Windows

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/appendix/build.adoc

Runs the build with default settings using the Maven wrapper on Windows.

```console
$ mvnw.cmd clean verify
```

--------------------------------

### Use @DataNeo4jTest with Testcontainers Neo4j

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/testing/testing-with-spring-boot.adoc

Complete @DataNeo4jTest test using Testcontainers Neo4j. Starts a Neo4j container with an admin password, registers dynamic Spring properties for the Bolt URL and credentials, and closes the container after all tests. The test queries the node count and asserts it is 0.

```java
import static org.assertj.core.api.Assertions.assertThat;

import java.util.Optional;

import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.data.neo4j.DataNeo4jTest;
import org.springframework.data.neo4j.core.Neo4jClient;
import org.springframework.test.context.DynamicPropertyRegistry;
import org.springframework.test.context.DynamicPropertySource;
import org.testcontainers.neo4j.Neo4jContainer;

@DataNeo4jTest
class MovieRepositoryTCTest {

	private static Neo4jContainer neo4jContainer;

	@BeforeAll
	static void initializeNeo4j() {

		neo4jContainer = new Neo4jContainer()
			.withAdminPassword("somePassword");
		neo4jContainer.start();
	}

	@AfterAll
	static void stopNeo4j() {

		neo4jContainer.close();
	}

	@DynamicPropertySource
	static void neo4jProperties(DynamicPropertyRegistry registry) {

		registry.add("spring.neo4j.uri", neo4jContainer::getBoltUrl);
		registry.add("spring.neo4j.authentication.username", () -> "neo4j");
		registry.add("spring.neo4j.authentication.password", () -> "somePassword");
	}

	@Test
	public void findSomethingShouldWork(@Autowired Neo4jClient client) {

		Optional<Long> result = client.query("MATCH (n) RETURN COUNT(n)")
			.fetchAs(Long.class)
			.one();
		assertThat(result).hasValue(0L);
	}
}
```

--------------------------------

### Use @DataNeo4jTest with Neo4j 4.x/5.x test harness

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/testing/testing-with-spring-boot.adoc

Complete @DataNeo4jTest test using the Neo4j 4.x/5.x test harness. Starts an in-process embedded Neo4j with the HTTP server disabled, registers dynamic Spring properties for the Bolt URI and credentials, and shuts down the server after all tests. The test queries the node count and asserts it is 0.

```java
import static org.assertj.core.api.Assertions.assertThat;

import java.util.Optional;

import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.neo4j.harness.Neo4j;
import org.neo4j.harness.Neo4jBuilders;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.data.neo4j.DataNeo4jTest;
import org.springframework.data.neo4j.core.Neo4jClient;
import org.springframework.test.context.DynamicPropertyRegistry;
import org.springframework.test.context.DynamicPropertySource;

@DataNeo4jTest
class MovieRepositoryTest {

	private static Neo4j embeddedDatabaseServer;

	@BeforeAll
	static void initializeNeo4j() {

		embeddedDatabaseServer = Neo4jBuilders.newInProcessBuilder() // <.>
			.withDisabledServer() // <.>
			.build();
	}

	@DynamicPropertySource // <.>
	static void neo4jProperties(DynamicPropertyRegistry registry) {

		registry.add("spring.neo4j.uri", embeddedDatabaseServer::boltURI);
		registry.add("spring.neo4j.authentication.username", () -> "neo4j");
		registry.add("spring.neo4j.authentication.password", () -> null);
	}

	@AfterAll
	static void stopNeo4j() {

		embeddedDatabaseServer.close(); // <.>
	}

	@Test
	public void findSomethingShouldWork(@Autowired Neo4jClient client) {

		Optional<Long> result = client.query("MATCH (n) RETURN COUNT(n)")
			.fetchAs(Long.class)
			.one();
		assertThat(result).hasValue(0L);
	}
}
```

--------------------------------

### Create a basic Gradle project with the Spring Initializr

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/getting-started.adoc

Uses curl to generate a Gradle project with webflux and data-neo4j dependencies, extracting it into a folder named 'Neo4jSpringBootExampleGradle'.

```bash
curl https://start.spring.io/starter.tgz \
  -d dependencies=webflux,data-neo4j \
  -d type=gradle-project \
  -d bootVersion={spring-boot-version} \
  -d baseDir=Neo4jSpringBootExampleGradle \
  -d name=Neo4j%20SpringBoot%20Example | tar -xzvf -
```

--------------------------------

### Fragment declaring non-domain-type results

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/faq.adoc

Declares a repository fragment with a custom query method returning a non-domain type. The method is annotated with Spring's @Transactional. This fragment is required for the repository to start; without an implementation, startup fails.

```java
include::example$documentation/repositories/custom_queries/NonDomainResults.java[lines=18..]
```

--------------------------------

### Enabling and configuring Neo4j auditing

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/faq.adoc

Configuration class enabling auditing with @EnableNeo4jAuditing. The modifyOnCreate attribute controls whether modification data is written during creation. The auditorAwareRef and dateTimeProviderRef attributes specify beans for the auditor and date/time provider. The example also shows BeforeBindCallback and AfterConvertCallback beans that modify entities before save and after convert.

```java
@Configuration
@EnableNeo4jAuditing(modifyOnCreate = false, // <.>
		auditorAwareRef = "auditorProvider", // <.>
		dateTimeProviderRef = "fixedDateTimeProvider" // <.>
)
class AuditingConfig {

	@Bean
	AuditorAware<String> auditorProvider() {
		return () -> Optional.of("A user");
	}

	@Bean
	DateTimeProvider fixedDateTimeProvider() {
		return () -> Optional.of(AuditingITBase.DEFAULT_CREATION_AND_MODIFICATION_DATE);
	}

}
```

--------------------------------

### Create a basic Maven project with the Spring Initializr

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/getting-started.adoc

Uses curl to generate a Maven project with webflux and data-neo4j dependencies, extracting it into a folder named 'Neo4jSpringBootExample'.

```bash
curl https://start.spring.io/starter.tgz \
  -d dependencies=webflux,data-neo4j  \
  -d bootVersion={spring-boot-version} \
  -d baseDir=Neo4jSpringBootExample \
  -d name=Neo4j%20SpringBoot%20Example | tar -xzvf -
```

--------------------------------

### Build with default settings on Linux/macOS

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/appendix/build.adoc

Runs the build with default settings using the Maven wrapper on Linux or macOS.

```console
$ ./mvnw clean verify
```

--------------------------------

### Build documentation with Antora

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/CONTRIBUTING.adoc

Processes resources and builds the Antora documentation. The commands are intended to be run sequentially.

```bash
./mvnw process-resources -Pantora-process-resources
```

```bash
./mvnw antora:antora -Pfast,antora
```

--------------------------------

### Creating an instance of the imperative Neo4j client

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/appendix/neo4j-client.adoc

Creates a Neo4jClient using a driver instance. The driver is created with authentication tokens. The client is created via Neo4jClient.create(driver).

```java
import org.neo4j.driver.AuthTokens;
import org.neo4j.driver.Driver;
import org.neo4j.driver.GraphDatabase;

import org.springframework.data.neo4j.core.Neo4jClient;

public class Demo {

    public static void main(String...args) {

        Driver driver = GraphDatabase
            .driver("neo4j://localhost:7687", AuthTokens.basic("neo4j", "secret"));

        Neo4jClient client = Neo4jClient.create(driver);
    }
}
```

--------------------------------

### Create relationship between nodes

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/appendix/query-creation.adoc

Cypher statement that matches the start and end nodes and creates a relationship (Has) between them using MERGE.

```cypher
MATCH (startNode) WHERE id(startNode) = $fromId MATCH (endNode) WHERE id(endNode) = 631 MERGE (startNode)-[:Has]->(endNode)
```

--------------------------------

### Creating an instance of the reactive Neo4j client

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/appendix/neo4j-client.adoc

Creates a ReactiveNeo4jClient using a driver instance. The driver is created with authentication tokens. The client is created via ReactiveNeo4jClient.create(driver).

```java
import org.neo4j.driver.AuthTokens;
import org.neo4j.driver.Driver;
import org.neo4j.driver.GraphDatabase;

import org.springframework.data.neo4j.core.ReactiveNeo4jClient;

public class Demo {

    public static void main(String...args) {

        Driver driver = GraphDatabase
            .driver("neo4j://localhost:7687", AuthTokens.basic("neo4j", "secret"));

        ReactiveNeo4jClient client = ReactiveNeo4jClient.create(driver);
    }
}
```

--------------------------------

### Delete relationships of first found type

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/appendix/query-creation.adoc

Cypher statement that removes all relationships of a given type (Has) from the start node to related nodes (Hobby) when the entity is not new. Uses the parameter $fromId.

```cypher
MATCH (startNode)-[rel:Has]->(:Hobby) WHERE id(startNode) = $fromId DELETE rel
```

--------------------------------

### Inclusion of the spring-data-neo4j-spring-boot-starter in a Gradle project

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/getting-started.adoc

Add this dependency to your build.gradle to include the Spring Data Neo4j starter. This is required because the starter is not yet on the Spring Initializr.

```groovy
dependencies {
    implementation '{groupIdStarter}:{artifactIdStarter}'
}
```

--------------------------------

### Configure Neo4j credentials in application.properties

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/getting-started.adoc

Sets the Neo4j URI and authentication credentials. This is the bare minimum to connect to a Neo4j instance.

```properties
spring.neo4j.uri=bolt://localhost:7687
spring.neo4j.authentication.username=neo4j
spring.neo4j.authentication.password=verysecret
```

--------------------------------

### BookmarkCapture.java - listening for bookmark updates

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/faq.adoc

Implements ApplicationListener<Neo4jBookmarksUpdatedEvent> to capture the latest bookmarks from the SDN transaction system.

```java
import java.util.Set;

import org.neo4j.driver.Bookmark;
import org.springframework.context.ApplicationListener;

public final class BookmarkCapture
	implements ApplicationListener<Neo4jBookmarksUpdatedEvent> {

	@Override
	public void onApplicationEvent(Neo4jBookmarksUpdatedEvent event) {
		// We make sure that this event is called only once,
		// the thread safe application of those bookmarks is up to your system.
		Set<Bookmark> latestBookmarks = event.getBookmarks();
	}
}
```

--------------------------------

### Domain model with interface and implementing class

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/object-mapping/metadata-based-mapping.adoc

Demonstrates using an interface for a domain model where the implementing class is annotated with @Node to synchronize primary labels.

```java
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;

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 org.springframework.data.neo4j.core.schema.RelationshipId;
import org.springframework.data.neo4j.core.schema.RelationshipProperties;
import org.springframework.data.neo4j.core.schema.TargetNode;

public interface SomeInterface { // <.>

	String getName();

	SomeInterface getRelated();
}

@Node("SomeInterface") // <.>
public static class SomeInterfaceEntity implements SomeInterface {

    @Id
    @GeneratedValue
    private Long id;

    private final String name;

    private SomeInterface related;

    public SomeInterfaceEntity(String name) {
        this.name = name;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public SomeInterface getRelated() {
        return related;
    }

    public Long getId() {
        return id;
    }

    public void setRelated(SomeInterface related) {
        this.related = related;
    }
}
```

--------------------------------

### Run integration tests against local Neo4j instance

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/CONTRIBUTING.adoc

Runs the integration tests using a locally running Neo4j instance by setting the connection URL and password via environment variables SDN_NEO4J_URL and SDN_NEO4J_PASSWORD.

```bash
SDN_NEO4J_URL=bolt://localhost:7687 \
SDN_NEO4J_PASSWORD=verysecret \
./mvnw verify
```

--------------------------------

### Minimal module-info.java for Spring Data Neo4j on module path

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/getting-started.adoc

Required module descriptor for running Spring Data Neo4j 6.1+ on the module path. Requires org.neo4j.cypherdsl.core, spring.data.commons, and spring.data.neo4j. Domain packages must be opened to spring.core and exported for repository access by spring.beans, spring.context, and spring.data.commons.

```java
module your.module {

	requires org.neo4j.cypherdsl.core;

	requires spring.data.commons;
	requires spring.data.neo4j;

	opens your.domain to spring.core; // <1>

	exports your.domain; // <2>
}
```

--------------------------------

### Add license headers with license plugin

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/CONTRIBUTING.adoc

Automatically adds required license headers to new source files.

```bash
./mvnw license:format
```

--------------------------------

### Build using a locally running database

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/appendix/build.adoc

Builds against a locally running Neo4j instance by setting the bolt URL and password. Warning: this will erase the database content.

```console
$ SDN_NEO4J_URL=bolt://localhost:7687 SDN_NEO4J_PASSWORD=verysecret ./mvnw clean verify
```

--------------------------------

### Retrieving result summaries in a reactive way

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/appendix/neo4j-client.adoc

Demonstrates reactive execution of a query and subscribing to the publisher to trigger the query, printing the number of deleted nodes.

```java
Mono<ResultSummary> summary = reactiveClient
    .query("MATCH (m:Movie) where m.title = 'Aeon Flux' DETACH DELETE m")
    .run();

summary
    .map(ResultSummary::counters)
    .subscribe(counters ->
        System.out.println(counters.nodesDeleted() + " nodes have been deleted")
    ); // <.>

```

--------------------------------

### Specifying a query with client.query()

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/appendix/neo4j-client.adoc

Shows how to specify a Cypher query using the Neo4j client's query method and fetch the first result as a Mono.

```java
Mono<Map<String, Object>> firstActor = client
	.query(() -> "MATCH (p:Person) RETURN p")
	.fetch()
	.first();

```

--------------------------------

### Reactive Neo4j configuration without Spring Boot

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/README.adoc

Configure SDN for reactive database access in a plain Spring Framework project without Spring Boot.

```java
@Configuration
@EnableReactiveNeo4jRepositories
@EnableTransactionManagement
class MyConfiguration extends AbstractReactiveNeo4jConfig {

    @Bean
    public Driver driver() {
        return GraphDatabase.driver("bolt://localhost:7687", AuthTokens.basic("neo4j", "secret"));
    }

    @Override
    protected Collection<String> getMappingBasePackages() {
        return Collections.singletonList(Person.class.getPackage().getName());
    }
}
```

--------------------------------

### Skip tests and validations with fast profile

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/CONTRIBUTING.adoc

Packages the project using the 'fast' profile, which skips all tests and validations. Useful for quick local builds.

```bash
./mvnw package -Pfast
```

--------------------------------

### Custom Neo4jTransactionManager with bookmark manager

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/faq.adoc

Shows how to create a custom Neo4jTransactionManager with a Neo4jBookmarkManager, allowing custom bookmark handling. The bookmark supplier can be anything that holds the latest bookmarks. This is only needed if your application must access or provide bookmark data.

```java
Neo4jBookmarkManager bookmarkManager =
			Neo4jBookmarkManager.create(bookmarkSupplier); // <.>
		return new Neo4jTransactionManager(
			driver, databaseNameProvider, bookmarkManager); // <.>
	}
}
```

--------------------------------

### Mapping simple types with bind() and bindAll()

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/appendix/neo4j-client.adoc

Shows how to bind simple types and a map of named parameters to a Cypher query using the fluent API.

```java
Map<String, Object> parameters = new HashMap<>();
parameters.put("name", "Li.*");

Flux<Map<String, Object>> directorAndMovies = client
	.query(
		"MATCH (p:Person) - [:DIRECTED] -> (m:Movie {title: $title}), (p) - [:WROTE] -> (om:Movie) " +
			"WHERE p.name =~ $name " +
			"  AND p.born < $someDate.year " +
			"RETURN p, om"
	)
	.bind("The Matrix").to("title") // <.>
	.bind(LocalDate.of(1979, 9, 21)).to("someDate")
	.bindAll(parameters) // <.>
	.fetch()
	.all();

```

--------------------------------

### Enable NullAway profile in Maven build (feature: -Pnullaway)

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/CONTRIBUTING.adoc

Runs the build with the NullAway static analysis profile to detect potential null-safety issues. This is optional and complements the standard JSpecify annotations.

```bash
./mvnw verify -Pnullaway
```

--------------------------------

### Build using a different Neo4j Docker image

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/appendix/build.adoc

Builds using a specific Neo4j Docker image version and accepts the commercial edition license.

```console
$ SDN_NEO4J_VERSION=5.3.0-enterprise SDN_NEO4J_ACCEPT_COMMERCIAL_EDITION=yes ./mvnw clean verify
```

--------------------------------

### Include Spring Boot Starter Test in a Maven build

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/testing/testing-with-spring-boot.adoc

Adds the spring-boot-starter-test dependency to a Maven pom.xml for using @DataNeo4jTest.

```xml
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
```

--------------------------------

### Clone SDN repository

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/appendix/build.adoc

Clones the Spring Data Neo4j repository from GitHub.

```console
$ git clone git@github.com:spring-projects/spring-data-neo4j.git
```

--------------------------------

### Use ApplicationContextInitializer to inject dynamic properties

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/testing/testing-with-spring-boot.adoc

Alternative to @DynamicPropertySource for injecting Neo4j properties via an initializer. The test class sets up a Neo4j container and applies properties to the environment.

```java
@ContextConfiguration(initializers = PriorToBoot226Test.Initializer.class)
@DataNeo4jTest
class PriorToBoot226Test {

    private static Neo4jContainer neo4jContainer;

    @BeforeAll
    static void initializeNeo4j() {

        neo4jContainer = new Neo4jContainer()
            .withAdminPassword("somePassword");
        neo4jContainer.start();
    }

    @AfterAll
    static void stopNeo4j() {

        neo4jContainer.close();
    }

    static class Initializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
        public void initialize(ConfigurableApplicationContext configurableApplicationContext) {
            TestPropertyValues.of(
                "spring.neo4j.uri=" + neo4jContainer.getBoltUrl(),
                "spring.neo4j.authentication.username=neo4j",
                "spring.neo4j.authentication.password=" + neo4jContainer.getAdminPassword()
            ).applyTo(configurableApplicationContext.getEnvironment());
        }
    }
}
```

--------------------------------

### Include Spring Boot Starter Test in a Gradle build

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/testing/testing-with-spring-boot.adoc

Adds the spring-boot-starter-test dependency to a Gradle build for using @DataNeo4jTest.

```groovy
dependencies {
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}
```

--------------------------------

### Define a Driver bean using a test container

Source: https://github.com/spring-projects/spring-data-neo4j/blob/main/src/main/antora/modules/ROOT/pages/testing/testing-with-spring-boot.adoc

A static configuration class that creates a Neo4j Driver bean using the test container's Bolt URL and admin password. This gives full control over driver initialization.

```java
@TestConfiguration(proxyBeanMethods = false)
static class TestNeo4jConfig {

    @Bean
    Driver driver() {
        return GraphDatabase.driver(
        		neo4jContainer.getBoltUrl(),
        		AuthTokens.basic("neo4j", neo4jContainer.getAdminPassword())
        );
    }
}
```
Tokens:
Raw