ExternalVendorCode/corda
1
0
Fork 0
mirror of https://github.com/corda/corda.git synced 2024-12-21 13:57:54 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

ENT-5196 handle errors during flow initialisation (#6378)

Browse Source 
Update flow error handling tests after merging from earlier releases
This commit is contained in:
LankyDan 2020-07-08 16:02:17 +01:00
parent b05c0f0cc1
commit b6d649634f
8 changed files with 127 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
node/src/integration-test-slow/kotlin/net/corda/node/services/statemachine/StateMachineErrorHandlingTest.kt
View File

@ -127,10 +127,21 @@ abstract class StateMachineErrorHandlingTest {
internal fun CordaRPCOps.assertHospitalCountsAllZero() = assertHospitalCounts() internal fun CordaRPCOps.assertHospitalCountsAllZero() = assertHospitalCounts()
internal fun CordaRPCOps.assertNumberOfCheckpoints(number: Long) { internal fun CordaRPCOps.assertNumberOfCheckpoints(
assertEquals(number, startFlow(StateMachineErrorHandlingTest::GetNumberOfCheckpointsFlow).returnValue.get()) runnable: Int = 0,
failed: Int = 0,
completed: Int = 0,
hospitalized: Int = 0
) {
val counts = startFlow(StateMachineErrorHandlingTest::GetNumberOfCheckpointsFlow).returnValue.getOrThrow(20.seconds)
assertEquals(runnable, counts.runnable, "There should be $runnable runnable checkpoints")
assertEquals(failed, counts.failed, "There should be $failed failed checkpoints")
assertEquals(completed, counts.completed, "There should be $completed completed checkpoints")
assertEquals(hospitalized, counts.hospitalized, "There should be $hospitalized hospitalized checkpoints")
} }
internal fun CordaRPCOps.assertNumberOfCheckpointsAllZero() = assertNumberOfCheckpoints()
@StartableByRPC @StartableByRPC
@InitiatingFlow @InitiatingFlow
class SendAMessageFlow(private val party: Party) : FlowLogic<String>() { class SendAMessageFlow(private val party: Party) : FlowLogic<String>() {
@ -181,44 +192,37 @@ abstract class StateMachineErrorHandlingTest {
} }
@StartableByRPC @StartableByRPC
class ThrowAnErrorFlow : FlowLogic<String>() { class GetNumberOfCheckpointsFlow : FlowLogic<NumberOfCheckpoints>() {
@Suspendable override fun call() = NumberOfCheckpoints(
override fun call(): String { runnable = getNumberOfCheckpointsWithStatus(Checkpoint.FlowStatus.RUNNABLE),
throwException() failed = getNumberOfCheckpointsWithStatus(Checkpoint.FlowStatus.FAILED),
return "cant get here" completed = getNumberOfCheckpointsWithStatus(Checkpoint.FlowStatus.COMPLETED),
} hospitalized = getNumberOfCheckpointsWithStatus(Checkpoint.FlowStatus.HOSPITALIZED)
)
private fun throwException() { private fun getNumberOfCheckpointsWithStatus(status: Checkpoint.FlowStatus): Int {
logger.info("Throwing exception in flow") return serviceHub.jdbcSession()
throw IllegalStateException("throwing exception in flow") .prepareStatement("select count(*) from node_checkpoints where status = ? and flow_id != ?")
} .apply {
} setInt(1, status.ordinal)
setString(2, runId.uuid.toString())
@StartableByRPC
class GetNumberOfUncompletedCheckpointsFlow : FlowLogic<Long>() {
override fun call(): Long {
val sqlStatement = "select count(*) from node_checkpoints where status not in (${Checkpoint.FlowStatus.COMPLETED.ordinal})"
return serviceHub.jdbcSession().prepareStatement(sqlStatement).use { ps ->
ps.executeQuery().use { rs ->
rs.next()
rs.getLong(1)
} }
} .use { ps ->
ps.executeQuery().use { rs ->
rs.next()
rs.getLong(1)
}
}.toInt()
} }
} }
@StartableByRPC @CordaSerializable
class GetNumberOfHospitalizedCheckpointsFlow : FlowLogic<Long>() { data class NumberOfCheckpoints(
override fun call(): Long { val runnable: Int = 0,
val sqlStatement = "select count(*) from node_checkpoints where status in (${Checkpoint.FlowStatus.HOSPITALIZED.ordinal})" val failed: Int = 0,
return serviceHub.jdbcSession().prepareStatement(sqlStatement).use { ps -> val completed: Int = 0,
ps.executeQuery().use { rs -> val hospitalized: Int = 0
rs.next() )
rs.getLong(1)
}
}
}
}
// Internal use for testing only!! // Internal use for testing only!!
@StartableByRPC @StartableByRPC

19
node/src/integration-test-slow/kotlin/net/corda/node/services/statemachine/StateMachineFinalityErrorHandlingTest.kt
View File

@ -77,11 +77,11 @@ class StateMachineFinalityErrorHandlingTest : StateMachineErrorHandlingTest() {
defaultNotaryIdentity defaultNotaryIdentity
).returnValue.getOrThrow(30.seconds) ).returnValue.getOrThrow(30.seconds)
alice.rpc.assertNumberOfCheckpointsAllZero()
charlie.rpc.assertNumberOfCheckpoints(hospitalized = 1)
charlie.rpc.assertHospitalCounts(observation = 1) charlie.rpc.assertHospitalCounts(observation = 1)
assertEquals(0, alice.rpc.stateMachinesSnapshot().size) assertEquals(0, alice.rpc.stateMachinesSnapshot().size)
assertEquals(1, charlie.rpc.stateMachinesSnapshot().size) assertEquals(1, charlie.rpc.stateMachinesSnapshot().size)
alice.rpc.assertNumberOfCheckpoints(0)
charlie.rpc.assertNumberOfCheckpoints(1)
} }
} }
@ -139,11 +139,11 @@ class StateMachineFinalityErrorHandlingTest : StateMachineErrorHandlingTest() {
defaultNotaryIdentity defaultNotaryIdentity
).returnValue.getOrThrow(30.seconds) ).returnValue.getOrThrow(30.seconds)
alice.rpc.assertNumberOfCheckpointsAllZero()
charlie.rpc.assertNumberOfCheckpoints(hospitalized = 1)
charlie.rpc.assertHospitalCounts(observation = 1) charlie.rpc.assertHospitalCounts(observation = 1)
assertEquals(0, alice.rpc.stateMachinesSnapshot().size) assertEquals(0, alice.rpc.stateMachinesSnapshot().size)
assertEquals(1, charlie.rpc.stateMachinesSnapshot().size) assertEquals(1, charlie.rpc.stateMachinesSnapshot().size)
alice.rpc.assertNumberOfCheckpoints(0)
charlie.rpc.assertNumberOfCheckpoints(1)
} }
} }
@ -201,11 +201,14 @@ class StateMachineFinalityErrorHandlingTest : StateMachineErrorHandlingTest() {
defaultNotaryIdentity defaultNotaryIdentity
).returnValue.getOrThrow(30.seconds) ).returnValue.getOrThrow(30.seconds)
// This sleep is a bit suspect...
Thread.sleep(1000)
alice.rpc.assertNumberOfCheckpointsAllZero()
charlie.rpc.assertNumberOfCheckpointsAllZero()
charlie.rpc.assertHospitalCounts(discharged = 3) charlie.rpc.assertHospitalCounts(discharged = 3)
assertEquals(0, alice.rpc.stateMachinesSnapshot().size) assertEquals(0, alice.rpc.stateMachinesSnapshot().size)
assertEquals(0, charlie.rpc.stateMachinesSnapshot().size) assertEquals(0, charlie.rpc.stateMachinesSnapshot().size)
alice.rpc.assertNumberOfCheckpoints(0)
charlie.rpc.assertNumberOfCheckpoints(0)
} }
} }
@ -268,14 +271,14 @@ class StateMachineFinalityErrorHandlingTest : StateMachineErrorHandlingTest() {
).returnValue.getOrThrow(30.seconds) ).returnValue.getOrThrow(30.seconds)
} }
alice.rpc.assertNumberOfCheckpoints(runnable = 1)
charlie.rpc.assertNumberOfCheckpoints(hospitalized = 1)
charlie.rpc.assertHospitalCounts( charlie.rpc.assertHospitalCounts(
discharged = 3, discharged = 3,
observation = 1 observation = 1
) )
assertEquals(1, alice.rpc.stateMachinesSnapshot().size) assertEquals(1, alice.rpc.stateMachinesSnapshot().size)
assertEquals(1, charlie.rpc.stateMachinesSnapshot().size) assertEquals(1, charlie.rpc.stateMachinesSnapshot().size)
alice.rpc.assertNumberOfCheckpoints(1)
charlie.rpc.assertNumberOfCheckpoints(1)
} }
} }
} }

