是否有使用Neo4j 5扩展模型的JUnit测试工具？

Question

在编写Neo4j测试用例时，我希望只使用JUnit 5扩展模型，而不使用org.junit.vintage或junit-jupiter-migrationsupport。目前，我只能找到JUnit 4的JUnit测试工具，它使用TestRule，依赖于org.junit.vintage和junit-jupiter-migrationsupport。

是否有使用扩展模型的Neo4j JUnit 5测试工具？

参考文献：

Neo4j：首页，GitHub

Neo4j test-harness：Maven，GitHub，pom.xml

JUnit 4：GitHub

JUnit 4 TestRule：JUnit 4指南，JUnit 4.12 API，Neo4jRule GitHub

JUnit 5：GitHub

JUnit 5 Extension Model：JUnit 5用户指南，GitHub

JUnit 5 org.junit.vintage：JUnit 5用户指南，测试线束pom.xml

JUnit 5 junit-jupiter-migrationsupport：JUnit 5用户指南，测试线束pom.xml

我知道在混合环境中使用JUnit 4和JUnit 5是可能的，例如混合JUnit 4和JUnit 5试验。

我已经开始在Neo4j 5扩展模型的帮助下编写自己的JUnit 5扩展，但是如果已经存在具有JUnit 5扩展模型的标准Neo4j测试工具，那么为什么要创建自己的扩展呢？

也许我只是在查询错误的关键字，这些关键字简单地是neo4j和JUnit 5，但是同样的结果不断出现，没有一个导致我想要的结果。

检查了JUnit木星扩展，没有找到Neo4j。

编辑

概念证明

由于下面的代码只是概念的证明，所以它不是作为公认的答案发布，而是希望在几天之内。

事实证明，将JUnit 5木星扩展添加到现有的JUnit TestRlue并没有那么糟糕。在这个过程中，有一些困难的地方，如果你和我一样，不生活和呼吸一个单一的编程语言或一套工具，你必须花一些时间来理解精神；如果你问我，那应该是个标签。

注意:此代码是来自Neo4j TestRule和JUnit 5扩展指南的一些代码的组合。

从Neo4j TestRule开始，只需更改实现：

删除TestRule

添加BeforeEachCallback和AfterEachCallback

