CORDA-654 Remaining key constants (corda#2226)

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 val SEED = BigInteger.valueOf(20170922L)
+    private companion object {
+        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

@@ -28,7 +28,7 @@
 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;
 
 public class CordaRPCJavaClientTest extends NodeBasedTest {
     public CordaRPCJavaClientTest() {
@@ -56,7 +56,7 @@ private void login(String username, String password) {
 
     @Before
     public void setUp() throws ExecutionException, InterruptedException {
-        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

@@ -7,7 +7,7 @@ import net.corda.core.flows.StartableByRPC
 import net.corda.core.messaging.startFlow
 import net.corda.core.serialization.CordaSerializable
 import net.corda.core.utilities.getOrThrow
-import net.corda.testing.ALICE
+import net.corda.testing.ALICE_NAME
 import net.corda.testing.driver.driver
 import org.assertj.core.api.Assertions.assertThatExceptionOfType
 import org.junit.Test
@@ -29,7 +29,7 @@ class BlacklistKotlinClosureTest {
     @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

@@ -135,7 +135,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
 

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

@@ -1,14 +1,10 @@
 package net.corda.confidential
 
-import net.corda.core.identity.AbstractParty
-import net.corda.core.identity.AnonymousParty
-import net.corda.core.identity.Party
-import net.corda.core.identity.PartyAndCertificate
+import net.corda.core.identity.*
 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 org.junit.Test
 import kotlin.test.*
 
@@ -24,8 +20,8 @@ class SwapIdentitiesFlowTests {
     @Test
     fun `issue key`() {
         // Set up values we'll need
-        val aliceNode = mockNet.createPartyNode(ALICE.name)
-        val bobNode = mockNet.createPartyNode(BOB.name)
+        val aliceNode = mockNet.createPartyNode(ALICE_NAME)
+        val bobNode = mockNet.createPartyNode(BOB_NAME)
         val alice = aliceNode.info.singleIdentity()
         val bob = bobNode.services.myInfo.singleIdentity()
 
@@ -60,9 +56,9 @@ class SwapIdentitiesFlowTests {
     @Test
     fun `verifies identity name`() {
         // Set up values we'll need
-        val aliceNode = mockNet.createPartyNode(ALICE.name)
-        val bobNode = mockNet.createPartyNode(BOB.name)
-        val charlieNode = mockNet.createPartyNode(CHARLIE.name)
+        val aliceNode = mockNet.createPartyNode(ALICE_NAME)
+        val bobNode = mockNet.createPartyNode(BOB_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 +79,8 @@ class SwapIdentitiesFlowTests {
     fun `verifies signature`() {
         // Set up values we'll need
         val notaryNode = mockNet.defaultNotaryNode
-        val aliceNode = mockNet.createPartyNode(ALICE.name)
-        val bobNode = mockNet.createPartyNode(BOB.name)
+        val aliceNode = mockNet.createPartyNode(ALICE_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/test/java/net/corda/core/flows/FlowsInJavaTest.java

@@ -26,8 +26,8 @@ public class FlowsInJavaTest {
 
     @Before
     public void setUp() throws Exception {
-        aliceNode = mockNet.createPartyNode(TestConstants.getALICE().getName());
-        bobNode = mockNet.createPartyNode(TestConstants.getBOB().getName());
+        aliceNode = mockNet.createPartyNode(TestConstants.getALICE_NAME());
+        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
@@ -24,6 +25,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

@@ -48,9 +48,8 @@ class AttachmentTests {
 
     @Test
     fun `download and store`() {
-        val aliceNode = mockNet.createPartyNode(ALICE.name)
-        val bobNode = mockNet.createPartyNode(BOB.name)
-
+        val aliceNode = mockNet.createPartyNode(ALICE_NAME)
+        val bobNode = mockNet.createPartyNode(BOB_NAME)
         val alice = aliceNode.info.singleIdentity()
         aliceNode.registerInitiatedFlow(FetchAttachmentsResponse::class.java)
         bobNode.registerInitiatedFlow(FetchAttachmentsResponse::class.java)
@@ -81,8 +80,8 @@ class AttachmentTests {
 
     @Test
     fun `missing`() {
-        val aliceNode = mockNet.createPartyNode(ALICE.name)
-        val bobNode = mockNet.createPartyNode(BOB.name)
+        val aliceNode = mockNet.createPartyNode(ALICE_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,12 +96,12 @@ 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)
         aliceNode.registerInitiatedFlow(FetchAttachmentsResponse::class.java)
         bobNode.registerInitiatedFlow(FetchAttachmentsResponse::class.java)

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
@@ -22,6 +23,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 +39,9 @@ class CollectSignaturesFlowTests {
     @Before
     fun setup() {
         mockNet = MockNetwork(cordappPackages = listOf("net.corda.testing.contracts"))
-        aliceNode = mockNet.createPartyNode(ALICE.name)
-        bobNode = mockNet.createPartyNode(BOB.name)
-        charlieNode = mockNet.createPartyNode(CHARLIE.name)
+        aliceNode = mockNet.createPartyNode(ALICE_NAME)
+        bobNode = mockNet.createPartyNode(BOB_NAME)
+        charlieNode = mockNet.createPartyNode(CHARLIE_NAME)
         alice = aliceNode.info.singleIdentity()
         bob = bobNode.info.singleIdentity()
         charlie = charlieNode.info.singleIdentity()
@@ -129,7 +134,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/FinalityFlowTests.kt

@@ -16,6 +16,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/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.BOB
+import net.corda.testing.ALICE_NAME
+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", "bob", "-keypass", "bobpass", "-dname", BOB.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_NAME.toString())
             (dir / "_signable1").writeLines(listOf("signable1"))
             (dir / "_signable2").writeLines(listOf("signable2"))
             (dir / "_signable3").writeLines(listOf("signable3"))
@@ -76,28 +76,28 @@ 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
     fun `two signers`() {
         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/ResolveTransactionsFlowTest.kt

@@ -3,17 +3,15 @@ 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.*
 import net.corda.testing.contracts.DummyContract
 import net.corda.testing.node.MockNetwork
-import net.corda.testing.singleIdentity
-import net.corda.testing.startFlow
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
@@ -40,8 +38,8 @@ class ResolveTransactionsFlowTest {
     fun setup() {
         mockNet = MockNetwork(cordappPackages = listOf("net.corda.testing.contracts"))
         notaryNode = mockNet.defaultNotaryNode
-        megaCorpNode = mockNet.createPartyNode(MEGA_CORP.name)
-        miniCorpNode = mockNet.createPartyNode(MINI_CORP.name)
+        megaCorpNode = mockNet.createPartyNode(CordaX500Name("MegaCorp", "London", "GB"))
+        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 {