diff --git a/core/src/test/java/net/corda/core/flows/FlowsInJavaTest.java b/core/src/test/java/net/corda/core/flows/FlowsInJavaTest.java index ea99e84cc6..831d27549e 100644 --- a/core/src/test/java/net/corda/core/flows/FlowsInJavaTest.java +++ b/core/src/test/java/net/corda/core/flows/FlowsInJavaTest.java @@ -13,28 +13,28 @@ import static org.assertj.core.api.AssertionsForClassTypes.assertThat; public class FlowsInJavaTest { - private final MockNetwork net = new MockNetwork(); + private final MockNetwork mockNet = new MockNetwork(); private MockNetwork.MockNode node1; private MockNetwork.MockNode node2; @Before public void setUp() { - MockNetwork.BasketOfNodes someNodes = net.createSomeNodes(2); + MockNetwork.BasketOfNodes someNodes = mockNet.createSomeNodes(2); node1 = someNodes.getPartyNodes().get(0); node2 = someNodes.getPartyNodes().get(1); - net.runNetwork(); + mockNet.runNetwork(); } @After public void cleanUp() { - net.stopNodes(); + mockNet.stopNodes(); } @Test public void suspendableActionInsideUnwrap() throws Exception { node2.registerInitiatedFlow(SendHelloAndThenReceive.class); Future result = node1.getServices().startFlow(new SendInUnwrapFlow(node2.getInfo().getLegalIdentity())).getResultFuture(); - net.runNetwork(); + mockNet.runNetwork(); assertThat(result.get()).isEqualTo("Hello"); } diff --git a/core/src/test/kotlin/net/corda/core/flows/ResolveTransactionsFlowTest.kt b/core/src/test/kotlin/net/corda/core/flows/ResolveTransactionsFlowTest.kt index a48e72944f..887e1649dc 100644 --- a/core/src/test/kotlin/net/corda/core/flows/ResolveTransactionsFlowTest.kt +++ b/core/src/test/kotlin/net/corda/core/flows/ResolveTransactionsFlowTest.kt @@ -28,24 +28,24 @@ import kotlin.test.assertNotNull import kotlin.test.assertNull class ResolveTransactionsFlowTest { - lateinit var net: MockNetwork + lateinit var mockNet: MockNetwork lateinit var a: MockNetwork.MockNode lateinit var b: MockNetwork.MockNode lateinit var notary: Party @Before fun setup() { - net = MockNetwork() - val nodes = net.createSomeNodes() + mockNet = MockNetwork() + val nodes = mockNet.createSomeNodes() a = nodes.partyNodes[0] b = nodes.partyNodes[1] notary = nodes.notaryNode.info.notaryIdentity - net.runNetwork() + mockNet.runNetwork() } @After fun tearDown() { - net.stopNodes() + mockNet.stopNodes() } // DOCSTART 1 @@ -54,7 +54,7 @@ class ResolveTransactionsFlowTest { val (stx1, stx2) = makeTransactions() val p = ResolveTransactionsFlow(setOf(stx2.id), a.info.legalIdentity) val future = b.services.startFlow(p).resultFuture - net.runNetwork() + mockNet.runNetwork() val results = future.getOrThrow() assertEquals(listOf(stx1.id, stx2.id), results.map { it.id }) b.database.transaction { @@ -69,7 +69,7 @@ class ResolveTransactionsFlowTest { val stx = makeTransactions(signFirstTX = false).second val p = ResolveTransactionsFlow(setOf(stx.id), a.info.legalIdentity) val future = b.services.startFlow(p).resultFuture - net.runNetwork() + mockNet.runNetwork() assertFailsWith(SignatureException::class) { future.getOrThrow() } } @@ -78,7 +78,7 @@ class ResolveTransactionsFlowTest { val (stx1, stx2) = makeTransactions() val p = ResolveTransactionsFlow(stx2, a.info.legalIdentity) val future = b.services.startFlow(p).resultFuture - net.runNetwork() + mockNet.runNetwork() future.getOrThrow() b.database.transaction { assertEquals(stx1, b.storage.validatedTransactions.getTransaction(stx1.id)) @@ -105,7 +105,7 @@ class ResolveTransactionsFlowTest { val p = ResolveTransactionsFlow(setOf(cursor.id), a.info.legalIdentity) p.transactionCountLimit = 40 val future = b.services.startFlow(p).resultFuture - net.runNetwork() + mockNet.runNetwork() assertFailsWith { future.getOrThrow() } } @@ -131,7 +131,7 @@ class ResolveTransactionsFlowTest { val p = ResolveTransactionsFlow(setOf(stx3.id), a.info.legalIdentity) val future = b.services.startFlow(p).resultFuture - net.runNetwork() + mockNet.runNetwork() future.getOrThrow() } @@ -153,7 +153,7 @@ class ResolveTransactionsFlowTest { val stx2 = makeTransactions(withAttachment = id).second val p = ResolveTransactionsFlow(stx2, a.info.legalIdentity) val future = b.services.startFlow(p).resultFuture - net.runNetwork() + mockNet.runNetwork() future.getOrThrow() // TODO: this operation should not require an explicit transaction diff --git a/core/src/test/kotlin/net/corda/core/flows/TxKeyFlowTests.kt b/core/src/test/kotlin/net/corda/core/flows/TxKeyFlowTests.kt index 7e3cf20b78..344c418d56 100644 --- a/core/src/test/kotlin/net/corda/core/flows/TxKeyFlowTests.kt +++ b/core/src/test/kotlin/net/corda/core/flows/TxKeyFlowTests.kt @@ -13,22 +13,22 @@ import kotlin.test.assertEquals import kotlin.test.assertNotEquals class TxKeyFlowTests { - lateinit var net: MockNetwork + lateinit var mockNet: MockNetwork @Before fun before() { - net = MockNetwork(false) + mockNet = MockNetwork(false) } @Test fun `issue key`() { // We run this in parallel threads to help catch any race conditions that may exist. - net = MockNetwork(false, true) + mockNet = MockNetwork(false, true) // Set up values we'll need - val notaryNode = net.createNotaryNode(null, DUMMY_NOTARY.name) - val aliceNode = net.createPartyNode(notaryNode.info.address, ALICE.name) - val bobNode = net.createPartyNode(notaryNode.info.address, BOB.name) + val notaryNode = mockNet.createNotaryNode(null, DUMMY_NOTARY.name) + val aliceNode = mockNet.createPartyNode(notaryNode.info.address, ALICE.name) + val bobNode = mockNet.createPartyNode(notaryNode.info.address, BOB.name) val alice: Party = aliceNode.services.myInfo.legalIdentity val bob: Party = bobNode.services.myInfo.legalIdentity aliceNode.services.identityService.registerIdentity(bobNode.info.legalIdentityAndCert) diff --git a/core/src/test/kotlin/net/corda/core/serialization/AttachmentSerializationTest.kt b/core/src/test/kotlin/net/corda/core/serialization/AttachmentSerializationTest.kt index 2e300844c9..8888bb75ea 100644 --- a/core/src/test/kotlin/net/corda/core/serialization/AttachmentSerializationTest.kt +++ b/core/src/test/kotlin/net/corda/core/serialization/AttachmentSerializationTest.kt @@ -61,22 +61,22 @@ private fun NodeAttachmentService.updateAttachment(attachmentId: SecureHash, dat } class AttachmentSerializationTest { - private lateinit var network: MockNetwork + private lateinit var mockNet: MockNetwork private lateinit var server: MockNetwork.MockNode private lateinit var client: MockNetwork.MockNode @Before fun setUp() { - network = MockNetwork() - server = network.createNode(advertisedServices = ServiceInfo(NetworkMapService.type)) - client = network.createNode(server.info.address) + mockNet = MockNetwork() + server = mockNet.createNode(advertisedServices = ServiceInfo(NetworkMapService.type)) + client = mockNet.createNode(server.info.address) client.disableDBCloseOnStop() // Otherwise the in-memory database may disappear (taking the checkpoint with it) while we reboot the client. - network.runNetwork() + mockNet.runNetwork() } @After fun tearDown() { - network.stopNodes() + mockNet.stopNodes() } private class ServerLogic(private val client: Party) : FlowLogic() { @@ -144,12 +144,12 @@ class AttachmentSerializationTest { } }, ServerLogic::class.java, track = false) client.services.startFlow(clientLogic) - network.runNetwork(rounds) + mockNet.runNetwork(rounds) } private fun rebootClientAndGetAttachmentContent(checkAttachmentsOnLoad: Boolean = true): String { client.stop() - client = network.createNode(server.info.address, client.id, object : MockNetwork.Factory { + client = mockNet.createNode(server.info.address, client.id, object : MockNetwork.Factory { override fun create(config: NodeConfiguration, network: MockNetwork, networkMapAddr: SingleMessageRecipient?, advertisedServices: Set, id: Int, overrideServices: Map?, entropyRoot: BigInteger): MockNetwork.MockNode { return object : MockNetwork.MockNode(config, network, networkMapAddr, advertisedServices, id, overrideServices, entropyRoot) { override fun startMessagingService(rpcOps: RPCOps) { @@ -159,7 +159,7 @@ class AttachmentSerializationTest { } } }) - return (client.smm.allStateMachines[0].stateMachine.resultFuture.apply { network.runNetwork() }.getOrThrow() as ClientResult).attachmentContent + return (client.smm.allStateMachines[0].stateMachine.resultFuture.apply { mockNet.runNetwork() }.getOrThrow() as ClientResult).attachmentContent } @Test diff --git a/docs/source/example-code/src/test/kotlin/net/corda/docs/FxTransactionBuildTutorialTest.kt b/docs/source/example-code/src/test/kotlin/net/corda/docs/FxTransactionBuildTutorialTest.kt index 59cd0dbfbc..4210c57ce6 100644 --- a/docs/source/example-code/src/test/kotlin/net/corda/docs/FxTransactionBuildTutorialTest.kt +++ b/docs/source/example-code/src/test/kotlin/net/corda/docs/FxTransactionBuildTutorialTest.kt @@ -18,28 +18,28 @@ import org.junit.Test import kotlin.test.assertEquals class FxTransactionBuildTutorialTest { - lateinit var net: MockNetwork + lateinit var mockNet: MockNetwork lateinit var notaryNode: MockNetwork.MockNode lateinit var nodeA: MockNetwork.MockNode lateinit var nodeB: MockNetwork.MockNode @Before fun setup() { - net = MockNetwork(threadPerNode = true) + mockNet = MockNetwork(threadPerNode = true) val notaryService = ServiceInfo(ValidatingNotaryService.type) - notaryNode = net.createNode( + notaryNode = mockNet.createNode( legalName = DUMMY_NOTARY.name, overrideServices = mapOf(notaryService to DUMMY_NOTARY_KEY), advertisedServices = *arrayOf(ServiceInfo(NetworkMapService.type), notaryService)) - nodeA = net.createPartyNode(notaryNode.info.address) - nodeB = net.createPartyNode(notaryNode.info.address) + nodeA = mockNet.createPartyNode(notaryNode.info.address) + nodeB = mockNet.createPartyNode(notaryNode.info.address) nodeB.registerInitiatedFlow(ForeignExchangeRemoteFlow::class.java) } @After fun cleanUp() { println("Close DB") - net.stopNodes() + mockNet.stopNodes() } @Test diff --git a/docs/source/example-code/src/test/kotlin/net/corda/docs/WorkflowTransactionBuildTutorialTest.kt b/docs/source/example-code/src/test/kotlin/net/corda/docs/WorkflowTransactionBuildTutorialTest.kt index 77d389a1bb..b456cb8e02 100644 --- a/docs/source/example-code/src/test/kotlin/net/corda/docs/WorkflowTransactionBuildTutorialTest.kt +++ b/docs/source/example-code/src/test/kotlin/net/corda/docs/WorkflowTransactionBuildTutorialTest.kt @@ -20,7 +20,7 @@ import org.junit.Test import kotlin.test.assertEquals class WorkflowTransactionBuildTutorialTest { - lateinit var net: MockNetwork + lateinit var mockNet: MockNetwork lateinit var notaryNode: MockNetwork.MockNode lateinit var nodeA: MockNetwork.MockNode lateinit var nodeB: MockNetwork.MockNode @@ -34,21 +34,21 @@ class WorkflowTransactionBuildTutorialTest { @Before fun setup() { - net = MockNetwork(threadPerNode = true) + mockNet = MockNetwork(threadPerNode = true) val notaryService = ServiceInfo(ValidatingNotaryService.type) - notaryNode = net.createNode( + notaryNode = mockNet.createNode( legalName = DUMMY_NOTARY.name, overrideServices = mapOf(Pair(notaryService, DUMMY_NOTARY_KEY)), advertisedServices = *arrayOf(ServiceInfo(NetworkMapService.type), notaryService)) - nodeA = net.createPartyNode(notaryNode.info.address) - nodeB = net.createPartyNode(notaryNode.info.address) + nodeA = mockNet.createPartyNode(notaryNode.info.address) + nodeB = mockNet.createPartyNode(notaryNode.info.address) nodeA.registerInitiatedFlow(RecordCompletionFlow::class.java) } @After fun cleanUp() { println("Close DB") - net.stopNodes() + mockNet.stopNodes() } @Test diff --git a/docs/source/flow-testing.rst b/docs/source/flow-testing.rst index 73b062998d..ba2f3178b1 100644 --- a/docs/source/flow-testing.rst +++ b/docs/source/flow-testing.rst @@ -20,24 +20,24 @@ with this basic skeleton: .. sourcecode:: kotlin class ResolveTransactionsFlowTest { - lateinit var net: MockNetwork + lateinit var mockNet: MockNetwork lateinit var a: MockNetwork.MockNode lateinit var b: MockNetwork.MockNode lateinit var notary: Party @Before fun setup() { - net = MockNetwork() - val nodes = net.createSomeNodes() + mockNet = MockNetwork() + val nodes = mockNet.createSomeNodes() a = nodes.partyNodes[0] b = nodes.partyNodes[1] notary = nodes.notaryNode.info.notaryIdentity - net.runNetwork() + mockNet.runNetwork() } @After fun tearDown() { - net.stopNodes() + mockNet.stopNodes() } } @@ -56,7 +56,7 @@ We'll take a look at the ``makeTransactions`` function in a moment. For now, it' but not node B. The test logic is simple enough: we create the flow, giving it node A's identity as the target to talk to. -Then we start it on node B and use the ``net.runNetwork()`` method to bounce messages around until things have +Then we start it on node B and use the ``mockNet.runNetwork()`` method to bounce messages around until things have settled (i.e. there are no more messages waiting to be delivered). All this is done using an in memory message routing implementation that is fast to initialise and use. Finally, we obtain the result of the flow and do some tests on it. We also check the contents of node B's database to see that the flow had the intended effect diff --git a/finance/src/test/kotlin/net/corda/flows/CashExitFlowTests.kt b/finance/src/test/kotlin/net/corda/flows/CashExitFlowTests.kt index 5754efd8a5..9a09229162 100644 --- a/finance/src/test/kotlin/net/corda/flows/CashExitFlowTests.kt +++ b/finance/src/test/kotlin/net/corda/flows/CashExitFlowTests.kt @@ -16,7 +16,7 @@ import kotlin.test.assertEquals import kotlin.test.assertFailsWith class CashExitFlowTests { - private val net = MockNetwork(servicePeerAllocationStrategy = RoundRobin()) + private val mockNet = MockNetwork(servicePeerAllocationStrategy = RoundRobin()) private val initialBalance = 2000.DOLLARS private val ref = OpaqueBytes.of(0x01) private lateinit var bankOfCordaNode: MockNode @@ -26,23 +26,23 @@ class CashExitFlowTests { @Before fun start() { - val nodes = net.createTwoNodes() + val nodes = mockNet.createTwoNodes() notaryNode = nodes.first bankOfCordaNode = nodes.second notary = notaryNode.info.notaryIdentity bankOfCorda = bankOfCordaNode.info.legalIdentity - net.runNetwork() + mockNet.runNetwork() val future = bankOfCordaNode.services.startFlow(CashIssueFlow(initialBalance, ref, bankOfCorda, notary)).resultFuture - net.runNetwork() + mockNet.runNetwork() future.getOrThrow() } @After fun cleanUp() { - net.stopNodes() + mockNet.stopNodes() } @Test @@ -50,7 +50,7 @@ class CashExitFlowTests { val exitAmount = 500.DOLLARS val future = bankOfCordaNode.services.startFlow(CashExitFlow(exitAmount, ref)).resultFuture - net.runNetwork() + mockNet.runNetwork() val exitTx = future.getOrThrow().tx val expected = (initialBalance - exitAmount).`issued by`(bankOfCorda.ref(ref)) assertEquals(1, exitTx.inputs.size) @@ -64,7 +64,7 @@ class CashExitFlowTests { val expected = 0.DOLLARS val future = bankOfCordaNode.services.startFlow(CashExitFlow(expected, ref)).resultFuture - net.runNetwork() + mockNet.runNetwork() assertFailsWith { future.getOrThrow() } diff --git a/finance/src/test/kotlin/net/corda/flows/CashIssueFlowTests.kt b/finance/src/test/kotlin/net/corda/flows/CashIssueFlowTests.kt index add01685be..5f81c03e40 100644 --- a/finance/src/test/kotlin/net/corda/flows/CashIssueFlowTests.kt +++ b/finance/src/test/kotlin/net/corda/flows/CashIssueFlowTests.kt @@ -16,7 +16,7 @@ import kotlin.test.assertEquals import kotlin.test.assertFailsWith class CashIssueFlowTests { - private val net = MockNetwork(servicePeerAllocationStrategy = RoundRobin()) + private val mockNet = MockNetwork(servicePeerAllocationStrategy = RoundRobin()) private lateinit var bankOfCordaNode: MockNode private lateinit var bankOfCorda: Party private lateinit var notaryNode: MockNode @@ -24,18 +24,18 @@ class CashIssueFlowTests { @Before fun start() { - val nodes = net.createTwoNodes() + val nodes = mockNet.createTwoNodes() notaryNode = nodes.first bankOfCordaNode = nodes.second notary = notaryNode.info.notaryIdentity bankOfCorda = bankOfCordaNode.info.legalIdentity - net.runNetwork() + mockNet.runNetwork() } @After fun cleanUp() { - net.stopNodes() + mockNet.stopNodes() } @Test @@ -45,7 +45,7 @@ class CashIssueFlowTests { val future = bankOfCordaNode.services.startFlow(CashIssueFlow(expected, ref, bankOfCorda, notary)).resultFuture - net.runNetwork() + mockNet.runNetwork() val issueTx = future.getOrThrow() val output = issueTx.tx.outputs.single().data as Cash.State assertEquals(expected.`issued by`(bankOfCorda.ref(ref)), output.amount) @@ -57,7 +57,7 @@ class CashIssueFlowTests { val future = bankOfCordaNode.services.startFlow(CashIssueFlow(expected, OpaqueBytes.of(0x01), bankOfCorda, notary)).resultFuture - net.runNetwork() + mockNet.runNetwork() assertFailsWith { future.getOrThrow() } diff --git a/finance/src/test/kotlin/net/corda/flows/CashPaymentFlowTests.kt b/finance/src/test/kotlin/net/corda/flows/CashPaymentFlowTests.kt index 33f15b0898..577c7c0029 100644 --- a/finance/src/test/kotlin/net/corda/flows/CashPaymentFlowTests.kt +++ b/finance/src/test/kotlin/net/corda/flows/CashPaymentFlowTests.kt @@ -16,7 +16,7 @@ import kotlin.test.assertEquals import kotlin.test.assertFailsWith class CashPaymentFlowTests { - private val net = MockNetwork(servicePeerAllocationStrategy = RoundRobin()) + private val mockNet = MockNetwork(servicePeerAllocationStrategy = RoundRobin()) private val initialBalance = 2000.DOLLARS private val ref = OpaqueBytes.of(0x01) private lateinit var bankOfCordaNode: MockNode @@ -26,23 +26,23 @@ class CashPaymentFlowTests { @Before fun start() { - val nodes = net.createTwoNodes() + val nodes = mockNet.createTwoNodes() notaryNode = nodes.first bankOfCordaNode = nodes.second notary = notaryNode.info.notaryIdentity bankOfCorda = bankOfCordaNode.info.legalIdentity - net.runNetwork() + mockNet.runNetwork() val future = bankOfCordaNode.services.startFlow(CashIssueFlow(initialBalance, ref, bankOfCorda, notary)).resultFuture - net.runNetwork() + mockNet.runNetwork() future.getOrThrow() } @After fun cleanUp() { - net.stopNodes() + mockNet.stopNodes() } @Test @@ -51,7 +51,7 @@ class CashPaymentFlowTests { val expected = 500.DOLLARS val future = bankOfCordaNode.services.startFlow(CashPaymentFlow(expected, payTo)).resultFuture - net.runNetwork() + mockNet.runNetwork() val paymentTx = future.getOrThrow() val states = paymentTx.tx.outputs.map { it.data }.filterIsInstance() val ourState = states.single { it.owner.owningKey != payTo.owningKey } @@ -65,7 +65,7 @@ class CashPaymentFlowTests { val expected = 4000.DOLLARS val future = bankOfCordaNode.services.startFlow(CashPaymentFlow(expected, payTo)).resultFuture - net.runNetwork() + mockNet.runNetwork() assertFailsWith { future.getOrThrow() } @@ -77,7 +77,7 @@ class CashPaymentFlowTests { val expected = 0.DOLLARS val future = bankOfCordaNode.services.startFlow(CashPaymentFlow(expected, payTo)).resultFuture - net.runNetwork() + mockNet.runNetwork() assertFailsWith { future.getOrThrow() } diff --git a/finance/src/test/kotlin/net/corda/flows/IssuerFlowTest.kt b/finance/src/test/kotlin/net/corda/flows/IssuerFlowTest.kt index 4e23555c56..81193c7e1d 100644 --- a/finance/src/test/kotlin/net/corda/flows/IssuerFlowTest.kt +++ b/finance/src/test/kotlin/net/corda/flows/IssuerFlowTest.kt @@ -27,18 +27,18 @@ import kotlin.test.assertEquals import kotlin.test.assertFailsWith class IssuerFlowTest { - lateinit var net: MockNetwork + lateinit var mockNet: MockNetwork lateinit var notaryNode: MockNode lateinit var bankOfCordaNode: MockNode lateinit var bankClientNode: MockNode @Test fun `test issuer flow`() { - net = MockNetwork(false, true) + mockNet = MockNetwork(false, true) ledger { - notaryNode = net.createNotaryNode(null, DUMMY_NOTARY.name) - bankOfCordaNode = net.createPartyNode(notaryNode.info.address, BOC.name) - bankClientNode = net.createPartyNode(notaryNode.info.address, MEGA_CORP.name) + notaryNode = mockNet.createNotaryNode(null, DUMMY_NOTARY.name) + bankOfCordaNode = mockNet.createPartyNode(notaryNode.info.address, BOC.name) + bankClientNode = mockNet.createPartyNode(notaryNode.info.address, MEGA_CORP.name) // using default IssueTo Party Reference val (issuer, issuerResult) = runIssuerAndIssueRequester(bankOfCordaNode, bankClientNode, 1000000.DOLLARS, @@ -58,10 +58,10 @@ class IssuerFlowTest { @Test fun `test issue flow to self`() { - net = MockNetwork(false, true) + mockNet = MockNetwork(false, true) ledger { - notaryNode = net.createNotaryNode(null, DUMMY_NOTARY.name) - bankOfCordaNode = net.createPartyNode(notaryNode.info.address, BOC.name) + notaryNode = mockNet.createNotaryNode(null, DUMMY_NOTARY.name) + bankOfCordaNode = mockNet.createPartyNode(notaryNode.info.address, BOC.name) // using default IssueTo Party Reference val (issuer, issuerResult) = runIssuerAndIssueRequester(bankOfCordaNode, bankOfCordaNode, 1000000.DOLLARS, @@ -74,11 +74,11 @@ class IssuerFlowTest { @Test fun `test concurrent issuer flow`() { - net = MockNetwork(false, true) + mockNet = MockNetwork(false, true) ledger { - notaryNode = net.createNotaryNode(null, DUMMY_NOTARY.name) - bankOfCordaNode = net.createPartyNode(notaryNode.info.address, BOC.name) - bankClientNode = net.createPartyNode(notaryNode.info.address, MEGA_CORP.name) + notaryNode = mockNet.createNotaryNode(null, DUMMY_NOTARY.name) + bankOfCordaNode = mockNet.createPartyNode(notaryNode.info.address, BOC.name) + bankClientNode = mockNet.createPartyNode(notaryNode.info.address, MEGA_CORP.name) // this test exercises the Cashflow issue and move subflows to ensure consistent spending of issued states val amount = 10000.DOLLARS diff --git a/node/src/integration-test/kotlin/net/corda/services/messaging/P2PMessagingTest.kt b/node/src/integration-test/kotlin/net/corda/services/messaging/P2PMessagingTest.kt index 04b69f6c86..a59e81dafe 100644 --- a/node/src/integration-test/kotlin/net/corda/services/messaging/P2PMessagingTest.kt +++ b/node/src/integration-test/kotlin/net/corda/services/messaging/P2PMessagingTest.kt @@ -53,7 +53,7 @@ class P2PMessagingTest : NodeBasedTest() { networkMapNode.respondWith("Hello") val alice = startNode(ALICE.name).getOrThrow() val serviceAddress = alice.services.networkMapCache.run { - alice.net.getAddressOfParty(getPartyInfo(getAnyNotary()!!)!!) + alice.network.getAddressOfParty(getPartyInfo(getAnyNotary()!!)!!) } val received = alice.receiveFrom(serviceAddress).getOrThrow(10.seconds) assertThat(received).isEqualTo("Hello") @@ -98,7 +98,7 @@ class P2PMessagingTest : NodeBasedTest() { val distributedServiceNodes = startNotaryCluster(DISTRIBUTED_SERVICE_NAME, 2).getOrThrow() val alice = startNode(ALICE.name, configOverrides = mapOf("messageRedeliveryDelaySeconds" to 1)).getOrThrow() val serviceAddress = alice.services.networkMapCache.run { - alice.net.getAddressOfParty(getPartyInfo(getAnyNotary()!!)!!) + alice.network.getAddressOfParty(getPartyInfo(getAnyNotary()!!)!!) } val dummyTopic = "dummy.topic" @@ -107,7 +107,7 @@ class P2PMessagingTest : NodeBasedTest() { simulateCrashingNode(distributedServiceNodes, dummyTopic, responseMessage) // Send a single request with retry - val response = with(alice.net) { + val response = with(alice.network) { val request = TestRequest(replyTo = myAddress) val responseFuture = onNext(dummyTopic, request.sessionID) val msg = createMessage(TopicSession(dummyTopic), data = request.serialize().bytes) @@ -123,7 +123,7 @@ class P2PMessagingTest : NodeBasedTest() { val distributedServiceNodes = startNotaryCluster(DISTRIBUTED_SERVICE_NAME, 2).getOrThrow() val alice = startNode(ALICE.name, configOverrides = mapOf("messageRedeliveryDelaySeconds" to 1)).getOrThrow() val serviceAddress = alice.services.networkMapCache.run { - alice.net.getAddressOfParty(getPartyInfo(getAnyNotary()!!)!!) + alice.network.getAddressOfParty(getPartyInfo(getAnyNotary()!!)!!) } val dummyTopic = "dummy.topic" @@ -134,7 +134,7 @@ class P2PMessagingTest : NodeBasedTest() { val sessionId = random63BitValue() // Send a single request with retry - with(alice.net) { + with(alice.network) { val request = TestRequest(sessionId, myAddress) val msg = createMessage(TopicSession(dummyTopic), data = request.serialize().bytes) send(msg, serviceAddress, retryId = request.sessionID) @@ -148,7 +148,7 @@ class P2PMessagingTest : NodeBasedTest() { // Restart the node and expect a response val aliceRestarted = startNode(ALICE.name, configOverrides = mapOf("messageRedeliveryDelaySeconds" to 1)).getOrThrow() - val response = aliceRestarted.net.onNext(dummyTopic, sessionId).getOrThrow(5.seconds) + val response = aliceRestarted.network.onNext(dummyTopic, sessionId).getOrThrow(5.seconds) assertThat(requestsReceived.get()).isGreaterThanOrEqualTo(2) assertThat(response).isEqualTo(responseMessage) @@ -166,7 +166,7 @@ class P2PMessagingTest : NodeBasedTest() { distributedServiceNodes.forEach { val nodeName = it.info.legalIdentity.name var ignoreRequests = false - it.net.addMessageHandler(dummyTopic, DEFAULT_SESSION_ID) { netMessage, _ -> + it.network.addMessageHandler(dummyTopic, DEFAULT_SESSION_ID) { netMessage, _ -> requestsReceived.incrementAndGet() firstRequestReceived.countDown() // The node which receives the first request will ignore all requests @@ -179,8 +179,8 @@ class P2PMessagingTest : NodeBasedTest() { } else { println("sending response") val request = netMessage.data.deserialize() - val response = it.net.createMessage(dummyTopic, request.sessionID, responseMessage.serialize().bytes) - it.net.send(response, request.replyTo) + val response = it.network.createMessage(dummyTopic, request.sessionID, responseMessage.serialize().bytes) + it.network.send(response, request.replyTo) } } } @@ -193,7 +193,7 @@ class P2PMessagingTest : NodeBasedTest() { node.respondWith(node.info) } val serviceAddress = originatingNode.services.networkMapCache.run { - originatingNode.net.getAddressOfParty(getPartyInfo(getNotary(serviceName)!!)!!) + originatingNode.network.getAddressOfParty(getPartyInfo(getNotary(serviceName)!!)!!) } val participatingNodes = HashSet() // Try several times so that we can be fairly sure that any node not participating is not due to Artemis' selection @@ -209,16 +209,16 @@ class P2PMessagingTest : NodeBasedTest() { } private fun Node.respondWith(message: Any) { - net.addMessageHandler(javaClass.name, DEFAULT_SESSION_ID) { netMessage, _ -> + network.addMessageHandler(javaClass.name, DEFAULT_SESSION_ID) { netMessage, _ -> val request = netMessage.data.deserialize() - val response = net.createMessage(javaClass.name, request.sessionID, message.serialize().bytes) - net.send(response, request.replyTo) + val response = network.createMessage(javaClass.name, request.sessionID, message.serialize().bytes) + network.send(response, request.replyTo) } } private fun Node.receiveFrom(target: MessageRecipients): ListenableFuture { - val request = TestRequest(replyTo = net.myAddress) - return net.sendRequest(javaClass.name, request, target) + val request = TestRequest(replyTo = network.myAddress) + return network.sendRequest(javaClass.name, request, target) } @CordaSerializable diff --git a/node/src/integration-test/kotlin/net/corda/services/messaging/P2PSecurityTest.kt b/node/src/integration-test/kotlin/net/corda/services/messaging/P2PSecurityTest.kt index 2e37fa7595..a0eaea5923 100644 --- a/node/src/integration-test/kotlin/net/corda/services/messaging/P2PSecurityTest.kt +++ b/node/src/integration-test/kotlin/net/corda/services/messaging/P2PSecurityTest.kt @@ -69,9 +69,9 @@ class P2PSecurityTest : NodeBasedTest() { private fun SimpleNode.registerWithNetworkMap(registrationName: X500Name): ListenableFuture { val legalIdentity = getTestPartyAndCertificate(registrationName, identity.public) - val nodeInfo = NodeInfo(net.myAddress, legalIdentity, MOCK_VERSION_INFO.platformVersion) + val nodeInfo = NodeInfo(network.myAddress, legalIdentity, MOCK_VERSION_INFO.platformVersion) val registration = NodeRegistration(nodeInfo, System.currentTimeMillis(), AddOrRemove.ADD, Instant.MAX) - val request = RegistrationRequest(registration.toWire(keyService, identity.public), net.myAddress) - return net.sendRequest(NetworkMapService.REGISTER_TOPIC, request, networkMapNode.net.myAddress) + val request = RegistrationRequest(registration.toWire(keyService, identity.public), network.myAddress) + return network.sendRequest(NetworkMapService.REGISTER_TOPIC, request, networkMapNode.network.myAddress) } } diff --git a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt index d81753a44f..f35be3135b 100644 --- a/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt +++ b/node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt @@ -116,7 +116,7 @@ abstract class AbstractNode(open val configuration: NodeConfiguration, protected val partyKeys = mutableSetOf() val services = object : ServiceHubInternal() { - override val networkService: MessagingService get() = net + override val networkService: MessagingService get() = network override val networkMapCache: NetworkMapCacheInternal get() = netMapCache override val storageService: TxWritableStorageService get() = storage override val vaultService: VaultService get() = vault @@ -167,7 +167,7 @@ abstract class AbstractNode(open val configuration: NodeConfiguration, var inNodeNetworkMapService: NetworkMapService? = null lateinit var txVerifierService: TransactionVerifierService lateinit var identity: IdentityService - lateinit var net: MessagingService + lateinit var network: MessagingService lateinit var netMapCache: NetworkMapCacheInternal lateinit var scheduler: NodeSchedulerService lateinit var schemas: SchemaService @@ -255,7 +255,7 @@ abstract class AbstractNode(open val configuration: NodeConfiguration, initUploaders() - runOnStop += Runnable { net.stop() } + runOnStop += Runnable { network.stop() } _networkMapRegistrationFuture.setFuture(registerWithNetworkMapIfConfigured()) smm.start(tokenizableServices) // Shut down the SMM so no Fibers are scheduled. @@ -437,7 +437,7 @@ abstract class AbstractNode(open val configuration: NodeConfiguration, storage = storageServices.first checkpointStorage = storageServices.second netMapCache = InMemoryNetworkMapCache() - net = makeMessagingService() + network = makeMessagingService() schemas = makeSchemaService() vault = makeVaultService(configuration.dataSourceProperties) txVerifierService = makeTransactionVerifierService() @@ -451,7 +451,7 @@ abstract class AbstractNode(open val configuration: NodeConfiguration, keyManagement = makeKeyManagementService(identity) scheduler = NodeSchedulerService(services, database, unfinishedSchedules = busyNodeLatch) - val tokenizableServices = mutableListOf(storage, net, vault, keyManagement, identity, platformClock, scheduler) + val tokenizableServices = mutableListOf(storage, network, vault, keyManagement, identity, platformClock, scheduler) makeAdvertisedServices(tokenizableServices) return tokenizableServices @@ -523,7 +523,7 @@ abstract class AbstractNode(open val configuration: NodeConfiguration, private fun makeInfo(): NodeInfo { val advertisedServiceEntries = makeServiceEntries() val legalIdentity = obtainLegalIdentity() - return NodeInfo(net.myAddress, legalIdentity, platformVersion, advertisedServiceEntries, findMyLocation()) + return NodeInfo(network.myAddress, legalIdentity, platformVersion, advertisedServiceEntries, findMyLocation()) } /** @@ -617,7 +617,7 @@ abstract class AbstractNode(open val configuration: NodeConfiguration, return sendNetworkMapRegistration(address).flatMap { (error) -> check(error == null) { "Unable to register with the network map service: $error" } // The future returned addMapService will complete on the same executor as sendNetworkMapRegistration, namely the one used by net - services.networkMapCache.addMapService(net, address, true, null) + services.networkMapCache.addMapService(network, address, true, null) } } @@ -627,8 +627,8 @@ abstract class AbstractNode(open val configuration: NodeConfiguration, val expires = instant + NetworkMapService.DEFAULT_EXPIRATION_PERIOD val reg = NodeRegistration(info, instant.toEpochMilli(), ADD, expires) val legalIdentityKey = obtainLegalIdentityKey() - val request = NetworkMapService.RegistrationRequest(reg.toWire(keyManagement, legalIdentityKey.public), net.myAddress) - return net.sendRequest(NetworkMapService.REGISTER_TOPIC, request, networkMapAddress) + val request = NetworkMapService.RegistrationRequest(reg.toWire(keyManagement, legalIdentityKey.public), network.myAddress) + return network.sendRequest(NetworkMapService.REGISTER_TOPIC, request, networkMapAddress) } /** This is overriden by the mock node implementation to enable operation without any network map service */ diff --git a/node/src/main/kotlin/net/corda/node/internal/Node.kt b/node/src/main/kotlin/net/corda/node/internal/Node.kt index 2377284f63..3ca1b97c4e 100644 --- a/node/src/main/kotlin/net/corda/node/internal/Node.kt +++ b/node/src/main/kotlin/net/corda/node/internal/Node.kt @@ -71,7 +71,7 @@ class Node(override val configuration: FullNodeConfiguration, override val log: Logger get() = logger override val platformVersion: Int get() = versionInfo.platformVersion override val networkMapAddress: NetworkMapAddress? get() = configuration.networkMapService?.address?.let(::NetworkMapAddress) - override fun makeTransactionVerifierService() = (net as NodeMessagingClient).verifierService + override fun makeTransactionVerifierService() = (network as NodeMessagingClient).verifierService // DISCUSSION // @@ -232,8 +232,7 @@ class Node(override val configuration: FullNodeConfiguration, } // Start up the MQ client. - val net = net as NodeMessagingClient - net.start(rpcOps, userService) + (network as NodeMessagingClient).start(rpcOps, userService) } /** @@ -321,7 +320,7 @@ class Node(override val configuration: FullNodeConfiguration, /** Starts a blocking event loop for message dispatch. */ fun run() { - (net as NodeMessagingClient).run(messageBroker!!.serverControl) + (network as NodeMessagingClient).run(messageBroker!!.serverControl) } // TODO: Do we really need setup? diff --git a/node/src/main/kotlin/net/corda/node/services/api/AbstractNodeService.kt b/node/src/main/kotlin/net/corda/node/services/api/AbstractNodeService.kt index 13edf41170..5c974fcfb1 100644 --- a/node/src/main/kotlin/net/corda/node/services/api/AbstractNodeService.kt +++ b/node/src/main/kotlin/net/corda/node/services/api/AbstractNodeService.kt @@ -13,7 +13,7 @@ import javax.annotation.concurrent.ThreadSafe @ThreadSafe abstract class AbstractNodeService(val services: ServiceHubInternal) : SingletonSerializeAsToken() { - val net: MessagingService get() = services.networkService + val network: MessagingService get() = services.networkService /** * Register a handler for a message topic. In comparison to using net.addMessageHandler() this manages a lot of @@ -28,14 +28,14 @@ abstract class AbstractNodeService(val services: ServiceHubInternal) : Singleton addMessageHandler(topic: String, crossinline handler: (Q) -> R, crossinline exceptionConsumer: (Message, Exception) -> Unit): MessageHandlerRegistration { - return net.addMessageHandler(topic, DEFAULT_SESSION_ID) { message, _ -> + return network.addMessageHandler(topic, DEFAULT_SESSION_ID) { message, _ -> try { val request = message.data.deserialize() val response = handler(request) // If the return type R is Unit, then do not send a response if (response.javaClass != Unit.javaClass) { - val msg = net.createMessage(topic, request.sessionID, response.serialize().bytes) - net.send(msg, request.replyTo) + val msg = network.createMessage(topic, request.sessionID, response.serialize().bytes) + network.send(msg, request.replyTo) } } catch(e: Exception) { exceptionConsumer(message, e) diff --git a/node/src/main/kotlin/net/corda/node/services/api/ServiceHubInternal.kt b/node/src/main/kotlin/net/corda/node/services/api/ServiceHubInternal.kt index 805e23c3a8..646af40f07 100644 --- a/node/src/main/kotlin/net/corda/node/services/api/ServiceHubInternal.kt +++ b/node/src/main/kotlin/net/corda/node/services/api/ServiceHubInternal.kt @@ -21,21 +21,21 @@ import net.corda.node.services.statemachine.FlowStateMachineImpl interface NetworkMapCacheInternal : NetworkMapCache { /** * Deregister from updates from the given map service. - * @param net the network messaging service. + * @param network the network messaging service. * @param service the network map service to fetch current state from. */ - fun deregisterForUpdates(net: MessagingService, service: NodeInfo): ListenableFuture + fun deregisterForUpdates(network: MessagingService, service: NodeInfo): ListenableFuture /** * Add a network map service; fetches a copy of the latest map from the service and subscribes to any further * updates. - * @param net the network messaging service. + * @param network the network messaging service. * @param networkMapAddress the network map service to fetch current state from. * @param subscribe if the cache should subscribe to updates. * @param ifChangedSinceVer an optional version number to limit updating the map based on. If the latest map * version is less than or equal to the given version, no update is fetched. */ - fun addMapService(net: MessagingService, networkMapAddress: SingleMessageRecipient, + fun addMapService(network: MessagingService, networkMapAddress: SingleMessageRecipient, subscribe: Boolean, ifChangedSinceVer: Int? = null): ListenableFuture /** Adds a node to the local cache (generally only used for adding ourselves). */ diff --git a/node/src/main/kotlin/net/corda/node/services/network/InMemoryNetworkMapCache.kt b/node/src/main/kotlin/net/corda/node/services/network/InMemoryNetworkMapCache.kt index 1f996b00d9..e1b2664b90 100644 --- a/node/src/main/kotlin/net/corda/node/services/network/InMemoryNetworkMapCache.kt +++ b/node/src/main/kotlin/net/corda/node/services/network/InMemoryNetworkMapCache.kt @@ -77,16 +77,16 @@ open class InMemoryNetworkMapCache : SingletonSerializeAsToken(), NetworkMapCach } } - override fun addMapService(net: MessagingService, networkMapAddress: SingleMessageRecipient, subscribe: Boolean, + override fun addMapService(network: MessagingService, networkMapAddress: SingleMessageRecipient, subscribe: Boolean, ifChangedSinceVer: Int?): ListenableFuture { if (subscribe && !registeredForPush) { // Add handler to the network, for updates received from the remote network map service. - net.addMessageHandler(NetworkMapService.PUSH_TOPIC, DEFAULT_SESSION_ID) { message, _ -> + network.addMessageHandler(NetworkMapService.PUSH_TOPIC, DEFAULT_SESSION_ID) { message, _ -> try { val req = message.data.deserialize() - val ackMessage = net.createMessage(NetworkMapService.PUSH_ACK_TOPIC, DEFAULT_SESSION_ID, - NetworkMapService.UpdateAcknowledge(req.mapVersion, net.myAddress).serialize().bytes) - net.send(ackMessage, req.replyTo) + val ackMessage = network.createMessage(NetworkMapService.PUSH_ACK_TOPIC, DEFAULT_SESSION_ID, + NetworkMapService.UpdateAcknowledge(req.mapVersion, network.myAddress).serialize().bytes) + network.send(ackMessage, req.replyTo) processUpdatePush(req) } catch(e: NodeMapError) { logger.warn("Failure during node map update due to bad update: ${e.javaClass.name}") @@ -98,8 +98,8 @@ open class InMemoryNetworkMapCache : SingletonSerializeAsToken(), NetworkMapCach } // Fetch the network map and register for updates at the same time - val req = NetworkMapService.FetchMapRequest(subscribe, ifChangedSinceVer, net.myAddress) - val future = net.sendRequest(NetworkMapService.FETCH_TOPIC, req, networkMapAddress).map { (nodes) -> + val req = NetworkMapService.FetchMapRequest(subscribe, ifChangedSinceVer, network.myAddress) + val future = network.sendRequest(NetworkMapService.FETCH_TOPIC, req, networkMapAddress).map { (nodes) -> // We may not receive any nodes back, if the map hasn't changed since the version specified nodes?.forEach { processRegistration(it) } Unit @@ -131,10 +131,10 @@ open class InMemoryNetworkMapCache : SingletonSerializeAsToken(), NetworkMapCach * Unsubscribes from updates from the given map service. * @param service the network map service to listen to updates from. */ - override fun deregisterForUpdates(net: MessagingService, service: NodeInfo): ListenableFuture { + override fun deregisterForUpdates(network: MessagingService, service: NodeInfo): ListenableFuture { // Fetch the network map and register for updates at the same time - val req = NetworkMapService.SubscribeRequest(false, net.myAddress) - val future = net.sendRequest(NetworkMapService.SUBSCRIPTION_TOPIC, req, service.address).map { + val req = NetworkMapService.SubscribeRequest(false, network.myAddress) + val future = network.sendRequest(NetworkMapService.SUBSCRIPTION_TOPIC, req, service.address).map { if (it.confirmed) Unit else throw NetworkCacheError.DeregistrationFailed() } _registrationFuture.setFuture(future) diff --git a/node/src/main/kotlin/net/corda/node/services/network/NetworkMapService.kt b/node/src/main/kotlin/net/corda/node/services/network/NetworkMapService.kt index f69779844f..035a1a506c 100644 --- a/node/src/main/kotlin/net/corda/node/services/network/NetworkMapService.kt +++ b/node/src/main/kotlin/net/corda/node/services/network/NetworkMapService.kt @@ -172,7 +172,7 @@ abstract class AbstractNetworkMapService(services: ServiceHubInternal, handlers += addMessageHandler(QUERY_TOPIC) { req: QueryIdentityRequest -> processQueryRequest(req) } handlers += addMessageHandler(REGISTER_TOPIC) { req: RegistrationRequest -> processRegistrationRequest(req) } handlers += addMessageHandler(SUBSCRIPTION_TOPIC) { req: SubscribeRequest -> processSubscriptionRequest(req) } - handlers += net.addMessageHandler(PUSH_ACK_TOPIC, DEFAULT_SESSION_ID) { message, _ -> + handlers += network.addMessageHandler(PUSH_ACK_TOPIC, DEFAULT_SESSION_ID) { message, _ -> val req = message.data.deserialize() processAcknowledge(req) } @@ -181,7 +181,7 @@ abstract class AbstractNetworkMapService(services: ServiceHubInternal, @VisibleForTesting fun unregisterNetworkHandlers() { for (handler in handlers) { - net.removeMessageHandler(handler) + network.removeMessageHandler(handler) } handlers.clear() } @@ -289,14 +289,14 @@ abstract class AbstractNetworkMapService(services: ServiceHubInternal, // TODO: Once we have a better established messaging system, we can probably send // to a MessageRecipientGroup that nodes join/leave, rather than the network map // service itself managing the group - val update = NetworkMapService.Update(wireReg, newMapVersion, net.myAddress).serialize().bytes - val message = net.createMessage(PUSH_TOPIC, DEFAULT_SESSION_ID, update) + val update = NetworkMapService.Update(wireReg, newMapVersion, network.myAddress).serialize().bytes + val message = network.createMessage(PUSH_TOPIC, DEFAULT_SESSION_ID, update) subscribers.locked { // Remove any stale subscribers values.removeIf { (mapVersion) -> newMapVersion - mapVersion > maxUnacknowledgedUpdates } // TODO: introduce some concept of time in the condition to avoid unsubscribes when there's a message burst. - keys.forEach { recipient -> net.send(message, recipient) } + keys.forEach { recipient -> network.send(message, recipient) } } } diff --git a/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt b/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt index da63771508..1a87c42034 100644 --- a/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt +++ b/node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt @@ -47,7 +47,7 @@ class CordaRPCOpsImplTest { val testJar = "net/corda/node/testing/test.jar" } - lateinit var network: MockNetwork + lateinit var mockNet: MockNetwork lateinit var aliceNode: MockNode lateinit var notaryNode: MockNode lateinit var rpc: CordaRPCOpsImpl @@ -57,10 +57,10 @@ class CordaRPCOpsImplTest { @Before fun setup() { - network = MockNetwork() - val networkMap = network.createNode(advertisedServices = ServiceInfo(NetworkMapService.type)) - aliceNode = network.createNode(networkMapAddress = networkMap.info.address) - notaryNode = network.createNode(advertisedServices = ServiceInfo(SimpleNotaryService.type), networkMapAddress = networkMap.info.address) + mockNet = MockNetwork() + val networkMap = mockNet.createNode(advertisedServices = ServiceInfo(NetworkMapService.type)) + aliceNode = mockNet.createNode(networkMapAddress = networkMap.info.address) + notaryNode = mockNet.createNode(advertisedServices = ServiceInfo(SimpleNotaryService.type), networkMapAddress = networkMap.info.address) rpc = CordaRPCOpsImpl(aliceNode.services, aliceNode.smm, aliceNode.database) CURRENT_RPC_CONTEXT.set(RpcContext(User("user", "pwd", permissions = setOf( startFlowPermission(), @@ -87,7 +87,7 @@ class CordaRPCOpsImplTest { // Tell the monitoring service node to issue some cash val recipient = aliceNode.info.legalIdentity rpc.startFlow(::CashIssueFlow, Amount(quantity, GBP), ref, recipient, notaryNode.info.notaryIdentity) - network.runNetwork() + mockNet.runNetwork() val expectedState = Cash.State(Amount(quantity, Issued(aliceNode.info.legalIdentity.ref(ref), GBP)), @@ -129,11 +129,11 @@ class CordaRPCOpsImplTest { notaryNode.info.notaryIdentity ) - network.runNetwork() + mockNet.runNetwork() rpc.startFlow(::CashPaymentFlow, Amount(100, USD), aliceNode.info.legalIdentity) - network.runNetwork() + mockNet.runNetwork() var issueSmId: StateMachineRunId? = null var moveSmId: StateMachineRunId? = null diff --git a/node/src/test/kotlin/net/corda/node/messaging/AttachmentTests.kt b/node/src/test/kotlin/net/corda/node/messaging/AttachmentTests.kt index f0322fb400..bb6f59c78f 100644 --- a/node/src/test/kotlin/net/corda/node/messaging/AttachmentTests.kt +++ b/node/src/test/kotlin/net/corda/node/messaging/AttachmentTests.kt @@ -31,14 +31,14 @@ import kotlin.test.assertEquals import kotlin.test.assertFailsWith class AttachmentTests { - lateinit var network: MockNetwork + lateinit var mockNet: MockNetwork lateinit var dataSource: Closeable lateinit var database: Database lateinit var configuration: RequeryConfiguration @Before fun setUp() { - network = MockNetwork() + mockNet = MockNetwork() val dataSourceProperties = makeTestDataSourceProperties() @@ -57,7 +57,7 @@ class AttachmentTests { @Test fun `download and store`() { - val (n0, n1) = network.createTwoNodes() + val (n0, n1) = mockNet.createTwoNodes() // Insert an attachment into node zero's store directly. val id = n0.database.transaction { @@ -65,9 +65,9 @@ class AttachmentTests { } // Get node one to run a flow to fetch it and insert it. - network.runNetwork() + mockNet.runNetwork() val f1 = n1.services.startFlow(FetchAttachmentsFlow(setOf(id), n0.info.legalIdentity)) - network.runNetwork() + mockNet.runNetwork() assertEquals(0, f1.resultFuture.getOrThrow().fromDisk.size) // Verify it was inserted into node one's store. @@ -86,13 +86,13 @@ class AttachmentTests { @Test fun `missing`() { - val (n0, n1) = network.createTwoNodes() + val (n0, n1) = mockNet.createTwoNodes() // Get node one to fetch a non-existent attachment. val hash = SecureHash.randomSHA256() - network.runNetwork() + mockNet.runNetwork() val f1 = n1.services.startFlow(FetchAttachmentsFlow(setOf(hash), n0.info.legalIdentity)) - network.runNetwork() + mockNet.runNetwork() val e = assertFailsWith { f1.resultFuture.getOrThrow() } assertEquals(hash, e.requested) } @@ -100,7 +100,7 @@ class AttachmentTests { @Test fun `malicious response`() { // Make a node that doesn't do sanity checking at load time. - val n0 = network.createNode(null, -1, object : MockNetwork.Factory { + val n0 = mockNet.createNode(null, -1, object : MockNetwork.Factory { override fun create(config: NodeConfiguration, network: MockNetwork, networkMapAddr: SingleMessageRecipient?, advertisedServices: Set, id: Int, overrideServices: Map?, @@ -114,7 +114,7 @@ class AttachmentTests { } } }, true, null, null, ServiceInfo(NetworkMapService.type), ServiceInfo(SimpleNotaryService.type)) - val n1 = network.createNode(n0.info.address) + val n1 = mockNet.createNode(n0.info.address) val attachment = fakeAttachment() // Insert an attachment into node zero's store directly. @@ -135,9 +135,9 @@ class AttachmentTests { // Get n1 to fetch the attachment. Should receive corrupted bytes. - network.runNetwork() + mockNet.runNetwork() val f1 = n1.services.startFlow(FetchAttachmentsFlow(setOf(id), n0.info.legalIdentity)) - network.runNetwork() + mockNet.runNetwork() assertFailsWith { f1.resultFuture.getOrThrow() } } } diff --git a/node/src/test/kotlin/net/corda/node/messaging/InMemoryMessagingTests.kt b/node/src/test/kotlin/net/corda/node/messaging/InMemoryMessagingTests.kt index e62045e315..bf6c2755fe 100644 --- a/node/src/test/kotlin/net/corda/node/messaging/InMemoryMessagingTests.kt +++ b/node/src/test/kotlin/net/corda/node/messaging/InMemoryMessagingTests.kt @@ -14,7 +14,7 @@ import kotlin.test.assertFails import kotlin.test.assertTrue class InMemoryMessagingTests { - val network = MockNetwork() + val mockNet = MockNetwork() @Test fun topicStringValidation() { @@ -33,45 +33,45 @@ class InMemoryMessagingTests { @Test fun basics() { - val node1 = network.createNode(advertisedServices = ServiceInfo(NetworkMapService.type)) - val node2 = network.createNode(networkMapAddress = node1.info.address) - val node3 = network.createNode(networkMapAddress = node1.info.address) + val node1 = mockNet.createNode(advertisedServices = ServiceInfo(NetworkMapService.type)) + val node2 = mockNet.createNode(networkMapAddress = node1.info.address) + val node3 = mockNet.createNode(networkMapAddress = node1.info.address) val bits = "test-content".toByteArray() var finalDelivery: Message? = null with(node2) { - node2.net.addMessageHandler { msg, _ -> - node2.net.send(msg, node3.info.address) + node2.network.addMessageHandler { msg, _ -> + node2.network.send(msg, node3.info.address) } } with(node3) { - node2.net.addMessageHandler { msg, _ -> + node2.network.addMessageHandler { msg, _ -> finalDelivery = msg } } // Node 1 sends a message and it should end up in finalDelivery, after we run the network - node1.net.send(node1.net.createMessage("test.topic", DEFAULT_SESSION_ID, bits), node2.info.address) + node1.network.send(node1.network.createMessage("test.topic", DEFAULT_SESSION_ID, bits), node2.info.address) - network.runNetwork(rounds = 1) + mockNet.runNetwork(rounds = 1) assertTrue(Arrays.equals(finalDelivery!!.data, bits)) } @Test fun broadcast() { - val node1 = network.createNode(advertisedServices = ServiceInfo(NetworkMapService.type)) - val node2 = network.createNode(networkMapAddress = node1.info.address) - val node3 = network.createNode(networkMapAddress = node1.info.address) + val node1 = mockNet.createNode(advertisedServices = ServiceInfo(NetworkMapService.type)) + val node2 = mockNet.createNode(networkMapAddress = node1.info.address) + val node3 = mockNet.createNode(networkMapAddress = node1.info.address) val bits = "test-content".toByteArray() var counter = 0 - listOf(node1, node2, node3).forEach { it.net.addMessageHandler { _, _ -> counter++ } } - node1.net.send(node2.net.createMessage("test.topic", DEFAULT_SESSION_ID, bits), network.messagingNetwork.everyoneOnline) - network.runNetwork(rounds = 1) + listOf(node1, node2, node3).forEach { it.network.addMessageHandler { _, _ -> counter++ } } + node1.network.send(node2.network.createMessage("test.topic", DEFAULT_SESSION_ID, bits), mockNet.messagingNetwork.everyoneOnline) + mockNet.runNetwork(rounds = 1) assertEquals(3, counter) } @@ -81,31 +81,31 @@ class InMemoryMessagingTests { */ @Test fun `skip unhandled messages`() { - val node1 = network.createNode(advertisedServices = ServiceInfo(NetworkMapService.type)) - val node2 = network.createNode(networkMapAddress = node1.info.address) + val node1 = mockNet.createNode(advertisedServices = ServiceInfo(NetworkMapService.type)) + val node2 = mockNet.createNode(networkMapAddress = node1.info.address) var received: Int = 0 - node1.net.addMessageHandler("valid_message") { _, _ -> + node1.network.addMessageHandler("valid_message") { _, _ -> received++ } - val invalidMessage = node2.net.createMessage("invalid_message", DEFAULT_SESSION_ID, ByteArray(0)) - val validMessage = node2.net.createMessage("valid_message", DEFAULT_SESSION_ID, ByteArray(0)) - node2.net.send(invalidMessage, node1.net.myAddress) - network.runNetwork() + val invalidMessage = node2.network.createMessage("invalid_message", DEFAULT_SESSION_ID, ByteArray(0)) + val validMessage = node2.network.createMessage("valid_message", DEFAULT_SESSION_ID, ByteArray(0)) + node2.network.send(invalidMessage, node1.network.myAddress) + mockNet.runNetwork() assertEquals(0, received) - node2.net.send(validMessage, node1.net.myAddress) - network.runNetwork() + node2.network.send(validMessage, node1.network.myAddress) + mockNet.runNetwork() assertEquals(1, received) // Here's the core of the test; previously the unhandled message would cause runNetwork() to abort early, so // this would fail. Make fresh messages to stop duplicate uniqueMessageId causing drops - val invalidMessage2 = node2.net.createMessage("invalid_message", DEFAULT_SESSION_ID, ByteArray(0)) - val validMessage2 = node2.net.createMessage("valid_message", DEFAULT_SESSION_ID, ByteArray(0)) - node2.net.send(invalidMessage2, node1.net.myAddress) - node2.net.send(validMessage2, node1.net.myAddress) - network.runNetwork() + val invalidMessage2 = node2.network.createMessage("invalid_message", DEFAULT_SESSION_ID, ByteArray(0)) + val validMessage2 = node2.network.createMessage("valid_message", DEFAULT_SESSION_ID, ByteArray(0)) + node2.network.send(invalidMessage2, node1.network.myAddress) + node2.network.send(validMessage2, node1.network.myAddress) + mockNet.runNetwork() assertEquals(2, received) } } diff --git a/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt b/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt index e74528b80c..c35d30c5c1 100644 --- a/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt +++ b/node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt @@ -59,11 +59,11 @@ import kotlin.test.assertTrue * We assume that Alice and Bob already found each other via some market, and have agreed the details already. */ class TwoPartyTradeFlowTests { - lateinit var net: MockNetwork + lateinit var mockNet: MockNetwork @Before fun before() { - net = MockNetwork(false) + mockNet = MockNetwork(false) LogHelper.setLevel("platform.trade", "core.contract.TransactionGroup", "recordingmap") } @@ -77,10 +77,10 @@ class TwoPartyTradeFlowTests { // We run this in parallel threads to help catch any race conditions that may exist. The other tests // we run in the unit test thread exclusively to speed things up, ensure deterministic results and // allow interruption half way through. - net = MockNetwork(false, true) + mockNet = MockNetwork(false, true) ledger { - val basketOfNodes = net.createSomeNodes(2) + val basketOfNodes = mockNet.createSomeNodes(2) val notaryNode = basketOfNodes.notaryNode val aliceNode = basketOfNodes.partyNodes[0] val bobNode = basketOfNodes.partyNodes[1] @@ -122,12 +122,12 @@ class TwoPartyTradeFlowTests { @Test(expected = InsufficientBalanceException::class) fun `trade cash for commercial paper fails using soft locking`() { - net = MockNetwork(false, true) + mockNet = MockNetwork(false, true) ledger { - val notaryNode = net.createNotaryNode(null, DUMMY_NOTARY.name) - val aliceNode = net.createPartyNode(notaryNode.info.address, ALICE.name) - val bobNode = net.createPartyNode(notaryNode.info.address, BOB.name) + val notaryNode = mockNet.createNotaryNode(null, DUMMY_NOTARY.name) + val aliceNode = mockNet.createPartyNode(notaryNode.info.address, ALICE.name) + val bobNode = mockNet.createPartyNode(notaryNode.info.address, BOB.name) aliceNode.disableDBCloseOnStop() bobNode.disableDBCloseOnStop() @@ -171,16 +171,16 @@ class TwoPartyTradeFlowTests { @Test fun `shutdown and restore`() { ledger { - val notaryNode = net.createNotaryNode(null, DUMMY_NOTARY.name) - val aliceNode = net.createPartyNode(notaryNode.info.address, ALICE.name) - var bobNode = net.createPartyNode(notaryNode.info.address, BOB.name) + val notaryNode = mockNet.createNotaryNode(null, DUMMY_NOTARY.name) + val aliceNode = mockNet.createPartyNode(notaryNode.info.address, ALICE.name) + var bobNode = mockNet.createPartyNode(notaryNode.info.address, BOB.name) aliceNode.disableDBCloseOnStop() bobNode.disableDBCloseOnStop() - val bobAddr = bobNode.net.myAddress as InMemoryMessagingNetwork.PeerHandle + val bobAddr = bobNode.network.myAddress as InMemoryMessagingNetwork.PeerHandle val networkMapAddr = notaryNode.info.address - net.runNetwork() // Clear network map registration messages + mockNet.runNetwork() // Clear network map registration messages bobNode.database.transaction { bobNode.services.fillWithSomeTestCash(2000.DOLLARS, outputNotary = notaryNode.info.notaryIdentity) @@ -224,7 +224,7 @@ class TwoPartyTradeFlowTests { // ... bring the node back up ... the act of constructing the SMM will re-register the message handlers // that Bob was waiting on before the reboot occurred. - bobNode = net.createNode(networkMapAddr, bobAddr.id, object : MockNetwork.Factory { + bobNode = mockNet.createNode(networkMapAddr, bobAddr.id, object : MockNetwork.Factory { override fun create(config: NodeConfiguration, network: MockNetwork, networkMapAddr: SingleMessageRecipient?, advertisedServices: Set, id: Int, overrideServices: Map?, entropyRoot: BigInteger): MockNetwork.MockNode { @@ -236,7 +236,7 @@ class TwoPartyTradeFlowTests { val bobFuture = bobNode.smm.findStateMachines(BuyerAcceptor::class.java).single().second // And off we go again. - net.runNetwork() + mockNet.runNetwork() // Bob is now finished and has the same transaction as Alice. assertThat(bobFuture.getOrThrow()).isEqualTo(aliceFuture.getOrThrow()) @@ -266,7 +266,7 @@ class TwoPartyTradeFlowTests { name: X500Name, overrideServices: Map? = null): MockNetwork.MockNode { // Create a node in the mock network ... - return net.createNode(networkMapAddr, -1, object : MockNetwork.Factory { + return mockNet.createNode(networkMapAddr, -1, object : MockNetwork.Factory { override fun create(config: NodeConfiguration, network: MockNetwork, networkMapAddr: SingleMessageRecipient?, @@ -289,7 +289,7 @@ class TwoPartyTradeFlowTests { @Test fun `check dependencies of sale asset are resolved`() { - val notaryNode = net.createNotaryNode(null, DUMMY_NOTARY.name) + val notaryNode = mockNet.createNotaryNode(null, DUMMY_NOTARY.name) val aliceNode = makeNodeWithTracking(notaryNode.info.address, ALICE.name) val bobNode = makeNodeWithTracking(notaryNode.info.address, BOB.name) @@ -317,11 +317,11 @@ class TwoPartyTradeFlowTests { } val alicesSignedTxns = insertFakeTransactions(alicesFakePaper, aliceNode, notaryNode, MEGA_CORP_PUBKEY) - net.runNetwork() // Clear network map registration messages + mockNet.runNetwork() // Clear network map registration messages runBuyerAndSeller(notaryNode, aliceNode, bobNode, "alice's paper".outputStateAndRef()) - net.runNetwork() + mockNet.runNetwork() run { val records = (bobNode.storage.validatedTransactions as RecordingTransactionStorage).records @@ -388,7 +388,7 @@ class TwoPartyTradeFlowTests { @Test fun `track works`() { - val notaryNode = net.createNotaryNode(null, DUMMY_NOTARY.name) + val notaryNode = mockNet.createNotaryNode(null, DUMMY_NOTARY.name) val aliceNode = makeNodeWithTracking(notaryNode.info.address, ALICE.name) val bobNode = makeNodeWithTracking(notaryNode.info.address, BOB.name) @@ -418,14 +418,14 @@ class TwoPartyTradeFlowTests { insertFakeTransactions(alicesFakePaper, aliceNode, notaryNode, MEGA_CORP_PUBKEY) - net.runNetwork() // Clear network map registration messages + mockNet.runNetwork() // Clear network map registration messages val aliceTxStream = aliceNode.storage.validatedTransactions.track().second val aliceTxMappings = with(aliceNode) { database.transaction { storage.stateMachineRecordedTransactionMapping.track().second } } val aliceSmId = runBuyerAndSeller(notaryNode, aliceNode, bobNode, "alice's paper".outputStateAndRef()).sellerId - net.runNetwork() + mockNet.runNetwork() // We need to declare this here, if we do it inside [expectEvents] kotlin throws an internal compiler error(!). val aliceTxExpectations = sequence( @@ -526,9 +526,9 @@ class TwoPartyTradeFlowTests { aliceError: Boolean, expectedMessageSubstring: String ) { - val notaryNode = net.createNotaryNode(null, DUMMY_NOTARY.name) - val aliceNode = net.createPartyNode(notaryNode.info.address, ALICE.name) - val bobNode = net.createPartyNode(notaryNode.info.address, BOB.name) + val notaryNode = mockNet.createNotaryNode(null, DUMMY_NOTARY.name) + val aliceNode = mockNet.createPartyNode(notaryNode.info.address, ALICE.name) + val bobNode = mockNet.createPartyNode(notaryNode.info.address, BOB.name) val issuer = MEGA_CORP.ref(1, 2, 3) val bobsBadCash = bobNode.database.transaction { @@ -543,11 +543,11 @@ class TwoPartyTradeFlowTests { insertFakeTransactions(bobsBadCash, bobNode, notaryNode, DUMMY_CASH_ISSUER_KEY.public, MEGA_CORP_PUBKEY) insertFakeTransactions(alicesFakePaper, aliceNode, notaryNode, MEGA_CORP_PUBKEY) - net.runNetwork() // Clear network map registration messages + mockNet.runNetwork() // Clear network map registration messages val (bobStateMachine, aliceResult) = runBuyerAndSeller(notaryNode, aliceNode, bobNode, "alice's paper".outputStateAndRef()) - net.runNetwork() + mockNet.runNetwork() val e = assertFailsWith { if (bobError) diff --git a/node/src/test/kotlin/net/corda/node/services/MockServiceHubInternal.kt b/node/src/test/kotlin/net/corda/node/services/MockServiceHubInternal.kt index 4b21b7fbd9..061655f22b 100644 --- a/node/src/test/kotlin/net/corda/node/services/MockServiceHubInternal.kt +++ b/node/src/test/kotlin/net/corda/node/services/MockServiceHubInternal.kt @@ -23,7 +23,7 @@ import java.time.Clock open class MockServiceHubInternal( val customVault: VaultService? = null, val keyManagement: KeyManagementService? = null, - val net: MessagingService? = null, + val network: MessagingService? = null, val identity: IdentityService? = MOCK_IDENTITY_SERVICE, val storage: TxWritableStorageService? = MockStorageService(), val mapCache: NetworkMapCacheInternal? = MockNetworkMapCache(), @@ -41,7 +41,7 @@ open class MockServiceHubInternal( override val identityService: IdentityService get() = identity ?: throw UnsupportedOperationException() override val networkService: MessagingService - get() = net ?: throw UnsupportedOperationException() + get() = network ?: throw UnsupportedOperationException() override val networkMapCache: NetworkMapCacheInternal get() = mapCache ?: throw UnsupportedOperationException() override val storageService: StorageService diff --git a/node/src/test/kotlin/net/corda/node/services/NotaryChangeTests.kt b/node/src/test/kotlin/net/corda/node/services/NotaryChangeTests.kt index 7334451db9..fbcbd6e725 100644 --- a/node/src/test/kotlin/net/corda/node/services/NotaryChangeTests.kt +++ b/node/src/test/kotlin/net/corda/node/services/NotaryChangeTests.kt @@ -25,7 +25,7 @@ import kotlin.test.assertEquals import kotlin.test.assertTrue class NotaryChangeTests { - lateinit var net: MockNetwork + lateinit var mockNet: MockNetwork lateinit var oldNotaryNode: MockNetwork.MockNode lateinit var newNotaryNode: MockNetwork.MockNode lateinit var clientNodeA: MockNetwork.MockNode @@ -33,15 +33,15 @@ class NotaryChangeTests { @Before fun setup() { - net = MockNetwork() - oldNotaryNode = net.createNode( + mockNet = MockNetwork() + oldNotaryNode = mockNet.createNode( legalName = DUMMY_NOTARY.name, advertisedServices = *arrayOf(ServiceInfo(NetworkMapService.type), ServiceInfo(SimpleNotaryService.type))) - clientNodeA = net.createNode(networkMapAddress = oldNotaryNode.info.address) - clientNodeB = net.createNode(networkMapAddress = oldNotaryNode.info.address) - newNotaryNode = net.createNode(networkMapAddress = oldNotaryNode.info.address, advertisedServices = ServiceInfo(SimpleNotaryService.type)) + clientNodeA = mockNet.createNode(networkMapAddress = oldNotaryNode.info.address) + clientNodeB = mockNet.createNode(networkMapAddress = oldNotaryNode.info.address) + newNotaryNode = mockNet.createNode(networkMapAddress = oldNotaryNode.info.address, advertisedServices = ServiceInfo(SimpleNotaryService.type)) - net.runNetwork() // Clear network map registration messages + mockNet.runNetwork() // Clear network map registration messages } @Test @@ -51,7 +51,7 @@ class NotaryChangeTests { val flow = NotaryChangeFlow(state, newNotary) val future = clientNodeA.services.startFlow(flow) - net.runNetwork() + mockNet.runNetwork() val newState = future.resultFuture.getOrThrow() assertEquals(newState.state.notary, newNotary) @@ -64,7 +64,7 @@ class NotaryChangeTests { val flow = NotaryChangeFlow(state, newNotary) val future = clientNodeA.services.startFlow(flow) - net.runNetwork() + mockNet.runNetwork() val newState = future.resultFuture.getOrThrow() assertEquals(newState.state.notary, newNotary) @@ -80,7 +80,7 @@ class NotaryChangeTests { val flow = NotaryChangeFlow(state, newEvilNotary.party) val future = clientNodeA.services.startFlow(flow) - net.runNetwork() + mockNet.runNetwork() assertThatExceptionOfType(StateReplacementException::class.java).isThrownBy { future.resultFuture.getOrThrow() @@ -95,7 +95,7 @@ class NotaryChangeTests { val newNotary = newNotaryNode.info.notaryIdentity val flow = NotaryChangeFlow(state, newNotary) val future = clientNodeA.services.startFlow(flow) - net.runNetwork() + mockNet.runNetwork() val newState = future.resultFuture.getOrThrow() assertEquals(newState.state.notary, newNotary) diff --git a/node/src/test/kotlin/net/corda/node/services/events/NodeSchedulerServiceTest.kt b/node/src/test/kotlin/net/corda/node/services/events/NodeSchedulerServiceTest.kt index 9c8704e951..5f2cf0cb23 100644 --- a/node/src/test/kotlin/net/corda/node/services/events/NodeSchedulerServiceTest.kt +++ b/node/src/test/kotlin/net/corda/node/services/events/NodeSchedulerServiceTest.kt @@ -87,7 +87,7 @@ class NodeSchedulerServiceTest : SingletonSerializeAsToken() { InMemoryMessagingNetwork.PeerHandle(0, nullIdentity), AffinityExecutor.ServiceAffinityExecutor("test", 1), database) - services = object : MockServiceHubInternal(overrideClock = testClock, keyManagement = kms, net = mockMessagingService), TestReference { + services = object : MockServiceHubInternal(overrideClock = testClock, keyManagement = kms, network = mockMessagingService), TestReference { override val vaultService: VaultService = NodeVaultService(this, dataSourceProps) override val testReference = this@NodeSchedulerServiceTest } diff --git a/node/src/test/kotlin/net/corda/node/services/events/ScheduledFlowTests.kt b/node/src/test/kotlin/net/corda/node/services/events/ScheduledFlowTests.kt index db951ed371..10a31f2cbe 100644 --- a/node/src/test/kotlin/net/corda/node/services/events/ScheduledFlowTests.kt +++ b/node/src/test/kotlin/net/corda/node/services/events/ScheduledFlowTests.kt @@ -27,7 +27,7 @@ import java.time.Instant import kotlin.test.assertEquals class ScheduledFlowTests { - lateinit var net: MockNetwork + lateinit var mockNet: MockNetwork lateinit var notaryNode: MockNetwork.MockNode lateinit var nodeA: MockNetwork.MockNode lateinit var nodeB: MockNetwork.MockNode @@ -90,18 +90,18 @@ class ScheduledFlowTests { @Before fun setup() { - net = MockNetwork(threadPerNode = true) - notaryNode = net.createNode( + mockNet = MockNetwork(threadPerNode = true) + notaryNode = mockNet.createNode( legalName = DUMMY_NOTARY.name, advertisedServices = *arrayOf(ServiceInfo(NetworkMapService.type), ServiceInfo(ValidatingNotaryService.type))) - nodeA = net.createNode(notaryNode.info.address, start = false) - nodeB = net.createNode(notaryNode.info.address, start = false) - net.startNodes() + nodeA = mockNet.createNode(notaryNode.info.address, start = false) + nodeB = mockNet.createNode(notaryNode.info.address, start = false) + mockNet.startNodes() } @After fun cleanUp() { - net.stopNodes() + mockNet.stopNodes() } @Test @@ -116,7 +116,7 @@ class ScheduledFlowTests { } } nodeA.services.startFlow(InsertInitialStateFlow(nodeB.info.legalIdentity)) - net.waitQuiescent() + mockNet.waitQuiescent() val stateFromA = nodeA.database.transaction { nodeA.services.vaultService.linearHeadsOfType().values.first() } @@ -135,7 +135,7 @@ class ScheduledFlowTests { nodeA.services.startFlow(InsertInitialStateFlow(nodeB.info.legalIdentity)) nodeB.services.startFlow(InsertInitialStateFlow(nodeA.info.legalIdentity)) } - net.waitQuiescent() + mockNet.waitQuiescent() val statesFromA = nodeA.database.transaction { nodeA.services.vaultService.linearHeadsOfType() } diff --git a/node/src/test/kotlin/net/corda/node/services/network/AbstractNetworkMapServiceTest.kt b/node/src/test/kotlin/net/corda/node/services/network/AbstractNetworkMapServiceTest.kt index 0da6408897..47a45d8e9b 100644 --- a/node/src/test/kotlin/net/corda/node/services/network/AbstractNetworkMapServiceTest.kt +++ b/node/src/test/kotlin/net/corda/node/services/network/AbstractNetworkMapServiceTest.kt @@ -39,7 +39,7 @@ import java.security.KeyPair import java.time.Instant abstract class AbstractNetworkMapServiceTest { - lateinit var network: MockNetwork + lateinit var mockNet: MockNetwork lateinit var mapServiceNode: MockNode lateinit var alice: MockNode @@ -49,18 +49,18 @@ abstract class AbstractNetworkMapServiceTest @Before fun setup() { - network = MockNetwork(defaultFactory = nodeFactory) - network.createTwoNodes(firstNodeName = DUMMY_MAP.name, secondNodeName = ALICE.name).apply { + mockNet = MockNetwork(defaultFactory = nodeFactory) + mockNet.createTwoNodes(firstNodeName = DUMMY_MAP.name, secondNodeName = ALICE.name).apply { mapServiceNode = first alice = second } - network.runNetwork() + mockNet.runNetwork() lastSerial = System.currentTimeMillis() } @After fun tearDown() { - network.stopNodes() + mockNet.stopNodes() } protected abstract val nodeFactory: MockNetwork.Factory @@ -188,7 +188,7 @@ abstract class AbstractNetworkMapServiceTest private fun MockNode.fetchMap(subscribe: Boolean = false, ifChangedSinceVersion: Int? = null): List { val request = FetchMapRequest(subscribe, ifChangedSinceVersion, info.address) val response = services.networkService.sendRequest(FETCH_TOPIC, request, mapServiceNode.info.address) - network.runNetwork() + mockNet.runNetwork() return response.getOrThrow().nodes?.map { it.toChanged() } ?: emptyList() } @@ -200,7 +200,7 @@ abstract class AbstractNetworkMapServiceTest private fun MockNode.identityQuery(): NodeInfo? { val request = QueryIdentityRequest(info.legalIdentityAndCert, info.address) val response = services.networkService.sendRequest(QUERY_TOPIC, request, mapServiceNode.info.address) - network.runNetwork() + mockNet.runNetwork() return response.getOrThrow().node } @@ -218,7 +218,7 @@ abstract class AbstractNetworkMapServiceTest val nodeRegistration = NodeRegistration(info, distinctSerial, addOrRemove, expires) val request = RegistrationRequest(nodeRegistration.toWire(services.keyManagementService, services.legalIdentityKey), info.address) val response = services.networkService.sendRequest(REGISTER_TOPIC, request, mapServiceNode.info.address) - network.runNetwork() + mockNet.runNetwork() return response } @@ -229,7 +229,7 @@ abstract class AbstractNetworkMapServiceTest updates += message.data.deserialize() } val response = services.networkService.sendRequest(SUBSCRIPTION_TOPIC, request, mapServiceNode.info.address) - network.runNetwork() + mockNet.runNetwork() assertThat(response.getOrThrow().confirmed).isTrue() return updates } @@ -237,25 +237,25 @@ abstract class AbstractNetworkMapServiceTest private fun MockNode.unsubscribe() { val request = SubscribeRequest(false, info.address) val response = services.networkService.sendRequest(SUBSCRIPTION_TOPIC, request, mapServiceNode.info.address) - network.runNetwork() + mockNet.runNetwork() assertThat(response.getOrThrow().confirmed).isTrue() } private fun MockNode.ackUpdate(mapVersion: Int) { val request = UpdateAcknowledge(mapVersion, services.networkService.myAddress) services.networkService.send(PUSH_ACK_TOPIC, DEFAULT_SESSION_ID, request, mapServiceNode.info.address) - network.runNetwork() + mockNet.runNetwork() } private fun addNewNodeToNetworkMap(legalName: X500Name): MockNode { - val node = network.createNode(networkMapAddress = mapServiceNode.info.address, legalName = legalName) - network.runNetwork() + val node = mockNet.createNode(networkMapAddress = mapServiceNode.info.address, legalName = legalName) + mockNet.runNetwork() lastSerial = System.currentTimeMillis() return node } private fun newNodeSeparateFromNetworkMap(legalName: X500Name): MockNode { - return network.createNode(legalName = legalName, nodeFactory = NoNMSNodeFactory) + return mockNet.createNode(legalName = legalName, nodeFactory = NoNMSNodeFactory) } sealed class Changed { diff --git a/node/src/test/kotlin/net/corda/node/services/network/InMemoryNetworkMapCacheTest.kt b/node/src/test/kotlin/net/corda/node/services/network/InMemoryNetworkMapCacheTest.kt index cbcf699c36..a341420963 100644 --- a/node/src/test/kotlin/net/corda/node/services/network/InMemoryNetworkMapCacheTest.kt +++ b/node/src/test/kotlin/net/corda/node/services/network/InMemoryNetworkMapCacheTest.kt @@ -11,21 +11,21 @@ import java.math.BigInteger import kotlin.test.assertEquals class InMemoryNetworkMapCacheTest { - private val network = MockNetwork() + private val mockNet = MockNetwork() @Test fun registerWithNetwork() { - val (n0, n1) = network.createTwoNodes() - val future = n1.services.networkMapCache.addMapService(n1.net, n0.info.address, false, null) - network.runNetwork() + val (n0, n1) = mockNet.createTwoNodes() + val future = n1.services.networkMapCache.addMapService(n1.network, n0.info.address, false, null) + mockNet.runNetwork() future.getOrThrow() } @Test fun `key collision`() { val entropy = BigInteger.valueOf(24012017L) - 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)) + val nodeA = mockNet.createNode(null, -1, MockNetwork.DefaultFactory, true, ALICE.name, null, entropy, ServiceInfo(NetworkMapService.type)) + val nodeB = mockNet.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 diff --git a/node/src/test/kotlin/net/corda/node/services/persistence/DataVendingServiceTests.kt b/node/src/test/kotlin/net/corda/node/services/persistence/DataVendingServiceTests.kt index 95072b0a7f..d5266caa8f 100644 --- a/node/src/test/kotlin/net/corda/node/services/persistence/DataVendingServiceTests.kt +++ b/node/src/test/kotlin/net/corda/node/services/persistence/DataVendingServiceTests.kt @@ -28,19 +28,19 @@ import kotlin.test.assertEquals * Tests for the data vending service. */ class DataVendingServiceTests { - lateinit var network: MockNetwork + lateinit var mockNet: MockNetwork @Before fun setup() { - network = MockNetwork() + mockNet = MockNetwork() } @Test fun `notify of transaction`() { - val (vaultServiceNode, registerNode) = network.createTwoNodes() + val (vaultServiceNode, registerNode) = mockNet.createTwoNodes() val beneficiary = vaultServiceNode.info.legalIdentity val deposit = registerNode.info.legalIdentity.ref(1) - network.runNetwork() + mockNet.runNetwork() // Generate an issuance transaction val ptx = TransactionType.General.Builder(null) @@ -65,10 +65,10 @@ class DataVendingServiceTests { */ @Test fun `notify failure`() { - val (vaultServiceNode, registerNode) = network.createTwoNodes() + val (vaultServiceNode, registerNode) = mockNet.createTwoNodes() val beneficiary = vaultServiceNode.info.legalIdentity val deposit = MEGA_CORP.ref(1) - network.runNetwork() + mockNet.runNetwork() // Generate an issuance transaction val ptx = TransactionType.General.Builder(DUMMY_NOTARY) @@ -89,7 +89,7 @@ class DataVendingServiceTests { private fun MockNode.sendNotifyTx(tx: SignedTransaction, walletServiceNode: MockNode) { walletServiceNode.registerInitiatedFlow(InitiateNotifyTxFlow::class.java) services.startFlow(NotifyTxFlow(walletServiceNode.info.legalIdentity, tx)) - network.runNetwork() + mockNet.runNetwork() } @InitiatingFlow diff --git a/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt b/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt index 3248cb33c5..cecc34d12e 100644 --- a/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt +++ b/node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt @@ -64,7 +64,7 @@ class FlowFrameworkTests { } } - private val net = MockNetwork(servicePeerAllocationStrategy = RoundRobin()) + private val mockNet = MockNetwork(servicePeerAllocationStrategy = RoundRobin()) private val sessionTransfers = ArrayList() private lateinit var node1: MockNode private lateinit var node2: MockNode @@ -73,7 +73,7 @@ class FlowFrameworkTests { @Before fun start() { - val nodes = net.createTwoNodes() + val nodes = mockNet.createTwoNodes() node1 = nodes.first node2 = nodes.second val notaryKeyPair = generateKeyPair() @@ -81,16 +81,16 @@ class FlowFrameworkTests { 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 = notaryService.name) - notary2 = net.createNotaryNode(networkMapAddr = node1.services.myInfo.address, overrideServices = overrideServices, serviceName = notaryService.name) + notary1 = mockNet.createNotaryNode(networkMapAddr = node1.services.myInfo.address, overrideServices = overrideServices, serviceName = notaryService.name) + notary2 = mockNet.createNotaryNode(networkMapAddr = node1.services.myInfo.address, overrideServices = overrideServices, serviceName = notaryService.name) - net.messagingNetwork.receivedMessages.toSessionTransfers().forEach { sessionTransfers += it } - net.runNetwork() + mockNet.messagingNetwork.receivedMessages.toSessionTransfers().forEach { sessionTransfers += it } + mockNet.runNetwork() } @After fun cleanUp() { - net.stopNodes() + mockNet.stopNodes() } @Test @@ -122,7 +122,7 @@ class FlowFrameworkTests { fiber.actionOnSuspend = { throw exceptionDuringSuspend } - net.runNetwork() + mockNet.runNetwork() assertThatThrownBy { fiber.resultFuture.getOrThrow() }.isSameAs(exceptionDuringSuspend) @@ -141,42 +141,42 @@ class FlowFrameworkTests { node2.disableDBCloseOnStop() node2.acceptableLiveFiberCountOnStop = 1 node2.stop() - net.runNetwork() + mockNet.runNetwork() val restoredFlow = node2.restartAndGetRestoredFlow(node1) assertThat(restoredFlow.receivedPayloads[0]).isEqualTo("Hello") } @Test fun `flow added before network map does run after init`() { - val node3 = net.createNode(node1.info.address) //create vanilla node + val node3 = mockNet.createNode(node1.info.address) //create vanilla node val flow = NoOpFlow() node3.services.startFlow(flow) assertEquals(false, flow.flowStarted) // Not started yet as no network activity has been allowed yet - net.runNetwork() // Allow network map messages to flow + mockNet.runNetwork() // Allow network map messages to flow assertEquals(true, flow.flowStarted) // Now we should have run the flow } @Test fun `flow added before network map will be init checkpointed`() { - var node3 = net.createNode(node1.info.address) //create vanilla node + var node3 = mockNet.createNode(node1.info.address) //create vanilla node val flow = NoOpFlow() node3.services.startFlow(flow) assertEquals(false, flow.flowStarted) // Not started yet as no network activity has been allowed yet node3.disableDBCloseOnStop() node3.stop() - node3 = net.createNode(node1.info.address, forcedID = node3.id) + node3 = mockNet.createNode(node1.info.address, forcedID = node3.id) val restoredFlow = node3.getSingleFlow().first assertEquals(false, restoredFlow.flowStarted) // Not started yet as no network activity has been allowed yet - net.runNetwork() // Allow network map messages to flow + mockNet.runNetwork() // Allow network map messages to flow node3.smm.executor.flush() assertEquals(true, restoredFlow.flowStarted) // Now we should have run the flow and hopefully cleared the init checkpoint node3.disableDBCloseOnStop() node3.stop() // Now it is completed the flow should leave no Checkpoint. - node3 = net.createNode(node1.info.address, forcedID = node3.id) - net.runNetwork() // Allow network map messages to flow + node3 = mockNet.createNode(node1.info.address, forcedID = node3.id) + mockNet.runNetwork() // Allow network map messages to flow node3.smm.executor.flush() assertTrue(node3.smm.findStateMachines(NoOpFlow::class.java).isEmpty()) } @@ -199,11 +199,11 @@ class FlowFrameworkTests { val payload2 = random63BitValue() var sentCount = 0 - net.messagingNetwork.sentMessages.toSessionTransfers().filter { it.isPayloadTransfer }.forEach { sentCount++ } + mockNet.messagingNetwork.sentMessages.toSessionTransfers().filter { it.isPayloadTransfer }.forEach { sentCount++ } - val node3 = net.createNode(node1.info.address) + val node3 = mockNet.createNode(node1.info.address) val secondFlow = node3.registerFlowFactory(PingPongFlow::class) { PingPongFlow(it, payload2) } - net.runNetwork() + mockNet.runNetwork() // Kick off first send and receive node2.services.startFlow(PingPongFlow(node3.info.legalIdentity, payload)) @@ -218,11 +218,11 @@ class FlowFrameworkTests { node2.database.transaction { assertEquals(1, node2.checkpointStorage.checkpoints().size) // confirm checkpoint } - val node2b = net.createNode(node1.info.address, node2.id, advertisedServices = *node2.advertisedServices.toTypedArray()) + val node2b = mockNet.createNode(node1.info.address, node2.id, advertisedServices = *node2.advertisedServices.toTypedArray()) node2.manuallyCloseDB() val (firstAgain, fut1) = node2b.getSingleFlow() // Run the network which will also fire up the second flow. First message should get deduped. So message data stays in sync. - net.runNetwork() + mockNet.runNetwork() node2b.smm.executor.flush() fut1.getOrThrow() @@ -245,13 +245,13 @@ class FlowFrameworkTests { @Test fun `sending to multiple parties`() { - val node3 = net.createNode(node1.info.address) - net.runNetwork() + val node3 = mockNet.createNode(node1.info.address) + mockNet.runNetwork() node2.registerFlowFactory(SendFlow::class) { ReceiveFlow(it).nonTerminating() } node3.registerFlowFactory(SendFlow::class) { ReceiveFlow(it).nonTerminating() } val payload = "Hello World" node1.services.startFlow(SendFlow(payload, node2.info.legalIdentity, node3.info.legalIdentity)) - net.runNetwork() + mockNet.runNetwork() val node2Flow = node2.getSingleFlow().first val node3Flow = node3.getSingleFlow().first assertThat(node2Flow.receivedPayloads[0]).isEqualTo(payload) @@ -277,8 +277,8 @@ class FlowFrameworkTests { @Test fun `receiving from multiple parties`() { - val node3 = net.createNode(node1.info.address) - net.runNetwork() + val node3 = mockNet.createNode(node1.info.address) + mockNet.runNetwork() val node2Payload = "Test 1" val node3Payload = "Test 2" node2.registerFlowFactory(ReceiveFlow::class) { SendFlow(node2Payload, it) } @@ -286,7 +286,7 @@ class FlowFrameworkTests { val multiReceiveFlow = ReceiveFlow(node2.info.legalIdentity, node3.info.legalIdentity).nonTerminating() node1.services.startFlow(multiReceiveFlow) node1.acceptableLiveFiberCountOnStop = 1 - net.runNetwork() + mockNet.runNetwork() assertThat(multiReceiveFlow.receivedPayloads[0]).isEqualTo(node2Payload) assertThat(multiReceiveFlow.receivedPayloads[1]).isEqualTo(node3Payload) @@ -309,7 +309,7 @@ class FlowFrameworkTests { fun `both sides do a send as their first IO request`() { node2.registerFlowFactory(PingPongFlow::class) { PingPongFlow(it, 20L) } node1.services.startFlow(PingPongFlow(node2.info.legalIdentity, 10L)) - net.runNetwork() + mockNet.runNetwork() assertSessionTransfers( node1 sent sessionInit(PingPongFlow::class, 1, 10L) to node2, @@ -332,9 +332,9 @@ class FlowFrameworkTests { // We pay a couple of times, the notary picking should go round robin for (i in 1..3) { node1.services.startFlow(CashPaymentFlow(500.DOLLARS, node2.info.legalIdentity)) - net.runNetwork() + mockNet.runNetwork() } - val endpoint = net.messagingNetwork.endpoint(notary1.net.myAddress as InMemoryMessagingNetwork.PeerHandle)!! + val endpoint = mockNet.messagingNetwork.endpoint(notary1.network.myAddress as InMemoryMessagingNetwork.PeerHandle)!! val party1Info = notary1.services.networkMapCache.getPartyInfo(notary1.info.notaryIdentity)!! assertTrue(party1Info is PartyInfo.Service) val notary1Address: MessageRecipients = endpoint.getAddressOfParty(notary1.services.networkMapCache.getPartyInfo(notary1.info.notaryIdentity)!!) @@ -380,7 +380,7 @@ class FlowFrameworkTests { fun `other side ends before doing expected send`() { node2.registerFlowFactory(ReceiveFlow::class) { NoOpFlow() } val resultFuture = node1.services.startFlow(ReceiveFlow(node2.info.legalIdentity)).resultFuture - net.runNetwork() + mockNet.runNetwork() assertThatExceptionOfType(FlowSessionException::class.java).isThrownBy { resultFuture.getOrThrow() }.withMessageContaining(String::class.java.name) // Make sure the exception message mentions the type the flow was expecting to receive @@ -397,7 +397,7 @@ class FlowFrameworkTests { val receiveFlowSteps = receiveFlow.progressSteps val receiveFlowResult = node1.services.startFlow(receiveFlow).resultFuture - net.runNetwork() + mockNet.runNetwork() assertThat(erroringFlowSteps.get()).containsExactly( Notification.createOnNext(ExceptionFlow.START_STEP), @@ -429,7 +429,7 @@ class FlowFrameworkTests { val receivingFiber = node1.services.startFlow(ReceiveFlow(node2.info.legalIdentity)) as FlowStateMachineImpl - net.runNetwork() + mockNet.runNetwork() assertThatExceptionOfType(MyFlowException::class.java) .isThrownBy { receivingFiber.resultFuture.getOrThrow() } @@ -457,13 +457,13 @@ class FlowFrameworkTests { @Test fun `FlowException propagated in invocation chain`() { - val node3 = net.createNode(node1.info.address) - net.runNetwork() + val node3 = mockNet.createNode(node1.info.address) + mockNet.runNetwork() node3.registerFlowFactory(ReceiveFlow::class) { ExceptionFlow { MyFlowException("Chain") } } node2.registerFlowFactory(ReceiveFlow::class) { ReceiveFlow(node3.info.legalIdentity) } val receivingFiber = node1.services.startFlow(ReceiveFlow(node2.info.legalIdentity)) - net.runNetwork() + mockNet.runNetwork() assertThatExceptionOfType(MyFlowException::class.java) .isThrownBy { receivingFiber.resultFuture.getOrThrow() } .withMessage("Chain") @@ -471,8 +471,8 @@ class FlowFrameworkTests { @Test fun `FlowException thrown and there is a 3rd unrelated party flow`() { - val node3 = net.createNode(node1.info.address) - net.runNetwork() + val node3 = mockNet.createNode(node1.info.address) + mockNet.runNetwork() // Node 2 will send its payload and then block waiting for the receive from node 1. Meanwhile node 1 will move // onto node 3 which will throw the exception @@ -482,7 +482,7 @@ class FlowFrameworkTests { node3.registerFlowFactory(ReceiveFlow::class) { ExceptionFlow { MyFlowException("Nothing useful") } } val node1Fiber = node1.services.startFlow(ReceiveFlow(node2.info.legalIdentity, node3.info.legalIdentity)) as FlowStateMachineImpl - net.runNetwork() + mockNet.runNetwork() // Node 1 will terminate with the error it received from node 3 but it won't propagate that to node 2 (as it's // not relevant to it) but it will end its session with it @@ -534,7 +534,7 @@ class FlowFrameworkTests { node2.registerFlowFactory(AskForExceptionFlow::class) { ConditionalExceptionFlow(it, "Hello") } val resultFuture = node1.services.startFlow(RetryOnExceptionFlow(node2.info.legalIdentity)).resultFuture - net.runNetwork() + mockNet.runNetwork() assertThat(resultFuture.getOrThrow()).isEqualTo("Hello") } @@ -542,7 +542,7 @@ class FlowFrameworkTests { fun `serialisation issue in counterparty`() { node2.registerFlowFactory(ReceiveFlow::class) { SendFlow(NonSerialisableData(1), it) } val result = node1.services.startFlow(ReceiveFlow(node2.info.legalIdentity)).resultFuture - net.runNetwork() + mockNet.runNetwork() assertThatExceptionOfType(FlowSessionException::class.java).isThrownBy { result.getOrThrow() } @@ -554,7 +554,7 @@ class FlowFrameworkTests { ExceptionFlow { NonSerialisableFlowException(NonSerialisableData(1)) } } val result = node1.services.startFlow(ReceiveFlow(node2.info.legalIdentity)).resultFuture - net.runNetwork() + mockNet.runNetwork() assertThatExceptionOfType(FlowException::class.java).isThrownBy { result.getOrThrow() } @@ -570,7 +570,7 @@ class FlowFrameworkTests { WaitingFlows.Committer(it) }.map { it.stateMachine } val waiterStx = node2.services.startFlow(WaitingFlows.Waiter(stx, node1.info.legalIdentity)).resultFuture - net.runNetwork() + mockNet.runNetwork() assertThat(waiterStx.getOrThrow()).isEqualTo(committerFiber.getOrThrow().resultFuture.getOrThrow()) } @@ -584,7 +584,7 @@ class FlowFrameworkTests { WaitingFlows.Committer(it) { throw Exception("Error") } } val waiter = node2.services.startFlow(WaitingFlows.Waiter(stx, node1.info.legalIdentity)).resultFuture - net.runNetwork() + mockNet.runNetwork() assertThatExceptionOfType(FlowSessionException::class.java).isThrownBy { waiter.getOrThrow() } @@ -593,7 +593,7 @@ class FlowFrameworkTests { @Test fun `lazy db iterator left on stack during checkpointing`() { val result = node2.services.startFlow(VaultAccessFlow()).resultFuture - net.runNetwork() + mockNet.runNetwork() assertThatThrownBy { result.getOrThrow() }.hasMessageContaining("Vault").hasMessageContaining("private method") } @@ -601,14 +601,14 @@ class FlowFrameworkTests { fun `customised client flow`() { val receiveFlowFuture = node2.registerFlowFactory(SendFlow::class) { ReceiveFlow(it) } node1.services.startFlow(CustomSendFlow("Hello", node2.info.legalIdentity)).resultFuture - net.runNetwork() + mockNet.runNetwork() assertThat(receiveFlowFuture.getOrThrow().receivedPayloads).containsOnly("Hello") } @Test fun `customised client flow which has annotated @InitiatingFlow again`() { val result = node1.services.startFlow(IncorrectCustomSendFlow("Hello", node2.info.legalIdentity)).resultFuture - net.runNetwork() + mockNet.runNetwork() assertThatExceptionOfType(IllegalArgumentException::class.java).isThrownBy { result.getOrThrow() }.withMessageContaining(InitiatingFlow::class.java.simpleName) @@ -617,7 +617,7 @@ class FlowFrameworkTests { @Test fun `upgraded flow`() { node1.services.startFlow(UpgradedFlow(node2.info.legalIdentity)) - net.runNetwork() + mockNet.runNetwork() assertThat(sessionTransfers).startsWith( node1 sent sessionInit(UpgradedFlow::class, 2) to node2 ) @@ -631,7 +631,7 @@ class FlowFrameworkTests { DoubleInlinedSubFlow::class.java, track = false) val result = node1.services.startFlow(UpgradedFlow(node2.info.legalIdentity)).resultFuture - net.runNetwork() + mockNet.runNetwork() assertThatExceptionOfType(FlowSessionException::class.java).isThrownBy { result.getOrThrow() }.withMessageContaining("Version") @@ -641,7 +641,7 @@ class FlowFrameworkTests { fun `single inlined sub-flow`() { node2.registerFlowFactory(SendAndReceiveFlow::class, ::SingleInlinedSubFlow) val result = node1.services.startFlow(SendAndReceiveFlow(node2.info.legalIdentity, "Hello")).resultFuture - net.runNetwork() + mockNet.runNetwork() assertThat(result.getOrThrow()).isEqualTo("HelloHello") } @@ -649,7 +649,7 @@ class FlowFrameworkTests { fun `double inlined sub-flow`() { node2.registerFlowFactory(SendAndReceiveFlow::class, ::DoubleInlinedSubFlow) val result = node1.services.startFlow(SendAndReceiveFlow(node2.info.legalIdentity, "Hello")).resultFuture - net.runNetwork() + mockNet.runNetwork() assertThat(result.getOrThrow()).isEqualTo("HelloHello") } @@ -696,7 +696,7 @@ class FlowFrameworkTests { } private fun assertSessionTransfers(node: MockNode, vararg expected: SessionTransfer): List { - val actualForNode = sessionTransfers.filter { it.from == node.id || it.to == node.net.myAddress } + val actualForNode = sessionTransfers.filter { it.from == node.id || it.to == node.network.myAddress } assertThat(actualForNode).containsExactly(*expected) return actualForNode } @@ -724,7 +724,7 @@ class FlowFrameworkTests { } private infix fun MockNode.sent(message: SessionMessage): Pair = Pair(id, message) - private infix fun Pair.to(node: MockNode): SessionTransfer = SessionTransfer(first, second, node.net.myAddress) + private infix fun Pair.to(node: MockNode): SessionTransfer = SessionTransfer(first, second, node.network.myAddress) private val FlowLogic<*>.progressSteps: ListenableFuture>> get() { return progressTracker!!.changes diff --git a/node/src/test/kotlin/net/corda/node/services/transactions/NotaryServiceTests.kt b/node/src/test/kotlin/net/corda/node/services/transactions/NotaryServiceTests.kt index eaf55f338e..039ca933b6 100644 --- a/node/src/test/kotlin/net/corda/node/services/transactions/NotaryServiceTests.kt +++ b/node/src/test/kotlin/net/corda/node/services/transactions/NotaryServiceTests.kt @@ -26,17 +26,17 @@ import kotlin.test.assertEquals import kotlin.test.assertFailsWith class NotaryServiceTests { - lateinit var net: MockNetwork + lateinit var mockNet: MockNetwork lateinit var notaryNode: MockNetwork.MockNode lateinit var clientNode: MockNetwork.MockNode @Before fun setup() { - net = MockNetwork() - notaryNode = net.createNode( + mockNet = MockNetwork() + notaryNode = mockNet.createNode( legalName = DUMMY_NOTARY.name, advertisedServices = *arrayOf(ServiceInfo(NetworkMapService.type), ServiceInfo(SimpleNotaryService.type))) - clientNode = net.createNode(networkMapAddress = notaryNode.info.address) - net.runNetwork() // Clear network map registration messages + clientNode = mockNet.createNode(networkMapAddress = notaryNode.info.address) + mockNet.runNetwork() // Clear network map registration messages } @Test fun `should sign a unique transaction with a valid time-window`() { @@ -90,7 +90,7 @@ class NotaryServiceTests { val f1 = clientNode.services.startFlow(firstAttempt) val f2 = clientNode.services.startFlow(secondAttempt) - net.runNetwork() + mockNet.runNetwork() assertEquals(f1.resultFuture.getOrThrow(), f2.resultFuture.getOrThrow()) } @@ -112,7 +112,7 @@ class NotaryServiceTests { clientNode.services.startFlow(firstSpend) val future = clientNode.services.startFlow(secondSpend) - net.runNetwork() + mockNet.runNetwork() val ex = assertFailsWith(NotaryException::class) { future.resultFuture.getOrThrow() } val notaryError = ex.error as NotaryError.Conflict @@ -123,7 +123,7 @@ class NotaryServiceTests { private fun runNotaryClient(stx: SignedTransaction): ListenableFuture> { val flow = NotaryFlow.Client(stx) val future = clientNode.services.startFlow(flow).resultFuture - net.runNetwork() + mockNet.runNetwork() return future } diff --git a/node/src/test/kotlin/net/corda/node/services/transactions/ValidatingNotaryServiceTests.kt b/node/src/test/kotlin/net/corda/node/services/transactions/ValidatingNotaryServiceTests.kt index dfe2cc29fa..aa8a417d81 100644 --- a/node/src/test/kotlin/net/corda/node/services/transactions/ValidatingNotaryServiceTests.kt +++ b/node/src/test/kotlin/net/corda/node/services/transactions/ValidatingNotaryServiceTests.kt @@ -23,18 +23,18 @@ import kotlin.test.assertEquals import kotlin.test.assertFailsWith class ValidatingNotaryServiceTests { - lateinit var net: MockNetwork + lateinit var mockNet: MockNetwork lateinit var notaryNode: MockNetwork.MockNode lateinit var clientNode: MockNetwork.MockNode @Before fun setup() { - net = MockNetwork() - notaryNode = net.createNode( + mockNet = MockNetwork() + notaryNode = mockNet.createNode( legalName = DUMMY_NOTARY.name, advertisedServices = *arrayOf(ServiceInfo(NetworkMapService.type), ServiceInfo(ValidatingNotaryService.type)) ) - clientNode = net.createNode(networkMapAddress = notaryNode.info.address) - net.runNetwork() // Clear network map registration messages + clientNode = mockNet.createNode(networkMapAddress = notaryNode.info.address) + mockNet.runNetwork() // Clear network map registration messages } @Test fun `should report error for invalid transaction dependency`() { @@ -74,7 +74,7 @@ class ValidatingNotaryServiceTests { private fun runClient(stx: SignedTransaction): ListenableFuture> { val flow = NotaryFlow.Client(stx) val future = clientNode.services.startFlow(flow).resultFuture - net.runNetwork() + mockNet.runNetwork() return future } diff --git a/samples/irs-demo/src/main/kotlin/net/corda/irs/simulation/Simulation.kt b/samples/irs-demo/src/main/kotlin/net/corda/irs/simulation/Simulation.kt index 966c9709da..2234a41119 100644 --- a/samples/irs-demo/src/main/kotlin/net/corda/irs/simulation/Simulation.kt +++ b/samples/irs-demo/src/main/kotlin/net/corda/irs/simulation/Simulation.kt @@ -81,7 +81,7 @@ abstract class Simulation(val networkSendManuallyPumped: Boolean, fun createAll(): List { return bankLocations.mapIndexed { i, _ -> // Use deterministic seeds so the simulation is stable. Needed so that party owning keys are stable. - network.createNode(networkMap.info.address, start = false, nodeFactory = this, entropyRoot = BigInteger.valueOf(i.toLong())) as SimulatedNode + mockNet.createNode(networkMap.info.address, start = false, nodeFactory = this, entropyRoot = BigInteger.valueOf(i.toLong())) as SimulatedNode } } } @@ -158,15 +158,15 @@ abstract class Simulation(val networkSendManuallyPumped: Boolean, } } - val network = MockNetwork(networkSendManuallyPumped, runAsync) + val mockNet = MockNetwork(networkSendManuallyPumped, runAsync) // This one must come first. val networkMap: SimulatedNode - = network.createNode(null, nodeFactory = NetworkMapNodeFactory, advertisedServices = ServiceInfo(NetworkMapService.type)) as SimulatedNode + = mockNet.createNode(null, nodeFactory = NetworkMapNodeFactory, advertisedServices = ServiceInfo(NetworkMapService.type)) as SimulatedNode val notary: SimulatedNode - = network.createNode(networkMap.info.address, nodeFactory = NotaryNodeFactory, advertisedServices = ServiceInfo(SimpleNotaryService.type)) as SimulatedNode - val regulators: List = listOf(network.createNode(networkMap.info.address, start = false, nodeFactory = RegulatorFactory) as SimulatedNode) + = mockNet.createNode(networkMap.info.address, nodeFactory = NotaryNodeFactory, advertisedServices = ServiceInfo(SimpleNotaryService.type)) as SimulatedNode + val regulators: List = listOf(mockNet.createNode(networkMap.info.address, start = false, nodeFactory = RegulatorFactory) as SimulatedNode) val ratesOracle: SimulatedNode - = network.createNode(networkMap.info.address, start = false, nodeFactory = RatesOracleFactory, advertisedServices = ServiceInfo(NodeInterestRates.Oracle.type)) as SimulatedNode + = mockNet.createNode(networkMap.info.address, start = false, nodeFactory = RatesOracleFactory, advertisedServices = ServiceInfo(NodeInterestRates.Oracle.type)) as SimulatedNode // All nodes must be in one of these two lists for the purposes of the visualiser tool. val serviceProviders: List = listOf(notary, ratesOracle, networkMap) @@ -220,11 +220,11 @@ abstract class Simulation(val networkSendManuallyPumped: Boolean, */ open fun iterate(): InMemoryMessagingNetwork.MessageTransfer? { if (networkSendManuallyPumped) { - network.messagingNetwork.pumpSend(false) + mockNet.messagingNetwork.pumpSend(false) } // Keep going until one of the nodes has something to do, or we have checked every node. - val endpoints = network.messagingNetwork.endpoints + val endpoints = mockNet.messagingNetwork.endpoints var countDown = endpoints.size while (countDown > 0) { val handledMessage = endpoints[pumpCursor].pumpReceive(false) @@ -271,10 +271,10 @@ abstract class Simulation(val networkSendManuallyPumped: Boolean, } val networkInitialisationFinished: ListenableFuture<*> = - Futures.allAsList(network.nodes.map { it.networkMapRegistrationFuture }) + Futures.allAsList(mockNet.nodes.map { it.networkMapRegistrationFuture }) fun start(): ListenableFuture { - network.startNodes() + mockNet.startNodes() // Wait for all the nodes to have finished registering with the network map service. return networkInitialisationFinished.flatMap { startMainSimulation() } } @@ -288,6 +288,6 @@ abstract class Simulation(val networkSendManuallyPumped: Boolean, } fun stop() { - network.stopNodes() + mockNet.stopNodes() } } diff --git a/samples/irs-demo/src/test/kotlin/net/corda/irs/testing/NodeInterestRatesTest.kt b/samples/irs-demo/src/test/kotlin/net/corda/irs/testing/NodeInterestRatesTest.kt index a91ac74f74..feb2fd6a0b 100644 --- a/samples/irs-demo/src/test/kotlin/net/corda/irs/testing/NodeInterestRatesTest.kt +++ b/samples/irs-demo/src/test/kotlin/net/corda/irs/testing/NodeInterestRatesTest.kt @@ -207,9 +207,9 @@ class NodeInterestRatesTest { @Test fun `network tearoff`() { - val net = MockNetwork() - val n1 = net.createNotaryNode() - val n2 = net.createNode(n1.info.address, advertisedServices = ServiceInfo(NodeInterestRates.Oracle.type)) + val mockNet = MockNetwork() + val n1 = mockNet.createNotaryNode() + val n2 = mockNet.createNode(n1.info.address, advertisedServices = ServiceInfo(NodeInterestRates.Oracle.type)) n2.registerInitiatedFlow(NodeInterestRates.FixQueryHandler::class.java) n2.registerInitiatedFlow(NodeInterestRates.FixSignHandler::class.java) n2.database.transaction { @@ -220,9 +220,9 @@ class NodeInterestRatesTest { val oracle = n2.info.serviceIdentities(NodeInterestRates.Oracle.type).first() val flow = FilteredRatesFlow(tx, oracle, fixOf, "0.675".bd, "0.1".bd) LogHelper.setLevel("rates") - net.runNetwork() + mockNet.runNetwork() val future = n1.services.startFlow(flow).resultFuture - net.runNetwork() + mockNet.runNetwork() future.getOrThrow() // We should now have a valid signature over our tx from the oracle. val fix = tx.toSignedTransaction(true).tx.commands.map { it.value as Fix }.first() diff --git a/samples/network-visualiser/src/main/kotlin/net/corda/netmap/NetworkMapVisualiser.kt b/samples/network-visualiser/src/main/kotlin/net/corda/netmap/NetworkMapVisualiser.kt index c6b67e3dce..96b0ec170a 100644 --- a/samples/network-visualiser/src/main/kotlin/net/corda/netmap/NetworkMapVisualiser.kt +++ b/samples/network-visualiser/src/main/kotlin/net/corda/netmap/NetworkMapVisualiser.kt @@ -110,9 +110,9 @@ class NetworkMapVisualiser : Application() { } } // Fire the message bullets between nodes. - simulation.network.messagingNetwork.sentMessages.observeOn(uiThread).subscribe { msg: InMemoryMessagingNetwork.MessageTransfer -> - val senderNode: MockNetwork.MockNode = simulation.network.addressToNode(msg.sender) - val destNode: MockNetwork.MockNode = simulation.network.addressToNode(msg.recipients as SingleMessageRecipient) + simulation.mockNet.messagingNetwork.sentMessages.observeOn(uiThread).subscribe { msg: InMemoryMessagingNetwork.MessageTransfer -> + val senderNode: MockNetwork.MockNode = simulation.mockNet.addressToNode(msg.sender) + val destNode: MockNetwork.MockNode = simulation.mockNet.addressToNode(msg.recipients as SingleMessageRecipient) if (transferIsInteresting(msg)) { viewModel.nodesToWidgets[senderNode]!!.pulseAnim.play() diff --git a/test-utils/src/main/kotlin/net/corda/testing/node/MockNode.kt b/test-utils/src/main/kotlin/net/corda/testing/node/MockNode.kt index 81afa595ca..fb9f649a48 100644 --- a/test-utils/src/main/kotlin/net/corda/testing/node/MockNode.kt +++ b/test-utils/src/main/kotlin/net/corda/testing/node/MockNode.kt @@ -233,7 +233,7 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false, @Suppress("unused") val place: PhysicalLocation get() = findMyLocation()!! fun pumpReceive(block: Boolean = false): InMemoryMessagingNetwork.MessageTransfer? { - return (net as InMemoryMessagingNetwork.InMemoryMessaging).pumpReceive(block) + return (network as InMemoryMessagingNetwork.InMemoryMessaging).pumpReceive(block) } fun disableDBCloseOnStop() { @@ -382,7 +382,7 @@ class MockNetwork(private val networkSendManuallyPumped: Boolean = false, } @Suppress("unused") // This is used from the network visualiser tool. - fun addressToNode(address: SingleMessageRecipient): MockNode = nodes.single { it.net.myAddress == address } + fun addressToNode(address: SingleMessageRecipient): MockNode = nodes.single { it.network.myAddress == address } fun startNodes() { require(nodes.isNotEmpty()) diff --git a/test-utils/src/main/kotlin/net/corda/testing/node/SimpleNode.kt b/test-utils/src/main/kotlin/net/corda/testing/node/SimpleNode.kt index 73de38dc5b..0104fd981c 100644 --- a/test-utils/src/main/kotlin/net/corda/testing/node/SimpleNode.kt +++ b/test-utils/src/main/kotlin/net/corda/testing/node/SimpleNode.kt @@ -45,7 +45,7 @@ class SimpleNode(val config: NodeConfiguration, val address: HostAndPort = freeL val executor = ServiceAffinityExecutor(config.myLegalName.commonName, 1) val broker = ArtemisMessagingServer(config, address.port, rpcAddress.port, InMemoryNetworkMapCache(), userService) val networkMapRegistrationFuture: SettableFuture = SettableFuture.create() - val net = database.transaction { + val network = database.transaction { NodeMessagingClient( config, MOCK_VERSION_INFO, @@ -59,18 +59,18 @@ class SimpleNode(val config: NodeConfiguration, val address: HostAndPort = freeL fun start() { broker.start() - net.start( + network.start( object : RPCOps { override val protocolVersion = 0 }, userService) thread(name = config.myLegalName.commonName) { - net.run(broker.serverControl) + network.run(broker.serverControl) } } override fun close() { - net.stop() + network.stop() broker.stop() databaseWithCloseable.first.close() executor.shutdownNow()