Removed the startNotary methods from NodeBasedTest, and moved it into an internal package

This commit is in preparation for the upcoming network parameters work.

client/rpc/src/integration-test/java/net/corda/client/rpc/CordaRPCJavaClientTest.java

@@ -1,6 +1,5 @@
 package net.corda.client.rpc;
 
-import net.corda.core.concurrent.CordaFuture;
 import net.corda.core.contracts.Amount;
 import net.corda.core.messaging.CordaRPCOps;
 import net.corda.core.messaging.FlowHandle;
@@ -13,7 +12,7 @@ import net.corda.node.internal.Node;
 import net.corda.node.internal.StartedNode;
 import net.corda.nodeapi.User;
 import net.corda.testing.CoreTestUtils;
-import net.corda.testing.node.NodeBasedTest;
+import net.corda.testing.internal.NodeBasedTest;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
@@ -51,8 +50,7 @@ public class CordaRPCJavaClientTest extends NodeBasedTest {
 
     @Before
     public void setUp() throws ExecutionException, InterruptedException {
-        CordaFuture<StartedNode<Node>> nodeFuture = startNotaryNode(getALICE().getName(), singletonList(rpcUser), true);
-        node = nodeFuture.get();
+        node = startNode(getALICE().getName(), 1, singletonList(rpcUser));
         client = new CordaRPCClient(requireNonNull(node.getInternals().getConfiguration().getRpcAddress()));
     }
 

client/rpc/src/integration-test/kotlin/net/corda/client/rpc/BlacklistKotlinClosureTest.kt

@@ -2,89 +2,38 @@ package net.corda.client.rpc
 
 import co.paralleluniverse.fibers.Suspendable
 import com.esotericsoftware.kryo.KryoException
-import net.corda.core.flows.*
-import net.corda.core.identity.Party
+import net.corda.core.flows.FlowLogic
+import net.corda.core.flows.StartableByRPC
 import net.corda.core.messaging.startFlow
 import net.corda.core.serialization.CordaSerializable
 import net.corda.core.utilities.getOrThrow
-import net.corda.core.utilities.loggerFor
-import net.corda.core.utilities.unwrap
-import net.corda.node.internal.Node
-import net.corda.node.internal.StartedNode
-import net.corda.nodeapi.User
-import net.corda.testing.*
-import net.corda.testing.node.NodeBasedTest
-import org.junit.After
-import org.junit.Before
-import org.junit.Rule
+import net.corda.testing.ALICE
+import net.corda.testing.driver.driver
+import org.assertj.core.api.Assertions.assertThatExceptionOfType
 import org.junit.Test
-import org.junit.rules.ExpectedException
 
-@CordaSerializable
-data class Packet(val x: () -> Long)
-
-class BlacklistKotlinClosureTest : NodeBasedTest(listOf("net.corda.client.rpc")) {
+class BlacklistKotlinClosureTest {
     companion object {
-        @Suppress("UNUSED") val logger = loggerFor<BlacklistKotlinClosureTest>()
         const val EVIL: Long = 666
     }
 
     @StartableByRPC
-    @InitiatingFlow
-    class FlowC(private val remoteParty: Party, private val data: Packet) : FlowLogic<Unit>() {
+    class FlowC(@Suppress("unused") private val data: Packet) : FlowLogic<Unit>() {
         @Suspendable
-        override fun call() {
-            val session = initiateFlow(remoteParty)
-            val x = session.sendAndReceive<Packet>(data).unwrap { x -> x }
-            logger.info("FlowC: ${x.x()}")
-        }
+        override fun call() = Unit
     }
 
-    @InitiatedBy(FlowC::class)
-    class RemoteFlowC(private val session: FlowSession) : FlowLogic<Unit>() {
-        @Suspendable
-        override fun call() {
-            val packet = session.receive<Packet>().unwrap { x -> x }
-            logger.info("RemoteFlowC: ${packet.x() + 1}")
-            session.send(Packet({ packet.x() + 1 }))
-        }
-    }
-
-    @JvmField
-    @Rule
-    val expectedEx: ExpectedException = ExpectedException.none()
-
-    private val rpcUser = User("user1", "test", permissions = setOf("ALL"))
-    private lateinit var aliceNode: StartedNode<Node>
-    private lateinit var bobNode: StartedNode<Node>
-    private lateinit var aliceClient: CordaRPCClient
-    private var connection: CordaRPCConnection? = null
-
-    private fun login(username: String, password: String) {
-        connection = aliceClient.start(username, password)
-    }
-
-    @Before
-    fun setUp() {
-        aliceNode = startNode(ALICE.name, rpcUsers = listOf(rpcUser)).getOrThrow()
-        bobNode = startNode(BOB.name, rpcUsers = listOf(rpcUser)).getOrThrow()
-        bobNode.registerInitiatedFlow(RemoteFlowC::class.java)
-        aliceClient = CordaRPCClient(aliceNode.internals.configuration.rpcAddress!!)
-    }
-
-    @After
-    fun done() {
-        connection?.close()
-        bobNode.internals.stop()
-        aliceNode.internals.stop()
-    }
+    @CordaSerializable
+    data class Packet(val x: () -> Long)
 
     @Test
     fun `closure sent via RPC`() {
-        login(rpcUser.username, rpcUser.password)
-        val proxy = connection!!.proxy
-        expectedEx.expect(KryoException::class.java)
-        expectedEx.expectMessage("is not annotated or on the whitelist, so cannot be used in serialization")
-        proxy.startFlow(::FlowC, bobNode.info.chooseIdentity(), Packet{ EVIL }).returnValue.getOrThrow()
+        driver(startNodesInProcess = true) {
+            val rpc = startNode(providedName = ALICE.name).getOrThrow().rpc
+            val packet = Packet { EVIL }
+            assertThatExceptionOfType(KryoException::class.java)
+                    .isThrownBy { rpc.startFlow(::FlowC, packet) }
+                    .withMessageContaining("is not annotated or on the whitelist, so cannot be used in serialization")
+        }
     }
 }

client/rpc/src/integration-test/kotlin/net/corda/client/rpc/CordaRPCClientTest.kt

@@ -24,7 +24,7 @@ import net.corda.node.services.FlowPermissions.Companion.startFlowPermission
 import net.corda.nodeapi.User
 import net.corda.testing.ALICE
 import net.corda.testing.chooseIdentity
-import net.corda.testing.node.NodeBasedTest
+import net.corda.testing.internal.NodeBasedTest
 import org.apache.activemq.artemis.api.core.ActiveMQSecurityException
 import org.assertj.core.api.Assertions.assertThatExceptionOfType
 import org.junit.After
@@ -49,7 +49,7 @@ class CordaRPCClientTest : NodeBasedTest(listOf("net.corda.finance.contracts", C
 
     @Before
     fun setUp() {
-        node = startNotaryNode(ALICE.name, rpcUsers = listOf(rpcUser)).getOrThrow()
+        node = startNode(ALICE.name, rpcUsers = listOf(rpcUser))
         client = CordaRPCClient(node.internals.configuration.rpcAddress!!)
     }