Reducing the size of the CorDapp jars used in tests (#4600)

The helper method enclosedCordapp is a replacement to scanning the current package (which pulls in a lot more into the jar than intended).
2025-06-23 01:19:00 +00:00 · 2019-01-21 13:54:26 +00:00
parent e5d00cf85e
commit c6a7d14f4f
50 changed files with 523 additions and 495 deletions
--- a/core/src/test/java/net/corda/core/flows/FlowsInJavaTest.java
+++ b/core/src/test/java/net/corda/core/flows/FlowsInJavaTest.java
@ -14,14 +14,15 @@ import org.junit.Test;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;

+import static java.util.Collections.singletonList;
 import static net.corda.testing.core.TestUtils.singleIdentity;
-import static net.corda.testing.node.internal.InternalTestUtilsKt.cordappsForPackages;
+import static net.corda.testing.node.internal.InternalTestUtilsKt.enclosedCordapp;
 import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
 import static org.junit.Assert.fail;

 public class FlowsInJavaTest {
    private final MockNetwork mockNet = new MockNetwork(
-            new MockNetworkParameters().withCordappsForAllNodes(cordappsForPackages("net.corda.core.flows"))
+            new MockNetworkParameters().withCordappsForAllNodes(singletonList(enclosedCordapp(this)))
    );
    private StartedMockNode aliceNode;
    private StartedMockNode bobNode;
--- a/core/src/test/kotlin/net/corda/core/contracts/ContractHierarchyTest.kt
+++ b/core/src/test/kotlin/net/corda/core/contracts/ContractHierarchyTest.kt
@ -13,7 +13,7 @@ import net.corda.testing.core.ALICE_NAME
 import net.corda.testing.core.BOB_NAME
 import net.corda.testing.core.singleIdentity
 import net.corda.testing.node.internal.InternalMockNetwork
-import net.corda.testing.node.internal.cordappsForPackages
+import net.corda.testing.node.internal.enclosedCordapp
 import net.corda.testing.node.internal.startFlow
 import org.junit.After
 import org.junit.Before
@ -25,7 +25,7 @@ class ContractHierarchyTest {
    @Before
    fun before() {
        // We run this in parallel threads to help catch any race conditions that may exist.
-        mockNet = InternalMockNetwork(networkSendManuallyPumped = false, threadPerNode = true, cordappsForAllNodes = cordappsForPackages("net.corda.core.contracts"))
+        mockNet = InternalMockNetwork(networkSendManuallyPumped = false, threadPerNode = true, cordappsForAllNodes = listOf(enclosedCordapp()))
    }

    @After
--- a/core/src/test/kotlin/net/corda/core/flows/CollectSignaturesFlowTests.kt
+++ b/core/src/test/kotlin/net/corda/core/flows/CollectSignaturesFlowTests.kt
@ -19,9 +19,10 @@ import net.corda.testing.internal.matchers.flow.willReturn
 import net.corda.testing.internal.matchers.flow.willThrow
 import net.corda.testing.internal.rigorousMock
 import net.corda.testing.node.MockServices
+import net.corda.testing.node.internal.DUMMY_CONTRACTS_CORDAPP
 import net.corda.testing.node.internal.InternalMockNetwork
 import net.corda.testing.node.internal.TestStartedNode
-import net.corda.testing.node.internal.cordappsForPackages
+import net.corda.testing.node.internal.enclosedCordapp
 import org.junit.AfterClass
 import org.junit.Test

@ -29,7 +30,7 @@ class CollectSignaturesFlowTests : WithContracts {
    companion object {
        private val miniCorp = TestIdentity(CordaX500Name("MiniCorp", "London", "GB"))
        private val miniCorpServices = MockServices(listOf("net.corda.testing.contracts"), miniCorp, rigorousMock<IdentityService>())
-        private val classMockNet = InternalMockNetwork(cordappsForAllNodes = cordappsForPackages("net.corda.testing.contracts", "net.corda.core.flows"))
+        private val classMockNet = InternalMockNetwork(cordappsForAllNodes = listOf(DUMMY_CONTRACTS_CORDAPP, enclosedCordapp()))

        private const val MAGIC_NUMBER = 1337

--- a/core/src/test/kotlin/net/corda/core/flows/ContractUpgradeFlowRPCTest.kt
+++ b/core/src/test/kotlin/net/corda/core/flows/ContractUpgradeFlowRPCTest.kt
@ -8,8 +8,6 @@ import com.natpryce.hamkrest.isA
 import net.corda.core.CordaRuntimeException
 import net.corda.core.contracts.ContractState
 import net.corda.core.contracts.StateAndRef
-import net.corda.testing.internal.matchers.rpc.willReturn
-import net.corda.testing.internal.matchers.rpc.willThrow
 import net.corda.core.flows.mixins.WithContracts
 import net.corda.core.flows.mixins.WithFinality
 import net.corda.core.messaging.CordaRPCOps
@ -21,6 +19,8 @@ import net.corda.testing.contracts.DummyContractV2
 import net.corda.testing.core.ALICE_NAME
 import net.corda.testing.core.BOB_NAME
 import net.corda.testing.core.singleIdentity
+import net.corda.testing.internal.matchers.rpc.willReturn
+import net.corda.testing.internal.matchers.rpc.willThrow
 import net.corda.testing.node.User
 import net.corda.testing.node.internal.*
 import org.junit.AfterClass
@ -28,7 +28,7 @@ import org.junit.Test

 class ContractUpgradeFlowRPCTest : WithContracts, WithFinality {
    companion object {
-        private val classMockNet = InternalMockNetwork(cordappsForAllNodes = cordappsForPackages("net.corda.testing.contracts", "net.corda.finance.contracts.asset", "net.corda.core.flows"))
+        private val classMockNet = InternalMockNetwork(cordappsForAllNodes = listOf(DUMMY_CONTRACTS_CORDAPP, enclosedCordapp()))

        @JvmStatic
        @AfterClass
--- a/core/src/test/kotlin/net/corda/core/flows/ContractUpgradeFlowTest.kt
+++ b/core/src/test/kotlin/net/corda/core/flows/ContractUpgradeFlowTest.kt
@ -23,17 +23,15 @@ import net.corda.testing.core.BOB_NAME
 import net.corda.testing.core.singleIdentity
 import net.corda.testing.internal.matchers.flow.willReturn
 import net.corda.testing.internal.matchers.flow.willThrow
-import net.corda.testing.node.internal.InternalMockNetwork
-import net.corda.testing.node.internal.TestStartedNode
-import net.corda.testing.node.internal.cordappsForPackages
-import net.corda.testing.node.internal.startFlow
+import net.corda.testing.node.internal.*
 import org.junit.AfterClass
 import org.junit.Test
 import java.util.*

 class ContractUpgradeFlowTest : WithContracts, WithFinality {
+
    companion object {
-        private val classMockNet = InternalMockNetwork(cordappsForAllNodes = cordappsForPackages("net.corda.testing.contracts", "net.corda.finance.contracts.asset", "net.corda.core.flows", "net.corda.finance.schemas"))
+        private val classMockNet = InternalMockNetwork(cordappsForAllNodes = listOf(FINANCE_CONTRACTS_CORDAPP, DUMMY_CONTRACTS_CORDAPP, enclosedCordapp()))

        @JvmStatic
        @AfterClass
--- a/core/src/test/kotlin/net/corda/core/flows/FinalityFlowTests.kt
+++ b/core/src/test/kotlin/net/corda/core/flows/FinalityFlowTests.kt
@ -26,11 +26,7 @@ class FinalityFlowTests : WithFinality {
        private val CHARLIE = TestIdentity(CHARLIE_NAME, 90).party
    }

-    override val mockNet = InternalMockNetwork(cordappsForAllNodes = cordappsForPackages(
-            "net.corda.finance.contracts.asset",
-            "net.corda.finance.schemas",
-            "net.corda.core.flows.mixins"
-    ))
+    override val mockNet = InternalMockNetwork(cordappsForAllNodes = listOf(FINANCE_CONTRACTS_CORDAPP, enclosedCordapp()))

    private val aliceNode = makeNode(ALICE_NAME)

--- a/core/src/test/kotlin/net/corda/core/flows/WithReferencedStatesFlowTests.kt
+++ b/core/src/test/kotlin/net/corda/core/flows/WithReferencedStatesFlowTests.kt
@ -14,111 +14,16 @@ import net.corda.core.transactions.TransactionBuilder
 import net.corda.core.utilities.getOrThrow
 import net.corda.node.VersionInfo
 import net.corda.testing.common.internal.testNetworkParameters
-import net.corda.testing.node.internal.InternalMockNetwork
-import net.corda.testing.node.internal.InternalMockNodeParameters
-import net.corda.testing.node.internal.cordappsForPackages
-import net.corda.testing.node.internal.startFlow
+import net.corda.testing.node.internal.*
 import org.junit.After
 import org.junit.Test
 import kotlin.test.assertEquals

-// A dummy reference state contract.
-internal class RefState : Contract {
-    companion object {
-        const val CONTRACT_ID = "net.corda.core.flows.RefState"
-    }
-
-    override fun verify(tx: LedgerTransaction) = Unit
-
-    data class State(val owner: Party, val version: Int = 0, override val linearId: UniqueIdentifier = UniqueIdentifier()) : LinearState {
-        override val participants: List<AbstractParty> get() = listOf(owner)
-        fun update() = copy(version = version + 1)
-    }
-
-    class Create : CommandData
-    class Update : CommandData
-}
-
-// A flow to create a reference state.
-internal class CreateRefState : FlowLogic<SignedTransaction>() {
-    @Suspendable
-    override fun call(): SignedTransaction {
-        val notary = serviceHub.networkMapCache.notaryIdentities.first()
-        val stx = serviceHub.signInitialTransaction(TransactionBuilder(notary = notary).apply {
-            addOutputState(RefState.State(ourIdentity), RefState.CONTRACT_ID)
-            addCommand(RefState.Create(), listOf(ourIdentity.owningKey))
-        })
-        return subFlow(FinalityFlow(stx, emptyList()))
-    }
-}
-
-// A flow to update a specific reference state.
-internal class UpdateRefState(private val stateAndRef: StateAndRef<RefState.State>) : FlowLogic<SignedTransaction>() {
-    @Suspendable
-    override fun call(): SignedTransaction {
-        val notary = serviceHub.networkMapCache.notaryIdentities.first()
-        val stx = serviceHub.signInitialTransaction(TransactionBuilder(notary = notary).apply {
-            addInputState(stateAndRef)
-            addOutputState(stateAndRef.state.data.update(), RefState.CONTRACT_ID)
-            addCommand(RefState.Update(), listOf(ourIdentity.owningKey))
-        })
-        return subFlow(FinalityFlow(stx, emptyList()))
-    }
-}
-
-// A set of flows to share a stateref with all other nodes in the mock network.
-internal object ShareRefState {
-    @InitiatingFlow
-    class Initiator(private val stateAndRef: StateAndRef<ContractState>) : FlowLogic<Unit>() {
-        @Suspendable
-        override fun call() {
-            val sessions = serviceHub.networkMapCache.allNodes.flatMap { it.legalIdentities }.map { initiateFlow(it) }
-            val transactionId = stateAndRef.ref.txhash
-            val transaction = serviceHub.validatedTransactions.getTransaction(transactionId)
-                    ?: throw FlowException("Cannot find $transactionId.")
-            sessions.forEach { subFlow(SendTransactionFlow(it, transaction)) }
-        }
-    }
-
-    @InitiatedBy(ShareRefState.Initiator::class)
-    class Responder(private val otherSession: FlowSession) : FlowLogic<Unit>() {
-        @Suspendable
-        override fun call() {
-            logger.info("Receiving dependencies.")
-            subFlow(ReceiveTransactionFlow(
-                    otherSideSession = otherSession,
-                    checkSufficientSignatures = true,
-                    statesToRecord = StatesToRecord.ALL_VISIBLE
-            ))
-        }
-    }
-}
-
-// A flow to use a reference state in another transaction.
-internal class UseRefState(private val linearId: UniqueIdentifier) : FlowLogic<SignedTransaction>() {
-    @Suspendable
-    override fun call(): SignedTransaction {
-        val notary = serviceHub.networkMapCache.notaryIdentities.first()
-        val query = QueryCriteria.LinearStateQueryCriteria(
-                linearId = listOf(linearId),
-                relevancyStatus = Vault.RelevancyStatus.ALL
-        )
-        val referenceState = serviceHub.vaultService.queryBy<ContractState>(query).states.single()
-
-        val stx = serviceHub.signInitialTransaction(TransactionBuilder(notary = notary).apply {
-            addReferenceState(referenceState.referenced())
-            addOutputState(RefState.State(ourIdentity), RefState.CONTRACT_ID)
-            addCommand(RefState.Create(), listOf(ourIdentity.owningKey))
-        })
-        return subFlow(FinalityFlow(stx, emptyList()))
-    }
-}
-
 class WithReferencedStatesFlowTests {
    companion object {
        @JvmStatic
        private val mockNet = InternalMockNetwork(
-                cordappsForAllNodes = cordappsForPackages("net.corda.core.flows", "net.corda.testing.contracts"),
+                cordappsForAllNodes = listOf(DUMMY_CONTRACTS_CORDAPP, enclosedCordapp()),
                threadPerNode = true,
                initialNetworkParameters = testNetworkParameters(minimumPlatformVersion = 4)
        )
@ -142,7 +47,7 @@ class WithReferencedStatesFlowTests {
        val newRefState = newRefTx.tx.outRefsOfType<RefState.State>().single()

        // 2. Share it with others.
-        nodes[0].services.startFlow(ShareRefState.Initiator(newRefState)).resultFuture.getOrThrow()
+        nodes[0].services.startFlow(Initiator(newRefState)).resultFuture.getOrThrow()

        // 3. Update the reference state but don't share the update.
        val updatedRefTx = nodes[0].services.startFlow(UpdateRefState(newRefState)).resultFuture.getOrThrow()
@ -152,10 +57,100 @@ class WithReferencedStatesFlowTests {
        val useRefTx = nodes[1].services.startFlow(WithReferencedStatesFlow { UseRefState(newRefState.state.data.linearId) }).resultFuture

        // 5. Share the update reference state.
-        nodes[0].services.startFlow(ShareRefState.Initiator(updatedRefState)).resultFuture.getOrThrow()
+        nodes[0].services.startFlow(Initiator(updatedRefState)).resultFuture.getOrThrow()

        // 6. Check that we have a valid signed transaction with the updated reference state.
        val result = useRefTx.getOrThrow()
        assertEquals(updatedRefState.ref, result.tx.references.single())
    }
+
+    // A dummy reference state contract.
+    class RefState : Contract {
+        companion object {
+            val CONTRACT_ID: String = RefState::class.java.name
+        }
+
+        override fun verify(tx: LedgerTransaction) = Unit
+
+        data class State(val owner: Party, val version: Int = 0, override val linearId: UniqueIdentifier = UniqueIdentifier()) : LinearState {
+            override val participants: List<AbstractParty> get() = listOf(owner)
+            fun update() = copy(version = version + 1)
+        }
+
+        class Create : CommandData
+        class Update : CommandData
+    }
+
+    // A flow to create a reference state.
+    class CreateRefState : FlowLogic<SignedTransaction>() {
+        @Suspendable
+        override fun call(): SignedTransaction {
+            val notary = serviceHub.networkMapCache.notaryIdentities.first()
+            val stx = serviceHub.signInitialTransaction(TransactionBuilder(notary = notary).apply {
+                addOutputState(RefState.State(ourIdentity), RefState.CONTRACT_ID)
+                addCommand(RefState.Create(), listOf(ourIdentity.owningKey))
+            })
+            return subFlow(FinalityFlow(stx, emptyList()))
+        }
+    }
+
+    // A flow to update a specific reference state.
+    class UpdateRefState(private val stateAndRef: StateAndRef<RefState.State>) : FlowLogic<SignedTransaction>() {
+        @Suspendable
+        override fun call(): SignedTransaction {
+            val notary = serviceHub.networkMapCache.notaryIdentities.first()
+            val stx = serviceHub.signInitialTransaction(TransactionBuilder(notary = notary).apply {
+                addInputState(stateAndRef)
+                addOutputState(stateAndRef.state.data.update(), RefState.CONTRACT_ID)
+                addCommand(RefState.Update(), listOf(ourIdentity.owningKey))
+            })
+            return subFlow(FinalityFlow(stx, emptyList()))
+        }
+    }
+
+    // A set of flows to share a stateref with all other nodes in the mock network.
+    @InitiatingFlow
+    class Initiator(private val stateAndRef: StateAndRef<ContractState>) : FlowLogic<Unit>() {
+        @Suspendable
+        override fun call() {
+            val sessions = serviceHub.networkMapCache.allNodes.flatMap { it.legalIdentities }.map { initiateFlow(it) }
+            val transactionId = stateAndRef.ref.txhash
+            val transaction = serviceHub.validatedTransactions.getTransaction(transactionId)
+                    ?: throw FlowException("Cannot find $transactionId.")
+            sessions.forEach { subFlow(SendTransactionFlow(it, transaction)) }
+        }
+    }
+
+    @InitiatedBy(Initiator::class)
+    class Responder(private val otherSession: FlowSession) : FlowLogic<Unit>() {
+        @Suspendable
+        override fun call() {
+            logger.info("Receiving dependencies.")
+            subFlow(ReceiveTransactionFlow(
+                    otherSideSession = otherSession,
+                    checkSufficientSignatures = true,
+                    statesToRecord = StatesToRecord.ALL_VISIBLE
+            ))
+        }
+    }
+
+    // A flow to use a reference state in another transaction.
+    class UseRefState(private val linearId: UniqueIdentifier) : FlowLogic<SignedTransaction>() {
+        @Suspendable
+        override fun call(): SignedTransaction {
+            val notary = serviceHub.networkMapCache.notaryIdentities.first()
+            val query = QueryCriteria.LinearStateQueryCriteria(
+                    linearId = listOf(linearId),
+                    relevancyStatus = Vault.RelevancyStatus.ALL
+            )
+            val referenceState = serviceHub.vaultService.queryBy<ContractState>(query).states.single()
+
+            val stx = serviceHub.signInitialTransaction(TransactionBuilder(notary = notary).apply {
+                addReferenceState(referenceState.referenced())
+                addOutputState(RefState.State(ourIdentity), RefState.CONTRACT_ID)
+                addCommand(RefState.Create(), listOf(ourIdentity.owningKey))
+            })
+            return subFlow(FinalityFlow(stx, emptyList()))
+        }
+    }
 }
--- a/core/src/test/kotlin/net/corda/core/internal/ResolveTransactionsFlowTest.kt
+++ b/core/src/test/kotlin/net/corda/core/internal/ResolveTransactionsFlowTest.kt
@ -15,7 +15,8 @@ import net.corda.testing.core.singleIdentity
 import net.corda.testing.node.MockNetwork
 import net.corda.testing.node.MockNetworkParameters
 import net.corda.testing.node.StartedMockNode
-import net.corda.testing.node.internal.cordappsForPackages
+import net.corda.testing.node.internal.DUMMY_CONTRACTS_CORDAPP
+import net.corda.testing.node.internal.enclosedCordapp
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
@ -40,7 +41,7 @@ class ResolveTransactionsFlowTest {

    @Before
    fun setup() {
-        mockNet = MockNetwork(MockNetworkParameters(cordappsForAllNodes = cordappsForPackages("net.corda.testing.contracts", javaClass.packageName)))
+        mockNet = MockNetwork(MockNetworkParameters(cordappsForAllNodes = listOf(DUMMY_CONTRACTS_CORDAPP, enclosedCordapp())))
        notaryNode = mockNet.defaultNotaryNode
        megaCorpNode = mockNet.createPartyNode(CordaX500Name("MegaCorp", "London", "GB"))
        miniCorpNode = mockNet.createPartyNode(CordaX500Name("MiniCorp", "London", "GB"))