docs/net.corda.testing.node.internal

Package-level declarations

Types

Internal API to enable testing of the network map service and node registration process using the internal driver.

data class CustomCordapp(val packages: Set<String> = emptySet(), val name: String = "custom-cordapp", val versionId: Int = 1, val targetPlatformVersion: Int = PLATFORM_VERSION, val classes: Set<Class<*>> = emptySet(), val fixups: List<<Error class: unknown class><Set<AttachmentId>, Set<AttachmentId>>> = emptyList(), val signingInfo: CustomCordapp.SigningInfo? = null, val config: Map<String, Any> = emptyMap()) : TestCordappInternal

Represents a completely custom CorDapp comprising of resources taken from packages on the existing classpath, even including individual disparate classes. The CorDapp metadata that's present in the MANIFEST can also be tailored.

DriverDSLImpl

class DriverDSLImpl(val portAllocation: PortAllocation, val debugPortAllocation: PortAllocation, val systemProperties: Map<String, String>, val driverDirectory: Path, val useTestClock: Boolean, val isDebug: Boolean, val startNodesInProcess: Boolean, val waitForAllNodesToFinish: Boolean, val extraCordappPackagesToScan: List<String>, val jmxPolicy: JmxPolicy, val notarySpecs: List<NotarySpec>, val compatibilityZone: CompatibilityZoneParams?, val networkParameters: NetworkParameters, val notaryCustomOverrides: Map<String, Any?>, val inMemoryDB: Boolean, val cordappsForAllNodes: Collection<TestCordappInternal>?, val environmentVariables: Map<String, String>, val allowHibernateToManageAppSchema: Boolean = true, val premigrateH2Database: Boolean = true, val notaryHandleTimeout: Duration = Duration.ofMinutes(1)) : InternalDriverDSL

DummyClusterSpec

data class DummyClusterSpec(val clusterSize: Int, val compositeServiceIdentity: Boolean = false) : ClusterSpec

Only used for testing the notary communication path. Can be configured to act as a Raft (singular identity), or a BFT (composite key identity) notary service.

InMemoryMessage

data class InMemoryMessage(val topic: String, val data: ByteSequence, val uniqueMessageId: <Error class: unknown class>, val debugTimestamp: Instant = Instant.now(), val senderUUID: String? = null)

An implementation of Message for in memory messaging by the test MockNodeMessagingService.

InProcessNode

class InProcessNode(configuration: <Error class: unknown class>, versionInfo: <Error class: unknown class>, flowManager: <Error class: unknown class> = NodeFlowManager(configuration.flowOverrides), allowHibernateToManageAppSchema: Boolean = true)

InternalDriverDSL

interface InternalDriverDSL : DriverDSL

InternalMockNetwork

open class InternalMockNetwork(cordappPackages: List<String> = emptyList(), defaultParameters: MockNetworkParameters = MockNetworkParameters(), val networkSendManuallyPumped: Boolean = defaultParameters.networkSendManuallyPumped, val threadPerNode: Boolean = defaultParameters.threadPerNode, servicePeerAllocationStrategy: InMemoryMessagingNetwork.ServicePeerAllocationStrategy = defaultParameters.servicePeerAllocationStrategy, val notarySpecs: List<MockNetworkNotarySpec> = defaultParameters.notarySpecs, val testDirectory: Path = Paths.get("build") / "mock-network" / getTimestampAsDirectoryName(), initialNetworkParameters: NetworkParameters = testNetworkParameters(), val defaultFactory: (MockNodeArgs) -> InternalMockNetwork.MockNode = { args -> MockNode(args) }, cordappsForAllNodes: Collection<TestCordappInternal> = emptySet(), val autoVisibleNodes: Boolean = true) : AutoCloseable

InternalMockNodeParameters

data class InternalMockNodeParameters(val forcedID: Int? = null, val legalName: CordaX500Name? = null, val entropyRoot: BigInteger = BigInteger.valueOf(random63BitValue()), val configOverrides: (<Error class: unknown class>) -> Any? = {}, val version: <Error class: unknown class> = MOCK_VERSION_INFO, val additionalCordapps: Collection<TestCordappInternal> = emptyList(), val flowManager: MockNodeFlowManager = MockNodeFlowManager())

ListenProcessDeathException

class ListenProcessDeathException(hostAndPort: NetworkHostAndPort, listenProcess: Process) : CordaException

MessagingServiceSpy

abstract class MessagingServiceSpy

MockCryptoService

class MockCryptoService(initialKeyPairs: Map<String, KeyPair>)

MockEncryptionService

class MockEncryptionService(aesKey: SecretKey = AesEncryption.randomKey())

MockKeyManagementService

class MockKeyManagementService(val identityService: IdentityService, initialKeys: KeyPair) : SingletonSerializeAsToken