注意:使用BeforeEach和AfterEach代替BeforeAll和AfterAll以及Neo4j，因为在创建节点时每次新测试时，如果创建一个新节点与之前的测试相同，而且数据库不是一个新数据库，那么检查节点的id就会有所不同，因为每个测试都创建了一个新节点，并且得到了不同的id。因此，为了避免这个问题，并按照与Neo4j TestRule相同的方式执行，将为每个测试实例创建一个新的数据库。我确实考虑过在测试之间重置数据库，但似乎唯一的方法是删除构成数据库的所有文件。:(

/*
 * Copyright (c) 2002-2018 "Neo4j,"
 * Neo4j Sweden AB [http://neo4j.com]
 *
 * This file is part of Neo4j.
 *
 * Neo4j is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
//package org.neo4j.harness.junit;
package org.egt.neo4j.harness.example_002.junit;

// References:
// GitHub - junit-team - junit5 - junit5/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine - https://github.com/junit-team/junit5/tree/releases/5.3.x/junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/extension

// Notes:
// With JUnit 4 TestRule there was basically one rule that was called at multiple points and for multiple needs.
// With JUnit 5 Extensions the calls are specific to a lifecycle step, e.g. BeforeAll, AfterEach,
// or specific to a need, e.g. Exception handling, maintaining state across test,
// so in JUnit 4 where a single TestRule could be created in JUnit5 many Extensions need to be created.
// Another major change is that with JUnit 4 a rule would wrap around a test which would make
// implementing a try/catch easy, with JUnit 5 the process is broken down into a before and after callbacks
// that make this harder, however because the extensions can be combined for any test,
// adding the ability to handle exceptions does not require adding the code to every extension,
// but merely adding the extension to the test. (Verify this).

import java.io.File;
import java.io.PrintStream;
import java.util.function.Function;

import org.junit.jupiter.api.extension.*;
import org.neo4j.graphdb.GraphDatabaseService;
import org.neo4j.graphdb.config.Setting;

import org.egt.neo4j.harness.example_002.ServerControls;
import org.egt.neo4j.harness.example_002.TestServerBuilder;
import org.egt.neo4j.harness.example_002.TestServerBuilders;

/**
 * A convenience wrapper around {@link org.neo4j.harness.TestServerBuilder}, exposing it as a JUnit
 * {@link org.junit.Rule rule}.
 *
 * Note that it will try to start the web server on the standard 7474 port, but if that is not available
 * (typically because you already have an instance of Neo4j running) it will try other ports. Therefore it is necessary
 * for the test code to use {@link #httpURI()} and then {@link java.net.URI#resolve(String)} to create the URIs to be invoked.
 */
//public class Neo4jRule implements TestRule, TestServerBuilder
public class Neo4jDatabaseSetupExtension implements  BeforeEachCallback, AfterEachCallback, TestServerBuilder
{
    private TestServerBuilder builder;
    private ServerControls controls;
    private PrintStream dumpLogsOnFailureTarget;

    Neo4jDatabaseSetupExtension(TestServerBuilder builder )
    {
        this.builder = builder;
    }

    public Neo4jDatabaseSetupExtension( )
    {
        this( TestServerBuilders.newInProcessBuilder() );
    }

    public Neo4jDatabaseSetupExtension(File workingDirectory )
    {
        this( TestServerBuilders.newInProcessBuilder( workingDirectory ) );
    }

    @Override
    public void afterEach(ExtensionContext context) throws Exception {

        if (controls != null)
        {
            controls.close();
        }
    }

    @Override
    public void beforeEach(ExtensionContext context) throws Exception {
        controls = builder.newServer();
    }

    @Override
    public ServerControls newServer() {
        throw new UnsupportedOperationException( "The server cannot be manually started via this class, it must be used as a JUnit 5 Extension." );
    }

    @Override
    public TestServerBuilder withConfig(Setting<?> key, String value) {
        builder = builder.withConfig( key, value );
        return this;
    }

    @Override
    public TestServerBuilder withConfig(String key, String value) {
        builder = builder.withConfig( key, value );
        return this;
    }

    @Override
    public TestServerBuilder withExtension(String mountPath, Class<?> extension) {
        builder = builder.withExtension( mountPath, extension );
        return this;
    }

    @Override
    public TestServerBuilder withExtension(String mountPath, String packageName) {
        builder = builder.withExtension( mountPath, packageName );
        return this;
    }

    @Override
    public TestServerBuilder withFixture(File cypherFileOrDirectory) {
        builder = builder.withFixture( cypherFileOrDirectory );
        return this;
    }

    @Override
    public TestServerBuilder withFixture(String fixtureStatement) {
        builder = builder.withFixture( fixtureStatement );
        return this;
    }

    @Override
    public TestServerBuilder withFixture(Function<GraphDatabaseService, Void> fixtureFunction) {
        builder = builder.withFixture( fixtureFunction );
        return this;
    }

    @Override
    public TestServerBuilder copyFrom(File sourceDirectory) {
        builder = builder.copyFrom( sourceDirectory );
        return this;
    }

    @Override
    public TestServerBuilder withProcedure(Class<?> procedureClass) {
        builder = builder.withProcedure( procedureClass );
        return this;
    }

    @Override
    public TestServerBuilder withFunction(Class<?> functionClass) {
        builder = builder.withFunction( functionClass );
        return this;
    }

    @Override
    public TestServerBuilder withAggregationFunction(Class<?> functionClass) {
        builder = builder.withAggregationFunction( functionClass );
        return this;
    }
}

接下来，为了允许每个测试实例都有一个新的GraphDatabaseService (用ServerControls创建)，实现一个JUnit 5 ParameterResolver。

package org.egt.neo4j.harness.example_002.junit;

import org.egt.neo4j.harness.example_002.ServerControls;
import org.egt.neo4j.harness.example_002.TestServerBuilders;
import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.jupiter.api.extension.ParameterContext;
import org.junit.jupiter.api.extension.ParameterResolutionException;
import org.junit.jupiter.api.extension.ParameterResolver;

public class Neo4jDatabaseParameterResolver implements ParameterResolver {

    @Override
    public boolean supportsParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {
        boolean result = parameterContext.getParameter()
                .getType()
                .equals(ServerControls.class);

        return result;
    }

    @Override
    public Object resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext) throws ParameterResolutionException {

        Object result = (ServerControls)TestServerBuilders.newInProcessBuilder().newServer();

        return result;
    }
}

