Merge remote-tracking branch 'open-hc02/master' into colljos-os-hc02-merge-121217

client/jackson/src/test/kotlin/net/corda/client/jackson/JacksonSupportTest.kt

@@ -6,6 +6,7 @@ import com.nhaarman.mockito_kotlin.whenever
 import net.corda.core.contracts.Amount
 import net.corda.core.cordapp.CordappProvider
 import net.corda.core.crypto.*
+import net.corda.core.identity.CordaX500Name
 import net.corda.core.node.ServiceHub
 import net.corda.core.transactions.SignedTransaction
 import net.corda.finance.USD
@@ -20,9 +21,12 @@ import java.util.*
 import kotlin.test.assertEquals
 
 class JacksonSupportTest {
-    companion object {
+    private companion object {
-        private val SEED = BigInteger.valueOf(20170922L)
+        val SEED = BigInteger.valueOf(20170922L)!!
         val mapper = JacksonSupport.createNonRpcMapper()
+        val ALICE_PUBKEY = TestIdentity(ALICE_NAME, 70).pubkey
+        val DUMMY_NOTARY = TestIdentity(DUMMY_NOTARY_NAME, 20).party
+        val MINI_CORP = TestIdentity(CordaX500Name("MiniCorp", "London", "GB")).party
     }
 
     @Rule

client/rpc/src/integration-test/java/net/corda/client/rpc/CordaRPCJavaClientTest.java

@@ -14,7 +14,7 @@ import net.corda.nodeapi.internal.config.User;
 import net.corda.testing.CoreTestUtils;
 import net.corda.testing.IntegrationTestKt;
 import net.corda.testing.IntegrationTestSchemas;
-import net.corda.testing.internal.NodeBasedTest;
+import net.corda.testing.node.internal.NodeBasedTest;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.ClassRule;
@@ -31,7 +31,7 @@ import static net.corda.finance.Currencies.DOLLARS;
 import static net.corda.finance.contracts.GetBalances.getCashBalance;
 import static net.corda.node.services.Permissions.invokeRpc;
 import static net.corda.node.services.Permissions.startFlow;
-import static net.corda.testing.TestConstants.getALICE;
+import static net.corda.testing.TestConstants.getALICE_NAME;
 import static net.corda.testing.TestConstants.getDUMMY_NOTARY;
 
 public class CordaRPCJavaClientTest extends NodeBasedTest {
@@ -65,7 +65,7 @@ public class CordaRPCJavaClientTest extends NodeBasedTest {
     @Before
     public void setUp() throws Exception {
         super.setUp();
-        node = startNode(getALICE().getName(), 1, singletonList(rpcUser));
+        node = startNode(getALICE_NAME(), 1, singletonList(rpcUser));
         client = new CordaRPCClient(requireNonNull(node.getInternals().getConfiguration().getRpcAddress()));
     }
 

client/rpc/src/integration-test/kotlin/net/corda/client/rpc/BlacklistKotlinClosureTest.kt

@@ -8,6 +8,7 @@ import net.corda.core.messaging.startFlow
 import net.corda.core.serialization.CordaSerializable
 import net.corda.core.utilities.getOrThrow
 import net.corda.testing.*
+import net.corda.testing.ALICE_NAME
 import net.corda.testing.driver.driver
 import org.assertj.core.api.Assertions.assertThatExceptionOfType
 import org.junit.ClassRule
@@ -33,7 +34,7 @@ class BlacklistKotlinClosureTest : IntegrationTest() {
     @Test
     fun `closure sent via RPC`() {
         driver(startNodesInProcess = true) {
-            val rpc = startNode(providedName = ALICE.name).getOrThrow().rpc
+            val rpc = startNode(providedName = ALICE_NAME).getOrThrow().rpc
             val packet = Packet { EVIL }
             assertThatExceptionOfType(KryoException::class.java)
                     .isThrownBy { rpc.startFlow(::FlowC, packet) }

client/rpc/src/integration-test/kotlin/net/corda/client/rpc/CordaRPCClientTest.kt

@@ -22,7 +22,7 @@ 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.*
-import net.corda.testing.internal.NodeBasedTest
+import net.corda.testing.node.internal.NodeBasedTest
 import org.apache.activemq.artemis.api.core.ActiveMQSecurityException
 import org.assertj.core.api.Assertions.assertThat
 import org.assertj.core.api.Assertions.assertThatExceptionOfType
@@ -141,7 +141,7 @@ class CordaRPCClientTest : NodeBasedTest(listOf("net.corda.finance.contracts", C
     @Test
     fun `flow initiator via RPC`() {
         val externalTrace = Trace.newInstance()
-        val impersonatedActor = Actor(Actor.Id("Mark Dadada"), AuthServiceId("Test"), owningLegalIdentity = BOB.name)
+        val impersonatedActor = Actor(Actor.Id("Mark Dadada"), AuthServiceId("Test"), owningLegalIdentity = BOB_NAME)
         login(rpcUser.username, rpcUser.password, externalTrace, impersonatedActor)
         val proxy = connection!!.proxy
 

client/rpc/src/integration-test/kotlin/net/corda/client/rpc/RPCStabilityTests.kt

@@ -14,7 +14,9 @@ import net.corda.node.services.messaging.RPCServerConfiguration
 import net.corda.nodeapi.RPCApi
 import net.corda.testing.*
 import net.corda.testing.internal.poll
+import net.corda.testing.SerializationEnvironmentRule
 import net.corda.testing.internal.*
+import net.corda.testing.node.internal.*
 import org.apache.activemq.artemis.api.core.SimpleString
 import org.junit.After
 import org.junit.Assert.assertEquals

client/rpc/src/test/kotlin/net/corda/client/rpc/AbstractRPCTest.kt

@@ -7,10 +7,10 @@ import net.corda.core.messaging.RPCOps
 import net.corda.node.services.messaging.RPCServerConfiguration
 import net.corda.nodeapi.internal.config.User
 import net.corda.testing.SerializationEnvironmentRule
-import net.corda.testing.internal.RPCDriverDSL
+import net.corda.testing.node.internal.RPCDriverDSL
-import net.corda.testing.internal.rpcTestUser
+import net.corda.testing.node.internal.rpcTestUser
-import net.corda.testing.internal.startInVmRpcClient
+import net.corda.testing.node.internal.startInVmRpcClient
-import net.corda.testing.internal.startRpcClient
+import net.corda.testing.node.internal.startRpcClient
 import org.apache.activemq.artemis.api.core.client.ClientSession
 import org.junit.Rule
 import org.junit.runners.Parameterized

client/rpc/src/test/kotlin/net/corda/client/rpc/ClientRPCInfrastructureTests.kt

@@ -7,9 +7,9 @@ import net.corda.core.internal.concurrent.thenMatch
 import net.corda.core.messaging.RPCOps
 import net.corda.core.utilities.getOrThrow
 import net.corda.node.services.messaging.rpcContext
-import net.corda.testing.internal.RPCDriverDSL
+import net.corda.testing.node.internal.RPCDriverDSL
-import net.corda.testing.internal.rpcDriver
+import net.corda.testing.node.internal.rpcDriver
-import net.corda.testing.internal.rpcTestUser
+import net.corda.testing.node.internal.rpcTestUser
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.Test
 import org.junit.runner.RunWith

client/rpc/src/test/kotlin/net/corda/client/rpc/RPCConcurrencyTests.kt

@@ -9,8 +9,8 @@ import net.corda.core.serialization.CordaSerializable
 import net.corda.core.utilities.getOrThrow
 import net.corda.core.utilities.millis
 import net.corda.node.services.messaging.RPCServerConfiguration
-import net.corda.testing.internal.RPCDriverDSL
+import net.corda.testing.node.internal.RPCDriverDSL
-import net.corda.testing.internal.rpcDriver
+import net.corda.testing.node.internal.rpcDriver
 import net.corda.testing.internal.testThreadFactory
 import org.apache.activemq.artemis.utils.collections.ConcurrentHashSet
 import org.junit.After

client/rpc/src/test/kotlin/net/corda/client/rpc/RPCFailureTests.kt

@@ -6,8 +6,8 @@ import net.corda.core.internal.concurrent.openFuture
 import net.corda.core.messaging.*
 import net.corda.core.utilities.getOrThrow
 import net.corda.testing.SerializationEnvironmentRule
-import net.corda.testing.internal.rpcDriver
+import net.corda.testing.node.internal.rpcDriver
-import net.corda.testing.internal.startRpcClient
+import net.corda.testing.node.internal.startRpcClient
 import org.assertj.core.api.Assertions.assertThatThrownBy
 import org.junit.Rule
 import org.junit.Test

client/rpc/src/test/kotlin/net/corda/client/rpc/RPCPerformanceTests.kt

@@ -6,12 +6,12 @@ import net.corda.core.messaging.RPCOps
 import net.corda.core.utilities.minutes
 import net.corda.core.utilities.seconds
 import net.corda.node.services.messaging.RPCServerConfiguration
-import net.corda.testing.internal.RPCDriverDSL
+import net.corda.testing.node.internal.RPCDriverDSL
 import net.corda.testing.internal.performance.div
-import net.corda.testing.internal.performance.startPublishingFixedRateInjector
+import net.corda.testing.node.internal.performance.startPublishingFixedRateInjector
-import net.corda.testing.internal.performance.startReporter
+import net.corda.testing.node.internal.performance.startReporter
-import net.corda.testing.internal.performance.startTightLoopInjector
+import net.corda.testing.node.internal.performance.startTightLoopInjector
-import net.corda.testing.internal.rpcDriver
+import net.corda.testing.node.internal.rpcDriver
 import net.corda.testing.measure
 import org.junit.Ignore
 import org.junit.Test

client/rpc/src/test/kotlin/net/corda/client/rpc/RPCPermissionsTests.kt

@@ -3,8 +3,8 @@ package net.corda.client.rpc
 import net.corda.core.messaging.RPCOps
 import net.corda.node.services.messaging.rpcContext
 import net.corda.nodeapi.internal.config.User
-import net.corda.testing.internal.RPCDriverDSL
+import net.corda.testing.node.internal.RPCDriverDSL
-import net.corda.testing.internal.rpcDriver
+import net.corda.testing.node.internal.rpcDriver
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.junit.runners.Parameterized

confidential-identities/src/test/kotlin/net/corda/confidential/IdentitySyncFlowTests.kt

@@ -16,6 +16,7 @@ import net.corda.finance.flows.CashIssueAndPaymentFlow
 import net.corda.finance.flows.CashPaymentFlow
 import net.corda.testing.*
 import net.corda.testing.node.MockNetwork
+import net.corda.testing.node.startFlow
 import org.junit.After
 import org.junit.Before
 import org.junit.Test

confidential-identities/src/test/kotlin/net/corda/confidential/SwapIdentitiesFlowTests.kt

@@ -1,14 +1,11 @@
 package net.corda.confidential
 
-import net.corda.core.identity.AbstractParty
+import net.corda.core.identity.*
-import net.corda.core.identity.AnonymousParty
-import net.corda.core.identity.Party
-import net.corda.core.identity.PartyAndCertificate
 import net.corda.core.utilities.getOrThrow
 import net.corda.testing.*
 import net.corda.testing.node.MockNetwork
 import org.junit.Before
-import net.corda.testing.node.MockNodeParameters
+import net.corda.testing.node.startFlow
 import org.junit.Test
 import kotlin.test.*
 
@@ -24,8 +21,8 @@ class SwapIdentitiesFlowTests {
     @Test
     fun `issue key`() {
         // Set up values we'll need
-        val aliceNode = mockNet.createPartyNode(ALICE.name)
+        val aliceNode = mockNet.createPartyNode(ALICE_NAME)
-        val bobNode = mockNet.createPartyNode(BOB.name)
+        val bobNode = mockNet.createPartyNode(BOB_NAME)
         val alice = aliceNode.info.singleIdentity()
         val bob = bobNode.services.myInfo.singleIdentity()
 
@@ -60,9 +57,9 @@ class SwapIdentitiesFlowTests {
     @Test
     fun `verifies identity name`() {
         // Set up values we'll need
-        val aliceNode = mockNet.createPartyNode(ALICE.name)
+        val aliceNode = mockNet.createPartyNode(ALICE_NAME)
-        val bobNode = mockNet.createPartyNode(BOB.name)
+        val bobNode = mockNet.createPartyNode(BOB_NAME)
-        val charlieNode = mockNet.createPartyNode(CHARLIE.name)
+        val charlieNode = mockNet.createPartyNode(CHARLIE_NAME)
         val bob: Party = bobNode.services.myInfo.singleIdentity()
         val notBob = charlieNode.database.transaction {
             charlieNode.services.keyManagementService.freshKeyAndCert(charlieNode.services.myInfo.chooseIdentityAndCert(), false)
@@ -83,8 +80,8 @@ class SwapIdentitiesFlowTests {
     fun `verifies signature`() {
         // Set up values we'll need
         val notaryNode = mockNet.defaultNotaryNode
-        val aliceNode = mockNet.createPartyNode(ALICE.name)
+        val aliceNode = mockNet.createPartyNode(ALICE_NAME)
-        val bobNode = mockNet.createPartyNode(BOB.name)
+        val bobNode = mockNet.createPartyNode(BOB_NAME)
         val alice: PartyAndCertificate = aliceNode.info.singleIdentityAndCert()
         val bob: PartyAndCertificate = bobNode.info.singleIdentityAndCert()
         val notary: PartyAndCertificate = mockNet.defaultNotaryIdentityAndCert

core/src/main/kotlin/net/corda/core/identity/CordaX500Name.kt

@@ -45,7 +45,7 @@ data class CordaX500Name(val commonName: String?,
 
     init {
         // Legal name checks.
-        LegalNameValidator.validateOrganization(organisation)
+        LegalNameValidator.validateOrganization(organisation, LegalNameValidator.Validation.MINIMAL)
 
         // Attribute data width checks.
         require(country.length == LENGTH_COUNTRY) { "Invalid country '$country' Country code must be $LENGTH_COUNTRY letters ISO code " }

core/src/main/kotlin/net/corda/core/internal/LegalNameValidator.kt

@@ -1,18 +1,27 @@
 package net.corda.core.internal
 
-import java.lang.Character.UnicodeScript.*
+import net.corda.core.internal.LegalNameValidator.normalize
 import java.text.Normalizer
-import java.util.regex.Pattern
 import javax.security.auth.x500.X500Principal
 
 object LegalNameValidator {
+    enum class Validation {
+        MINIMAL,
+        FULL
+    }
+
     @Deprecated("Use validateOrganization instead", replaceWith = ReplaceWith("validateOrganization(normalizedLegalName)"))
-    fun validateLegalName(normalizedLegalName: String) = validateOrganization(normalizedLegalName)
+    fun validateLegalName(normalizedLegalName: String) = validateOrganization(normalizedLegalName, Validation.FULL)
 
     /**
      * The validation function validates a string for use as part of a legal name. It applies the following rules:
      *
-     * - No blacklisted words like "node", "server".
+     * - Does not contain the null character
+     * - Must be normalized (as per the [normalize] function).
+     * - Length must be 255 characters or shorter.
+     *
+     * Full validation (typically this is only done for names the Doorman approves) adds:
+     *
      * - Restrict names to Latin scripts for now to avoid right-to-left issues, debugging issues when we can't pronounce
      *   names over the phone, and character confusability attacks.
      * - No commas or equals signs.
@@ -20,25 +29,37 @@ object LegalNameValidator {
      *
      * @throws IllegalArgumentException if the name does not meet the required rules. The message indicates why not.
      */
-    fun validateNameAttribute(normalizedNameAttribute: String) {
+    fun validateNameAttribute(normalizedNameAttribute: String, validation: Validation) {
-        Rule.baseNameRules.forEach { it.validate(normalizedNameAttribute) }
+        when (validation) {
+            Validation.MINIMAL -> Rule.attributeRules.forEach { it.validate(normalizedNameAttribute) }
+            Validation.FULL -> Rule.attributeFullRules.forEach { it.validate(normalizedNameAttribute) }
+        }
     }
 
     /**
      * The validation function validates a string for use as the organization attribute of a name, which includes additional
-     * constraints over basic name attribute checks. It applies the following rules:
+     * constraints over basic name attribute checks. It applies the following additional rules:
      *
+     * - Must be normalized (as per the [normalize] function).
+     * - Length must be 255 characters or shorter.
      * - No blacklisted words like "node", "server".
+     * - Must consist of at least three letters.
+     *
+     * Full validation (typically this is only done for names the Doorman approves) adds:
+     *
      * - Restrict names to Latin scripts for now to avoid right-to-left issues, debugging issues when we can't pronounce
      *   names over the phone, and character confusability attacks.
-     * - Must consist of at least three letters and should start with a capital letter.
+     * - Must start with a capital letter.
      * - No commas or equals signs.
      * - No dollars or quote marks, we might need to relax the quote mark constraint in future to handle Irish company names.
      *
      * @throws IllegalArgumentException if the name does not meet the required rules. The message indicates why not.
      */
-    fun validateOrganization(normalizedOrganization: String) {
+    fun validateOrganization(normalizedOrganization: String, validation: Validation) {
-        Rule.legalNameRules.forEach { it.validate(normalizedOrganization) }
+        when (validation) {
+            Validation.MINIMAL -> Rule.legalNameRules.forEach { it.validate(normalizedOrganization) }
+            Validation.FULL -> Rule.legalNameFullRules.forEach { it.validate(normalizedOrganization) }
+        }
     }
 
     @Deprecated("Use normalize instead", replaceWith = ReplaceWith("normalize(legalName)"))
@@ -57,18 +78,27 @@ object LegalNameValidator {
 
     sealed class Rule<in T> {
         companion object {
-            val baseNameRules: List<Rule<String>> = listOf(
+            val attributeRules: List<Rule<String>> = listOf(
                     UnicodeNormalizationRule(),
-                    CharacterRule(',', '=', '$', '"', '\'', '\\'),
-                    WordRule("node", "server"),
                     LengthRule(maxLength = 255),
+                    MustHaveAtLeastTwoLettersRule(),
+                    CharacterRule('\u0000') // Ban null
+            )
+            val attributeFullRules: List<Rule<String>> = attributeRules + listOf(
+                    CharacterRule(',', '=', '$', '"', '\'', '\\'),
                     // TODO: Implement confusable character detection if we add more scripts.
-                    UnicodeRangeRule(LATIN, COMMON, INHERITED),
+                    UnicodeRangeRule(Character.UnicodeBlock.BASIC_LATIN),
+                    CapitalLetterRule()
+            )
+            val legalNameRules: List<Rule<String>> = attributeRules + listOf(
+                    WordRule("node", "server"),
                     X500NameRule()
             )
-            val legalNameRules: List<Rule<String>> = baseNameRules + listOf(
+            val legalNameFullRules: List<Rule<String>> = legalNameRules + listOf(
-                    CapitalLetterRule(),
+                    CharacterRule(',', '=', '$', '"', '\'', '\\'),
-                    MustHaveAtLeastTwoLettersRule()
+                    // TODO: Implement confusable character detection if we add more scripts.
+                    UnicodeRangeRule(Character.UnicodeBlock.BASIC_LATIN),
+                    CapitalLetterRule()
             )
         }
 
@@ -80,18 +110,13 @@ object LegalNameValidator {
             }
         }
 
-        private class UnicodeRangeRule(vararg supportScripts: Character.UnicodeScript) : Rule<String>() {
+        private class UnicodeRangeRule(vararg supportScripts: Character.UnicodeBlock) : Rule<String>() {
-            private val pattern = supportScripts.map { "\\p{Is$it}" }.joinToString(separator = "", prefix = "[", postfix = "]*").let { Pattern.compile(it) }
+            val supportScriptsSet = supportScripts.toSet()
 
             override fun validate(legalName: String) {
-                require(pattern.matcher(legalName).matches()) {
+                val illegalChars = legalName.toCharArray().filter { Character.UnicodeBlock.of(it) !in supportScriptsSet }.size
-                    val illegalChars = legalName.replace(pattern.toRegex(), "").toSet()
+                // We don't expose the characters or the legal name, for security reasons
-                    if (illegalChars.size > 1) {
+                require (illegalChars == 0) { "$illegalChars forbidden characters in legal name." }
-                        "Forbidden characters $illegalChars in \"$legalName\"."
-                    } else {
-                        "Forbidden character $illegalChars in \"$legalName\"."
-                    }
-                }
             }
         }
 

core/src/test/java/net/corda/core/flows/FlowsInJavaTest.java

@@ -17,6 +17,7 @@ import static net.corda.testing.CoreTestUtils.singleIdentity;
 import static net.corda.testing.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();
@@ -26,8 +27,8 @@ public class FlowsInJavaTest {
 
     @Before
     public void setUp() throws Exception {
-        aliceNode = mockNet.createPartyNode(TestConstants.getALICE().getName());
+        aliceNode = mockNet.createPartyNode(TestConstants.getALICE_NAME());
-        bobNode = mockNet.createPartyNode(TestConstants.getBOB().getName());
+        bobNode = mockNet.createPartyNode(TestConstants.getBOB_NAME());
         bob = singleIdentity(bobNode.getInfo());
     }
 

core/src/test/kotlin/net/corda/core/contracts/DummyContractV2Tests.kt

@@ -18,6 +18,11 @@ import kotlin.test.assertTrue
  * Tests for the version 2 dummy contract, to cover ensuring upgrade transactions are built correctly.
  */
 class DummyContractV2Tests {
+    private companion object {
+        val ALICE = TestIdentity(ALICE_NAME, 70).party
+        val DUMMY_NOTARY = TestIdentity(DUMMY_NOTARY_NAME, 20).party
+    }
+
     @Rule
     @JvmField
     val testSerialization = SerializationEnvironmentRule()

core/src/test/kotlin/net/corda/core/crypto/PartialMerkleTreeTest.kt

@@ -4,6 +4,7 @@ import com.nhaarman.mockito_kotlin.doReturn
 import com.nhaarman.mockito_kotlin.whenever
 import net.corda.core.contracts.*
 import net.corda.core.crypto.SecureHash.Companion.zeroHash
+import net.corda.core.identity.CordaX500Name
 import net.corda.core.identity.Party
 import net.corda.core.serialization.deserialize
 import net.corda.core.serialization.serialize
@@ -14,6 +15,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.Before
 import org.junit.Rule
 import org.junit.Test
@@ -24,6 +26,16 @@ import kotlin.streams.toList
 import kotlin.test.*
 
 class PartialMerkleTreeTest {
+    private companion object {
+        val DUMMY_NOTARY = TestIdentity(DUMMY_NOTARY_NAME, 20).party
+        val megaCorp = TestIdentity(CordaX500Name("MegaCorp", "London", "GB"))
+        val miniCorp = TestIdentity(CordaX500Name("MiniCorp", "London", "GB"))
+        val MEGA_CORP get() = megaCorp.party
+        val MEGA_CORP_PUBKEY get() = megaCorp.pubkey
+        val MINI_CORP get() = miniCorp.party
+        val MINI_CORP_PUBKEY get() = miniCorp.pubkey
+    }
+
     @Rule
     @JvmField
     val testSerialization = SerializationEnvironmentRule()

core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt

@@ -13,6 +13,7 @@ import net.corda.node.services.persistence.NodeAttachmentService
 import net.corda.testing.*
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.node.MockNodeParameters
+import net.corda.testing.node.startFlow
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
@@ -48,9 +49,8 @@ class AttachmentTests {
 
     @Test
     fun `download and store`() {
-        val aliceNode = mockNet.createPartyNode(ALICE.name)
+        val aliceNode = mockNet.createPartyNode(ALICE_NAME)
-        val bobNode = mockNet.createPartyNode(BOB.name)
+        val bobNode = mockNet.createPartyNode(BOB_NAME)
-
         val alice = aliceNode.info.singleIdentity()
         aliceNode.registerInitiatedFlow(FetchAttachmentsResponse::class.java)
         bobNode.registerInitiatedFlow(FetchAttachmentsResponse::class.java)
@@ -81,8 +81,8 @@ class AttachmentTests {
 
     @Test
     fun `missing`() {
-        val aliceNode = mockNet.createPartyNode(ALICE.name)
+        val aliceNode = mockNet.createPartyNode(ALICE_NAME)
-        val bobNode = mockNet.createPartyNode(BOB.name)
+        val bobNode = mockNet.createPartyNode(BOB_NAME)
         aliceNode.registerInitiatedFlow(FetchAttachmentsResponse::class.java)
         bobNode.registerInitiatedFlow(FetchAttachmentsResponse::class.java)
         // Get node one to fetch a non-existent attachment.
@@ -97,13 +97,13 @@ class AttachmentTests {
     @Test
     fun maliciousResponse() {
         // Make a node that doesn't do sanity checking at load time.
-        val aliceNode = mockNet.createNode(MockNodeParameters(legalName = ALICE.name), nodeFactory = { args ->
+        val aliceNode = mockNet.createNode(MockNodeParameters(legalName = ALICE_NAME), nodeFactory = { args ->
             object : MockNetwork.MockNode(args) {
                 override fun start() = super.start().apply { attachments.checkAttachmentsOnLoad = false }
             }
         })
-        val bobNode = mockNet.createNode(MockNodeParameters(legalName = BOB.name))
+        val bobNode = mockNet.createNode(MockNodeParameters(legalName = BOB_NAME))
-        val alice = aliceNode.services.myInfo.identityFromX500Name(ALICE_NAME)
+        val alice = aliceNode.info.singleIdentity()
         aliceNode.registerInitiatedFlow(FetchAttachmentsResponse::class.java)
         bobNode.registerInitiatedFlow(FetchAttachmentsResponse::class.java)
         val attachment = fakeAttachment()

core/src/test/kotlin/net/corda/core/flows/CollectSignaturesFlowTests.kt

@@ -4,6 +4,7 @@ import co.paralleluniverse.fibers.Suspendable
 import net.corda.core.contracts.Command
 import net.corda.core.contracts.StateAndContract
 import net.corda.core.contracts.requireThat
+import net.corda.core.identity.CordaX500Name
 import net.corda.core.identity.Party
 import net.corda.core.identity.excludeHostNode
 import net.corda.core.identity.groupAbstractPartyByWellKnownParty
@@ -15,6 +16,7 @@ import net.corda.testing.*
 import net.corda.testing.contracts.DummyContract
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.node.MockServices
+import net.corda.testing.node.startFlow
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
@@ -22,6 +24,10 @@ import kotlin.reflect.KClass
 import kotlin.test.assertFailsWith
 
 class CollectSignaturesFlowTests {
+    companion object {
+        private val miniCorp = TestIdentity(CordaX500Name("MiniCorp", "London", "GB"))
+    }
+
     private lateinit var mockNet: MockNetwork
     private lateinit var aliceNode: StartedNode<MockNetwork.MockNode>
     private lateinit var bobNode: StartedNode<MockNetwork.MockNode>
@@ -34,9 +40,9 @@ class CollectSignaturesFlowTests {
     @Before
     fun setup() {
         mockNet = MockNetwork(cordappPackages = listOf("net.corda.testing.contracts"))
-        aliceNode = mockNet.createPartyNode(ALICE.name)
+        aliceNode = mockNet.createPartyNode(ALICE_NAME)
-        bobNode = mockNet.createPartyNode(BOB.name)
+        bobNode = mockNet.createPartyNode(BOB_NAME)
-        charlieNode = mockNet.createPartyNode(CHARLIE.name)
+        charlieNode = mockNet.createPartyNode(CHARLIE_NAME)
         alice = aliceNode.info.singleIdentity()
         bob = bobNode.info.singleIdentity()
         charlie = charlieNode.info.singleIdentity()
@@ -129,7 +135,7 @@ class CollectSignaturesFlowTests {
     @Test
     fun `fails when not signed by initiator`() {
         val onePartyDummyContract = DummyContract.generateInitial(1337, notary, alice.ref(1))
-        val miniCorpServices = MockServices(listOf("net.corda.testing.contracts"), rigorousMock(), MINI_CORP.name, MINI_CORP_KEY)
+        val miniCorpServices = MockServices(listOf("net.corda.testing.contracts"), rigorousMock(), miniCorp)
         val ptx = miniCorpServices.signInitialTransaction(onePartyDummyContract)
         val flow = aliceNode.services.startFlow(CollectSignaturesFlow(ptx, emptySet()))
         mockNet.runNetwork()

core/src/test/kotlin/net/corda/core/flows/ContractUpgradeFlowTest.kt

@@ -24,13 +24,13 @@ import net.corda.testing.ALICE_NAME
 import net.corda.testing.BOB_NAME
 import net.corda.testing.contracts.DummyContract
 import net.corda.testing.contracts.DummyContractV2
-import net.corda.testing.internal.RPCDriverDSL
+import net.corda.testing.node.internal.RPCDriverDSL
-import net.corda.testing.internal.rpcDriver
+import net.corda.testing.node.internal.rpcDriver
-import net.corda.testing.internal.rpcTestUser
+import net.corda.testing.node.internal.rpcTestUser
-import net.corda.testing.internal.startRpcClient
+import net.corda.testing.node.internal.startRpcClient
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.singleIdentity
-import net.corda.testing.startFlow
+import net.corda.testing.node.startFlow
 import org.junit.After
 import org.junit.Before
 import org.junit.Test

core/src/test/kotlin/net/corda/core/flows/FinalityFlowTests.kt

@@ -9,6 +9,7 @@ import net.corda.finance.issuedBy
 import net.corda.node.services.api.StartedNodeServices
 import net.corda.testing.*
 import net.corda.testing.node.MockNetwork
+import net.corda.testing.node.startFlow
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
@@ -16,6 +17,10 @@ import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
 
 class FinalityFlowTests {
+    companion object {
+        private val CHARLIE = TestIdentity(CHARLIE_NAME, 90).party
+    }
+
     private lateinit var mockNet: MockNetwork
     private lateinit var aliceServices: StartedNodeServices
     private lateinit var bobServices: StartedNodeServices

core/src/test/kotlin/net/corda/core/flows/ReceiveAllFlowTests.kt

@@ -7,7 +7,7 @@ import net.corda.core.utilities.getOrThrow
 import net.corda.core.utilities.unwrap
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.singleIdentity
-import net.corda.testing.startFlow
+import net.corda.testing.node.startFlow
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.After
 import org.junit.Test

core/src/test/kotlin/net/corda/core/identity/PartyTest.kt

@@ -1,7 +1,7 @@
 package net.corda.core.identity
 
 import net.corda.core.crypto.entropyToKeyPair
-import net.corda.testing.ALICE
+import net.corda.testing.ALICE_NAME
 import org.junit.Test
 import java.math.BigInteger
 import kotlin.test.assertEquals
@@ -13,7 +13,7 @@ class PartyTest {
         val key = entropyToKeyPair(BigInteger.valueOf(20170207L)).public
         val differentKey = entropyToKeyPair(BigInteger.valueOf(7201702L)).public
         val anonymousParty = AnonymousParty(key)
-        val party = Party(ALICE.name, key)
+        val party = Party(ALICE_NAME, key)
         assertEquals<AbstractParty>(party, anonymousParty)
         assertEquals<AbstractParty>(anonymousParty, party)
         assertNotEquals<AbstractParty>(AnonymousParty(differentKey), anonymousParty)

core/src/test/kotlin/net/corda/core/internal/AbstractAttachmentTest.kt

@@ -1,7 +1,7 @@
 package net.corda.core.internal
 
-import net.corda.testing.ALICE
+import net.corda.testing.ALICE_NAME
-import net.corda.testing.BOB
+import net.corda.testing.BOB_NAME
 import org.assertj.core.api.Assertions.assertThatThrownBy
 import org.junit.After
 import org.junit.AfterClass
@@ -29,8 +29,8 @@ class AbstractAttachmentTest {
         @BeforeClass
         @JvmStatic
         fun beforeClass() {
-            execute("keytool", "-genkey", "-keystore", "_teststore", "-storepass", "storepass", "-keyalg", "RSA", "-alias", "alice", "-keypass", "alicepass", "-dname", ALICE.toString())
+            execute("keytool", "-genkey", "-keystore", "_teststore", "-storepass", "storepass", "-keyalg", "RSA", "-alias", "alice", "-keypass", "alicepass", "-dname", ALICE_NAME.toString())
-            execute("keytool", "-genkey", "-keystore", "_teststore", "-storepass", "storepass", "-keyalg", "RSA", "-alias", "bob", "-keypass", "bobpass", "-dname", BOB.toString())
+            execute("keytool", "-genkey", "-keystore", "_teststore", "-storepass", "storepass", "-keyalg", "RSA", "-alias", "bob", "-keypass", "bobpass", "-dname", BOB_NAME.toString())
             (dir / "_signable1").writeLines(listOf("signable1"))
             (dir / "_signable2").writeLines(listOf("signable2"))
             (dir / "_signable3").writeLines(listOf("signable3"))
@@ -76,10 +76,10 @@ class AbstractAttachmentTest {
     fun `one signer`() {
         execute("jar", "cvf", "attachment.jar", "_signable1", "_signable2")
         execute("jarsigner", "-keystore", "_teststore", "-storepass", "storepass", "-keypass", "alicepass", "attachment.jar", "alice")
-        assertEquals(listOf(ALICE.name), load("attachment.jar").signers.map { it.name }) // We only reused ALICE's distinguished name, so the keys will be different.
+        assertEquals(listOf(ALICE_NAME), load("attachment.jar").signers.map { it.name }) // We only reused ALICE's distinguished name, so the keys will be different.
         (dir / "my-dir").createDirectory()
         execute("jar", "uvf", "attachment.jar", "my-dir")
-        assertEquals(listOf(ALICE.name), load("attachment.jar").signers.map { it.name }) // Unsigned directory is irrelevant.
+        assertEquals(listOf(ALICE_NAME), load("attachment.jar").signers.map { it.name }) // Unsigned directory is irrelevant.
     }
 
     @Test
@@ -87,17 +87,17 @@ class AbstractAttachmentTest {
         execute("jar", "cvf", "attachment.jar", "_signable1", "_signable2")
         execute("jarsigner", "-keystore", "_teststore", "-storepass", "storepass", "-keypass", "alicepass", "attachment.jar", "alice")
         execute("jarsigner", "-keystore", "_teststore", "-storepass", "storepass", "-keypass", "bobpass", "attachment.jar", "bob")
-        assertEquals(listOf(ALICE.name, BOB.name), load("attachment.jar").signers.map { it.name })
+        assertEquals(listOf(ALICE_NAME, BOB_NAME), load("attachment.jar").signers.map { it.name })
     }
 
     @Test
     fun `a party must sign all the files in the attachment to be a signer`() {
         execute("jar", "cvf", "attachment.jar", "_signable1")
         execute("jarsigner", "-keystore", "_teststore", "-storepass", "storepass", "-keypass", "alicepass", "attachment.jar", "alice")
-        assertEquals(listOf(ALICE.name), load("attachment.jar").signers.map { it.name })
+        assertEquals(listOf(ALICE_NAME), load("attachment.jar").signers.map { it.name })
         execute("jar", "uvf", "attachment.jar", "_signable2")
         execute("jarsigner", "-keystore", "_teststore", "-storepass", "storepass", "-keypass", "bobpass", "attachment.jar", "bob")
-        assertEquals(listOf(BOB.name), load("attachment.jar").signers.map { it.name }) // ALICE hasn't signed the new file.
+        assertEquals(listOf(BOB_NAME), load("attachment.jar").signers.map { it.name }) // ALICE hasn't signed the new file.
         execute("jar", "uvf", "attachment.jar", "_signable3")
         assertEquals(emptyList(), load("attachment.jar").signers) // Neither party has signed the new file.
     }
@@ -107,7 +107,7 @@ class AbstractAttachmentTest {
         (dir / "volatile").writeLines(listOf("volatile"))
         execute("jar", "cvf", "attachment.jar", "volatile")
         execute("jarsigner", "-keystore", "_teststore", "-storepass", "storepass", "-keypass", "alicepass", "attachment.jar", "alice")
-        assertEquals(listOf(ALICE.name), load("attachment.jar").signers.map { it.name })
+        assertEquals(listOf(ALICE_NAME), load("attachment.jar").signers.map { it.name })
         (dir / "volatile").writeLines(listOf("garbage"))
         execute("jar", "uvf", "attachment.jar", "volatile", "_signable1") // ALICE's signature on volatile is now bad.
         execute("jarsigner", "-keystore", "_teststore", "-storepass", "storepass", "-keypass", "bobpass", "attachment.jar", "bob")

core/src/test/kotlin/net/corda/core/internal/LegalNameValidatorTest.kt

@@ -8,55 +8,94 @@ class LegalNameValidatorTest {
     @Test
     fun `no double spaces`() {
         assertFailsWith(IllegalArgumentException::class) {
-            LegalNameValidator.validateOrganization("Test Legal  Name")
+            LegalNameValidator.validateOrganization("Test Legal  Name", LegalNameValidator.Validation.FULL)
         }
-        LegalNameValidator.validateOrganization(LegalNameValidator.normalize("Test Legal  Name"))
+        LegalNameValidator.validateOrganization(LegalNameValidator.normalize("Test Legal  Name"), LegalNameValidator.Validation.FULL)
     }
 
     @Test
     fun `no trailing white space`() {
         assertFailsWith(IllegalArgumentException::class) {
-            LegalNameValidator.validateOrganization("Test ")
+            LegalNameValidator.validateOrganization("Test ", LegalNameValidator.Validation.FULL)
         }
     }
 
     @Test
     fun `no prefixed white space`() {
         assertFailsWith(IllegalArgumentException::class) {
-            LegalNameValidator.validateOrganization(" Test")
+            LegalNameValidator.validateOrganization(" Test", LegalNameValidator.Validation.FULL)
         }
     }
 
     @Test
     fun `blacklisted words`() {
         assertFailsWith(IllegalArgumentException::class) {
-            LegalNameValidator.validateOrganization("Test Server")
+            LegalNameValidator.validateOrganization("Test Server", LegalNameValidator.Validation.FULL)
         }
     }
 
     @Test
     fun `blacklisted characters`() {
-        LegalNameValidator.validateOrganization("Test")
+        LegalNameValidator.validateOrganization("Test", LegalNameValidator.Validation.FULL)
         assertFailsWith(IllegalArgumentException::class) {
-            LegalNameValidator.validateOrganization("\$Test")
+            LegalNameValidator.validateOrganization("\$Test", LegalNameValidator.Validation.FULL)
         }
         assertFailsWith(IllegalArgumentException::class) {
-            LegalNameValidator.validateOrganization("\"Test")
+            LegalNameValidator.validateOrganization("\"Test", LegalNameValidator.Validation.FULL)
         }
         assertFailsWith(IllegalArgumentException::class) {
-            LegalNameValidator.validateOrganization("\'Test")
+            LegalNameValidator.validateOrganization("\'Test", LegalNameValidator.Validation.FULL)
         }
         assertFailsWith(IllegalArgumentException::class) {
-            LegalNameValidator.validateOrganization("=Test")
+            LegalNameValidator.validateOrganization("=Test", LegalNameValidator.Validation.FULL)
         }
     }
 
     @Test
-    fun `unicode range`() {
+    fun `unicode range in organization`() {
-        LegalNameValidator.validateOrganization("Test A")
+        LegalNameValidator.validateOrganization("The quick brown fox jumped over the lazy dog.1234567890", LegalNameValidator.Validation.FULL)
+        assertFailsWith(IllegalArgumentException::class) {
+            // Null
+            LegalNameValidator.validateOrganization("\u0000R3 Null", LegalNameValidator.Validation.FULL)
+        }
+        assertFailsWith(IllegalArgumentException::class) {
+            // Right to left direction override
+            LegalNameValidator.validateOrganization("\u202EdtL 3R", LegalNameValidator.Validation.FULL)
+        }
         assertFailsWith(IllegalArgumentException::class) {
             // Greek letter A.
-            LegalNameValidator.validateOrganization("Test Α")
+            LegalNameValidator.validateOrganization("Test \u0391", LegalNameValidator.Validation.FULL)
+        }
+        // Latin capital letter turned m
+        assertFailsWith<IllegalArgumentException> {
+            LegalNameValidator.validateOrganization( "Test\u019CLtd", LegalNameValidator.Validation.FULL)
+        }
+        // Latin small letter turned e
+        assertFailsWith<IllegalArgumentException> {
+            LegalNameValidator.validateOrganization("Test\u01ddLtd", LegalNameValidator.Validation.FULL)
+        }
+    }
+
+    @Test
+    fun `unicode range in general attributes`() {
+        LegalNameValidator.validateNameAttribute("The quick brown fox jumped over the lazy dog.1234567890", LegalNameValidator.Validation.FULL)
+        assertFailsWith(IllegalArgumentException::class) {
+            // Right to left direction override
+            LegalNameValidator.validateNameAttribute("\u202EdtL 3R", LegalNameValidator.Validation.FULL)
+        }
+        // Right to left direction override is okay with minimal validation though
+        LegalNameValidator.validateNameAttribute("\u202EdtL 3R", LegalNameValidator.Validation.MINIMAL)
+        assertFailsWith(IllegalArgumentException::class) {
+            // Greek letter A.
+            LegalNameValidator.validateNameAttribute("Test \u0391", LegalNameValidator.Validation.FULL)
+        }
+        // Latin capital letter turned m
+        assertFailsWith<IllegalArgumentException> {
+            LegalNameValidator.validateNameAttribute( "Test\u019CLtd", LegalNameValidator.Validation.FULL)
+        }
+        // Latin small letter turned e
+        assertFailsWith<IllegalArgumentException> {
+            LegalNameValidator.validateNameAttribute("Test\u01ddLtd", LegalNameValidator.Validation.FULL)
         }
     }
 
@@ -66,21 +105,21 @@ class LegalNameValidatorTest {
         while (longLegalName.length < 255) {
             longLegalName.append("A")
         }
-        LegalNameValidator.validateOrganization(longLegalName.toString())
+        LegalNameValidator.validateOrganization(longLegalName.toString(), LegalNameValidator.Validation.FULL)
 
         assertFailsWith(IllegalArgumentException::class) {
-            LegalNameValidator.validateOrganization(longLegalName.append("A").toString())
+            LegalNameValidator.validateOrganization(longLegalName.append("A").toString(), LegalNameValidator.Validation.FULL)
         }
     }
 
     @Test
     fun `legal name should be capitalized`() {
-        LegalNameValidator.validateOrganization("Good legal name")
+        LegalNameValidator.validateOrganization("Good legal name", LegalNameValidator.Validation.FULL)
         assertFailsWith(IllegalArgumentException::class) {
-            LegalNameValidator.validateOrganization("bad name")
+            LegalNameValidator.validateOrganization("bad name", LegalNameValidator.Validation.FULL)
         }
         assertFailsWith(IllegalArgumentException::class) {
-            LegalNameValidator.validateOrganization("bad Name")
+            LegalNameValidator.validateOrganization("bad Name", LegalNameValidator.Validation.FULL)
         }
     }
 
@@ -90,13 +129,13 @@ class LegalNameValidatorTest {
         assertEquals("Legal Name With Unicode Whitespaces", LegalNameValidator.normalize("Legal Name\u2004With\u0009Unicode\u0020Whitespaces"))
         assertEquals("Legal Name With Line Breaks", LegalNameValidator.normalize("Legal Name With\n\rLine\nBreaks"))
         assertFailsWith(IllegalArgumentException::class) {
-            LegalNameValidator.validateOrganization("Legal Name With\tTab")
+            LegalNameValidator.validateOrganization("Legal Name With\tTab", LegalNameValidator.Validation.FULL)
         }
         assertFailsWith(IllegalArgumentException::class) {
-            LegalNameValidator.validateOrganization("Legal Name\u2004With\u0009Unicode\u0020Whitespaces")
+            LegalNameValidator.validateOrganization("Legal Name\u2004With\u0009Unicode\u0020Whitespaces", LegalNameValidator.Validation.FULL)
         }
         assertFailsWith(IllegalArgumentException::class) {
-            LegalNameValidator.validateOrganization("Legal Name With\n\rLine\nBreaks")
+            LegalNameValidator.validateOrganization("Legal Name With\n\rLine\nBreaks", LegalNameValidator.Validation.FULL)
         }
     }
 }

core/src/test/kotlin/net/corda/core/internal/ResolveTransactionsFlowTest.kt

@@ -3,17 +3,16 @@ package net.corda.core.internal
 import co.paralleluniverse.fibers.Suspendable
 import net.corda.core.crypto.SecureHash
 import net.corda.core.flows.*
+import net.corda.core.identity.CordaX500Name
 import net.corda.core.identity.Party
 import net.corda.core.transactions.SignedTransaction
 import net.corda.core.utilities.getOrThrow
 import net.corda.core.utilities.sequence
 import net.corda.node.internal.StartedNode
-import net.corda.testing.MEGA_CORP
-import net.corda.testing.MINI_CORP
 import net.corda.testing.contracts.DummyContract
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.singleIdentity
-import net.corda.testing.startFlow
+import net.corda.testing.node.startFlow
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
@@ -40,8 +39,8 @@ class ResolveTransactionsFlowTest {
     fun setup() {
         mockNet = MockNetwork(cordappPackages = listOf("net.corda.testing.contracts"))
         notaryNode = mockNet.defaultNotaryNode
-        megaCorpNode = mockNet.createPartyNode(MEGA_CORP.name)
+        megaCorpNode = mockNet.createPartyNode(CordaX500Name("MegaCorp", "London", "GB"))
-        miniCorpNode = mockNet.createPartyNode(MINI_CORP.name)
+        miniCorpNode = mockNet.createPartyNode(CordaX500Name("MiniCorp", "London", "GB"))
         megaCorpNode.registerInitiatedFlow(TestResponseFlow::class.java)
         miniCorpNode.registerInitiatedFlow(TestResponseFlow::class.java)
         notary = mockNet.defaultNotaryIdentity

core/src/test/kotlin/net/corda/core/node/VaultUpdateTests.kt

@@ -5,14 +5,18 @@ import net.corda.core.crypto.SecureHash
 import net.corda.core.identity.AbstractParty
 import net.corda.core.node.services.Vault
 import net.corda.core.transactions.LedgerTransaction
-import net.corda.testing.DUMMY_NOTARY
+import net.corda.testing.DUMMY_NOTARY_NAME
+import net.corda.testing.TestIdentity
 import org.junit.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
 
 
 class VaultUpdateTests {
-    val DUMMY_PROGRAM_ID = "net.corda.core.node.VaultUpdateTests.DummyContract"
+    private companion object {
+        val DUMMY_PROGRAM_ID = "net.corda.core.node.VaultUpdateTests.DummyContract"
+        val DUMMY_NOTARY = TestIdentity(DUMMY_NOTARY_NAME, 20).party
+    }
 
     object DummyContract : Contract {
 

core/src/test/kotlin/net/corda/core/serialization/AttachmentSerializationTest.kt

@@ -21,7 +21,7 @@ import net.corda.testing.BOB_NAME
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.node.MockNodeParameters
 import net.corda.testing.singleIdentity
-import net.corda.testing.startFlow
+import net.corda.testing.node.startFlow
 import org.junit.After
 import org.junit.Before
 import org.junit.Test

core/src/test/kotlin/net/corda/core/serialization/TransactionSerializationTests.kt

@@ -3,6 +3,7 @@ package net.corda.core.serialization
 import net.corda.core.contracts.*
 import net.corda.core.crypto.generateKeyPair
 import net.corda.core.identity.AbstractParty
+import net.corda.core.identity.CordaX500Name
 import net.corda.core.transactions.LedgerTransaction
 import net.corda.core.transactions.TransactionBuilder
 import net.corda.core.utilities.seconds
@@ -19,6 +20,16 @@ import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
 
 class TransactionSerializationTests {
+    private companion object {
+        val dummyNotary = TestIdentity(DUMMY_NOTARY_NAME, 20)
+        val megaCorp = TestIdentity(CordaX500Name("MegaCorp", "London", "GB"))
+        val MINI_CORP = TestIdentity(CordaX500Name("MiniCorp", "London", "GB")).party
+        val DUMMY_NOTARY get() = dummyNotary.party
+        val DUMMY_NOTARY_KEY get() = dummyNotary.key
+        val MEGA_CORP get() = megaCorp.party
+        val MEGA_CORP_KEY get() = megaCorp.key
+    }
+
     @Rule
     @JvmField
     val testSerialization = SerializationEnvironmentRule()

core/src/test/kotlin/net/corda/core/transactions/CompatibleTransactionTests.kt

@@ -18,6 +18,8 @@ class CompatibleTransactionTests {
     private companion object {
         val DUMMY_KEY_1 = generateKeyPair()
         val DUMMY_KEY_2 = generateKeyPair()
+        val BOB = TestIdentity(BOB_NAME, 80).party
+        val DUMMY_NOTARY = TestIdentity(DUMMY_NOTARY_NAME, 20).party
     }
 
     @Rule

core/src/test/kotlin/net/corda/core/transactions/LedgerTransactionQueryTests.kt

@@ -5,6 +5,7 @@ import com.nhaarman.mockito_kotlin.whenever
 import net.corda.core.contracts.*
 import net.corda.core.crypto.generateKeyPair
 import net.corda.core.identity.AbstractParty
+import net.corda.core.identity.CordaX500Name
 import net.corda.core.identity.Party
 import net.corda.node.services.api.IdentityServiceInternal
 import net.corda.testing.*
@@ -19,13 +20,17 @@ import kotlin.test.assertFailsWith
 import kotlin.test.assertTrue
 
 class LedgerTransactionQueryTests {
+    companion object {
+        private val DUMMY_NOTARY = TestIdentity(DUMMY_NOTARY_NAME, 20).party
+    }
+
     @Rule
     @JvmField
     val testSerialization = SerializationEnvironmentRule()
     private val keyPair = generateKeyPair()
     private val services = MockServices(rigorousMock<IdentityServiceInternal>().also {
         doReturn(null).whenever(it).partyFromKey(keyPair.public)
-    }, MEGA_CORP.name, keyPair)
+    }, CordaX500Name("MegaCorp", "London", "GB"), keyPair)
     private val identity: Party = services.myInfo.singleIdentity()
 
     @Before

core/src/test/kotlin/net/corda/core/transactions/TransactionEncumbranceTests.kt

@@ -6,12 +6,14 @@ import net.corda.core.contracts.Contract
 import net.corda.core.contracts.ContractState
 import net.corda.core.contracts.requireThat
 import net.corda.core.identity.AbstractParty
+import net.corda.core.identity.CordaX500Name
 import net.corda.finance.DOLLARS
 import net.corda.finance.`issued by`
 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.Rule
 import org.junit.Test
 import java.time.Instant
@@ -20,6 +22,14 @@ import java.time.temporal.ChronoUnit
 val TEST_TIMELOCK_ID = "net.corda.core.transactions.TransactionEncumbranceTests\$DummyTimeLock"
 
 class TransactionEncumbranceTests {
+    private companion object {
+        val DUMMY_NOTARY = TestIdentity(DUMMY_NOTARY_NAME, 20).party
+        val megaCorp = TestIdentity(CordaX500Name("MegaCorp", "London", "GB"))
+        val MINI_CORP = TestIdentity(CordaX500Name("MiniCorp", "London", "GB")).party
+        val MEGA_CORP get() = megaCorp.party
+        val MEGA_CORP_PUBKEY get() = megaCorp.pubkey
+    }
+
     @Rule
     @JvmField
     val testSerialization = SerializationEnvironmentRule()

core/src/test/kotlin/net/corda/core/transactions/TransactionTests.kt

@@ -6,7 +6,6 @@ import net.corda.core.crypto.CompositeKey
 import net.corda.core.identity.Party
 import net.corda.testing.*
 import net.corda.testing.contracts.DummyContract
-import net.corda.testing.node.MockAttachment
 import org.junit.Rule
 import org.junit.Test
 import java.math.BigInteger
@@ -20,6 +19,11 @@ class TransactionTests {
         val DUMMY_KEY_1 = generateKeyPair()
         val DUMMY_KEY_2 = generateKeyPair()
         val DUMMY_CASH_ISSUER_KEY = entropyToKeyPair(BigInteger.valueOf(10))
+        val ALICE = TestIdentity(ALICE_NAME, 70).party
+        val BOB = TestIdentity(BOB_NAME, 80).party
+        val dummyNotary = TestIdentity(DUMMY_NOTARY_NAME, 20)
+        val DUMMY_NOTARY get() = dummyNotary.party
+        val DUMMY_NOTARY_KEY get() = dummyNotary.key
     }
 
     @Rule
@@ -107,7 +111,7 @@ class TransactionTests {
         val inputs = emptyList<StateAndRef<*>>()
         val outputs = listOf(baseOutState, baseOutState.copy(notary = ALICE), baseOutState.copy(notary = BOB))
         val commands = emptyList<CommandWithParties<CommandData>>()
-        val attachments = listOf<Attachment>(ContractAttachment(MockAttachment(), DummyContract.PROGRAM_ID))
+        val attachments = listOf<Attachment>(ContractAttachment(rigorousMock(), DummyContract.PROGRAM_ID))
         val id = SecureHash.randomSHA256()
         val timeWindow: TimeWindow? = null
         val privacySalt: PrivacySalt = PrivacySalt()

docs/source/example-code/src/integration-test/kotlin/net/corda/docs/IntegrationTestingTutorial.kt

@@ -44,8 +44,8 @@ class IntegrationTestingTutorial : IntegrationTest() {
                     invokeRpc(CordaRPCOps::networkMapFeed)
             ))
             val (alice, bob) = listOf(
-                    startNode(providedName = ALICE.name, rpcUsers = listOf(aliceUser)),
+                    startNode(providedName = ALICE_NAME, rpcUsers = listOf(aliceUser)),
-                    startNode(providedName = BOB.name, rpcUsers = listOf(bobUser))
+                    startNode(providedName = BOB_NAME, rpcUsers = listOf(bobUser))
             ).transpose().getOrThrow()
 
             // END 1

docs/source/example-code/src/main/java/net/corda/docs/FlowCookbookJava.java

@@ -33,7 +33,7 @@ import java.util.List;
 import java.util.Set;
 
 import static net.corda.core.contracts.ContractsDSL.requireThat;
-import static net.corda.testing.TestConstants.getALICE_KEY;
+import static net.corda.core.crypto.Crypto.generateKeyPair;
 
 @SuppressWarnings("unused")
 public class FlowCookbookJava {
@@ -107,9 +107,7 @@ public class FlowCookbookJava {
         @Override
         public Void call() throws FlowException {
             // We'll be using a dummy public key for demonstration purposes.
-            // These are built in to Corda, and are generally used for writing
+            PublicKey dummyPubKey = generateKeyPair().getPublic();
-            // tests.
-            PublicKey dummyPubKey = getALICE_KEY().getPublic();
 
             /*---------------------------
              * IDENTIFYING OTHER NODES *

docs/source/example-code/src/main/java/net/corda/docs/java/tutorial/testdsl/CommercialPaperTest.java

@@ -2,47 +2,56 @@ package net.corda.docs.java.tutorial.testdsl;
 
 import kotlin.Unit;
 import net.corda.core.contracts.PartyAndReference;
-import net.corda.core.utilities.OpaqueBytes;
+import net.corda.core.identity.CordaX500Name;
+import net.corda.core.identity.Party;
 import net.corda.finance.contracts.ICommercialPaperState;
 import net.corda.finance.contracts.JavaCommercialPaper;
 import net.corda.finance.contracts.asset.Cash;
 import net.corda.node.services.api.IdentityServiceInternal;
 import net.corda.testing.SerializationEnvironmentRule;
 import net.corda.testing.node.MockServices;
+import net.corda.testing.TestIdentity;
 import org.junit.Rule;
 import org.junit.Test;
 
+import java.security.PublicKey;
 import java.time.temporal.ChronoUnit;
 
+import static net.corda.core.crypto.Crypto.generateKeyPair;
 import static net.corda.finance.Currencies.DOLLARS;
 import static net.corda.finance.Currencies.issuedBy;
 import static net.corda.finance.contracts.JavaCommercialPaper.JCP_PROGRAM_ID;
-import static net.corda.testing.CoreTestUtils.*;
+import static net.corda.testing.node.NodeTestUtils.ledger;
-import static net.corda.testing.NodeTestUtils.ledger;
+import static net.corda.testing.node.NodeTestUtils.transaction;
-import static net.corda.testing.NodeTestUtils.transaction;
+import static net.corda.testing.CoreTestUtils.rigorousMock;
 import static net.corda.testing.TestConstants.*;
 import static org.mockito.Mockito.doReturn;
 
 public class CommercialPaperTest {
+    private static final TestIdentity ALICE = new TestIdentity(getALICE_NAME(), 70L);
+    private static final PublicKey BIG_CORP_PUBKEY = generateKeyPair().getPublic();
+    private static final TestIdentity BOB = new TestIdentity(getBOB_NAME(), 80L);
+    private static final TestIdentity MEGA_CORP = new TestIdentity(new CordaX500Name("MegaCorp", "London", "GB"));
+    private static final Party DUMMY_NOTARY = new TestIdentity(getDUMMY_NOTARY_NAME(), 20L).getParty();
     @Rule
     public final SerializationEnvironmentRule testSerialization = new SerializationEnvironmentRule();
-    private final OpaqueBytes defaultRef = new OpaqueBytes(new byte[]{123});
+    private final byte[] defaultRef = {123};
     private final MockServices ledgerServices;
 
     {
         IdentityServiceInternal identityService = rigorousMock(IdentityServiceInternal.class);
-        doReturn(getMEGA_CORP()).when(identityService).partyFromKey(getMEGA_CORP_PUBKEY());
+        doReturn(MEGA_CORP.getParty()).when(identityService).partyFromKey(MEGA_CORP.getPubkey());
-        doReturn(null).when(identityService).partyFromKey(getBIG_CORP_PUBKEY());
+        doReturn(null).when(identityService).partyFromKey(BIG_CORP_PUBKEY);
-        doReturn(null).when(identityService).partyFromKey(getALICE_PUBKEY());
+        doReturn(null).when(identityService).partyFromKey(ALICE.getPubkey());
-        ledgerServices = new MockServices(identityService, getMEGA_CORP().getName());
+        ledgerServices = new MockServices(identityService, MEGA_CORP.getName());
     }
 
     // DOCSTART 1
     private ICommercialPaperState getPaper() {
         return new JavaCommercialPaper.State(
-                getMEGA_CORP().ref(defaultRef),
+                MEGA_CORP.ref(defaultRef),
-                getMEGA_CORP(),
+                MEGA_CORP.getParty(),
-                issuedBy(DOLLARS(1000), getMEGA_CORP().ref(defaultRef)),
+                issuedBy(DOLLARS(1000), MEGA_CORP.ref(defaultRef)),
                 getTEST_TX_TIME().plus(7, ChronoUnit.DAYS)
         );
     }
@@ -52,7 +61,7 @@ public class CommercialPaperTest {
     @Test
     public void simpleCP() {
         ICommercialPaperState inState = getPaper();
-        ledger(ledgerServices, getDUMMY_NOTARY(), l -> {
+        ledger(ledgerServices, DUMMY_NOTARY, l -> {
             l.transaction(tx -> {
                 tx.attachments(JCP_PROGRAM_ID);
                 tx.input(JCP_PROGRAM_ID, inState);
@@ -67,10 +76,10 @@ public class CommercialPaperTest {
     @Test
     public void simpleCPMove() {
         ICommercialPaperState inState = getPaper();
-        ledger(ledgerServices, getDUMMY_NOTARY(), l -> {
+        ledger(ledgerServices, DUMMY_NOTARY, l -> {
             l.transaction(tx -> {
                 tx.input(JCP_PROGRAM_ID, inState);
-                tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Move());
+                tx.command(MEGA_CORP.getPubkey(), new JavaCommercialPaper.Commands.Move());
                 tx.attachments(JCP_PROGRAM_ID);
                 return tx.verifies();
             });
@@ -83,10 +92,10 @@ public class CommercialPaperTest {
     @Test
     public void simpleCPMoveFails() {
         ICommercialPaperState inState = getPaper();
-        ledger(ledgerServices, getDUMMY_NOTARY(), l -> {
+        ledger(ledgerServices, DUMMY_NOTARY, l -> {
             l.transaction(tx -> {
                 tx.input(JCP_PROGRAM_ID, inState);
-                tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Move());
+                tx.command(MEGA_CORP.getPubkey(), new JavaCommercialPaper.Commands.Move());
                 tx.attachments(JCP_PROGRAM_ID);
                 return tx.failsWith("the state is propagated");
             });
@@ -99,13 +108,13 @@ public class CommercialPaperTest {
     @Test
     public void simpleCPMoveSuccess() {
         ICommercialPaperState inState = getPaper();
-        ledger(ledgerServices, getDUMMY_NOTARY(), l -> {
+        ledger(ledgerServices, DUMMY_NOTARY, l -> {
             l.transaction(tx -> {
                 tx.input(JCP_PROGRAM_ID, inState);
-                tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Move());
+                tx.command(MEGA_CORP.getPubkey(), new JavaCommercialPaper.Commands.Move());
                 tx.attachments(JCP_PROGRAM_ID);
                 tx.failsWith("the state is propagated");
-                tx.output(JCP_PROGRAM_ID, "alice's paper", inState.withOwner(getALICE()));
+                tx.output(JCP_PROGRAM_ID, "alice's paper", inState.withOwner(ALICE.getParty()));
                 return tx.verifies();
             });
             return Unit.INSTANCE;
@@ -116,16 +125,16 @@ public class CommercialPaperTest {
     // DOCSTART 6
     @Test
     public void simpleIssuanceWithTweak() {
-        ledger(ledgerServices, getDUMMY_NOTARY(), l -> {
+        ledger(ledgerServices, DUMMY_NOTARY, l -> {
             l.transaction(tx -> {
                 tx.output(JCP_PROGRAM_ID, "paper", getPaper()); // Some CP is issued onto the ledger by MegaCorp.
                 tx.attachments(JCP_PROGRAM_ID);
                 tx.tweak(tw -> {
-                    tw.command(getBIG_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Issue());
+                    tw.command(BIG_CORP_PUBKEY, new JavaCommercialPaper.Commands.Issue());
                     tw.timeWindow(getTEST_TX_TIME());
                     return tw.failsWith("output states are issued by a command signer");
                 });
-                tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Issue());
+                tx.command(MEGA_CORP.getPubkey(), new JavaCommercialPaper.Commands.Issue());
                 tx.timeWindow(getTEST_TX_TIME());
                 return tx.verifies();
             });
@@ -137,15 +146,15 @@ public class CommercialPaperTest {
     // DOCSTART 7
     @Test
     public void simpleIssuanceWithTweakTopLevelTx() {
-        transaction(ledgerServices, getDUMMY_NOTARY(), tx -> {
+        transaction(ledgerServices, DUMMY_NOTARY, tx -> {
             tx.output(JCP_PROGRAM_ID, "paper", getPaper()); // Some CP is issued onto the ledger by MegaCorp.
             tx.attachments(JCP_PROGRAM_ID);
             tx.tweak(tw -> {
-                tw.command(getBIG_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Issue());
+                tw.command(BIG_CORP_PUBKEY, new JavaCommercialPaper.Commands.Issue());
                 tw.timeWindow(getTEST_TX_TIME());
                 return tw.failsWith("output states are issued by a command signer");
             });
-            tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Issue());
+            tx.command(MEGA_CORP.getPubkey(), new JavaCommercialPaper.Commands.Issue());
             tx.timeWindow(getTEST_TX_TIME());
             return tx.verifies();
         });
@@ -155,11 +164,11 @@ public class CommercialPaperTest {
     // DOCSTART 8
     @Test
     public void chainCommercialPaper() {
-        PartyAndReference issuer = getMEGA_CORP().ref(defaultRef);
+        PartyAndReference issuer = MEGA_CORP.ref(defaultRef);
-        ledger(ledgerServices, getDUMMY_NOTARY(), l -> {
+        ledger(ledgerServices, DUMMY_NOTARY, l -> {
             l.unverifiedTransaction(tx -> {
                 tx.output(Cash.PROGRAM_ID, "alice's $900",
-                        new Cash.State(issuedBy(DOLLARS(900), issuer), getALICE()));
+                        new Cash.State(issuedBy(DOLLARS(900), issuer), ALICE.getParty()));
                 tx.attachments(Cash.PROGRAM_ID);
                 return Unit.INSTANCE;
             });
@@ -167,7 +176,7 @@ public class CommercialPaperTest {
             // Some CP is issued onto the ledger by MegaCorp.
             l.transaction("Issuance", tx -> {
                 tx.output(JCP_PROGRAM_ID, "paper", getPaper());
-                tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Issue());
+                tx.command(MEGA_CORP.getPubkey(), new JavaCommercialPaper.Commands.Issue());
                 tx.attachments(JCP_PROGRAM_ID);
                 tx.timeWindow(getTEST_TX_TIME());
                 return tx.verifies();
@@ -176,11 +185,11 @@ public class CommercialPaperTest {
             l.transaction("Trade", tx -> {
                 tx.input("paper");
                 tx.input("alice's $900");
-                tx.output(Cash.PROGRAM_ID, "borrowed $900", new Cash.State(issuedBy(DOLLARS(900), issuer), getMEGA_CORP()));
+                tx.output(Cash.PROGRAM_ID, "borrowed $900", new Cash.State(issuedBy(DOLLARS(900), issuer), MEGA_CORP.getParty()));
                 JavaCommercialPaper.State inputPaper = l.retrieveOutput(JavaCommercialPaper.State.class, "paper");
-                tx.output(JCP_PROGRAM_ID, "alice's paper", inputPaper.withOwner(getALICE()));
+                tx.output(JCP_PROGRAM_ID, "alice's paper", inputPaper.withOwner(ALICE.getParty()));
-                tx.command(getALICE_PUBKEY(), new Cash.Commands.Move());
+                tx.command(ALICE.getPubkey(), new Cash.Commands.Move());
-                tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Move());
+                tx.command(MEGA_CORP.getPubkey(), new JavaCommercialPaper.Commands.Move());
                 return tx.verifies();
             });
             return Unit.INSTANCE;
@@ -191,11 +200,11 @@ public class CommercialPaperTest {
     // DOCSTART 9
     @Test
     public void chainCommercialPaperDoubleSpend() {
-        PartyAndReference issuer = getMEGA_CORP().ref(defaultRef);
+        PartyAndReference issuer = MEGA_CORP.ref(defaultRef);
-        ledger(ledgerServices, getDUMMY_NOTARY(), l -> {
+        ledger(ledgerServices, DUMMY_NOTARY, l -> {
             l.unverifiedTransaction(tx -> {
                 tx.output(Cash.PROGRAM_ID, "alice's $900",
-                        new Cash.State(issuedBy(DOLLARS(900), issuer), getALICE()));
+                        new Cash.State(issuedBy(DOLLARS(900), issuer), ALICE.getParty()));
                 tx.attachments(Cash.PROGRAM_ID);
                 return Unit.INSTANCE;
             });
@@ -203,7 +212,7 @@ public class CommercialPaperTest {
             // Some CP is issued onto the ledger by MegaCorp.
             l.transaction("Issuance", tx -> {
                 tx.output(Cash.PROGRAM_ID, "paper", getPaper());
-                tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Issue());
+                tx.command(MEGA_CORP.getPubkey(), new JavaCommercialPaper.Commands.Issue());
                 tx.attachments(JCP_PROGRAM_ID);
                 tx.timeWindow(getTEST_TX_TIME());
                 return tx.verifies();
@@ -212,11 +221,11 @@ public class CommercialPaperTest {
             l.transaction("Trade", tx -> {
                 tx.input("paper");
                 tx.input("alice's $900");
-                tx.output(Cash.PROGRAM_ID, "borrowed $900", new Cash.State(issuedBy(DOLLARS(900), issuer), getMEGA_CORP()));
+                tx.output(Cash.PROGRAM_ID, "borrowed $900", new Cash.State(issuedBy(DOLLARS(900), issuer), MEGA_CORP.getParty()));
                 JavaCommercialPaper.State inputPaper = l.retrieveOutput(JavaCommercialPaper.State.class, "paper");
-                tx.output(JCP_PROGRAM_ID, "alice's paper", inputPaper.withOwner(getALICE()));
+                tx.output(JCP_PROGRAM_ID, "alice's paper", inputPaper.withOwner(ALICE.getParty()));
-                tx.command(getALICE_PUBKEY(), new Cash.Commands.Move());
+                tx.command(ALICE.getPubkey(), new Cash.Commands.Move());
-                tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Move());
+                tx.command(MEGA_CORP.getPubkey(), new JavaCommercialPaper.Commands.Move());
                 return tx.verifies();
             });
 
@@ -224,8 +233,8 @@ public class CommercialPaperTest {
                 tx.input("paper");
                 JavaCommercialPaper.State inputPaper = l.retrieveOutput(JavaCommercialPaper.State.class, "paper");
                 // We moved a paper to other pubkey.
-                tx.output(JCP_PROGRAM_ID, "bob's paper", inputPaper.withOwner(getBOB()));
+                tx.output(JCP_PROGRAM_ID, "bob's paper", inputPaper.withOwner(BOB.getParty()));
-                tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Move());
+                tx.command(MEGA_CORP.getPubkey(), new JavaCommercialPaper.Commands.Move());
                 return tx.verifies();
             });
             l.fails();
@@ -237,11 +246,11 @@ public class CommercialPaperTest {
     // DOCSTART 10
     @Test
     public void chainCommercialPaperTweak() {
-        PartyAndReference issuer = getMEGA_CORP().ref(defaultRef);
+        PartyAndReference issuer = MEGA_CORP.ref(defaultRef);
-        ledger(ledgerServices, getDUMMY_NOTARY(), l -> {
+        ledger(ledgerServices, DUMMY_NOTARY, l -> {
             l.unverifiedTransaction(tx -> {
                 tx.output(Cash.PROGRAM_ID, "alice's $900",
-                        new Cash.State(issuedBy(DOLLARS(900), issuer), getALICE()));
+                        new Cash.State(issuedBy(DOLLARS(900), issuer), ALICE.getParty()));
                 tx.attachments(Cash.PROGRAM_ID);
                 return Unit.INSTANCE;
             });
@@ -249,7 +258,7 @@ public class CommercialPaperTest {
             // Some CP is issued onto the ledger by MegaCorp.
             l.transaction("Issuance", tx -> {
                 tx.output(Cash.PROGRAM_ID, "paper", getPaper());
-                tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Issue());
+                tx.command(MEGA_CORP.getPubkey(), new JavaCommercialPaper.Commands.Issue());
                 tx.attachments(JCP_PROGRAM_ID);
                 tx.timeWindow(getTEST_TX_TIME());
                 return tx.verifies();
@@ -258,11 +267,11 @@ public class CommercialPaperTest {
             l.transaction("Trade", tx -> {
                 tx.input("paper");
                 tx.input("alice's $900");
-                tx.output(Cash.PROGRAM_ID, "borrowed $900", new Cash.State(issuedBy(DOLLARS(900), issuer), getMEGA_CORP()));
+                tx.output(Cash.PROGRAM_ID, "borrowed $900", new Cash.State(issuedBy(DOLLARS(900), issuer), MEGA_CORP.getParty()));
                 JavaCommercialPaper.State inputPaper = l.retrieveOutput(JavaCommercialPaper.State.class, "paper");
-                tx.output(JCP_PROGRAM_ID, "alice's paper", inputPaper.withOwner(getALICE()));
+                tx.output(JCP_PROGRAM_ID, "alice's paper", inputPaper.withOwner(ALICE.getParty()));
-                tx.command(getALICE_PUBKEY(), new Cash.Commands.Move());
+                tx.command(ALICE.getPubkey(), new Cash.Commands.Move());
-                tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Move());
+                tx.command(MEGA_CORP.getPubkey(), new JavaCommercialPaper.Commands.Move());
                 return tx.verifies();
             });
 
@@ -271,8 +280,8 @@ public class CommercialPaperTest {
                     tx.input("paper");
                     JavaCommercialPaper.State inputPaper = l.retrieveOutput(JavaCommercialPaper.State.class, "paper");
                     // We moved a paper to another pubkey.
-                    tx.output(JCP_PROGRAM_ID, "bob's paper", inputPaper.withOwner(getBOB()));
+                    tx.output(JCP_PROGRAM_ID, "bob's paper", inputPaper.withOwner(BOB.getParty()));
-                    tx.command(getMEGA_CORP_PUBKEY(), new JavaCommercialPaper.Commands.Move());
+                    tx.command(MEGA_CORP.getPubkey(), new JavaCommercialPaper.Commands.Move());
                     return tx.verifies();
                 });
                 lw.fails();

docs/source/example-code/src/main/kotlin/net/corda/docs/ClientRpcTutorial.kt

@@ -18,7 +18,7 @@ import net.corda.finance.flows.CashPaymentFlow
 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.ALICE
+import net.corda.testing.ALICE_NAME
 import net.corda.testing.driver.driver
 import org.graphstream.graph.Edge
 import org.graphstream.graph.Node
@@ -49,7 +49,7 @@ fun main(args: Array<String>) {
             invokeRpc(CordaRPCOps::nodeInfo)
     ))
     driver(driverDirectory = baseDirectory, extraCordappPackagesToScan = listOf("net.corda.finance"), waitForAllNodesToFinish = true) {
-        val node = startNode(providedName = ALICE.name, rpcUsers = listOf(user)).get()
+        val node = startNode(providedName = ALICE_NAME, rpcUsers = listOf(user)).get()
         // END 1
 
         // START 2

docs/source/example-code/src/main/kotlin/net/corda/docs/FlowCookbook.kt

@@ -6,6 +6,7 @@ import co.paralleluniverse.fibers.Suspendable
 import net.corda.core.contracts.*
 import net.corda.core.crypto.SecureHash
 import net.corda.core.crypto.TransactionSignature
+import net.corda.core.crypto.generateKeyPair
 import net.corda.core.flows.*
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.identity.Party
@@ -23,7 +24,6 @@ import net.corda.core.utilities.UntrustworthyData
 import net.corda.core.utilities.seconds
 import net.corda.core.utilities.unwrap
 import net.corda.finance.contracts.asset.Cash
-import net.corda.testing.ALICE_PUBKEY
 import net.corda.testing.contracts.DummyContract
 import net.corda.testing.contracts.DummyState
 import java.security.PublicKey
@@ -87,9 +87,7 @@ class InitiatorFlow(val arg1: Boolean, val arg2: Int, private val counterparty:
     @Suspendable
     override fun call() {
         // We'll be using a dummy public key for demonstration purposes.
-        // These are built in to Corda, and are generally used for writing
+        val dummyPubKey: PublicKey = generateKeyPair().public
-        // tests.
-        val dummyPubKey: PublicKey = ALICE_PUBKEY
 
         /**--------------------------
          * IDENTIFYING OTHER NODES *

docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/mocknetwork/TutorialMockNetwork.kt

@@ -21,7 +21,7 @@ import net.corda.testing.node.InMemoryMessagingNetwork
 import net.corda.testing.node.MessagingServiceSpy
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.node.setMessagingServiceSpy
-import net.corda.testing.startFlow
+import net.corda.testing.node.startFlow
 import org.junit.After
 import org.junit.Before
 import org.junit.Rule

docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/tearoffs/TutorialTearOffs.kt

@@ -4,16 +4,16 @@ import net.corda.core.contracts.Command
 import net.corda.core.contracts.StateRef
 import net.corda.core.contracts.TimeWindow
 import net.corda.core.crypto.MerkleTreeException
+import net.corda.core.identity.AbstractParty
 import net.corda.core.transactions.FilteredTransaction
 import net.corda.core.transactions.FilteredTransactionVerificationException
 import net.corda.core.transactions.SignedTransaction
 import net.corda.finance.contracts.Fix
-import net.corda.testing.ALICE
 import java.util.function.Predicate
 
 fun main(args: Array<String>) {
     // Typealias to make the example coherent.
-    val oracle = ALICE
+    val oracle = Any() as AbstractParty
     val stx = Any() as SignedTransaction
 
     // DOCSTART 1

docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/testdsl/TutorialTestDSL.kt

@@ -2,6 +2,8 @@ package net.corda.docs.tutorial.testdsl
 
 import com.nhaarman.mockito_kotlin.doReturn
 import com.nhaarman.mockito_kotlin.whenever
+import net.corda.core.crypto.generateKeyPair
+import net.corda.core.identity.CordaX500Name
 import net.corda.core.utilities.days
 import net.corda.finance.DOLLARS
 import net.corda.finance.`issued by`
@@ -13,10 +15,24 @@ 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 net.corda.testing.node.transaction
 import org.junit.Rule
 import org.junit.Test
 
 class CommercialPaperTest {
+    private companion object {
+        val alice = TestIdentity(ALICE_NAME, 70)
+        val BIG_CORP_PUBKEY = generateKeyPair().public
+        val BOB = TestIdentity(BOB_NAME, 80).party
+        val DUMMY_NOTARY = TestIdentity(DUMMY_NOTARY_NAME, 20).party
+        val megaCorp = TestIdentity(CordaX500Name("MegaCorp", "London", "GB"))
+        val ALICE get() = alice.party
+        val ALICE_PUBKEY get() = alice.pubkey
+        val MEGA_CORP get() = megaCorp.party
+        val MEGA_CORP_PUBKEY get() = megaCorp.pubkey
+    }
+
     @Rule
     @JvmField
     val testSerialization = SerializationEnvironmentRule()

docs/source/example-code/src/test/kotlin/net/corda/docs/CustomVaultQueryTest.kt

@@ -10,7 +10,7 @@ import net.corda.finance.flows.CashIssueFlow
 import net.corda.node.internal.StartedNode
 import net.corda.testing.chooseIdentity
 import net.corda.testing.node.MockNetwork
-import net.corda.testing.startFlow
+import net.corda.testing.node.startFlow
 import org.junit.After
 import org.junit.Assert
 import org.junit.Before

docs/source/example-code/src/test/kotlin/net/corda/docs/FxTransactionBuildTutorialTest.kt

@@ -10,7 +10,7 @@ import net.corda.finance.flows.CashIssueFlow
 import net.corda.node.internal.StartedNode
 import net.corda.testing.chooseIdentity
 import net.corda.testing.node.MockNetwork
-import net.corda.testing.startFlow
+import net.corda.testing.node.startFlow
 import org.junit.After
 import org.junit.Before
 import org.junit.Test

docs/source/example-code/src/test/kotlin/net/corda/docs/WorkflowTransactionBuildTutorialTest.kt

@@ -12,6 +12,7 @@ import net.corda.core.utilities.getOrThrow
 import net.corda.node.services.api.StartedNodeServices
 import net.corda.testing.*
 import net.corda.testing.node.MockNetwork
+import net.corda.testing.node.startFlow
 import org.junit.After
 import org.junit.Before
 import org.junit.Test

docs/source/generating-a-node.rst

@@ -50,17 +50,21 @@ The name must also obey the following constraints:
 
 * The country attribute is a valid ISO 3166-1 two letter code in upper-case
 
-* The organisation field of the name obeys the following constraints:
+* All attributes must obey the following constraints:
 
     * Upper-case first letter
     * Has at least two letters
     * No leading or trailing whitespace
-    * No double-spacing
-    * Does not contain the words "node" or "server"
     * Does not include the following characters: ``,`` , ``=`` , ``$`` , ``"`` , ``'`` , ``\``
     * Is in NFKC normalization form
+    * Does not contain the null character
     * Only the latin, common and inherited unicode scripts are supported
 
+* The organisation field of the name also obeys the following constraints:
+
+    * No double-spacing
+    * Does not contain the words "node" or "server"
+
         * This is to avoid right-to-left issues, debugging issues when we can't pronounce names over the phone, and
           character confusability attacks
 
@@ -149,4 +153,4 @@ in the ``deployNodes`` task, plus a ``runnodes`` shell script (or batch file on
 for testing and development purposes. If you make any changes to your CorDapp source or ``deployNodes`` task, you will
 need to re-run the task to see the changes take effect.
 
-You can now run the nodes by following the instructions in :doc:`Running a node <running-a-node>`.
+You can now run the nodes by following the instructions in :doc:`Running a node <running-a-node>`.

experimental/src/test/kotlin/net/corda/finance/contracts/universal/Cap.kt

@@ -2,9 +2,7 @@ package net.corda.finance.contracts.universal
 
 import com.nhaarman.mockito_kotlin.doReturn
 import com.nhaarman.mockito_kotlin.whenever
-import net.corda.core.crypto.entropyToKeyPair
 import net.corda.core.identity.CordaX500Name
-import net.corda.core.identity.Party
 import net.corda.finance.contracts.BusinessCalendar
 import net.corda.finance.contracts.FixOf
 import net.corda.finance.contracts.Frequency
@@ -12,20 +10,20 @@ import net.corda.finance.contracts.Tenor
 import net.corda.node.services.api.IdentityServiceInternal
 import net.corda.testing.*
 import net.corda.testing.node.MockServices
-import net.corda.testing.node.makeTestIdentityService
+import net.corda.testing.node.transaction
 import org.junit.Ignore
 import org.junit.Rule
 import org.junit.Test
-import java.math.BigInteger
 import java.time.Instant
 import java.time.LocalDate
 
+internal val DUMMY_NOTARY = TestIdentity(DUMMY_NOTARY_NAME, 20).party
 fun transaction(script: TransactionDSL<TransactionDSLInterpreter>.() -> EnforceVerifyOrFail) = run {
     MockServices(listOf("net.corda.finance.contracts.universal"), rigorousMock<IdentityServiceInternal>().also {
         listOf(acmeCorp, highStreetBank, momAndPop).forEach { party ->
             doReturn(null).whenever(it).partyFromKey(party.owningKey)
         }
-    }, MEGA_CORP.name).transaction(DUMMY_NOTARY, script)
+    }, CordaX500Name("MegaCorp", "London", "GB")).transaction(DUMMY_NOTARY, script)
 }
 
 class Cap {

experimental/src/test/kotlin/net/corda/finance/contracts/universal/Caplet.kt

@@ -2,7 +2,6 @@ package net.corda.finance.contracts.universal
 
 import net.corda.finance.contracts.FixOf
 import net.corda.finance.contracts.Tenor
-import net.corda.testing.DUMMY_NOTARY
 import net.corda.testing.SerializationEnvironmentRule
 import org.junit.Ignore
 import org.junit.Rule

experimental/src/test/kotlin/net/corda/finance/contracts/universal/ContractDefinition.kt

@@ -1,20 +1,17 @@
 package net.corda.finance.contracts.universal
 
 import net.corda.core.crypto.generateKeyPair
-import net.corda.core.identity.Party
+import net.corda.core.identity.CordaX500Name
-import net.corda.testing.ALICE
+import net.corda.testing.TestIdentity
-import net.corda.testing.MEGA_CORP
-import net.corda.testing.MINI_CORP
 import org.junit.Test
 import java.util.*
 import kotlin.test.assertEquals
 import kotlin.test.assertTrue
 
 // Test parties
-val acmeCorp = Party(ALICE.name, generateKeyPair().public)
+val acmeCorp = TestIdentity(CordaX500Name("Alice Corp", "Madrid", "ES")).party
-val highStreetBank = Party(MEGA_CORP.name, generateKeyPair().public)
+val highStreetBank = TestIdentity(CordaX500Name("MegaCorp", "London", "GB")).party
-val momAndPop = Party(MINI_CORP.name, generateKeyPair().public)
+val momAndPop = TestIdentity(CordaX500Name("MiniCorp", "London", "GB")).party
-
 val acmeCorporationHasDefaulted = TerminalEvent(acmeCorp, generateKeyPair().public)
 
 

experimental/src/test/kotlin/net/corda/finance/contracts/universal/FXFwdTimeOption.kt

@@ -1,6 +1,5 @@
 package net.corda.finance.contracts.universal
 
-import net.corda.testing.DUMMY_NOTARY
 import net.corda.testing.SerializationEnvironmentRule
 import org.junit.Ignore
 import org.junit.Rule

experimental/src/test/kotlin/net/corda/finance/contracts/universal/FXSwap.kt

@@ -1,6 +1,5 @@
 package net.corda.finance.contracts.universal
 
-import net.corda.testing.DUMMY_NOTARY
 import net.corda.testing.SerializationEnvironmentRule
 import org.junit.Ignore
 import org.junit.Rule

experimental/src/test/kotlin/net/corda/finance/contracts/universal/IRS.kt

@@ -3,7 +3,6 @@ package net.corda.finance.contracts.universal
 import net.corda.finance.contracts.FixOf
 import net.corda.finance.contracts.Frequency
 import net.corda.finance.contracts.Tenor
-import net.corda.testing.DUMMY_NOTARY
 import net.corda.testing.SerializationEnvironmentRule
 import org.junit.Ignore
 import org.junit.Rule

experimental/src/test/kotlin/net/corda/finance/contracts/universal/RollOutTests.kt

@@ -1,7 +1,6 @@
 package net.corda.finance.contracts.universal
 
 import net.corda.finance.contracts.Frequency
-import net.corda.testing.DUMMY_NOTARY
 import net.corda.testing.SerializationEnvironmentRule
 import org.junit.Rule
 import org.junit.Test

experimental/src/test/kotlin/net/corda/finance/contracts/universal/Swaption.kt

@@ -2,7 +2,6 @@ package net.corda.finance.contracts.universal
 
 import net.corda.finance.contracts.Frequency
 import net.corda.finance.contracts.Tenor
-import net.corda.testing.DUMMY_NOTARY
 import net.corda.testing.SerializationEnvironmentRule
 import org.junit.Ignore
 import org.junit.Rule

experimental/src/test/kotlin/net/corda/finance/contracts/universal/ZeroCouponBond.kt

@@ -1,6 +1,5 @@
 package net.corda.finance.contracts.universal
 
-import net.corda.testing.DUMMY_NOTARY
 import net.corda.testing.SerializationEnvironmentRule
 import org.junit.Rule
 import org.junit.Test

finance/src/test/java/net/corda/finance/contracts/asset/CashTestsJava.java

@@ -2,72 +2,76 @@ package net.corda.finance.contracts.asset;
 
 import net.corda.core.contracts.PartyAndReference;
 import net.corda.core.identity.AnonymousParty;
-import net.corda.core.utilities.OpaqueBytes;
+import net.corda.core.identity.CordaX500Name;
+import net.corda.core.identity.Party;
 import net.corda.node.services.api.IdentityServiceInternal;
 import net.corda.testing.DummyCommandData;
 import net.corda.testing.SerializationEnvironmentRule;
+import net.corda.testing.TestIdentity;
 import net.corda.testing.node.MockServices;
 import org.junit.Rule;
 import org.junit.Test;
 
 import static net.corda.finance.Currencies.DOLLARS;
 import static net.corda.finance.Currencies.issuedBy;
-import static net.corda.testing.CoreTestUtils.*;
+import static net.corda.testing.node.NodeTestUtils.transaction;
-import static net.corda.testing.NodeTestUtils.transaction;
+import static net.corda.testing.CoreTestUtils.rigorousMock;
-import static net.corda.testing.TestConstants.getDUMMY_NOTARY;
+import static net.corda.testing.TestConstants.getDUMMY_NOTARY_NAME;
 import static org.mockito.Mockito.doReturn;
 
 /**
  * This is an incomplete Java replica of CashTests.kt to show how to use the Java test DSL
  */
 public class CashTestsJava {
-    private final OpaqueBytes defaultRef = new OpaqueBytes(new byte[]{1});
+    private static final Party DUMMY_NOTARY = new TestIdentity(getDUMMY_NOTARY_NAME(), 20L).getParty();
-    private final PartyAndReference defaultIssuer = getMEGA_CORP().ref(defaultRef);
+    private static final TestIdentity MEGA_CORP = new TestIdentity(new CordaX500Name("MegaCorp", "London", "GB"));
-    private final Cash.State inState = new Cash.State(issuedBy(DOLLARS(1000), defaultIssuer), new AnonymousParty(getMEGA_CORP_PUBKEY()));
+    private static final TestIdentity MINI_CORP = new TestIdentity(new CordaX500Name("MiniCorp", "London", "GB"));
-    private final Cash.State outState = new Cash.State(inState.getAmount(), new AnonymousParty(getMINI_CORP_PUBKEY()));
+    private final PartyAndReference defaultIssuer = MEGA_CORP.ref((byte) 1);
+    private final Cash.State inState = new Cash.State(issuedBy(DOLLARS(1000), defaultIssuer), new AnonymousParty(MEGA_CORP.getPubkey()));
+    private final Cash.State outState = new Cash.State(inState.getAmount(), new AnonymousParty(MINI_CORP.getPubkey()));
     @Rule
     public final SerializationEnvironmentRule testSerialization = new SerializationEnvironmentRule();
 
     @Test
     public void trivial() {
         IdentityServiceInternal identityService = rigorousMock(IdentityServiceInternal.class);
-        doReturn(getMEGA_CORP()).when(identityService).partyFromKey(getMEGA_CORP_PUBKEY());
+        doReturn(MEGA_CORP.getParty()).when(identityService).partyFromKey(MEGA_CORP.getPubkey());
-        doReturn(getMINI_CORP()).when(identityService).partyFromKey(getMINI_CORP_PUBKEY());
+        doReturn(MINI_CORP.getParty()).when(identityService).partyFromKey(MINI_CORP.getPubkey());
-        transaction(new MockServices(identityService, getMEGA_CORP().getName()), getDUMMY_NOTARY(), tx -> {
+        transaction(new MockServices(identityService, MEGA_CORP.getName()), DUMMY_NOTARY, tx -> {
             tx.attachment(Cash.PROGRAM_ID);
 
             tx.input(Cash.PROGRAM_ID, inState);
 
             tx.tweak(tw -> {
-                tw.output(Cash.PROGRAM_ID, new Cash.State(issuedBy(DOLLARS(2000), defaultIssuer), new AnonymousParty(getMINI_CORP_PUBKEY())));
+                tw.output(Cash.PROGRAM_ID, new Cash.State(issuedBy(DOLLARS(2000), defaultIssuer), new AnonymousParty(MINI_CORP.getPubkey())));
-                tw.command(getMEGA_CORP_PUBKEY(), new Cash.Commands.Move());
+                tw.command(MEGA_CORP.getPubkey(), new Cash.Commands.Move());
                 return tw.failsWith("the amounts balance");
             });
 
             tx.tweak(tw -> {
                 tw.output(Cash.PROGRAM_ID, outState);
-                tw.command(getMEGA_CORP_PUBKEY(), DummyCommandData.INSTANCE);
+                tw.command(MEGA_CORP.getPubkey(), DummyCommandData.INSTANCE);
                 // Invalid command
                 return tw.failsWith("required net.corda.finance.contracts.asset.Cash.Commands.Move command");
             });
             tx.tweak(tw -> {
                 tw.output(Cash.PROGRAM_ID, outState);
-                tw.command(getMINI_CORP_PUBKEY(), new Cash.Commands.Move());
+                tw.command(MINI_CORP.getPubkey(), new Cash.Commands.Move());
                 return tw.failsWith("the owning keys are a subset of the signing keys");
             });
             tx.tweak(tw -> {
                 tw.output(Cash.PROGRAM_ID, outState);
                 // issuedBy() can't be directly imported because it conflicts with other identically named functions
                 // with different overloads (for some reason).
-                tw.output(Cash.PROGRAM_ID, outState.issuedBy(getMINI_CORP()));
+                tw.output(Cash.PROGRAM_ID, outState.issuedBy(MINI_CORP.getParty()));
-                tw.command(getMEGA_CORP_PUBKEY(), new Cash.Commands.Move());
+                tw.command(MEGA_CORP.getPubkey(), new Cash.Commands.Move());
                 return tw.failsWith("at least one cash input");
             });
 
             // Simple reallocation works.
             return tx.tweak(tw -> {
                 tw.output(Cash.PROGRAM_ID, outState);
-                tw.command(getMEGA_CORP_PUBKEY(), new Cash.Commands.Move());
+                tw.command(MEGA_CORP.getPubkey(), new Cash.Commands.Move());
                 return tw.verifies();
             });
         });

finance/src/test/kotlin/net/corda/finance/contracts/CommercialPaperTests.kt

@@ -3,7 +3,7 @@ package net.corda.finance.contracts
 import com.nhaarman.mockito_kotlin.doReturn
 import com.nhaarman.mockito_kotlin.whenever
 import net.corda.core.contracts.*
-import net.corda.core.crypto.entropyToKeyPair
+import net.corda.core.crypto.generateKeyPair
 import net.corda.core.identity.AnonymousParty
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.identity.Party
@@ -21,12 +21,13 @@ import net.corda.testing.*
 import net.corda.testing.contracts.VaultFiller
 import net.corda.testing.node.MockServices
 import net.corda.testing.node.MockServices.Companion.makeTestDatabaseAndMockServices
+import net.corda.testing.node.ledger
 import net.corda.testing.node.makeTestIdentityService
+import net.corda.testing.node.transaction
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.junit.runners.Parameterized
-import java.math.BigInteger
 import java.time.Instant
 import java.util.*
 import kotlin.test.assertFailsWith
@@ -42,6 +43,11 @@ interface ICommercialPaperTestTemplate {
     fun getContract(): ContractClassName
 }
 
+private val megaCorp = TestIdentity(CordaX500Name("MegaCorp", "London", "GB"))
+private val MEGA_CORP get() = megaCorp.party
+private val MEGA_CORP_IDENTITY get() = megaCorp.identity
+private val MEGA_CORP_PUBKEY get() = megaCorp.pubkey
+
 class JavaCommercialPaperTest : ICommercialPaperTestTemplate {
     override fun getPaper(): ICommercialPaperState = JavaCommercialPaper.State(
             MEGA_CORP.ref(123),
@@ -91,9 +97,21 @@ class CommercialPaperTestsGeneric {
         @JvmStatic
         fun data() = listOf(JavaCommercialPaperTest(), KotlinCommercialPaperTest(), KotlinCommercialPaperLegacyTest())
 
-        private val DUMMY_CASH_ISSUER_KEY = entropyToKeyPair(BigInteger.valueOf(10))
+        private val dummyCashIssuer = TestIdentity(CordaX500Name("Snake Oil Issuer", "London", "GB"), 10)
-        private val DUMMY_CASH_ISSUER_IDENTITY = getTestPartyAndCertificate(Party(CordaX500Name("Snake Oil Issuer", "London", "GB"), DUMMY_CASH_ISSUER_KEY.public))
+        private val DUMMY_CASH_ISSUER_IDENTITY get() = dummyCashIssuer.identity
-        private val DUMMY_CASH_ISSUER = DUMMY_CASH_ISSUER_IDENTITY.party.ref(1)
+        private val DUMMY_CASH_ISSUER = dummyCashIssuer.ref(1)
+        private val alice = TestIdentity(ALICE_NAME, 70)
+        private val BIG_CORP_KEY = generateKeyPair()
+        private val dummyNotary = TestIdentity(DUMMY_NOTARY_NAME, 20)
+        private val miniCorp = TestIdentity(CordaX500Name("MiniCorp", "London", "GB"))
+        private val ALICE get() = alice.party
+        private val ALICE_KEY get() = alice.key
+        private val ALICE_PUBKEY get() = alice.pubkey
+        private val DUMMY_NOTARY get() = dummyNotary.party
+        private val DUMMY_NOTARY_IDENTITY get() = dummyNotary.identity
+        private val MINI_CORP get() = miniCorp.party
+        private val MINI_CORP_IDENTITY get() = miniCorp.identity
+        private val MINI_CORP_PUBKEY get() = miniCorp.pubkey
     }
 
     @Parameterized.Parameter
@@ -242,8 +260,8 @@ class CommercialPaperTestsGeneric {
     private lateinit var aliceServices: MockServices
     private lateinit var aliceVaultService: VaultService
     private lateinit var alicesVault: Vault<ContractState>
-    private val notaryServices = MockServices(rigorousMock(), MEGA_CORP.name, DUMMY_NOTARY_KEY)
+    private val notaryServices = MockServices(rigorousMock(), MEGA_CORP.name, dummyNotary.key)
-    private val issuerServices = MockServices(listOf("net.corda.finance.contracts"), rigorousMock(), MEGA_CORP.name, DUMMY_CASH_ISSUER_KEY)
+    private val issuerServices = MockServices(listOf("net.corda.finance.contracts"), rigorousMock(), MEGA_CORP.name, dummyCashIssuer.key)
     private lateinit var moveTX: SignedTransaction
     @Test
     fun `issue move and then redeem`() {
@@ -257,7 +275,7 @@ class CommercialPaperTestsGeneric {
         aliceVaultService = aliceServices.vaultService
 
         databaseAlice.transaction {
-            alicesVault = VaultFiller(aliceServices, DUMMY_NOTARY, DUMMY_NOTARY_KEY, rngFactory = ::Random).fillWithSomeTestCash(9000.DOLLARS, issuerServices, 1, DUMMY_CASH_ISSUER)
+            alicesVault = VaultFiller(aliceServices, dummyNotary, rngFactory = ::Random).fillWithSomeTestCash(9000.DOLLARS, issuerServices, 1, DUMMY_CASH_ISSUER)
             aliceVaultService = aliceServices.vaultService
         }
         val bigCorpDatabaseAndServices = makeTestDatabaseAndMockServices(
@@ -270,7 +288,7 @@ class CommercialPaperTestsGeneric {
         bigCorpVaultService = bigCorpServices.vaultService
 
         databaseBigCorp.transaction {
-            bigCorpVault = VaultFiller(bigCorpServices, DUMMY_NOTARY, DUMMY_NOTARY_KEY, rngFactory = ::Random).fillWithSomeTestCash(13000.DOLLARS, issuerServices, 1, DUMMY_CASH_ISSUER)
+            bigCorpVault = VaultFiller(bigCorpServices, dummyNotary, rngFactory = ::Random).fillWithSomeTestCash(13000.DOLLARS, issuerServices, 1, DUMMY_CASH_ISSUER)
             bigCorpVaultService = bigCorpServices.vaultService
         }
 

finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt

@@ -3,7 +3,6 @@ package net.corda.finance.contracts.asset
 import com.nhaarman.mockito_kotlin.*
 import net.corda.core.contracts.*
 import net.corda.core.crypto.SecureHash
-import net.corda.core.crypto.entropyToKeyPair
 import net.corda.core.crypto.generateKeyPair
 import net.corda.core.identity.*
 import net.corda.core.node.ServiceHub
@@ -25,24 +24,46 @@ import net.corda.testing.contracts.DummyState
 import net.corda.testing.contracts.VaultFiller
 import net.corda.testing.node.MockServices
 import net.corda.testing.node.MockServices.Companion.makeTestDatabaseAndMockServices
+import net.corda.testing.node.ledger
 import net.corda.testing.node.makeTestIdentityService
+import net.corda.testing.node.transaction
 import org.junit.After
 import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
-import java.math.BigInteger
 import java.util.*
 import kotlin.test.*
 
 class CashTests {
-    companion object {
+    private companion object {
-        private val DUMMY_CASH_ISSUER_IDENTITY = getTestPartyAndCertificate(Party(CordaX500Name("Snake Oil Issuer", "London", "GB"), entropyToKeyPair(BigInteger.valueOf(10)).public))
+        val alice = TestIdentity(ALICE_NAME, 70)
+        val BOB_PUBKEY = TestIdentity(BOB_NAME, 80).pubkey
+        val charlie = TestIdentity(CHARLIE_NAME, 90)
+        val DUMMY_CASH_ISSUER_IDENTITY = TestIdentity(CordaX500Name("Snake Oil Issuer", "London", "GB"), 10).identity
+        val dummyNotary = TestIdentity(DUMMY_NOTARY_NAME, 20)
+        val megaCorp = TestIdentity(CordaX500Name("MegaCorp", "London", "GB"))
+        val miniCorp = TestIdentity(CordaX500Name("MiniCorp", "London", "GB"))
+        val ALICE get() = alice.party
+        val ALICE_PUBKEY get() = alice.pubkey
+        val CHARLIE get() = charlie.party
+        val CHARLIE_IDENTITY get() = charlie.identity
+        val DUMMY_NOTARY get() = dummyNotary.party
+        val DUMMY_NOTARY_IDENTITY get() = dummyNotary.identity
+        val DUMMY_NOTARY_KEY get() = dummyNotary.key
+        val MEGA_CORP get() = megaCorp.party
+        val MEGA_CORP_IDENTITY get() = megaCorp.identity
+        val MEGA_CORP_KEY get() = megaCorp.key
+        val MEGA_CORP_PUBKEY get() = megaCorp.pubkey
+        val MINI_CORP get() = miniCorp.party
+        val MINI_CORP_IDENTITY get() = miniCorp.identity
+        val MINI_CORP_KEY get() = miniCorp.key
+        val MINI_CORP_PUBKEY get() = miniCorp.pubkey
     }
 
     @Rule
     @JvmField
     val testSerialization = SerializationEnvironmentRule()
-    private val defaultRef = OpaqueBytes(ByteArray(1, { 1 }))
+    private val defaultRef = OpaqueBytes.of(1)
     private val defaultIssuer = MEGA_CORP.ref(defaultRef)
     private val inState = Cash.State(
             amount = 1000.DOLLARS `issued by` defaultIssuer,
@@ -94,7 +115,7 @@ class CashTests {
 
         // Create some cash. Any attempt to spend >$500 will require multiple issuers to be involved.
         database.transaction {
-            val vaultFiller = VaultFiller(ourServices, DUMMY_NOTARY, DUMMY_NOTARY_KEY, rngFactory = ::Random)
+            val vaultFiller = VaultFiller(ourServices, dummyNotary, rngFactory = ::Random)
             vaultFiller.fillWithSomeTestCash(100.DOLLARS, megaCorpServices, 1, MEGA_CORP.ref(1), ourIdentity)
             vaultFiller.fillWithSomeTestCash(400.DOLLARS, megaCorpServices, 1, MEGA_CORP.ref(1), ourIdentity)
             vaultFiller.fillWithSomeTestCash(80.DOLLARS, miniCorpServices, 1, MINI_CORP.ref(1), ourIdentity)

finance/src/test/kotlin/net/corda/finance/contracts/asset/ObligationTests.kt

@@ -5,12 +5,10 @@ import com.nhaarman.mockito_kotlin.whenever
 import net.corda.core.contracts.*
 import net.corda.core.crypto.NullKeys.NULL_PARTY
 import net.corda.core.crypto.SecureHash
-import net.corda.core.crypto.entropyToKeyPair
 import net.corda.core.crypto.sha256
 import net.corda.core.identity.AbstractParty
 import net.corda.core.identity.AnonymousParty
 import net.corda.core.identity.CordaX500Name
-import net.corda.core.identity.Party
 import net.corda.core.transactions.TransactionBuilder
 import net.corda.core.utilities.NonEmptySet
 import net.corda.core.utilities.OpaqueBytes
@@ -25,9 +23,10 @@ import net.corda.testing.*
 import net.corda.testing.contracts.DummyContract
 import net.corda.testing.contracts.DummyState
 import net.corda.testing.node.MockServices
+import net.corda.testing.node.ledger
+import net.corda.testing.node.transaction
 import org.junit.Rule
 import org.junit.Test
-import java.math.BigInteger
 import java.time.Instant
 import java.time.temporal.ChronoUnit
 import java.util.*
@@ -37,8 +36,23 @@ import kotlin.test.assertNotEquals
 import kotlin.test.assertTrue
 
 class ObligationTests {
-    companion object {
+    private companion object {
-        private val DUMMY_OBLIGATION_ISSUER = Party(CordaX500Name("Snake Oil Issuer", "London", "GB"), entropyToKeyPair(BigInteger.valueOf(10)).public)
+        val alice = TestIdentity(ALICE_NAME, 70)
+        val bob = TestIdentity(BOB_NAME, 80)
+        val CHARLIE = TestIdentity(CHARLIE_NAME, 90).party
+        val dummyNotary = TestIdentity(DUMMY_NOTARY_NAME, 20)
+        val DUMMY_OBLIGATION_ISSUER = TestIdentity(CordaX500Name("Snake Oil Issuer", "London", "GB"), 10).party
+        val megaCorp = TestIdentity(CordaX500Name("MegaCorp", "London", "GB"))
+        val miniCorp = TestIdentity(CordaX500Name("MiniCorp", "London", "GB"))
+        val ALICE get() = alice.party
+        val ALICE_PUBKEY get() = alice.pubkey
+        val BOB get() = bob.party
+        val BOB_PUBKEY get() = bob.pubkey
+        val DUMMY_NOTARY get() = dummyNotary.party
+        val MEGA_CORP get() = megaCorp.party
+        val MEGA_CORP_PUBKEY get() = megaCorp.pubkey
+        val MINI_CORP get() = miniCorp.party
+        val MINI_CORP_PUBKEY get() = miniCorp.pubkey
     }
 
     @Rule
@@ -62,8 +76,8 @@ class ObligationTests {
             beneficiary = CHARLIE
     )
     private val outState = inState.copy(beneficiary = AnonymousParty(BOB_PUBKEY))
-    private val miniCorpServices = MockServices(listOf("net.corda.finance.contracts.asset"), rigorousMock(), MINI_CORP.name, MINI_CORP_KEY)
+    private val miniCorpServices = MockServices(listOf("net.corda.finance.contracts.asset"), rigorousMock(), miniCorp)
-    private val notaryServices = MockServices(rigorousMock(), MEGA_CORP.name, DUMMY_NOTARY_KEY)
+    private val notaryServices = MockServices(rigorousMock(), MEGA_CORP.name, dummyNotary.key)
     private val identityService = rigorousMock<IdentityServiceInternal>().also {
         doReturn(null).whenever(it).partyFromKey(ALICE_PUBKEY)
         doReturn(null).whenever(it).partyFromKey(BOB_PUBKEY)

finance/src/test/kotlin/net/corda/finance/contracts/asset/cash/selection/CashSelectionH2ImplTest.kt

@@ -10,7 +10,7 @@ import net.corda.finance.flows.CashIssueFlow
 import net.corda.finance.flows.CashPaymentFlow
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.node.MockNodeParameters
-import net.corda.testing.startFlow
+import net.corda.testing.node.startFlow
 import org.assertj.core.api.Assertions.assertThatThrownBy
 import org.junit.After
 import org.junit.Test

finance/src/test/kotlin/net/corda/finance/flows/CashExitFlowTests.kt

@@ -11,7 +11,7 @@ import net.corda.testing.BOC_NAME
 import net.corda.testing.node.InMemoryMessagingNetwork.ServicePeerAllocationStrategy.RoundRobin
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.node.MockNetwork.MockNode
-import net.corda.testing.startFlow
+import net.corda.testing.node.startFlow
 import org.junit.After
 import org.junit.Before
 import org.junit.Test

finance/src/test/kotlin/net/corda/finance/flows/CashIssueFlowTests.kt

@@ -11,7 +11,7 @@ import net.corda.testing.BOC_NAME
 import net.corda.testing.node.InMemoryMessagingNetwork.ServicePeerAllocationStrategy.RoundRobin
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.node.MockNetwork.MockNode
-import net.corda.testing.startFlow
+import net.corda.testing.node.startFlow
 import org.junit.After
 import org.junit.Before
 import org.junit.Test

finance/src/test/kotlin/net/corda/finance/flows/CashPaymentFlowTests.kt

@@ -14,6 +14,7 @@ import net.corda.testing.*
 import net.corda.testing.node.InMemoryMessagingNetwork.ServicePeerAllocationStrategy.RoundRobin
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.node.MockNetwork.MockNode
+import net.corda.testing.node.startFlow
 import org.junit.After
 import org.junit.Before
 import org.junit.Test

node-api/src/test/kotlin/net/corda/nodeapi/internal/AttachmentsClassLoaderStaticContractTests.kt

@@ -4,6 +4,7 @@ import com.nhaarman.mockito_kotlin.doReturn
 import com.nhaarman.mockito_kotlin.whenever
 import net.corda.core.contracts.*
 import net.corda.core.identity.AbstractParty
+import net.corda.core.identity.CordaX500Name
 import net.corda.core.identity.Party
 import net.corda.core.node.ServicesForResolution
 import net.corda.core.serialization.deserialize
@@ -13,12 +14,17 @@ import net.corda.core.transactions.TransactionBuilder
 import net.corda.node.internal.cordapp.CordappLoader
 import net.corda.node.internal.cordapp.CordappProviderImpl
 import net.corda.testing.*
-import net.corda.testing.node.MockAttachmentStorage
+import net.corda.testing.services.MockAttachmentStorage
 import org.junit.Assert.*
 import org.junit.Rule
 import org.junit.Test
 
 class AttachmentsClassLoaderStaticContractTests {
+    private companion object {
+        val DUMMY_NOTARY = TestIdentity(DUMMY_NOTARY_NAME, 20).party
+        val MEGA_CORP = TestIdentity(CordaX500Name("MegaCorp", "London", "GB")).party
+    }
+
     @Rule
     @JvmField
     val testSerialization = SerializationEnvironmentRule()

node-api/src/test/kotlin/net/corda/nodeapi/internal/AttachmentsClassLoaderTests.kt

@@ -4,6 +4,7 @@ import com.nhaarman.mockito_kotlin.doReturn
 import com.nhaarman.mockito_kotlin.whenever
 import net.corda.core.contracts.*
 import net.corda.core.crypto.SecureHash
+import net.corda.core.identity.CordaX500Name
 import net.corda.core.internal.declaredField
 import net.corda.core.internal.toWireTransaction
 import net.corda.core.node.ServiceHub
@@ -18,7 +19,7 @@ import net.corda.nodeapi.internal.serialization.SerializeAsTokenContextImpl
 import net.corda.nodeapi.internal.serialization.attachmentsClassLoaderEnabledPropertyName
 import net.corda.nodeapi.internal.serialization.withTokenContext
 import net.corda.testing.*
-import net.corda.testing.node.MockAttachmentStorage
+import net.corda.testing.services.MockAttachmentStorage
 import org.apache.commons.io.IOUtils
 import org.junit.Assert.*
 import org.junit.Rule
@@ -35,7 +36,8 @@ class AttachmentsClassLoaderTests {
     companion object {
         val ISOLATED_CONTRACTS_JAR_PATH: URL = AttachmentsClassLoaderTests::class.java.getResource("isolated.jar")
         private const val ISOLATED_CONTRACT_CLASS_NAME = "net.corda.finance.contracts.isolated.AnotherDummyContract"
-
+        private val DUMMY_NOTARY = TestIdentity(DUMMY_NOTARY_NAME, 20).party
+        private val MEGA_CORP = TestIdentity(CordaX500Name("MegaCorp", "London", "GB")).party
         private fun SerializationContext.withAttachmentStorage(attachmentStorage: AttachmentStorage): SerializationContext {
             val serviceHub = rigorousMock<ServiceHub>()
             doReturn(attachmentStorage).whenever(serviceHub).attachments

node-api/src/test/kotlin/net/corda/nodeapi/internal/crypto/X509UtilitiesTest.kt

@@ -17,10 +17,7 @@ import net.corda.nodeapi.internal.serialization.AllWhitelist
 import net.corda.nodeapi.internal.serialization.SerializationContextImpl
 import net.corda.nodeapi.internal.serialization.SerializationFactoryImpl
 import net.corda.nodeapi.internal.serialization.kryo.KryoHeaderV0_1
-import net.corda.testing.ALICE
+import net.corda.testing.*
-import net.corda.testing.BOB
-import net.corda.testing.BOB_PUBKEY
-import net.corda.testing.MEGA_CORP
 import org.bouncycastle.asn1.x500.X500Name
 import org.bouncycastle.asn1.x509.BasicConstraints
 import org.bouncycastle.asn1.x509.Extension
@@ -49,6 +46,14 @@ import kotlin.concurrent.thread
 import kotlin.test.*
 
 class X509UtilitiesTest {
+    private companion object {
+        val ALICE = TestIdentity(ALICE_NAME, 70).party
+        val bob = TestIdentity(BOB_NAME, 80)
+        val MEGA_CORP = TestIdentity(CordaX500Name("MegaCorp", "London", "GB")).party
+        val BOB get() = bob.party
+        val BOB_PUBKEY get() = bob.pubkey
+    }
+
     @Rule
     @JvmField
     val tempFolder: TemporaryFolder = TemporaryFolder()

node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/ContractAttachmentSerializerTest.kt

@@ -1,6 +1,7 @@
 package net.corda.nodeapi.internal.serialization
 
 import net.corda.core.contracts.ContractAttachment
+import net.corda.core.identity.CordaX500Name
 import net.corda.core.serialization.*
 import net.corda.testing.*
 import net.corda.testing.contracts.DummyContract
@@ -22,7 +23,7 @@ class ContractAttachmentSerializerTest {
     private lateinit var factory: SerializationFactory
     private lateinit var context: SerializationContext
     private lateinit var contextWithToken: SerializationContext
-    private val mockServices = MockServices(rigorousMock(),  MEGA_CORP.name)
+    private val mockServices = MockServices(rigorousMock(), CordaX500Name("MegaCorp", "London", "GB"))
     @Before
     fun setup() {
         factory = testSerialization.env.serializationFactory

node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/CordaClassResolverTests.kt

@@ -12,7 +12,7 @@ import net.corda.nodeapi.internal.AttachmentsClassLoader
 import net.corda.nodeapi.internal.AttachmentsClassLoaderTests
 import net.corda.nodeapi.internal.serialization.kryo.CordaKryo
 import net.corda.nodeapi.internal.serialization.kryo.KryoHeaderV0_1
-import net.corda.testing.node.MockAttachmentStorage
+import net.corda.testing.services.MockAttachmentStorage
 import net.corda.testing.rigorousMock
 import org.junit.Rule
 import org.junit.Test

node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/KryoTests.kt

@@ -14,8 +14,9 @@ import net.corda.core.utilities.sequence
 import net.corda.node.serialization.KryoServerSerializationScheme
 import net.corda.node.services.persistence.NodeAttachmentService
 import net.corda.nodeapi.internal.serialization.kryo.KryoHeaderV0_1
-import net.corda.testing.ALICE_PUBKEY
+import net.corda.testing.ALICE_NAME
 import net.corda.testing.SerializationEnvironmentRule
+import net.corda.testing.TestIdentity
 import org.assertj.core.api.Assertions.assertThat
 import org.assertj.core.api.Assertions.assertThatThrownBy
 import org.junit.Before
@@ -31,6 +32,10 @@ import kotlin.test.assertNotNull
 import kotlin.test.assertTrue
 
 class KryoTests {
+    companion object {
+        private val ALICE_PUBKEY = TestIdentity(ALICE_NAME, 70).pubkey
+    }
+
     @Rule
     @JvmField
     val testSerialization = SerializationEnvironmentRule()

node-api/src/test/kotlin/net/corda/nodeapi/internal/serialization/amqp/SerializationOutputTests.kt

@@ -9,6 +9,7 @@ import net.corda.core.crypto.SecureHash
 import net.corda.core.crypto.secureRandomBytes
 import net.corda.core.flows.FlowException
 import net.corda.core.identity.AbstractParty
+import net.corda.core.identity.CordaX500Name
 import net.corda.core.internal.AbstractAttachment
 import net.corda.core.serialization.CordaSerializable
 import net.corda.core.serialization.MissingAttachmentsException
@@ -19,11 +20,8 @@ import net.corda.nodeapi.internal.serialization.AllWhitelist
 import net.corda.nodeapi.internal.serialization.EmptyWhitelist
 import net.corda.nodeapi.internal.serialization.GeneratedAttachment
 import net.corda.nodeapi.internal.serialization.amqp.SerializerFactory.Companion.isPrimitive
-import net.corda.testing.BOB_IDENTITY
+import net.corda.testing.*
-import net.corda.testing.MEGA_CORP
-import net.corda.testing.MEGA_CORP_PUBKEY
 import net.corda.testing.contracts.DummyContract
-import net.corda.testing.withTestSerialization
 import org.apache.activemq.artemis.api.core.SimpleString
 import org.apache.qpid.proton.amqp.*
 import org.apache.qpid.proton.codec.DecoderImpl
@@ -46,6 +44,16 @@ import kotlin.test.assertNotNull
 import kotlin.test.assertTrue
 
 class SerializationOutputTests {
+    private companion object {
+        val BOB_IDENTITY = TestIdentity(BOB_NAME, 80).identity
+        val megaCorp = TestIdentity(CordaX500Name("MegaCorp", "London", "GB"))
+        val miniCorp = TestIdentity(CordaX500Name("MiniCorp", "London", "GB"))
+        val MEGA_CORP get() = megaCorp.party
+        val MEGA_CORP_PUBKEY get() = megaCorp.pubkey
+        val MINI_CORP get() = miniCorp.party
+        val MINI_CORP_PUBKEY get() = miniCorp.pubkey
+    }
+
     data class Foo(val bar: String, val pub: Int)
 
     data class testFloat(val f: Float)

node/src/integration-test/kotlin/net/corda/node/BootTests.kt

@@ -11,6 +11,7 @@ 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
@@ -43,12 +44,12 @@ class BootTests : IntegrationTest() {
         val logConfigFile = projectRootDir / "config" / "dev" / "log4j2.xml"
         assertThat(logConfigFile).isRegularFile()
         driver(isDebug = true, systemProperties = mapOf("log4j.configurationFile" to logConfigFile.toString())) {
-            val alice = startNode(providedName = ALICE.name).get()
+            val alice = startNode(providedName = ALICE_NAME).get()
             val logFolder = alice.configuration.baseDirectory / NodeStartup.LOGS_DIRECTORY_NAME
             val logFile = logFolder.toFile().listFiles { _, name -> name.endsWith(".log") }.single()
             // Start second Alice, should fail
             assertThatThrownBy {
-                startNode(providedName = ALICE.name).getOrThrow()
+                startNode(providedName = ALICE_NAME).getOrThrow()
             }
             // We count the number of nodes that wrote into the logfile by counting "Logs can be found in"
             val numberOfNodesThatLogged = Files.lines(logFile.toPath()).filter { NodeStartup.LOGS_CAN_BE_FOUND_IN_STRING in it }.count()

node/src/integration-test/kotlin/net/corda/node/CordappScanningDriverTest.kt

@@ -13,6 +13,7 @@ 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
 import org.junit.ClassRule
@@ -30,8 +31,8 @@ class CordappScanningDriverTest : IntegrationTest() {
         // The driver will automatically pick up the annotated flows below
         driver {
             val (alice, bob) = listOf(
-                    startNode(providedName = ALICE.name, rpcUsers = listOf(user)),
+                    startNode(providedName = ALICE_NAME, rpcUsers = listOf(user)),
-                    startNode(providedName = BOB.name)).transpose().getOrThrow()
+                    startNode(providedName = BOB_NAME)).transpose().getOrThrow()
             val initiatedFlowClass = alice.rpcClientToNode()
                     .start(user.username, user.password)
                     .proxy

node/src/integration-test/kotlin/net/corda/node/NodePerformanceTests.kt

@@ -16,14 +16,15 @@ 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.internal.InternalDriverDSL
+import net.corda.testing.node.internal.InternalDriverDSL
 import net.corda.testing.internal.performance.div
-import net.corda.testing.internal.performance.startPublishingFixedRateInjector
+import net.corda.testing.node.internal.performance.startPublishingFixedRateInjector
-import net.corda.testing.internal.performance.startReporter
+import net.corda.testing.node.internal.performance.startReporter
-import net.corda.testing.internal.performance.startTightLoopInjector
+import net.corda.testing.node.internal.performance.startTightLoopInjector
 import net.corda.testing.node.NotarySpec
 import org.junit.Before
 import org.junit.ClassRule
@@ -128,7 +129,7 @@ class NodePerformanceTests : IntegrationTest() {
     fun `self pay rate`() {
         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)

node/src/integration-test/kotlin/net/corda/node/SSHServerTest.kt

@@ -11,19 +11,18 @@ 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.ALICE
 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.testing.ALICE_NAME
 import java.net.ConnectException
 import kotlin.test.assertTrue
 import kotlin.test.fail
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.ClassRule
 import java.util.regex.Pattern
-import kotlin.reflect.jvm.jvmName
 
 class SSHServerTest : IntegrationTest() {
     companion object {
@@ -35,8 +34,8 @@ class SSHServerTest : IntegrationTest() {
     fun `ssh server does not start be default`() {
         val user = User("u", "p", setOf())
         // The driver will automatically pick up the annotated flows below
-        driver() {
+        driver {
-            val node = startNode(providedName = ALICE.name, rpcUsers = listOf(user))
+            val node = startNode(providedName = ALICE_NAME, rpcUsers = listOf(user))
             node.getOrThrow()
 
             val session = JSch().getSession("u", "localhost", 2222)
@@ -57,7 +56,7 @@ class SSHServerTest : IntegrationTest() {
         val user = User("u", "p", setOf())
         // The driver will automatically pick up the annotated flows below
         driver {
-            val node = startNode(providedName = ALICE.name, rpcUsers = listOf(user),
+            val node = startNode(providedName = ALICE_NAME, rpcUsers = listOf(user),
                     customOverrides = mapOf("sshd" to mapOf("port" to 2222)))
             node.getOrThrow()
 
@@ -77,7 +76,7 @@ class SSHServerTest : IntegrationTest() {
         val user = User("u", "p", setOf())
         // The driver will automatically pick up the annotated flows below
         driver {
-            val node = startNode(providedName = ALICE.name, rpcUsers = listOf(user),
+            val node = startNode(providedName = ALICE_NAME, rpcUsers = listOf(user),
                     customOverrides = mapOf("sshd" to mapOf("port" to 2222)))
             node.getOrThrow()
 
@@ -100,7 +99,7 @@ class SSHServerTest : IntegrationTest() {
         val user = User("u", "p", setOf(startFlow<FlowICanRun>()))
         // The driver will automatically pick up the annotated flows below
         driver(isDebug = true) {
-            val node = startNode(providedName = ALICE.name, rpcUsers = listOf(user),
+            val node = startNode(providedName = ALICE_NAME, rpcUsers = listOf(user),
                     customOverrides = mapOf("sshd" to mapOf("port" to 2222)))
             node.getOrThrow()
 
@@ -112,7 +111,7 @@ class SSHServerTest : IntegrationTest() {
             assertTrue(session.isConnected)
 
             val channel = session.openChannel("exec") as ChannelExec
-            channel.setCommand("start FlowICannotRun otherParty: \"O=Alice Corp,L=Madrid,C=ES\"")
+            channel.setCommand("start FlowICannotRun otherParty: \"${ALICE_NAME}\"")
             channel.connect()
             val response = String(Streams.readAll(channel.inputStream))
 
@@ -130,7 +129,7 @@ class SSHServerTest : IntegrationTest() {
         val user = User("u", "p", setOf(startFlow<FlowICanRun>()))
         // The driver will automatically pick up the annotated flows below
         driver(isDebug = true) {
-            val node = startNode(providedName = ALICE.name, rpcUsers = listOf(user),
+            val node = startNode(providedName = ALICE_NAME, rpcUsers = listOf(user),
                     customOverrides = mapOf("sshd" to mapOf("port" to 2222)))
             node.getOrThrow()
 

node/src/integration-test/kotlin/net/corda/node/services/AttachmentLoadingTests.kt

@@ -24,7 +24,7 @@ import net.corda.testing.*
 import net.corda.testing.driver.DriverDSL
 import net.corda.testing.driver.NodeHandle
 import net.corda.testing.driver.driver
-import net.corda.testing.node.MockAttachmentStorage
+import net.corda.testing.services.MockAttachmentStorage
 import org.junit.Assert.assertEquals
 import org.junit.ClassRule
 import org.junit.Test
@@ -53,7 +53,8 @@ class AttachmentLoadingTests : IntegrationTest() {
         val flowInitiatorClass: Class<out FlowLogic<*>> =
                 Class.forName("net.corda.finance.contracts.isolated.IsolatedDummyFlow\$Initiator", true, URLClassLoader(arrayOf(isolatedJAR)))
                         .asSubclass(FlowLogic::class.java)
-
+        val DUMMY_BANK_A = TestIdentity(DUMMY_BANK_A_NAME, 40).party
+        val DUMMY_NOTARY = TestIdentity(DUMMY_NOTARY_NAME, 20).party
         private fun DriverDSL.createTwoNodes(): List<NodeHandle> {
             return listOf(
                     startNode(providedName = bankAName),

node/src/integration-test/kotlin/net/corda/node/services/BFTNotaryServiceTests.kt

@@ -33,6 +33,7 @@ import net.corda.testing.contracts.DummyContract
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.node.MockNetwork.MockNode
 import net.corda.testing.node.MockNodeParameters
+import net.corda.testing.node.startFlow
 import org.junit.After
 import org.junit.Before
 import org.junit.ClassRule

node/src/integration-test/kotlin/net/corda/node/services/DistributedServiceTests.kt

@@ -46,9 +46,9 @@ class DistributedServiceTests : IntegrationTest() {
 
         driver(
                 extraCordappPackagesToScan = listOf("net.corda.finance.contracts"),
-                notarySpecs = listOf(NotarySpec(DUMMY_NOTARY.name, rpcUsers = listOf(testUser), cluster = ClusterSpec.Raft(clusterSize = 3))))
+                notarySpecs = listOf(NotarySpec(DUMMY_NOTARY_NAME, rpcUsers = listOf(testUser), cluster = ClusterSpec.Raft(clusterSize = 3))))
         {
-            alice = startNode(providedName = ALICE.name, rpcUsers = listOf(testUser)).getOrThrow()
+            alice = startNode(providedName = ALICE_NAME, rpcUsers = listOf(testUser)).getOrThrow()
             raftNotaryIdentity = defaultNotaryIdentity
             notaryNodes = defaultNotaryHandle.nodeHandles.getOrThrow().map { it as NodeHandle.OutOfProcess }
 

node/src/integration-test/kotlin/net/corda/node/services/RaftNotaryServiceTests.kt

@@ -16,6 +16,8 @@ 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 org.junit.ClassRule
@@ -39,8 +41,7 @@ class RaftNotaryServiceTests : IntegrationTest() {
                 extraCordappPackagesToScan = listOf("net.corda.testing.contracts"),
                 notarySpecs = listOf(NotarySpec(notaryName, cluster = ClusterSpec.Raft(clusterSize = 3))))
         {
-            val bankA = startNode(providedName = DUMMY_BANK_A.name).map { (it as NodeHandle.InProcess).node }.getOrThrow()
+            val bankA = startNode(providedName = DUMMY_BANK_A_NAME).map { (it as NodeHandle.InProcess).node }.getOrThrow()
-
             val inputState = issueState(bankA, defaultNotaryIdentity)
 
             val firstTxBuilder = TransactionBuilder(defaultNotaryIdentity)

node/src/integration-test/kotlin/net/corda/node/services/UserAuthServiceTests.kt

@@ -16,7 +16,7 @@ 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.internal.NodeBasedTest
+import net.corda.testing.node.internal.NodeBasedTest
 import net.corda.testing.*
 import org.apache.activemq.artemis.api.core.ActiveMQSecurityException
 import org.junit.After

node/src/integration-test/kotlin/net/corda/node/services/network/NetworkMapTest.kt

@@ -2,12 +2,12 @@ package net.corda.node.services.network
 
 import net.corda.core.node.NodeInfo
 import net.corda.core.utilities.seconds
-import net.corda.testing.ALICE
+import net.corda.testing.node.internal.CompatibilityZoneParams
-import net.corda.testing.BOB
+import net.corda.testing.ALICE_NAME
-import net.corda.testing.internal.CompatibilityZoneParams
+import net.corda.testing.BOB_NAME
 import net.corda.testing.driver.NodeHandle
 import net.corda.testing.driver.PortAllocation
-import net.corda.testing.internal.internalDriver
+import net.corda.testing.node.internal.internalDriver
 import net.corda.testing.node.network.NetworkMapServer
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.After
@@ -37,9 +37,8 @@ class NetworkMapTest {
     @Test
     fun `nodes can see each other using the http network map`() {
         internalDriver(portAllocation = portAllocation, compatibilityZone = compatibilityZone) {
-            val alice = startNode(providedName = ALICE.name)
+            val alice = startNode(providedName = ALICE_NAME)
-            val bob = startNode(providedName = BOB.name)
+            val bob = startNode(providedName = BOB_NAME)
-
             val notaryNode = defaultNotaryNode.get()
             val aliceNode = alice.get()
             val bobNode = bob.get()
@@ -53,14 +52,13 @@ class NetworkMapTest {
     @Test
     fun `nodes process network map add updates correctly when adding new node to network map`() {
         internalDriver(portAllocation = portAllocation, compatibilityZone = compatibilityZone) {
-            val alice = startNode(providedName = ALICE.name)
+            val alice = startNode(providedName = ALICE_NAME)
             val notaryNode = defaultNotaryNode.get()
             val aliceNode = alice.get()
 
             notaryNode.onlySees(notaryNode.nodeInfo, aliceNode.nodeInfo)
             aliceNode.onlySees(notaryNode.nodeInfo, aliceNode.nodeInfo)
-
+            val bob = startNode(providedName = BOB_NAME)
-            val bob = startNode(providedName = BOB.name)
             val bobNode = bob.get()
 
             // Wait for network map client to poll for the next update.
@@ -75,9 +73,8 @@ class NetworkMapTest {
     @Test
     fun `nodes process network map remove updates correctly`() {
         internalDriver(portAllocation = portAllocation, compatibilityZone = compatibilityZone) {
-            val alice = startNode(providedName = ALICE.name)
+            val alice = startNode(providedName = ALICE_NAME)
-            val bob = startNode(providedName = BOB.name)
+            val bob = startNode(providedName = BOB_NAME)
-
             val notaryNode = defaultNotaryNode.get()
             val aliceNode = alice.get()
             val bobNode = bob.get()

node/src/integration-test/kotlin/net/corda/node/services/network/NodeInfoWatcherTest.kt

@@ -9,7 +9,6 @@ import net.corda.core.internal.div
 import net.corda.core.node.NodeInfo
 import net.corda.core.node.services.KeyManagementService
 import net.corda.core.serialization.serialize
-import net.corda.node.services.identity.InMemoryIdentityService
 import net.corda.nodeapi.internal.NodeInfoFilesCopier
 import net.corda.testing.*
 import net.corda.testing.node.MockKeyManagementService
@@ -28,8 +27,9 @@ import kotlin.test.assertEquals
 import kotlin.test.assertTrue
 
 class NodeInfoWatcherTest {
-    companion object {
+    private companion object {
-        val nodeInfo = NodeInfo(listOf(), listOf(getTestPartyAndCertificate(ALICE)), 0, 0)
+        val alice = TestIdentity(ALICE_NAME, 70)
+        val nodeInfo = NodeInfo(listOf(), listOf(alice.identity), 0, 0)
     }
 
     @Rule
@@ -49,7 +49,7 @@ class NodeInfoWatcherTest {
     @Before
     fun start() {
         val identityService = makeTestIdentityService()
-        keyManagementService = MockKeyManagementService(identityService, ALICE_KEY)
+        keyManagementService = MockKeyManagementService(identityService, alice.key)
         nodeInfoWatcher = NodeInfoWatcher(tempFolder.root.toPath(), scheduler)
         nodeInfoPath = tempFolder.root.toPath() / CordformNode.NODE_INFO_DIRECTORY
     }

node/src/integration-test/kotlin/net/corda/node/services/network/PersistentNetworkMapCacheTest.kt

@@ -8,6 +8,11 @@ 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
 import org.junit.Test
@@ -15,6 +20,10 @@ import kotlin.test.assertEquals
 
 class PersistentNetworkMapCacheTest : NodeBasedTest() {
     companion object {
+        val ALICE = TestIdentity(ALICE_NAME, 70).party
+        val BOB = TestIdentity(BOB_NAME, 80).party
+        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())
     }

node/src/integration-test/kotlin/net/corda/node/services/statemachine/FlowVersioningTest.kt

@@ -7,6 +7,10 @@ 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.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
@@ -21,8 +25,8 @@ class FlowVersioningTest : NodeBasedTest() {
 
     @Test
     fun `getFlowContext returns the platform version for core flows`() {
-        val alice = startNode(ALICE.name, platformVersion = 2)
+        val alice = startNode(ALICE_NAME, platformVersion = 2)
-        val bob = startNode(BOB.name, platformVersion = 3)
+        val bob = startNode(BOB_NAME, platformVersion = 3)
         bob.internals.installCoreFlow(PretendInitiatingCoreFlow::class, ::PretendInitiatedCoreFlow)
         val (alicePlatformVersionAccordingToBob, bobPlatformVersionAccordingToAlice) = alice.services.startFlow(
                 PretendInitiatingCoreFlow(bob.info.chooseIdentity())).resultFuture.getOrThrow()

node/src/integration-test/kotlin/net/corda/node/services/statemachine/LargeTransactionsTest.kt

@@ -23,6 +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
+        }
         @ClassRule @JvmField
         val databaseSchemas = IntegrationTestSchemas(*listOf(ALICE, BOB, DUMMY_NOTARY).map { it.toDatabaseSchemaName() }.toTypedArray())
     }

node/src/integration-test/kotlin/net/corda/node/utilities/registration/NodeRegistrationTest.kt

@@ -1,6 +1,5 @@
 package net.corda.node.utilities.registration
 
-import com.google.common.net.HostAndPort
 import net.corda.core.crypto.Crypto
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.internal.cert
@@ -15,9 +14,9 @@ import net.corda.nodeapi.internal.crypto.X509Utilities
 import net.corda.nodeapi.internal.crypto.X509Utilities.CORDA_CLIENT_CA
 import net.corda.nodeapi.internal.crypto.X509Utilities.CORDA_INTERMEDIATE_CA
 import net.corda.nodeapi.internal.crypto.X509Utilities.CORDA_ROOT_CA
-import net.corda.testing.internal.CompatibilityZoneParams
+import net.corda.testing.node.internal.CompatibilityZoneParams
 import net.corda.testing.driver.PortAllocation
-import net.corda.testing.internal.internalDriver
+import net.corda.testing.node.internal.internalDriver
 import net.corda.testing.node.network.NetworkMapServer
 import org.assertj.core.api.Assertions.assertThat
 import org.assertj.core.api.Assertions.assertThatThrownBy

node/src/integration-test/kotlin/net/corda/services/messaging/MQSecurityAsNodeTest.kt

@@ -1,14 +1,13 @@
 package net.corda.services.messaging
 
 import net.corda.core.crypto.Crypto
+import net.corda.core.identity.CordaX500Name
 import net.corda.core.internal.*
 import net.corda.nodeapi.internal.ArtemisMessagingComponent.Companion.NODE_USER
 import net.corda.nodeapi.internal.ArtemisMessagingComponent.Companion.PEER_USER
 import net.corda.nodeapi.RPCApi
 import net.corda.nodeapi.internal.config.SSLConfiguration
 import net.corda.nodeapi.internal.crypto.*
-import net.corda.testing.MEGA_CORP
-import net.corda.testing.MINI_CORP
 import net.corda.testing.messaging.SimpleMQClient
 import org.apache.activemq.artemis.api.config.ActiveMQDefaultConfiguration
 import org.apache.activemq.artemis.api.core.ActiveMQClusterSecurityException
@@ -86,7 +85,7 @@ class MQSecurityAsNodeTest : MQSecurityTest() {
             override val trustStorePassword: String get() = "trustpass"
 
             init {
-                val legalName = MEGA_CORP.name
+                val legalName = CordaX500Name("MegaCorp", "London", "GB")
                 certificatesDirectory.createDirectories()
                 if (!trustStoreFile.exists()) {
                     javaClass.classLoader.getResourceAsStream("certificates/cordatruststore.jks").copyTo(trustStoreFile)
@@ -106,7 +105,7 @@ class MQSecurityAsNodeTest : MQSecurityTest() {
                         intermediateCA.keyPair, legalName, clientKey.public, nameConstraints = nameConstraints)
                 val tlsKey = Crypto.generateKeyPair(X509Utilities.DEFAULT_TLS_SIGNATURE_SCHEME)
                 // Using different x500 name in the TLS cert which is not allowed in the name constraints.
-                val clientTLSCert = X509Utilities.createCertificate(CertificateType.TLS, clientCACert, clientKey, MINI_CORP.name, tlsKey.public)
+                val clientTLSCert = X509Utilities.createCertificate(CertificateType.TLS, clientCACert, clientKey, CordaX500Name("MiniCorp", "London", "GB"), tlsKey.public)
                 val keyPass = keyStorePassword.toCharArray()
                 val clientCAKeystore = loadOrCreateKeyStore(nodeKeystore, keyStorePassword)
                 clientCAKeystore.addOrReplaceKey(

node/src/integration-test/kotlin/net/corda/services/messaging/MQSecurityTest.kt

@@ -9,6 +9,7 @@ import net.corda.core.flows.FlowLogic
 import net.corda.core.flows.FlowSession
 import net.corda.core.flows.InitiatedBy
 import net.corda.core.flows.InitiatingFlow
+import net.corda.core.identity.CordaX500Name
 import net.corda.core.identity.Party
 import net.corda.core.messaging.CordaRPCOps
 import net.corda.core.utilities.NetworkHostAndPort
@@ -25,8 +26,9 @@ import net.corda.nodeapi.RPCApi
 import net.corda.nodeapi.internal.config.User
 import net.corda.nodeapi.internal.config.SSLConfiguration
 import net.corda.testing.*
-import net.corda.testing.internal.NodeBasedTest
+import net.corda.testing.node.internal.NodeBasedTest
 import net.corda.testing.messaging.SimpleMQClient
+import net.corda.testing.node.startFlow
 import org.apache.activemq.artemis.api.core.ActiveMQNonExistentQueueException
 import org.apache.activemq.artemis.api.core.ActiveMQSecurityException
 import org.apache.activemq.artemis.api.core.SimpleString
@@ -53,7 +55,7 @@ abstract class MQSecurityTest : NodeBasedTest() {
     override fun setUp() {
         super.init()
         super.setUp()
-        alice = startNode(ALICE.name, rpcUsers = extraRPCUsers + rpcUser)
+        alice = startNode(ALICE_NAME, rpcUsers = extraRPCUsers + rpcUser)
         attacker = createAttacker()
         startAttacker(attacker)
     }
@@ -89,7 +91,7 @@ abstract class MQSecurityTest : NodeBasedTest() {
 
     @Test
     fun `create queue for peer which has not been communicated with`() {
-        val bob = startNode(BOB.name)
+        val bob = startNode(BOB_NAME)
         assertAllQueueCreationAttacksFail("$PEERS_PREFIX${bob.info.chooseIdentity().owningKey.toBase58String()}")
     }
 
@@ -139,7 +141,7 @@ abstract class MQSecurityTest : NodeBasedTest() {
         assertAllQueueCreationAttacksFail(randomQueue)
     }
 
-    fun clientTo(target: NetworkHostAndPort, sslConfiguration: SSLConfiguration? = configureTestSSL()): SimpleMQClient {
+    fun clientTo(target: NetworkHostAndPort, sslConfiguration: SSLConfiguration? = configureTestSSL(CordaX500Name("MegaCorp", "London", "GB"))): SimpleMQClient {
         val client = SimpleMQClient(target, sslConfiguration)
         clients += client
         return client
@@ -212,7 +214,7 @@ abstract class MQSecurityTest : NodeBasedTest() {
     }
 
     private fun startBobAndCommunicateWithAlice(): Party {
-        val bob = startNode(BOB.name)
+        val bob = startNode(BOB_NAME)
         bob.registerInitiatedFlow(ReceiveFlow::class.java)
         val bobParty = bob.info.chooseIdentity()
         // Perform a protocol exchange to force the peer queue to be created

node/src/integration-test/kotlin/net/corda/services/messaging/P2PMessagingTest.kt

@@ -19,6 +19,8 @@ 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
@@ -120,7 +122,7 @@ class P2PMessagingTest : IntegrationTest() {
     }
 
     private fun DriverDSL.startAlice(): StartedNode<Node> {
-        return startNode(providedName = ALICE.name, customOverrides = mapOf("messageRedeliveryDelaySeconds" to 1))
+        return startNode(providedName = ALICE_NAME, customOverrides = mapOf("messageRedeliveryDelaySeconds" to 1))
                 .map { (it as NodeHandle.InProcess).node }
                 .getOrThrow()
     }

node/src/test/java/net/corda/node/services/vault/VaultQueryJavaTests.java

@@ -8,7 +8,6 @@ import net.corda.core.crypto.CryptoUtils;
 import net.corda.core.identity.AbstractParty;
 import net.corda.core.identity.CordaX500Name;
 import net.corda.core.identity.Party;
-import net.corda.core.identity.PartyAndCertificate;
 import net.corda.core.messaging.DataFeed;
 import net.corda.core.node.services.Vault;
 import net.corda.core.node.services.VaultQueryException;
@@ -17,7 +16,6 @@ import net.corda.core.node.services.vault.*;
 import net.corda.core.node.services.vault.QueryCriteria.LinearStateQueryCriteria;
 import net.corda.core.node.services.vault.QueryCriteria.VaultCustomQueryCriteria;
 import net.corda.core.node.services.vault.QueryCriteria.VaultQueryCriteria;
-import net.corda.core.utilities.OpaqueBytes;
 import net.corda.finance.contracts.DealState;
 import net.corda.finance.contracts.asset.Cash;
 import net.corda.finance.schemas.CashSchemaV1;
@@ -25,6 +23,7 @@ import net.corda.node.services.api.IdentityServiceInternal;
 import net.corda.nodeapi.internal.persistence.CordaPersistence;
 import net.corda.nodeapi.internal.persistence.DatabaseTransaction;
 import net.corda.testing.SerializationEnvironmentRule;
+import net.corda.testing.TestIdentity;
 import net.corda.testing.contracts.DummyLinearContract;
 import net.corda.testing.contracts.VaultFiller;
 import net.corda.testing.node.MockServices;
@@ -36,30 +35,31 @@ import rx.Observable;
 
 import java.io.IOException;
 import java.lang.reflect.Field;
-import java.math.BigInteger;
 import java.security.InvalidAlgorithmParameterException;
-import java.security.KeyPair;
 import java.security.cert.CertificateException;
 import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 
-import static net.corda.core.crypto.CryptoUtils.entropyToKeyPair;
 import static net.corda.core.node.services.vault.QueryCriteriaUtils.DEFAULT_PAGE_NUM;
 import static net.corda.core.node.services.vault.QueryCriteriaUtils.MAX_PAGE_SIZE;
 import static net.corda.core.utilities.ByteArrays.toHexString;
-import static net.corda.testing.CoreTestUtils.*;
+import static net.corda.testing.CoreTestUtils.rigorousMock;
-import static net.corda.testing.TestConstants.*;
+import static net.corda.testing.TestConstants.getBOC_NAME;
+import static net.corda.testing.TestConstants.getCHARLIE_NAME;
+import static net.corda.testing.TestConstants.getDUMMY_NOTARY_NAME;
 import static net.corda.testing.node.MockServices.makeTestDatabaseAndMockServices;
 import static net.corda.testing.node.MockServicesKt.makeTestIdentityService;
 import static org.assertj.core.api.Assertions.assertThat;
 
 public class VaultQueryJavaTests {
-    private static final CordaX500Name DUMMY_CASH_ISSUER_NAME = new CordaX500Name("Snake Oil Issuer", "London", "GB");
+    private static final TestIdentity BOC = new TestIdentity(getBOC_NAME());
-    private static final KeyPair DUMMY_CASH_ISSUER_KEY = entropyToKeyPair(BigInteger.valueOf(10));
+    private static final Party CHARLIE = new TestIdentity(getCHARLIE_NAME(), 90L).getParty();
-    private static final PartyAndCertificate DUMMY_CASH_ISSUER_IDENTITY = getTestPartyAndCertificate(new Party(DUMMY_CASH_ISSUER_NAME, DUMMY_CASH_ISSUER_KEY.getPublic()));
+    private static final TestIdentity DUMMY_CASH_ISSUER_INFO = new TestIdentity(new CordaX500Name("Snake Oil Issuer", "London", "GB"), 10L);
-    private static final PartyAndReference DUMMY_CASH_ISSUER = DUMMY_CASH_ISSUER_IDENTITY.getParty().ref((byte) 1);
+    private static final PartyAndReference DUMMY_CASH_ISSUER = DUMMY_CASH_ISSUER_INFO.ref((byte) 1);
+    private static final TestIdentity DUMMY_NOTARY = new TestIdentity(getDUMMY_NOTARY_NAME(), 20L);
+    private static final TestIdentity MEGA_CORP = new TestIdentity(new CordaX500Name("MegaCorp", "London", "GB"));
     @Rule
     public final SerializationEnvironmentRule testSerialization = new SerializationEnvironmentRule();
     private VaultFiller vaultFiller;
@@ -70,16 +70,16 @@ public class VaultQueryJavaTests {
     @Before
     public void setUp() throws CertificateException, InvalidAlgorithmParameterException {
         List<String> cordappPackages = Arrays.asList("net.corda.testing.contracts", "net.corda.finance.contracts.asset", CashSchemaV1.class.getPackage().getName());
-        IdentityServiceInternal identitySvc = makeTestIdentityService(Arrays.asList(getMEGA_CORP_IDENTITY(), DUMMY_CASH_ISSUER_IDENTITY, getDUMMY_NOTARY_IDENTITY()));
+        IdentityServiceInternal identitySvc = makeTestIdentityService(Arrays.asList(MEGA_CORP.getIdentity(), DUMMY_CASH_ISSUER_INFO.getIdentity(), DUMMY_NOTARY.getIdentity()));
         Pair<CordaPersistence, MockServices> databaseAndServices = makeTestDatabaseAndMockServices(
-                Arrays.asList(getMEGA_CORP_KEY(), getDUMMY_NOTARY_KEY()),
+                Arrays.asList(MEGA_CORP.getKey(), DUMMY_NOTARY.getKey()),
                 identitySvc,
                 cordappPackages,
-                getMEGA_CORP().getName());
+                MEGA_CORP.getName());
-        issuerServices = new MockServices(cordappPackages, rigorousMock(IdentityServiceInternal.class), DUMMY_CASH_ISSUER_NAME, DUMMY_CASH_ISSUER_KEY, getBOC_KEY());
+        issuerServices = new MockServices(cordappPackages, rigorousMock(IdentityServiceInternal.class), DUMMY_CASH_ISSUER_INFO, BOC.getKey());
         database = databaseAndServices.getFirst();
         MockServices services = databaseAndServices.getSecond();
-        vaultFiller = new VaultFiller(services, getDUMMY_NOTARY(), getDUMMY_NOTARY_KEY());
+        vaultFiller = new VaultFiller(services, DUMMY_NOTARY);
         vaultService = services.getVaultService();
     }
 
@@ -153,7 +153,7 @@ public class VaultQueryJavaTests {
             return tx;
         });
         database.transaction(tx -> {
-            vaultFiller.consumeCash(amount, getCHARLIE());
+            vaultFiller.consumeCash(amount, CHARLIE);
             return tx;
         });
         database.transaction(tx -> {
@@ -306,7 +306,7 @@ public class VaultQueryJavaTests {
             QueryCriteria vaultCriteria = new VaultQueryCriteria(Vault.StateStatus.UNCONSUMED, contractStateTypes);
 
             List<UniqueIdentifier> linearIds = Collections.singletonList(uid);
-            List<AbstractParty> dealParty = Collections.singletonList(getMEGA_CORP());
+            List<AbstractParty> dealParty = Collections.singletonList(MEGA_CORP.getParty());
             QueryCriteria dealCriteria = new LinearStateQueryCriteria(dealParty, null, dealIds);
             QueryCriteria linearCriteria = new LinearStateQueryCriteria(dealParty, linearIds, Vault.StateStatus.UNCONSUMED, null);
             QueryCriteria dealOrLinearIdCriteria = dealCriteria.or(linearCriteria);
@@ -448,9 +448,9 @@ public class VaultQueryJavaTests {
             Amount<Currency> pounds300 = new Amount<>(300, Currency.getInstance("GBP"));
             Amount<Currency> pounds400 = new Amount<>(400, Currency.getInstance("GBP"));
             vaultFiller.fillWithSomeTestCash(dollars100, issuerServices, 1, DUMMY_CASH_ISSUER);
-            vaultFiller.fillWithSomeTestCash(dollars200, issuerServices, 2, getBOC().ref(new OpaqueBytes("1".getBytes())));
+            vaultFiller.fillWithSomeTestCash(dollars200, issuerServices, 2, BOC.ref((byte) '1'));
             vaultFiller.fillWithSomeTestCash(pounds300, issuerServices, 3, DUMMY_CASH_ISSUER);
-            vaultFiller.fillWithSomeTestCash(pounds400, issuerServices, 4, getBOC().ref(new OpaqueBytes("1".getBytes())));
+            vaultFiller.fillWithSomeTestCash(pounds400, issuerServices, 4, BOC.ref((byte) '1'));
             return tx;
         });
         database.transaction(tx -> {
@@ -466,16 +466,16 @@ public class VaultQueryJavaTests {
                 assertThat(results.getOtherResults()).hasSize(12);
 
                 assertThat(results.getOtherResults().get(0)).isEqualTo(400L);
-                assertThat(results.getOtherResults().get(1)).isEqualTo(CryptoUtils.toStringShort(getBOC_PUBKEY()));
+                assertThat(results.getOtherResults().get(1)).isEqualTo(CryptoUtils.toStringShort(BOC.getPubkey()));
                 assertThat(results.getOtherResults().get(2)).isEqualTo("GBP");
                 assertThat(results.getOtherResults().get(3)).isEqualTo(300L);
-                assertThat(results.getOtherResults().get(4)).isEqualTo(CryptoUtils.toStringShort(DUMMY_CASH_ISSUER_KEY.getPublic()));
+                assertThat(results.getOtherResults().get(4)).isEqualTo(CryptoUtils.toStringShort(DUMMY_CASH_ISSUER_INFO.getPubkey()));
                 assertThat(results.getOtherResults().get(5)).isEqualTo("GBP");
                 assertThat(results.getOtherResults().get(6)).isEqualTo(200L);
-                assertThat(results.getOtherResults().get(7)).isEqualTo(CryptoUtils.toStringShort(getBOC_PUBKEY()));
+                assertThat(results.getOtherResults().get(7)).isEqualTo(CryptoUtils.toStringShort(BOC.getPubkey()));
                 assertThat(results.getOtherResults().get(8)).isEqualTo("USD");
                 assertThat(results.getOtherResults().get(9)).isEqualTo(100L);
-                assertThat(results.getOtherResults().get(10)).isEqualTo(CryptoUtils.toStringShort(DUMMY_CASH_ISSUER_KEY.getPublic()));
+                assertThat(results.getOtherResults().get(10)).isEqualTo(CryptoUtils.toStringShort(DUMMY_CASH_ISSUER_INFO.getPubkey()));
                 assertThat(results.getOtherResults().get(11)).isEqualTo("USD");
 
             } catch (NoSuchFieldException e) {

node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt

@@ -37,6 +37,7 @@ import net.corda.testing.*
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.node.MockNetwork.MockNode
 import net.corda.testing.node.MockNodeParameters
+import net.corda.testing.node.testActor
 import org.apache.commons.io.IOUtils
 import org.assertj.core.api.Assertions.assertThatExceptionOfType
 import org.junit.After

node/src/test/kotlin/net/corda/node/InteractiveShellTest.kt

@@ -6,6 +6,7 @@ import net.corda.core.contracts.Amount
 import net.corda.core.crypto.SecureHash
 import net.corda.core.flows.FlowLogic
 import net.corda.core.flows.StateMachineRunId
+import net.corda.core.identity.CordaX500Name
 import net.corda.core.identity.Party
 import net.corda.core.internal.concurrent.openFuture
 import net.corda.core.messaging.FlowProgressHandleImpl
@@ -13,8 +14,7 @@ import net.corda.core.utilities.ProgressTracker
 import net.corda.nodeapi.internal.persistence.DatabaseConfig
 import net.corda.node.shell.InteractiveShell
 import net.corda.node.internal.configureDatabase
-import net.corda.testing.MEGA_CORP
+import net.corda.testing.TestIdentity
-import net.corda.testing.MEGA_CORP_IDENTITY
 import net.corda.testing.node.MockServices
 import net.corda.testing.node.makeTestIdentityService
 import net.corda.testing.rigorousMock
@@ -26,6 +26,10 @@ import java.util.*
 import kotlin.test.assertEquals
 
 class InteractiveShellTest {
+    companion object {
+        private val megaCorp = TestIdentity(CordaX500Name("MegaCorp", "London", "GB"))
+    }
+
     @Before
     fun setup() {
         InteractiveShell.database = configureDatabase(MockServices.makeTestDataSourceProperties(), DatabaseConfig(), rigorousMock())
@@ -48,7 +52,7 @@ class InteractiveShellTest {
         override fun call() = a
     }
 
-    private val ids = makeTestIdentityService(listOf(MEGA_CORP_IDENTITY))
+    private val ids = makeTestIdentityService(listOf(megaCorp.identity))
     private val om = JacksonSupport.createInMemoryMapper(ids, YAMLFactory())
 
     private fun check(input: String, expected: String) {
@@ -90,5 +94,5 @@ class InteractiveShellTest {
     fun flowTooManyParams() = check("b: 12, c: Yo, d: Bar", "")
 
     @Test
-    fun party() = check("party: \"${MEGA_CORP.name}\"", MEGA_CORP.name.toString())
+    fun party() = check("party: \"${megaCorp.name}\"", megaCorp.name.toString())
 }

node/src/test/kotlin/net/corda/node/internal/cordapp/CordappProviderImplTests.kt

@@ -1,7 +1,7 @@
 package net.corda.node.internal.cordapp
 
 import net.corda.core.node.services.AttachmentStorage
-import net.corda.testing.node.MockAttachmentStorage
+import net.corda.testing.services.MockAttachmentStorage
 import org.junit.Assert
 import org.junit.Before
 import org.junit.Test

node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt

@@ -72,6 +72,10 @@ class TwoPartyTradeFlowTests(private val anonymous: Boolean) {
         @JvmStatic
         @Parameterized.Parameters(name = "Anonymous = {0}")
         fun data(): Collection<Boolean> = listOf(true, false)
+
+        private val dummyNotary = TestIdentity(DUMMY_NOTARY_NAME, 20)
+        private val MEGA_CORP = TestIdentity(CordaX500Name("MegaCorp", "London", "GB")).party
+        private val DUMMY_NOTARY get() = dummyNotary.party
     }
 
     private lateinit var mockNet: MockNetwork
@@ -111,7 +115,7 @@ class TwoPartyTradeFlowTests(private val anonymous: Boolean) {
             bobNode.internals.disableDBCloseOnStop()
 
             bobNode.database.transaction {
-                VaultFiller(bobNode.services, DUMMY_NOTARY, DUMMY_NOTARY_KEY, notary, ::Random).fillWithSomeTestCash(2000.DOLLARS, bankNode.services, 3, 10, cashIssuer)
+                VaultFiller(bobNode.services, dummyNotary, notary, ::Random).fillWithSomeTestCash(2000.DOLLARS, bankNode.services, 3, 10, cashIssuer)
             }
 
             val alicesFakePaper = aliceNode.database.transaction {
@@ -162,7 +166,7 @@ class TwoPartyTradeFlowTests(private val anonymous: Boolean) {
             bobNode.internals.disableDBCloseOnStop()
 
             val cashStates = bobNode.database.transaction {
-                VaultFiller(bobNode.services, DUMMY_NOTARY, DUMMY_NOTARY_KEY, notary, ::Random).fillWithSomeTestCash(2000.DOLLARS, bankNode.services, 3, issuer)
+                VaultFiller(bobNode.services, dummyNotary, notary, ::Random).fillWithSomeTestCash(2000.DOLLARS, bankNode.services, 3, issuer)
             }
 
             val alicesFakePaper = aliceNode.database.transaction {
@@ -223,7 +227,7 @@ class TwoPartyTradeFlowTests(private val anonymous: Boolean) {
             val issuer = bank.ref(1, 2, 3)
 
             bobNode.database.transaction {
-                VaultFiller(bobNode.services, DUMMY_NOTARY, DUMMY_NOTARY_KEY, notary, ::Random).fillWithSomeTestCash(2000.DOLLARS, bankNode.services, 3, 10, issuer)
+                VaultFiller(bobNode.services, dummyNotary, notary, ::Random).fillWithSomeTestCash(2000.DOLLARS, bankNode.services, 3, 10, issuer)
             }
             val alicesFakePaper = aliceNode.database.transaction {
                 fillUpForSeller(false, issuer, alice,

node/src/test/kotlin/net/corda/node/services/NotaryChangeTests.kt

@@ -18,6 +18,7 @@ import net.corda.testing.contracts.DummyContract
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.node.MockNetwork.NotarySpec
 import net.corda.testing.node.MockNodeParameters
+import net.corda.testing.node.startFlow
 import org.assertj.core.api.Assertions.assertThatExceptionOfType
 import org.junit.After
 import org.junit.Before
@@ -38,16 +39,16 @@ class NotaryChangeTests {
 
     @Before
     fun setUp() {
-        val oldNotaryName = DUMMY_REGULATOR.name
+        val oldNotaryName = CordaX500Name("Regulator A", "Paris", "FR")
         mockNet = MockNetwork(
-                notarySpecs = listOf(NotarySpec(DUMMY_NOTARY.name), NotarySpec(oldNotaryName)),
+                notarySpecs = listOf(NotarySpec(DUMMY_NOTARY_NAME), NotarySpec(oldNotaryName)),
                 cordappPackages = listOf("net.corda.testing.contracts")
         )
         clientNodeA = mockNet.createNode(MockNodeParameters(legalName = ALICE_NAME))
         clientNodeB = mockNet.createNode(MockNodeParameters(legalName = BOB_NAME))
         clientA = clientNodeA.info.singleIdentity()
         oldNotaryNode = mockNet.notaryNodes[1]
-        newNotaryParty = clientNodeA.services.networkMapCache.getNotary(DUMMY_NOTARY.name)!!
+        newNotaryParty = clientNodeA.services.networkMapCache.getNotary(DUMMY_NOTARY_NAME)!!
         oldNotaryParty = clientNodeA.services.networkMapCache.getNotary(oldNotaryName)!!
     }
 

node/src/test/kotlin/net/corda/node/services/config/NodeConfigurationImplTest.kt

@@ -1,8 +1,7 @@
 package net.corda.node.services.config
 
 import net.corda.core.utilities.NetworkHostAndPort
-import net.corda.nodeapi.internal.persistence.DatabaseConfig
+import net.corda.testing.ALICE_NAME
-import net.corda.testing.ALICE
 import net.corda.testing.node.MockServices.Companion.makeTestDataSourceProperties
 import org.assertj.core.api.Assertions.assertThatThrownBy
 import org.junit.Test
@@ -34,11 +33,11 @@ class NodeConfigurationImplTest {
 
     private val testConfiguration = NodeConfigurationImpl(
             baseDirectory = Paths.get("."),
-            myLegalName = ALICE.name,
+            myLegalName = ALICE_NAME,
             emailAddress = "",
             keyStorePassword = "cordacadevpass",
             trustStorePassword = "trustpass",
-            dataSourceProperties = makeTestDataSourceProperties(ALICE.name.organisation),
+            dataSourceProperties = makeTestDataSourceProperties(ALICE_NAME.organisation),
             rpcUsers = emptyList(),
             verifierType = VerifierType.InMemory,
             useHTTPS = false,

node/src/test/kotlin/net/corda/node/services/events/NodeSchedulerServiceTest.kt

@@ -16,6 +16,7 @@ import net.corda.core.node.NodeInfo
 import net.corda.core.node.ServiceHub
 import net.corda.core.serialization.SingletonSerializeAsToken
 import net.corda.core.transactions.TransactionBuilder
+import net.corda.core.utilities.NetworkHostAndPort
 import net.corda.core.utilities.days
 import net.corda.node.internal.FlowStarterImpl
 import net.corda.node.internal.cordapp.CordappLoader
@@ -36,6 +37,7 @@ import net.corda.testing.*
 import net.corda.testing.contracts.DummyContract
 import net.corda.testing.node.*
 import net.corda.testing.node.MockServices.Companion.makeTestDataSourceProperties
+import net.corda.testing.services.MockAttachmentStorage
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.After
 import org.junit.Before
@@ -50,9 +52,11 @@ import java.util.concurrent.TimeUnit
 import kotlin.test.assertTrue
 
 class NodeSchedulerServiceTest : SingletonSerializeAsToken() {
-    companion object {
+    private companion object {
-        private val DUMMY_IDENTITY_1 = getTestPartyAndCertificate(Party(CordaX500Name("Dummy", "Madrid", "ES"), generateKeyPair().public))
+        val ALICE_KEY = TestIdentity(ALICE_NAME, 70).key
-        private val myInfo = NodeInfo(listOf(MOCK_HOST_AND_PORT), listOf(DUMMY_IDENTITY_1), 1, serial = 1L)
+        val DUMMY_IDENTITY_1 = getTestPartyAndCertificate(Party(CordaX500Name("Dummy", "Madrid", "ES"), generateKeyPair().public))
+        val DUMMY_NOTARY = TestIdentity(DUMMY_NOTARY_NAME, 20).party
+        val myInfo = NodeInfo(listOf(NetworkHostAndPort("mockHost", 30000)), listOf(DUMMY_IDENTITY_1), 1, serial = 1L)
     }
 
     @Rule

node/src/test/kotlin/net/corda/node/services/events/ScheduledFlowTests.kt

@@ -24,6 +24,7 @@ import net.corda.testing.*
 import net.corda.testing.contracts.DummyContract
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.node.MockNodeParameters
+import net.corda.testing.node.startFlow
 import org.junit.After
 import org.junit.Assert.*
 import org.junit.Before

node/src/test/kotlin/net/corda/node/services/identity/InMemoryIdentityServiceTests.kt

@@ -22,8 +22,16 @@ import kotlin.test.assertNull
  * Tests for the in memory identity service.
  */
 class InMemoryIdentityServiceTests {
-    companion object {
+    private companion object {
-        private fun createService(vararg identities: PartyAndCertificate) = InMemoryIdentityService(identities.toSet(), DEV_TRUST_ROOT)
+        val alice = TestIdentity(ALICE_NAME, 70)
+        val bob = TestIdentity(BOB_NAME, 80)
+        val ALICE get() = alice.party
+        val ALICE_IDENTITY get() = alice.identity
+        val ALICE_PUBKEY get() = alice.pubkey
+        val BOB get() = bob.party
+        val BOB_IDENTITY get() = bob.identity
+        val BOB_PUBKEY get() = bob.pubkey
+        fun createService(vararg identities: PartyAndCertificate) = InMemoryIdentityService(identities.toSet(), DEV_TRUST_ROOT)
     }
 
     @Test

node/src/test/kotlin/net/corda/node/services/identity/PersistentIdentityServiceTests.kt

@@ -30,6 +30,17 @@ import kotlin.test.assertNull
  * Tests for the in memory identity service.
  */
 class PersistentIdentityServiceTests {
+    private companion object {
+        val alice = TestIdentity(ALICE_NAME, 70)
+        val bob = TestIdentity(BOB_NAME, 80)
+        val ALICE get() = alice.party
+        val ALICE_IDENTITY get() = alice.identity
+        val ALICE_PUBKEY get() = alice.pubkey
+        val BOB get() = bob.party
+        val BOB_IDENTITY get() = bob.identity
+        val BOB_PUBKEY get() = bob.pubkey
+    }
+
     private lateinit var database: CordaPersistence
     private lateinit var identityService: IdentityService