A class which provides an implementation of KeyManagementService which is used in MockServices

MockNetworkParametersStorage

class MockNetworkParametersStorage(currentParameters: NetworkParameters = testNetworkParameters(modifiedTime = Instant.MIN)) : NetworkParametersStorage

MockNodeArgs

data class MockNodeArgs(val config: <Error class: unknown class>, val network: InternalMockNetwork, val id: Int, val entropyRoot: BigInteger, val version: <Error class: unknown class> = MOCK_VERSION_INFO, val flowManager: MockNodeFlowManager = MockNodeFlowManager())

MockNodeFlowManager

class MockNodeFlowManager

MockNodeMessagingService

class MockNodeMessagingService(configuration: <Error class: unknown class>, executor: <Error class: unknown class>, stateHelper: <Error class: unknown class> = ServiceStateHelper(log)) : SingletonSerializeAsToken

MockPublicKeyToOwningIdentityCache

class MockPublicKeyToOwningIdentityCache

A mock implementation of WritablePublicKeyToOwningIdentityCache that stores all key mappings in memory. Used in testing scenarios that do not require database access.

MockTransactionStorage

open class MockTransactionStorage : SingletonSerializeAsToken

A class which provides an implementation of WritableTransactionStorage which is used in MockServices

NodeBasedTest

abstract class NodeBasedTest constructor(cordappPackages: Set<TestCordappInternal> = emptySet(), notaries: List<CordaX500Name> = emptyList())

NodeListenProcessDeathException

class NodeListenProcessDeathException(hostAndPort: NetworkHostAndPort, listenProcess: Process, val causeFromStdError: String) : CordaException

ProcessUtilities

object ProcessUtilities

RandomRpcUser

class RandomRpcUser

An out-of-process RPC user that connects to an RPC server and issues random RPCs with random arguments.

RpcBrokerHandle

data class RpcBrokerHandle(val hostAndPort: NetworkHostAndPort?, val clientTransportConfiguration: <Error class: unknown class>, val serverControl: <Error class: unknown class>, val shutdown: () -> Unit)

RPCDriverDSL

data class RPCDriverDSL(driverDSL: DriverDSLImpl, externalTrace: Trace?) : InternalDriverDSL

RpcServerHandle

data class RpcServerHandle(val broker: RpcBrokerHandle, val rpcServer: <Error class: unknown class>)

ScanPackageTestCordapp

data class ScanPackageTestCordapp(val scanPackage: String, val config: Map<String, Any> = emptyMap(), val signed: Boolean = false) : TestCordappInternal

Implementation of the public TestCordapp API.

SharedCompatibilityZoneParams

class SharedCompatibilityZoneParams(url: URL, pnm: UUID?, val publishNotaries: (List<NotaryInfo>) -> Unit, val rootCert: X509Certificate? = null) : CompatibilityZoneParams

Represent network management services, network map and doorman, running on the same URL

ShutdownManager

class ShutdownManager(executorService: ExecutorService)

SplitCompatibilityZoneParams

class SplitCompatibilityZoneParams(doormanURL: URL, networkMapURL: URL, pnm: UUID?, val publishNotaries: (List<NotaryInfo>) -> Unit, val rootCert: X509Certificate? = null) : CompatibilityZoneParams

Represent network management services, network map and doorman, running on different URLs

TestCordappInternal

abstract class TestCordappInternal : TestCordapp

Extends the public TestCordapp API with internal extensions for use within the testing framework and for internal testing of the platform.

TestCordappSigner

object TestCordappSigner

TestStartedNode

interface TestStartedNode

UriTestCordapp

data class UriTestCordapp(val uri: URI, val config: Map<String, Any> = emptyMap(), val signed: Boolean = false) : TestCordappInternal

Properties

DIRECTORY_TIMESTAMP_FORMAT

val DIRECTORY_TIMESTAMP_FORMAT: DateTimeFormatter

DUMMY_CONTRACTS_CORDAPP

val DUMMY_CONTRACTS_CORDAPP: CustomCordapp

Custom CorDapp containing the contents of the net.corda.testing.contracts package, i.e. the dummy contracts. This is not a real CorDapp in the way that FINANCE_CONTRACTS_CORDAPP and FINANCE_WORKFLOWS_CORDAPP are.

fakeNodeLegalName

val fakeNodeLegalName: CordaX500Name

FINANCE_CONTRACTS_CORDAPP

val FINANCE_CONTRACTS_CORDAPP: ScanPackageTestCordapp

Reference to the finance-contracts CorDapp in this repo. The metadata is taken directly from finance/contracts/build.gradle, including the fact that the jar is signed. If you need an unsigned jar then use cordappWithPackages("net.corda.finance.contracts").

FINANCE_CORDAPPS

val FINANCE_CORDAPPS: Set<ScanPackageTestCordapp>

