Spring Boot Data Neo4j图数据库集成测试实战指南

1. 项目概述：为什么需要为Spring Boot Data Neo4j编写图测试？

在开发基于Neo4j图数据库的Spring Boot应用时，我们常常会陷入一种“数据层信任危机”。你写好了 @Node 实体和 @Relationship 注解，也定义了漂亮的 Repository 接口，通过 Neo4jTemplate 执行了几个简单的Cypher查询，在开发环境里跑得飞快。但当你把应用部署到测试环境，或者尝试执行一个涉及多跳关系、复杂路径查找的查询时，问题就来了：返回的数据结构对吗？关系方向有没有搞反？那个精心设计的 @Query 注解里的Cypher语句，在真实图数据上真的能按预期工作吗？

这就是图测试的价值所在。它不同于传统的单元测试（只测Java对象逻辑）或简单的集成测试（只测数据库连接）。图测试的核心是验证 应用程序的业务逻辑与图数据库中的数据模型、查询语义是否精确对齐 。JUnit4作为Java生态中久经考验的测试框架，结合Spring Boot Test提供的强大容器支持，为我们搭建一个稳定、可重复的图测试环境提供了完美的工具链。通过这套组合拳，我们可以在内存中或隔离的测试数据库中，构造出特定的图数据场景，然后断言我们的查询、保存和删除操作，是否在图这个独特的结构世界里产生了正确的结果。这不仅提升了代码质量，更是将图数据库这种“ schema-lite ”（轻模式）但“ semantics-heavy ”（重语义）的数据存储的不可预测性，牢牢地掌控在了开发阶段。

2. 环境准备与项目骨架搭建

2.1 依赖配置：选对版本是关键

第一步，在你的 pom.xml 或 build.gradle 中引入正确的依赖。版本兼容性是Spring Boot项目的老生常谈，但对于Neo4j来说更是重中之重，因为其驱动和OGM（Object-Graph Mapping）的API变动可能比较频繁。

对于Spring Boot 2.x（这是目前大多数存量项目的主流），我推荐以下配置。注意，我们使用JUnit4的 spring-boot-starter-test ，它默认包含了JUnit4、Mockito、AssertJ等。

<dependencies>
    <!-- Spring Boot Data Neo4j Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-neo4j</artifactId>
    </dependency>

    <!-- Spring Boot Test Starter (JUnit4) -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <!-- 排除JUnit5，确保使用JUnit4 -->
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
            <exclusion>
                <groupId>org.junit.jupiter</groupId>
                <artifactId>junit-jupiter</artifactId>
            </exclusion>
        </exclusions>
    </dependency>

    <!-- 显式引入JUnit4 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <scope>test</scope>
    </dependency>

    <!-- 测试中可能需要用到嵌入式Neo4j（非必须，见下文解析） -->
    <!-- <dependency>
        <groupId>org.neo4j</groupId>
        <artifactId>neo4j-ogm-embedded-driver</artifactId>
        <scope>test</scope>
    </dependency> -->
</dependencies>

注意：关于嵌入式Neo4j驱动 ： neo4j-ogm-embedded-driver 依赖可以让你在JVM进程中启动一个真正的、但非持久化的Neo4j数据库实例进行测试。这听起来很完美，但它有两个显著缺点：1) 启动速度相对较慢；2) 与Neo4j社区版/企业版的版本绑定可能带来冲突。对于大多数 集成测试 ，我个人的建议是使用一个 独立的、专用的测试Neo4j数据库实例 （通过Docker Compose或测试环境配置），这更接近生产环境。嵌入式驱动更适合纯粹的、隔离的 单元测试 场景。本文后续的“完整实践”将基于独立的测试数据库来展开，因为它更具普适性和实战价值。

2.2 测试配置类与属性文件

接下来，我们需要为测试环境准备专门的配置。在 src/test/resources 目录下创建 application-test.properties （或 .yml ）。

# application-test.properties
spring.data.neo4j.uri=bolt://localhost:7687
spring.data.neo4j.authentication.username=neo4j
spring.data.neo4j.authentication.password=testPassword123

# 在测试中，我们通常不希望自动生成模式（如创建约束、索引）
# 因为测试数据应由测试用例完全控制，且测试库可能被频繁清空
spring.data.neo4j.auto-index=none

# 可选：配置连接池大小，测试时不需要太大
spring.data.neo4j.connection.pool.max-connection-pool-size=10