68
node/src/integration-test-slow/kotlin/net/corda/node/services/statemachine/StateMachineFlowInitErrorHandlingTest.kt
View File

@ -45,7 +45,7 @@ class StateMachineFlowInitErrorHandlingTest : StateMachineErrorHandlingTest() {
val rules = """ val rules = """
RULE Create Counter RULE Create Counter
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF createCounter("counter", $counter) IF createCounter("counter", $counter)
@ -53,7 +53,7 @@ class StateMachineFlowInitErrorHandlingTest : StateMachineErrorHandlingTest() {
ENDRULE ENDRULE
RULE Throw exception on executeCommitTransaction action RULE Throw exception on executeCommitTransaction action
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF readCounter("counter") < 3 IF readCounter("counter") < 3
@ -70,9 +70,9 @@ class StateMachineFlowInitErrorHandlingTest : StateMachineErrorHandlingTest() {
30.seconds 30.seconds
) )
alice.rpc.assertNumberOfCheckpointsAllZero()
alice.rpc.assertHospitalCounts(discharged = 3) alice.rpc.assertHospitalCounts(discharged = 3)
assertEquals(0, alice.rpc.stateMachinesSnapshot().size) assertEquals(0, alice.rpc.stateMachinesSnapshot().size)
alice.rpc.assertNumberOfCheckpoints(0)
} }
} }
@ -117,9 +117,9 @@ class StateMachineFlowInitErrorHandlingTest : StateMachineErrorHandlingTest() {
).returnValue.getOrThrow(30.seconds) ).returnValue.getOrThrow(30.seconds)
} }
alice.rpc.assertNumberOfCheckpoints(failed = 1)
alice.rpc.assertHospitalCounts(propagated = 1) alice.rpc.assertHospitalCounts(propagated = 1)
assertEquals(0, alice.rpc.stateMachinesSnapshot().size) assertEquals(0, alice.rpc.stateMachinesSnapshot().size)
alice.rpc.assertNumberOfCheckpoints(0)
} }
} }
@ -139,7 +139,7 @@ class StateMachineFlowInitErrorHandlingTest : StateMachineErrorHandlingTest() {
val rules = """ val rules = """
RULE Create Counter RULE Create Counter
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF createCounter("counter", $counter) IF createCounter("counter", $counter)
@ -147,7 +147,7 @@ class StateMachineFlowInitErrorHandlingTest : StateMachineErrorHandlingTest() {
ENDRULE ENDRULE
RULE Throw exception on executeCommitTransaction action RULE Throw exception on executeCommitTransaction action
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF readCounter("counter") == 0 IF readCounter("counter") == 0
@ -170,9 +170,9 @@ class StateMachineFlowInitErrorHandlingTest : StateMachineErrorHandlingTest() {
charlie.nodeInfo.singleIdentity() charlie.nodeInfo.singleIdentity()
).returnValue.getOrThrow(30.seconds) ).returnValue.getOrThrow(30.seconds)
alice.rpc.assertNumberOfCheckpointsAllZero()
alice.rpc.assertHospitalCounts(discharged = 1) alice.rpc.assertHospitalCounts(discharged = 1)
assertEquals(0, alice.rpc.stateMachinesSnapshot().size) assertEquals(0, alice.rpc.stateMachinesSnapshot().size)
alice.rpc.assertNumberOfCheckpoints(0)
} }
} }
@ -192,7 +192,7 @@ class StateMachineFlowInitErrorHandlingTest : StateMachineErrorHandlingTest() {
val rules = """ val rules = """
RULE Create Counter RULE Create Counter
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF createCounter("counter", $counter) IF createCounter("counter", $counter)
@ -200,7 +200,7 @@ class StateMachineFlowInitErrorHandlingTest : StateMachineErrorHandlingTest() {
ENDRULE ENDRULE
RULE Throw exception on executeCommitTransaction action RULE Throw exception on executeCommitTransaction action
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF readCounter("counter") == 0 IF readCounter("counter") == 0
@ -223,9 +223,9 @@ class StateMachineFlowInitErrorHandlingTest : StateMachineErrorHandlingTest() {
charlie.nodeInfo.singleIdentity() charlie.nodeInfo.singleIdentity()
).returnValue.getOrThrow(30.seconds) ).returnValue.getOrThrow(30.seconds)
alice.rpc.assertNumberOfCheckpointsAllZero()
alice.rpc.assertHospitalCounts(discharged = 1) alice.rpc.assertHospitalCounts(discharged = 1)
assertEquals(0, alice.rpc.stateMachinesSnapshot().size) assertEquals(0, alice.rpc.stateMachinesSnapshot().size)
alice.rpc.assertNumberOfCheckpoints(0)
} }
} }
@ -247,7 +247,7 @@ class StateMachineFlowInitErrorHandlingTest : StateMachineErrorHandlingTest() {
val rules = """ val rules = """
RULE Create Counter RULE Create Counter
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF createCounter("counter", $counter) IF createCounter("counter", $counter)
@ -255,7 +255,7 @@ class StateMachineFlowInitErrorHandlingTest : StateMachineErrorHandlingTest() {
ENDRULE ENDRULE
RULE Throw exception on executeCommitTransaction action RULE Throw exception on executeCommitTransaction action
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF readCounter("counter") < 4 IF readCounter("counter") < 4
@ -272,17 +272,17 @@ class StateMachineFlowInitErrorHandlingTest : StateMachineErrorHandlingTest() {
// flow is not signaled as started calls to [getOrThrow] will hang, sleeping instead // flow is not signaled as started calls to [getOrThrow] will hang, sleeping instead
Thread.sleep(30.seconds.toMillis()) Thread.sleep(30.seconds.toMillis())
alice.rpc.assertNumberOfCheckpoints(hospitalized = 1)
alice.rpc.assertHospitalCounts( alice.rpc.assertHospitalCounts(
discharged = 3, discharged = 3,
observation = 1 observation = 1
) )
assertEquals(1, alice.rpc.stateMachinesSnapshot().size) assertEquals(1, alice.rpc.stateMachinesSnapshot().size)
alice.rpc.assertNumberOfCheckpoints(0)
val terminated = (alice as OutOfProcessImpl).stop(60.seconds) val terminated = (alice as OutOfProcessImpl).stop(60.seconds)
assertTrue(terminated, "The node must be shutdown before it can be restarted") assertTrue(terminated, "The node must be shutdown before it can be restarted")
val (alice2, _) = createBytemanNode(ALICE_NAME) val (alice2, _) = createBytemanNode(ALICE_NAME)
Thread.sleep(10.seconds.toMillis()) Thread.sleep(20.seconds.toMillis())
alice2.rpc.assertNumberOfCheckpoints(0) alice2.rpc.assertNumberOfCheckpointsAllZero()
} }
} }
@ -303,7 +303,7 @@ class StateMachineFlowInitErrorHandlingTest : StateMachineErrorHandlingTest() {
val rules = """ val rules = """
RULE Throw exception on executeCommitTransaction action after first suspend + commit RULE Throw exception on executeCommitTransaction action after first suspend + commit
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF !flagged("commit_exception_flag") IF !flagged("commit_exception_flag")
@ -311,7 +311,7 @@ class StateMachineFlowInitErrorHandlingTest : StateMachineErrorHandlingTest() {
ENDRULE ENDRULE
RULE Throw exception on retry RULE Throw exception on retry
CLASS ${SingleThreadedStateMachineManager::class.java.name} CLASS $stateMachineManagerClassName
METHOD onExternalStartFlow METHOD onExternalStartFlow
AT ENTRY AT ENTRY
IF flagged("commit_exception_flag") && !flagged("retry_exception_flag") IF flagged("commit_exception_flag") && !flagged("retry_exception_flag")
@ -328,12 +328,12 @@ class StateMachineFlowInitErrorHandlingTest : StateMachineErrorHandlingTest() {
30.seconds 30.seconds
) )
alice.rpc.assertNumberOfCheckpointsAllZero()
alice.rpc.assertHospitalCounts( alice.rpc.assertHospitalCounts(
discharged = 1, discharged = 1,
dischargedRetry = 1 dischargedRetry = 1
) )
assertEquals(0, alice.rpc.stateMachinesSnapshot().size) assertEquals(0, alice.rpc.stateMachinesSnapshot().size)
alice.rpc.assertNumberOfCheckpoints(0)
} }
} }
@ -356,7 +356,7 @@ class StateMachineFlowInitErrorHandlingTest : StateMachineErrorHandlingTest() {
val rules = """ val rules = """
RULE Create Counter RULE Create Counter
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF createCounter("counter", $counter) IF createCounter("counter", $counter)
@ -364,7 +364,7 @@ class StateMachineFlowInitErrorHandlingTest : StateMachineErrorHandlingTest() {
ENDRULE ENDRULE
RULE Throw exception on executeCommitTransaction action RULE Throw exception on executeCommitTransaction action
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF readCounter("counter") < 3 IF readCounter("counter") < 3
@ -381,9 +381,9 @@ class StateMachineFlowInitErrorHandlingTest : StateMachineErrorHandlingTest() {
30.seconds 30.seconds
) )
alice.rpc.assertNumberOfCheckpointsAllZero()
charlie.rpc.assertNumberOfCheckpointsAllZero()
charlie.rpc.assertHospitalCounts(discharged = 3) charlie.rpc.assertHospitalCounts(discharged = 3)
alice.rpc.assertNumberOfCheckpoints(0)
charlie.rpc.assertNumberOfCheckpoints(0)
} }
} }
@ -405,7 +405,7 @@ class StateMachineFlowInitErrorHandlingTest : StateMachineErrorHandlingTest() {
val rules = """ val rules = """
RULE Create Counter RULE Create Counter
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF createCounter("counter", $counter) IF createCounter("counter", $counter)
@ -413,7 +413,7 @@ class StateMachineFlowInitErrorHandlingTest : StateMachineErrorHandlingTest() {
ENDRULE ENDRULE
RULE Throw exception on executeCommitTransaction action RULE Throw exception on executeCommitTransaction action
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF readCounter("counter") < 4 IF readCounter("counter") < 4
@ -430,20 +430,20 @@ class StateMachineFlowInitErrorHandlingTest : StateMachineErrorHandlingTest() {
// flow is not signaled as started calls to [getOrThrow] will hang, sleeping instead // flow is not signaled as started calls to [getOrThrow] will hang, sleeping instead
Thread.sleep(30.seconds.toMillis()) Thread.sleep(30.seconds.toMillis())
alice.rpc.assertNumberOfCheckpoints(runnable = 1)
charlie.rpc.assertNumberOfCheckpoints(hospitalized = 1)
charlie.rpc.assertHospitalCounts( charlie.rpc.assertHospitalCounts(
discharged = 3, discharged = 3,
observation = 1 observation = 1
) )
assertEquals(1, alice.rpc.stateMachinesSnapshot().size) assertEquals(1, alice.rpc.stateMachinesSnapshot().size)
assertEquals(1, charlie.rpc.stateMachinesSnapshot().size) assertEquals(1, charlie.rpc.stateMachinesSnapshot().size)
alice.rpc.assertNumberOfCheckpoints(1)
charlie.rpc.assertNumberOfCheckpoints(0)
val terminated = (charlie as OutOfProcessImpl).stop(60.seconds) val terminated = (charlie as OutOfProcessImpl).stop(60.seconds)
assertTrue(terminated, "The node must be shutdown before it can be restarted") assertTrue(terminated, "The node must be shutdown before it can be restarted")
val (charlie2, _) = createBytemanNode(CHARLIE_NAME) val (charlie2, _) = createBytemanNode(CHARLIE_NAME)
Thread.sleep(10.seconds.toMillis()) Thread.sleep(10.seconds.toMillis())
alice.rpc.assertNumberOfCheckpoints(0) alice.rpc.assertNumberOfCheckpointsAllZero()
charlie2.rpc.assertNumberOfCheckpoints(0) charlie2.rpc.assertNumberOfCheckpointsAllZero()
} }
} }
@ -469,7 +469,7 @@ class StateMachineFlowInitErrorHandlingTest : StateMachineErrorHandlingTest() {
val rules = """ val rules = """
RULE Create Counter RULE Create Counter
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF createCounter("counter", $counter) IF createCounter("counter", $counter)
@ -477,7 +477,7 @@ class StateMachineFlowInitErrorHandlingTest : StateMachineErrorHandlingTest() {
ENDRULE ENDRULE
RULE Throw exception on executeCommitTransaction action RULE Throw exception on executeCommitTransaction action
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF readCounter("counter") < 3 IF readCounter("counter") < 3
@ -502,13 +502,13 @@ class StateMachineFlowInitErrorHandlingTest : StateMachineErrorHandlingTest() {
30.seconds 30.seconds
) )
alice.rpc.assertNumberOfCheckpointsAllZero()
charlie.rpc.assertHospitalCounts( charlie.rpc.assertHospitalCounts(
discharged = 3, discharged = 3,
observation = 0 observation = 0
) )
assertEquals(0, alice.rpc.stateMachinesSnapshot().size) assertEquals(0, alice.rpc.stateMachinesSnapshot().size)
assertEquals(0, charlie.rpc.stateMachinesSnapshot().size) assertEquals(0, charlie.rpc.stateMachinesSnapshot().size)
assertEquals(0, charlie.rpc.startFlow(StateMachineErrorHandlingTest::GetNumberOfCheckpointsFlow).returnValue.get())
} }
} }
@ -534,7 +534,7 @@ class StateMachineFlowInitErrorHandlingTest : StateMachineErrorHandlingTest() {
val rules = """ val rules = """
RULE Create Counter RULE Create Counter
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF createCounter("counter", $counter) IF createCounter("counter", $counter)
@ -542,7 +542,7 @@ class StateMachineFlowInitErrorHandlingTest : StateMachineErrorHandlingTest() {
ENDRULE ENDRULE
RULE Throw exception on executeCommitTransaction action RULE Throw exception on executeCommitTransaction action
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF readCounter("counter") < 4 IF readCounter("counter") < 4
@ -569,13 +569,13 @@ class StateMachineFlowInitErrorHandlingTest : StateMachineErrorHandlingTest() {
) )
} }
charlie.rpc.assertNumberOfCheckpoints(hospitalized = 1)
charlie.rpc.assertHospitalCounts( charlie.rpc.assertHospitalCounts(
discharged = 3, discharged = 3,
observation = 1 observation = 1
) )
assertEquals(1, alice.rpc.stateMachinesSnapshot().size) assertEquals(1, alice.rpc.stateMachinesSnapshot().size)
assertEquals(1, charlie.rpc.stateMachinesSnapshot().size) assertEquals(1, charlie.rpc.stateMachinesSnapshot().size)
assertEquals(0, charlie.rpc.startFlow(StateMachineErrorHandlingTest::GetNumberOfCheckpointsFlow).returnValue.get())
} }
} }
} }

