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>> = 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: <Error class: unknown class>, val notaryCustomOverrides: Map<String, Any?>, val inMemoryDB: Boolean, val cordappsForAllNodes: Collection<TestCordappInternal>?, val environmentVariables: Map<String, String>, val enableSNI: Boolean = false, val allowHibernateToManageAppSchema: Boolean = true, val premigrateH2Database: Boolean = true, val notaryHandleTimeout: Duration = Duration.ofMinutes(2)) : 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.

EnterpriseMockNamedCachedFactory

class EnterpriseMockNamedCachedFactory(sizeOverride: Long, metricRegistry: <Error class: unknown class>?, nodeConfiguration: <Error class: unknown class>?)

InMemoryMessage

data class InMemoryMessage(val topic: String, val data: <Error class: unknown class>, 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, val runMigrationScripts: 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(), val initialNetworkParameters: <Error class: unknown class> = 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: <Error class: unknown class>? = 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(), val cryptoServiceFlowRetryCount: Int? = null)

ListenProcessDeathException

class ListenProcessDeathException(hostAndPort: <Error class: unknown class>, listenProcess: Process)

MessagingServiceSpy

abstract class MessagingServiceSpy

MockCryptoService

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

MockEncryptionService

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

MockKeyManagementService

class MockKeyManagementService(val identityService: <Error class: unknown class>, initialKeys: KeyPair, val meteringRecorder: <Error class: unknown class> = MeteringRecorderFactory().stubbed())

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

MockNetworkParametersStorage

class MockNetworkParametersStorage(currentParameters: <Error class: unknown class> = testNetworkParameters(modifiedTime = Instant.MIN))

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(), val clock: <Error class: unknown class> = TestClock(Clock.systemUTC()))

MockNodeFlowManager

class MockNodeFlowManager

MockNodeMessagingService

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

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

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

NetworkVisibilityController

class NetworkVisibilityController

Keeps track of how many nodes each node sees and gates nodes from completing their startNode CordaFuture until all current nodes see everyone.

NodeBasedTest

abstract class NodeBasedTest(cordappPackages: Set<TestCordappInternal> = emptySet(), notaries: List<<Error class: unknown class>> = emptyList()) : IntegrationTest

NodeListenProcessDeathException

class NodeListenProcessDeathException(hostAndPort: <Error class: unknown class>, listenProcess: Process, val causeFromStdError: String)

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: <Error class: unknown class>?, val clientTransportConfiguration: <Error class: unknown class>, val serverControl: <Error class: unknown class>, val shutdown: () -> Unit)

RPCDriverDSL

data class RPCDriverDSL(driverDSL: DriverDSLImpl, externalTrace: <Error class: unknown class>?) : 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<<Error class: unknown class>>) -> 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<<Error class: unknown class>>) -> 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

BUSINESS_NETWORK_CORDAPP

val BUSINESS_NETWORK_CORDAPP: ScanPackageTestCordapp

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: <Error class: unknown class>

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: <Error class: unknown class>, listenProcess: Process? = null)

addressMustBeBoundFuture

fun addressMustBeBoundFuture(executorService: ScheduledExecutorService, hostAndPort: <Error class: unknown class>, listenProcess: Process? = null): <Error class: unknown class><Unit>

addressMustNotBeBound

fun addressMustNotBeBound(executorService: ScheduledExecutorService, hostAndPort: <Error class: unknown class>, timeout: Duration = 40.seconds)

addressMustNotBeBoundFuture

fun addressMustNotBeBoundFuture(executorService: ScheduledExecutorService, hostAndPort: <Error class: unknown class>): <Error class: unknown class><Unit>

applyMockNodeOverrides

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

assertUncompletedCheckpoints

fun DriverDSL.assertUncompletedCheckpoints(name: <Error class: unknown class>, 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>>): 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.

createDataSourceConfig

fun createDataSourceConfig(providedNodeName: String? = null, postfix: String? = null, inMemory: Boolean): <Error class: unknown class>

Creates data source configuration for in memory H2 as it would be specified in reference.conf 'datasource' snippet.

databaseProviderDataSourceConfig

fun databaseProviderDataSourceConfig(nodeName: String? = null, nodeSchemaName: String? = null): <Error class: unknown class>

