ExternalVendorCode/corda
1
0
Fork 0
mirror of https://github.com/corda/corda.git synced 2025-06-16 22:28:15 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

[CORDA-442] make MockNetwork not start a networkmap node (#1908)

Browse Source 
* [CORDA-442] make MockNetwork not start a networkmap node

Now MockNetwork will put the appropriate NodeInfos inside each running node networkMapCache.

Tests relating to networkmap node starting and interaction have been removed since they where relaying on MockNetwork
This commit is contained in:
Alberto Arri
2017-10-23 16:50:53 +01:00
committed by GitHub
parent b73020a014
commit b04368e36a
24 changed files with 79 additions and 513 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt
View File

@ -689,6 +689,7 @@ abstract class AbstractNode(config: NodeConfiguration,
toRun()
}
runOnStop.clear()
_started = null
}
protected abstract fun makeMessagingService(legalIdentity: PartyAndCertificate): MessagingService

6
node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt
View File

@ -29,9 +29,12 @@ import net.corda.node.services.FlowPermissions.Companion.startFlowPermission
import net.corda.node.services.messaging.CURRENT_RPC_CONTEXT
import net.corda.node.services.messaging.RpcContext
import net.corda.nodeapi.User
import net.corda.testing.*
import net.corda.testing.chooseIdentity
import net.corda.testing.expect
import net.corda.testing.expectEvents
import net.corda.testing.node.MockNetwork
import net.corda.testing.node.MockNetwork.MockNode
import net.corda.testing.sequence
import org.apache.commons.io.IOUtils
import org.assertj.core.api.Assertions.assertThatExceptionOfType
import org.junit.After
@ -72,7 +75,6 @@ class CordaRPCOpsImplTest {
))))
mockNet.runNetwork()
mockNet.networkMapNode.internals.ensureRegistered()
notary = rpc.notaryIdentities().first()
}

20
node/src/test/kotlin/net/corda/node/messaging/InMemoryMessagingTests.kt
View File