68
node/src/integration-test-slow/kotlin/net/corda/node/services/statemachine/StateMachineGeneralErrorHandlingTest.kt
View File

@ -40,7 +40,7 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
val rules = """ val rules = """
RULE Create Counter RULE Create Counter
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeSendMultiple METHOD executeSendMultiple
AT ENTRY AT ENTRY
IF createCounter("counter", $counter) IF createCounter("counter", $counter)
@ -48,7 +48,7 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
ENDRULE ENDRULE
RULE Throw exception on executeSendMultiple action RULE Throw exception on executeSendMultiple action
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeSendMultiple METHOD executeSendMultiple
AT ENTRY AT ENTRY
IF readCounter("counter") < 4 IF readCounter("counter") < 4
@ -67,12 +67,12 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
) )
} }
alice.rpc.assertNumberOfCheckpoints(hospitalized = 1)
alice.rpc.assertHospitalCounts( alice.rpc.assertHospitalCounts(
discharged = 3, discharged = 3,
observation = 1 observation = 1
) )
assertEquals(1, alice.rpc.stateMachinesSnapshot().size) assertEquals(1, alice.rpc.stateMachinesSnapshot().size)
alice.rpc.assertNumberOfCheckpoints(1)
} }
} }
@ -92,7 +92,7 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
val rules = """ val rules = """
RULE Create Counter RULE Create Counter
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeSendMultiple METHOD executeSendMultiple
AT ENTRY AT ENTRY
IF createCounter("counter", $counter) IF createCounter("counter", $counter)
@ -100,7 +100,7 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
ENDRULE ENDRULE
RULE Throw exception on executeSendMultiple action RULE Throw exception on executeSendMultiple action
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeSendMultiple METHOD executeSendMultiple
AT ENTRY AT ENTRY
IF readCounter("counter") < 3 IF readCounter("counter") < 3
@ -117,9 +117,9 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
30.seconds 30.seconds
) )
alice.rpc.assertNumberOfCheckpointsAllZero()
alice.rpc.assertHospitalCounts(discharged = 3) alice.rpc.assertHospitalCounts(discharged = 3)
assertEquals(0, alice.rpc.stateMachinesSnapshot().size) assertEquals(0, alice.rpc.stateMachinesSnapshot().size)
alice.rpc.assertNumberOfCheckpoints(0)
} }
} }
@ -140,7 +140,7 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
val rules = """ val rules = """
RULE Set flag when inside executeAcknowledgeMessages RULE Set flag when inside executeAcknowledgeMessages
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeAcknowledgeMessages METHOD executeAcknowledgeMessages
AT INVOKE ${DeduplicationHandler::class.java.name}.afterDatabaseTransaction() AT INVOKE ${DeduplicationHandler::class.java.name}.afterDatabaseTransaction()
IF !flagged("exception_flag") IF !flagged("exception_flag")
@ -165,9 +165,9 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
30.seconds 30.seconds
) )
alice.rpc.assertNumberOfCheckpointsAllZero()
alice.rpc.assertHospitalCountsAllZero() alice.rpc.assertHospitalCountsAllZero()
assertEquals(0, alice.rpc.stateMachinesSnapshot().size) assertEquals(0, alice.rpc.stateMachinesSnapshot().size)
alice.rpc.assertNumberOfCheckpoints(0)
} }
} }
@ -195,7 +195,7 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
ENDRULE ENDRULE
RULE Throw exception on executeCommitTransaction action RULE Throw exception on executeCommitTransaction action
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF flagged("my_flag") && readCounter("counter") < 3 IF flagged("my_flag") && readCounter("counter") < 3
@ -209,12 +209,12 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
alice.rpc.startFlow(StateMachineErrorHandlingTest::ThrowAnErrorFlow).returnValue.getOrThrow(60.seconds) alice.rpc.startFlow(StateMachineErrorHandlingTest::ThrowAnErrorFlow).returnValue.getOrThrow(60.seconds)
} }
alice.rpc.assertNumberOfCheckpoints(failed = 1)
alice.rpc.assertHospitalCounts( alice.rpc.assertHospitalCounts(
propagated = 1, propagated = 1,
propagatedRetry = 3 propagatedRetry = 3
) )
assertEquals(0, alice.rpc.stateMachinesSnapshot().size) assertEquals(0, alice.rpc.stateMachinesSnapshot().size)
alice.rpc.assertNumberOfCheckpoints(0)
} }
} }
@ -243,7 +243,7 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
ENDRULE ENDRULE
RULE Throw exception on executeCommitTransaction action after first suspend + commit RULE Throw exception on executeCommitTransaction action after first suspend + commit
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF flagged("suspend_flag") && flagged("commit_flag") && !flagged("commit_exception_flag") IF flagged("suspend_flag") && flagged("commit_flag") && !flagged("commit_exception_flag")
@ -251,7 +251,7 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
ENDRULE ENDRULE
RULE Set flag when executing first commit RULE Set flag when executing first commit
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF flagged("suspend_flag") && !flagged("commit_flag") IF flagged("suspend_flag") && !flagged("commit_flag")
@ -259,7 +259,7 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
ENDRULE ENDRULE
RULE Throw exception on retry RULE Throw exception on retry
CLASS ${SingleThreadedStateMachineManager::class.java.name} CLASS $stateMachineManagerClassName
METHOD addAndStartFlow METHOD addAndStartFlow
AT ENTRY AT ENTRY
IF flagged("suspend_flag") && flagged("commit_flag") && !flagged("retry_exception_flag") IF flagged("suspend_flag") && flagged("commit_flag") && !flagged("retry_exception_flag")
@ -274,12 +274,12 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
charlie.nodeInfo.singleIdentity() charlie.nodeInfo.singleIdentity()
).returnValue.getOrThrow(40.seconds) ).returnValue.getOrThrow(40.seconds)
alice.rpc.assertNumberOfCheckpointsAllZero()
alice.rpc.assertHospitalCounts( alice.rpc.assertHospitalCounts(
discharged = 1, discharged = 1,
dischargedRetry = 1 dischargedRetry = 1
) )
assertEquals(0, alice.rpc.stateMachinesSnapshot().size) assertEquals(0, alice.rpc.stateMachinesSnapshot().size)
alice.rpc.assertNumberOfCheckpoints(0)
} }
} }
@ -302,7 +302,7 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
// seems to be restarting the flow from the beginning every time // seems to be restarting the flow from the beginning every time
val rules = """ val rules = """
RULE Create Counter RULE Create Counter
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF createCounter("counter", $counter) IF createCounter("counter", $counter)
@ -318,7 +318,7 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
ENDRULE ENDRULE
RULE Throw exception on executeCommitTransaction action after first suspend + commit RULE Throw exception on executeCommitTransaction action after first suspend + commit
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF flagged("suspend_flag") && flagged("commit_flag") && readCounter("counter") < 3 IF flagged("suspend_flag") && flagged("commit_flag") && readCounter("counter") < 3
@ -326,7 +326,7 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
ENDRULE ENDRULE
RULE Set flag when executing first commit RULE Set flag when executing first commit
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF flagged("suspend_flag") && !flagged("commit_flag") IF flagged("suspend_flag") && !flagged("commit_flag")
@ -343,9 +343,9 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
30.seconds 30.seconds
) )
alice.rpc.assertNumberOfCheckpointsAllZero()
alice.rpc.assertHospitalCounts(discharged = 3) alice.rpc.assertHospitalCounts(discharged = 3)
assertEquals(0, alice.rpc.stateMachinesSnapshot().size) assertEquals(0, alice.rpc.stateMachinesSnapshot().size)
alice.rpc.assertNumberOfCheckpoints(0)
} }
} }
@ -368,7 +368,7 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
// seems to be restarting the flow from the beginning every time // seems to be restarting the flow from the beginning every time
val rules = """ val rules = """
RULE Create Counter RULE Create Counter
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF createCounter("counter", $counter) IF createCounter("counter", $counter)
@ -384,7 +384,7 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
ENDRULE ENDRULE
RULE Throw exception on executeCommitTransaction when removing checkpoint RULE Throw exception on executeCommitTransaction when removing checkpoint
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF flagged("remove_checkpoint_flag") && readCounter("counter") < 3 IF flagged("remove_checkpoint_flag") && readCounter("counter") < 3
@ -401,9 +401,9 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
30.seconds 30.seconds
) )
alice.rpc.assertNumberOfCheckpointsAllZero()
alice.rpc.assertHospitalCounts(discharged = 3) alice.rpc.assertHospitalCounts(discharged = 3)
assertEquals(0, alice.rpc.stateMachinesSnapshot().size) assertEquals(0, alice.rpc.stateMachinesSnapshot().size)
alice.rpc.assertNumberOfCheckpoints(0)
} }
} }
@ -424,7 +424,7 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
val rules = """ val rules = """
RULE Create Counter RULE Create Counter
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF createCounter("counter", $counter) IF createCounter("counter", $counter)
@ -440,7 +440,7 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
ENDRULE ENDRULE
RULE Throw exception on executeCommitTransaction when removing checkpoint RULE Throw exception on executeCommitTransaction when removing checkpoint
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF flagged("remove_checkpoint_flag") && readCounter("counter") < 4 IF flagged("remove_checkpoint_flag") && readCounter("counter") < 4
@ -462,12 +462,12 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
) )
} }
alice.rpc.assertNumberOfCheckpoints(hospitalized = 1)
alice.rpc.assertHospitalCounts( alice.rpc.assertHospitalCounts(
discharged = 3, discharged = 3,
observation = 1 observation = 1
) )
assertEquals(1, alice.rpc.stateMachinesSnapshot().size) assertEquals(1, alice.rpc.stateMachinesSnapshot().size)
alice.rpc.assertNumberOfCheckpoints(1)
} }
} }
@ -493,7 +493,7 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
val rules = """ val rules = """
RULE Create Counter RULE Create Counter
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF createCounter("counter", $counter) IF createCounter("counter", $counter)
@ -501,7 +501,7 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
ENDRULE ENDRULE
RULE Throw exception on executeCommitTransaction action RULE Throw exception on executeCommitTransaction action
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF readCounter("counter") < 3 IF readCounter("counter") < 3
@ -526,12 +526,12 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
30.seconds 30.seconds
) )
alice.rpc.assertNumberOfCheckpointsAllZero()
alice.rpc.assertHospitalCounts( alice.rpc.assertHospitalCounts(
discharged = 3, discharged = 3,
observation = 0 observation = 0
) )
assertEquals(0, alice.rpc.stateMachinesSnapshot().size) assertEquals(0, alice.rpc.stateMachinesSnapshot().size)
assertEquals(0, alice.rpc.startFlow(StateMachineErrorHandlingTest::GetNumberOfCheckpointsFlow).returnValue.get())
} }
} }
@ -557,7 +557,7 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
val rules = """ val rules = """
RULE Create Counter RULE Create Counter
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF createCounter("counter", $counter) IF createCounter("counter", $counter)
@ -565,7 +565,7 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
ENDRULE ENDRULE
RULE Throw exception on executeCommitTransaction action RULE Throw exception on executeCommitTransaction action
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF readCounter("counter") < 4 IF readCounter("counter") < 4
@ -590,12 +590,12 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
// flow is not signaled as started calls to [getOrThrow] will hang, sleeping instead // flow is not signaled as started calls to [getOrThrow] will hang, sleeping instead
Thread.sleep(30.seconds.toMillis()) Thread.sleep(30.seconds.toMillis())
alice.rpc.assertNumberOfCheckpoints(hospitalized = 1)
alice.rpc.assertHospitalCounts( alice.rpc.assertHospitalCounts(
discharged = 3, discharged = 3,
observation = 1 observation = 1
) )
assertEquals(1, alice.rpc.stateMachinesSnapshot().size) assertEquals(1, alice.rpc.stateMachinesSnapshot().size)
assertEquals(0, alice.rpc.startFlow(StateMachineErrorHandlingTest::GetNumberOfCheckpointsFlow).returnValue.get())
} }
} }
@ -615,7 +615,7 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
val rules = """ val rules = """
RULE Create Counter RULE Create Counter
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF createCounter("counter", $counter) IF createCounter("counter", $counter)
@ -631,7 +631,7 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
ENDRULE ENDRULE
RULE Throw exception on executeCommitTransaction when removing checkpoint RULE Throw exception on executeCommitTransaction when removing checkpoint
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeCommitTransaction METHOD executeCommitTransaction
AT ENTRY AT ENTRY
IF flagged("remove_checkpoint_flag") && readCounter("counter") < 3 IF flagged("remove_checkpoint_flag") && readCounter("counter") < 3
@ -651,11 +651,11 @@ class StateMachineGeneralErrorHandlingTest : StateMachineErrorHandlingTest() {
30.seconds 30.seconds
) )
alice.rpc.assertNumberOfCheckpointsAllZero()
charlie.rpc.assertNumberOfCheckpointsAllZero()
charlie.rpc.assertHospitalCounts(discharged = 3) charlie.rpc.assertHospitalCounts(discharged = 3)
assertEquals(0, alice.rpc.stateMachinesSnapshot().size) assertEquals(0, alice.rpc.stateMachinesSnapshot().size)
assertEquals(0, charlie.rpc.stateMachinesSnapshot().size) assertEquals(0, charlie.rpc.stateMachinesSnapshot().size)
alice.rpc.assertNumberOfCheckpoints(0)
charlie.rpc.assertNumberOfCheckpoints(0)
} }
} }
} }

