Introduce full legal names for test parties

Use full names for test parties, ahead of complete X.500 name support.

node/src/integration-test/kotlin/net/corda/node/driver/DriverTests.kt

@@ -42,7 +42,7 @@ class DriverTests {
     fun `simple node startup and shutdown`() {
         val handles = driver {
             val notary = startNode(DUMMY_NOTARY.name, setOf(ServiceInfo(SimpleNotaryService.type)))
-            val regulator = startNode("Regulator", setOf(ServiceInfo(RegulatorService.type)))
+            val regulator = startNode("CN=Regulator,O=R3,OU=corda,L=London,C=UK", setOf(ServiceInfo(RegulatorService.type)))
             listOf(nodeMustBeUp(notary), nodeMustBeUp(regulator))
         }
         handles.map { nodeMustBeDown(it) }

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

@@ -98,4 +98,4 @@ class BFTNotaryServiceTests : NodeBasedTest() {
 
         return remainingNodes + masterNode
     }
-}
+}

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

@@ -22,7 +22,7 @@ import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
 
 class RaftNotaryServiceTests : NodeBasedTest() {
-    private val notaryName = "RAFT Notary Service"
+    private val notaryName = "CN=RAFT Notary Service,O=R3,OU=corda,L=London,C=UK"
 
     @Test
     fun `detect double spend`() {

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

@@ -42,9 +42,9 @@ class P2PSecurityTest : NodeBasedTest() {
 
     @Test
     fun `register with the network map service using a legal name different from the TLS CN`() {
-        startSimpleNode("Attacker").use {
+        startSimpleNode("CN=Attacker,O=R3,OU=corda,L=London,C=UK").use {
             // Register with the network map using a different legal name
-            val response = it.registerWithNetworkMap("Legit Business")
+            val response = it.registerWithNetworkMap("CN=Legit Business,O=R3,OU=corda,L=London,C=UK")
             // We don't expect a response because the network map's host verification will prevent a connection back
             // to the attacker as the TLS CN will not match the legal name it has just provided
             assertThatExceptionOfType(TimeoutException::class.java).isThrownBy {

node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt

@@ -51,6 +51,7 @@ import net.corda.node.utilities.AffinityExecutor
 import net.corda.node.utilities.configureDatabase
 import net.corda.node.utilities.transaction
 import org.apache.activemq.artemis.utils.ReusableLatch
+import org.bouncycastle.asn1.x500.X500Name
 import org.jetbrains.exposed.sql.Database
 import org.slf4j.Logger
 import java.io.IOException
@@ -305,7 +306,7 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
     protected open fun makeServiceEntries(): List<ServiceEntry> {
         return advertisedServices.map {
             val serviceId = it.type.id
-            val serviceName = it.name ?: "$serviceId|${configuration.myLegalName}"
+            val serviceName = it.name ?: "ou=$serviceId,${configuration.myLegalName}"
             val identity = obtainKeyPair(configuration.baseDirectory, serviceId + "-private-key", serviceId + "-public", serviceName).first
             ServiceEntry(it, identity)
         }

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

@@ -5,6 +5,7 @@ import com.google.common.util.concurrent.ListenableFuture
 import net.corda.core.contracts.Amount
 import net.corda.core.crypto.Party
 import net.corda.core.crypto.SecureHash
+import net.corda.core.crypto.X509Utilities
 import net.corda.core.flows.FlowLogic
 import net.corda.core.flows.FlowStateMachine
 import net.corda.core.flows.StateMachineRunId
@@ -16,6 +17,7 @@ import net.corda.core.utilities.UntrustworthyData
 import net.corda.jackson.JacksonSupport
 import net.corda.node.services.identity.InMemoryIdentityService
 import net.corda.node.shell.InteractiveShell
+import net.corda.testing.MEGA_CORP
 import org.junit.Test
 import org.slf4j.Logger
 import java.util.*
@@ -28,12 +30,12 @@ class InteractiveShellTest {
         constructor(b: Int, c: String) : this(b.toString() + c)
         constructor(amount: Amount<Currency>) : this(amount.toString())
         constructor(pair: Pair<Amount<Currency>, SecureHash.SHA256>) : this(pair.toString())
-        constructor(party: Party) : this(party.name)
-
+        constructor(party: Party) : this(party.name.toString())
         override fun call() = a
     }
 
-    private val ids = InMemoryIdentityService().apply { registerIdentity(Party("SomeCorp", DUMMY_PUBKEY_1)) }
+    private val someCorpLegalName = MEGA_CORP.name
+    private val ids = InMemoryIdentityService().apply { registerIdentity(Party(MEGA_CORP.name, DUMMY_PUBKEY_1)) }
     private val om = JacksonSupport.createInMemoryMapper(ids, YAMLFactory())
 
     private fun check(input: String, expected: String) {
@@ -66,7 +68,7 @@ class InteractiveShellTest {
     fun flowTooManyParams() = check("b: 12, c: Yo, d: Bar", "")
 
     @Test
-    fun party() = check("party: SomeCorp", "SomeCorp")
+    fun party() = check("party: \"${someCorpLegalName}\"", someCorpLegalName)
 
     class DummyFSM(val logic: FlowA) : FlowStateMachine<Any?> {
         override fun <T : Any> sendAndReceive(receiveType: Class<T>, otherParty: Party, payload: Any, sessionFlow: FlowLogic<*>): UntrustworthyData<T> {

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

@@ -2,6 +2,7 @@ package net.corda.node.services
 
 import net.corda.core.contracts.*
 import net.corda.core.crypto.Party
+import net.corda.core.crypto.X509Utilities
 import net.corda.core.crypto.generateKeyPair
 import net.corda.core.getOrThrow
 import net.corda.core.node.services.ServiceInfo
@@ -74,7 +75,7 @@ class NotaryChangeTests {
     @Test
     fun `should throw when a participant refuses to change Notary`() {
         val state = issueMultiPartyState(clientNodeA, clientNodeB, oldNotaryNode)
-        val newEvilNotary = Party("Evil Notary", generateKeyPair().public)
+        val newEvilNotary = Party("CN=Evil Notary,O=Evil R3,OU=corda,L=London,C=UK", generateKeyPair().public)
         val flow = Instigator(state, newEvilNotary)
         val future = clientNodeA.services.startFlow(flow)
 

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

@@ -1,5 +1,6 @@
 package net.corda.node.services.config
 
+import net.corda.core.utilities.ALICE
 import net.corda.nodeapi.User
 import net.corda.testing.testConfiguration
 import org.assertj.core.api.Assertions.assertThatThrownBy
@@ -10,7 +11,7 @@ class FullNodeConfigurationTest {
     @Test
     fun `Artemis special characters not permitted in RPC usernames`() {
         fun configWithRPCUsername(username: String): FullNodeConfiguration {
-            return testConfiguration(Paths.get("."), "NodeA", 0).copy(
+            return testConfiguration(Paths.get("."), ALICE.name, 0).copy(
                     rpcUsers = listOf(User(username, "pass", emptySet())))
         }
 

node/src/test/kotlin/net/corda/node/services/messaging/ArtemisMessagingTests.kt

@@ -6,11 +6,13 @@ import com.google.common.util.concurrent.Futures
 import com.google.common.util.concurrent.ListenableFuture
 import com.google.common.util.concurrent.SettableFuture
 import com.typesafe.config.ConfigFactory.empty
+import net.corda.core.crypto.X509Utilities
 import net.corda.core.crypto.generateKeyPair
 import net.corda.core.messaging.Message
 import net.corda.core.messaging.RPCOps
 import net.corda.core.messaging.createMessage
 import net.corda.core.node.services.DEFAULT_SESSION_ID
+import net.corda.core.utilities.ALICE
 import net.corda.core.utilities.LogHelper
 import net.corda.node.services.RPCUserService
 import net.corda.node.services.RPCUserServiceImpl
@@ -73,7 +75,7 @@ class ArtemisMessagingTests {
         userService = RPCUserServiceImpl(emptyList())
         config = TestNodeConfiguration(
                 baseDirectory = baseDirectory,
-                myLegalName = "me",
+                myLegalName = ALICE.name,
                 networkMapService = null)
         LogHelper.setLevel(PersistentUniquenessProvider::class)
         val dataSourceAndDatabase = configureDatabase(makeTestDataSourceProperties())

node/src/test/kotlin/net/corda/node/services/network/AbstractNetworkMapServiceTest.kt

@@ -10,6 +10,7 @@ import net.corda.core.node.services.ServiceInfo
 import net.corda.core.serialization.deserialize
 import net.corda.core.utilities.ALICE
 import net.corda.core.utilities.BOB
+import net.corda.core.utilities.CHARLIE
 import net.corda.flows.sendRequest
 import net.corda.node.services.config.NodeConfiguration
 import net.corda.node.services.network.AbstractNetworkMapServiceTest.Changed.Added
@@ -141,7 +142,7 @@ abstract class AbstractNetworkMapServiceTest<out S : AbstractNetworkMapService>
         val updates = alice.subscribe()
         val bob = addNewNodeToNetworkMap(BOB.name)
         alice.unsubscribe()
-        addNewNodeToNetworkMap("Charlie")
+        addNewNodeToNetworkMap(CHARLIE.name)
         swizzle()
         assertThat(updates.map { it.wireReg.verified().toChanged() }).containsOnly(Added(bob.info))
     }
@@ -274,4 +275,4 @@ abstract class AbstractNetworkMapServiceTest<out S : AbstractNetworkMapService>
             }
         }
     }
-}
+}

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

@@ -1,6 +1,7 @@
 package net.corda.node.services.network
 
 import net.corda.core.crypto.Party
+import net.corda.core.crypto.X509Utilities
 import net.corda.core.crypto.generateKeyPair
 import net.corda.node.services.identity.InMemoryIdentityService
 import net.corda.core.utilities.ALICE
@@ -50,9 +51,10 @@ class InMemoryIdentityServiceTests {
     @Test
     fun `get identity by name`() {
         val service = InMemoryIdentityService()
-        val identities = listOf("Node A", "Node B", "Node C").map { Party(it, generateKeyPair().public) }
+        val identities = listOf("Node A", "Node B", "Node C")
+                .map { Party("CN=$it,O=R3,OU=corda,L=London,C=UK", generateKeyPair().public) }
         assertNull(service.partyFromName(identities.first().name))
         identities.forEach { service.registerIdentity(it) }
         identities.forEach { assertEquals(it, service.partyFromName(it.name)) }
     }
-}
+}

node/src/test/kotlin/net/corda/node/services/network/InMemoryNetworkMapCacheTest.kt

@@ -2,6 +2,8 @@ package net.corda.node.services.network
 
 import net.corda.core.getOrThrow
 import net.corda.core.node.services.ServiceInfo
+import net.corda.core.utilities.ALICE
+import net.corda.core.utilities.BOB
 import net.corda.node.utilities.transaction
 import net.corda.testing.node.MockNetwork
 import org.junit.Test
@@ -22,8 +24,8 @@ class InMemoryNetworkMapCacheTest {
     @Test
     fun `key collision`() {
         val entropy = BigInteger.valueOf(24012017L)
-        val nodeA = network.createNode(null, -1, MockNetwork.DefaultFactory, true, "Node A", null, entropy, ServiceInfo(NetworkMapService.type))
-        val nodeB = network.createNode(null, -1, MockNetwork.DefaultFactory, true, "Node B", null, entropy, ServiceInfo(NetworkMapService.type))
+        val nodeA = network.createNode(null, -1, MockNetwork.DefaultFactory, true, ALICE.name, null, entropy, ServiceInfo(NetworkMapService.type))
+        val nodeB = network.createNode(null, -1, MockNetwork.DefaultFactory, true, BOB.name, null, entropy, ServiceInfo(NetworkMapService.type))
         assertEquals(nodeA.info.legalIdentity, nodeB.info.legalIdentity)
 
         // Node A currently knows only about itself, so this returns node A

node/src/test/kotlin/net/corda/node/services/statemachine/StateMachineManagerTests.kt

@@ -8,6 +8,7 @@ import net.corda.core.*
 import net.corda.core.contracts.DOLLARS
 import net.corda.core.contracts.DummyState
 import net.corda.core.crypto.Party
+import net.corda.core.crypto.X509Utilities
 import net.corda.core.crypto.generateKeyPair
 import net.corda.core.flows.FlowException
 import net.corda.core.flows.FlowLogic
@@ -73,12 +74,12 @@ class StateMachineManagerTests {
         node1 = nodes.first
         node2 = nodes.second
         val notaryKeyPair = generateKeyPair()
-        val notaryService = ServiceInfo(ValidatingNotaryService.type, "notary-service-2000")
+        val notaryService = ServiceInfo(ValidatingNotaryService.type, "CN=notary-service-2000,O=R3,OU=corda,L=London,C=UK")
         val overrideServices = mapOf(Pair(notaryService, notaryKeyPair))
         // Note that these notaries don't operate correctly as they don't share their state. They are only used for testing
         // service addressing.
-        notary1 = net.createNotaryNode(networkMapAddr = node1.services.myInfo.address, overrideServices = overrideServices, serviceName = "notary-service-2000")
-        notary2 = net.createNotaryNode(networkMapAddr = node1.services.myInfo.address, overrideServices = overrideServices, serviceName = "notary-service-2000")
+        notary1 = net.createNotaryNode(networkMapAddr = node1.services.myInfo.address, overrideServices = overrideServices, serviceName = notaryService.name)
+        notary2 = net.createNotaryNode(networkMapAddr = node1.services.myInfo.address, overrideServices = overrideServices, serviceName = notaryService.name)
 
         net.messagingNetwork.receivedMessages.toSessionTransfers().forEach { sessionTransfers += it }
         net.runNetwork()

node/src/test/kotlin/net/corda/node/utilities/registration/NetworkisRegistrationHelperTest.kt

@@ -6,6 +6,7 @@ import com.nhaarman.mockito_kotlin.mock
 import net.corda.core.crypto.SecureHash
 import net.corda.core.crypto.X509Utilities
 import net.corda.core.exists
+import net.corda.core.utilities.ALICE
 import net.corda.testing.TestNodeConfiguration
 import org.junit.Rule
 import org.junit.Test
@@ -34,7 +35,7 @@ class NetworkRegistrationHelperTest {
 
         val config = TestNodeConfiguration(
                 baseDirectory = tempFolder.root.toPath(),
-                myLegalName = "me",
+                myLegalName = ALICE.name,
                 networkMapService = null)
 
         assertFalse(config.keyStoreFile.exists())