使用TestContainers进行Corda API测试：构建模拟测试网络验证REST API的实现指导咨询

Absolutely, using TestContainers with Corda's official Docker images is a solid approach to validate your REST API’s behavior against a simulated Corda network—let me break down a practical, step-by-step implementation for you.

First, make sure you’ve got these basics covered:

• A JVM environment (Java 8/11, matching your Corda version’s requirements)
• TestContainers dependencies added to your build (Maven/Gradle—use the core module plus any language-specific helpers)
• Access to Corda’s official Docker images (you can pull them directly from Docker Hub, e.g., corda/corda-zulu-java1.8:4.9 for Corda 4.9)
• Your REST API project includes the Corda RPC client library matching your Corda version

Start by setting up a single Corda node container. We’ll use TestContainers’ GenericContainer since Corda’s official images don’t have a dedicated TestContainers module (yet). Here’s a Kotlin example:

import org.testcontainers.containers.GenericContainer
import org.testcontainers.containers.wait.strategy.Wait
import org.testcontainers.utility.DockerImageName

// Define the Corda Docker image (match your target Corda version)
val cordaImage = DockerImageName.parse("corda/corda-zulu-java1.8:4.9")

// Initialize the node container
val cordaNode = GenericContainer(cordaImage)
    // Expose required ports: RPC (10006) and P2P (10002)
    .withExposedPorts(10006, 10002)
    // Set environment variables to configure the node
    .withEnv(mapOf(
        "CORDA_NODE_NAME" to "O=PartyA,L=London,C=GB",
        "CORDA_P2P_ADDRESS" to "0.0.0.0:10002",
        "CORDA_RPC_ADDRESS" to "0.0.0.0:10006",
        "CORDA_RPC_USERS" to """[{ "username": "user1", "password": "test", "permissions": ["ALL"] }]"""
    ))
    // Wait for the node to fully start (check for a specific log line)
    .waitingFor(Wait.forLogMessage(".*Node for \"PartyA\" started up.*", 1))
    // Optional: Mount a local config directory if you need custom node settings
    .withFileSystemBind("./local-node-config", "/opt/corda/config")

• The CORDA_RPC_USERS env var defines a valid RPC user your API will use to connect.
• Mounting a local config directory lets you customize node settings (like network parameters or CorDapp loading) without modifying the container image.

Once your container is configured, start it and fetch the mapped RPC port (TestContainers uses random host ports by default):

// Start the container (TestContainers handles pulling the image if needed)
cordaNode.start()

// Get the mapped RPC port on your host machine
val mappedRpcPort = cordaNode.getMappedPort(10006)

// Initialize the Corda RPC client from your REST API
val rpcClient = CordaRPCClient(InetSocketAddress("localhost", mappedRpcPort))
val rpcConnection = rpcClient.start("user1", "test")
val cordaRpcProxy = rpcConnection.proxy

Now your REST API can use cordaRpcProxy to interact with the simulated node—just like it would with a real Corda node.

With the node running, write test cases to hit your REST endpoints and verify their output matches expected Corda behavior. For example, using JUnit 5 and RestAssured:

import io.restassured.RestAssured.given
import org.junit.jupiter.api.Test
import kotlin.test.assertEquals

@Test
fun `get accounts endpoint returns correct data from Corda node`() {
    // Fetch expected accounts directly from Corda RPC
    val expectedAccounts = cordaRpcProxy.nodeInfo().legalIdentities.map { it.name.toString() }

    // Call your REST API endpoint
    val response = given()
        .baseUri("http://localhost:8080") // Your API's base URL
        .get("/api/v1/accounts")
        .then()
        .statusCode(200)
        .extract()
        .jsonPath()
        .getList<String>("accounts")

    // Assert the API returns the same data as the Corda node
    assertEquals(expectedAccounts, response)
}

If you need to test cross-node interactions (e.g., transaction flows between PartyA and PartyB), create multiple containers and connect them via a TestContainers network:

import org.testcontainers.containers.Network

// Create a dedicated network for Corda nodes
val cordaNetwork = Network.newNetwork()

// Configure PartyA node (add .withNetwork(cordaNetwork) and set CORDA_P2P_ADDRESS to "partya:10002")
val partyA = GenericContainer(cordaImage)
    .withNetwork(cordaNetwork)
    .withNetworkAliases("partya")
    .withEnv("CORDA_P2P_ADDRESS", "partya:10002")
    // ... other configs

// Configure PartyB node similarly, with network alias "partyb"
val partyB = GenericContainer(cordaImage)
    .withNetwork(cordaNetwork)
    .withNetworkAliases("partyb")
    .withEnv("CORDA_P2P_ADDRESS", "partyb:10002")
    // ... other configs

// Start both nodes
partyA.start()
partyB.start()

This lets nodes discover each other using their network aliases, just like in a real Corda network.

• Preload CorDapps: Mount your CorDapp JARs to the container’s /opt/corda/cordapps directory (using withFileSystemBind) so the node loads them on startup.
• Log Collection: Add a log consumer to debug node issues:

  import org.testcontainers.containers.output.Slf4jLogConsumer
  import org.slf4j.LoggerFactory
  
  val logConsumer = Slf4jLogConsumer(LoggerFactory.getLogger("CordaNode"))
  cordaNode.withLogConsumer(logConsumer)
  

• Corda 5 Notes: For Corda 5, the official image uses a different structure (e.g., /opt/corda5 instead of /opt/corda) and requires different startup commands—adjust your configs accordingly.

内容的提问来源于stack exchange，提问作者McXD