Merge pull request #795 from corda/m4ksio-os-merge-30-04-2018

Merged https://github.com/corda/corda/pull/2994 and fixed conflicts

build.gradle

@@ -340,6 +340,12 @@ tasks.withType(Test) {
     reports.html.destination = file("${reporting.baseDir}/${name}")
 }
 
+task testReport(type: TestReport) {
+    destinationDir = file("$buildDir/reports/allTests")
+    // Include the results from the `test` task in all subprojects
+    reportOn subprojects*.test
+}
+
 bintrayConfig {
     // user = System.getenv('CORDA_BINTRAY_USER')
     // key = System.getenv('CORDA_BINTRAY_KEY')

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

@@ -18,6 +18,7 @@ import net.corda.testing.internal.IntegrationTestSchemas
 import net.corda.testing.internal.toDatabaseSchemaName
 import org.junit.*
 
+@Ignore // TODO - refactor VaultQuery integration tests with external junit resource
 class VaultQueryIntegrationTests : VaultQueryTests() {
 
     private val adapter = object: IntegrationTest() {

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

@@ -0,0 +1,126 @@
+/*
+ * R3 Proprietary and Confidential
+ *
+ * Copyright (c) 2018 R3 Limited.  All rights reserved.
+ *
+ * The intellectual and technical concepts contained herein are proprietary to R3 and its suppliers and are protected by trade secret law.
+ *
+ * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited.
+ */
+
+package net.corda.node.services.vault
+
+import net.corda.core.identity.CordaX500Name
+import net.corda.core.internal.packageName
+import net.corda.core.node.services.*
+import net.corda.core.node.services.vault.*
+import net.corda.core.node.services.vault.QueryCriteria.*
+import net.corda.finance.*
+import net.corda.finance.contracts.asset.Cash
+import net.corda.finance.sampleschemas.SampleCashSchemaV3
+import net.corda.finance.schemas.CashSchemaV1
+import net.corda.nodeapi.internal.persistence.CordaPersistence
+import net.corda.nodeapi.internal.persistence.DatabaseTransaction
+import net.corda.testing.core.*
+import net.corda.testing.internal.rigorousMock
+import net.corda.testing.internal.vault.VaultFiller
+import net.corda.testing.node.MockServices
+import net.corda.testing.node.MockServices.Companion.makeTestDatabaseAndMockServices
+import net.corda.testing.node.makeTestIdentityService
+import net.corda.testing.internal.vault.DummyLinearStateSchemaV1
+import org.assertj.core.api.Assertions.assertThatThrownBy
+import org.junit.*
+import org.junit.rules.ExpectedException
+
+class VaultQueryExceptionsTests {
+    private companion object {
+        val bankOfCorda = TestIdentity(BOC_NAME)
+        val cashNotary = TestIdentity(CordaX500Name("Cash Notary Service", "Zurich", "CH"), 21)
+        val dummyCashIssuer = TestIdentity(CordaX500Name("Snake Oil Issuer", "London", "GB"), 10)
+        val DUMMY_CASH_ISSUER = dummyCashIssuer.ref(1)
+        val dummyNotary = TestIdentity(DUMMY_NOTARY_NAME, 20)
+        val megaCorp = TestIdentity(CordaX500Name("MegaCorp", "London", "GB"))
+        val miniCorp = TestIdentity(CordaX500Name("MiniCorp", "London", "GB"))
+        val BOC_IDENTITY get() = bankOfCorda.identity
+        val BOC_KEY get() = bankOfCorda.keyPair
+        val CASH_NOTARY get() = cashNotary.party
+        val CASH_NOTARY_IDENTITY get() = cashNotary.identity
+        val DUMMY_NOTARY_KEY get() = dummyNotary.keyPair
+        val MEGA_CORP_IDENTITY get() = megaCorp.identity
+        val MEGA_CORP_KEY get() = megaCorp.keyPair
+        val MINI_CORP_IDENTITY get() = miniCorp.identity
+
+        private val cordappPackages = listOf(
+                "net.corda.testing.contracts",
+                "net.corda.finance.contracts",
+                CashSchemaV1::class.packageName,
+                DummyLinearStateSchemaV1::class.packageName) - SampleCashSchemaV3::class.packageName
+
+        private lateinit var services: MockServices
+        private lateinit var vaultFiller: VaultFiller
+        private lateinit var vaultFillerCashNotary: VaultFiller
+        private lateinit var notaryServices: MockServices
+        private val vaultService: VaultService get() = services.vaultService
+        private lateinit var identitySvc: IdentityService
+        private lateinit var database: CordaPersistence
+
+
+        @BeforeClass @JvmStatic
+        fun setUpClass() {
+            // register additional identities
+            val databaseAndServices = makeTestDatabaseAndMockServices(
+                    cordappPackages,
+                    makeTestIdentityService(Companion.MEGA_CORP_IDENTITY, Companion.MINI_CORP_IDENTITY, Companion.dummyCashIssuer.identity, Companion.dummyNotary.identity),
+                    Companion.megaCorp,
+                    moreKeys = Companion.DUMMY_NOTARY_KEY)
+            database = databaseAndServices.first
+            services = databaseAndServices.second
+            vaultFiller = VaultFiller(services, Companion.dummyNotary)
+            vaultFillerCashNotary = VaultFiller(services, Companion.dummyNotary, Companion.CASH_NOTARY)
+            notaryServices = MockServices(cordappPackages, Companion.dummyNotary, rigorousMock(), Companion.dummyCashIssuer.keyPair, Companion.BOC_KEY, Companion.MEGA_CORP_KEY)
+            identitySvc = services.identityService
+            // Register all of the identities we're going to use
+            (notaryServices.myInfo.legalIdentitiesAndCerts + Companion.BOC_IDENTITY + Companion.CASH_NOTARY_IDENTITY + Companion.MINI_CORP_IDENTITY + Companion.MEGA_CORP_IDENTITY).forEach { identity ->
+                services.identityService.verifyAndRegisterIdentity(identity)
+            }
+        }
+    }
+
+    private lateinit var transaction: DatabaseTransaction
+
+
+    @Rule
+    @JvmField
+    val testSerialization = SerializationEnvironmentRule()
+
+    @Rule
+    @JvmField
+    val expectedEx: ExpectedException = ExpectedException.none()
+
+    @Before
+    fun setUp() {
+        transaction = database.newTransaction()
+    }
+
+    @After
+    fun tearDown() {
+        transaction.rollback()
+        transaction.close()
+    }
+
+    @Test
+    fun `query attempting to use unregistered schema`() {
+        database.transaction {
+            vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 1, DUMMY_CASH_ISSUER)
+            vaultFiller.fillWithSomeTestCash(100.POUNDS, notaryServices, 1, DUMMY_CASH_ISSUER)
+            vaultFiller.fillWithSomeTestCash(100.SWISS_FRANCS, notaryServices, 1, DUMMY_CASH_ISSUER)
+            // CashSchemaV3 NOT registered with NodeSchemaService
+            val logicalExpression = builder { SampleCashSchemaV3.PersistentCashState::currency.equal(GBP.currencyCode) }
+            val criteria = VaultCustomQueryCriteria(logicalExpression)
+
+            assertThatThrownBy {
+                vaultService.queryBy<Cash.State>(criteria)
+            }.isInstanceOf(VaultQueryException::class.java).hasMessageContaining("Please register the entity")
+        }
+    }
+}

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

@@ -34,6 +34,7 @@ import net.corda.finance.schemas.CommercialPaperSchemaV1
 import net.corda.node.internal.configureDatabase
 import net.corda.nodeapi.internal.persistence.CordaPersistence
 import net.corda.nodeapi.internal.persistence.DatabaseConfig
+import net.corda.nodeapi.internal.persistence.DatabaseTransaction
 import net.corda.testing.core.*
 import net.corda.testing.internal.TEST_TX_TIME
 import net.corda.testing.internal.rigorousMock
@@ -42,7 +43,6 @@ import net.corda.testing.node.MockServices
 import net.corda.testing.node.MockServices.Companion.makeTestDatabaseAndMockServices
 import net.corda.testing.node.makeTestIdentityService
 import org.assertj.core.api.Assertions.assertThat
-import org.assertj.core.api.Assertions.assertThatThrownBy
 import org.junit.*
 import org.junit.rules.ExpectedException
 import java.lang.Thread.sleep
@@ -88,7 +88,49 @@ open class VaultQueryTests {
         val MEGA_CORP get() = megaCorp.party
         val MINI_CORP_IDENTITY get() = miniCorp.identity
         val MINI_CORP get() = miniCorp.party
+
+        private val cordappPackages = listOf(
+                "net.corda.testing.contracts",
+                "net.corda.finance.contracts",
+                CashSchemaV1::class.packageName,
+                DummyLinearStateSchemaV1::class.packageName,
+                SampleCashSchemaV3::class.packageName)
+        private lateinit var services: MockServices
+        private lateinit var vaultFiller: VaultFiller
+        private lateinit var vaultFillerCashNotary: VaultFiller
+        private lateinit var notaryServices: MockServices
+        private val vaultService: VaultService get() = services.vaultService
+        private lateinit var identitySvc: IdentityService
+        private lateinit var database: CordaPersistence
+
+        @BeforeClass @JvmStatic
+        fun setUpClass() {
+            // register additional identities
+            val databaseAndServices = makeTestDatabaseAndMockServices(
+                    cordappPackages,
+                    makeTestIdentityService(Companion.MEGA_CORP_IDENTITY, Companion.MINI_CORP_IDENTITY, Companion.dummyCashIssuer.identity, Companion.dummyNotary.identity),
+                    Companion.megaCorp,
+                    moreKeys = Companion.DUMMY_NOTARY_KEY)
+            database = databaseAndServices.first
+            services = databaseAndServices.second
+            vaultFiller = VaultFiller(services, Companion.dummyNotary)
+            vaultFillerCashNotary = VaultFiller(services, Companion.dummyNotary, Companion.CASH_NOTARY)
+            notaryServices = MockServices(cordappPackages, Companion.dummyNotary, rigorousMock(), Companion.dummyCashIssuer.keyPair, Companion.BOC_KEY, Companion.MEGA_CORP_KEY)
+            identitySvc = services.identityService
+            // Register all of the identities we're going to use
+            (notaryServices.myInfo.legalIdentitiesAndCerts + Companion.BOC_IDENTITY + Companion.CASH_NOTARY_IDENTITY + Companion.MINI_CORP_IDENTITY + Companion.MEGA_CORP_IDENTITY).forEach { identity ->
+                services.identityService.verifyAndRegisterIdentity(identity)
+            }
+        }
+
+        @AfterClass @JvmStatic
+        fun afterClass() {
+            database.close()
+        }
     }
+
+    private lateinit var transaction: DatabaseTransaction
+
     @Rule
     @JvmField
     val testSerialization = SerializationEnvironmentRule()
@@ -97,42 +139,15 @@ open class VaultQueryTests {
     @JvmField
     val expectedEx: ExpectedException = ExpectedException.none()
 
-    private val cordappPackages = mutableListOf(
-            "net.corda.testing.contracts",
-            "net.corda.finance.contracts",
-            CashSchemaV1::class.packageName,
-            DummyLinearStateSchemaV1::class.packageName,
-            DummyDealStateSchemaV1::class.packageName)
-    private lateinit var services: MockServices
-    private lateinit var vaultFiller: VaultFiller
-    private lateinit var vaultFillerCashNotary: VaultFiller
-    private lateinit var notaryServices: MockServices
-    private val vaultService: VaultService get() = services.vaultService
-    private lateinit var identitySvc: IdentityService
-    private lateinit var database: CordaPersistence
     @Before
     open fun setUp() {
-        // register additional identities
-        val databaseAndServices = makeTestDatabaseAndMockServices(
-                cordappPackages,
-                makeTestIdentityService(MEGA_CORP_IDENTITY, MINI_CORP_IDENTITY, dummyCashIssuer.identity, dummyNotary.identity),
-                megaCorp,
-                moreKeys = DUMMY_NOTARY_KEY)
-        database = databaseAndServices.first
-        services = databaseAndServices.second
-        vaultFiller = VaultFiller(services, dummyNotary)
-        vaultFillerCashNotary = VaultFiller(services, dummyNotary, CASH_NOTARY)
-        notaryServices = MockServices(cordappPackages, dummyNotary, rigorousMock(), dummyCashIssuer.keyPair, BOC_KEY, MEGA_CORP_KEY)
-        identitySvc = services.identityService
-        // Register all of the identities we're going to use
-        (notaryServices.myInfo.legalIdentitiesAndCerts + BOC_IDENTITY + CASH_NOTARY_IDENTITY + MINI_CORP_IDENTITY + MEGA_CORP_IDENTITY).forEach { identity ->
-            services.identityService.verifyAndRegisterIdentity(identity)
-        }
+        transaction = database.newTransaction()
     }
 
     @After
     open fun tearDown() {
-        database.close()
+        transaction.rollback()
+        transaction.close()
     }
 
     /**
@@ -277,8 +292,8 @@ open class VaultQueryTests {
             val issuedStates = vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 10, DUMMY_CASH_ISSUER)
             val issuedStateRefs = issuedStates.states.map { it.ref }.toList()
             stateRefs.addAll(issuedStateRefs)
-        }
-        database.transaction {
+            this.session.flush()
+
             val spentStates = consumeCash(25.DOLLARS)
             val consumedStateRefs = spentStates.consumed.map { it.ref }.toList()
             val producedStateRefs = spentStates.produced.map { it.ref }.toList()
@@ -306,8 +321,8 @@ open class VaultQueryTests {
         val consumed = mutableSetOf<SecureHash>()
         database.transaction {
             vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 10, DUMMY_CASH_ISSUER)
-        }
-        database.transaction {
+            this.session.flush()
+
             consumeCash(10.DOLLARS).consumed.forEach { consumed += it.ref.txhash }
             consumeCash(10.DOLLARS).consumed.forEach { consumed += it.ref.txhash }
             val sortAttributeTxnId = SortAttribute.Standard(Sort.CommonStateAttribute.STATE_REF_TXN_ID)
@@ -405,9 +420,12 @@ open class VaultQueryTests {
             val linearStates = vaultFiller.fillWithSomeTestLinearStates(2, "TEST") // create 2 results with same UID
             vaultFiller.fillWithSomeTestLinearStates(8)
             val dealStates = vaultFiller.fillWithSomeTestDeals(listOf("123", "456", "789"))
+
             vaultFiller.consumeLinearStates(linearStates.states.toList())
             vaultFiller.consumeDeals(dealStates.states.filter { it.state.data.linearId.externalId == "456" })
+
             consumeCash(50.DOLLARS) // generates a new change state!
+
             val criteria = VaultQueryCriteria(status = Vault.StateStatus.ALL)
             val results = vaultService.queryBy<ContractState>(criteria)
             assertThat(results.states).hasSize(17)
@@ -986,8 +1004,7 @@ open class VaultQueryTests {
             vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 3, DUMMY_CASH_ISSUER)
             vaultFiller.fillWithSomeTestLinearStates(10)
             vaultFiller.fillWithSomeTestDeals(listOf("123", "456", "789"))
-        }
-        database.transaction {
+            this.session.flush()
             consumeCash(100.DOLLARS)
             val asOfDateTime = TODAY
             val consumedAfterExpression = TimeCondition(
@@ -1105,8 +1122,8 @@ open class VaultQueryTests {
     // sorting
     @Test
     fun `sorting - all states sorted by contract type, state status, consumed time`() {
-        setUpDb(database)
         database.transaction {
+            setUpDb(database)
             val sortCol1 = Sort.SortColumn(SortAttribute.Standard(Sort.VaultStateAttribute.CONTRACT_STATE_TYPE), Sort.Direction.DESC)
             val sortCol2 = Sort.SortColumn(SortAttribute.Standard(Sort.VaultStateAttribute.STATE_STATUS), Sort.Direction.ASC)
             val sortCol3 = Sort.SortColumn(SortAttribute.Standard(Sort.VaultStateAttribute.CONSUMED_TIME), Sort.Direction.DESC)
@@ -1116,10 +1133,6 @@ open class VaultQueryTests {
             val states = result.states
             val metadata = result.statesMetadata
 
-            for (i in 0 until states.size) {
-                println("${states[i].ref} : ${metadata[i].contractStateClassName}, ${metadata[i].status}, ${metadata[i].consumedTime}")
-            }
-
             assertThat(states).hasSize(20)
             assertThat(metadata.first().contractStateClassName).isEqualTo("$DUMMY_LINEAR_CONTRACT_PROGRAM_ID\$State")
             assertThat(metadata.first().status).isEqualTo(Vault.StateStatus.UNCONSUMED) // 0 = UNCONSUMED
@@ -1134,6 +1147,7 @@ open class VaultQueryTests {
             vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 3, DUMMY_CASH_ISSUER)
             vaultFiller.fillWithSomeTestCommodity(Amount(100, Commodity.getInstance("FCOJ")!!), notaryServices, DUMMY_OBLIGATION_ISSUER.ref(1))
             vaultFiller.fillWithSomeTestLinearStates(10)
+
             val results = vaultService.queryBy<FungibleAsset<*>>()
             assertThat(results.states).hasSize(4)
         }
@@ -1143,8 +1157,8 @@ open class VaultQueryTests {
     fun `consumed fungible assets`() {
         database.transaction {
             vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 3, DUMMY_CASH_ISSUER)
-        }
-        database.transaction {
+            this.session.flush()
+
             consumeCash(50.DOLLARS)
             vaultFiller.fillWithSomeTestCommodity(Amount(100, Commodity.getInstance("FCOJ")!!), notaryServices, DUMMY_OBLIGATION_ISSUER.ref(1))
             vaultFiller.fillWithSomeTestLinearStates(10)
@@ -1168,8 +1182,8 @@ open class VaultQueryTests {
     fun `unconsumed cash fungible assets after spending`() {
         database.transaction {
             vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 3, DUMMY_CASH_ISSUER)
-        }
-        database.transaction {
+            this.session.flush()
+
             consumeCash(50.DOLLARS)
             // should now have x2 CONSUMED + x2 UNCONSUMED (one spent + one change)
             val results = vaultService.queryBy<Cash.State>(FungibleAssetQueryCriteria())
@@ -1182,8 +1196,8 @@ open class VaultQueryTests {
     fun `consumed cash fungible assets`() {
         database.transaction {
             vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 3, DUMMY_CASH_ISSUER)
-        }
-        database.transaction {
+            this.session.flush()
+
             consumeCash(50.DOLLARS)
             val linearStates = vaultFiller.fillWithSomeTestLinearStates(10)
             vaultFiller.consumeLinearStates(linearStates.states.toList())
@@ -1310,7 +1324,6 @@ open class VaultQueryTests {
             val sorting = Sort(setOf(Sort.SortColumn(SortAttribute.Standard(Sort.LinearStateAttribute.EXTERNAL_ID), Sort.Direction.DESC)))
 
             val results = vaultService.queryBy<DummyLinearContract.State>((vaultCriteria), sorting = sorting)
-            results.states.forEach { println(it.state.data.linearString) }
             assertThat(results.states).hasSize(6)
         }
     }
@@ -1397,8 +1410,6 @@ open class VaultQueryTests {
             vaultFiller.fillWithSomeTestLinearStates(2, "TEST")
             vaultFiller.fillWithSomeTestDeals(listOf("456"))
             vaultFiller.fillWithSomeTestDeals(listOf("123", "789"))
-            val all = vaultService.queryBy<DealState>()
-            all.states.forEach { println(it.state) }
 
             val criteria = LinearStateQueryCriteria(externalId = listOf("456"))
             val results = vaultService.queryBy<DealState>(criteria)
@@ -1459,8 +1470,8 @@ open class VaultQueryTests {
             vaultFiller.fillWithSomeTestCash(100.POUNDS, gbpCashIssuerServices, 1, gbpCashIssuer.party.ref(1))
             vaultFiller.fillWithSomeTestCash(100.DOLLARS, usdCashIssuerServices, 1, usdCashIssuer.party.ref(1))
             vaultFiller.fillWithSomeTestCash(100.SWISS_FRANCS, chfCashIssuerServices, 1, chfCashIssuer.party.ref(1))
-        }
-        database.transaction {
+            this.session.flush()
+
             val criteria = FungibleAssetQueryCriteria(issuer = listOf(gbpCashIssuer.party, usdCashIssuer.party))
             val results = vaultService.queryBy<FungibleAsset<*>>(criteria)
             assertThat(results.states).hasSize(2)
@@ -1472,8 +1483,7 @@ open class VaultQueryTests {
         database.transaction {
             vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 1, BOC.ref(1))
             vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 1, MEGA_CORP.ref(0), MINI_CORP)
-        }
-        database.transaction {
+
             val criteria = FungibleAssetQueryCriteria(owner = listOf(MEGA_CORP))
             val results = vaultService.queryBy<FungibleAsset<*>>(criteria)
             assertThat(results.states).hasSize(1)   // can only be 1 owner of a node (MEGA_CORP in this MockServices setup)
@@ -1486,8 +1496,7 @@ open class VaultQueryTests {
             vaultFillerCashNotary.fillWithSomeTestCash(100.DOLLARS, notaryServices, 1, DUMMY_CASH_ISSUER)
             vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 1, MEGA_CORP.ref(0), MEGA_CORP)
             vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 1, BOC.ref(0), MINI_CORP)  // irrelevant to this vault
-        }
-        database.transaction {
+
             // DOCSTART VaultQueryExample5.2
             val criteria = FungibleAssetQueryCriteria(owner = listOf(MEGA_CORP, BOC))
             val results = vaultService.queryBy<ContractState>(criteria)
@@ -1687,25 +1696,6 @@ open class VaultQueryTests {
         }
     }
 
-    @Test
-    fun `query attempting to use unregistered schema`() {
-        tearDown()
-        cordappPackages -= SampleCashSchemaV3::class.packageName
-        setUp()
-        database.transaction {
-            vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 1, DUMMY_CASH_ISSUER)
-            vaultFiller.fillWithSomeTestCash(100.POUNDS, notaryServices, 1, DUMMY_CASH_ISSUER)
-            vaultFiller.fillWithSomeTestCash(100.SWISS_FRANCS, notaryServices, 1, DUMMY_CASH_ISSUER)
-            // CashSchemaV3 NOT registered with NodeSchemaService
-            val logicalExpression = builder { SampleCashSchemaV3.PersistentCashState::currency.equal(GBP.currencyCode) }
-            val criteria = VaultCustomQueryCriteria(logicalExpression)
-
-            assertThatThrownBy {
-                vaultService.queryBy<Cash.State>(criteria)
-            }.isInstanceOf(VaultQueryException::class.java).hasMessageContaining("Please register the entity")
-        }
-    }
-
     /** Chaining together different Query Criteria tests**/
 
     // specifying Query on Cash contract state attributes
@@ -1920,28 +1910,28 @@ open class VaultQueryTests {
 
     @Test
     fun trackCashStates_unconsumed() {
-        val updates =
-                database.transaction {
-                    // DOCSTART VaultQueryExample15
+        val updates = database.transaction {
+            val updates =
+            // DOCSTART VaultQueryExample15
                     vaultService.trackBy<Cash.State>().updates     // UNCONSUMED default
-                    // DOCEND VaultQueryExample15
-                }
-        val (linearStates, dealStates) =
-                database.transaction {
-                    vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 5, DUMMY_CASH_ISSUER)
-                    val linearStates = vaultFiller.fillWithSomeTestLinearStates(10).states
-                    val dealStates = vaultFiller.fillWithSomeTestDeals(listOf("123", "456", "789")).states
-                    // add more cash
-                    vaultFiller.fillWithSomeTestCash(100.POUNDS, notaryServices, 1, DUMMY_CASH_ISSUER)
-                    // add another deal
-                    vaultFiller.fillWithSomeTestDeals(listOf("SAMPLE DEAL"))
-                    Pair(linearStates, dealStates)
-                }
-        database.transaction {
+            // DOCEND VaultQueryExample15
+
+            vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 5, DUMMY_CASH_ISSUER)
+            val linearStates = vaultFiller.fillWithSomeTestLinearStates(10).states
+            val dealStates = vaultFiller.fillWithSomeTestDeals(listOf("123", "456", "789")).states
+            // add more cash
+            vaultFiller.fillWithSomeTestCash(100.POUNDS, notaryServices, 1, DUMMY_CASH_ISSUER)
+            // add another deal
+            vaultFiller.fillWithSomeTestDeals(listOf("SAMPLE DEAL"))
+            this.session.flush()
+
             // consume stuff
             consumeCash(100.DOLLARS)
             vaultFiller.consumeDeals(dealStates.toList())
             vaultFiller.consumeLinearStates(linearStates.toList())
+
+            close() // transaction needs to be closed to trigger events
+            updates
         }
 
         updates.expectEvents {
@@ -1962,31 +1952,29 @@ open class VaultQueryTests {
 
     @Test
     fun trackCashStates_consumed() {
-        val updates =
-                database.transaction {
-                    val criteria = VaultQueryCriteria(status = Vault.StateStatus.CONSUMED)
-                    vaultService.trackBy<Cash.State>(criteria).updates
-                }
-        val (linearStates, dealStates) =
-                database.transaction {
-                    vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 5, DUMMY_CASH_ISSUER)
-                    val linearStates = vaultFiller.fillWithSomeTestLinearStates(10).states
-                    val dealStates = vaultFiller.fillWithSomeTestDeals(listOf("123", "456", "789")).states
-                    // add more cash
-                    vaultFiller.fillWithSomeTestCash(100.POUNDS, notaryServices, 1, DUMMY_CASH_ISSUER)
-                    // add another deal
-                    vaultFiller.fillWithSomeTestDeals(listOf("SAMPLE DEAL"))
-                    Pair(linearStates, dealStates)
-                }
-        database.transaction {
-            // consume stuff
+
+        val updates = database.transaction {
+            val criteria = VaultQueryCriteria(status = Vault.StateStatus.CONSUMED)
+            val updates = vaultService.trackBy<Cash.State>(criteria).updates
+
+            vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 5, DUMMY_CASH_ISSUER)
+            val linearStates = vaultFiller.fillWithSomeTestLinearStates(10).states
+            val dealStates = vaultFiller.fillWithSomeTestDeals(listOf("123", "456", "789")).states
+            // add more cash
+            vaultFiller.fillWithSomeTestCash(100.POUNDS, notaryServices, 1, DUMMY_CASH_ISSUER)
+            // add another deal
+            vaultFiller.fillWithSomeTestDeals(listOf("SAMPLE DEAL"))
+            this.session.flush()
+
             consumeCash(100.POUNDS)
-        }
-        database.transaction {
+
             // consume more stuff
             consumeCash(100.DOLLARS)
             vaultFiller.consumeDeals(dealStates.toList())
             vaultFiller.consumeLinearStates(linearStates.toList())
+
+            close() // transaction needs to be closed to trigger events
+            updates
         }
 
         updates.expectEvents {
@@ -2007,31 +1995,30 @@ open class VaultQueryTests {
 
     @Test
     fun trackCashStates_all() {
-        val updates =
-                database.transaction {
-                    val criteria = VaultQueryCriteria(status = Vault.StateStatus.ALL)
-                    vaultService.trackBy<Cash.State>(criteria).updates
-                }
-        val (linearStates, dealStates) =
-                database.transaction {
-                    vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 5, DUMMY_CASH_ISSUER)
-                    val linearStates = vaultFiller.fillWithSomeTestLinearStates(10).states
-                    val dealStates = vaultFiller.fillWithSomeTestDeals(listOf("123", "456", "789")).states
-                    // add more cash
-                    vaultFiller.fillWithSomeTestCash(100.POUNDS, notaryServices, 1, DUMMY_CASH_ISSUER)
-                    // add another deal
-                    vaultFiller.fillWithSomeTestDeals(listOf("SAMPLE DEAL"))
-                    Pair(linearStates, dealStates)
-                }
-        database.transaction {
-            // consume stuff
+        val updates = database.transaction {
+            val updates =
+                    database.transaction {
+                        val criteria = VaultQueryCriteria(status = Vault.StateStatus.ALL)
+                        vaultService.trackBy<Cash.State>(criteria).updates
+                    }
+            vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 5, DUMMY_CASH_ISSUER)
+            val linearStates = vaultFiller.fillWithSomeTestLinearStates(10).states
+            val dealStates = vaultFiller.fillWithSomeTestDeals(listOf("123", "456", "789")).states
+            // add more cash
+            vaultFiller.fillWithSomeTestCash(100.POUNDS, notaryServices, 1, DUMMY_CASH_ISSUER)
+            // add another deal
+            vaultFiller.fillWithSomeTestDeals(listOf("SAMPLE DEAL"))
+            this.session.flush()
+
+//             consume stuff
             consumeCash(99.POUNDS)
-        }
-        database.transaction {
-            // consume more stuff
+
             consumeCash(100.DOLLARS)
             vaultFiller.consumeDeals(dealStates.toList())
             vaultFiller.consumeLinearStates(linearStates.toList())
+
+            close() // transaction needs to be closed to trigger events
+            updates
         }
 
         updates.expectEvents {
@@ -2062,30 +2049,29 @@ open class VaultQueryTests {
 
     @Test
     fun trackLinearStates() {
-        val updates =
-                database.transaction {
-                    // DOCSTART VaultQueryExample16
-                    val (snapshot, updates) = vaultService.trackBy<LinearState>()
-                    // DOCEND VaultQueryExample16
-                    assertThat(snapshot.states).hasSize(0)
-                    updates
-                }
-        val (linearStates, dealStates) =
-                database.transaction {
-                    vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 3, DUMMY_CASH_ISSUER)
-                    val linearStates = vaultFiller.fillWithSomeTestLinearStates(10).states
-                    val dealStates = vaultFiller.fillWithSomeTestDeals(listOf("123", "456", "789")).states
-                    // add more cash
-                    vaultFiller.fillWithSomeTestCash(100.POUNDS, notaryServices, 1, DUMMY_CASH_ISSUER)
-                    // add another deal
-                    vaultFiller.fillWithSomeTestDeals(listOf("SAMPLE DEAL"))
-                    Pair(linearStates, dealStates)
-                }
-        database.transaction {
+
+        val updates = database.transaction {
+            // DOCSTART VaultQueryExample16
+            val (snapshot, updates) = vaultService.trackBy<LinearState>()
+            // DOCEND VaultQueryExample16
+            assertThat(snapshot.states).hasSize(0)
+
+            vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 3, DUMMY_CASH_ISSUER)
+            val linearStates = vaultFiller.fillWithSomeTestLinearStates(10).states
+            val dealStates = vaultFiller.fillWithSomeTestDeals(listOf("123", "456", "789")).states
+            // add more cash
+            vaultFiller.fillWithSomeTestCash(100.POUNDS, notaryServices, 1, DUMMY_CASH_ISSUER)
+            // add another deal
+            vaultFiller.fillWithSomeTestDeals(listOf("SAMPLE DEAL"))
+            this.session.flush()
+
             // consume stuff
             consumeCash(100.DOLLARS)
             vaultFiller.consumeDeals(dealStates.toList())
             vaultFiller.consumeLinearStates(linearStates.toList())
+
+            close() // transaction needs to be closed to trigger events
+            updates
         }
 
         updates.expectEvents {
@@ -2111,30 +2097,30 @@ open class VaultQueryTests {
 
     @Test
     fun trackDealStates() {
-        val updates =
-                database.transaction {
-                    // DOCSTART VaultQueryExample17
-                    val (snapshot, updates) = vaultService.trackBy<DealState>()
-                    // DOCEND VaultQueryExample17
-                    assertThat(snapshot.states).hasSize(0)
-                    updates
-                }
-        val (linearStates, dealStates) =
-                database.transaction {
-                    vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 3, DUMMY_CASH_ISSUER)
-                    val linearStates = vaultFiller.fillWithSomeTestLinearStates(10).states
-                    val dealStates = vaultFiller.fillWithSomeTestDeals(listOf("123", "456", "789")).states
-                    // add more cash
-                    vaultFiller.fillWithSomeTestCash(100.POUNDS, notaryServices, 1, DUMMY_CASH_ISSUER)
-                    // add another deal
-                    vaultFiller.fillWithSomeTestDeals(listOf("SAMPLE DEAL"))
-                    Pair(linearStates, dealStates)
-                }
-        database.transaction {
+
+        val updates = database.transaction {
+
+            // DOCSTART VaultQueryExample17
+            val (snapshot, updates) = vaultService.trackBy<DealState>()
+            // DOCEND VaultQueryExample17
+            assertThat(snapshot.states).hasSize(0)
+
+            vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 3, DUMMY_CASH_ISSUER)
+            val linearStates = vaultFiller.fillWithSomeTestLinearStates(10).states
+            val dealStates = vaultFiller.fillWithSomeTestDeals(listOf("123", "456", "789")).states
+            // add more cash
+            vaultFiller.fillWithSomeTestCash(100.POUNDS, notaryServices, 1, DUMMY_CASH_ISSUER)
+            // add another deal
+            vaultFiller.fillWithSomeTestDeals(listOf("SAMPLE DEAL"))
+            this.session.flush()
+
             // consume stuff
             consumeCash(100.DOLLARS)
             vaultFiller.consumeDeals(dealStates.toList())
             vaultFiller.consumeLinearStates(linearStates.toList())
+
+            close()
+            updates
         }
 
         updates.expectEvents {
@@ -2157,8 +2143,8 @@ open class VaultQueryTests {
     fun `unconsumedCashStatesForSpending_single_issuer_reference`() {
         database.transaction {
             vaultFiller.fillWithSomeTestCash(1000.DOLLARS, notaryServices, 1, DUMMY_CASH_ISSUER)
-        }
-        database.transaction {
+            this.session.flush()
+
             val builder = TransactionBuilder()
             val issuer = DUMMY_CASH_ISSUER
             val exitStates = AbstractCashSelection
@@ -2175,8 +2161,7 @@ open class VaultQueryTests {
     fun `unconsumedCashStatesForSpending_single_issuer_reference_not_matching`() {
         database.transaction {
             vaultFiller.fillWithSomeTestCash(1000.DOLLARS, notaryServices, 1, DUMMY_CASH_ISSUER)
-        }
-        database.transaction {
+
             val builder = TransactionBuilder()
             val issuer = DUMMY_CASH_ISSUER
             val exitStates = AbstractCashSelection

testing/node-driver/src/main/kotlin/net/corda/testing/node/MockServices.kt

@@ -117,7 +117,7 @@ open class MockServices private constructor(
                                             networkParameters: NetworkParameters = testNetworkParameters(),
                                             vararg moreKeys: KeyPair): Pair<CordaPersistence, MockServices> {
             val cordappLoader = CordappLoader.createWithTestPackages(cordappPackages)
-            val dataSourceProps = makeTestDataSourceProperties(initialIdentity.name.organisation)
+            val dataSourceProps = makeTestDataSourceProperties(initialIdentity.name.organisation, SecureHash.randomSHA256().toString())
             val schemaService = NodeSchemaService(cordappLoader.cordappSchemas)
             val database = configureDatabase(dataSourceProps, makeTestDatabaseProperties(initialIdentity.name.organisation), identityService, schemaService)
             val mockService = database.transaction {