Reads database and dataSource configuration from a file denoted by 'databaseProvider' system property, overwritten by system properties and defaults to H2 in memory db.

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

inMemoryH2DataSourceConfig

fun inMemoryH2DataSourceConfig(providedNodeName: String? = null, postfix: String? = null): <Error class: unknown class>

Creates data source configuration for in memory H2 as it would be specified in reference.conf 'datasource' snippet.

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: <Error class: unknown class> = DriverParameters().networkParameters, compatibilityZone: CompatibilityZoneParams? = null, notaryCustomOverrides: Map<String, Any?> = DriverParameters().notaryCustomOverrides, inMemoryDB: Boolean = DriverParameters().inMemoryDB, cordappsForAllNodes: Collection<TestCordappInternal>? = null, environmentVariables: Map<String, String> = emptyMap(), enableSNI: Boolean = DriverParameters().enableSNI, allowHibernateToManageAppSchema: Boolean = true, premigrateH2Database: Boolean = true, notaryHandleTimeout: Duration = Duration.ofMinutes(2), dsl: DriverDSLImpl.() -> A): A

makeInternalTestDataSourceProperties

fun makeInternalTestDataSourceProperties(nodeName: String? = SecureHash.randomSHA256().toString(), nodeNameExtension: String? = null, nodeSchemaName: String? = null, mode: String? = null, configSupplier: (String?, String?) -> <Error class: unknown class> = ::databaseProviderDataSourceConfig, fallBackConfigSupplier: (String?, String?, String?) -> <Error class: unknown class> = ::onDiskH2DataSourceConfig): Properties

Make properties appropriate for creating a DataSource for unit tests. Defaults configuration of in-memory H2 instance. If 'databaseProvider' system property is set then creates a config from the relevant config file is present in resources folder (used to parametrize test to run against a remote database). Properties retrieval can be parameterized by configSupplier and/or fallBackConfigSupplier methods which are run with nodeName and nodeNameExtension parameters.

makeTestDatabaseProperties

fun makeTestDatabaseProperties(nodeName: String? = null, nodeSchemaName: String? = null, configSupplier: (String?, String?) -> <Error class: unknown class> = ::databaseProviderDataSourceConfig): <Error class: unknown class>

Make properties appropriate for creating a Database for unit tests.

newContext

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

nodeMustBeStartedFuture

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

onDiskH2DataSourceConfig

fun onDiskH2DataSourceConfig(providedNodeName: String? = null, postfix: String? = null, mode: String? = null): <Error class: unknown class>

Creates data source configuration for on disk H2 as it would be specified in reference.conf 'datasource' snippet.

poll

fun <A> poll(executorService: ScheduledExecutorService, pollName: String, pollInterval: Duration = 500.millis, warnCount: Int = 180, check: () -> A?): <Error class: unknown class><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: <Error class: unknown class>? = null, jmxPolicy: JmxPolicy = JmxPolicy(), networkParameters: <Error class: unknown class> = testNetworkParameters(), notaryCustomOverrides: Map<String, Any?> = emptyMap(), inMemoryDB: Boolean = true, cordappsForAllNodes: Collection<TestCordappInternal>? = null, environmentVariables: Map<String, String> = emptyMap(), enableSNI: Boolean = true, 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: <Error class: unknown class><T>): <Error class: unknown class><T>

startFlowWithClientId

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

startInVmRpcClient

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

startNode

fun DriverDSL.startNode(providedName: <Error class: unknown class>, devMode: Boolean, parameters: NodeParameters = NodeParameters()): <Error class: unknown class><NodeHandle>

startRandomRpcClient

inline fun RPCDriverDSL.startRandomRpcClient(hostAndPort: <Error class: unknown class>, username: String = rpcTestUser.username, password: String = rpcTestUser.password): <Error class: unknown class><Process>

startRpcClient

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

inline fun RPCDriverDSL.startRpcClient(haAddressPool: List<<Error class: unknown class>>, 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 <Error class: unknown class>.waitForShutdown(): <Error class: unknown class><Unit>

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

withDatabaseConnection

fun <T> DriverDSL.withDatabaseConnection(name: <Error class: unknown class>, block: (Connection) -> T): T

writeConfig

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