最后，剩下的就是使用Neo4j JUnit 5扩展模型与@ExtendWith和@Test

package org.egt.example_002;

import org.egt.neo4j.harness.example_002.ServerControls;
import org.egt.neo4j.harness.example_002.junit.Neo4jDatabaseParameterResolver;
import org.egt.neo4j.harness.example_002.junit.Neo4jDatabaseSetupExtension;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;

import org.neo4j.graphdb.GraphDatabaseService;
import org.neo4j.graphdb.Node;
import org.neo4j.graphdb.Transaction;

import static org.junit.jupiter.api.Assertions.assertEquals;

@ExtendWith({ Neo4jDatabaseSetupExtension.class, Neo4jDatabaseParameterResolver.class })
public class Neo4jUnitTests {

    private ServerControls sc;
    private GraphDatabaseService graphDb;

    public Neo4jUnitTests(ServerControls sc) {
        this.sc = sc;
        this.graphDb = sc.graph();
    }

    @Test
    public void shouldCreateNode()
    {
        // START SNIPPET: unitTest
        Node n;
        try ( Transaction tx = graphDb.beginTx() )
        {
            n = graphDb.createNode();
            n.setProperty( "name", "Nancy" );
            tx.success();
        }

        long id = n.getId();
        // The node should have a valid id
        assertEquals(0L, n.getId());

        // Retrieve a node by using the id of the created node. The id's and
        // property should match.
        try ( Transaction tx = graphDb.beginTx() )
        {
            Node foundNode = graphDb.getNodeById( n.getId() );
            assertEquals( foundNode.getId(),  n.getId() );
            assertEquals( "Nancy" , (String)foundNode.getProperty("name") );
        }
        // END SNIPPET: unitTest

    }
}

在此过程中，我学到了一件重要的事情: TestRule代码似乎是一个do everything in one class，而新的扩展模型使用许多扩展来做同样的事情。因此，Neo4j TestRule所拥有的日志记录、异常处理和其他东西并不是这个概念的证明。但是，由于Extension允许您混合和匹配扩展，添加日志记录和异常处理可以像使用来自另一个地方的扩展一样简单，只添加@ExtendWith，这就是为什么我没有为这个概念的证明创建它们。

另外，您会注意到，我更改了包名，这只是为了避免与同一项目中的其他代码发生冲突，这些代码以独立的方式实现代码的其他部分，这样我就可以完成这个概念的工作证明。

最后，如果JUnit 4 Neo4j TestRule类和JUnit 5扩展模型类都可以继承基类，然后可以在相同的测试工具中使用；祈祷吧，我也不会感到惊讶。显然，大多数基类将从Neo4j TestRule类中提取。

Answer 1

最简单的方法可能是根本不使用扩展。

对Neo4j 4.x使用以下依赖关系：

<dependency>
    <groupId>org.neo4j.test</groupId>
    <artifactId>neo4j-harness</artifactId>
    <version>4.0.8</version>
    <scope>test</scope>
</dependency>

然后构建JUnit 5测试，如下所示：

import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.neo4j.harness.Neo4j;
import org.neo4j.harness.Neo4jBuilders;

public class SimpleTest {

    private static Neo4j embeddedDatabaseServer;