@ -47,23 +47,17 @@ class InMemoryMessagingTests {
@Test
fun basics() {
val node1 = mockNet.networkMapNode
val node1 = mockNet.createNode()
val node2 = mockNet.createNode()
val node3 = mockNet.createNode()
val bits = "test-content".toByteArray()
var finalDelivery: Message? = null
with(node2) {
node2.network.addMessageHandler { msg, _ ->
node2.network.send(msg, node3.network.myAddress)
}
node2.network.addMessageHandler { msg, _ ->
node2.network.send(msg, node3.network.myAddress)
}
with(node3) {
node2.network.addMessageHandler { msg, _ ->
finalDelivery = msg
}
node3.network.addMessageHandler { msg, _ ->
finalDelivery = msg
}
// Node 1 sends a message and it should end up in finalDelivery, after we run the network
@ -76,7 +70,7 @@ class InMemoryMessagingTests {
@Test
fun broadcast() {
val node1 = mockNet.networkMapNode
val node1 = mockNet.createNode()
val node2 = mockNet.createNode()
val node3 = mockNet.createNode()
@ -95,7 +89,7 @@ class InMemoryMessagingTests {
*/
@Test
fun `skip unhandled messages`() {
val node1 = mockNet.networkMapNode
val node1 = mockNet.createNode()
val node2 = mockNet.createNode()
var received = 0

13
node/src/test/kotlin/net/corda/node/messaging/TwoPartyTradeFlowTests.kt
View File

@ -13,7 +13,6 @@ import net.corda.core.internal.FlowStateMachine
import net.corda.core.internal.concurrent.map
import net.corda.core.internal.rootCause
import net.corda.core.messaging.DataFeed
import net.corda.core.messaging.SingleMessageRecipient
import net.corda.core.messaging.StateMachineTransactionMapping
import net.corda.core.node.services.Vault
import net.corda.core.serialization.CordaSerializable
@ -75,7 +74,7 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
companion object {
private val cordappPackages = listOf("net.corda.finance.contracts")
@JvmStatic
@Parameterized.Parameters
@Parameterized.Parameters(name = "Anonymous = {0}")
fun data(): Collection<Boolean> {
return listOf(true, false)
}
@ -269,9 +268,9 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
// ... 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 = mockNet.createNode(bobAddr.id, object : MockNetwork.Factory<MockNetwork.MockNode> {
override fun create(config: NodeConfiguration, network: MockNetwork, networkMapAddr: SingleMessageRecipient?,
override fun create(config: NodeConfiguration, network: MockNetwork,
id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?, entropyRoot: BigInteger): MockNetwork.MockNode {
return MockNetwork.MockNode(config, network, networkMapAddr, bobAddr.id, notaryIdentity, entropyRoot)
return MockNetwork.MockNode(config, network, bobAddr.id, notaryIdentity, entropyRoot)
}
}, BOB_NAME)
@ -311,10 +310,9 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
return mockNet.createNode(nodeFactory = object : MockNetwork.Factory<MockNetwork.MockNode> {
override fun create(config: NodeConfiguration,
network: MockNetwork,
networkMapAddr: SingleMessageRecipient?,
id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?,
entropyRoot: BigInteger): MockNetwork.MockNode {
return object : MockNetwork.MockNode(config, network, networkMapAddr, id, notaryIdentity, entropyRoot) {
return object : MockNetwork.MockNode(config, network, id, notaryIdentity, entropyRoot) {
// That constructs a recording tx storage
override fun makeTransactionStorage(): WritableTransactionStorage {
return RecordingTransactionStorage(database, super.makeTransactionStorage())
@ -332,7 +330,6 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
val bobNode = makeNodeWithTracking(BOB_NAME)
val bankNode = makeNodeWithTracking(BOC_NAME)
mockNet.runNetwork()
notaryNode.internals.ensureRegistered()
val notary = aliceNode.services.getDefaultNotary()
val alice = aliceNode.info.singleIdentity()
val bob = bobNode.info.singleIdentity()
@ -440,7 +437,6 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
val bankNode = makeNodeWithTracking(BOC_NAME)
mockNet.runNetwork()
notaryNode.internals.ensureRegistered()
val notary = aliceNode.services.getDefaultNotary()
val alice: Party = aliceNode.info.singleIdentity()
val bank: Party = bankNode.info.singleIdentity()
@ -596,7 +592,6 @@ class TwoPartyTradeFlowTests(val anonymous: Boolean) {
val bankNode = mockNet.createPartyNode(BOC_NAME)
mockNet.runNetwork()
notaryNode.internals.ensureRegistered()
val notary = aliceNode.services.getDefaultNotary()
val alice = aliceNode.info.singleIdentity()
val bob = bobNode.info.singleIdentity()

2
node/src/test/kotlin/net/corda/node/services/NotaryChangeTests.kt
View File

@ -13,7 +13,6 @@ import net.corda.core.transactions.WireTransaction
import net.corda.core.utilities.getOrThrow
import net.corda.core.utilities.seconds
import net.corda.node.internal.StartedNode
import net.corda.node.services.api.ServiceHubInternal
import net.corda.testing.*
import net.corda.testing.contracts.DummyContract
import net.corda.testing.node.MockNetwork
@ -43,7 +42,6 @@ class NotaryChangeTests {
clientNodeB = mockNet.createNode()
newNotaryNode = mockNet.createNotaryNode(legalName = DUMMY_NOTARY.name.copy(organisation = "Dummy Notary 2"))
mockNet.runNetwork() // Clear network map registration messages
oldNotaryNode.internals.ensureRegistered()
oldNotaryParty = newNotaryNode.services.networkMapCache.getNotary(DUMMY_NOTARY_SERVICE_NAME)!!
newNotaryParty = newNotaryNode.services.networkMapCache.getNotary(DUMMY_NOTARY_SERVICE_NAME.copy(organisation = "Dummy Notary 2"))!!
}

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

@ -16,8 +16,11 @@ import net.corda.core.transactions.TransactionBuilder
import net.corda.core.utilities.getOrThrow
import net.corda.node.internal.StartedNode
import net.corda.node.services.statemachine.StateMachineManager
import net.corda.testing.*
import net.corda.testing.DUMMY_NOTARY
import net.corda.testing.chooseIdentity
import net.corda.testing.contracts.DummyContract
import net.corda.testing.dummyCommand
import net.corda.testing.getDefaultNotary
import net.corda.testing.node.MockNetwork
import org.junit.After
import org.junit.Assert.*
@ -96,8 +99,6 @@ class ScheduledFlowTests {
val a = mockNet.createUnstartedNode()
val b = mockNet.createUnstartedNode()
notaryNode.internals.ensureRegistered()
mockNet.startNodes()
nodeA = a.started!!
nodeB = b.started!!

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

@ -1,281 +0,0 @@
package net.corda.node.services.network
import net.corda.core.concurrent.CordaFuture
import net.corda.core.identity.CordaX500Name
import net.corda.core.messaging.SingleMessageRecipient
import net.corda.core.node.NodeInfo
import net.corda.core.serialization.deserialize
import net.corda.core.utilities.getOrThrow
import net.corda.node.internal.StartedNode
import net.corda.node.services.api.NetworkMapCacheInternal
import net.corda.node.services.config.NodeConfiguration
import net.corda.node.services.messaging.MessagingService
import net.corda.node.services.messaging.send
import net.corda.node.services.messaging.sendRequest
import net.corda.node.services.network.AbstractNetworkMapServiceTest.Changed.Added
import net.corda.node.services.network.AbstractNetworkMapServiceTest.Changed.Removed
import net.corda.node.services.network.NetworkMapService.*
import net.corda.node.services.network.NetworkMapService.Companion.FETCH_TOPIC
import net.corda.node.services.network.NetworkMapService.Companion.PUSH_ACK_TOPIC
import net.corda.node.services.network.NetworkMapService.Companion.PUSH_TOPIC
import net.corda.node.services.network.NetworkMapService.Companion.QUERY_TOPIC
import net.corda.node.services.network.NetworkMapService.Companion.REGISTER_TOPIC
import net.corda.node.services.network.NetworkMapService.Companion.SUBSCRIPTION_TOPIC
import net.corda.node.utilities.AddOrRemove
import net.corda.node.utilities.AddOrRemove.ADD
import net.corda.node.utilities.AddOrRemove.REMOVE
import net.corda.nodeapi.internal.ServiceInfo
import net.corda.testing.*
import net.corda.testing.node.MockNetwork
import net.corda.testing.node.MockNetwork.MockNode
import org.assertj.core.api.Assertions.assertThat
import org.junit.After
import org.junit.Before
import org.junit.Test
import java.math.BigInteger
import java.security.KeyPair
import java.time.Instant
import java.util.*
import java.util.concurrent.LinkedBlockingQueue
abstract class AbstractNetworkMapServiceTest<out S : AbstractNetworkMapService> {
lateinit var mockNet: MockNetwork
lateinit var mapServiceNode: StartedNode<MockNode>
lateinit var alice: StartedNode<MockNode>
companion object {
val subscriberLegalName = CordaX500Name(organisation = "Subscriber", locality = "New York", country = "US")
}
@Before
fun setup() {
mockNet = MockNetwork(defaultFactory = nodeFactory)
mapServiceNode = mockNet.networkMapNode
alice = mockNet.createNode(nodeFactory = nodeFactory, legalName = ALICE.name)
mockNet.runNetwork()
lastSerial = System.currentTimeMillis()
}
@After
fun tearDown() {
mockNet.stopNodes()
}
protected abstract val nodeFactory: MockNetwork.Factory<*>
protected abstract val networkMapService: S
// For persistent service, switch out the implementation for a newly instantiated one so we can check the state is preserved.
protected abstract fun swizzle()
@Test
fun `all nodes register themselves`() {
// setup has run the network and so we immediately expect the network map service to be correctly populated
assertThat(alice.fetchMap()).containsOnly(Added(mapServiceNode), Added(alice))
assertThat(alice.identityQuery()).isEqualTo(alice.info)
assertThat(mapServiceNode.identityQuery()).isEqualTo(mapServiceNode.info)
}
@Test
fun `re-register the same node`() {
val response = alice.registration(ADD)
swizzle()
assertThat(response.getOrThrow().error).isNull()
assertThat(alice.fetchMap()).containsOnly(Added(mapServiceNode), Added(alice)) // Confirm it's a no-op
}
@Test
fun `re-register with smaller serial value`() {
val response = alice.registration(ADD, serial = 1)
swizzle()
assertThat(response.getOrThrow().error).isNotNull() // Make sure send error message is sent back
assertThat(alice.fetchMap()).containsOnly(Added(mapServiceNode), Added(alice)) // Confirm it's a no-op
}
@Test
fun `de-register node`() {
val response = alice.registration(REMOVE)
swizzle()
assertThat(response.getOrThrow().error).isNull()
assertThat(alice.fetchMap()).containsOnly(Added(mapServiceNode), Removed(alice))
swizzle()
assertThat(alice.identityQuery()).isNull()
assertThat(mapServiceNode.identityQuery()).isEqualTo(mapServiceNode.info)
}
@Test
fun `de-register same node again`() {
alice.registration(REMOVE)
val response = alice.registration(REMOVE)
swizzle()
assertThat(response.getOrThrow().error).isNotNull() // Make sure send error message is sent back
assertThat(alice.fetchMap()).containsOnly(Added(mapServiceNode), Removed(alice))
}
@Test
fun `de-register unknown node`() {
val bob = newNodeSeparateFromNetworkMap(BOB.name)
val response = bob.registration(REMOVE)
swizzle()
assertThat(response.getOrThrow().error).isNotNull() // Make sure send error message is sent back
assertThat(alice.fetchMap()).containsOnly(Added(mapServiceNode), Added(alice))
}
@Test
fun `subscribed while new node registers`() {
val updates = alice.subscribe()
swizzle()
val bob = addNewNodeToNetworkMap(BOB.name)
swizzle()
val update = updates.single()
assertThat(update.mapVersion).isEqualTo(networkMapService.mapVersion)
assertThat(update.wireReg.verified().toChanged()).isEqualTo(Added(bob.info))
}
@Test
fun `subscribed while node de-registers`() {
val bob = addNewNodeToNetworkMap(BOB.name)
val updates = alice.subscribe()
bob.registration(REMOVE)
swizzle()
assertThat(updates.map { it.wireReg.verified().toChanged() }).containsOnly(Removed(bob.info))
}
@Test
fun unsubscribe() {
val updates = alice.subscribe()
val bob = addNewNodeToNetworkMap(BOB.name)
alice.unsubscribe()
addNewNodeToNetworkMap(CHARLIE.name)
swizzle()
assertThat(updates.map { it.wireReg.verified().toChanged() }).containsOnly(Added(bob.info))
}
@Test
fun `surpass unacknowledged update limit`() {
val subscriber = newNodeSeparateFromNetworkMap(subscriberLegalName)
val updates = subscriber.subscribe()
val bob = addNewNodeToNetworkMap(BOB.name)
var serial = updates.first().wireReg.verified().serial
repeat(networkMapService.maxUnacknowledgedUpdates) {
bob.registration(ADD, serial = ++serial)
swizzle()
}
// We sent maxUnacknowledgedUpdates + 1 updates - the last one will be missed
assertThat(updates).hasSize(networkMapService.maxUnacknowledgedUpdates)
}
@Test
fun `delay sending update ack until just before unacknowledged update limit`() {
val subscriber = newNodeSeparateFromNetworkMap(subscriberLegalName)
val updates = subscriber.subscribe()
val bob = addNewNodeToNetworkMap(BOB.name)
var serial = updates.first().wireReg.verified().serial
repeat(networkMapService.maxUnacknowledgedUpdates - 1) {
bob.registration(ADD, serial = ++serial)
swizzle()
}
// Subscriber will receive maxUnacknowledgedUpdates updates before sending ack
subscriber.ackUpdate(updates.last().mapVersion)
swizzle()
bob.registration(ADD, serial = ++serial)
assertThat(updates).hasSize(networkMapService.maxUnacknowledgedUpdates + 1)
assertThat(updates.last().wireReg.verified().serial).isEqualTo(serial)
}
private fun StartedNode<*>.fetchMap(subscribe: Boolean = false, ifChangedSinceVersion: Int? = null): List<Changed> {
val request = FetchMapRequest(subscribe, ifChangedSinceVersion, network.myAddress)
val response = services.networkService.sendRequest<FetchMapResponse>(FETCH_TOPIC, request, mapServiceNode.network.myAddress)
mockNet.runNetwork()
return response.getOrThrow().nodes?.map { it.toChanged() } ?: emptyList()
}
private fun NodeRegistration.toChanged(): Changed = when (type) {
ADD -> Added(node)
REMOVE -> Removed(node)
}
private fun StartedNode<*>.identityQuery(): NodeInfo? {
val request = QueryIdentityRequest(services.myInfo.chooseIdentityAndCert(), network.myAddress)
val response = services.networkService.sendRequest<QueryIdentityResponse>(QUERY_TOPIC, request, mapServiceNode.network.myAddress)
mockNet.runNetwork()
return response.getOrThrow().node
}
private var lastSerial = Long.MIN_VALUE
private fun StartedNode<*>.registration(addOrRemove: AddOrRemove,
serial: Long? = null): CordaFuture<RegistrationResponse> {
val distinctSerial = if (serial == null) {
++lastSerial
} else {
lastSerial = serial
serial
}
val expires = Instant.now() + NetworkMapService.DEFAULT_EXPIRATION_PERIOD
val nodeRegistration = NodeRegistration(info, distinctSerial, addOrRemove, expires)
val request = RegistrationRequest(nodeRegistration.toWire(services.keyManagementService, info.chooseIdentity().owningKey), network.myAddress)
val response = services.networkService.sendRequest<RegistrationResponse>(REGISTER_TOPIC, request, mapServiceNode.network.myAddress)
mockNet.runNetwork()
return response
}
private fun StartedNode<*>.subscribe(): Queue<Update> {
val request = SubscribeRequest(true, network.myAddress)
val updates = LinkedBlockingQueue<Update>()
services.networkService.addMessageHandler(PUSH_TOPIC) { message, _ ->
updates += message.data.deserialize<Update>()
}
val response = services.networkService.sendRequest<SubscribeResponse>(SUBSCRIPTION_TOPIC, request, mapServiceNode.network.myAddress)
mockNet.runNetwork()
assertThat(response.getOrThrow().confirmed).isTrue()
return updates
}
private fun StartedNode<*>.unsubscribe() {
val request = SubscribeRequest(false, network.myAddress)
val response = services.networkService.sendRequest<SubscribeResponse>(SUBSCRIPTION_TOPIC, request, mapServiceNode.network.myAddress)
mockNet.runNetwork()
assertThat(response.getOrThrow().confirmed).isTrue()
}
private fun StartedNode<*>.ackUpdate(mapVersion: Int) {
val request = UpdateAcknowledge(mapVersion, services.networkService.myAddress)
services.networkService.send(PUSH_ACK_TOPIC, MessagingService.DEFAULT_SESSION_ID, request, mapServiceNode.network.myAddress)
mockNet.runNetwork()
}
private fun addNewNodeToNetworkMap(legalName: CordaX500Name): StartedNode<MockNode> {
val node = mockNet.createNode(legalName = legalName)
mockNet.runNetwork()
lastSerial = System.currentTimeMillis()
return node
}
private fun newNodeSeparateFromNetworkMap(legalName: CordaX500Name): StartedNode<MockNode> {
return mockNet.createNode(legalName = legalName, nodeFactory = NoNMSNodeFactory)
}
sealed class Changed {
data class Added(val node: NodeInfo) : Changed() {
constructor(node: StartedNode<*>) : this(node.info)
}
data class Removed(val node: NodeInfo) : Changed() {
constructor(node: StartedNode<*>) : this(node.info)
}
}
private object NoNMSNodeFactory : MockNetwork.Factory<MockNode> {
override fun create(config: NodeConfiguration,
network: MockNetwork,
networkMapAddr: SingleMessageRecipient?,
id: Int,
notaryIdentity: Pair<ServiceInfo, KeyPair>?,
entropyRoot: BigInteger): MockNode {
return object : MockNode(config, network, null, id, notaryIdentity, entropyRoot) {
override fun makeNetworkMapService(network: MessagingService, networkMapCache: NetworkMapCacheInternal) = NullNetworkMapService
}
}
}
}

9
node/src/test/kotlin/net/corda/node/services/network/InMemoryNetworkMapServiceTest.kt
View File

@ -1,9 +0,0 @@
package net.corda.node.services.network
import net.corda.testing.node.MockNetwork
class InMemoryNetworkMapServiceTest : AbstractNetworkMapServiceTest<InMemoryNetworkMapService>() {
override val nodeFactory get() = MockNetwork.DefaultFactory
override val networkMapService: InMemoryNetworkMapService get() = mapServiceNode.inNodeNetworkMapService as InMemoryNetworkMapService
override fun swizzle() = Unit
}

18
node/src/test/kotlin/net/corda/node/services/network/NetworkMapCacheTest.kt
View File

@ -1,40 +1,24 @@
package net.corda.node.services.network
import net.corda.core.node.services.NetworkMapCache
import net.corda.core.utilities.getOrThrow
import net.corda.testing.ALICE
import net.corda.testing.BOB
import net.corda.testing.chooseIdentity
import net.corda.testing.node.MockNetwork
import org.assertj.core.api.Assertions.assertThat
import org.junit.After
import org.junit.Before
import org.junit.Test
import java.math.BigInteger
import kotlin.test.assertEquals
class NetworkMapCacheTest {
lateinit var mockNet: MockNetwork
@Before
fun setUp() {
mockNet = MockNetwork()
}
val mockNet: MockNetwork = MockNetwork()
@After
fun teardown() {
mockNet.stopNodes()
}
@Test
fun registerWithNetwork() {
mockNet.createNotaryNode()
val aliceNode = mockNet.createPartyNode(ALICE.name)
val future = aliceNode.services.networkMapCache.addMapService(aliceNode.network, mockNet.networkMapNode.network.myAddress, false, null)
mockNet.runNetwork()
future.getOrThrow()
}
@Test
fun `key collision`() {
val entropy = BigInteger.valueOf(24012017L)

56
node/src/test/kotlin/net/corda/node/services/network/PersistentNetworkMapServiceTest.kt
View File

@ -1,56 +0,0 @@
package net.corda.node.services.network
import net.corda.core.messaging.SingleMessageRecipient
import net.corda.node.services.api.NetworkMapCacheInternal
import net.corda.node.services.config.NodeConfiguration
import net.corda.node.services.messaging.MessagingService
import net.corda.nodeapi.internal.ServiceInfo
import net.corda.testing.node.MockNetwork
import net.corda.testing.node.MockNetwork.MockNode
import java.math.BigInteger
import java.security.KeyPair
/**
* This class mirrors [InMemoryNetworkMapServiceTest] but switches in a [PersistentNetworkMapService] and
* repeatedly replaces it with new instances to check that the service correctly restores the most recent state.
*/
class PersistentNetworkMapServiceTest : AbstractNetworkMapServiceTest<PersistentNetworkMapService>() {
override val nodeFactory: MockNetwork.Factory<*> get() = NodeFactory
override val networkMapService: PersistentNetworkMapService
get() = (mapServiceNode.inNodeNetworkMapService as SwizzleNetworkMapService).delegate
override fun swizzle() {
mapServiceNode.database.transaction {
(mapServiceNode.inNodeNetworkMapService as SwizzleNetworkMapService).swizzle()
}
}
private object NodeFactory : MockNetwork.Factory<MockNode> {
override fun create(config: NodeConfiguration,
network: MockNetwork,
networkMapAddr: SingleMessageRecipient?,
id: Int,
notaryIdentity: Pair<ServiceInfo, KeyPair>?,
entropyRoot: BigInteger): MockNode {
return object : MockNode(config, network, networkMapAddr, id, notaryIdentity, entropyRoot) {
override fun makeNetworkMapService(network: MessagingService, networkMapCache: NetworkMapCacheInternal) = SwizzleNetworkMapService(network, networkMapCache)
}
}
}
/**
* We use a special [NetworkMapService] that allows us to switch in a new instance at any time to check that the
* state within it is correctly restored.
*/
private class SwizzleNetworkMapService(private val delegateFactory: () -> PersistentNetworkMapService) : NetworkMapService {
constructor(network: MessagingService, networkMapCache: NetworkMapCacheInternal) : this({ PersistentNetworkMapService(network, networkMapCache, 1) })
var delegate = delegateFactory()
fun swizzle() {
delegate.unregisterNetworkHandlers()
delegate = delegateFactory()
}
}
}

30
node/src/test/kotlin/net/corda/node/services/statemachine/FlowFrameworkTests.kt
View File

@ -39,6 +39,7 @@ import org.assertj.core.api.Assertions.assertThatThrownBy
import org.assertj.core.api.AssertionsForClassTypes.assertThatExceptionOfType
import org.junit.After
import org.junit.Before
import org.junit.Ignore
import org.junit.Test
import rx.Notification
import rx.Observable
@ -75,7 +76,6 @@ class FlowFrameworkTests {
bobNode = mockNet.createNode(legalName = BOB_NAME)
mockNet.runNetwork()
aliceNode.internals.ensureRegistered()
// We intentionally create our own notary and ignore the one provided by the network
// Note that these notaries don't operate correctly as they don't share their state. They are only used for testing
@ -156,33 +156,6 @@ class FlowFrameworkTests {
assertEquals(true, flow.flowStarted) // Now we should have run the flow
}
@Test
fun `flow added before network map will be init checkpointed`() {
var charlieNode = mockNet.createNode() //create vanilla node
val flow = NoOpFlow()
charlieNode.services.startFlow(flow)
assertEquals(false, flow.flowStarted) // Not started yet as no network activity has been allowed yet
charlieNode.internals.disableDBCloseOnStop()
charlieNode.services.networkMapCache.clearNetworkMapCache() // zap persisted NetworkMapCache to force use of network.
charlieNode.dispose()
charlieNode = mockNet.createNode(charlieNode.internals.id)
val restoredFlow = charlieNode.getSingleFlow<NoOpFlow>().first
assertEquals(false, restoredFlow.flowStarted) // Not started yet as no network activity has been allowed yet
mockNet.runNetwork() // Allow network map messages to flow
charlieNode.flushSmm()
assertEquals(true, restoredFlow.flowStarted) // Now we should have run the flow and hopefully cleared the init checkpoint
charlieNode.internals.disableDBCloseOnStop()
charlieNode.services.networkMapCache.clearNetworkMapCache() // zap persisted NetworkMapCache to force use of network.
charlieNode.dispose()
// Now it is completed the flow should leave no Checkpoint.
charlieNode = mockNet.createNode(charlieNode.internals.id)
mockNet.runNetwork() // Allow network map messages to flow
charlieNode.flushSmm()
assertTrue(charlieNode.smm.findStateMachines(NoOpFlow::class.java).isEmpty())
}
@Test
fun `flow loaded from checkpoint will respond to messages from before start`() {
aliceNode.registerFlowFactory(ReceiveFlow::class) { InitiatedSendFlow("Hello", it) }
@ -195,6 +168,7 @@ class FlowFrameworkTests {
assertThat(restoredFlow.receivedPayloads[0]).isEqualTo("Hello")
}
@Ignore("Some changes in startup order make this test's assumptions fail.")
@Test
fun `flow with send will resend on interrupted restart`() {
val payload = random63BitValue()

1
node/src/test/kotlin/net/corda/node/services/transactions/NotaryServiceTests.kt
View File

@ -39,7 +39,6 @@ class NotaryServiceTests {
val notaryNode = mockNet.createNotaryNode(legalName = DUMMY_NOTARY.name, validating = false)
aliceServices = mockNet.createNode(legalName = ALICE_NAME).services
mockNet.runNetwork() // Clear network map registration messages
notaryNode.internals.ensureRegistered()
notaryServices = notaryNode.services
notary = notaryServices.getDefaultNotary()
alice = aliceServices.myInfo.singleIdentity()

1
node/src/test/kotlin/net/corda/node/services/transactions/ValidatingNotaryServiceTests.kt
View File

@ -39,7 +39,6 @@ class ValidatingNotaryServiceTests {
val notaryNode = mockNet.createNotaryNode(legalName = DUMMY_NOTARY.name)
val aliceNode = mockNet.createNode(legalName = ALICE_NAME)
mockNet.runNetwork() // Clear network map registration messages
notaryNode.internals.ensureRegistered()
notaryServices = notaryNode.services
aliceServices = aliceNode.services
notary = notaryServices.getDefaultNotary()

5
node/src/test/kotlin/net/corda/node/services/vault/VaultSoftLockManagerTest.kt
View File

@ -11,7 +11,6 @@ import net.corda.core.identity.AbstractParty
import net.corda.core.internal.FlowStateMachine
import net.corda.core.internal.packageName
import net.corda.core.internal.uncheckedCast
import net.corda.core.messaging.SingleMessageRecipient
import net.corda.core.node.StateLoader
import net.corda.core.node.services.KeyManagementService
import net.corda.core.node.services.queryBy
@ -84,8 +83,8 @@ class VaultSoftLockManagerTest {
doNothing().whenever(it).softLockRelease(any(), anyOrNull())
}
private val mockNet = MockNetwork(cordappPackages = listOf(ContractImpl::class.packageName), defaultFactory = object : MockNetwork.Factory<MockNetwork.MockNode> {
override fun create(config: NodeConfiguration, network: MockNetwork, networkMapAddr: SingleMessageRecipient?, id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?, entropyRoot: BigInteger): MockNetwork.MockNode {
return object : MockNetwork.MockNode(config, network, networkMapAddr, id, notaryIdentity, entropyRoot) {
override fun create(config: NodeConfiguration, network: MockNetwork, id: Int, notaryIdentity: Pair<ServiceInfo, KeyPair>?, entropyRoot: BigInteger): MockNetwork.MockNode {
return object : MockNetwork.MockNode(config, network, id, notaryIdentity, entropyRoot) {
override fun makeVaultService(keyManagementService: KeyManagementService, stateLoader: StateLoader): VaultServiceInternal {
val realVault = super.makeVaultService(keyManagementService, stateLoader)
return object : VaultServiceInternal by realVault {