SQL Azure and SQL Server database integration tests (#115)

* Integration test are parameterised (extends IntegrationTest) to run against a remote database with 4 db scripts run @BeforeClass, @Before, @After and @AfterClass.
* SQL script for SQL Azure and SQL Server databases and templates of JDBC configuration.

node/build.gradle

@@ -35,6 +35,7 @@ sourceSets {
         }
         resources {
             srcDir file('src/integration-test/resources')
+            srcDir file('../../testing/test-utils/src/main/resources')
         }
     }
 }

node/src/integration-test/kotlin/net/corda/node/BootTests.kt

@@ -9,18 +9,23 @@ import net.corda.core.utilities.getOrThrow
 import net.corda.node.internal.NodeStartup
 import net.corda.node.services.Permissions.Companion.startFlow
 import net.corda.nodeapi.User
-import net.corda.testing.ALICE
-import net.corda.testing.IntegrationTest
+import net.corda.testing.*
 import net.corda.testing.common.internal.ProjectStructure.projectRootDir
 import net.corda.testing.driver.driver
 import org.assertj.core.api.Assertions.assertThat
 import org.assertj.core.api.Assertions.assertThatThrownBy
+import org.junit.ClassRule
 import org.junit.Test
 import java.io.*
 import java.nio.file.Files
 import kotlin.test.assertEquals
 
 class BootTests : IntegrationTest() {
+     companion object {
+        @ClassRule @JvmField
+        val databaseSchemas = IntegrationTestSchemas(*listOf(ALICE, BOB, DUMMY_BANK_A)
+                .map { it.toDatabaseSchemaNames("", "_10000","_10003") }.flatten().toTypedArray())
+     }
 
     @Test
     fun `java deserialization is disabled`() {

node/src/integration-test/kotlin/net/corda/node/CordappScanningDriverTest.kt

@@ -9,15 +9,18 @@ import net.corda.core.utilities.getOrThrow
 import net.corda.core.utilities.unwrap
 import net.corda.node.services.Permissions.Companion.startFlow
 import net.corda.nodeapi.User
-import net.corda.testing.ALICE
-import net.corda.testing.BOB
-import net.corda.testing.IntegrationTest
-import net.corda.testing.chooseIdentity
+import net.corda.testing.*
 import net.corda.testing.driver.driver
 import org.assertj.core.api.Assertions.assertThat
+import org.junit.ClassRule
 import org.junit.Test
 
 class CordappScanningDriverTest : IntegrationTest() {
+    companion object {
+        @ClassRule @JvmField
+        val databaseSchemas = IntegrationTestSchemas(ALICE.toDatabaseSchemaName(), BOB.toDatabaseSchemaName())
+    }
+
     @Test
     fun `sub-classed initiated flow pointing to the same initiating flow as its super-class`() {
         val user = User("u", "p", setOf(startFlow<ReceiveFlow>()))

node/src/integration-test/kotlin/net/corda/node/NodePerformanceTests.kt

@@ -14,8 +14,7 @@ import net.corda.finance.flows.CashIssueFlow
 import net.corda.finance.flows.CashPaymentFlow
 import net.corda.node.services.Permissions.Companion.startFlow
 import net.corda.nodeapi.User
-import net.corda.testing.DUMMY_NOTARY
-import net.corda.testing.IntegrationTest
+import net.corda.testing.*
 import net.corda.testing.driver.NodeHandle
 import net.corda.testing.driver.driver
 import net.corda.testing.node.NotarySpec
@@ -24,6 +23,7 @@ import net.corda.testing.internal.performance.startPublishingFixedRateInjector
 import net.corda.testing.internal.performance.startReporter
 import net.corda.testing.internal.performance.startTightLoopInjector
 import org.junit.Before
+import org.junit.ClassRule
 import org.junit.Ignore
 import org.junit.Test
 import java.lang.management.ManagementFactory
@@ -40,6 +40,12 @@ private fun checkQuasarAgent() {
 
 @Ignore("Run these locally")
 class NodePerformanceTests : IntegrationTest() {
+     companion object {
+        @ClassRule @JvmField
+        val databaseSchemas = IntegrationTestSchemas(*DUMMY_NOTARY.toDatabaseSchemaNames("_0", "_1", "_2").toTypedArray(),
+                DUMMY_BANK_A.toDatabaseSchemaName())
+    }
+
     @StartableByRPC
     class EmptyFlow : FlowLogic<Unit>() {
         @Suspendable

node/src/integration-test/kotlin/net/corda/node/NodeStartupPerformanceTests.kt

@@ -1,8 +1,9 @@
 package net.corda.node
 
 import com.google.common.base.Stopwatch
-import net.corda.testing.IntegrationTest
+import net.corda.testing.*
 import net.corda.testing.driver.driver
+import org.junit.ClassRule
 import org.junit.Ignore
 import org.junit.Test
 import java.util.*
@@ -10,7 +11,10 @@ import java.util.concurrent.TimeUnit
 
 @Ignore("Only use locally")
 class NodeStartupPerformanceTests : IntegrationTest() {
-
+    companion object {
+        @ClassRule @JvmField
+        val databaseSchemas = IntegrationTestSchemas(*listOf(ALICE, BOB, DUMMY_BANK_A).map { it.toDatabaseSchemaName() }.toTypedArray())
+    }
     // Measure the startup time of nodes. Note that this includes an RPC roundtrip, which causes e.g. Kryo initialisation.
     @Test
     fun `single node startup time`() {

node/src/integration-test/kotlin/net/corda/node/SSHServerTest.kt

@@ -10,24 +10,29 @@ import net.corda.core.utilities.ProgressTracker
 import net.corda.core.utilities.getOrThrow
 import net.corda.core.utilities.unwrap
 import net.corda.nodeapi.User
-import net.corda.testing.ALICE
 import net.corda.testing.driver.driver
 import org.bouncycastle.util.io.Streams
 import org.junit.Test
 import net.corda.node.services.Permissions.Companion.startFlow
+import net.corda.testing.*
 import java.net.ConnectException
 import kotlin.test.assertTrue
 import kotlin.test.fail
 import org.assertj.core.api.Assertions.assertThat
+import org.junit.ClassRule
 import java.util.regex.Pattern
 
-class SSHServerTest {
+class SSHServerTest : IntegrationTest() {
+    companion object {
+        @ClassRule @JvmField
+        val databaseSchemas = IntegrationTestSchemas(ALICE.toDatabaseSchemaName())
+    }
 
     @Test()
     fun `ssh server does not start be default`() {
         val user = User("u", "p", setOf())
         // The driver will automatically pick up the annotated flows below
-        driver() {
+        driver {
             val node = startNode(providedName = ALICE.name, rpcUsers = listOf(user))
             node.getOrThrow()
 

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

@@ -20,7 +20,6 @@ import net.corda.node.internal.cordapp.CordappProviderImpl
 import net.corda.testing.*
 import net.corda.testing.DUMMY_BANK_A
 import net.corda.testing.DUMMY_NOTARY
-import net.corda.testing.SerializationEnvironmentRule
 import net.corda.testing.IntegrationTest
 import net.corda.testing.driver.DriverDSLExposedInterface
 import net.corda.testing.driver.NodeHandle
@@ -28,12 +27,14 @@ import net.corda.testing.driver.driver
 import net.corda.testing.node.MockServices
 import org.junit.Assert.assertEquals
 import org.junit.Before
+import org.junit.ClassRule
 import org.junit.Test
 import java.net.URLClassLoader
 import java.nio.file.Files
 import kotlin.test.assertFailsWith
 
 class AttachmentLoadingTests : IntegrationTest() {
+
     private class Services : MockServices() {
         private val provider = CordappProviderImpl(CordappLoader.createDevMode(listOf(isolatedJAR)), attachments)
         private val cordapp get() = provider.cordapps.first()
@@ -43,6 +44,10 @@ class AttachmentLoadingTests : IntegrationTest() {
     }
 
     private companion object {
+        @ClassRule @JvmField
+        val databaseSchemas = IntegrationTestSchemas(*listOf(DUMMY_BANK_A, DUMMY_BANK_B, DUMMY_NOTARY)
+                .map { it.toDatabaseSchemaName() }.toTypedArray())
+
         private val logger = contextLogger()
         val isolatedJAR = AttachmentLoadingTests::class.java.getResource("isolated.jar")!!
         val ISOLATED_CONTRACT_ID = "net.corda.finance.contracts.isolated.AnotherDummyContract"

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

@@ -27,20 +27,27 @@ import net.corda.node.services.transactions.minCorrectReplicas
 import net.corda.node.utilities.ServiceIdentityGenerator
 import net.corda.testing.IntegrationTest
 import net.corda.testing.chooseIdentity
+import net.corda.testing.*
 import net.corda.testing.contracts.DummyContract
-import net.corda.testing.dummyCommand
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.node.MockNetwork.MockNode
 import net.corda.testing.node.MockNodeParameters
 import net.corda.testing.startFlow
 import org.junit.After
 import org.junit.Before
+import org.junit.ClassRule
 import org.junit.Test
 import java.nio.file.Paths
 import kotlin.test.assertEquals
 import kotlin.test.assertTrue
 
 class BFTNotaryServiceTests : IntegrationTest() {
+    companion object {
+        @ClassRule @JvmField
+        val databaseSchemas = IntegrationTestSchemas("node_0", "node_1", "node_2", "node_3", "node_4", "node_5",
+                "node_6", "node_7", "node_8", "node_9")
+    }
+
     private lateinit var mockNet: MockNetwork
     private lateinit var notary: Party
     private lateinit var node: StartedNode<MockNode>

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

@@ -21,6 +21,7 @@ import net.corda.testing.driver.driver
 import net.corda.testing.node.ClusterSpec
 import net.corda.testing.node.NotarySpec
 import org.assertj.core.api.Assertions.assertThat
+import org.junit.ClassRule
 import org.junit.Test
 import rx.Observable
 import java.util.*
@@ -31,7 +32,11 @@ class DistributedServiceTests : IntegrationTest() {
     private lateinit var aliceProxy: CordaRPCOps
     private lateinit var raftNotaryIdentity: Party
     private lateinit var notaryStateMachines: Observable<Pair<Party, StateMachineUpdate>>
-
+    companion object {
+        @ClassRule @JvmField
+        val databaseSchemas = IntegrationTestSchemas(*DUMMY_NOTARY.toDatabaseSchemaNames("_0", "_1", "_2").toTypedArray(),
+                ALICE.toDatabaseSchemaName())
+    }
     private fun setup(testBlock: () -> Unit) {
         val testUser = User("test", "test", permissions = setOf(
                 startFlow<CashIssueFlow>(),

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

@@ -12,22 +12,24 @@ import net.corda.core.transactions.TransactionBuilder
 import net.corda.core.utilities.getOrThrow
 import net.corda.node.internal.StartedNode
 import net.corda.node.services.transactions.RaftValidatingNotaryService
-import net.corda.testing.DUMMY_BANK_A
-import net.corda.testing.IntegrationTest
-import net.corda.testing.chooseIdentity
+import net.corda.testing.*
 import net.corda.testing.contracts.DummyContract
 import net.corda.testing.driver.NodeHandle
 import net.corda.testing.driver.driver
-import net.corda.testing.dummyCommand
-import net.corda.testing.startFlow
 import net.corda.testing.node.ClusterSpec
 import net.corda.testing.node.NotarySpec
+import org.junit.ClassRule
 import org.junit.Test
 import java.util.*
 import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
 
 class RaftNotaryServiceTests : IntegrationTest() {
+    companion object {
+        @ClassRule @JvmField
+        val databaseSchemas = IntegrationTestSchemas( "RAFTNotaryService_0", "RAFTNotaryService_1", "RAFTNotaryService_2",
+                DUMMY_BANK_A.toDatabaseSchemaName())
+    }
     private val notaryName = CordaX500Name(RaftValidatingNotaryService.id, "RAFT Notary Service", "London", "GB")
 
     @Test

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

@@ -6,16 +6,18 @@ import net.corda.core.node.NodeInfo
 import net.corda.core.utilities.NetworkHostAndPort
 import net.corda.node.internal.Node
 import net.corda.node.internal.StartedNode
-import net.corda.testing.ALICE
-import net.corda.testing.BOB
-import net.corda.testing.DUMMY_REGULATOR
-import net.corda.testing.chooseIdentity
+import net.corda.testing.*
 import net.corda.testing.internal.NodeBasedTest
 import org.junit.Before
+import org.junit.ClassRule
 import org.junit.Test
 import kotlin.test.assertEquals
 
 class PersistentNetworkMapCacheTest : NodeBasedTest() {
+    companion object {
+        @ClassRule @JvmField
+        val databaseSchemas = IntegrationTestSchemas(*listOf(DUMMY_REGULATOR, ALICE, BOB).map { it.toDatabaseSchemaName() }.toTypedArray())
+    }
     private val partiesList = listOf(DUMMY_REGULATOR, ALICE, BOB)
     private val addressesMap = HashMap<CordaX500Name, NetworkHostAndPort>()
     private val infos = HashSet<NodeInfo>()

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

@@ -7,15 +7,18 @@ import net.corda.core.flows.InitiatingFlow
 import net.corda.core.identity.Party
 import net.corda.core.utilities.getOrThrow
 import net.corda.core.utilities.unwrap
-import net.corda.testing.ALICE
-import net.corda.testing.BOB
-import net.corda.testing.chooseIdentity
+import net.corda.testing.*
 import net.corda.testing.internal.NodeBasedTest
-import net.corda.testing.startFlow
 import org.assertj.core.api.Assertions.assertThat
+import org.junit.ClassRule
 import org.junit.Test
 
 class FlowVersioningTest : NodeBasedTest() {
+    companion object {
+        @ClassRule @JvmField
+        val databaseSchemas = IntegrationTestSchemas(ALICE.toDatabaseSchemaName(), BOB.toDatabaseSchemaName())
+    }
+
     @Test
     fun `getFlowContext returns the platform version for core flows`() {
         val alice = startNode(ALICE.name, platformVersion = 2)

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

@@ -13,8 +13,7 @@ import net.corda.testing.*
 import net.corda.testing.contracts.DummyContract
 import net.corda.testing.contracts.DummyState
 import net.corda.testing.driver.driver
-import net.corda.testing.dummyCommand
-import net.corda.testing.IntegrationTest
+import org.junit.ClassRule
 import org.junit.Test
 import kotlin.test.assertEquals
 
@@ -23,6 +22,11 @@ import kotlin.test.assertEquals
  * transaction size limit (which should only consider the hashes).
  */
 class LargeTransactionsTest : IntegrationTest() {
+    companion object {
+        @ClassRule @JvmField
+        val databaseSchemas = IntegrationTestSchemas(*listOf(ALICE, BOB, DUMMY_NOTARY).map { it.toDatabaseSchemaName() }.toTypedArray())
+    }
+
     @StartableByRPC
     @InitiatingFlow
     class SendLargeTransactionFlow(private val hash1: SecureHash,

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

@@ -0,0 +1,40 @@
+package net.corda.node.services.vault
+
+
+import net.corda.testing.*
+import org.junit.*
+
+class VaultQueryIntegrationTests : VaultQueryTests() {
+
+    private val adapter = object: IntegrationTest() {
+    }
+
+    @Before
+    override fun setUp() {
+        adapter.setUp()
+        super.setUp()
+    }
+
+    @After
+    override fun tearDown() {
+        adapter.tearDown()
+        super.tearDown()
+    }
+
+    companion object {
+        @ClassRule @JvmField
+        val databaseSchemas = IntegrationTestSchemas(MEGA_CORP.toDatabaseSchemaName())
+
+        @BeforeClass
+        @JvmStatic
+        fun globalSetUp() {
+            IntegrationTest.globalSetUp()
+        }
+
+        @AfterClass
+        @JvmStatic
+        fun globalTearDown() {
+            IntegrationTest.globalTearDown()
+        }
+    }
+}

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

@@ -31,8 +31,7 @@ import org.apache.activemq.artemis.api.core.ActiveMQNonExistentQueueException
 import org.apache.activemq.artemis.api.core.ActiveMQSecurityException
 import org.apache.activemq.artemis.api.core.SimpleString
 import org.assertj.core.api.Assertions.assertThatExceptionOfType
-import org.junit.After
-import org.junit.Before
+import org.junit.ClassRule
 import org.junit.Test
 import java.util.*
 import kotlin.test.assertEquals
@@ -42,13 +41,17 @@ import kotlin.test.assertEquals
  * the attacker to [alice].
  */
 abstract class MQSecurityTest : NodeBasedTest() {
+    companion object {
+        @ClassRule @JvmField
+        val databaseSchemas = IntegrationTestSchemas(ALICE.toDatabaseSchemaName(), BOB.toDatabaseSchemaName())
+    }
     val rpcUser = User("user1", "pass", permissions = emptySet())
     lateinit var alice: StartedNode<Node>
     lateinit var attacker: SimpleMQClient
     private val clients = ArrayList<SimpleMQClient>()
 
-    @Before
-    fun start() {
+    override fun setUp() {
+        super.setUp()
         alice = startNode(ALICE.name, rpcUsers = extraRPCUsers + rpcUser)
         attacker = createAttacker()
         startAttacker(attacker)
@@ -60,9 +63,10 @@ abstract class MQSecurityTest : NodeBasedTest() {
 
     abstract fun startAttacker(attacker: SimpleMQClient)
 
-    @After
-    fun stopClients() {
+    override fun tearDown() {
+        rpcConnections.forEach { it.forceClose() }
         clients.forEach { it.stop() }
+        super.tearDown()
     }
 
     @Test
@@ -145,11 +149,6 @@ abstract class MQSecurityTest : NodeBasedTest() {
         return CordaRPCClient(target).start(rpcUser.username, rpcUser.password).also { rpcConnections.add(it) }.proxy
     }
 
-    @After
-    fun closeRPCConnections() {
-        rpcConnections.forEach { it.forceClose() }
-    }
-
     fun loginToRPCAndGetClientQueue(): String {
         loginToRPC(alice.internals.configuration.rpcAddress!!, rpcUser)
         val clientQueueQuery = SimpleString("${RPCApi.RPC_CLIENT_QUEUE_NAME_PREFIX}.${rpcUser.username}.*")

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

@@ -16,15 +16,14 @@ import net.corda.node.internal.Node
 import net.corda.node.internal.StartedNode
 import net.corda.node.services.messaging.*
 import net.corda.node.services.transactions.RaftValidatingNotaryService
-import net.corda.testing.ALICE
-import net.corda.testing.IntegrationTest
-import net.corda.testing.chooseIdentity
+import net.corda.testing.*
 import net.corda.testing.driver.DriverDSLExposedInterface
 import net.corda.testing.driver.NodeHandle
 import net.corda.testing.driver.driver
 import net.corda.testing.node.ClusterSpec
 import net.corda.testing.node.NotarySpec
 import org.assertj.core.api.Assertions.assertThat
+import org.junit.ClassRule
 import org.junit.Test
 import java.util.*
 import java.util.concurrent.CountDownLatch
@@ -32,7 +31,10 @@ import java.util.concurrent.TimeUnit
 import java.util.concurrent.atomic.AtomicInteger
 
 class P2PMessagingTest : IntegrationTest() {
-    private companion object {
+     private companion object {
+        @ClassRule @JvmField
+        val databaseSchemas = IntegrationTestSchemas(ALICE.toDatabaseSchemaName(), "DistributedService_0", "DistributedService_1")
+
         val DISTRIBUTED_SERVICE_NAME = CordaX500Name(RaftValidatingNotaryService.id, "DistributedService", "London", "GB")
     }
 

node/src/integration-test/kotlin/net/corda/test/node/NodeStatePersistenceTests.kt

@@ -20,10 +20,10 @@ import net.corda.core.utilities.getOrThrow
 import net.corda.node.services.Permissions.Companion.invokeRpc
 import net.corda.node.services.Permissions.Companion.startFlow
 import net.corda.nodeapi.User
-import net.corda.testing.IntegrationTest
-import net.corda.testing.chooseIdentity
+import net.corda.testing.*
 import net.corda.testing.driver.driver
 import org.junit.Assume.assumeFalse
+import org.junit.ClassRule
 import org.junit.Test
 import java.lang.management.ManagementFactory
 import javax.persistence.Column
@@ -33,6 +33,12 @@ import kotlin.test.assertEquals
 import kotlin.test.assertNotNull
 
 class NodeStatePersistenceTests : IntegrationTest() {
+    companion object {
+        @ClassRule @JvmField
+        val databaseSchemas = IntegrationTestSchemas(*listOf(ALICE, BOB, DUMMY_BANK_A)
+                .map { it.toDatabaseSchemaNames("", "_10000","_10003","_10006") }.flatten().toTypedArray(),
+                DUMMY_NOTARY.toDatabaseSchemaName())
+    }
     @Test
     fun `persistent state survives node restart`() {
         // Temporary disable this test when executed on Windows. It is known to be sporadically failing.

node/src/test/kotlin/net/corda/node/services/vault/VaultQueryTests.kt

@@ -49,7 +49,7 @@ import java.time.ZoneOffset
 import java.time.temporal.ChronoUnit
 import java.util.*
 
-class VaultQueryTests {
+open class VaultQueryTests {
     @Rule
     @JvmField
     val testSerialization = SerializationEnvironmentRule()
@@ -77,7 +77,7 @@ class VaultQueryTests {
     private val CASH_NOTARY_IDENTITY: PartyAndCertificate get() = getTestPartyAndCertificate(CASH_NOTARY.nameOrNull(), CASH_NOTARY_KEY.public)
 
     @Before
-    fun setUp() {
+    open fun setUp() {
         // register additional identities
         val databaseAndServices = makeTestDatabaseAndMockServices(keys = listOf(MEGA_CORP_KEY, DUMMY_NOTARY_KEY),
                 cordappPackages = cordappPackages)
@@ -94,7 +94,7 @@ class VaultQueryTests {
     }
 
     @After
-    fun tearDown() {
+    open fun tearDown() {
         database.close()
     }
 
@@ -1651,7 +1651,7 @@ class VaultQueryTests {
     @Test
     fun `unconsumed linear heads for linearId between two timestamps for a given external id`() {
         val start = Instant.now()
-        val end = start.plus(1, ChronoUnit.SECONDS)
+        val end = start.plus(3, ChronoUnit.SECONDS)
 
         database.transaction {
             vaultFiller.fillWithSomeTestLinearStates(1, "TEST1")