    @BeforeAll
    static void initializeNeo4j() {

        embeddedDatabaseServer = Neo4jBuilders.newInProcessBuilder()
            .withDisabledServer() // Don't need Neos HTTP server
            .withFixture(""
                + "CREATE (TheMatrix:Movie {title:'The Matrix', released:1999, tagline:'Welcome to the Real World'})"
            )
            .build();
    }

    @AfterAll
    static void stopNeo4j() {

        embeddedDatabaseServer.close();
    }

    @Test
    void testSomething() {

        try(var tx = embeddedDatabaseServer.databaseManagementService().database("neo4j").beginTx()) {
            var result = tx.execute("MATCH (m:Movie) WHERE m.title = 'The Matrix' RETURN m.released");
            Assertions.assertEquals(1999L, result.next().get("m.released"));
        }
    }
}

当然，您也可以打开嵌入实例的螺栓URL。embeddedDatabaseServer.boltURI()为您提供本地套接字地址。身份验证被关闭。

测试将如下所示：

@Test
void testSomethingOverBolt() {

    try(var driver = GraphDatabase.driver(embeddedDatabaseServer.boltURI(), AuthTokens.none());
    var session = driver.session()) {
        var result = session.run("MATCH (m:Movie) WHERE m.title = 'The Matrix' RETURN m.released");
        Assertions.assertEquals(1999L, result.next().get("m.released").asLong());
    }
}

当然，在这方面您需要org.neo4j.driver:neo4j-java-driver。

如果需要嵌入式服务器的非静态实例，可以对整个测试类建模如下：

import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInstance;
import org.neo4j.harness.Neo4j;
import org.neo4j.harness.Neo4jBuilders;

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
public class SimpleTest {

    private final Neo4j embeddedDatabaseServer = Neo4jBuilders.newInProcessBuilder()
            .withDisabledServer() // Don't need Neos HTTP server
        .withFixture(""
            + "CREATE (TheMatrix:Movie {title:'The Matrix', released:1999, tagline:'Welcome to the Real World'})"
        )
        .build();

    @AfterAll
    void stopNeo4j() {

        embeddedDatabaseServer.close();
    }

    @Test
    void whatever() {
    }
}

请注意测试类和非静态@TestInstance(TestInstance.Lifecycle.PER_CLASS)方法之上的@AfterAll。

Answer 2

不是真正的答案，但我有一个Neo4jExtension类，它是一个JUnit 5扩展。

我的大部分都是硬编码的，因为我想要一些对我有用的东西。

它创建了一个带有螺栓连接器的嵌入式Neo4j数据库。

它还加载一些apoc过程和函数，并加载初始数据进行测试。

你的方法更有趣。

import lombok.extern.slf4j.Slf4j;
import org.apache.catalina.webresources.TomcatURLStreamHandlerFactory;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang3.StringUtils;
import org.junit.jupiter.api.extension.AfterAllCallback;
import org.junit.jupiter.api.extension.AfterEachCallback;
import org.junit.jupiter.api.extension.BeforeAllCallback;
import org.junit.jupiter.api.extension.BeforeEachCallback;
import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.jupiter.api.extension.ParameterContext;
import org.junit.jupiter.api.extension.ParameterResolutionException;
import org.junit.jupiter.api.extension.ParameterResolver;
import org.neo4j.graphdb.GraphDatabaseService;
import org.neo4j.graphdb.Transaction;
import org.neo4j.graphdb.factory.GraphDatabaseFactory;
import org.neo4j.graphdb.factory.GraphDatabaseSettings;
import org.neo4j.internal.kernel.api.exceptions.KernelException;
import org.neo4j.kernel.configuration.BoltConnector;
import org.neo4j.kernel.configuration.Settings;
import org.neo4j.kernel.impl.proc.Procedures;
import org.neo4j.kernel.internal.GraphDatabaseAPI;

import java.io.File;
import java.util.List;