10
node/src/integration-test-slow/kotlin/net/corda/node/services/statemachine/StateMachineKillFlowErrorHandlingTest.kt
View File

@ -48,9 +48,9 @@ class StateMachineKillFlowErrorHandlingTest : StateMachineErrorHandlingTest() {
assertFailsWith<KilledFlowException> { flow.returnValue.getOrThrow(20.seconds) } assertFailsWith<KilledFlowException> { flow.returnValue.getOrThrow(20.seconds) }
assertTrue(flowKilled) assertTrue(flowKilled)
alice.rpc.assertNumberOfCheckpointsAllZero()
alice.rpc.assertHospitalCountsAllZero() alice.rpc.assertHospitalCountsAllZero()
assertEquals(0, alice.rpc.stateMachinesSnapshot().size) assertEquals(0, alice.rpc.stateMachinesSnapshot().size)
alice.rpc.assertNumberOfCheckpoints(0)
} }
} }
@ -85,9 +85,9 @@ class StateMachineKillFlowErrorHandlingTest : StateMachineErrorHandlingTest() {
assertFailsWith<KilledFlowException> { flow.returnValue.getOrThrow(30.seconds) } assertFailsWith<KilledFlowException> { flow.returnValue.getOrThrow(30.seconds) }
assertTrue(flowKilled) assertTrue(flowKilled)
alice.rpc.assertNumberOfCheckpointsAllZero()
alice.rpc.assertHospitalCountsAllZero() alice.rpc.assertHospitalCountsAllZero()
assertEquals(0, alice.rpc.stateMachinesSnapshot().size) assertEquals(0, alice.rpc.stateMachinesSnapshot().size)
alice.rpc.assertNumberOfCheckpoints(0)
} }
} }
@ -108,7 +108,7 @@ class StateMachineKillFlowErrorHandlingTest : StateMachineErrorHandlingTest() {
val rules = """ val rules = """
RULE Create Counter RULE Create Counter
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeSendMultiple METHOD executeSendMultiple
AT ENTRY AT ENTRY
IF createCounter("counter", $counter) IF createCounter("counter", $counter)
@ -116,7 +116,7 @@ class StateMachineKillFlowErrorHandlingTest : StateMachineErrorHandlingTest() {
ENDRULE ENDRULE
RULE Throw exception on executeSendMultiple action RULE Throw exception on executeSendMultiple action
CLASS ${ActionExecutorImpl::class.java.name} CLASS $actionExecutorClassName
METHOD executeSendMultiple METHOD executeSendMultiple
AT ENTRY AT ENTRY
IF readCounter("counter") < 4 IF readCounter("counter") < 4
@ -132,12 +132,12 @@ class StateMachineKillFlowErrorHandlingTest : StateMachineErrorHandlingTest() {
alice.rpc.killFlow(flow.id) alice.rpc.killFlow(flow.id)
alice.rpc.assertNumberOfCheckpointsAllZero()
alice.rpc.assertHospitalCounts( alice.rpc.assertHospitalCounts(
discharged = 3, discharged = 3,
observation = 1 observation = 1
) )
assertEquals(0, alice.rpc.stateMachinesSnapshot().size) assertEquals(0, alice.rpc.stateMachinesSnapshot().size)
alice.rpc.assertNumberOfCheckpoints(0)
} }
} }