FINANCE_WORKFLOWS_CORDAPP

val FINANCE_WORKFLOWS_CORDAPP: ScanPackageTestCordapp

Reference to the finance-workflows CorDapp in this repo. The metadata is taken directly from finance/workflows/build.gradle, including the fact that the jar is signed. If you need an unsigned jar then use cordappWithPackages("net.corda.finance.flows").

MOCK_VERSION_INFO

val MOCK_VERSION_INFO: <Error class: unknown class>

nodeJvmArgs

val nodeJvmArgs: List<String>

rpcServerUser

val rpcServerUser: User

rpcTestUser

val rpcTestUser: User

Functions

addEntry

fun JarOutputStream.addEntry(entry: ZipEntry)

inline fun JarOutputStream.addEntry(entry: ZipEntry, write: () -> Unit)

fun JarOutputStream.addEntry(entry: ZipEntry, input: InputStream)

Add a new entry using the entire remaining bytes of input for the entry content. input will be closed at the end.

addressMustBeBound

fun addressMustBeBound(executorService: ScheduledExecutorService, hostAndPort: NetworkHostAndPort, listenProcess: Process? = null)

addressMustBeBoundFuture

fun addressMustBeBoundFuture(executorService: ScheduledExecutorService, hostAndPort: NetworkHostAndPort, listenProcess: Process? = null): CordaFuture<Unit>

addressMustNotBeBound

fun addressMustNotBeBound(executorService: ScheduledExecutorService, hostAndPort: NetworkHostAndPort, timeout: Duration = 40.seconds)

addressMustNotBeBoundFuture

fun addressMustNotBeBoundFuture(executorService: ScheduledExecutorService, hostAndPort: NetworkHostAndPort): CordaFuture<Unit>

applyMockNodeOverrides

fun MockNodeConfigOverrides.applyMockNodeOverrides(config: <Error class: unknown class>)

assertUncompletedCheckpoints

fun DriverDSL.assertUncompletedCheckpoints(name: CordaX500Name, expected: Long)

cordappForClasses

fun cordappForClasses(vararg classes: Class<*>): CustomCordapp

Create a custom CorDapp which contains just the given classes.

cordappsForPackages

fun cordappsForPackages(vararg packageNames: String): Set<CustomCordapp>

fun cordappsForPackages(packageNames: Iterable<String>): Set<CustomCordapp>

cordappWithFixups

fun cordappWithFixups(fixups: List<<Error class: unknown class><Set<AttachmentId>, Set<AttachmentId>>>): CustomCordapp

cordappWithPackages

fun cordappWithPackages(vararg packageNames: String): CustomCordapp

Create a custom CorDapp which contains all the classes and resoures located in the given packages. The CorDapp's metadata will be the default values as defined in the CustomCordapp c'tor. Use the copy to change them. This means the metadata will not be the one defined in the original CorDapp(s) that the given packages may represent. If this is not what you want then use findCordapp instead.

enclosedCordapp

fun Any.enclosedCordapp(): CustomCordapp

Create a custom CorDapp which just contains the enclosed classes of the receiver class.

findCordapp

fun findCordapp(scanPackage: String): ScanPackageTestCordapp

Find the single CorDapp jar on the current classpath which contains the given package. This is a convenience method for TestCordapp.findCordapp but returns the internal ScanPackageTestCordapp.

genericDriver

fun <DI : DriverDSL, D : InternalDriverDSL, A> genericDriver(driverDsl: D, coerce: (D) -> DI, dsl: DI.() -> A): A

This is a helper method to allow extending of the DSL, along the lines of interface SomeOtherExposedDSLInterface : DriverDSL interface SomeOtherInternalDSLInterface : InternalDriverDSL, SomeOtherExposedDSLInterface class SomeOtherDSL(val driverDSL : DriverDSLImpl) : InternalDriverDSL by driverDSL, SomeOtherInternalDSLInterface

getCallerPackage

fun getCallerPackage(directCallerClass: KClass<*>): String?

getMessage

fun InMemoryMessagingNetwork.MessageTransfer.getMessage(): <Error class: unknown class>

getTimestampAsDirectoryName

fun getTimestampAsDirectoryName(): String

internalDriver

