Fix broken integration test following rebase from OS master (mostly test utils identity constant redefinitions / renaming)

2025-04-19 08:36:39 +00:00 · 2017-12-13 12:34:06 +00:00 · 2017-12-13 12:34:06 +00:00 · 4e42fff7d4
commit 4e42fff7d4
parent d1998b2c94
27 changed files with 114 additions and 95 deletions
--- a/core/src/test/java/net/corda/core/flows/FlowsInJavaTest.java
+++ b/core/src/test/java/net/corda/core/flows/FlowsInJavaTest.java
@ -14,10 +14,9 @@ import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;

 import static net.corda.testing.CoreTestUtils.singleIdentity;
-import static net.corda.testing.NodeTestUtils.startFlow;
+import static net.corda.testing.node.NodeTestUtils.startFlow;
 import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
 import static org.junit.Assert.fail;
-import static net.corda.testing.node.NodeTestUtils.startFlow;

 public class FlowsInJavaTest {
    private final MockNetwork mockNet = new MockNetwork();
--- a/docs/source/example-code/src/integration-test/kotlin/net/corda/docs/IntegrationTestingTutorial.kt
+++ b/docs/source/example-code/src/integration-test/kotlin/net/corda/docs/IntegrationTestingTutorial.kt
@ -1,5 +1,6 @@
 package net.corda.docs

+import net.corda.core.identity.CordaX500Name
 import net.corda.core.internal.concurrent.transpose
 import net.corda.core.messaging.CordaRPCOps
 import net.corda.core.messaging.startFlow
@ -23,7 +24,7 @@ import kotlin.test.assertEquals
 class IntegrationTestingTutorial : IntegrationTest() {
    companion object {
        @ClassRule @JvmField
-        val databaseSchemas = IntegrationTestSchemas(*listOf(ALICE, BOB, DUMMY_NOTARY).map { it.toDatabaseSchemaName() }.toTypedArray())
+        val databaseSchemas = IntegrationTestSchemas(*listOf(ALICE_NAME, BOB_NAME, DUMMY_NOTARY_NAME).map { it.toDatabaseSchemaName() }.toTypedArray())
    }

    @Test
--- a/finance/src/integration-test/kotlin/net/corda/finance/flows/CashConfigDataFlowTest.kt
+++ b/finance/src/integration-test/kotlin/net/corda/finance/flows/CashConfigDataFlowTest.kt
@ -13,7 +13,7 @@ import org.junit.Test
 class CashConfigDataFlowTest : IntegrationTest() {
    companion object {
        @ClassRule @JvmField
-        val databaseSchemas = IntegrationTestSchemas(*listOf(ALICE, BOB, DUMMY_BANK_A)
+        val databaseSchemas = IntegrationTestSchemas(*listOf(ALICE_NAME, BOB_NAME, DUMMY_BANK_A_NAME)
                .map { it.toDatabaseSchemaNames("","_10000","_10003") }.flatten().toTypedArray())
    }
    @Test
--- a/network-management/src/integration-test/kotlin/com/r3/corda/networkmanage/doorman/DoormanIntegrationTest.kt
+++ b/network-management/src/integration-test/kotlin/com/r3/corda/networkmanage/doorman/DoormanIntegrationTest.kt
@ -21,10 +21,10 @@ import net.corda.node.services.network.NetworkMapClient
 import net.corda.node.utilities.registration.HTTPNetworkRegistrationService
 import net.corda.node.utilities.registration.NetworkRegistrationHelper
 import net.corda.nodeapi.internal.crypto.*
-import net.corda.testing.ALICE
+import net.corda.testing.ALICE_NAME
 import net.corda.testing.SerializationEnvironmentRule
 import net.corda.testing.common.internal.testNetworkParameters
-import net.corda.testing.testNodeConfiguration
+import net.corda.testing.node.testNodeConfiguration
 import org.bouncycastle.cert.X509CertificateHolder
 import org.junit.Ignore
 import org.junit.Rule
@ -57,7 +57,7 @@ class DoormanIntegrationTest {
        // Start Corda network registration.
        val config = testNodeConfiguration(
                baseDirectory = tempFolder.root.toPath(),
-                myLegalName = ALICE.name).also {
+                myLegalName = ALICE_NAME).also {
            val doormanHostAndPort = doorman.hostAndPort
            whenever(it.compatibilityZoneURL).thenReturn(URL("http://${doormanHostAndPort.host}:${doormanHostAndPort.port}"))
            whenever(it.emailAddress).thenReturn("iTest@R3.com")
@ -77,13 +77,13 @@ class DoormanIntegrationTest {

        loadKeyStore(config.nodeKeystore, config.keyStorePassword).apply {
            assert(containsAlias(X509Utilities.CORDA_CLIENT_CA))
-            assertEquals(ALICE.name.copy(commonName = X509Utilities.CORDA_CLIENT_CA_CN).x500Principal, getX509Certificate(X509Utilities.CORDA_CLIENT_CA).subjectX500Principal)
+            assertEquals(ALICE_NAME.copy(commonName = X509Utilities.CORDA_CLIENT_CA_CN).x500Principal, getX509Certificate(X509Utilities.CORDA_CLIENT_CA).subjectX500Principal)
            assertEquals(listOf(intermediateCACert.cert, rootCACert.cert), getCertificateChain(X509Utilities.CORDA_CLIENT_CA).drop(1).toList())
        }

        loadKeyStore(config.sslKeystore, config.keyStorePassword).apply {
            assert(containsAlias(X509Utilities.CORDA_CLIENT_TLS))
-            assertEquals(ALICE.name.x500Principal, getX509Certificate(X509Utilities.CORDA_CLIENT_TLS).subjectX500Principal)
+            assertEquals(ALICE_NAME.x500Principal, getX509Certificate(X509Utilities.CORDA_CLIENT_TLS).subjectX500Principal)
            assertEquals(listOf(intermediateCACert.cert, rootCACert.cert), getCertificateChain(X509Utilities.CORDA_CLIENT_TLS).drop(2).toList())
        }

@ -110,7 +110,7 @@ class DoormanIntegrationTest {
        // Start Corda network registration.
        val config = testNodeConfiguration(
                baseDirectory = tempFolder.root.toPath(),
-                myLegalName = ALICE.name).also {
+                myLegalName = ALICE_NAME).also {
            whenever(it.compatibilityZoneURL).thenReturn(URL("http://${doormanHostAndPort.host}:${doormanHostAndPort.port}"))
            whenever(it.emailAddress).thenReturn("iTest@R3.com")
        }
--- a/network-management/src/integration-test/kotlin/com/r3/corda/networkmanage/hsm/SigningServiceIntegrationTest.kt
+++ b/network-management/src/integration-test/kotlin/com/r3/corda/networkmanage/hsm/SigningServiceIntegrationTest.kt
@ -23,7 +23,11 @@ import net.corda.node.utilities.registration.NetworkRegistrationHelper
 import net.corda.nodeapi.internal.crypto.CertificateType
 import net.corda.nodeapi.internal.crypto.X509Utilities
 import net.corda.nodeapi.internal.persistence.DatabaseConfig
-import net.corda.testing.*
+import net.corda.testing.ALICE_NAME
+import net.corda.testing.BOB_NAME
+import net.corda.testing.CHARLIE_NAME
+import net.corda.testing.SerializationEnvironmentRule
+import net.corda.testing.node.testNodeConfiguration
 import org.bouncycastle.cert.X509CertificateHolder
 import org.bouncycastle.pkcs.jcajce.JcaPKCS10CertificationRequest
 import org.h2.tools.Server
@ -101,7 +105,7 @@ class SigningServiceIntegrationTest {
            // Start Corda network registration.
            val config = testNodeConfiguration(
                    baseDirectory = tempFolder.root.toPath(),
-                    myLegalName = ALICE.name).also {
+                    myLegalName = ALICE_NAME).also {
                val doormanHostAndPort = server.hostAndPort
                whenever(it.compatibilityZoneURL).thenReturn(URL("http://${doormanHostAndPort.host}:${doormanHostAndPort.port}"))
            }
@ -162,9 +166,9 @@ class SigningServiceIntegrationTest {
                    val config = testNodeConfiguration(
                            baseDirectory = tempFolder.root.toPath(),
                            myLegalName = when (it) {
-                                1 -> ALICE.name
-                                2 -> BOB.name
-                                3 -> CHARLIE.name
+                                1 -> ALICE_NAME
+                                2 -> BOB_NAME
+                                3 -> CHARLIE_NAME
                                else -> throw IllegalArgumentException("Unrecognised option")
                            }).also {
                        whenever(it.compatibilityZoneURL).thenReturn(URL("http://$HOST:${server.hostAndPort.port}"))
--- a/node/src/integration-test/kotlin/net/corda/node/BootTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/BootTests.kt
@ -9,9 +9,7 @@ import net.corda.core.utilities.getOrThrow
 import net.corda.node.internal.NodeStartup
 import net.corda.node.services.Permissions.Companion.startFlow
 import net.corda.nodeapi.internal.config.User
-import net.corda.testing.ALICE
 import net.corda.testing.*
-import net.corda.testing.ALICE_NAME
 import net.corda.testing.common.internal.ProjectStructure.projectRootDir
 import net.corda.testing.driver.driver
 import org.assertj.core.api.Assertions.assertThat
@ -25,7 +23,7 @@ import kotlin.test.assertEquals
 class BootTests : IntegrationTest() {
     companion object {
        @ClassRule @JvmField
-        val databaseSchemas = IntegrationTestSchemas(*listOf(ALICE, BOB, DUMMY_BANK_A)
+        val databaseSchemas = IntegrationTestSchemas(*listOf(ALICE_NAME, BOB_NAME, DUMMY_BANK_A_NAME)
                .map { it.toDatabaseSchemaNames("", "_10000","_10003") }.flatten().toTypedArray())
     }

--- a/node/src/integration-test/kotlin/net/corda/node/CordappScanningDriverTest.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/CordappScanningDriverTest.kt
@ -9,10 +9,6 @@ import net.corda.core.utilities.getOrThrow
 import net.corda.core.utilities.unwrap
 import net.corda.node.services.Permissions.Companion.startFlow
 import net.corda.nodeapi.internal.config.User
-import net.corda.testing.ALICE
-import net.corda.testing.BOB
-import net.corda.testing.chooseIdentity
-import net.corda.testing.*
 import net.corda.testing.*
 import net.corda.testing.driver.driver
 import org.assertj.core.api.Assertions.assertThat
@ -22,7 +18,7 @@ import org.junit.Test
 class CordappScanningDriverTest : IntegrationTest() {
    companion object {
        @ClassRule @JvmField
-        val databaseSchemas = IntegrationTestSchemas(ALICE.toDatabaseSchemaName(), BOB.toDatabaseSchemaName())
+        val databaseSchemas = IntegrationTestSchemas(ALICE_NAME.toDatabaseSchemaName(), BOB_NAME.toDatabaseSchemaName())
    }

    @Test
--- a/node/src/integration-test/kotlin/net/corda/node/NodeKeystoreCheckTest.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/NodeKeystoreCheckTest.kt
@ -8,8 +8,11 @@ import net.corda.core.utilities.getOrThrow
 import net.corda.node.services.config.configureDevKeyAndTrustStores
 import net.corda.nodeapi.internal.config.SSLConfiguration
 import net.corda.nodeapi.internal.crypto.*
-import net.corda.testing.*
+import net.corda.testing.ALICE_NAME
+import net.corda.testing.IntegrationTest
+import net.corda.testing.IntegrationTestSchemas
 import net.corda.testing.driver.driver
+import net.corda.testing.toDatabaseSchemaName
 import org.junit.ClassRule
 import org.junit.Test
 import java.nio.file.Path
@ -20,7 +23,7 @@ import kotlin.test.assertTrue
 class NodeKeystoreCheckTest : IntegrationTest() {
    companion object {
        @ClassRule @JvmField
-        val databaseSchemas = IntegrationTestSchemas(ALICE.toDatabaseSchemaName())
+        val databaseSchemas = IntegrationTestSchemas(ALICE_NAME.toDatabaseSchemaName())
    }

    @Test
--- a/node/src/integration-test/kotlin/net/corda/node/NodePerformanceTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/NodePerformanceTests.kt
@ -14,18 +14,16 @@ import net.corda.finance.flows.CashIssueFlow
 import net.corda.finance.flows.CashPaymentFlow
 import net.corda.node.services.Permissions.Companion.startFlow
 import net.corda.nodeapi.internal.config.User
-import net.corda.testing.DUMMY_NOTARY
 import net.corda.testing.*
-import net.corda.testing.DUMMY_NOTARY_NAME
 import net.corda.testing.driver.NodeHandle
 import net.corda.testing.driver.PortAllocation
 import net.corda.testing.driver.driver
-import net.corda.testing.node.internal.InternalDriverDSL
 import net.corda.testing.internal.performance.div
+import net.corda.testing.node.NotarySpec
+import net.corda.testing.node.internal.InternalDriverDSL
 import net.corda.testing.node.internal.performance.startPublishingFixedRateInjector
 import net.corda.testing.node.internal.performance.startReporter
 import net.corda.testing.node.internal.performance.startTightLoopInjector
-import net.corda.testing.node.NotarySpec
 import org.junit.Before
 import org.junit.ClassRule
 import org.junit.Ignore
@ -33,8 +31,6 @@ import org.junit.Test
 import java.lang.management.ManagementFactory
 import java.util.*
 import java.util.concurrent.TimeUnit
-import kotlin.streams.toList
-

 private fun checkQuasarAgent() {
    if (!(ManagementFactory.getRuntimeMXBean().inputArguments.any { it.contains("quasar") })) {
@ -45,9 +41,10 @@ private fun checkQuasarAgent() {
@Ignore("Run these locally")
 class NodePerformanceTests : IntegrationTest() {
     companion object {
+        val ALICE = TestIdentity(ALICE_NAME, 70).party
        @ClassRule @JvmField
-        val databaseSchemas = IntegrationTestSchemas(*DUMMY_NOTARY.toDatabaseSchemaNames("_0", "_1", "_2").toTypedArray(),
-                DUMMY_BANK_A.toDatabaseSchemaName())
+        val databaseSchemas = IntegrationTestSchemas(*DUMMY_NOTARY_NAME.toDatabaseSchemaNames("_0", "_1", "_2").toTypedArray(),
+                DUMMY_BANK_A_NAME.toDatabaseSchemaName())
    }

    @StartableByRPC
@ -154,7 +151,7 @@ class NodePerformanceTests : IntegrationTest() {
    fun `single pay`() {
        val user = User("A", "A", setOf(startFlow<CashIssueFlow>(), startFlow<CashPaymentFlow>()))
        driver(
-                notarySpecs = listOf(NotarySpec(DUMMY_NOTARY.name, rpcUsers = listOf(user))),
+                notarySpecs = listOf(NotarySpec(DUMMY_NOTARY_NAME, rpcUsers = listOf(user))),
                startNodesInProcess = true,
                extraCordappPackagesToScan = listOf("net.corda.finance"),
                portAllocation = PortAllocation.Incremental(20000)
--- a/node/src/integration-test/kotlin/net/corda/node/NodeStartupPerformanceTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/NodeStartupPerformanceTests.kt
@ -13,7 +13,7 @@ import java.util.concurrent.TimeUnit
 class NodeStartupPerformanceTests : IntegrationTest() {
    companion object {
        @ClassRule @JvmField
-        val databaseSchemas = IntegrationTestSchemas(*listOf(ALICE, BOB, DUMMY_BANK_A).map { it.toDatabaseSchemaName() }.toTypedArray())
+        val databaseSchemas = IntegrationTestSchemas(*listOf(ALICE_NAME, BOB_NAME, DUMMY_BANK_A_NAME).map { it.toDatabaseSchemaName() }.toTypedArray())
    }
    // Measure the startup time of nodes. Note that this includes an RPC roundtrip, which causes e.g. Kryo initialisation.
    @Test
--- a/node/src/integration-test/kotlin/net/corda/node/SSHServerTest.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/SSHServerTest.kt
@ -4,30 +4,33 @@ import co.paralleluniverse.fibers.Suspendable
 import com.jcraft.jsch.ChannelExec
 import com.jcraft.jsch.JSch
 import com.jcraft.jsch.JSchException
-import net.corda.core.flows.*
+import net.corda.core.flows.FlowLogic
+import net.corda.core.flows.InitiatingFlow
+import net.corda.core.flows.StartableByRPC
 import net.corda.core.identity.Party
 import net.corda.core.utilities.ProgressTracker
 import net.corda.core.utilities.getOrThrow
-import net.corda.core.utilities.toHex
 import net.corda.core.utilities.unwrap
-import net.corda.nodeapi.internal.config.User
-import net.corda.testing.driver.driver
-import org.bouncycastle.util.io.Streams
-import org.junit.Test
 import net.corda.node.services.Permissions.Companion.startFlow
-import net.corda.testing.*
+import net.corda.nodeapi.internal.config.User
 import net.corda.testing.ALICE_NAME
+import net.corda.testing.IntegrationTest
+import net.corda.testing.IntegrationTestSchemas
+import net.corda.testing.driver.driver
+import net.corda.testing.toDatabaseSchemaName
+import org.assertj.core.api.Assertions.assertThat
+import org.bouncycastle.util.io.Streams
+import org.junit.ClassRule
+import org.junit.Test
 import java.net.ConnectException
+import java.util.regex.Pattern
 import kotlin.test.assertTrue
 import kotlin.test.fail
-import org.assertj.core.api.Assertions.assertThat
-import org.junit.ClassRule
-import java.util.regex.Pattern

 class SSHServerTest : IntegrationTest() {
    companion object {
        @ClassRule @JvmField
-        val databaseSchemas = IntegrationTestSchemas(ALICE.toDatabaseSchemaName())
+        val databaseSchemas = IntegrationTestSchemas(ALICE_NAME.toDatabaseSchemaName())
    }

    @Test()
--- a/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt
@ -41,7 +41,7 @@ class AttachmentLoadingTests : IntegrationTest() {

    private companion object {
        @ClassRule @JvmField
-        val databaseSchemas = IntegrationTestSchemas(*listOf(DUMMY_BANK_A, DUMMY_BANK_B, DUMMY_NOTARY)
+        val databaseSchemas = IntegrationTestSchemas(*listOf(DUMMY_BANK_A_NAME, DUMMY_BANK_B_NAME, DUMMY_NOTARY_NAME)
                .map { it.toDatabaseSchemaName() }.toTypedArray())

        private val logger = contextLogger()
--- a/node/src/integration-test/kotlin/net/corda/node/services/DistributedServiceTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/DistributedServiceTests.kt
@ -33,8 +33,8 @@ class DistributedServiceTests : IntegrationTest() {
    private lateinit var notaryStateMachines: Observable<Pair<Party, StateMachineUpdate>>
    companion object {
        @ClassRule @JvmField
-        val databaseSchemas = IntegrationTestSchemas(*DUMMY_NOTARY.toDatabaseSchemaNames("_0", "_1", "_2").toTypedArray(),
-                ALICE.toDatabaseSchemaName())
+        val databaseSchemas = IntegrationTestSchemas(*DUMMY_NOTARY_NAME.toDatabaseSchemaNames("_0", "_1", "_2").toTypedArray(),
+                ALICE_NAME.toDatabaseSchemaName())
    }
    private fun setup(testBlock: () -> Unit) {
        val testUser = User("test", "test", permissions = setOf(
--- a/node/src/integration-test/kotlin/net/corda/node/services/RaftNotaryServiceTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/RaftNotaryServiceTests.kt
@ -16,10 +16,9 @@ import net.corda.testing.*
 import net.corda.testing.contracts.DummyContract
 import net.corda.testing.driver.NodeHandle
 import net.corda.testing.driver.driver
-import net.corda.testing.dummyCommand
-import net.corda.testing.node.startFlow
 import net.corda.testing.node.ClusterSpec
 import net.corda.testing.node.NotarySpec
+import net.corda.testing.node.startFlow
 import org.junit.ClassRule
 import org.junit.Test
 import java.util.*
@ -30,7 +29,7 @@ class RaftNotaryServiceTests : IntegrationTest() {
    companion object {
        @ClassRule @JvmField
        val databaseSchemas = IntegrationTestSchemas( "RAFTNotaryService_0", "RAFTNotaryService_1", "RAFTNotaryService_2",
-                DUMMY_BANK_A.toDatabaseSchemaName())
+                DUMMY_BANK_A_NAME.toDatabaseSchemaName())
    }
    private val notaryName = CordaX500Name(RaftValidatingNotaryService.id, "RAFT Notary Service", "London", "GB")

--- a/node/src/integration-test/kotlin/net/corda/node/services/UserAuthServiceTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/UserAuthServiceTests.kt
@ -11,13 +11,15 @@ import net.corda.core.messaging.startFlow
 import net.corda.finance.flows.CashIssueFlow
 import net.corda.node.internal.Node
 import net.corda.node.internal.StartedNode
+import net.corda.node.services.config.AuthDataSourceType
 import net.corda.node.services.config.PasswordEncryption
 import net.corda.node.services.config.SecurityConfiguration
-import net.corda.node.services.config.AuthDataSourceType
 import net.corda.nodeapi.internal.config.User
 import net.corda.nodeapi.internal.config.toConfig
+import net.corda.testing.ALICE_NAME
+import net.corda.testing.IntegrationTestSchemas
 import net.corda.testing.node.internal.NodeBasedTest
-import net.corda.testing.*
+import net.corda.testing.toDatabaseSchemaName
 import org.apache.activemq.artemis.api.core.ActiveMQSecurityException
 import org.junit.After
 import org.junit.Before
@ -31,7 +33,7 @@ import kotlin.test.assertFailsWith
 abstract class UserAuthServiceTest : NodeBasedTest() {
    companion object {
        @ClassRule @JvmField
-        val databaseSchemas = IntegrationTestSchemas(ALICE.toDatabaseSchemaName())
+        val databaseSchemas = IntegrationTestSchemas(ALICE_NAME.toDatabaseSchemaName())
    }

    protected lateinit var node: StartedNode<Node>
--- a/node/src/integration-test/kotlin/net/corda/node/services/network/PersistentNetworkMapCacheTest.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/network/PersistentNetworkMapCacheTest.kt
@ -7,11 +7,6 @@ import net.corda.core.utilities.NetworkHostAndPort
 import net.corda.node.internal.Node
 import net.corda.node.internal.StartedNode
 import net.corda.testing.*
-import net.corda.testing.internal.NodeBasedTest
-import net.corda.testing.ALICE_NAME
-import net.corda.testing.BOB_NAME
-import net.corda.testing.TestIdentity
-import net.corda.testing.chooseIdentity
 import net.corda.testing.node.internal.NodeBasedTest
 import org.junit.Before
 import org.junit.ClassRule
@ -25,7 +20,7 @@ class PersistentNetworkMapCacheTest : NodeBasedTest() {
        val DUMMY_REGULATOR = TestIdentity(CordaX500Name("Regulator A", "Paris", "FR"), 100).party

        @ClassRule @JvmField
-        val databaseSchemas = IntegrationTestSchemas(*listOf(DUMMY_REGULATOR, ALICE, BOB).map { it.toDatabaseSchemaName() }.toTypedArray())
+        val databaseSchemas = IntegrationTestSchemas(*listOf(DUMMY_REGULATOR.name, ALICE.name, BOB.name).map { it.toDatabaseSchemaName() }.toTypedArray())
    }
    private val partiesList = listOf(DUMMY_REGULATOR, ALICE, BOB)
    private val addressesMap = HashMap<CordaX500Name, NetworkHostAndPort>()
--- a/node/src/integration-test/kotlin/net/corda/node/services/statemachine/FlowVersioningTest.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/statemachine/FlowVersioningTest.kt
@ -7,12 +7,9 @@ import net.corda.core.flows.InitiatingFlow
 import net.corda.core.identity.Party
 import net.corda.core.utilities.getOrThrow
 import net.corda.core.utilities.unwrap
-import net.corda.testing.chooseIdentity
+import net.corda.testing.*
 import net.corda.testing.node.internal.NodeBasedTest
 import net.corda.testing.node.startFlow
-import net.corda.testing.*
-import net.corda.testing.*
-import net.corda.testing.internal.NodeBasedTest
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.ClassRule
 import org.junit.Test
@ -20,7 +17,7 @@ import org.junit.Test
 class FlowVersioningTest : NodeBasedTest() {
    companion object {
        @ClassRule @JvmField
-        val databaseSchemas = IntegrationTestSchemas(ALICE.toDatabaseSchemaName(), BOB.toDatabaseSchemaName())
+        val databaseSchemas = IntegrationTestSchemas(ALICE_NAME.toDatabaseSchemaName(), BOB_NAME.toDatabaseSchemaName())
    }

    @Test
--- a/node/src/integration-test/kotlin/net/corda/node/services/statemachine/LargeTransactionsTest.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/statemachine/LargeTransactionsTest.kt
@ -23,12 +23,10 @@ import kotlin.test.assertEquals
 */
 class LargeTransactionsTest : IntegrationTest() {
    companion object {
-        private companion object {
-            val BOB = TestIdentity(BOB_NAME, 80).party
-            val DUMMY_NOTARY = TestIdentity(DUMMY_NOTARY_NAME, 20).party
-        }
+        val BOB = TestIdentity(BOB_NAME, 80).party
+        val DUMMY_NOTARY = TestIdentity(DUMMY_NOTARY_NAME, 20).party
        @ClassRule @JvmField
-        val databaseSchemas = IntegrationTestSchemas(*listOf(ALICE, BOB, DUMMY_NOTARY).map { it.toDatabaseSchemaName() }.toTypedArray())
+        val databaseSchemas = IntegrationTestSchemas(*listOf(ALICE_NAME, BOB_NAME, DUMMY_NOTARY_NAME).map { it.toDatabaseSchemaName() }.toTypedArray())
    }

    @StartableByRPC
--- a/node/src/integration-test/kotlin/net/corda/node/services/vault/VaultQueryIntegrationTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/node/services/vault/VaultQueryIntegrationTests.kt
@ -1,6 +1,7 @@
 package net.corda.node.services.vault


+import net.corda.core.identity.CordaX500Name
 import net.corda.testing.*
 import org.junit.*

@ -22,6 +23,7 @@ class VaultQueryIntegrationTests : VaultQueryTests() {
    }

    companion object {
+        val MEGA_CORP = TestIdentity(CordaX500Name("MegaCorp", "London", "GB")).name
        @ClassRule @JvmField
        val databaseSchemas = IntegrationTestSchemas(MEGA_CORP.toDatabaseSchemaName())

--- a/node/src/integration-test/kotlin/net/corda/services/messaging/MQSecurityTest.kt
+++ b/node/src/integration-test/kotlin/net/corda/services/messaging/MQSecurityTest.kt
@ -18,16 +18,16 @@ import net.corda.core.utilities.toBase58String
 import net.corda.core.utilities.unwrap
 import net.corda.node.internal.Node
 import net.corda.node.internal.StartedNode
+import net.corda.nodeapi.RPCApi
 import net.corda.nodeapi.internal.ArtemisMessagingComponent.Companion.INTERNAL_PREFIX
 import net.corda.nodeapi.internal.ArtemisMessagingComponent.Companion.NOTIFICATIONS_ADDRESS
 import net.corda.nodeapi.internal.ArtemisMessagingComponent.Companion.P2P_QUEUE
 import net.corda.nodeapi.internal.ArtemisMessagingComponent.Companion.PEERS_PREFIX
-import net.corda.nodeapi.RPCApi
-import net.corda.nodeapi.internal.config.User
 import net.corda.nodeapi.internal.config.SSLConfiguration
+import net.corda.nodeapi.internal.config.User
 import net.corda.testing.*
-import net.corda.testing.node.internal.NodeBasedTest
 import net.corda.testing.messaging.SimpleMQClient
+import net.corda.testing.node.internal.NodeBasedTest
 import net.corda.testing.node.startFlow
 import org.apache.activemq.artemis.api.core.ActiveMQNonExistentQueueException
 import org.apache.activemq.artemis.api.core.ActiveMQSecurityException
@ -45,7 +45,7 @@ import kotlin.test.assertEquals
 abstract class MQSecurityTest : NodeBasedTest() {
    companion object {
        @ClassRule @JvmField
-        val databaseSchemas = IntegrationTestSchemas(ALICE.toDatabaseSchemaName(), BOB.toDatabaseSchemaName())
+        val databaseSchemas = IntegrationTestSchemas(ALICE_NAME.toDatabaseSchemaName(), BOB_NAME.toDatabaseSchemaName())
    }
    val rpcUser = User("user1", "pass", permissions = emptySet())
    lateinit var alice: StartedNode<Node>
--- a/node/src/integration-test/kotlin/net/corda/services/messaging/P2PMessagingTest.kt
+++ b/node/src/integration-test/kotlin/net/corda/services/messaging/P2PMessagingTest.kt
@ -19,8 +19,6 @@ import net.corda.node.services.messaging.ReceivedMessage
 import net.corda.node.services.messaging.send
 import net.corda.node.services.transactions.RaftValidatingNotaryService
 import net.corda.testing.*
-import net.corda.testing.ALICE_NAME
-import net.corda.testing.chooseIdentity
 import net.corda.testing.driver.DriverDSL
 import net.corda.testing.driver.NodeHandle
 import net.corda.testing.driver.driver
@ -38,7 +36,7 @@ import java.util.concurrent.atomic.AtomicInteger
 class P2PMessagingTest : IntegrationTest() {
     private companion object {
        @ClassRule @JvmField
-        val databaseSchemas = IntegrationTestSchemas(ALICE.toDatabaseSchemaName(), "DistributedService_0", "DistributedService_1")
+        val databaseSchemas = IntegrationTestSchemas(ALICE_NAME.toDatabaseSchemaName(), "DistributedService_0", "DistributedService_1")

        val DISTRIBUTED_SERVICE_NAME = CordaX500Name(RaftValidatingNotaryService.id, "DistributedService", "London", "GB")
    }
--- a/node/src/integration-test/kotlin/net/corda/test/node/NodeStatePersistenceTests.kt
+++ b/node/src/integration-test/kotlin/net/corda/test/node/NodeStatePersistenceTests.kt
@ -20,7 +20,6 @@ import net.corda.core.utilities.getOrThrow
 import net.corda.node.services.Permissions.Companion.invokeRpc
 import net.corda.node.services.Permissions.Companion.startFlow
 import net.corda.nodeapi.internal.config.User
-import net.corda.testing.chooseIdentity
 import net.corda.testing.*
 import net.corda.testing.driver.driver
 import org.junit.Assume.assumeFalse
@ -36,9 +35,9 @@ import kotlin.test.assertNotNull
 class NodeStatePersistenceTests : IntegrationTest() {
    companion object {
        @ClassRule @JvmField
-        val databaseSchemas = IntegrationTestSchemas(*listOf(ALICE, BOB, DUMMY_BANK_A)
+        val databaseSchemas = IntegrationTestSchemas(*listOf(ALICE_NAME, BOB_NAME, DUMMY_BANK_A_NAME)
                .map { it.toDatabaseSchemaNames("", "_10000","_10003","_10006") }.flatten().toTypedArray(),
-                DUMMY_NOTARY.toDatabaseSchemaName())
+                DUMMY_NOTARY_NAME.toDatabaseSchemaName())
    }
    @Test
    fun `persistent state survives node restart`() {
--- a/node/src/test/kotlin/net/corda/node/services/persistence/DBCheckpointStorageTests.kt
+++ b/node/src/test/kotlin/net/corda/node/services/persistence/DBCheckpointStorageTests.kt
@ -3,6 +3,7 @@ package net.corda.node.services.persistence
 import net.corda.core.context.InvocationContext
 import net.corda.core.flows.FlowLogic
 import net.corda.core.flows.StateMachineRunId
+import net.corda.core.identity.CordaX500Name
 import net.corda.core.serialization.SerializationDefaults
 import net.corda.core.serialization.SerializedBytes
 import net.corda.core.serialization.serialize
@ -13,11 +14,8 @@ import net.corda.node.services.statemachine.FlowStart
 import net.corda.node.services.transactions.PersistentUniquenessProvider
 import net.corda.nodeapi.internal.persistence.CordaPersistence
 import net.corda.nodeapi.internal.persistence.DatabaseConfig
-import net.corda.testing.ALICE
-import net.corda.testing.LogHelper
-import net.corda.testing.SerializationEnvironmentRule
+import net.corda.testing.*
 import net.corda.testing.node.MockServices.Companion.makeTestDataSourceProperties
-import net.corda.testing.rigorousMock
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.After
 import org.junit.Before
@ -31,6 +29,9 @@ internal fun CheckpointStorage.checkpoints(): List<SerializedBytes<Checkpoint>>
 }

 class DBCheckpointStorageTests {
+    private companion object {
+        val ALICE = TestIdentity(ALICE_NAME, 70).party
+    }
    @Rule
    @JvmField
    val testSerialization = SerializationEnvironmentRule()
--- a/testing/test-utils/src/main/kotlin/net/corda/testing/IntegrationTest.kt
+++ b/testing/test-utils/src/main/kotlin/net/corda/testing/IntegrationTest.kt
@ -1,5 +1,6 @@
 package net.corda.testing

+import net.corda.core.identity.CordaX500Name
 import net.corda.core.identity.Party
 import net.corda.testing.database.DbScriptRunner.runDbScript
 import org.junit.After
@ -67,9 +68,9 @@ class IntegrationTestSchemas(vararg var list : String) : ExternalResource() {
    }
 }

-fun Party.toDatabaseSchemaName() = this.name.organisation.replace(" ", "").replace("-", "_")
+fun CordaX500Name.toDatabaseSchemaName() = this.organisation.replace(" ", "").replace("-", "_")

-fun Party.toDatabaseSchemaNames(vararg postfixes: String): List<String> {
+fun CordaX500Name.toDatabaseSchemaNames(vararg postfixes: String): List<String> {
    val nodeName = this.toDatabaseSchemaName()
    return postfixes.map { "$nodeName$it" }
-}
+}
--- a/verifier/src/integration-test/kotlin/net/corda/verifier/VerifierTests.kt
+++ b/verifier/src/integration-test/kotlin/net/corda/verifier/VerifierTests.kt
@ -25,7 +25,7 @@ import kotlin.test.assertTrue
 class VerifierTests  : IntegrationTest() {
    companion object {
        @ClassRule @JvmField
-        val databaseSchemas = IntegrationTestSchemas(ALICE.toDatabaseSchemaName(), DUMMY_NOTARY.toDatabaseSchemaName())
+        val databaseSchemas = IntegrationTestSchemas(ALICE_NAME.toDatabaseSchemaName(), DUMMY_NOTARY_NAME.toDatabaseSchemaName())
    }
    @Rule
    @JvmField
--- a/verify-enclave/src/integration-test/kotlin/com/r3/enclaves/verify/NativeSgxApiTest.kt
+++ b/verify-enclave/src/integration-test/kotlin/com/r3/enclaves/verify/NativeSgxApiTest.kt
@ -1,31 +1,51 @@
 package com.r3.enclaves.verify

+import com.nhaarman.mockito_kotlin.doReturn
+import com.nhaarman.mockito_kotlin.whenever
 import com.r3.enclaves.txverify.MockContractAttachment
 import com.r3.enclaves.txverify.NativeSgxApi
 import com.r3.enclaves.txverify.TransactionVerificationRequest
+import net.corda.core.crypto.entropyToKeyPair
 import net.corda.core.identity.AnonymousParty
+import net.corda.core.identity.CordaX500Name
+import net.corda.core.identity.Party
 import net.corda.core.serialization.serialize
 import net.corda.finance.POUNDS
 import net.corda.finance.`issued by`
 import net.corda.finance.contracts.asset.Cash
-import net.corda.finance.contracts.asset.DUMMY_CASH_ISSUER
-import net.corda.testing.MEGA_CORP_PUBKEY
-import net.corda.testing.MINI_CORP_PUBKEY
-import net.corda.testing.ledger
+import net.corda.node.services.api.IdentityServiceInternal
+import net.corda.testing.DUMMY_NOTARY_NAME
+import net.corda.testing.TestIdentity
+import net.corda.testing.getTestPartyAndCertificate
+import net.corda.testing.node.MockServices
+import net.corda.testing.node.ledger
+import net.corda.testing.rigorousMock
 import org.junit.Ignore
 import org.junit.Test
+import java.math.BigInteger
 import kotlin.test.assertNull

 class NativeSgxApiTest {
-
    companion object {
        val enclavePath = "../sgx-jvm/jvm-enclave/enclave/build/cordaenclave.signed.so"
+        val DUMMY_NOTARY = TestIdentity(DUMMY_NOTARY_NAME, 20).party
+        val DUMMY_CASH_ISSUER_KEY = entropyToKeyPair(BigInteger.valueOf(10))
+        val DUMMY_CASH_ISSUER_IDENTITY = getTestPartyAndCertificate(Party(CordaX500Name("Snake Oil Issuer", "London", "GB"), DUMMY_CASH_ISSUER_KEY.public))
+        val DUMMY_CASH_ISSUER = DUMMY_CASH_ISSUER_IDENTITY.party.ref(1)
+        val megaCorp = TestIdentity(CordaX500Name("MegaCorp", "London", "GB"))
+        val MEGA_CORP get() = megaCorp.party
+        val MEGA_CORP_PUBKEY get() = megaCorp.pubkey
+        val MINI_CORP_PUBKEY = TestIdentity(CordaX500Name("MiniCorp", "London", "GB")).pubkey
    }

+    private val ledgerServices = MockServices(rigorousMock<IdentityServiceInternal>().also {
+        doReturn(NativeSgxApiTest.MEGA_CORP).whenever(it).partyFromKey(NativeSgxApiTest.MEGA_CORP_PUBKEY)
+    }, NativeSgxApiTest.MEGA_CORP.name)
+
    @Ignore("The SGX code is not part of the standard build yet")
    @Test
    fun `verification of valid transaction works`() {
-        ledger {
+        ledgerServices.ledger(DUMMY_NOTARY) {
            // Issue a couple of cash states and spend them.
            val wtx1 = transaction {
                attachments(Cash.PROGRAM_ID)
--- a/verify-enclave/src/test/kotlin/com/r3/enclaves/txverify/EnclaveletTest.kt
+++ b/verify-enclave/src/test/kotlin/com/r3/enclaves/txverify/EnclaveletTest.kt
@ -13,6 +13,7 @@ import net.corda.finance.contracts.asset.Cash
 import net.corda.node.services.api.IdentityServiceInternal
 import net.corda.testing.*
 import net.corda.testing.node.MockServices
+import net.corda.testing.node.ledger
 import org.junit.Ignore
 import org.junit.Rule
 import org.junit.Test
@ -24,9 +25,14 @@ import kotlin.test.assertTrue

 class EnclaveletTest {
    private companion object {
+        val DUMMY_NOTARY = TestIdentity(DUMMY_NOTARY_NAME, 20).party
        val DUMMY_CASH_ISSUER_KEY = entropyToKeyPair(BigInteger.valueOf(10))
        val DUMMY_CASH_ISSUER_IDENTITY = getTestPartyAndCertificate(Party(CordaX500Name("Snake Oil Issuer", "London", "GB"), DUMMY_CASH_ISSUER_KEY.public))
        val DUMMY_CASH_ISSUER = DUMMY_CASH_ISSUER_IDENTITY.party.ref(1)
+        val megaCorp = TestIdentity(CordaX500Name("MegaCorp", "London", "GB"))
+        val MEGA_CORP get() = megaCorp.party
+        val MEGA_CORP_PUBKEY get() = megaCorp.pubkey
+        val MINI_CORP_PUBKEY = TestIdentity(CordaX500Name("MiniCorp", "London", "GB")).pubkey
    }
    @Rule
    @JvmField