ExternalVendorCode/corda
1
0
Fork 0
mirror of https://github.com/corda/corda.git synced 2025-04-15 15:07:03 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

notary healthcheck improvements (#1298)

Browse Source 
* Use correct asserts in unit tests

* gradle tweaks

* Remove unneeded imports

* Minor code review changes

* Use version var
This commit is contained in:
Christian Sailer 2018-07-25 18:09:04 +01:00 committed by GitHub
parent 3259c4b64a
commit 3647a10aa5
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 43 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
tools/notary-healthcheck/client/build.gradle
View File

@ -11,7 +11,6 @@
repositories {
mavenCentral()
jcenter()
maven { url 'https://jitpack.io' }
mavenLocal()
}
@ -29,9 +28,8 @@ mainClassName = 'net.corda.notaryhealthcheck.client.MainKt'
dependencies {
compile project(":client:rpc")
runtime project(":core")
testCompile "junit:junit:$junit_version"
compile group: 'info.picocli', name: 'picocli', version: '3.0.1'
compile "info.picocli:picocli:$picocli_version"
compile project(":tools:notary-healthcheck:cordapp")
}
@ -43,7 +41,7 @@ jar {
task buildClientJar(type: FatCapsule) {
applicationClass mainClassName
archiveName "notaryhealthcheck-client-${corda_release_version}.jar"
baseName "notaryhealthcheck-client"
applicationSource = jar
}
@ -58,3 +56,5 @@ publish {
disableDefaultJar = true
name "corda-notary-healthcheck-client"
}
assemble.dependsOn buildClientJar

1
tools/notary-healthcheck/contract/build.gradle
View File

@ -11,7 +11,6 @@
repositories {
mavenCentral()
jcenter()
maven { url 'https://jitpack.io' }
mavenLocal()
}

3
tools/notary-healthcheck/cordapp/build.gradle
View File

@ -26,12 +26,11 @@ sourceSets {
dependencies {
cordaCompile project(":node") // Not node-api so we get metrics.
cordaCompile project(":tools:notary-healthcheck:contract")
cordapp project(":tools:notary-healthcheck:contract")
testCompile project(":node-driver")
}
configurations {
testArtifacts.extendsFrom testRuntime
integrationTestCompile.extendsFrom testCompile
integrationTestRuntime.extendsFrom testRuntime
}

18
tools/notary-healthcheck/cordapp/src/integration-test/kotlin/net/corda/notaryhealthcheck/TestNotaryTypes.kt
View File

@ -28,6 +28,8 @@ import net.corda.testing.node.internal.DummyClusterSpec
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.runners.Parameterized
import kotlin.test.assertEquals
import kotlin.test.assertTrue
@RunWith(Parameterized::class)
class TestNotaryTypes(val validating: Boolean, @Suppress("UNUSED_PARAMETER") description: String) {
@ -54,14 +56,14 @@ class TestNotaryTypes(val validating: Boolean, @Suppress("UNUSED_PARAMETER") des
nodeA.rpc.startFlow(::StartAllChecksFlow, 2, 5).returnValue.getOrThrow()
Thread.sleep(5.seconds.toMillis())
val pendingStates = nodeA.rpc.vaultQueryBy(criteria = QueryCriteria.VaultQueryCriteria(Vault.StateStatus.UNCONSUMED), contractStateType = ScheduledCheckState::class.java, paging = PageSpecification(1, 100), sorting = Sort(columns = emptyList())).states
assert(pendingStates.size == 4)
assertEquals(4, pendingStates.size)
val successStates = nodeA.rpc.vaultQueryBy(criteria = QueryCriteria.VaultQueryCriteria(Vault.StateStatus.UNCONSUMED), contractStateType = SuccessfulCheckState::class.java, paging = PageSpecification(1, 100), sorting = Sort(columns = emptyList())).states
assert(successStates.size > 7) { "Expecting at least 8 successful checks by now, got ${successStates.size}" }
assertTrue(successStates.size > 7, "Expecting at least 8 successful checks by now, got ${successStates.size}")
val failStates = nodeA.rpc.vaultQueryBy(criteria = QueryCriteria.VaultQueryCriteria(Vault.StateStatus.UNCONSUMED), contractStateType = FailedCheckState::class.java, paging = PageSpecification(1, 100), sorting = Sort(columns = emptyList())).states
assert(failStates.isEmpty()) { "Did not expect any checks to fail, got ${failStates.size}" }
assertTrue(failStates.isEmpty(), "Did not expect any checks to fail, got ${failStates.size}")
nodeA.rpc.startFlow(::StopAllChecksFlow).returnValue.getOrThrow()
val pendingStatesAfterClean = nodeA.rpc.vaultQueryBy(criteria = QueryCriteria.VaultQueryCriteria(Vault.StateStatus.UNCONSUMED), contractStateType = ScheduledCheckState::class.java, paging = PageSpecification(1, 100), sorting = Sort(columns = emptyList())).states
assert(pendingStatesAfterClean.isEmpty()) { "Expected all pending states to be cleared, got ${pendingStatesAfterClean.size}" }
assertTrue(pendingStatesAfterClean.isEmpty(), "Expected all pending states to be cleared, got ${pendingStatesAfterClean.size}")
}
}
@ -80,14 +82,14 @@ class TestNotaryTypes(val validating: Boolean, @Suppress("UNUSED_PARAMETER") des
nodeA.rpc.startFlow(::StartAllChecksFlow, 2, 5).returnValue.getOrThrow()
Thread.sleep(5.seconds.toMillis())
val pendingStates = nodeA.rpc.vaultQueryBy(criteria = QueryCriteria.VaultQueryCriteria(Vault.StateStatus.UNCONSUMED), contractStateType = ScheduledCheckState::class.java, paging = PageSpecification(1, 100), sorting = Sort(columns = emptyList())).states
assert(pendingStates.size == 1)
assertEquals(1, pendingStates.size)
val successStates = nodeA.rpc.vaultQueryBy(criteria = QueryCriteria.VaultQueryCriteria(Vault.StateStatus.UNCONSUMED), contractStateType = SuccessfulCheckState::class.java, paging = PageSpecification(1, 100), sorting = Sort(columns = emptyList())).states
assert(successStates.size > 1) { "Expecting at least 2 successful checks by now, got ${successStates.size}" }
assertTrue(successStates.size > 1, "Expecting at least 2 successful checks by now, got ${successStates.size}")
val failStates = nodeA.rpc.vaultQueryBy(criteria = QueryCriteria.VaultQueryCriteria(Vault.StateStatus.UNCONSUMED), contractStateType = FailedCheckState::class.java, paging = PageSpecification(1, 100), sorting = Sort(columns = emptyList())).states
assert(failStates.isEmpty()) { "Did not expect any checks to fail, got ${failStates.size}" }
assertTrue(failStates.isEmpty(), "Did not expect any checks to fail, got ${failStates.size}")
nodeA.rpc.startFlow(::StopAllChecksFlow).returnValue.getOrThrow()
val pendingStatesAfterClean = nodeA.rpc.vaultQueryBy(criteria = QueryCriteria.VaultQueryCriteria(Vault.StateStatus.UNCONSUMED), contractStateType = ScheduledCheckState::class.java, paging = PageSpecification(1, 100), sorting = Sort(columns = emptyList())).states
assert(pendingStatesAfterClean.isEmpty()) { "Expected all pending states to be cleared, got ${pendingStatesAfterClean.size}" }
assertTrue(pendingStatesAfterClean.isEmpty(), "Expected all pending states to be cleared, got ${pendingStatesAfterClean.size}")
}
}

24
tools/notary-healthcheck/cordapp/src/test/kotlin/net/corda/notaryhealthcheck/cordapp/TestCheckScheduleManagementFlow.kt
View File

@ -36,6 +36,8 @@ import org.junit.Before
import org.junit.Test
import java.lang.Thread.sleep
import java.time.Instant
import kotlin.test.assertEquals
import kotlin.test.assertTrue
class TestCheckScheduleManagementFlow {
private lateinit var mockNet: MockNetwork
@ -70,10 +72,10 @@ class TestCheckScheduleManagementFlow {
Thread.sleep(4.seconds.toMillis())
nodeA.transaction {
val successfulChecks = nodeA.services.vaultService.queryBy<SuccessfulCheckState>()
assert(successfulChecks.states.size > 4) { "Expected at least 3 successful checks per notary by now, got ${successfulChecks.states.size}" }
assertTrue { successfulChecks.states.size > 4 }
val pendingChecks = nodeA.services.vaultService.queryBy<ScheduledCheckState>(criteria = QueryCriteria.VaultQueryCriteria(Vault.StateStatus.UNCONSUMED))
assert(pendingChecks.states.size == 2) { "Expected exactly 2 pending (scheduled) checks, got ${pendingChecks.states.size}" }
assertEquals(2, pendingChecks.states.size, "Expected exactly 2 pending (scheduled) checks, got ${pendingChecks.states.size}")
}
nodeA.startFlow(StopCheckScheduleFlow(target)).get()
@ -81,7 +83,7 @@ class TestCheckScheduleManagementFlow {
val pendingChecksAfterCleanUp = nodeA.transaction {
nodeA.services.vaultService.queryBy<ScheduledCheckState>(criteria = QueryCriteria.VaultQueryCriteria(Vault.StateStatus.UNCONSUMED))
}
assert(pendingChecksAfterCleanUp.states.size == 1) { "Expected 1 pending check to be removed, got ${pendingChecksAfterCleanUp.states.size}" }
assertEquals(1, pendingChecksAfterCleanUp.states.size, "Expected 1 pending check to be removed, got ${pendingChecksAfterCleanUp.states.size}")
}
@ -93,10 +95,10 @@ class TestCheckScheduleManagementFlow {
Thread.sleep(4.seconds.toMillis())
nodeA.transaction {
val successfulChecks = nodeA.services.vaultService.queryBy<SuccessfulCheckState>()
assert(successfulChecks.states.size > 3) { "Expected at least 2 successful checks per notary by now, got ${successfulChecks.states.size}" }
assertTrue(successfulChecks.states.size > 3, "Expected at least 2 successful checks per notary by now, got ${successfulChecks.states.size}")
val pendingChecks = nodeA.services.vaultService.queryBy<ScheduledCheckState>(criteria = QueryCriteria.VaultQueryCriteria(Vault.StateStatus.UNCONSUMED))
assert(pendingChecks.states.size == 2) { "Expected exactly 2 pending (scheduled) checks, got ${pendingChecks.states.size}" }
assertEquals(2, pendingChecks.states.size, "Expected exactly 2 pending (scheduled) checks, got ${pendingChecks.states.size}")
}
nodeA.startFlow(StopCheckScheduleFlow(target)).get()
@ -104,7 +106,7 @@ class TestCheckScheduleManagementFlow {
val pendingChecksAfterCleanUp = nodeA.transaction {
nodeA.services.vaultService.queryBy<ScheduledCheckState>(criteria = QueryCriteria.VaultQueryCriteria(Vault.StateStatus.UNCONSUMED))
}
assert(pendingChecksAfterCleanUp.states.isEmpty()) { "Expected all pending checks to be removed, got ${pendingChecksAfterCleanUp.states.size}" }
assertTrue(pendingChecksAfterCleanUp.states.isEmpty(), "Expected all pending checks to be removed, got ${pendingChecksAfterCleanUp.states.size}")
}
@Test
@ -113,13 +115,13 @@ class TestCheckScheduleManagementFlow {
sleep(1.seconds.toMillis())
nodeA.transaction {
val pendingChecks = nodeA.services.vaultService.queryBy<ScheduledCheckState>(criteria = QueryCriteria.VaultQueryCriteria(Vault.StateStatus.UNCONSUMED))
assert(pendingChecks.states.size == 2) { "Expected exactly 2 pending (scheduled) checks, got ${pendingChecks.states.size}" }
assertEquals(2, pendingChecks.states.size, "Expected exactly 2 pending (scheduled) checks, got ${pendingChecks.states.size}")
}
nodeA.startFlow(StopAllChecksFlow()).getOrThrow()
val pendingChecksAfterCleanUp = nodeA.transaction {
nodeA.services.vaultService.queryBy<ScheduledCheckState>(criteria = QueryCriteria.VaultQueryCriteria(Vault.StateStatus.UNCONSUMED))
}
assert(pendingChecksAfterCleanUp.states.isEmpty()) { "Expected all pending checks to be removed, got ${pendingChecksAfterCleanUp.states.size}" }
assertTrue(pendingChecksAfterCleanUp.states.isEmpty(), "Expected all pending checks to be removed, got ${pendingChecksAfterCleanUp.states.size}")
}
@Test
@ -167,9 +169,9 @@ class TestCheckScheduleManagementFlow {
}
val targets = getTargets(networkMap)
assert(targets.size == 4) { "Expected 4 targets. got ${targets.size}" }
assert(notaries.all { it in targets.map { it.party } })
assert(notary2Parties.all { it in targets.map { it.party } })
assertEquals(4, targets.size, "Expected 4 targets. got ${targets.size}")
assertTrue(notaries.all { it in targets.map { it.party } })
assertTrue(notary2Parties.all { it in targets.map { it.party } })
}
}

29
tools/notary-healthcheck/cordapp/src/test/kotlin/net/corda/notaryhealthcheck/cordapp/TestScheduleCheckFlow.kt
View File

@ -24,6 +24,7 @@ import org.junit.Before
import org.junit.Test
import java.time.Instant
import kotlin.test.assertEquals
import kotlin.test.assertTrue
class TestScheduleCheckFlow {
@ -57,12 +58,12 @@ class TestScheduleCheckFlow {
val successfulChecks = nodeA.services.vaultService.queryBy<SuccessfulCheckState>()
val pendingChecks = nodeA.services.vaultService.queryBy<ScheduledCheckState>(criteria = QueryCriteria.VaultQueryCriteria(Vault.StateStatus.UNCONSUMED))
assert(successfulChecks.states.size > 1) { "Expected at least 2 successful checks by now, got ${successfulChecks.states.size}" }
assertTrue(successfulChecks.states.size > 1, "Expected at least 2 successful checks by now, got ${successfulChecks.states.size}")
// sort all successful states, get the second to last one and take it's finish time - that will be the last recorded success. The last one will be
// handled the next time the scheduled state is run as it was started in the last run and finished after scheduling
// the current pending state.
val lastSuccessTime = successfulChecks.states.map { it.state.data.finishTime }.sorted().dropLast(1).last()
assert(pendingChecks.states.size == 1) { "Expected exactly 1 pending (scheduled check), got ${pendingChecks.states.size}" }
assertEquals(1, pendingChecks.states.size, "Expected exactly 1 pending (scheduled check), got ${pendingChecks.states.size}")
assertEquals(lastSuccessTime, pendingChecks.states.first().state.data.lastSuccessTime)
}
@ -71,7 +72,7 @@ class TestScheduleCheckFlow {
val pendingChecksAfterCleanUp = nodeA.transaction {
nodeA.services.vaultService.queryBy<ScheduledCheckState>(criteria = QueryCriteria.VaultQueryCriteria(Vault.StateStatus.UNCONSUMED))
}
assert(pendingChecksAfterCleanUp.states.isEmpty()) { "Expected all pending checks to be removed, got ${pendingChecksAfterCleanUp.states.size}" }
assertTrue(pendingChecksAfterCleanUp.states.isEmpty(), "Expected all pending checks to be removed, got ${pendingChecksAfterCleanUp.states.size}")
}
@ -84,23 +85,23 @@ class TestScheduleCheckFlow {
Thread.sleep(5.seconds.toMillis())
nodeA.transaction {
val successfulChecks = nodeA.services.vaultService.queryBy<SuccessfulCheckState>()
assert(successfulChecks.states.isEmpty()) { "Not expecting any successful checks, got ${successfulChecks.states.size}" }
assertTrue(successfulChecks.states.isEmpty(), "Not expecting any successful checks, got ${successfulChecks.states.size}")
val startedChecks = nodeA.services.vaultService.queryBy<RunningCheckState>()
assert(startedChecks.states.size > 1) { "Expected at least 2 started/running checks by now, got ${startedChecks.states.size}" }
assertTrue(startedChecks.states.size > 1, "Expected at least 2 started/running checks by now, got ${startedChecks.states.size}")
val abandonnedStates = nodeA.services.vaultService.queryBy<AbandonnedCheckState>()
assert(abandonnedStates.states.size > 1) { "Expected at least 1 abandonned check by now, got ${abandonnedStates.states.size}" }
assertTrue(abandonnedStates.states.size > 1, "Expected at least 1 abandonned check by now, got ${abandonnedStates.states.size}")
val scheduledStates = nodeA.services.vaultService.queryBy<ScheduledCheckState>()
assert(scheduledStates.states.size == 1) { "Expected exactly 1 pending (scheduled check), got ${scheduledStates.states.size}" }
assertEquals(1, scheduledStates.states.size, "Expected exactly 1 pending (scheduled check), got ${scheduledStates.states.size}")
}
nodeA.startFlow(StopAllChecksFlow()).get()
val pendingChecksAfterCleanUp = nodeA.transaction {
nodeA.services.vaultService.queryBy<ScheduledCheckState>(criteria = QueryCriteria.VaultQueryCriteria(Vault.StateStatus.UNCONSUMED))
}
assert(pendingChecksAfterCleanUp.states.isEmpty()) { "Expected all pending checks to be removed, got ${pendingChecksAfterCleanUp.states.size}" }
assertTrue(pendingChecksAfterCleanUp.states.isEmpty(), "Expected all pending checks to be removed, got ${pendingChecksAfterCleanUp.states.size}")
}
@Test
@ -114,23 +115,23 @@ class TestScheduleCheckFlow {
nodeA.transaction {
val successfulChecks = nodeA.services.vaultService.queryBy<SuccessfulCheckState>()
assert(successfulChecks.states.isEmpty()) { "Not expecting any successful checks, got ${successfulChecks.states.size}" }
assertTrue(successfulChecks.states.isEmpty(), "Not expecting any successful checks, got ${successfulChecks.states.size}")
val failedStates = nodeA.services.vaultService.queryBy<FailedCheckState>()
assert(failedStates.states.size > 1) { "Expected at least 2 failed checks by now, got ${failedStates.states.size}" }
assertTrue(failedStates.states.size > 1, "Expected at least 2 failed checks by now, got ${failedStates.states.size}")
val abandonnedStates = nodeA.services.vaultService.queryBy<AbandonnedCheckState>()
assert(abandonnedStates.states.isEmpty()) { "Not expecting any abandonned checks, got ${abandonnedStates.states.size}" }
assertTrue(abandonnedStates.states.isEmpty(), "Not expecting any abandonned checks, got ${abandonnedStates.states.size}")
val scheduledStates = nodeA.services.vaultService.queryBy<ScheduledCheckState>()
assert(scheduledStates.states.size == 1) { "Expected exactly 1 pending (scheduled check), got ${scheduledStates.states.size}" }
assert(scheduledStates.states.first().state.data.lastSuccessTime == lastSuccessTime)
assertEquals(1, scheduledStates.states.size, "Expected exactly 1 pending (scheduled check), got ${scheduledStates.states.size}")
assertEquals(lastSuccessTime, scheduledStates.states.first().state.data.lastSuccessTime)
}
nodeA.startFlow(StopAllChecksFlow())
Thread.sleep(1.seconds.toMillis())
val pendingChecksAfterCleanUp = nodeA.transaction {
nodeA.services.vaultService.queryBy<ScheduledCheckState>(criteria = QueryCriteria.VaultQueryCriteria(Vault.StateStatus.UNCONSUMED))
}
assert(pendingChecksAfterCleanUp.states.isEmpty()) { "Expected all pending checks to be removed, got ${pendingChecksAfterCleanUp.states.size}" }
assertTrue(pendingChecksAfterCleanUp.states.isEmpty(), "Expected all pending checks to be removed, got ${pendingChecksAfterCleanUp.states.size}")
}
}