然后，创建一个基础的测试配置类。这个类的作用是启用特定的测试配置Profile，并为测试场景提供一些公共的Bean。

import org.neo4j.ogm.session.Session;
import org.neo4j.ogm.session.SessionFactory;
import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Profile;
import org.springframework.data.neo4j.repository.config.EnableNeo4jRepositories;

@TestConfiguration
@Profile("test") // 指定该配置仅在`test` profile下激活
@EnableNeo4jRepositories(basePackages = "com.yourcompany.yourproject.repository")
public class Neo4jTestConfig {

    /**
     * 提供一个测试用的Session Bean。
     * 在实际测试中，Spring Boot会自动配置SessionFactory，
     * 但这里我们可以定义一些测试专用的行为，例如在每次测试后清理数据库。
     * 更常见的做法是使用`@Transactional`注解或`TestEntityManager`，
     * 但对于图数据库，有时直接使用Session执行原生Cypher进行清理更直接。
     */
    @Bean
    public Session neo4jSession(SessionFactory sessionFactory) {
        return sessionFactory.openSession();
    }
}

这个配置类目前比较简单，但它预留了位置。例如，你可以在这里定义一个 @PostConstruct 方法，在测试SessionFactory创建后，执行一些初始化Cypher（如创建测试专用的索引）。

3. 核心测试策略与模型设计

3.1 测试金字塔在图数据库场景的应用

测试金字塔（单元测试->集成测试->端到端测试）的理念在这里依然适用，但内涵有所不同。

1. 单元测试（占比最大） ：测试不依赖Neo4j数据库的纯Java逻辑。例如，你的 Service 层方法中的业务计算、转换逻辑。使用Mockito等框架将 Repository 完全Mock掉。这部分测试速度快，与数据库无关。
2. 图数据集成测试（本文重点） ：测试 Repository 接口、自定义的Cypher @Query 、以及 Neo4jTemplate 与真实Neo4j数据库的交互。这是验证 数据访问层正确性 的核心。每个测试类对应一个 Repository ，每个测试方法验证一个特定的图查询或操作场景。
3. API集成测试 ：使用 @SpringBootTest 启动整个应用上下文，测试 Controller 层。此时会调用真实的 Service 和 Repository ，连接测试数据库。这验证了从API入口到数据库的完整链路。

我们的实践指南聚焦在第二层： 图数据集成测试 。这是确保你的图模型和查询没跑偏的关键防线。

3.2 设计可测试的图数据模型

假设我们有一个简单的“电影-人物”图模型，这是Neo4j的经典示例。为了测试，我们需要让实体类尽可能清晰。

// Movie.java
@Node("Movie")
@Data // 使用Lombok简化，需自行添加依赖
@NoArgsConstructor
@AllArgsConstructor
public class Movie {
    @Id
    @GeneratedValue
    private Long id;

    @Property("title")
    private String title;

    @Property("released")
    private Integer releaseYear;

    // 定义指向Person节点，关系类型为`ACTED_IN`的关系
    @Relationship(type = "ACTED_IN", direction = Relationship.Direction.INCOMING)
    private List<Role> actors = new ArrayList<>();

    // 定义指向Person节点，关系类型为`DIRECTED`的关系
    @Relationship(type = "DIRECTED", direction = Relationship.Direction.INCOMING)
    private List<Person> directors = new ArrayList<>();
}

// Person.java
@Node("Person")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Person {
    @Id
    @GeneratedValue
    private Long id;

    @Property("name")
    private String name;

    @Property("born")
    private Integer born;

    // 这里通常不直接定义反向关系，避免循环引用。关系主要在Movie端定义。
}

// Role.java
// 这是一个关系实体（Relationship Entity），用于表示`ACTED_IN`关系上的属性
@RelationshipEntity(type = "ACTED_IN")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Role {
    @Id
    @GeneratedValue
    private Long id;

    @StartNode
    private Person person;

    @EndNode
    private Movie movie;

    @Property("roles")
    private List<String> roleNames; // 一个人在一部电影中可能扮演多个角色
}

实操心得：关系实体的使用 ： @RelationshipEntity 非常强大，它允许你将关系（边）本身也作为一个富实体来对待，拥有自己的属性和ID。在测试中，这意味你可以精确地断言关系的属性值。但要注意，这会增加模型的复杂度。如果关系没有属性，直接用 @Relationship 的 List<Person> 会更简单。在测试设计时，要根据业务查询的需要来决定模型的精细度。

