Fix node integration tests. (#2233)

* Add tests for node registration and communication

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

@@ -10,6 +10,7 @@ import net.corda.core.utilities.seconds
 import net.corda.nodeapi.internal.network.NETWORK_PARAMS_FILE_NAME
 import net.corda.nodeapi.internal.network.NetworkParameters
 import net.corda.testing.ALICE_NAME
+import net.corda.testing.ROOT_CA
 import net.corda.testing.BOB_NAME
 import net.corda.testing.SerializationEnvironmentRule
 import net.corda.testing.driver.NodeHandle
@@ -49,20 +50,22 @@ class NetworkMapTest {
 
     @Test
     fun `node correctly downloads and saves network parameters file on startup`() {
-        internalDriver(portAllocation = portAllocation, compatibilityZone = compatibilityZone, initialiseSerialization = false) {
+        internalDriver(portAllocation = portAllocation, compatibilityZone = compatibilityZone,
+                initialiseSerialization = false, notarySpecs = emptyList()) {
             val alice = startNode(providedName = ALICE_NAME).getOrThrow()
             val networkParameters = alice.configuration.baseDirectory
                     .list { paths -> paths.filter { it.fileName.toString() == NETWORK_PARAMS_FILE_NAME }.findFirst().get() }
                     .readAll()
                     .deserialize<SignedData<NetworkParameters>>()
                     .verified()
-            assertEquals(NetworkMapServer.stubNetworkParameter, networkParameters)
+            assertEquals(networkMapServer.networkParameters, networkParameters)
         }
     }
 
     @Test
     fun `nodes can see each other using the http network map`() {
-        internalDriver(portAllocation = portAllocation, compatibilityZone = compatibilityZone, initialiseSerialization = false) {
+        internalDriver(portAllocation = portAllocation, compatibilityZone = compatibilityZone,
+                initialiseSerialization = false, onNetworkParametersGeneration = { networkMapServer.networkParameters = it }) {
             val alice = startNode(providedName = ALICE_NAME)
             val bob = startNode(providedName = BOB_NAME)
             val notaryNode = defaultNotaryNode.get()
@@ -77,7 +80,8 @@ class NetworkMapTest {
 
     @Test
     fun `nodes process network map add updates correctly when adding new node to network map`() {
-        internalDriver(portAllocation = portAllocation, compatibilityZone = compatibilityZone, initialiseSerialization = false) {
+        internalDriver(portAllocation = portAllocation, compatibilityZone = compatibilityZone,
+                initialiseSerialization = false, onNetworkParametersGeneration = { networkMapServer.networkParameters = it }) {
             val alice = startNode(providedName = ALICE_NAME)
             val notaryNode = defaultNotaryNode.get()
             val aliceNode = alice.get()
@@ -98,7 +102,8 @@ class NetworkMapTest {
 
     @Test
     fun `nodes process network map remove updates correctly`() {
-        internalDriver(portAllocation = portAllocation, compatibilityZone = compatibilityZone, initialiseSerialization = false) {
+        internalDriver(portAllocation = portAllocation, compatibilityZone = compatibilityZone,
+                initialiseSerialization = false, onNetworkParametersGeneration = { networkMapServer.networkParameters = it }) {
             val alice = startNode(providedName = ALICE_NAME)
             val bob = startNode(providedName = BOB_NAME)
             val notaryNode = defaultNotaryNode.get()

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

@@ -3,10 +3,12 @@ package net.corda.node.utilities.registration
 import net.corda.core.crypto.Crypto
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.internal.cert
+import net.corda.core.internal.concurrent.transpose
 import net.corda.core.internal.toX509CertHolder
-import net.corda.core.utilities.NetworkHostAndPort
-import net.corda.core.utilities.getOrThrow
-import net.corda.core.utilities.minutes
+import net.corda.core.messaging.startFlow
+import net.corda.core.utilities.*
+import net.corda.finance.DOLLARS
+import net.corda.finance.flows.CashIssueAndPaymentFlow
 import net.corda.nodeapi.internal.crypto.CertificateAndKeyPair
 import net.corda.nodeapi.internal.crypto.CertificateType
 import net.corda.nodeapi.internal.crypto.X509CertificateFactory
@@ -14,11 +16,16 @@ 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.nodeapi.internal.network.NotaryInfo
+import net.corda.testing.ROOT_CA
 import net.corda.testing.SerializationEnvironmentRule
-import net.corda.testing.node.internal.CompatibilityZoneParams
 import net.corda.testing.driver.PortAllocation
+import net.corda.testing.node.NotarySpec
+import net.corda.testing.node.internal.CompatibilityZoneParams
 import net.corda.testing.node.internal.internalDriver
 import net.corda.testing.node.internal.network.NetworkMapServer
+import net.corda.testing.singleIdentity
+import net.corda.testing.singleIdentityAndCert
 import org.assertj.core.api.Assertions.assertThat
 import org.assertj.core.api.Assertions.assertThatThrownBy
 import org.bouncycastle.pkcs.PKCS10CertificationRequest
@@ -44,15 +51,13 @@ class NodeRegistrationTest {
     @JvmField
     val testSerialization = SerializationEnvironmentRule(true)
     private val portAllocation = PortAllocation.Incremental(13000)
-    private val rootCertAndKeyPair = createSelfKeyAndSelfSignedCertificate()
-    private val registrationHandler = RegistrationHandler(rootCertAndKeyPair)
-
+    private val registrationHandler = RegistrationHandler(ROOT_CA)
     private lateinit var server: NetworkMapServer
     private lateinit var serverHostAndPort: NetworkHostAndPort
 
     @Before
     fun startServer() {
-        server = NetworkMapServer(1.minutes, portAllocation.nextHostAndPort(), rootCertAndKeyPair, registrationHandler)
+        server = NetworkMapServer(1.minutes, portAllocation.nextHostAndPort(), ROOT_CA, "localhost", registrationHandler)
         serverHostAndPort = server.start()
     }
 
@@ -61,19 +66,47 @@ class NodeRegistrationTest {
         server.close()
     }
 
-    // TODO Ideally this test should be checking that two nodes that register are able to transact with each other. However
-    // starting a second node hangs so that needs to be fixed.
     @Test
     fun `node registration correct root cert`() {
-        val compatibilityZone = CompatibilityZoneParams(URL("http://$serverHostAndPort"), rootCert = rootCertAndKeyPair.certificate.cert)
+        val compatibilityZone = CompatibilityZoneParams(URL("http://$serverHostAndPort"), rootCert = ROOT_CA.certificate.cert)
         internalDriver(
                 portAllocation = portAllocation,
-                notarySpecs = emptyList(),
                 compatibilityZone = compatibilityZone,
-                initialiseSerialization = false
+                initialiseSerialization = false,
+                notarySpecs = listOf(NotarySpec(CordaX500Name(organisation = "NotaryService", locality = "Zurich", country = "CH"), validating = false)),
+                extraCordappPackagesToScan = listOf("net.corda.finance"),
+                onNetworkParametersGeneration = { server.networkParameters = it }
         ) {
-            startNode(providedName = CordaX500Name("Alice", "London", "GB")).getOrThrow()
-            assertThat(registrationHandler.idsPolled).contains("Alice")
+            val notary = defaultNotaryNode.get()
+
+            val ALICE_NAME = "Alice"
+            val GENEVIEVE_NAME = "Genevieve"
+            val nodesFutures = listOf(startNode(providedName = CordaX500Name(ALICE_NAME, "London", "GB")),
+                    startNode(providedName = CordaX500Name(GENEVIEVE_NAME, "London", "GB")))
+
+            val (alice, genevieve) = nodesFutures.transpose().get()
+            val nodes = listOf(alice, genevieve, notary)
+
+            assertThat(registrationHandler.idsPolled).contains(ALICE_NAME, GENEVIEVE_NAME)
+            // Notary identities are generated beforehand hence notary nodes don't go through registration.
+            // This test isn't specifically testing this, or relying on this behavior, though if this check fail,
+            // this will probably lead to the rest of the test to fail.
+            assertThat(registrationHandler.idsPolled).doesNotContain("NotaryService")
+
+            // Check each node has each other identity in their network map cache.
+            val nodeIdentities = nodes.map { it.nodeInfo.singleIdentity() }
+            for (node in nodes) {
+                assertThat(node.rpc.networkMapSnapshot().map { it.singleIdentity() }).containsAll(nodeIdentities)
+            }
+
+            // Check we nodes communicate among themselves (and the notary).
+            val anonymous = false
+            genevieve.rpc.startFlow(::CashIssueAndPaymentFlow, 1000.DOLLARS, OpaqueBytes.of(12),
+                    alice.nodeInfo.singleIdentity(),
+                    anonymous,
+                    notary.nodeInfo.singleIdentity())
+                    .returnValue
+                    .getOrThrow()
         }
     }
 
@@ -85,6 +118,7 @@ class NodeRegistrationTest {
                 portAllocation = portAllocation,
                 notarySpecs = emptyList(),
                 compatibilityZone = compatibilityZone,
+                initialiseSerialization = false,
                 // Changing the content of the truststore makes the node fail in a number of ways if started out process.
                 startNodesInProcess = true
         ) {

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

@@ -5,10 +5,7 @@ import net.corda.core.crypto.sha256
 import net.corda.core.internal.cert
 import net.corda.core.serialization.serialize
 import net.corda.core.utilities.seconds
-import net.corda.testing.ALICE_NAME
-import net.corda.testing.BOB_NAME
-import net.corda.testing.DEV_TRUST_ROOT
-import net.corda.testing.SerializationEnvironmentRule
+import net.corda.testing.*
 import net.corda.testing.driver.PortAllocation
 import net.corda.testing.internal.createNodeInfoAndSigned
 import net.corda.testing.node.internal.network.NetworkMapServer
@@ -33,7 +30,7 @@ class NetworkMapClientTest {
 
     @Before
     fun setUp() {
-        server = NetworkMapServer(cacheTimeout, PortAllocation.Incremental(10000).nextHostAndPort())
+        server = NetworkMapServer(cacheTimeout, PortAllocation.Incremental(10000).nextHostAndPort(), root_ca = ROOT_CA)
         val hostAndPort = server.start()
         networkMapClient = NetworkMapClient(URL("http://${hostAndPort.host}:${hostAndPort.port}"), DEV_TRUST_ROOT.cert)
     }
@@ -70,7 +67,7 @@ class NetworkMapClientTest {
         // The test server returns same network parameter for any hash.
         val networkParameter = networkMapClient.getNetworkParameter(SecureHash.randomSHA256())?.verified()
         assertNotNull(networkParameter)
-        assertEquals(NetworkMapServer.stubNetworkParameter, networkParameter)
+        assertEquals(server.networkParameters, networkParameter)
     }
 
     @Test