fun <A> internalDriver(isDebug: Boolean = DriverParameters().isDebug, driverDirectory: Path = DriverParameters().driverDirectory, portAllocation: PortAllocation = DriverParameters().portAllocation, debugPortAllocation: PortAllocation = DriverParameters().debugPortAllocation, systemProperties: Map<String, String> = DriverParameters().systemProperties, useTestClock: Boolean = DriverParameters().useTestClock, startNodesInProcess: Boolean = DriverParameters().startNodesInProcess, extraCordappPackagesToScan: List<String> = @Suppress("DEPRECATION") DriverParameters().extraCordappPackagesToScan, waitForAllNodesToFinish: Boolean = DriverParameters().waitForAllNodesToFinish, notarySpecs: List<NotarySpec> = DriverParameters().notarySpecs, jmxPolicy: JmxPolicy = DriverParameters().jmxPolicy, networkParameters: NetworkParameters = DriverParameters().networkParameters, compatibilityZone: CompatibilityZoneParams? = null, notaryCustomOverrides: Map<String, Any?> = DriverParameters().notaryCustomOverrides, inMemoryDB: Boolean = DriverParameters().inMemoryDB, cordappsForAllNodes: Collection<TestCordappInternal>? = null, environmentVariables: Map<String, String> = emptyMap(), allowHibernateToManageAppSchema: Boolean = true, premigrateH2Database: Boolean = true, notaryHandleTimeout: Duration = Duration.ofMinutes(1), dsl: DriverDSLImpl.() -> A): A

newContext

fun <Error class: unknown class>.newContext(): InvocationContext

nodeMustBeStartedFuture

fun nodeMustBeStartedFuture(executorService: ScheduledExecutorService, logFile: Path, listenProcess: Process, exception: () -> NodeListenProcessDeathException): CordaFuture<Unit>

poll

fun <A> poll(executorService: ScheduledExecutorService, pollName: String, pollInterval: Duration = 500.millis, warnCount: Int = 120, check: () -> A?): CordaFuture<A>

rpcDriver

fun <A> rpcDriver(isDebug: Boolean = false, driverDirectory: Path = Paths.get("build") / "rpc-driver" / getTimestampAsDirectoryName(), portAllocation: PortAllocation = globalPortAllocation, debugPortAllocation: PortAllocation = globalDebugPortAllocation, systemProperties: Map<String, String> = emptyMap(), useTestClock: Boolean = false, startNodesInProcess: Boolean = false, waitForNodesToFinish: Boolean = false, extraCordappPackagesToScan: List<String> = emptyList(), notarySpecs: List<NotarySpec> = emptyList(), externalTrace: Trace? = null, jmxPolicy: JmxPolicy = JmxPolicy(), networkParameters: NetworkParameters = testNetworkParameters(), notaryCustomOverrides: Map<String, Any?> = emptyMap(), inMemoryDB: Boolean = true, cordappsForAllNodes: Collection<TestCordappInternal>? = null, environmentVariables: Map<String, String> = emptyMap(), dsl: RPCDriverDSL.() -> A): A

setDriverSerialization

fun setDriverSerialization(): AutoCloseable?

fun setDriverSerialization(classLoader: ClassLoader?): AutoCloseable?

Should only be used by Driver and MockNode.

start

fun CordaRPCClient.start(user: User): CordaRPCConnection

startFlow

fun <T> <Error class: unknown class>.startFlow(logic: FlowLogic<T>): FlowStateMachineHandle<T>

startFlowWithClientId

fun <T> <Error class: unknown class>.startFlowWithClientId(clientId: String, logic: FlowLogic<T>): FlowStateMachineHandle<T>

startInVmRpcClient

inline fun <I : RPCOps> RPCDriverDSL.startInVmRpcClient(username: String = rpcTestUser.username, password: String = rpcTestUser.password, configuration: CordaRPCClientConfiguration = CordaRPCClientConfiguration.DEFAULT): <Error class: unknown class>

startNode

fun DriverDSL.startNode(providedName: CordaX500Name, devMode: Boolean, parameters: NodeParameters = NodeParameters()): CordaFuture<NodeHandle>

startRandomRpcClient

inline fun <I : RPCOps> RPCDriverDSL.startRandomRpcClient(hostAndPort: NetworkHostAndPort, username: String = rpcTestUser.username, password: String = rpcTestUser.password): CordaFuture<Process>

startRpcClient

inline fun <I : RPCOps> RPCDriverDSL.startRpcClient(haAddressPool: List<NetworkHostAndPort>, username: String = rpcTestUser.username, password: String = rpcTestUser.password, configuration: CordaRPCClientConfiguration = CordaRPCClientConfiguration.DEFAULT): <Error class: unknown class>

inline fun <I : RPCOps> RPCDriverDSL.startRpcClient(rpcAddress: NetworkHostAndPort, username: String = rpcTestUser.username, password: String = rpcTestUser.password, configuration: CordaRPCClientConfiguration = CordaRPCClientConfiguration.DEFAULT): <Error class: unknown class>

toNotaryConfig

fun MockNetNotaryConfig.toNotaryConfig(): <Error class: unknown class>

waitForShutdown

fun CordaRPCOps.waitForShutdown(): <Error class: unknown class><Unit>

fun NodeHandle.waitForShutdown(): <Error class: unknown class><Unit>

writeConfig

fun writeConfig(path: Path, filename: String, config: <Error class: unknown class>)