4. 编写图数据集成测试：从简单到复杂

4.1 基础测试类搭建与数据清理

我们为 MovieRepository 编写测试。首先创建测试类骨架。

import com.yourcompany.yourproject.config.Neo4jTestConfig;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.neo4j.ogm.session.Session;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.transaction.annotation.Transactional;

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

@RunWith(SpringRunner.class) // JUnit4 Runner
@SpringBootTest // 启动Spring应用上下文
@ActiveProfiles("test") // 激活`test` profile，使用我们的测试配置
public class MovieRepositoryTest {

    @Autowired
    private MovieRepository movieRepository;

    @Autowired
    private Session session; // 注入我们在配置类中定义的Session，用于执行原生Cypher

    @Before
    public void setUp() {
        // 在每个测试方法执行前，清空数据库，确保测试隔离性
        // 这是图测试非常关键的一步！
        session.purgeDatabase();
    }

    @After
    public void tearDown() {
        // 通常`setUp`中的清理已足够。这里可以留空或执行一些全局的断言。
    }
}

重要警告： session.purgeDatabase() ：这个方法会 删除数据库中的所有节点和关系 ，相当于 MATCH (n) DETACH DELETE n 。它非常高效，但破坏性极强。 务必确保你的测试配置（ spring.data.neo4j.uri ）指向的是一个专用于测试的数据库实例，而不是开发或生产数据库！ 我通常通过Docker启动一个独立的Neo4j容器，其数据卷是临时的，专门用于CI/CD流水线。

4.2 测试场景一：基本CRUD与派生查询

Spring Data Neo4j提供了强大的派生查询（Derived Query）功能，方法名即查询。我们来测试这些。

@Test
public void shouldSaveAndRetrieveMovie() {
    // Given
    Movie movie = new Movie(null, "The Matrix", 1999, new ArrayList<>(), new ArrayList<>());

    // When
    Movie savedMovie = movieRepository.save(movie);
    // 注意：save操作后，实体的id会被填充

    // Then
    assertThat(savedMovie.getId()).isNotNull();
    assertThat(savedMovie.getTitle()).isEqualTo("The Matrix");

    // 验证是否能通过ID查回来
    Movie foundMovie = movieRepository.findById(savedMovie.getId()).orElse(null);
    assertThat(foundMovie).isNotNull();
    assertThat(foundMovie.getTitle()).isEqualTo(savedMovie.getTitle());
}

@Test
public void shouldFindMoviesByReleaseYear() {
    // Given
    Movie matrix = new Movie(null, "The Matrix", 1999, new ArrayList<>(), new ArrayList<>());
    Movie reloaded = new Movie(null, "The Matrix Reloaded", 2003, new ArrayList<>(), new ArrayList<>());
    movieRepository.save(matrix);
    movieRepository.save(reloaded);

    // When
    List<Movie> moviesFrom1999 = movieRepository.findByReleaseYear(1999);

    // Then
    assertThat(moviesFrom1999).hasSize(1);
    assertThat(moviesFrom1999.get(0).getTitle()).isEqualTo("The Matrix");
}

这里 findByReleaseYear 是派生查询，SDN会自动将其翻译为Cypher： MATCH (m:Movie) WHERE m.released = $0 RETURN m 。测试验证了这种翻译是正确的。

4.3 测试场景二：包含关系的保存与抓取

这是图数据库测试的核心。我们需要验证节点间的关系是否能被正确地持久化和加载。

@Test
public void shouldSaveAndLoadMovieWithActorsAndRoles() {
    // Given: 构建一个完整的图结构对象
    Person keanu = new Person(null, "Keanu Reeves", 1964);
    Person laurence = new Person(null, "Laurence Fishburne", 1961);

    Role keanuRole = new Role(null, keanu, null, Arrays.asList("Neo"));
    Role laurenceRole = new Role(null, laurence, null, Arrays.asList("Morpheus"));

    Movie matrix = new Movie(null, "The Matrix", 1999, new ArrayList<>(), new ArrayList<>());
    // 建立双向关联
    keanuRole.setMovie(matrix);
    laurenceRole.setMovie(matrix);
    matrix.setActors(Arrays.asList(keanuRole, laurenceRole));

    // When: 保存电影节点。由于配置了级联关系，关联的Person和Role也会被保存。
    Movie savedMovie = movieRepository.save(matrix);
    // 清空Session缓存，强制从数据库重新加载，验证持久化结果
    session.clear();

    // Then: 通过ID重新查询，并验证关系图
    Movie loadedMovie = movieRepository.findById(savedMovie.getId()).orElseThrow();

    assertThat(loadedMovie.getActors()).hasSize(2);
    // 验证关系实体Role的属性
    assertThat(loadedMovie.getActors())
            .extracting(Role::getPerson)
            .extracting(Person::getName)
            .containsExactlyInAnyOrder("Keanu Reeves", "Laurence Fishburne");

    assertThat(loadedMovie.getActors().get(0).getRoleNames()).containsExactly("Neo");
}