import static java.nio.charset.StandardCharsets.UTF_8;
import static java.util.Arrays.asList;
import static org.neo4j.helpers.ListenSocketAddress.listenAddress;
import static org.neo4j.kernel.configuration.BoltConnector.EncryptionLevel.DISABLED;
import static org.neo4j.kernel.configuration.Connector.ConnectorType.BOLT;
import static org.neo4j.kernel.configuration.Settings.FALSE;
import static org.neo4j.kernel.configuration.Settings.STRING;
import static org.neo4j.kernel.configuration.Settings.TRUE;

@Slf4j
public class Neo4jExtension implements
        BeforeAllCallback, AfterAllCallback, ParameterResolver,
        BeforeEachCallback, AfterEachCallback {

    private static final File DB_PATH = new File("target/neo4j-test");

    private GraphDatabaseService graphDb;
    private Transaction currentTransaction;

    @Override
    public void beforeAll(ExtensionContext extensionContext) throws Exception {
        FileUtils.deleteDirectory(DB_PATH);
        TomcatURLStreamHandlerFactory.disable();
        final BoltConnector boltConnector = new BoltConnector("bolt");
        graphDb = new GraphDatabaseFactory()
                .newEmbeddedDatabaseBuilder(DB_PATH)
                .setConfig(Settings.setting("dbms.directories.import", STRING, "data"),"../../data")
                .setConfig(Settings.setting("dbms.security.procedures.unrestricted", STRING, "apoc.*"),"apoc.*")
                .setConfig(boltConnector.type, BOLT.name())
                .setConfig(boltConnector.enabled, TRUE)
                .setConfig(boltConnector.listen_address, listenAddress("127.0.0.1", 7676))
                .setConfig(boltConnector.encryption_level, DISABLED.name())
                .setConfig(GraphDatabaseSettings.auth_enabled, FALSE)
                .newGraphDatabase();
        Procedures procedures = ((GraphDatabaseAPI) graphDb).getDependencyResolver().resolveDependency(Procedures.class);
        List<Class<?>> apocProcedures = asList(apoc.convert.Json.class);
        apocProcedures.forEach((procedure) -> {
            try {
                procedures.registerFunction(procedure);
                procedures.registerProcedure(procedure);
            } catch (KernelException e) {
                e.printStackTrace();
            }
        });
        final String importScript = FileUtils.readFileToString(new File("data/import_data.cql"), UTF_8);
        final String[] split = importScript.split(";");
        for (String query : split) {
            if (StringUtils.isNotBlank(query)) {
                graphDb.execute(query);
            }
        }
    }

    @Override
    public void afterAll(ExtensionContext extensionContext) throws Exception {
        graphDb.shutdown();
    }

    @Override
    public void beforeEach(ExtensionContext extensionContext) throws Exception {
        currentTransaction = graphDb.beginTx();
    }

    @Override
    public void afterEach(ExtensionContext extensionContext) throws Exception {
        currentTransaction.failure();
        currentTransaction.close();
    }

    @Override
    public boolean supportsParameter(ParameterContext parameterContext,
                                     ExtensionContext extensionContext) throws ParameterResolutionException {
        return parameterContext.getParameter().getType().equals(GraphDatabaseService.class);
    }

    @Override
    public Object resolveParameter(ParameterContext parameterContext,
                                   ExtensionContext extensionContext) throws ParameterResolutionException {
        return graphDb;
    }
}

Answer 3

更新:靠近Neo4J/数据生态系统的 Folk建议不要使用Neo4jExtention。有关更多细节，请参见这个答案。

现在(从2019年1月起)有一个对于JUnit 5，其本质上是Neo4jRule为Junit 4所做的工作。

你就这样用它：

@ExtendWith(org.neo4j.harness.junit.extension.Neo4jExtension.class)
class MyTest {
    ...

如果您使用的是Spring / Spring数据Neo4j，您可能会发现这个扩展在SpringExtension中发挥得不太好。我在另一个问答中描述了如何解决这个问题：如何使用Neo4j 5(在Kotlin中)设置Spring数据JUnit集成测试？