Pass some key constants into MockServices. (#2173)

finance/src/test/kotlin/net/corda/finance/contracts/CommercialPaperTests.kt

@@ -16,6 +16,7 @@ import net.corda.testing.*
 import net.corda.testing.contracts.VaultFiller
 import net.corda.testing.node.MockServices
 import net.corda.testing.node.MockServices.Companion.makeTestDatabaseAndMockServices
+import net.corda.testing.node.makeTestIdentityService
 import org.junit.Ignore
 import org.junit.Rule
 import org.junit.Test
@@ -232,7 +233,10 @@ class CommercialPaperTestsGeneric {
     //    @Test
     @Ignore
     fun `issue move and then redeem`() = withTestSerialization {
-        val aliceDatabaseAndServices = makeTestDatabaseAndMockServices(keys = listOf(ALICE_KEY))
+        val aliceDatabaseAndServices = makeTestDatabaseAndMockServices(
+                listOf(ALICE_KEY),
+                makeTestIdentityService(listOf(MEGA_CORP_IDENTITY, MINI_CORP_IDENTITY, DUMMY_CASH_ISSUER_IDENTITY, DUMMY_NOTARY_IDENTITY)),
+                initialIdentityName = MEGA_CORP.name)
         val databaseAlice = aliceDatabaseAndServices.first
         aliceServices = aliceDatabaseAndServices.second
         aliceVaultService = aliceServices.vaultService
@@ -241,8 +245,10 @@ class CommercialPaperTestsGeneric {
             alicesVault = VaultFiller(aliceServices, DUMMY_NOTARY, DUMMY_NOTARY_KEY, rngFactory = ::Random).fillWithSomeTestCash(9000.DOLLARS, issuerServices, 1, DUMMY_CASH_ISSUER)
             aliceVaultService = aliceServices.vaultService
         }
-
+        val bigCorpDatabaseAndServices = makeTestDatabaseAndMockServices(
-        val bigCorpDatabaseAndServices = makeTestDatabaseAndMockServices(keys = listOf(BIG_CORP_KEY))
+                listOf(BIG_CORP_KEY),
+                makeTestIdentityService(listOf(MEGA_CORP_IDENTITY, MINI_CORP_IDENTITY, DUMMY_CASH_ISSUER_IDENTITY, DUMMY_NOTARY_IDENTITY)),
+                initialIdentityName = MEGA_CORP.name)
         val databaseBigCorp = bigCorpDatabaseAndServices.first
         bigCorpServices = bigCorpDatabaseAndServices.second
         bigCorpVaultService = bigCorpServices.vaultService

finance/src/test/kotlin/net/corda/finance/contracts/asset/CashTests.kt

@@ -25,6 +25,7 @@ import net.corda.testing.contracts.DummyState
 import net.corda.testing.contracts.VaultFiller
 import net.corda.testing.node.MockServices
 import net.corda.testing.node.MockServices.Companion.makeTestDatabaseAndMockServices
+import net.corda.testing.node.makeTestIdentityService
 import org.junit.After
 import org.junit.Before
 import org.junit.Rule
@@ -70,9 +71,10 @@ class CashTests {
         miniCorpServices = MockServices(listOf("net.corda.finance.contracts.asset"), MINI_CORP.name, MINI_CORP_KEY)
         val notaryServices = MockServices(listOf("net.corda.finance.contracts.asset"), DUMMY_NOTARY.name, DUMMY_NOTARY_KEY)
         val databaseAndServices = makeTestDatabaseAndMockServices(
-                cordappPackages = listOf("net.corda.finance.contracts.asset"),
+                listOf(generateKeyPair()),
-                initialIdentityName = CordaX500Name(organisation = "Me", locality = "London", country = "GB"),
+                makeTestIdentityService(listOf(MEGA_CORP_IDENTITY, MINI_CORP_IDENTITY, DUMMY_CASH_ISSUER_IDENTITY, DUMMY_NOTARY_IDENTITY)),
-                keys = listOf(generateKeyPair()))
+                listOf("net.corda.finance.contracts.asset"),
+                CordaX500Name("Me", "London", "GB"))
         database = databaseAndServices.first
         ourServices = databaseAndServices.second
 

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

@@ -13,6 +13,7 @@ import net.corda.node.services.identity.InMemoryIdentityService
 import net.corda.nodeapi.NodeInfoFilesCopier
 import net.corda.testing.*
 import net.corda.testing.node.MockKeyManagementService
+import net.corda.testing.node.makeTestIdentityService
 import org.assertj.core.api.Assertions.assertThat
 import org.assertj.core.api.Assertions.contentOf
 import org.junit.Before
@@ -47,7 +48,7 @@ class NodeInfoWatcherTest {
 
     @Before
     fun start() {
-        val identityService = InMemoryIdentityService(trustRoot = DEV_TRUST_ROOT)
+        val identityService = makeTestIdentityService()
         keyManagementService = MockKeyManagementService(identityService, ALICE_KEY)
         nodeInfoWatcher = NodeInfoWatcher(tempFolder.root.toPath(), scheduler)
         nodeInfoPath = tempFolder.root.toPath() / CordformNode.NODE_INFO_DIRECTORY

node/src/main/kotlin/net/corda/node/services/identity/InMemoryIdentityService.kt

@@ -24,14 +24,8 @@ import javax.annotation.concurrent.ThreadSafe
  * @param identities initial set of identities for the service, typically only used for unit tests.
  */
 @ThreadSafe
-class InMemoryIdentityService(identities: Iterable<PartyAndCertificate> = emptySet(),
+class InMemoryIdentityService(identities: Iterable<PartyAndCertificate>,
-                              confidentialIdentities: Iterable<PartyAndCertificate> = emptySet(),
+                              trustRoot: X509CertificateHolder) : SingletonSerializeAsToken(), IdentityService {
-                              override val trustRoot: X509Certificate,
-                              vararg caCertificates: X509Certificate) : SingletonSerializeAsToken(), IdentityService {
-    constructor(wellKnownIdentities: Iterable<PartyAndCertificate> = emptySet(),
-                confidentialIdentities: Iterable<PartyAndCertificate> = emptySet(),
-                trustRoot: X509CertificateHolder) : this(wellKnownIdentities, confidentialIdentities, trustRoot.cert)
-
     companion object {
         private val log = contextLogger()
     }
@@ -40,18 +34,15 @@ class InMemoryIdentityService(identities: Iterable<PartyAndCertificate> = emptyS
      * Certificate store for certificate authority and intermediary certificates.
      */
     override val caCertStore: CertStore
-    override val trustAnchor: TrustAnchor = TrustAnchor(trustRoot, null)
+    override val trustRoot = trustRoot.cert
+    override val trustAnchor: TrustAnchor = TrustAnchor(this.trustRoot, null)
     private val keyToParties = ConcurrentHashMap<PublicKey, PartyAndCertificate>()
     private val principalToParties = ConcurrentHashMap<CordaX500Name, PartyAndCertificate>()
 
     init {
-        val caCertificatesWithRoot: Set<X509Certificate> = caCertificates.toSet() + trustRoot
+        caCertStore = CertStore.getInstance("Collection", CollectionCertStoreParameters(setOf(this.trustRoot)))
-        caCertStore = CertStore.getInstance("Collection", CollectionCertStoreParameters(caCertificatesWithRoot))
         keyToParties.putAll(identities.associateBy { it.owningKey })
         principalToParties.putAll(identities.associateBy { it.name })
-        confidentialIdentities.forEach { identity ->
-            principalToParties.computeIfAbsent(identity.name) { identity }
-        }
     }
 
     // TODO: Check the certificate validation logic

node/src/test/java/net/corda/node/services/vault/VaultQueryJavaTests.java

@@ -19,7 +19,6 @@ import net.corda.core.utilities.OpaqueBytes;
 import net.corda.finance.contracts.DealState;
 import net.corda.finance.contracts.asset.Cash;
 import net.corda.finance.schemas.CashSchemaV1;
-import net.corda.node.services.identity.InMemoryIdentityService;
 import net.corda.nodeapi.internal.persistence.CordaPersistence;
 import net.corda.nodeapi.internal.persistence.DatabaseTransaction;
 import net.corda.testing.SerializationEnvironmentRule;
@@ -48,6 +47,7 @@ import static net.corda.finance.contracts.asset.CashUtilities.*;
 import static net.corda.testing.CoreTestUtils.*;
 import static net.corda.testing.TestConstants.*;
 import static net.corda.testing.node.MockServices.makeTestDatabaseAndMockServices;
+import static net.corda.testing.node.MockServicesKt.makeTestIdentityService;
 import static org.assertj.core.api.Assertions.assertThat;
 
 public class VaultQueryJavaTests {
@@ -61,14 +61,12 @@ public class VaultQueryJavaTests {
     @Before
     public void setUp() throws CertificateException, InvalidAlgorithmParameterException {
         List<String> cordappPackages = Arrays.asList("net.corda.testing.contracts", "net.corda.finance.contracts.asset", CashSchemaV1.class.getPackage().getName());
-        IdentityService identitySvc = new InMemoryIdentityService(
+        IdentityService identitySvc = makeTestIdentityService(Arrays.asList(getMEGA_CORP_IDENTITY(), getDUMMY_CASH_ISSUER_IDENTITY(), getDUMMY_NOTARY_IDENTITY()));
-                Arrays.asList(getMEGA_CORP_IDENTITY(), getDUMMY_CASH_ISSUER_IDENTITY(), getDUMMY_NOTARY_IDENTITY()),
-                Collections.emptySet(),
-                getDEV_TRUST_ROOT());
         Pair<CordaPersistence, MockServices> databaseAndServices = makeTestDatabaseAndMockServices(
                 Arrays.asList(getMEGA_CORP_KEY(), getDUMMY_NOTARY_KEY()),
                 identitySvc,
-                cordappPackages);
+                cordappPackages,
+                getMEGA_CORP().getName());
         issuerServices = new MockServices(cordappPackages, getDUMMY_CASH_ISSUER_NAME(), getDUMMY_CASH_ISSUER_KEY(), getBOC_KEY());
         database = databaseAndServices.getFirst();
         MockServices services = databaseAndServices.getSecond();

node/src/test/kotlin/net/corda/node/InteractiveShellTest.kt

@@ -11,13 +11,12 @@ import net.corda.core.internal.concurrent.openFuture
 import net.corda.core.messaging.FlowProgressHandleImpl
 import net.corda.core.utilities.ProgressTracker
 import net.corda.nodeapi.internal.persistence.DatabaseConfig
-import net.corda.node.services.identity.InMemoryIdentityService
 import net.corda.node.shell.InteractiveShell
 import net.corda.node.internal.configureDatabase
-import net.corda.testing.DEV_TRUST_ROOT
 import net.corda.testing.MEGA_CORP
 import net.corda.testing.MEGA_CORP_IDENTITY
 import net.corda.testing.node.MockServices
+import net.corda.testing.node.makeTestIdentityService
 import net.corda.testing.rigorousMock
 import org.junit.After
 import org.junit.Before
@@ -49,7 +48,7 @@ class InteractiveShellTest {
         override fun call() = a
     }
 
-    private val ids = InMemoryIdentityService(listOf(MEGA_CORP_IDENTITY), trustRoot = DEV_TRUST_ROOT)
+    private val ids = makeTestIdentityService(listOf(MEGA_CORP_IDENTITY))
     private val om = JacksonSupport.createInMemoryMapper(ids, YAMLFactory())
 
     private fun check(input: String, expected: String) {

node/src/test/kotlin/net/corda/node/services/events/NodeSchedulerServiceTest.kt

@@ -91,7 +91,7 @@ class NodeSchedulerServiceTest : SingletonSerializeAsToken() {
         calls = 0
         val dataSourceProps = makeTestDataSourceProperties()
         database = configureDatabase(dataSourceProps, DatabaseConfig(), rigorousMock())
-        val identityService = InMemoryIdentityService(trustRoot = DEV_TRUST_ROOT)
+        val identityService = makeTestIdentityService()
         kms = MockKeyManagementService(identityService, ALICE_KEY)
         val configuration = testNodeConfiguration(Paths.get("."), CordaX500Name("Alice", "London", "GB"))
         val validatedTransactions = MockTransactionStorage()

node/src/test/kotlin/net/corda/node/services/identity/InMemoryIdentityServiceTests.kt

@@ -23,9 +23,13 @@ import kotlin.test.assertNull
  * Tests for the in memory identity service.
  */
 class InMemoryIdentityServiceTests {
+    companion object {
+        private fun createService(vararg identities: PartyAndCertificate) = InMemoryIdentityService(identities.toSet(), DEV_TRUST_ROOT)
+    }
+
     @Test
     fun `get all identities`() {
-        val service = InMemoryIdentityService(trustRoot = DEV_TRUST_ROOT)
+        val service = createService()
         // Nothing registered, so empty set
         assertNull(service.getAllIdentities().firstOrNull())
 
@@ -43,7 +47,7 @@ class InMemoryIdentityServiceTests {
 
     @Test
     fun `get identity by key`() {
-        val service = InMemoryIdentityService(trustRoot = DEV_TRUST_ROOT)
+        val service = createService()
         assertNull(service.partyFromKey(ALICE_PUBKEY))
         service.verifyAndRegisterIdentity(ALICE_IDENTITY)
         assertEquals(ALICE, service.partyFromKey(ALICE_PUBKEY))
@@ -52,13 +56,13 @@ class InMemoryIdentityServiceTests {
 
     @Test
     fun `get identity by name with no registered identities`() {
-        val service = InMemoryIdentityService(trustRoot = DEV_TRUST_ROOT)
+        val service = createService()
         assertNull(service.wellKnownPartyFromX500Name(ALICE.name))
     }
 
     @Test
     fun `get identity by substring match`() {
-        val service = InMemoryIdentityService(trustRoot = DEV_TRUST_ROOT)
+        val service = createService()
         service.verifyAndRegisterIdentity(ALICE_IDENTITY)
         service.verifyAndRegisterIdentity(BOB_IDENTITY)
         val alicente = getTestPartyAndCertificate(CordaX500Name(organisation = "Alicente Worldwide", locality = "London", country = "GB"), generateKeyPair().public)
@@ -70,7 +74,7 @@ class InMemoryIdentityServiceTests {
 
     @Test
     fun `get identity by name`() {
-        val service = InMemoryIdentityService(trustRoot = DEV_TRUST_ROOT)
+        val service = createService()
         val identities = listOf("Org A", "Org B", "Org C")
                 .map { getTestPartyAndCertificate(CordaX500Name(organisation = it, locality = "London", country = "GB"), generateKeyPair().public) }
         assertNull(service.wellKnownPartyFromX500Name(identities.first().name))
@@ -87,7 +91,7 @@ class InMemoryIdentityServiceTests {
             val rootKey = Crypto.generateKeyPair(X509Utilities.DEFAULT_TLS_SIGNATURE_SCHEME)
             val rootCert = X509Utilities.createSelfSignedCACertificate(ALICE.name, rootKey)
             val txKey = Crypto.generateKeyPair(X509Utilities.DEFAULT_TLS_SIGNATURE_SCHEME)
-            val service = InMemoryIdentityService(trustRoot = DEV_TRUST_ROOT)
+            val service = createService()
             // TODO: Generate certificate with an EdDSA key rather than ECDSA
             val identity = Party(rootCert.cert)
             val txIdentity = AnonymousParty(txKey.public)
@@ -108,7 +112,7 @@ class InMemoryIdentityServiceTests {
         val (_, bobTxIdentity) = createParty(ALICE.name, DEV_CA)
 
         // Now we have identities, construct the service and let it know about both
-        val service = InMemoryIdentityService(setOf(alice), emptySet(), DEV_TRUST_ROOT)
+        val service = createService(alice)
         service.verifyAndRegisterIdentity(aliceTxIdentity)
 
         var actual = service.certificateFromKey(aliceTxIdentity.party.owningKey)
@@ -131,8 +135,7 @@ class InMemoryIdentityServiceTests {
             val (bob, anonymousBob) = createParty(BOB.name, DEV_CA)
 
             // Now we have identities, construct the service and let it know about both
-            val service = InMemoryIdentityService(setOf(alice, bob), emptySet(), DEV_TRUST_ROOT)
+            val service = createService(alice, bob)
-
             service.verifyAndRegisterIdentity(anonymousAlice)
             service.verifyAndRegisterIdentity(anonymousBob)
 
@@ -168,7 +171,7 @@ class InMemoryIdentityServiceTests {
      */
     @Test
     fun `deanonymising a well known identity should return the identity`() {
-        val service = InMemoryIdentityService(trustRoot = DEV_TRUST_ROOT)
+        val service = createService()
         val expected = ALICE
         service.verifyAndRegisterIdentity(ALICE_IDENTITY)
         val actual = service.wellKnownPartyFromAnonymous(expected)
@@ -180,7 +183,7 @@ class InMemoryIdentityServiceTests {
      */
     @Test
     fun `deanonymising a false well known identity should return null`() {
-        val service = InMemoryIdentityService(trustRoot = DEV_TRUST_ROOT)
+        val service = createService()
         val notAlice = Party(ALICE.name, generateKeyPair().public)
         service.verifyAndRegisterIdentity(ALICE_IDENTITY)
         val actual = service.wellKnownPartyFromAnonymous(notAlice)

node/src/test/kotlin/net/corda/node/services/identity/PersistentIdentityServiceTests.kt

@@ -17,6 +17,7 @@ import net.corda.nodeapi.internal.crypto.X509Utilities
 import net.corda.nodeapi.internal.persistence.CordaPersistence
 import net.corda.testing.*
 import net.corda.testing.node.MockServices
+import net.corda.testing.node.makeTestIdentityService
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
@@ -34,7 +35,7 @@ class PersistentIdentityServiceTests {
 
     @Before
     fun setup() {
-        val databaseAndServices = MockServices.makeTestDatabaseAndMockServices(keys = emptyList(), identityService = PersistentIdentityService(DEV_TRUST_ROOT))
+        val databaseAndServices = MockServices.makeTestDatabaseAndMockServices(emptyList(), PersistentIdentityService(DEV_TRUST_ROOT), initialIdentityName = MEGA_CORP.name)
         database = databaseAndServices.first
         services = databaseAndServices.second
         identityService = services.identityService
@@ -266,7 +267,7 @@ class PersistentIdentityServiceTests {
      */
     @Test
     fun `deanonymising a well known identity should return the identity`() {
-        val service = InMemoryIdentityService(trustRoot = DEV_TRUST_ROOT)
+        val service = makeTestIdentityService()
         val expected = ALICE
         service.verifyAndRegisterIdentity(ALICE_IDENTITY)
         val actual = service.wellKnownPartyFromAnonymous(expected)
@@ -278,7 +279,7 @@ class PersistentIdentityServiceTests {
      */
     @Test
     fun `deanonymising a false well known identity should return null`() {
-        val service = InMemoryIdentityService(trustRoot = DEV_TRUST_ROOT)
+        val service = makeTestIdentityService()
         val notAlice = Party(ALICE.name, generateKeyPair().public)
         service.verifyAndRegisterIdentity(ALICE_IDENTITY)
         val actual = service.wellKnownPartyFromAnonymous(notAlice)

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

@@ -38,6 +38,7 @@ import net.corda.nodeapi.internal.persistence.CordaPersistence
 import net.corda.testing.*
 import net.corda.testing.contracts.VaultFiller
 import net.corda.testing.node.MockServices
+import net.corda.testing.node.makeTestIdentityService
 import org.assertj.core.api.Assertions.assertThat
 import org.assertj.core.api.Assertions.assertThatExceptionOfType
 import org.junit.After
@@ -72,7 +73,11 @@ class NodeVaultServiceTest {
     @Before
     fun setUp() {
         LogHelper.setLevel(NodeVaultService::class)
-        val databaseAndServices = MockServices.makeTestDatabaseAndMockServices(cordappPackages = cordappPackages)
+        val databaseAndServices = MockServices.makeTestDatabaseAndMockServices(
+                listOf(MEGA_CORP_KEY),
+                makeTestIdentityService(listOf(MEGA_CORP_IDENTITY, MINI_CORP_IDENTITY, DUMMY_CASH_ISSUER_IDENTITY, DUMMY_NOTARY_IDENTITY)),
+                cordappPackages,
+                MEGA_CORP.name)
         database = databaseAndServices.first
         services = databaseAndServices.second
         vaultFiller = VaultFiller(services, DUMMY_NOTARY, DUMMY_NOTARY_KEY)

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

@@ -35,6 +35,7 @@ import net.corda.testing.*
 import net.corda.testing.contracts.*
 import net.corda.testing.node.MockServices
 import net.corda.testing.node.MockServices.Companion.makeTestDatabaseAndMockServices
+import net.corda.testing.node.makeTestIdentityService
 import net.corda.testing.schemas.DummyLinearStateSchemaV1
 import org.assertj.core.api.Assertions.assertThat
 import org.assertj.core.api.Assertions.assertThatThrownBy
@@ -79,8 +80,11 @@ class VaultQueryTests {
     @Before
     fun setUp() {
         // register additional identities
-        val databaseAndServices = makeTestDatabaseAndMockServices(keys = listOf(MEGA_CORP_KEY, DUMMY_NOTARY_KEY),
+        val databaseAndServices = makeTestDatabaseAndMockServices(
-                cordappPackages = cordappPackages)
+                listOf(MEGA_CORP_KEY, DUMMY_NOTARY_KEY),
+                makeTestIdentityService(listOf(MEGA_CORP_IDENTITY, MINI_CORP_IDENTITY, DUMMY_CASH_ISSUER_IDENTITY, DUMMY_NOTARY_IDENTITY)),
+                cordappPackages,
+                MEGA_CORP.name)
         database = databaseAndServices.first
         services = databaseAndServices.second
         vaultFiller = VaultFiller(services, DUMMY_NOTARY, DUMMY_NOTARY_KEY)

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

@@ -29,6 +29,7 @@ import net.corda.testing.*
 import net.corda.testing.contracts.*
 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.After
@@ -60,7 +61,11 @@ class VaultWithCashTest {
     @Before
     fun setUp() {
         LogHelper.setLevel(VaultWithCashTest::class)
-        val databaseAndServices = makeTestDatabaseAndMockServices(cordappPackages = cordappPackages, keys = listOf(generateKeyPair(), DUMMY_NOTARY_KEY))
+        val databaseAndServices = makeTestDatabaseAndMockServices(
+                listOf(generateKeyPair(), DUMMY_NOTARY_KEY),
+                makeTestIdentityService(listOf(MEGA_CORP_IDENTITY, MINI_CORP_IDENTITY, DUMMY_CASH_ISSUER_IDENTITY, DUMMY_NOTARY_IDENTITY)),
+                cordappPackages,
+                MEGA_CORP.name)
         database = databaseAndServices.first
         services = databaseAndServices.second
         vaultFiller = VaultFiller(services, DUMMY_NOTARY, DUMMY_NOTARY_KEY)

samples/network-visualiser/src/main/kotlin/net/corda/netmap/simulation/IRSSimulation.kt

@@ -21,10 +21,9 @@ import net.corda.finance.flows.TwoPartyDealFlow.Instigator
 import net.corda.finance.plugin.registerFinanceJSONMappers
 import net.corda.irs.contract.InterestRateSwap
 import net.corda.irs.flows.FixingFlow
-import net.corda.node.services.identity.InMemoryIdentityService
-import net.corda.testing.DEV_TRUST_ROOT
 import net.corda.testing.chooseIdentity
 import net.corda.testing.node.InMemoryMessagingNetwork
+import net.corda.testing.node.makeTestIdentityService
 import net.corda.testing.startFlow
 import rx.Observable
 import java.time.LocalDate
@@ -45,7 +44,7 @@ class IRSSimulation(networkSendManuallyPumped: Boolean, runAsync: Boolean, laten
     private val executeOnNextIteration = Collections.synchronizedList(LinkedList<() -> Unit>())
 
     override fun startMainSimulation(): CompletableFuture<Unit> {
-        om = JacksonSupport.createInMemoryMapper(InMemoryIdentityService((banks + regulators + ratesOracle).flatMap { it.started!!.info.legalIdentitiesAndCerts }, trustRoot = DEV_TRUST_ROOT))
+        om = JacksonSupport.createInMemoryMapper(makeTestIdentityService((banks + regulators + ratesOracle).flatMap { it.started!!.info.legalIdentitiesAndCerts }))
         registerFinanceJSONMappers(om)
 
         return startIRSDealBetween(0, 1).thenCompose {

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

@@ -45,6 +45,7 @@ import java.sql.Connection
 import java.time.Clock
 import java.util.*
 
+fun makeTestIdentityService(identities: Iterable<PartyAndCertificate> = emptySet()) = InMemoryIdentityService(identities, DEV_TRUST_ROOT)
 /**
  * A singleton utility that only provides a mock identity, key and storage service. However, this is sufficient for
  * building chains of transactions and verifying them. It isn't sufficient for testing flows however.
@@ -57,8 +58,6 @@ open class MockServices(
         vararg val keys: KeyPair
 ) : ServiceHub, StateLoader by stateLoader {
     companion object {
-        private val MOCK_IDENTITIES = listOf(MEGA_CORP_IDENTITY, MINI_CORP_IDENTITY, DUMMY_CASH_ISSUER_IDENTITY, DUMMY_NOTARY_IDENTITY)
-
         @JvmStatic
         val MOCK_VERSION_INFO = VersionInfo(1, "Mock release", "Mock revision", "Mock Vendor")
 
@@ -78,32 +77,16 @@ open class MockServices(
             return props
         }
 
-        private fun makeTestIdentityService() = InMemoryIdentityService(MOCK_IDENTITIES, trustRoot = DEV_TRUST_ROOT)
-
         /**
          * 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 keys a list of [KeyPair] instances to be used by [MockServices].
-         * @param createIdentityService a lambda function returning an instance of [IdentityService]. Defaults to [InMemoryIdentityService].
+         * @param identityService an instance of [IdentityService], see [makeTestIdentityService].
-         *
-         * @return a pair where the first element is the instance of [CordaPersistence] and the second is [MockServices].
-         */
-        @JvmStatic
-        fun makeTestDatabaseAndMockServices(keys: List<KeyPair> = listOf(MEGA_CORP_KEY),
-                                            identityService: IdentityService = makeTestIdentityService(),
-                                            cordappPackages: List<String> = emptyList()): Pair<CordaPersistence, MockServices> {
-            return makeTestDatabaseAndMockServices(keys, identityService, 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<KeyPair> = listOf(MEGA_CORP_KEY),
+        fun makeTestDatabaseAndMockServices(keys: List<KeyPair>,
-                                            identityService: IdentityService = makeTestIdentityService(),
+                                            identityService: IdentityService,
                                             cordappPackages: List<String> = emptyList(),
                                             initialIdentityName: CordaX500Name): Pair<CordaPersistence, MockServices> {
             val cordappLoader = CordappLoader.createWithTestPackages(cordappPackages)
@@ -148,7 +131,7 @@ open class MockServices(
 
     final override val attachments = MockAttachmentStorage()
     val stateMachineRecordedTransactionMapping: StateMachineRecordedTransactionMappingStorage = MockStateMachineRecordedTransactionMappingStorage()
-    override val identityService: IdentityService = makeTestIdentityService()
+    override val identityService: IdentityService = makeTestIdentityService(listOf(MEGA_CORP_IDENTITY, MINI_CORP_IDENTITY, DUMMY_CASH_ISSUER_IDENTITY, DUMMY_NOTARY_IDENTITY))
     override val keyManagementService: KeyManagementService by lazy { MockKeyManagementService(identityService, *keys) }
 
     override val vaultService: VaultService get() = throw UnsupportedOperationException()