踩坑记录：Session缓存与 session.clear() ：Neo4j OGM的 Session 有一级缓存。当你 save 一个对象后，后续从同一个 Session 中 findById ，可能会直接返回缓存中的对象，而不会去数据库查询。这会导致你的测试“虚假通过”，因为它没有真正测试数据库的持久化。在验证持久化效果时， 在 save 之后、再次查询之前，调用 session.clear() 来清除缓存 是一个好习惯。这确保了后续查询是真正命中数据库的。

4.4 测试场景三：自定义 @Query 注解的Cypher查询

自定义查询是图数据库应用的灵魂，测试它们至关重要。

首先，在 MovieRepository 中添加一个复杂查询：

public interface MovieRepository extends Neo4jRepository<Movie, Long> {
    // ... 其他派生查询

    @Query("MATCH (m:Movie)<-[r:ACTED_IN]-(p:Person) " +
           "WHERE m.title = $title " +
           "RETURN p, r, m ORDER BY p.name")
    List<Person> findActorsByMovieTitle(@Param("title") String title);
}

然后为它编写测试：

@Test
public void shouldFindActorsByMovieTitleUsingCustomQuery() {
    // Given: 构建并保存一个更复杂的图
    Person keanu = new Person(null, "Keanu Reeves", 1964);
    Person laurence = new Person(null, "Laurence Fishburne", 1961);
    Person carrie = new Person(null, "Carrie-Anne Moss", 1967);

    Movie matrix = new Movie(null, "The Matrix", 1999, new ArrayList<>(), new ArrayList<>());

    List<Role> roles = Arrays.asList(
        new Role(null, keanu, matrix, Arrays.asList("Neo")),
        new Role(null, laurence, matrix, Arrays.asList("Morpheus")),
        new Role(null, carrie, matrix, Arrays.asList("Trinity"))
    );
    matrix.setActors(roles);
    movieRepository.save(matrix);
    session.clear();

    // When: 执行自定义查询
    List<Person> actors = movieRepository.findActorsByMovieTitle("The Matrix");

    // Then
    assertThat(actors).hasSize(3);
    assertThat(actors)
            .extracting(Person::getName)
            .containsExactly("Carrie-Anne Moss", "Keanu Reeves", "Laurence Fishburne"); // 注意ORDER BY p.name
}

这个测试验证了：

1. @Query 中的Cypher语法是否正确。
2. 参数绑定 $title 是否工作。
3. 查询返回的结果映射（这里返回的是 Person 列表）是否符合预期。
4. ORDER BY 子句是否生效。

4.5 测试场景四：使用 Neo4jTemplate 执行复杂操作

有些操作不适合写在 @Query 里，或者你需要更动态地构建Cypher。这时 Neo4jTemplate 是更好的选择。

@Autowired
private Neo4jTemplate neo4jTemplate;

@Test
public void shouldExecuteComplexCypherViaTemplate() {
    // Given: 使用Session快速插入一些测试数据（比通过Repository更快）
    session.query("CREATE (m:Movie {title: 'Inception', released: 2010})" +
                  "CREATE (p:Person {name: 'Leonardo DiCaprio', born: 1974})" +
                  "CREATE (p)-[:ACTED_IN {roles: ['Cobb']}]->(m)", Collections.emptyMap());

    // When: 使用Neo4jTemplate执行一个返回自定义DTO（非实体）的查询
    String cypher = "MATCH (p:Person)-[r:ACTED_IN]->(m:Movie) " +
                    "WHERE m.title = $movieTitle " +
                    "RETURN p.name as actorName, r.roles as roles, m.released as releaseYear";
    Map<String, Object> parameters = Collections.singletonMap("movieTitle", "Inception");

    // 使用`neo4jTemplate.query`返回一个Result（可迭代的Map）
    Iterable<Map<String, Object>> result = neo4jTemplate.query(cypher, parameters);

    // Then: 验证返回的数据
    List<Map<String, Object>> resultList = new ArrayList<>();
    result.forEach(resultList::add);

    assertThat(resultList).hasSize(1);
    Map<String, Object> row = resultList.get(0);
    assertThat(row.get("actorName")).isEqualTo("Leonardo DiCaprio");
    assertThat((List<String>)row.get("roles")).containsExactly("Cobb");
    assertThat(row.get("releaseYear")).isEqualTo(2010L); // Neo4j返回的整数是Long类型
}