8
node/src/integration-test-slow/kotlin/net/corda/node/services/statemachine/StateMachineSubFlowErrorHandlingTest.kt
View File

@ -94,9 +94,9 @@ class StateMachineSubFlowErrorHandlingTest : StateMachineErrorHandlingTest() {
30.seconds 30.seconds
) )
alice.rpc.assertNumberOfCheckpointsAllZero()
alice.rpc.assertHospitalCounts(discharged = 3) alice.rpc.assertHospitalCounts(discharged = 3)
assertEquals(0, alice.rpc.stateMachinesSnapshot().size) assertEquals(0, alice.rpc.stateMachinesSnapshot().size)
alice.rpc.assertNumberOfCheckpoints(0)
} }
} }
@ -165,9 +165,9 @@ class StateMachineSubFlowErrorHandlingTest : StateMachineErrorHandlingTest() {
30.seconds 30.seconds
) )
alice.rpc.assertNumberOfCheckpointsAllZero()
alice.rpc.assertHospitalCounts(discharged = 3) alice.rpc.assertHospitalCounts(discharged = 3)
assertEquals(0, alice.rpc.stateMachinesSnapshot().size) assertEquals(0, alice.rpc.stateMachinesSnapshot().size)
alice.rpc.assertNumberOfCheckpoints(0)
} }
} }
@ -228,9 +228,9 @@ class StateMachineSubFlowErrorHandlingTest : StateMachineErrorHandlingTest() {
30.seconds 30.seconds
) )
alice.rpc.assertNumberOfCheckpointsAllZero()
alice.rpc.assertHospitalCounts(discharged = 3) alice.rpc.assertHospitalCounts(discharged = 3)
assertEquals(0, alice.rpc.stateMachinesSnapshot().size) assertEquals(0, alice.rpc.stateMachinesSnapshot().size)
alice.rpc.assertNumberOfCheckpoints(0)
} }
} }
@ -299,9 +299,9 @@ class StateMachineSubFlowErrorHandlingTest : StateMachineErrorHandlingTest() {
30.seconds 30.seconds
) )
alice.rpc.assertNumberOfCheckpointsAllZero()
alice.rpc.assertHospitalCounts(discharged = 3) alice.rpc.assertHospitalCounts(discharged = 3)
assertEquals(0, alice.rpc.stateMachinesSnapshot().size) assertEquals(0, alice.rpc.stateMachinesSnapshot().size)
alice.rpc.assertNumberOfCheckpoints(0)
} }
} }

0
node/src/integration-test-slow/kotlin/net/corda/node/services/statemachine/StatemachineGeneralErrorHandlingTest.kt
View File

0
node/src/integration-test-slow/kotlin/net/corda/node/services/statemachine/StatemachineKillFlowErrorHandlingTest.kt
View File