[CORDA-1494] Enable TimeFlow test integration tests to run properly with external DBs (#962)

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

@@ -34,62 +34,36 @@ import net.corda.node.internal.StartedNode
 import net.corda.node.services.config.NodeConfiguration
 import net.corda.node.services.config.NotaryConfig
 import net.corda.node.services.config.P2PMessagingRetryConfiguration
+import net.corda.node.services.vault.VaultQueryIntegrationTests
 import net.corda.nodeapi.internal.DevIdentityGenerator
 import net.corda.nodeapi.internal.network.NetworkParametersCopier
 import net.corda.testing.common.internal.testNetworkParameters
 import net.corda.testing.contracts.DummyContract
 import net.corda.testing.core.dummyCommand
 import net.corda.testing.core.singleIdentity
+import net.corda.testing.internal.GlobalDatabaseRule
 import net.corda.testing.internal.LogHelper
+import net.corda.testing.internal.toDatabaseSchemaName
 import net.corda.testing.node.InMemoryMessagingNetwork
 import net.corda.testing.node.MockNetworkParameters
 import net.corda.testing.node.internal.InternalMockNetwork
 import net.corda.testing.node.internal.InternalMockNodeParameters
 import net.corda.testing.node.internal.startFlow
-import org.junit.AfterClass
+import org.junit.*
-import org.junit.Before
+import org.junit.rules.ExternalResource
-import org.junit.BeforeClass
+import org.junit.rules.RuleChain
-import org.junit.Test
 import org.slf4j.MDC
 import java.security.PublicKey
 import java.util.concurrent.atomic.AtomicInteger
 
-class TimedFlowTests {
+class TimedFlowTestRule(val clusterSize: Int) : ExternalResource() {
-    companion object {
-        /** The notary nodes don't run any consensus protocol, so 2 nodes are sufficient for the purpose of this test. */
-        private const val CLUSTER_SIZE = 2
-        /** A shared counter across all notary service nodes. */
-        var requestsReceived: AtomicInteger = AtomicInteger(0)
 
-        private lateinit var mockNet: InternalMockNetwork
+    lateinit var mockNet: InternalMockNetwork
-        private lateinit var notary: Party
+    lateinit var notary: Party
-        private lateinit var node: StartedNode<InternalMockNetwork.MockNode>
+    lateinit var node: StartedNode<InternalMockNetwork.MockNode>
-
-        init {
-            LogHelper.setLevel("+net.corda.flow", "+net.corda.testing.node", "+net.corda.node.services.messaging")
-        }
-
-        @BeforeClass
-        @JvmStatic
-        fun setup() {
-            mockNet = InternalMockNetwork(
-                    listOf("net.corda.testing.contracts", "net.corda.node.services"),
-                    MockNetworkParameters().withServicePeerAllocationStrategy(InMemoryMessagingNetwork.ServicePeerAllocationStrategy.RoundRobin()),
-                    threadPerNode = true
-            )
-            val started = startClusterAndNode(mockNet)
-            notary = started.first
-            node = started.second
-        }
-
-        @AfterClass
-        @JvmStatic
-        fun stopNodes() {
-            mockNet.stopNodes()
-        }
 
     private fun startClusterAndNode(mockNet: InternalMockNetwork): Pair<Party, StartedNode<InternalMockNetwork.MockNode>> {
-            val replicaIds = (0 until CLUSTER_SIZE)
+        val replicaIds = (0 until clusterSize)
         val notaryIdentity = DevIdentityGenerator.generateDistributedNotaryCompositeIdentity(
                 replicaIds.map { mockNet.baseDirectory(mockNet.nextNodeId + it) },
                 CordaX500Name("Custom Notary", "Zurich", "CH"))
@@ -101,7 +75,7 @@ class TimedFlowTests {
             whenever(it.validating).thenReturn(true)
         }
 
-            val notaryNodes = (0 until CLUSTER_SIZE).map {
+        val notaryNodes = (0 until clusterSize).map {
             mockNet.createUnstartedNode(InternalMockNodeParameters(configOverrides = {
                 doReturn(notaryConfig).whenever(it).notary
             }))
@@ -111,7 +85,7 @@ class TimedFlowTests {
                 InternalMockNodeParameters(
                         legalName = CordaX500Name("Alice", "AliceCorp", "GB"),
                         configOverrides = { conf: NodeConfiguration ->
-                                val retryConfig = P2PMessagingRetryConfiguration(1.seconds, 3, 1.0)
+                            val retryConfig = P2PMessagingRetryConfiguration(10.seconds, 3, 1.0)
                             doReturn(retryConfig).whenever(conf).p2pMessagingRetry
                         }
                 )
@@ -126,6 +100,45 @@ class TimedFlowTests {
 
         return Pair(notaryIdentity, node)
     }
+
+
+    override fun before() {
+        mockNet = InternalMockNetwork(
+                listOf("net.corda.testing.contracts", "net.corda.node.services"),
+                MockNetworkParameters().withServicePeerAllocationStrategy(InMemoryMessagingNetwork.ServicePeerAllocationStrategy.RoundRobin()),
+                threadPerNode = true
+        )
+        val started = startClusterAndNode(mockNet)
+        notary = started.first
+        node = started.second
+    }
+
+    override fun after() {
+        mockNet.stopNodes()
+    }
+}
+
+class TimedFlowTests {
+    companion object {
+        /** A shared counter across all notary service nodes. */
+        var requestsReceived: AtomicInteger = AtomicInteger(0)
+
+        private val notary by lazy { globalRule.notary }
+        private val node by lazy { globalRule.node }
+
+        init {
+            LogHelper.setLevel("+net.corda.flow", "+net.corda.testing.node", "+net.corda.node.services.messaging")
+        }
+
+        /** node_0 for default notary created by mock network + alice + cluster size = 5 */
+        private val globalDatabaseRule = GlobalDatabaseRule(listOf("node_0", "node_1", "node_2", "node_3"))
+
+        /** The notary nodes don't run any consensus protocol, so 2 nodes are sufficient for the purpose of this test. */
+        private val globalRule = TimedFlowTestRule(2)
+
+        @ClassRule @JvmField
+        val ruleChain = RuleChain.outerRule(globalDatabaseRule).around(globalRule)
+
     }
 
     @Before