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

Merged https://github.com/corda/corda/pull/2994 and fixed conflicts
2025-02-20 17:33:15 +00:00 · 2018-05-01 16:00:42 +01:00 · 2018-05-01 16:00:42 +01:00 · 8eb976d035
commit 8eb976d035
parent 5edb414a07 29615f512e
5 changed files with 298 additions and 180 deletions
--- a/build.gradle
+++ b/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')
--- a/node/src/integration-test/kotlin/net/corda/node/services/vault/VaultQueryIntegrationTests.kt
+++ b/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() {
--- a/node/src/test/kotlin/net/corda/node/services/vault/VaultQueryExceptionsTests.kt
+++ b/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")
+        }
+    }
+}
--- a/node/src/test/kotlin/net/corda/node/services/vault/VaultQueryTests.kt
+++ b/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
@ -2194,4 +2179,4 @@ open class VaultQueryTests {
     *  3) Template / Tutorial CorDapp service query extension executing Named Queries via JPA
     *  4) Advanced pagination queries using Spring Data (and/or Hibernate/JPQL)
     */
-}
+}
--- a/testing/node-driver/src/main/kotlin/net/corda/testing/node/MockServices.kt
+++ b/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 {