注意事项： Neo4jTemplate vs Session ： Neo4jTemplate 是Spring Data Neo4j提供的一个更高级的抽象，它集成了Spring的异常转换和事务管理。 Session 是Neo4j OGM的核心接口，更底层。在测试中，对于简单的数据准备（如 Given 阶段），直接用 Session.query 可能更直接。对于测试业务逻辑中使用的复杂查询，应使用与生产代码相同的方式，即注入 Neo4jTemplate 来测试。

5. 高级测试技巧与问题排查

5.1 使用 @Transactional 管理测试数据

虽然我们在 @Before 中清理了整个数据库，但有时我们希望每个测试方法在一个事务中运行，测试结束后自动回滚，这样更快且不影响其他测试。Spring Test默认会为测试方法回滚事务，但Neo4j OGM与Spring事务的集成需要一点配置。

确保你的主应用配置或测试配置启用了Neo4j事务管理：

// 在主应用类或配置类上
@SpringBootApplication
@EnableTransactionManagement // 确保此注解存在
public class YourApplication { ... }

然后在测试类上添加 @Transactional 注解：

@RunWith(SpringRunner.class)
@SpringBootTest
@ActiveProfiles("test")
@Transactional // 每个测试方法都在事务中执行，方法结束后回滚
public class MovieRepositoryTransactionalTest {
    @Autowired
    private MovieRepository repository;

    @Test
    public void testWithinTransaction() {
        Movie m = new Movie(null, "Test Movie", 2023, new ArrayList<>(), new ArrayList<>());
        repository.save(m);
        // 此时数据在事务内，对同一事务内的查询可见
        assertThat(repository.findByTitle("Test Movie")).isNotEmpty();
    }
    // 测试方法结束后，保存的Movie会被回滚，数据库状态不变
}

重要提示 ：使用 @Transactional 时， 不要 在 @Before 或 @After 方法中调用 session.purgeDatabase() 或执行任何会提交数据的操作，否则会破坏事务语义。这种模式适合测试 读操作 或 不依赖数据库绝对干净状态 的写操作组合测试。对于需要绝对干净状态的测试，还是用 purgeDatabase 更可靠。

5.2 常见问题排查实录

问题1：测试通过，但生产环境查询慢或结果不对。

• 排查思路 ：测试数据库可能是空的或数据量很小，而生产数据库有上千万节点。查询性能和数据分布强相关。
• 解决技巧 ：在测试中，不仅要测试“正确性”，还要有意识地为 性能测试 做准备。可以编写一个单独的测试类，使用 Session 批量插入 模拟生产数据量级和分布 的数据（例如，使用 UNWIND range(1,100000) AS i CREATE (:Person {id: i}) ），然后针对核心查询进行计时断言。确保你的Cypher查询使用了索引。
• 在测试中创建索引 ：可以在测试配置类或一个 @BeforeClass 方法中，通过 Session 执行 CREATE INDEX ON :Person(name) 。但要记得这些索引在测试结束后（如果不用 @Transactional ）会留在测试库里。

问题2： LazyInitializationException （懒加载异常）。

• 现象 ：在测试方法外部（如 assertThat 的提取方法中）访问未加载的关系集合时抛出异常。
• 原因 ：Neo4j OGM默认对关系是懒加载的。当测试方法结束，事务关闭（如果用了 @Transactional ）或Session关闭后，再尝试访问关系就会出错。
• 解决方案 ：
  1. 在事务内完成所有访问 ：确保所有对关联数据的断言都在测试方法内部完成。
  2. 使用 @Transactional ：确保整个测试方法在同一个事务和Session中。
  3. 主动抓取 ：在自定义 @Query 中使用 FETCH 关键字，如 MATCH (m:Movie)-[r:ACTED_IN]->(p:Person) RETURN m, COLLECT(r), COLLECT(p) ，或者在派生查询返回后，手动调用 session.load(entity.getClass(), entity.getId(), 1) 指定加载深度。

