diff --git a/core/src/test/kotlin/net/corda/core/flows/CollectSignaturesFlowTests.kt b/core/src/test/kotlin/net/corda/core/flows/CollectSignaturesFlowTests.kt index aba0cacdfa..6ad19b2e28 100644 --- a/core/src/test/kotlin/net/corda/core/flows/CollectSignaturesFlowTests.kt +++ b/core/src/test/kotlin/net/corda/core/flows/CollectSignaturesFlowTests.kt @@ -129,7 +129,7 @@ class CollectSignaturesFlowTests { @Test fun `fails when not signed by initiator`() { val onePartyDummyContract = DummyContract.generateInitial(1337, notary, alice.ref(1)) - val miniCorpServices = MockServices(listOf("net.corda.testing.contracts"), MINI_CORP_KEY) + val miniCorpServices = MockServices(listOf("net.corda.testing.contracts"), MINI_CORP.name, MINI_CORP_KEY) val ptx = miniCorpServices.signInitialTransaction(onePartyDummyContract) val flow = aliceNode.services.startFlow(CollectSignaturesFlow(ptx, emptySet())) mockNet.runNetwork() diff --git a/core/src/test/kotlin/net/corda/core/serialization/TransactionSerializationTests.kt b/core/src/test/kotlin/net/corda/core/serialization/TransactionSerializationTests.kt index 803fb57628..efa87a441f 100644 --- a/core/src/test/kotlin/net/corda/core/serialization/TransactionSerializationTests.kt +++ b/core/src/test/kotlin/net/corda/core/serialization/TransactionSerializationTests.kt @@ -50,8 +50,8 @@ class TransactionSerializationTests { val outputState = TransactionState(TestCash.State(depositRef, 600.POUNDS, MEGA_CORP), TEST_CASH_PROGRAM_ID, DUMMY_NOTARY) val changeState = TransactionState(TestCash.State(depositRef, 400.POUNDS, MEGA_CORP), TEST_CASH_PROGRAM_ID, DUMMY_NOTARY) - val megaCorpServices = MockServices(listOf("net.corda.core.serialization"), MEGA_CORP_KEY) - val notaryServices = MockServices(listOf("net.corda.core.serialization"), DUMMY_NOTARY_KEY) + val megaCorpServices = MockServices(listOf("net.corda.core.serialization"), MEGA_CORP.name, MEGA_CORP_KEY) + val notaryServices = MockServices(listOf("net.corda.core.serialization"), DUMMY_NOTARY.name, DUMMY_NOTARY_KEY) lateinit var tx: TransactionBuilder @Before diff --git a/finance/src/main/kotlin/net/corda/finance/contracts/asset/Cash.kt b/finance/src/main/kotlin/net/corda/finance/contracts/asset/Cash.kt index 59aef7bded..6234c7ab73 100644 --- a/finance/src/main/kotlin/net/corda/finance/contracts/asset/Cash.kt +++ b/finance/src/main/kotlin/net/corda/finance/contracts/asset/Cash.kt @@ -343,10 +343,12 @@ class Cash : OnLedgerAsset() { // Unit testing helpers. These could go in a separate file but it's hardly worth it for just a few functions. +/** A dummy, randomly generated issuer party by the name of "Snake Oil Issuer" */ +val DUMMY_CASH_ISSUER_NAME = CordaX500Name(organisation = "Snake Oil Issuer", locality = "London", country = "GB") /** A randomly generated key. */ val DUMMY_CASH_ISSUER_KEY by lazy { entropyToKeyPair(BigInteger.valueOf(10)) } /** A dummy, randomly generated issuer party by the name of "Snake Oil Issuer" */ -val DUMMY_CASH_ISSUER by lazy { Party(CordaX500Name(organisation = "Snake Oil Issuer", locality = "London", country = "GB"), DUMMY_CASH_ISSUER_KEY.public).ref(1) } +val DUMMY_CASH_ISSUER by lazy { Party(DUMMY_CASH_ISSUER_NAME, DUMMY_CASH_ISSUER_KEY.public).ref(1) } /** An extension property that lets you write 100.DOLLARS.CASH */ val Amount.CASH: Cash.State get() = Cash.State(Amount(quantity, Issued(DUMMY_CASH_ISSUER, token)), NULL_PARTY) /** An extension property that lets you get a cash state from an issued token, under the [NULL_PARTY] */ diff --git a/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt b/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt index e3c072ff0c..6884abbacf 100644 --- a/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt +++ b/finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt @@ -26,7 +26,6 @@ import org.junit.After import org.junit.Before import org.junit.Rule import org.junit.Test -import java.security.KeyPair import java.util.* import kotlin.test.* @@ -48,34 +47,55 @@ class CashTests { amount = Amount(amount.quantity, token = amount.token.copy(amount.token.issuer.copy(reference = OpaqueBytes.of(ref)))) ) + private lateinit var ourServices: MockServices private lateinit var miniCorpServices: MockServices private lateinit var megaCorpServices: MockServices val vault: VaultService get() = miniCorpServices.vaultService lateinit var database: CordaPersistence private lateinit var vaultStatesUnconsumed: List> + private lateinit var OUR_IDENTITY_1: AbstractParty + private lateinit var OUR_IDENTITY_AND_CERT: PartyAndCertificate + private lateinit var miniCorpAnonymised: AnonymousParty + private val CHARLIE_ANONYMISED = CHARLIE_IDENTITY.party.anonymise() + + private lateinit var WALLET: List> + @Before fun setUp() { LogHelper.setLevel(NodeVaultService::class) - megaCorpServices = MockServices(listOf("net.corda.finance.contracts.asset"), MEGA_CORP_KEY) - val databaseAndServices = makeTestDatabaseAndMockServices(cordappPackages = listOf("net.corda.finance.contracts.asset"), keys = listOf(MINI_CORP_KEY, MEGA_CORP_KEY, OUR_KEY)) + megaCorpServices = MockServices(listOf("net.corda.finance.contracts.asset"), MEGA_CORP.name, MEGA_CORP_KEY) + val databaseAndServices = makeTestDatabaseAndMockServices( + cordappPackages = listOf("net.corda.finance.contracts.asset"), + initialIdentityName = CordaX500Name(organisation = "Me", locality = "London", country = "GB"), + keys = listOf(generateKeyPair())) database = databaseAndServices.first - miniCorpServices = databaseAndServices.second + miniCorpServices = MockServices(listOf("net.corda.finance.contracts.asset"), MINI_CORP.name, MINI_CORP_KEY) + ourServices = databaseAndServices.second + OUR_IDENTITY_AND_CERT = ourServices.myInfo.singleIdentityAndCert() + OUR_IDENTITY_1 = ourServices.myInfo.singleIdentity() // Create some cash. Any attempt to spend >$500 will require multiple issuers to be involved. database.transaction { - miniCorpServices.fillWithSomeTestCash(howMuch = 100.DOLLARS, atLeastThisManyStates = 1, atMostThisManyStates = 1, + ourServices.fillWithSomeTestCash(howMuch = 100.DOLLARS, atLeastThisManyStates = 1, atMostThisManyStates = 1, ownedBy = OUR_IDENTITY_1, issuedBy = MEGA_CORP.ref(1), issuerServices = megaCorpServices) - miniCorpServices.fillWithSomeTestCash(howMuch = 400.DOLLARS, atLeastThisManyStates = 1, atMostThisManyStates = 1, + ourServices.fillWithSomeTestCash(howMuch = 400.DOLLARS, atLeastThisManyStates = 1, atMostThisManyStates = 1, ownedBy = OUR_IDENTITY_1, issuedBy = MEGA_CORP.ref(1), issuerServices = megaCorpServices) - miniCorpServices.fillWithSomeTestCash(howMuch = 80.DOLLARS, atLeastThisManyStates = 1, atMostThisManyStates = 1, + ourServices.fillWithSomeTestCash(howMuch = 80.DOLLARS, atLeastThisManyStates = 1, atMostThisManyStates = 1, ownedBy = OUR_IDENTITY_1, issuedBy = MINI_CORP.ref(1), issuerServices = miniCorpServices) - miniCorpServices.fillWithSomeTestCash(howMuch = 80.SWISS_FRANCS, atLeastThisManyStates = 1, atMostThisManyStates = 1, + ourServices.fillWithSomeTestCash(howMuch = 80.SWISS_FRANCS, atLeastThisManyStates = 1, atMostThisManyStates = 1, ownedBy = OUR_IDENTITY_1, issuedBy = MINI_CORP.ref(1), issuerServices = miniCorpServices) } + miniCorpAnonymised = miniCorpServices.myInfo.singleIdentityAndCert().party.anonymise() database.transaction { - vaultStatesUnconsumed = miniCorpServices.vaultService.queryBy().states + vaultStatesUnconsumed = ourServices.vaultService.queryBy().states } + WALLET = listOf( + makeCash(100.DOLLARS, MEGA_CORP), + makeCash(400.DOLLARS, MEGA_CORP), + makeCash(80.DOLLARS, MINI_CORP), + makeCash(80.SWISS_FRANCS, MINI_CORP, 2) + ) } @After @@ -473,26 +493,12 @@ class CashTests { // // Spend tx generation - private val OUR_KEY: KeyPair by lazy { generateKeyPair() } - private val OUR_IDENTITY_1: AbstractParty get() = AnonymousParty(OUR_KEY.public) - private val OUR_IDENTITY_AND_CERT = getTestPartyAndCertificate(CordaX500Name(organisation = "Me", locality = "London", country = "GB"), OUR_KEY.public) - - private val THEIR_IDENTITY_1 = AnonymousParty(MINI_CORP_PUBKEY) - private val THEIR_IDENTITY_2 = AnonymousParty(CHARLIE_PUBKEY) - private fun makeCash(amount: Amount, issuer: AbstractParty, depositRef: Byte = 1) = StateAndRef( TransactionState(Cash.State(amount `issued by` issuer.ref(depositRef), OUR_IDENTITY_1), Cash.PROGRAM_ID, DUMMY_NOTARY), StateRef(SecureHash.randomSHA256(), Random().nextInt(32)) ) - private val WALLET = listOf( - makeCash(100.DOLLARS, MEGA_CORP), - makeCash(400.DOLLARS, MEGA_CORP), - makeCash(80.DOLLARS, MINI_CORP), - makeCash(80.SWISS_FRANCS, MINI_CORP, 2) - ) - /** * Generate an exit transaction, removing some amount of cash from the ledger. */ @@ -506,7 +512,7 @@ class CashTests { private fun makeSpend(amount: Amount, dest: AbstractParty): WireTransaction { val tx = TransactionBuilder(DUMMY_NOTARY) database.transaction { - Cash.generateSpend(miniCorpServices, tx, amount, OUR_IDENTITY_AND_CERT, dest) + Cash.generateSpend(ourServices, tx, amount, OUR_IDENTITY_AND_CERT, dest) } return tx.toWireTransaction(miniCorpServices) } @@ -590,12 +596,12 @@ class CashTests { fun generateSimpleDirectSpend() { val wtx = database.transaction { - makeSpend(100.DOLLARS, THEIR_IDENTITY_1) + makeSpend(100.DOLLARS, miniCorpAnonymised) } database.transaction { val vaultState = vaultStatesUnconsumed.elementAt(0) assertEquals(vaultState.ref, wtx.inputs[0]) - assertEquals(vaultState.state.data.copy(owner = THEIR_IDENTITY_1), wtx.getOutput(0)) + assertEquals(vaultState.state.data.copy(owner = miniCorpAnonymised), wtx.getOutput(0)) assertEquals(OUR_IDENTITY_1.owningKey, wtx.commands.single { it.value is Cash.Commands.Move }.signers[0]) } } @@ -605,7 +611,7 @@ class CashTests { database.transaction { val tx = TransactionBuilder(DUMMY_NOTARY) - Cash.generateSpend(miniCorpServices, tx, 80.DOLLARS, OUR_IDENTITY_AND_CERT, ALICE, setOf(MINI_CORP)) + Cash.generateSpend(ourServices, tx, 80.DOLLARS, OUR_IDENTITY_AND_CERT, ALICE, setOf(MINI_CORP)) assertEquals(vaultStatesUnconsumed.elementAt(2).ref, tx.inputStates()[0]) } @@ -615,7 +621,7 @@ class CashTests { fun generateSimpleSpendWithChange() { val wtx = database.transaction { - makeSpend(10.DOLLARS, THEIR_IDENTITY_1) + makeSpend(10.DOLLARS, miniCorpAnonymised) } database.transaction { val vaultState = vaultStatesUnconsumed.elementAt(0) @@ -628,9 +634,9 @@ class CashTests { } } val changeOwner = (likelyChangeState as Cash.State).owner - assertEquals(1, miniCorpServices.keyManagementService.filterMyKeys(setOf(changeOwner.owningKey)).toList().size) + assertEquals(1, ourServices.keyManagementService.filterMyKeys(setOf(changeOwner.owningKey)).toList().size) assertEquals(vaultState.ref, wtx.inputs[0]) - assertEquals(vaultState.state.data.copy(owner = THEIR_IDENTITY_1, amount = 10.DOLLARS `issued by` defaultIssuer), wtx.outputs[0].data) + assertEquals(vaultState.state.data.copy(owner = miniCorpAnonymised, amount = 10.DOLLARS `issued by` defaultIssuer), wtx.outputs[0].data) assertEquals(vaultState.state.data.copy(amount = changeAmount, owner = changeOwner), wtx.outputs[1].data) assertEquals(OUR_IDENTITY_1.owningKey, wtx.commands.single { it.value is Cash.Commands.Move }.signers[0]) } @@ -640,14 +646,14 @@ class CashTests { fun generateSpendWithTwoInputs() { val wtx = database.transaction { - makeSpend(500.DOLLARS, THEIR_IDENTITY_1) + makeSpend(500.DOLLARS, miniCorpAnonymised) } database.transaction { val vaultState0 = vaultStatesUnconsumed.elementAt(0) val vaultState1 = vaultStatesUnconsumed.elementAt(1) assertEquals(vaultState0.ref, wtx.inputs[0]) assertEquals(vaultState1.ref, wtx.inputs[1]) - assertEquals(vaultState0.state.data.copy(owner = THEIR_IDENTITY_1, amount = 500.DOLLARS `issued by` defaultIssuer), wtx.getOutput(0)) + assertEquals(vaultState0.state.data.copy(owner = miniCorpAnonymised, amount = 500.DOLLARS `issued by` defaultIssuer), wtx.getOutput(0)) assertEquals(OUR_IDENTITY_1.owningKey, wtx.commands.single { it.value is Cash.Commands.Move }.signers[0]) } } @@ -656,7 +662,7 @@ class CashTests { fun generateSpendMixedDeposits() { val wtx = database.transaction { - val wtx = makeSpend(580.DOLLARS, THEIR_IDENTITY_1) + val wtx = makeSpend(580.DOLLARS, miniCorpAnonymised) assertEquals(3, wtx.inputs.size) wtx } @@ -667,8 +673,8 @@ class CashTests { assertEquals(vaultState0.ref, wtx.inputs[0]) assertEquals(vaultState1.ref, wtx.inputs[1]) assertEquals(vaultState2.ref, wtx.inputs[2]) - assertEquals(vaultState0.state.data.copy(owner = THEIR_IDENTITY_1, amount = 500.DOLLARS `issued by` defaultIssuer), wtx.outputs[1].data) - assertEquals(vaultState2.state.data.copy(owner = THEIR_IDENTITY_1), wtx.outputs[0].data) + assertEquals(vaultState0.state.data.copy(owner = miniCorpAnonymised, amount = 500.DOLLARS `issued by` defaultIssuer), wtx.outputs[1].data) + assertEquals(vaultState2.state.data.copy(owner = miniCorpAnonymised), wtx.outputs[0].data) assertEquals(OUR_IDENTITY_1.owningKey, wtx.commands.single { it.value is Cash.Commands.Move }.signers[0]) } } @@ -678,12 +684,12 @@ class CashTests { database.transaction { val e: InsufficientBalanceException = assertFailsWith("balance") { - makeSpend(1000.DOLLARS, THEIR_IDENTITY_1) + makeSpend(1000.DOLLARS, miniCorpAnonymised) } assertEquals((1000 - 580).DOLLARS, e.amountMissing) assertFailsWith(InsufficientBalanceException::class) { - makeSpend(81.SWISS_FRANCS, THEIR_IDENTITY_1) + makeSpend(81.SWISS_FRANCS, miniCorpAnonymised) } } } @@ -774,7 +780,7 @@ class CashTests { // Double spend. @Test fun chainCashDoubleSpendFailsWith() { - val mockService = MockServices(listOf("net.corda.finance.contracts.asset"), MEGA_CORP_KEY) + val mockService = MockServices(listOf("net.corda.finance.contracts.asset"), MEGA_CORP.name, MEGA_CORP_KEY) ledger(mockService) { unverifiedTransaction { @@ -815,13 +821,14 @@ class CashTests { fun multiSpend() { val tx = TransactionBuilder(DUMMY_NOTARY) database.transaction { + val changeIdentity = ourServices.keyManagementService.freshKeyAndCert(OUR_IDENTITY_AND_CERT, false) val payments = listOf( - PartyAndAmount(THEIR_IDENTITY_1, 400.DOLLARS), - PartyAndAmount(THEIR_IDENTITY_2, 150.DOLLARS) + PartyAndAmount(miniCorpAnonymised, 400.DOLLARS), + PartyAndAmount(CHARLIE_ANONYMISED, 150.DOLLARS) ) - Cash.generateSpend(miniCorpServices, tx, payments) + Cash.generateSpend(ourServices, tx, payments, changeIdentity) } - val wtx = tx.toWireTransaction(miniCorpServices) + val wtx = tx.toWireTransaction(ourServices) fun out(i: Int) = wtx.getOutput(i) as Cash.State assertEquals(4, wtx.outputs.size) assertEquals(80.DOLLARS, out(0).amount.withoutIssuer()) diff --git a/finance/src/test/kotlin/net/corda/finance/contracts/asset/ObligationTests.kt b/finance/src/test/kotlin/net/corda/finance/contracts/asset/ObligationTests.kt index 8f66d87f8b..b927f09516 100644 --- a/finance/src/test/kotlin/net/corda/finance/contracts/asset/ObligationTests.kt +++ b/finance/src/test/kotlin/net/corda/finance/contracts/asset/ObligationTests.kt @@ -51,7 +51,7 @@ class ObligationTests { beneficiary = CHARLIE ) private val outState = inState.copy(beneficiary = AnonymousParty(BOB_PUBKEY)) - private val miniCorpServices = MockServices(listOf("net.corda.finance.contracts.asset"), MINI_CORP_KEY) + private val miniCorpServices = MockServices(listOf("net.corda.finance.contracts.asset"), MINI_CORP.name, MINI_CORP_KEY) private val notaryServices = MockServices(DUMMY_NOTARY_KEY) private val mockService = MockServices(listOf("net.corda.finance.contracts.asset")) diff --git a/node/src/test/java/net/corda/node/services/vault/VaultQueryJavaTests.java b/node/src/test/java/net/corda/node/services/vault/VaultQueryJavaTests.java index 4d86c161e4..bf532ae053 100644 --- a/node/src/test/java/net/corda/node/services/vault/VaultQueryJavaTests.java +++ b/node/src/test/java/net/corda/node/services/vault/VaultQueryJavaTests.java @@ -50,7 +50,7 @@ public class VaultQueryJavaTests { IdentityService identitySvc = makeTestIdentityService(); @SuppressWarnings("unchecked") Pair databaseAndServices = makeTestDatabaseAndMockServices(keys, () -> identitySvc, cordappPackages); - issuerServices = new MockServices(cordappPackages, getDUMMY_CASH_ISSUER_KEY(), getBOC_KEY()); + issuerServices = new MockServices(cordappPackages, getDUMMY_CASH_ISSUER_NAME(), getDUMMY_CASH_ISSUER_KEY(), getBOC_KEY()); database = databaseAndServices.getFirst(); services = databaseAndServices.getSecond(); vaultService = services.getVaultService(); diff --git a/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt b/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt index f3213f5e0c..a63846573e 100644 --- a/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt +++ b/node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt @@ -18,10 +18,7 @@ import net.corda.core.transactions.SignedTransaction import net.corda.finance.DOLLARS import net.corda.finance.POUNDS import net.corda.finance.SWISS_FRANCS -import net.corda.finance.contracts.asset.Cash -import net.corda.finance.contracts.asset.DUMMY_CASH_ISSUER -import net.corda.finance.contracts.asset.DUMMY_CASH_ISSUER_KEY -import net.corda.finance.contracts.asset.DummyFungibleContract +import net.corda.finance.contracts.asset.* import net.corda.finance.schemas.CashSchemaV1 import net.corda.finance.schemas.SampleCashSchemaV2 import net.corda.finance.schemas.SampleCashSchemaV3 @@ -74,13 +71,13 @@ class HibernateConfigurationTest { @Before fun setUp() { val cordappPackages = listOf("net.corda.testing.contracts", "net.corda.finance.contracts.asset") - issuerServices = MockServices(cordappPackages, DUMMY_CASH_ISSUER_KEY, BOB_KEY, BOC_KEY) + issuerServices = MockServices(cordappPackages, DUMMY_CASH_ISSUER_NAME, DUMMY_CASH_ISSUER_KEY, BOB_KEY, BOC_KEY) val dataSourceProps = makeTestDataSourceProperties() val defaultDatabaseProperties = makeTestDatabaseProperties() database = configureDatabase(dataSourceProps, defaultDatabaseProperties, ::makeTestIdentityService) database.transaction { hibernateConfig = database.hibernateConfig - services = object : MockServices(cordappPackages, BOB_KEY, BOC_KEY, DUMMY_NOTARY_KEY) { + services = object : MockServices(cordappPackages, BOB_NAME, BOB_KEY, BOC_KEY, DUMMY_NOTARY_KEY) { override val vaultService = makeVaultService(database.hibernateConfig) override fun recordTransactions(statesToRecord: StatesToRecord, txs: Iterable) { for (stx in txs) { diff --git a/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt b/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt index ed6b391e9a..ff57f2d363 100644 --- a/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt +++ b/node/src/test/kotlin/net/corda/node/services/vault/NodeVaultServiceTest.kt @@ -28,6 +28,7 @@ import net.corda.finance.* import net.corda.finance.contracts.asset.Cash import net.corda.finance.contracts.asset.DUMMY_CASH_ISSUER import net.corda.finance.contracts.asset.DUMMY_CASH_ISSUER_KEY +import net.corda.finance.contracts.asset.DUMMY_CASH_ISSUER_NAME import net.corda.finance.contracts.getCashBalance import net.corda.finance.schemas.CashSchemaV1 import net.corda.finance.utils.sumCash @@ -70,8 +71,8 @@ class NodeVaultServiceTest { val databaseAndServices = MockServices.makeTestDatabaseAndMockServices(cordappPackages = cordappPackages) database = databaseAndServices.first services = databaseAndServices.second - issuerServices = MockServices(cordappPackages, DUMMY_CASH_ISSUER_KEY) - bocServices = MockServices(cordappPackages, BOC_KEY) + issuerServices = MockServices(cordappPackages, DUMMY_CASH_ISSUER_NAME, DUMMY_CASH_ISSUER_KEY) + bocServices = MockServices(cordappPackages, BOC_NAME, BOC_KEY) services.identityService.verifyAndRegisterIdentity(DUMMY_CASH_ISSUER_IDENTITY) } @@ -453,7 +454,7 @@ class NodeVaultServiceTest { @Test fun addNoteToTransaction() { - val megaCorpServices = MockServices(cordappPackages, MEGA_CORP_KEY) + val megaCorpServices = MockServices(cordappPackages, MEGA_CORP.name, MEGA_CORP_KEY) database.transaction { val freshKey = services.myInfo.chooseIdentity().owningKey diff --git a/node/src/test/kotlin/net/corda/node/services/vault/VaultQueryTests.kt b/node/src/test/kotlin/net/corda/node/services/vault/VaultQueryTests.kt index 7491a91969..002e8ba00a 100644 --- a/node/src/test/kotlin/net/corda/node/services/vault/VaultQueryTests.kt +++ b/node/src/test/kotlin/net/corda/node/services/vault/VaultQueryTests.kt @@ -3,6 +3,7 @@ package net.corda.node.services.vault import net.corda.core.contracts.* import net.corda.core.crypto.SecureHash import net.corda.core.crypto.entropyToKeyPair +import net.corda.core.crypto.generateKeyPair import net.corda.core.crypto.toStringShort import net.corda.core.identity.CordaX500Name import net.corda.core.identity.Party @@ -74,7 +75,7 @@ class VaultQueryTests { cordappPackages = cordappPackages) database = databaseAndServices.first services = databaseAndServices.second - notaryServices = MockServices(cordappPackages, DUMMY_NOTARY_KEY, DUMMY_CASH_ISSUER_KEY, BOC_KEY, MEGA_CORP_KEY) + notaryServices = MockServices(cordappPackages, DUMMY_NOTARY.name, DUMMY_NOTARY_KEY, DUMMY_CASH_ISSUER_KEY, BOC_KEY, MEGA_CORP_KEY) } @After @@ -1352,7 +1353,7 @@ class VaultQueryTests { val parties = listOf(MINI_CORP) database.transaction { services.fillWithSomeTestLinearStates(2, "TEST") - services.fillWithSomeTestDeals(listOf("456"), parties) + services.fillWithSomeTestDeals(listOf("456"), participants = parties) services.fillWithSomeTestDeals(listOf("123", "789")) // DOCSTART VaultQueryExample11 @@ -1385,23 +1386,22 @@ class VaultQueryTests { @Test fun `unconsumed fungible assets for selected issuer parties`() { // GBP issuer - val gbpCashIssuerKey = entropyToKeyPair(BigInteger.valueOf(1001)) - val gbpCashIssuer = Party(CordaX500Name(organisation = "British Pounds Cash Issuer", locality = "London", country = "GB"), gbpCashIssuerKey.public).ref(1) - val gbpCashIssuerServices = MockServices(cordappPackages, gbpCashIssuerKey) + val gbpCashIssuerName = CordaX500Name(organisation = "British Pounds Cash Issuer", locality = "London", country = "GB") + val gbpCashIssuerServices = MockServices(cordappPackages, gbpCashIssuerName, generateKeyPair()) + val gbpCashIssuer = gbpCashIssuerServices.myInfo.singleIdentity().ref(1) // USD issuer - val usdCashIssuerKey = entropyToKeyPair(BigInteger.valueOf(1002)) - val usdCashIssuer = Party(CordaX500Name(organisation = "US Dollars Cash Issuer", locality = "New York", country = "US"), usdCashIssuerKey.public).ref(1) - val usdCashIssuerServices = MockServices(cordappPackages, usdCashIssuerKey) + val usdCashIssuerName = CordaX500Name(organisation = "US Dollars Cash Issuer", locality = "New York", country = "US") + val usdCashIssuerServices = MockServices(cordappPackages, usdCashIssuerName, generateKeyPair()) + val usdCashIssuer = usdCashIssuerServices.myInfo.singleIdentity().ref(1) // CHF issuer - val chfCashIssuerKey = entropyToKeyPair(BigInteger.valueOf(1003)) - val chfCashIssuer = Party(CordaX500Name(organisation = "Swiss Francs Cash Issuer", locality = "Zurich", country = "CH"), chfCashIssuerKey.public).ref(1) - val chfCashIssuerServices = MockServices(cordappPackages, chfCashIssuerKey) + val chfCashIssuerName = CordaX500Name(organisation = "Swiss Francs Cash Issuer", locality = "Zurich", country = "CH") + val chfCashIssuerServices = MockServices(cordappPackages, chfCashIssuerName, generateKeyPair()) + val chfCashIssuer = chfCashIssuerServices.myInfo.singleIdentity().ref(1) database.transaction { - services.fillWithSomeTestCash(100.POUNDS, gbpCashIssuerServices, DUMMY_NOTARY, 1, 1, Random(0L), issuedBy = (gbpCashIssuer)) - services.fillWithSomeTestCash(100.DOLLARS, usdCashIssuerServices, DUMMY_NOTARY, 1, 1, Random(0L), issuedBy = (usdCashIssuer)) - services.fillWithSomeTestCash(100.SWISS_FRANCS, chfCashIssuerServices, DUMMY_NOTARY, 1, 1, Random(0L), issuedBy = (chfCashIssuer)) - + services.fillWithSomeTestCash(100.POUNDS, gbpCashIssuerServices, DUMMY_NOTARY, 1, 1, Random(0L), issuedBy = gbpCashIssuer) + services.fillWithSomeTestCash(100.DOLLARS, usdCashIssuerServices, DUMMY_NOTARY, 1, 1, Random(0L), issuedBy = usdCashIssuer) + services.fillWithSomeTestCash(100.SWISS_FRANCS, chfCashIssuerServices, DUMMY_NOTARY, 1, 1, Random(0L), issuedBy = chfCashIssuer) val criteria = FungibleAssetQueryCriteria(issuer = listOf(gbpCashIssuer.party, usdCashIssuer.party)) val results = vaultService.queryBy>(criteria) assertThat(results.states).hasSize(2) diff --git a/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt b/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt index 5ed6fc323e..1d95d8bf7d 100644 --- a/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt +++ b/node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt @@ -4,6 +4,7 @@ import net.corda.core.contracts.ContractState import net.corda.core.contracts.InsufficientBalanceException import net.corda.core.contracts.LinearState import net.corda.core.contracts.UniqueIdentifier +import net.corda.core.crypto.generateKeyPair import net.corda.core.identity.AnonymousParty import net.corda.core.internal.concurrent.fork import net.corda.core.internal.concurrent.transpose @@ -19,6 +20,7 @@ import net.corda.finance.* import net.corda.finance.contracts.asset.Cash import net.corda.finance.contracts.asset.DUMMY_CASH_ISSUER import net.corda.finance.contracts.asset.DUMMY_CASH_ISSUER_KEY +import net.corda.finance.contracts.asset.DUMMY_CASH_ISSUER_NAME import net.corda.finance.contracts.getCashBalance import net.corda.finance.schemas.CashSchemaV1 import net.corda.node.utilities.CordaPersistence @@ -56,12 +58,11 @@ class VaultWithCashTest { @Before fun setUp() { LogHelper.setLevel(VaultWithCashTest::class) - val databaseAndServices = makeTestDatabaseAndMockServices(keys = listOf(DUMMY_CASH_ISSUER_KEY, DUMMY_NOTARY_KEY), - cordappPackages = cordappPackages) + val databaseAndServices = makeTestDatabaseAndMockServices(cordappPackages = cordappPackages, keys = listOf(generateKeyPair(), DUMMY_NOTARY_KEY)) database = databaseAndServices.first services = databaseAndServices.second - issuerServices = MockServices(cordappPackages, DUMMY_CASH_ISSUER_KEY, MEGA_CORP_KEY) - notaryServices = MockServices(cordappPackages, DUMMY_NOTARY_KEY) + issuerServices = MockServices(cordappPackages, DUMMY_CASH_ISSUER_NAME, DUMMY_CASH_ISSUER_KEY, MEGA_CORP_KEY) + notaryServices = MockServices(cordappPackages, DUMMY_NOTARY.name, DUMMY_NOTARY_KEY) } @After @@ -91,7 +92,7 @@ class VaultWithCashTest { @Test fun `issue and spend total correctly and irrelevant ignored`() { - val megaCorpServices = MockServices(cordappPackages, MEGA_CORP_KEY) + val megaCorpServices = MockServices(cordappPackages, MEGA_CORP.name, MEGA_CORP_KEY) val freshKey = services.keyManagementService.freshKey() val usefulTX = @@ -303,7 +304,7 @@ class VaultWithCashTest { cash.forEach { println(it.state.data.amount) } } database.transaction { - services.fillWithSomeTestDeals(listOf("123", "456", "789")) + services.fillWithSomeTestDeals(listOf("123", "456", "789"), issuerServices) } database.transaction { val deals = vaultService.queryBy().states @@ -333,7 +334,7 @@ class VaultWithCashTest { val freshKey = services.keyManagementService.freshKey() val freshIdentity = AnonymousParty(freshKey) database.transaction { - services.fillWithSomeTestDeals(listOf("123", "456", "789")) + services.fillWithSomeTestDeals(listOf("123", "456", "789"), issuerServices) } val deals = database.transaction { diff --git a/samples/irs-demo/cordapp/src/test/kotlin/net/corda/irs/api/NodeInterestRatesTest.kt b/samples/irs-demo/cordapp/src/test/kotlin/net/corda/irs/api/NodeInterestRatesTest.kt index d61b1d794f..19953b63fd 100644 --- a/samples/irs-demo/cordapp/src/test/kotlin/net/corda/irs/api/NodeInterestRatesTest.kt +++ b/samples/irs-demo/cordapp/src/test/kotlin/net/corda/irs/api/NodeInterestRatesTest.kt @@ -50,7 +50,7 @@ class NodeInterestRatesTest { private val DUMMY_CASH_ISSUER_KEY = generateKeyPair() private val DUMMY_CASH_ISSUER = Party(CordaX500Name(organisation = "Cash issuer", locality = "London", country = "GB"), DUMMY_CASH_ISSUER_KEY.public) - private val services = MockServices(listOf("net.corda.finance.contracts.asset"), DUMMY_CASH_ISSUER_KEY, MEGA_CORP_KEY) + private val services = MockServices(listOf("net.corda.finance.contracts.asset"), DUMMY_CASH_ISSUER.name, DUMMY_CASH_ISSUER_KEY, MEGA_CORP_KEY) private lateinit var oracle: NodeInterestRates.Oracle private lateinit var database: CordaPersistence diff --git a/samples/irs-demo/cordapp/src/test/kotlin/net/corda/irs/contract/IRSTests.kt b/samples/irs-demo/cordapp/src/test/kotlin/net/corda/irs/contract/IRSTests.kt index 11966ff288..a0e75da7ac 100644 --- a/samples/irs-demo/cordapp/src/test/kotlin/net/corda/irs/contract/IRSTests.kt +++ b/samples/irs-demo/cordapp/src/test/kotlin/net/corda/irs/contract/IRSTests.kt @@ -212,9 +212,9 @@ class IRSTests { @Rule @JvmField val testSerialization = SerializationEnvironmentRule() - private val megaCorpServices = MockServices(listOf("net.corda.irs.contract"), MEGA_CORP_KEY) - private val miniCorpServices = MockServices(listOf("net.corda.irs.contract"), MINI_CORP_KEY) - private val notaryServices = MockServices(listOf("net.corda.irs.contract"), DUMMY_NOTARY_KEY) + private val megaCorpServices = MockServices(listOf("net.corda.irs.contract"), MEGA_CORP.name, MEGA_CORP_KEY) + private val miniCorpServices = MockServices(listOf("net.corda.irs.contract"), MINI_CORP.name, MINI_CORP_KEY) + private val notaryServices = MockServices(listOf("net.corda.irs.contract"), DUMMY_NOTARY.name, DUMMY_NOTARY_KEY) @Test fun ok() { diff --git a/samples/trader-demo/src/test/kotlin/net/corda/traderdemo/TransactionGraphSearchTests.kt b/samples/trader-demo/src/test/kotlin/net/corda/traderdemo/TransactionGraphSearchTests.kt index 6c9536980e..0a893c54a6 100644 --- a/samples/trader-demo/src/test/kotlin/net/corda/traderdemo/TransactionGraphSearchTests.kt +++ b/samples/trader-demo/src/test/kotlin/net/corda/traderdemo/TransactionGraphSearchTests.kt @@ -36,8 +36,8 @@ class TransactionGraphSearchTests { * @param signer signer for the two transactions and their commands. */ fun buildTransactions(command: CommandData): GraphTransactionStorage { - val megaCorpServices = MockServices(listOf("net.corda.testing.contracts"), MEGA_CORP_KEY) - val notaryServices = MockServices(listOf("net.corda.testing.contracts"), DUMMY_NOTARY_KEY) + val megaCorpServices = MockServices(listOf("net.corda.testing.contracts"), MEGA_CORP.name, MEGA_CORP_KEY) + val notaryServices = MockServices(listOf("net.corda.testing.contracts"), DUMMY_NOTARY.name, DUMMY_NOTARY_KEY) val originBuilder = TransactionBuilder(DUMMY_NOTARY) .addOutputState(DummyState(random31BitValue()), DummyContract.PROGRAM_ID) diff --git 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 index 9f1ba7dd5f..d3dde4f44d 100644 --- 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 @@ -5,6 +5,7 @@ import net.corda.core.cordapp.CordappProvider import net.corda.core.crypto.* import net.corda.core.flows.FlowLogic import net.corda.core.flows.StateMachineRunId +import net.corda.core.identity.CordaX500Name import net.corda.core.identity.PartyAndCertificate import net.corda.core.messaging.DataFeed import net.corda.core.messaging.FlowHandle @@ -51,6 +52,7 @@ open class MockServices( cordappLoader: CordappLoader, override val validatedTransactions: WritableTransactionStorage, protected val stateLoader: StateLoaderImpl = StateLoaderImpl(validatedTransactions), + private val initialIdentityName: CordaX500Name = MEGA_CORP.name, vararg val keys: KeyPair ) : ServiceHub, StateLoader by stateLoader { companion object { @@ -106,14 +108,28 @@ open class MockServices( @JvmStatic fun makeTestDatabaseAndMockServices(keys: List = listOf(MEGA_CORP_KEY), createIdentityService: () -> IdentityService = { makeTestIdentityService() }, - cordappPackages: List = emptyList()): Pair { + cordappPackages: List = emptyList()): Pair + = makeTestDatabaseAndMockServices(keys, createIdentityService, cordappPackages, MEGA_CORP.name) + + /** + * Makes database and mock services appropriate for unit tests. + * @param keys a list of [KeyPair] instances to be used by [MockServices]. Defaults to [MEGA_CORP_KEY] + * @param createIdentityService a lambda function returning an instance of [IdentityService]. Defauts to [InMemoryIdentityService]. + * @param initialIdentityName the name of the first (typically sole) identity the services will represent. + * @return a pair where the first element is the instance of [CordaPersistence] and the second is [MockServices]. + */ + @JvmStatic + fun makeTestDatabaseAndMockServices(keys: List = listOf(MEGA_CORP_KEY), + createIdentityService: () -> IdentityService = { makeTestIdentityService() }, + cordappPackages: List = emptyList(), + initialIdentityName: CordaX500Name): Pair { val cordappLoader = CordappLoader.createWithTestPackages(cordappPackages) val dataSourceProps = makeTestDataSourceProperties() val databaseProperties = makeTestDatabaseProperties() val identityServiceRef: IdentityService by lazy { createIdentityService() } val database = configureDatabase(dataSourceProps, databaseProperties, { identityServiceRef }, NodeSchemaService(cordappLoader)) val mockService = database.transaction { - object : MockServices(cordappLoader, *(keys.toTypedArray())) { + object : MockServices(cordappLoader, initialIdentityName = initialIdentityName, keys = *(keys.toTypedArray())) { override val identityService: IdentityService = database.transaction { identityServiceRef } override val vaultService: VaultServiceInternal = makeVaultService(database.hibernateConfig) @@ -132,9 +148,9 @@ open class MockServices( } } - private constructor(cordappLoader: CordappLoader, vararg keys: KeyPair) : this(cordappLoader, MockTransactionStorage(), keys = *keys) - constructor(cordappPackages: List, vararg keys: KeyPair) : this(CordappLoader.createWithTestPackages(cordappPackages), keys = *keys) - constructor(vararg keys: KeyPair) : this(emptyList(), *keys) + constructor(cordappLoader: CordappLoader, initialIdentityName: CordaX500Name = MEGA_CORP.name, vararg keys: KeyPair) : this(cordappLoader, MockTransactionStorage(), initialIdentityName = initialIdentityName, keys = *keys) + constructor(cordappPackages: List, initialIdentityName: CordaX500Name = MEGA_CORP.name, vararg keys: KeyPair) : this(CordappLoader.createWithTestPackages(cordappPackages), initialIdentityName = initialIdentityName, keys = *keys) + constructor(vararg keys: KeyPair) : this(emptyList(), MEGA_CORP.name, *keys) constructor() : this(generateKeyPair()) val key: KeyPair get() = keys.first() @@ -159,7 +175,7 @@ open class MockServices( override val clock: Clock get() = Clock.systemUTC() override val myInfo: NodeInfo get() { - val identity = getTestPartyAndCertificate(MEGA_CORP.name, key.public) + val identity = getTestPartyAndCertificate(initialIdentityName, key.public) return NodeInfo(emptyList(), listOf(identity), 1, serial = 1L) } override val myNodeStateObservable: Observable diff --git a/testing/test-utils/src/main/kotlin/net/corda/testing/contracts/VaultFiller.kt b/testing/test-utils/src/main/kotlin/net/corda/testing/contracts/VaultFiller.kt index 4a36926be8..cad028aa20 100644 --- a/testing/test-utils/src/main/kotlin/net/corda/testing/contracts/VaultFiller.kt +++ b/testing/test-utils/src/main/kotlin/net/corda/testing/contracts/VaultFiller.kt @@ -31,6 +31,7 @@ import java.util.* @JvmOverloads fun ServiceHub.fillWithSomeTestDeals(dealIds: List, + issuerServices: ServiceHub = this, participants: List = emptyList(), notary: Party = DUMMY_NOTARY): Vault { val myKey: PublicKey = myInfo.chooseIdentity().owningKey @@ -42,7 +43,7 @@ fun ServiceHub.fillWithSomeTestDeals(dealIds: List, addOutputState(DummyDealContract.State(ref = it, participants = participants.plus(me)), DUMMY_DEAL_PROGRAM_ID) addCommand(dummyCommand()) } - val stx = signInitialTransaction(dummyIssue) + val stx = issuerServices.signInitialTransaction(dummyIssue) return@map addSignature(stx, notary.owningKey) }