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

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

Browse Source 
Merged https://github.com/corda/corda/pull/2994 and fixed conflicts
This commit is contained in:
Maksymilian Pawlak 2018-05-01 16:00:42 +01:00 committed by GitHub
commit 8eb976d035
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 298 additions and 180 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
build.gradle
View File

@ -340,6 +340,12 @@ tasks.withType(Test) {
reports.html.destination = file("${reporting.baseDir}/${name}") 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 { bintrayConfig {
// user = System.getenv('CORDA_BINTRAY_USER') // user = System.getenv('CORDA_BINTRAY_USER')
// key = System.getenv('CORDA_BINTRAY_KEY') // key = System.getenv('CORDA_BINTRAY_KEY')

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

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

126
node/src/test/kotlin/net/corda/node/services/vault/VaultQueryExceptionsTests.kt Normal file
View File

@ -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")
}
}
}

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

@ -34,6 +34,7 @@ import net.corda.finance.schemas.CommercialPaperSchemaV1
import net.corda.node.internal.configureDatabase import net.corda.node.internal.configureDatabase
import net.corda.nodeapi.internal.persistence.CordaPersistence import net.corda.nodeapi.internal.persistence.CordaPersistence
import net.corda.nodeapi.internal.persistence.DatabaseConfig import net.corda.nodeapi.internal.persistence.DatabaseConfig
import net.corda.nodeapi.internal.persistence.DatabaseTransaction
import net.corda.testing.core.* import net.corda.testing.core.*
import net.corda.testing.internal.TEST_TX_TIME import net.corda.testing.internal.TEST_TX_TIME
import net.corda.testing.internal.rigorousMock 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.MockServices.Companion.makeTestDatabaseAndMockServices
import net.corda.testing.node.makeTestIdentityService import net.corda.testing.node.makeTestIdentityService
import org.assertj.core.api.Assertions.assertThat import org.assertj.core.api.Assertions.assertThat
import org.assertj.core.api.Assertions.assertThatThrownBy
import org.junit.* import org.junit.*
import org.junit.rules.ExpectedException import org.junit.rules.ExpectedException
import java.lang.Thread.sleep import java.lang.Thread.sleep
@ -88,7 +88,49 @@ open class VaultQueryTests {
val MEGA_CORP get() = megaCorp.party val MEGA_CORP get() = megaCorp.party
val MINI_CORP_IDENTITY get() = miniCorp.identity val MINI_CORP_IDENTITY get() = miniCorp.identity
val MINI_CORP get() = miniCorp.party 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 @Rule
@JvmField @JvmField
val testSerialization = SerializationEnvironmentRule() val testSerialization = SerializationEnvironmentRule()
@ -97,42 +139,15 @@ open class VaultQueryTests {
@JvmField @JvmField
val expectedEx: ExpectedException = ExpectedException.none() 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 @Before
open fun setUp() { open fun setUp() {
// register additional identities transaction = database.newTransaction()
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)
}
} }
@After @After
open fun tearDown() { 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 issuedStates = vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 10, DUMMY_CASH_ISSUER)
val issuedStateRefs = issuedStates.states.map { it.ref }.toList() val issuedStateRefs = issuedStates.states.map { it.ref }.toList()
stateRefs.addAll(issuedStateRefs) stateRefs.addAll(issuedStateRefs)
} this.session.flush()
database.transaction {
val spentStates = consumeCash(25.DOLLARS) val spentStates = consumeCash(25.DOLLARS)
val consumedStateRefs = spentStates.consumed.map { it.ref }.toList() val consumedStateRefs = spentStates.consumed.map { it.ref }.toList()
val producedStateRefs = spentStates.produced.map { it.ref }.toList() val producedStateRefs = spentStates.produced.map { it.ref }.toList()
@ -306,8 +321,8 @@ open class VaultQueryTests {
val consumed = mutableSetOf<SecureHash>() val consumed = mutableSetOf<SecureHash>()
database.transaction { database.transaction {
vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 10, DUMMY_CASH_ISSUER) vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 10, DUMMY_CASH_ISSUER)
} this.session.flush()
database.transaction {
consumeCash(10.DOLLARS).consumed.forEach { consumed += it.ref.txhash } consumeCash(10.DOLLARS).consumed.forEach { consumed += it.ref.txhash }
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) 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 val linearStates = vaultFiller.fillWithSomeTestLinearStates(2, "TEST") // create 2 results with same UID
vaultFiller.fillWithSomeTestLinearStates(8) vaultFiller.fillWithSomeTestLinearStates(8)
val dealStates = vaultFiller.fillWithSomeTestDeals(listOf("123", "456", "789")) val dealStates = vaultFiller.fillWithSomeTestDeals(listOf("123", "456", "789"))
vaultFiller.consumeLinearStates(linearStates.states.toList()) vaultFiller.consumeLinearStates(linearStates.states.toList())
vaultFiller.consumeDeals(dealStates.states.filter { it.state.data.linearId.externalId == "456" }) vaultFiller.consumeDeals(dealStates.states.filter { it.state.data.linearId.externalId == "456" })
consumeCash(50.DOLLARS) // generates a new change state! consumeCash(50.DOLLARS) // generates a new change state!
val criteria = VaultQueryCriteria(status = Vault.StateStatus.ALL) val criteria = VaultQueryCriteria(status = Vault.StateStatus.ALL)
val results = vaultService.queryBy<ContractState>(criteria) val results = vaultService.queryBy<ContractState>(criteria)
assertThat(results.states).hasSize(17) assertThat(results.states).hasSize(17)
@ -986,8 +1004,7 @@ open class VaultQueryTests {
vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 3, DUMMY_CASH_ISSUER) vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 3, DUMMY_CASH_ISSUER)
vaultFiller.fillWithSomeTestLinearStates(10) vaultFiller.fillWithSomeTestLinearStates(10)
vaultFiller.fillWithSomeTestDeals(listOf("123", "456", "789")) vaultFiller.fillWithSomeTestDeals(listOf("123", "456", "789"))
} this.session.flush()
database.transaction {
consumeCash(100.DOLLARS) consumeCash(100.DOLLARS)
val asOfDateTime = TODAY val asOfDateTime = TODAY
val consumedAfterExpression = TimeCondition( val consumedAfterExpression = TimeCondition(
@ -1105,8 +1122,8 @@ open class VaultQueryTests {
// sorting // sorting
@Test @Test
fun `sorting - all states sorted by contract type, state status, consumed time`() { fun `sorting - all states sorted by contract type, state status, consumed time`() {
setUpDb(database)
database.transaction { database.transaction {
setUpDb(database)
val sortCol1 = Sort.SortColumn(SortAttribute.Standard(Sort.VaultStateAttribute.CONTRACT_STATE_TYPE), Sort.Direction.DESC) 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 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) 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 states = result.states
val metadata = result.statesMetadata 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(states).hasSize(20)
assertThat(metadata.first().contractStateClassName).isEqualTo("$DUMMY_LINEAR_CONTRACT_PROGRAM_ID\$State") assertThat(metadata.first().contractStateClassName).isEqualTo("$DUMMY_LINEAR_CONTRACT_PROGRAM_ID\$State")
assertThat(metadata.first().status).isEqualTo(Vault.StateStatus.UNCONSUMED) // 0 = UNCONSUMED 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.fillWithSomeTestCash(100.DOLLARS, notaryServices, 3, DUMMY_CASH_ISSUER)
vaultFiller.fillWithSomeTestCommodity(Amount(100, Commodity.getInstance("FCOJ")!!), notaryServices, DUMMY_OBLIGATION_ISSUER.ref(1)) vaultFiller.fillWithSomeTestCommodity(Amount(100, Commodity.getInstance("FCOJ")!!), notaryServices, DUMMY_OBLIGATION_ISSUER.ref(1))
vaultFiller.fillWithSomeTestLinearStates(10) vaultFiller.fillWithSomeTestLinearStates(10)
val results = vaultService.queryBy<FungibleAsset<*>>() val results = vaultService.queryBy<FungibleAsset<*>>()
assertThat(results.states).hasSize(4) assertThat(results.states).hasSize(4)
} }
@ -1143,8 +1157,8 @@ open class VaultQueryTests {
fun `consumed fungible assets`() { fun `consumed fungible assets`() {
database.transaction { database.transaction {
vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 3, DUMMY_CASH_ISSUER) vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 3, DUMMY_CASH_ISSUER)
} this.session.flush()
database.transaction {
consumeCash(50.DOLLARS) consumeCash(50.DOLLARS)
vaultFiller.fillWithSomeTestCommodity(Amount(100, Commodity.getInstance("FCOJ")!!), notaryServices, DUMMY_OBLIGATION_ISSUER.ref(1)) vaultFiller.fillWithSomeTestCommodity(Amount(100, Commodity.getInstance("FCOJ")!!), notaryServices, DUMMY_OBLIGATION_ISSUER.ref(1))
vaultFiller.fillWithSomeTestLinearStates(10) vaultFiller.fillWithSomeTestLinearStates(10)
@ -1168,8 +1182,8 @@ open class VaultQueryTests {
fun `unconsumed cash fungible assets after spending`() { fun `unconsumed cash fungible assets after spending`() {
database.transaction { database.transaction {
vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 3, DUMMY_CASH_ISSUER) vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 3, DUMMY_CASH_ISSUER)
} this.session.flush()
database.transaction {
consumeCash(50.DOLLARS) consumeCash(50.DOLLARS)
// should now have x2 CONSUMED + x2 UNCONSUMED (one spent + one change) // should now have x2 CONSUMED + x2 UNCONSUMED (one spent + one change)
val results = vaultService.queryBy<Cash.State>(FungibleAssetQueryCriteria()) val results = vaultService.queryBy<Cash.State>(FungibleAssetQueryCriteria())
@ -1182,8 +1196,8 @@ open class VaultQueryTests {
fun `consumed cash fungible assets`() { fun `consumed cash fungible assets`() {
database.transaction { database.transaction {
vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 3, DUMMY_CASH_ISSUER) vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 3, DUMMY_CASH_ISSUER)
} this.session.flush()
database.transaction {
consumeCash(50.DOLLARS) consumeCash(50.DOLLARS)
val linearStates = vaultFiller.fillWithSomeTestLinearStates(10) val linearStates = vaultFiller.fillWithSomeTestLinearStates(10)
vaultFiller.consumeLinearStates(linearStates.states.toList()) 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 sorting = Sort(setOf(Sort.SortColumn(SortAttribute.Standard(Sort.LinearStateAttribute.EXTERNAL_ID), Sort.Direction.DESC)))
val results = vaultService.queryBy<DummyLinearContract.State>((vaultCriteria), sorting = sorting) val results = vaultService.queryBy<DummyLinearContract.State>((vaultCriteria), sorting = sorting)
results.states.forEach { println(it.state.data.linearString) }
assertThat(results.states).hasSize(6) assertThat(results.states).hasSize(6)
} }
} }
@ -1397,8 +1410,6 @@ open class VaultQueryTests {
vaultFiller.fillWithSomeTestLinearStates(2, "TEST") vaultFiller.fillWithSomeTestLinearStates(2, "TEST")
vaultFiller.fillWithSomeTestDeals(listOf("456")) vaultFiller.fillWithSomeTestDeals(listOf("456"))
vaultFiller.fillWithSomeTestDeals(listOf("123", "789")) vaultFiller.fillWithSomeTestDeals(listOf("123", "789"))
val all = vaultService.queryBy<DealState>()
all.states.forEach { println(it.state) }
val criteria = LinearStateQueryCriteria(externalId = listOf("456")) val criteria = LinearStateQueryCriteria(externalId = listOf("456"))
val results = vaultService.queryBy<DealState>(criteria) 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.POUNDS, gbpCashIssuerServices, 1, gbpCashIssuer.party.ref(1))
vaultFiller.fillWithSomeTestCash(100.DOLLARS, usdCashIssuerServices, 1, usdCashIssuer.party.ref(1)) vaultFiller.fillWithSomeTestCash(100.DOLLARS, usdCashIssuerServices, 1, usdCashIssuer.party.ref(1))
vaultFiller.fillWithSomeTestCash(100.SWISS_FRANCS, chfCashIssuerServices, 1, chfCashIssuer.party.ref(1)) vaultFiller.fillWithSomeTestCash(100.SWISS_FRANCS, chfCashIssuerServices, 1, chfCashIssuer.party.ref(1))
} this.session.flush()
database.transaction {
val criteria = FungibleAssetQueryCriteria(issuer = listOf(gbpCashIssuer.party, usdCashIssuer.party)) val criteria = FungibleAssetQueryCriteria(issuer = listOf(gbpCashIssuer.party, usdCashIssuer.party))
val results = vaultService.queryBy<FungibleAsset<*>>(criteria) val results = vaultService.queryBy<FungibleAsset<*>>(criteria)
assertThat(results.states).hasSize(2) assertThat(results.states).hasSize(2)
@ -1472,8 +1483,7 @@ open class VaultQueryTests {
database.transaction { database.transaction {
vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 1, BOC.ref(1)) vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 1, BOC.ref(1))
vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 1, MEGA_CORP.ref(0), MINI_CORP) vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 1, MEGA_CORP.ref(0), MINI_CORP)
}
database.transaction {
val criteria = FungibleAssetQueryCriteria(owner = listOf(MEGA_CORP)) val criteria = FungibleAssetQueryCriteria(owner = listOf(MEGA_CORP))
val results = vaultService.queryBy<FungibleAsset<*>>(criteria) 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) 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) 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, MEGA_CORP.ref(0), MEGA_CORP)
vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 1, BOC.ref(0), MINI_CORP) // irrelevant to this vault vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 1, BOC.ref(0), MINI_CORP) // irrelevant to this vault
}
database.transaction {
// DOCSTART VaultQueryExample5.2 // DOCSTART VaultQueryExample5.2
val criteria = FungibleAssetQueryCriteria(owner = listOf(MEGA_CORP, BOC)) val criteria = FungibleAssetQueryCriteria(owner = listOf(MEGA_CORP, BOC))
val results = vaultService.queryBy<ContractState>(criteria) 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**/ /** Chaining together different Query Criteria tests**/
// specifying Query on Cash contract state attributes // specifying Query on Cash contract state attributes
@ -1920,28 +1910,28 @@ open class VaultQueryTests {
@Test @Test
fun trackCashStates_unconsumed() { fun trackCashStates_unconsumed() {
val updates = val updates = database.transaction {
database.transaction { val updates =
// DOCSTART VaultQueryExample15 // DOCSTART VaultQueryExample15
vaultService.trackBy<Cash.State>().updates // UNCONSUMED default vaultService.trackBy<Cash.State>().updates // UNCONSUMED default
// DOCEND VaultQueryExample15 // DOCEND VaultQueryExample15
}
val (linearStates, dealStates) = vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 5, DUMMY_CASH_ISSUER)
database.transaction { val linearStates = vaultFiller.fillWithSomeTestLinearStates(10).states
vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 5, DUMMY_CASH_ISSUER) val dealStates = vaultFiller.fillWithSomeTestDeals(listOf("123", "456", "789")).states
val linearStates = vaultFiller.fillWithSomeTestLinearStates(10).states // add more cash
val dealStates = vaultFiller.fillWithSomeTestDeals(listOf("123", "456", "789")).states vaultFiller.fillWithSomeTestCash(100.POUNDS, notaryServices, 1, DUMMY_CASH_ISSUER)
// add more cash // add another deal
vaultFiller.fillWithSomeTestCash(100.POUNDS, notaryServices, 1, DUMMY_CASH_ISSUER) vaultFiller.fillWithSomeTestDeals(listOf("SAMPLE DEAL"))
// add another deal this.session.flush()
vaultFiller.fillWithSomeTestDeals(listOf("SAMPLE DEAL"))
Pair(linearStates, dealStates)
}
database.transaction {
// consume stuff // consume stuff
consumeCash(100.DOLLARS) consumeCash(100.DOLLARS)
vaultFiller.consumeDeals(dealStates.toList()) vaultFiller.consumeDeals(dealStates.toList())
vaultFiller.consumeLinearStates(linearStates.toList()) vaultFiller.consumeLinearStates(linearStates.toList())
close() // transaction needs to be closed to trigger events
updates
} }
updates.expectEvents { updates.expectEvents {
@ -1962,31 +1952,29 @@ open class VaultQueryTests {
@Test @Test
fun trackCashStates_consumed() { fun trackCashStates_consumed() {
val updates =
database.transaction { val updates = database.transaction {
val criteria = VaultQueryCriteria(status = Vault.StateStatus.CONSUMED) val criteria = VaultQueryCriteria(status = Vault.StateStatus.CONSUMED)
vaultService.trackBy<Cash.State>(criteria).updates val updates = vaultService.trackBy<Cash.State>(criteria).updates
}
val (linearStates, dealStates) = vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 5, DUMMY_CASH_ISSUER)
database.transaction { val linearStates = vaultFiller.fillWithSomeTestLinearStates(10).states
vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 5, DUMMY_CASH_ISSUER) val dealStates = vaultFiller.fillWithSomeTestDeals(listOf("123", "456", "789")).states
val linearStates = vaultFiller.fillWithSomeTestLinearStates(10).states // add more cash
val dealStates = vaultFiller.fillWithSomeTestDeals(listOf("123", "456", "789")).states vaultFiller.fillWithSomeTestCash(100.POUNDS, notaryServices, 1, DUMMY_CASH_ISSUER)
// add more cash // add another deal
vaultFiller.fillWithSomeTestCash(100.POUNDS, notaryServices, 1, DUMMY_CASH_ISSUER) vaultFiller.fillWithSomeTestDeals(listOf("SAMPLE DEAL"))
// add another deal this.session.flush()
vaultFiller.fillWithSomeTestDeals(listOf("SAMPLE DEAL"))
Pair(linearStates, dealStates)
}
database.transaction {
// consume stuff
consumeCash(100.POUNDS) consumeCash(100.POUNDS)
}
database.transaction {
// consume more stuff // consume more stuff
consumeCash(100.DOLLARS) consumeCash(100.DOLLARS)
vaultFiller.consumeDeals(dealStates.toList()) vaultFiller.consumeDeals(dealStates.toList())
vaultFiller.consumeLinearStates(linearStates.toList()) vaultFiller.consumeLinearStates(linearStates.toList())
close() // transaction needs to be closed to trigger events
updates
} }
updates.expectEvents { updates.expectEvents {
@ -2007,31 +1995,30 @@ open class VaultQueryTests {
@Test @Test
fun trackCashStates_all() { fun trackCashStates_all() {
val updates = val updates = database.transaction {
database.transaction { val updates =
val criteria = VaultQueryCriteria(status = Vault.StateStatus.ALL) database.transaction {
vaultService.trackBy<Cash.State>(criteria).updates 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)
vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 5, DUMMY_CASH_ISSUER) val linearStates = vaultFiller.fillWithSomeTestLinearStates(10).states
val linearStates = vaultFiller.fillWithSomeTestLinearStates(10).states val dealStates = vaultFiller.fillWithSomeTestDeals(listOf("123", "456", "789")).states
val dealStates = vaultFiller.fillWithSomeTestDeals(listOf("123", "456", "789")).states // add more cash
// add more cash vaultFiller.fillWithSomeTestCash(100.POUNDS, notaryServices, 1, DUMMY_CASH_ISSUER)
vaultFiller.fillWithSomeTestCash(100.POUNDS, notaryServices, 1, DUMMY_CASH_ISSUER) // add another deal
// add another deal vaultFiller.fillWithSomeTestDeals(listOf("SAMPLE DEAL"))
vaultFiller.fillWithSomeTestDeals(listOf("SAMPLE DEAL")) this.session.flush()
Pair(linearStates, dealStates)
} // consume stuff
database.transaction {
// consume stuff
consumeCash(99.POUNDS) consumeCash(99.POUNDS)
}
database.transaction {
// consume more stuff
consumeCash(100.DOLLARS) consumeCash(100.DOLLARS)
vaultFiller.consumeDeals(dealStates.toList()) vaultFiller.consumeDeals(dealStates.toList())
vaultFiller.consumeLinearStates(linearStates.toList()) vaultFiller.consumeLinearStates(linearStates.toList())
close() // transaction needs to be closed to trigger events
updates
} }
updates.expectEvents { updates.expectEvents {
@ -2062,30 +2049,29 @@ open class VaultQueryTests {
@Test @Test
fun trackLinearStates() { fun trackLinearStates() {
val updates =
database.transaction { val updates = database.transaction {
// DOCSTART VaultQueryExample16 // DOCSTART VaultQueryExample16
val (snapshot, updates) = vaultService.trackBy<LinearState>() val (snapshot, updates) = vaultService.trackBy<LinearState>()
// DOCEND VaultQueryExample16 // DOCEND VaultQueryExample16
assertThat(snapshot.states).hasSize(0) assertThat(snapshot.states).hasSize(0)
updates
} vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 3, DUMMY_CASH_ISSUER)
val (linearStates, dealStates) = val linearStates = vaultFiller.fillWithSomeTestLinearStates(10).states
database.transaction { val dealStates = vaultFiller.fillWithSomeTestDeals(listOf("123", "456", "789")).states
vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 3, DUMMY_CASH_ISSUER) // add more cash
val linearStates = vaultFiller.fillWithSomeTestLinearStates(10).states vaultFiller.fillWithSomeTestCash(100.POUNDS, notaryServices, 1, DUMMY_CASH_ISSUER)
val dealStates = vaultFiller.fillWithSomeTestDeals(listOf("123", "456", "789")).states // add another deal
// add more cash vaultFiller.fillWithSomeTestDeals(listOf("SAMPLE DEAL"))
vaultFiller.fillWithSomeTestCash(100.POUNDS, notaryServices, 1, DUMMY_CASH_ISSUER) this.session.flush()
// add another deal
vaultFiller.fillWithSomeTestDeals(listOf("SAMPLE DEAL"))
Pair(linearStates, dealStates)
}
database.transaction {
// consume stuff // consume stuff
consumeCash(100.DOLLARS) consumeCash(100.DOLLARS)
vaultFiller.consumeDeals(dealStates.toList()) vaultFiller.consumeDeals(dealStates.toList())
vaultFiller.consumeLinearStates(linearStates.toList()) vaultFiller.consumeLinearStates(linearStates.toList())
close() // transaction needs to be closed to trigger events
updates
} }
updates.expectEvents { updates.expectEvents {
@ -2111,30 +2097,30 @@ open class VaultQueryTests {
@Test @Test
fun trackDealStates() { fun trackDealStates() {
val updates =
database.transaction { val updates = database.transaction {
// DOCSTART VaultQueryExample17
val (snapshot, updates) = vaultService.trackBy<DealState>() // DOCSTART VaultQueryExample17
// DOCEND VaultQueryExample17 val (snapshot, updates) = vaultService.trackBy<DealState>()
assertThat(snapshot.states).hasSize(0) // DOCEND VaultQueryExample17
updates assertThat(snapshot.states).hasSize(0)
}
val (linearStates, dealStates) = vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 3, DUMMY_CASH_ISSUER)
database.transaction { val linearStates = vaultFiller.fillWithSomeTestLinearStates(10).states
vaultFiller.fillWithSomeTestCash(100.DOLLARS, notaryServices, 3, DUMMY_CASH_ISSUER) val dealStates = vaultFiller.fillWithSomeTestDeals(listOf("123", "456", "789")).states
val linearStates = vaultFiller.fillWithSomeTestLinearStates(10).states // add more cash
val dealStates = vaultFiller.fillWithSomeTestDeals(listOf("123", "456", "789")).states vaultFiller.fillWithSomeTestCash(100.POUNDS, notaryServices, 1, DUMMY_CASH_ISSUER)
// add more cash // add another deal
vaultFiller.fillWithSomeTestCash(100.POUNDS, notaryServices, 1, DUMMY_CASH_ISSUER) vaultFiller.fillWithSomeTestDeals(listOf("SAMPLE DEAL"))
// add another deal this.session.flush()
vaultFiller.fillWithSomeTestDeals(listOf("SAMPLE DEAL"))
Pair(linearStates, dealStates)
}
database.transaction {
// consume stuff // consume stuff
consumeCash(100.DOLLARS) consumeCash(100.DOLLARS)
vaultFiller.consumeDeals(dealStates.toList()) vaultFiller.consumeDeals(dealStates.toList())
vaultFiller.consumeLinearStates(linearStates.toList()) vaultFiller.consumeLinearStates(linearStates.toList())
close()
updates
} }
updates.expectEvents { updates.expectEvents {
@ -2157,8 +2143,8 @@ open class VaultQueryTests {
fun `unconsumedCashStatesForSpending_single_issuer_reference`() { fun `unconsumedCashStatesForSpending_single_issuer_reference`() {
database.transaction { database.transaction {
vaultFiller.fillWithSomeTestCash(1000.DOLLARS, notaryServices, 1, DUMMY_CASH_ISSUER) vaultFiller.fillWithSomeTestCash(1000.DOLLARS, notaryServices, 1, DUMMY_CASH_ISSUER)
} this.session.flush()
database.transaction {
val builder = TransactionBuilder() val builder = TransactionBuilder()
val issuer = DUMMY_CASH_ISSUER val issuer = DUMMY_CASH_ISSUER
val exitStates = AbstractCashSelection val exitStates = AbstractCashSelection
@ -2175,8 +2161,7 @@ open class VaultQueryTests {
fun `unconsumedCashStatesForSpending_single_issuer_reference_not_matching`() { fun `unconsumedCashStatesForSpending_single_issuer_reference_not_matching`() {
database.transaction { database.transaction {
vaultFiller.fillWithSomeTestCash(1000.DOLLARS, notaryServices, 1, DUMMY_CASH_ISSUER) vaultFiller.fillWithSomeTestCash(1000.DOLLARS, notaryServices, 1, DUMMY_CASH_ISSUER)
}
database.transaction {
val builder = TransactionBuilder() val builder = TransactionBuilder()
val issuer = DUMMY_CASH_ISSUER val issuer = DUMMY_CASH_ISSUER
val exitStates = AbstractCashSelection val exitStates = AbstractCashSelection

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

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