问题3：测试数据构造繁琐，代码冗长。

• 解决技巧 ：使用 测试数据构建器模式（Test Data Builder） 或像 Instancio 、 Datafaker 这样的库来生成随机但合理的测试数据。对于图数据，可以编写一个 GraphTestUtils 工具类，提供诸如 createMovieWithActors(String title, String... actorNames) 这样的方法，让测试的 Given 部分更清晰。

问题4：集成测试运行太慢。

• 原因 ：启动真实的Neo4j数据库（即使是Docker容器）和Spring上下文需要时间。
• 优化策略 ：
  1. 使用 @DataNeo4jTest 注解 ：这是Spring Boot Test提供的切片测试注解，它只会加载与Neo4j相关的配置（Repository、Entity等），大大减少上下文启动时间。将它与嵌入式驱动结合，可以快速运行。

     @RunWith(SpringRunner.class)
     @DataNeo4jTest // 关键注解
     @AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE) // 如果使用外部测试数据库
     public class MovieRepositorySliceTest { ... }
     

  2. 复用Spring上下文 ：如果多个测试类使用相同的配置，JUnit和Spring会尝试缓存并复用应用上下文。确保你的测试类结构合理。
  3. 区分测试类型 ：将快速的单元测试（Mockito）和慢的集成测试分开，在Maven/Gradle中配置不同的profile或任务来分别执行。

5.3 测试数据工厂示例

为了提升测试代码的可读性和可维护性，创建一个简单的测试数据工厂类：

// MovieTestFactory.java
public class MovieTestFactory {

    public static Movie createSimpleMovie(String title, int year) {
        return new Movie(null, title, year, new ArrayList<>(), new ArrayList<>());
    }

    public static Movie createMovieWithActors(String title, int year, Map<String, List<String>> actorToRoles) {
        Movie movie = createSimpleMovie(title, year);
        List<Role> roles = new ArrayList<>();

        for (Map.Entry<String, List<String>> entry : actorToRoles.entrySet()) {
            Person actor = new Person(null, entry.getKey(), 1970); // 简化，出生年份固定
            Role role = new Role(null, actor, movie, entry.getValue());
            roles.add(role);
        }
        movie.setActors(roles);
        return movie;
    }
}

在测试中使用：

@Test
public void shouldFindMovieWithComplexActors() {
    // Given
    Map<String, List<String>> cast = new HashMap<>();
    cast.put("Keanu Reeves", Arrays.asList("Neo", "Thomas A. Anderson"));
    cast.put("Laurence Fishburne", Arrays.asList("Morpheus"));
    Movie matrix = MovieTestFactory.createMovieWithActors("The Matrix", 1999, cast);
    movieRepository.save(matrix);
    session.clear();

    // When & Then ... 测试逻辑
}

这种方式让测试意图（“创建一部带有特定演员阵容的电影”）一目了然，避免了在测试方法中堆积大量的 new 和 set 语句。

6. 总结与持续集成建议

为Spring Boot Data Neo4j应用编写扎实的图测试，是一个从“信任代码”到“信任数据交互”的思维转变。通过JUnit4和Spring Boot Test，我们能够构建一个从简单CRUD到复杂图遍历的全方位测试网。

回顾一下关键点： 使用独立的测试数据库 并通过 session.purgeDatabase() 保证隔离性； 在验证持久化后调用 session.clear() 避免缓存误导； 精心设计测试数据 以覆盖关系的保存、加载和查询； 对自定义 @Query 进行严格断言 ；并善用 @DataNeo4jTest 进行切片测试以提升速度。

最后，将这套测试集成到你的CI/CD流水线中。确保流水线能自动启动一个Neo4j测试容器（例如使用Testcontainers库，它提供了 @Neo4jContainer 注解），在每个构建中运行这些集成测试。这样，任何对图模型或Cypher查询的修改，都会立即得到反馈，从而让你在驾驭图数据库这种强大而灵活的工具时，拥有十足的信心。记住，好的图测试不仅是找Bug，更是对你领域模型的一种可执行文档，它清晰地说明了数据应该如何连接和流动。