From 89afd543f4d0c59552df2b4c6d284d197c6ba35b Mon Sep 17 00:00:00 2001 From: Janne Valkealahti Date: Sat, 28 Nov 2020 17:51:15 +0000 Subject: [PATCH] Port core tests to assertj --- build.gradle | 2 - .../statemachine/EnumStateMachineTests.java | 25 +- .../statemachine/EventDeferTests.java | 88 +++--- .../statemachine/EventHeaderTests.java | 218 ++++++++------- .../statemachine/RegionMachineTests.java | 141 +++++----- .../statemachine/RelayTests.java | 13 +- .../statemachine/StateContextTests.java | 182 ++++++------- .../StateMachineFactoryTests.java | 35 ++- .../statemachine/StateMachineResetTests.java | 115 ++++---- .../statemachine/StateMachineTests.java | 91 +++---- .../statemachine/SubStateMachineTests.java | 120 ++++----- .../access/StateMachineAccessTests.java | 9 +- .../action/ActionAndTimerTests.java | 23 +- .../statemachine/action/ActionErrorTests.java | 14 +- .../statemachine/action/ActionTests.java | 69 +++-- .../action/DistributedLeaderActionTests.java | 13 +- .../action/ReactiveActionTests.java | 21 +- .../action/SpelExpressionActionTests.java | 10 +- .../action/StateDoActivityActionTests.java | 68 +++-- .../annotation/ClassAnnotationTests.java | 25 +- .../annotation/MethodAnnotationTests.java | 173 ++++++------ .../MethodAnnotationWithBuilderTests.java | 30 +-- .../MethodAnnotationWithFactoryTests.java | 12 +- .../config/ConfigurationErrorTests.java | 34 +-- .../config/ConfigurationTests.java | 84 +++--- .../config/MachineTypedTests.java | 43 ++- .../config/ManualBuilderContextTests.java | 26 +- .../config/ManualBuilderTests.java | 47 ++-- .../config/SessionScopedAnnotationTests.java | 26 +- .../config/SessionScopedManualTests.java | 26 +- .../ComplexAnnotationConfigurationTests.java | 44 ++- .../ImportingBeanDefinitionTests.java | 7 +- .../MixedAnnotationConfigurationTests.java | 39 ++- .../MultipleAnnotationConfigurationTests.java | 33 +-- .../SimpleAnnotationConfiguration2Tests.java | 39 ++- .../SimpleAnnotationConfigurationTests.java | 43 ++- .../XmlImportDependenciesTests.java | 18 +- .../DefaultStateConfigurerTests.java | 107 ++++---- .../model/StateMachineModelFactoryTests.java | 26 +- .../config/model/StateMachineModelTests.java | 22 +- .../docs/DocsConfigurationSampleTests10.java | 18 +- .../docs/DocsConfigurationSampleTests2.java | 45 ++-- .../docs/DocsConfigurationSampleTests5.java | 9 +- .../docs/DocsConfigurationSampleTests6.java | 9 +- .../statemachine/docs/IntroSample.java | 11 +- .../DistributedStateMachineTests.java | 17 +- .../statemachine/event/ContextEventTests.java | 14 +- .../event/StateMachineEventTests.java | 117 ++++---- .../statemachine/guard/GuardTests.java | 35 ++- .../guard/SpelExpressionGuardTests.java | 15 +- .../CompositeStateMachineListenerTests.java | 11 +- .../statemachine/listener/ListenerTests.java | 44 ++- .../monitor/StateMachineMonitorTests.java | 22 +- .../DefaultStateMachinePersisterTests.java | 117 ++++---- .../persist/StateMachinePersistTests.java | 118 ++++---- .../persist/StateMachinePersistTests2.java | 34 ++- .../persist/StateMachinePersistTests3.java | 37 ++- .../persist/StateMachinePersistTests4.java | 237 ++++++++-------- .../processor/AnnotatedMethodTests.java | 96 ++++--- .../processor/MethodParameterTests.java | 17 +- ...teMachineAnnotationPostProcessorTests.java | 9 +- .../security/AbstractSecurityTests.java | 40 ++- .../security/ActionSecurityTests.java | 34 ++- .../security/SecurityConfigTests.java | 85 +++--- .../security/SecurityRuleTests.java | 15 +- ...TransitionSecurityExpressionRootTests.java | 23 +- .../TransitionSecurityExpressionTests.java | 30 +-- .../DefaultStateMachineServiceTests.java | 25 +- .../statemachine/state/ChoiceStateTests.java | 67 +++-- .../state/CompletionEventTests.java | 43 ++- .../statemachine/state/EndStateTests.java | 111 ++++---- .../statemachine/state/EnumStateTests.java | 13 +- .../state/ExitEntryStateTests.java | 40 ++- .../statemachine/state/ForkStateTests.java | 68 +++-- .../statemachine/state/HistoryStateTests.java | 40 ++- .../statemachine/state/InitialStateTests.java | 23 +- .../state/JoinPseudoStateTests.java | 41 ++- .../statemachine/state/JoinStateTests.java | 200 +++++++------- .../state/JunctionStateTests.java | 51 ++-- .../statemachine/state/RegionStateTests.java | 16 +- .../statemachine/state/StateActionTests.java | 27 +- .../state/SubmachineRefEnumTests.java | 26 +- .../state/SubmachineRefTests.java | 26 +- .../state/SubmachineStateTests.java | 51 ++-- .../DefaultStateMachineContextTests.java | 13 +- .../support/LifecycleObjectSupportTests.java | 15 +- .../ReactiveLifecycleManagerTests.java | 37 ++- .../support/StateChangeInterceptorTests.java | 254 +++++++++--------- .../StateContextExpressionMethodsTests.java | 25 +- .../support/TransitionComparatorTests.java | 29 +- .../transition/LocalTransitionTests.java | 122 +++++---- .../TransitionEventHeaderTests.java | 104 ++++--- .../transition/TransitionOrderTests.java | 41 ++- .../transition/TransitionTests.java | 121 ++++----- .../trigger/TimerTriggerTests.java | 67 +++-- .../data/AbstractRepositoryTests.java | 9 +- .../ZookeeperStateMachineEnsembleTests.java | 7 +- 97 files changed, 2449 insertions(+), 2683 deletions(-) diff --git a/build.gradle b/build.gradle index 25cf1f7d..11192c1e 100644 --- a/build.gradle +++ b/build.gradle @@ -221,8 +221,6 @@ project('spring-statemachine-core') { testCompile 'org.springframework:spring-webmvc' testCompile 'io.projectreactor:reactor-test' testCompile 'org.apache.tomcat.embed:tomcat-embed-core' - testCompile 'org.hamcrest:hamcrest-core' - testCompile 'org.hamcrest:hamcrest-library' testCompile('org.mockito:mockito-core') { dep -> exclude group: 'org.hamcrest' } diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/EnumStateMachineTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/EnumStateMachineTests.java index 805b70f1..e035a5cc 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/EnumStateMachineTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/EnumStateMachineTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,8 +15,7 @@ */ package org.springframework.statemachine; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.is; +import static org.assertj.core.api.Assertions.assertThat; import java.util.ArrayList; import java.util.Collection; @@ -86,27 +85,27 @@ public class EnumStateMachineTests extends AbstractStateMachineTests { machine.start(); State initialState = machine.getInitialState(); - assertThat(initialState, is(stateSI)); + assertThat(initialState).isEqualTo(stateSI); State state = machine.getState(); - assertThat(state, is(stateSI)); + assertThat(state).isEqualTo(stateSI); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).build()); state = machine.getState(); - assertThat(state, is(stateS1)); + assertThat(state).isEqualTo(stateS1); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E2).build()); state = machine.getState(); - assertThat(state, is(stateS2)); + assertThat(state).isEqualTo(stateS2); // not processed machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).build()); state = machine.getState(); - assertThat(state, is(stateS2)); + assertThat(state).isEqualTo(stateS2); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E3).build()); state = machine.getState(); - assertThat(state, is(stateS3)); + assertThat(state).isEqualTo(stateS3); } @Test @@ -159,21 +158,21 @@ public class EnumStateMachineTests extends AbstractStateMachineTests { machine.start(); State initialState = machine.getInitialState(); - assertThat(initialState, is(stateSI)); + assertThat(initialState).isEqualTo(stateSI); State state = machine.getState(); - assertThat(state, is(stateSI)); + assertThat(state).isEqualTo(stateSI); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E2).build()); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E3).build()); state = machine.getState(); - assertThat(state, is(stateSI)); + assertThat(state).isEqualTo(stateSI); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).build()); state = machine.getState(); - assertThat(state, is(stateS3)); + assertThat(state).isEqualTo(stateS3); } @Test diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/EventDeferTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/EventDeferTests.java index 8de873fd..0aa2eae2 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/EventDeferTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/EventDeferTests.java @@ -15,11 +15,7 @@ */ package org.springframework.statemachine; -import static org.hamcrest.CoreMatchers.nullValue; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.is; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; import static org.springframework.statemachine.TestUtils.resolveMachine; @@ -65,9 +61,9 @@ public class EventDeferTests extends AbstractStateMachineTests { doSendEventAndConsumeAll(machine, "E1"); Object executor = TestUtils.readField("stateMachineExecutor", machine); Collection readField = TestUtils.readField("deferList", executor); - assertThat(readField.size(), is(1)); + assertThat(readField).hasSize(1); doSendEventAndConsumeAll(machine, "E2"); - assertThat(readField.size(), is(2)); + assertThat(readField).hasSize(2); } @Test @@ -79,7 +75,7 @@ public class EventDeferTests extends AbstractStateMachineTests { StateMachine machine = resolveMachine(context); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), contains("S1")); + assertThat(machine.getState().getIds()).containsExactly("S1"); AtomicReference error = new AtomicReference<>(); AtomicInteger i1 = new AtomicInteger(); @@ -112,7 +108,7 @@ public class EventDeferTests extends AbstractStateMachineTests { t2.start(); t1.join(); t2.join(); - assertThat(error.get(), nullValue()); + assertThat(error.get()).isNull(); } @Test @@ -124,26 +120,26 @@ public class EventDeferTests extends AbstractStateMachineTests { machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(listener.stateMachineStartedLatch.await(3, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedLatch.await(3, TimeUnit.SECONDS), is(true)); + assertThat(listener.stateMachineStartedLatch.await(3, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedLatch.await(3, TimeUnit.SECONDS)).isTrue(); listener.reset(0, 0, 0, 1); doSendEventAndConsumeAll(machine, "E3"); - assertThat(listener.sub3readyStateEnteredLatch.await(3, TimeUnit.SECONDS), is(true)); - assertThat(listener.sub3readyStateEnteredCount, is(1)); + assertThat(listener.sub3readyStateEnteredLatch.await(3, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.sub3readyStateEnteredCount).isEqualTo(1); doSendEventAndConsumeAll(machine, "E1"); Object executor = TestUtils.readField("stateMachineExecutor", machine); Collection readField = TestUtils.readField("deferList", executor); - assertThat(readField.size(), is(1)); + assertThat(readField).hasSize(1); listener.reset(0, 0, 2, 0); doSendEventAndConsumeAll(machine, "E4"); - assertThat(listener.readyStateEnteredLatch.await(3, TimeUnit.SECONDS), is(true)); - assertThat(listener.readyStateEnteredCount, is(2)); + assertThat(listener.readyStateEnteredLatch.await(3, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.readyStateEnteredCount).isEqualTo(2); - assertThat(machine.getState().getIds(), contains("READY")); + assertThat(machine.getState().getIds()).containsExactly("READY"); } @Test @@ -154,18 +150,18 @@ public class EventDeferTests extends AbstractStateMachineTests { TestListener listener = new TestListener(); machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(listener.stateMachineStartedLatch.await(3, TimeUnit.SECONDS), is(true)); + assertThat(listener.stateMachineStartedLatch.await(3, TimeUnit.SECONDS)).isTrue(); doSendEventAndConsumeAll(machine, "E1"); - assertThat(machine.getState().getIds(), contains("SUB1", "SUB11")); + assertThat(machine.getState().getIds()).containsExactly("SUB1", "SUB11"); // sub doesn't defer doSendEventAndConsumeAll(machine, "E15"); Object executor = TestUtils.readField("stateMachineExecutor", machine); Collection readField = TestUtils.readField("deferList", executor); - assertThat(readField.size(), is(0)); + assertThat(readField).isEmpty(); - assertThat(machine.getState().getIds(), contains("SUB5")); + assertThat(machine.getState().getIds()).containsExactly("SUB5"); } @Test @@ -176,26 +172,26 @@ public class EventDeferTests extends AbstractStateMachineTests { TestListener listener = new TestListener(); machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(listener.stateMachineStartedLatch.await(3, TimeUnit.SECONDS), is(true)); + assertThat(listener.stateMachineStartedLatch.await(3, TimeUnit.SECONDS)).isTrue(); doSendEventAndConsumeAll(machine, "E1"); - assertThat(machine.getState().getIds(), contains("SUB1", "SUB11")); + assertThat(machine.getState().getIds()).containsExactly("SUB1", "SUB11"); doSendEventAndConsumeAll(machine, "E1112"); - assertThat(machine.getState().getIds(), contains("SUB1", "SUB12")); + assertThat(machine.getState().getIds()).containsExactly("SUB1", "SUB12"); // sub defers doSendEventAndConsumeAll(machine, "E15"); Object executor = TestUtils.readField("stateMachineExecutor", machine); Collection readField = TestUtils.readField("deferList", executor); - assertThat(readField.size(), is(1)); + assertThat(readField).hasSize(1); - assertThat(machine.getState().getIds(), contains("SUB1", "SUB12")); + assertThat(machine.getState().getIds()).containsExactly("SUB1", "SUB12"); // from SUB12 to SUB11 should then cause E15 to fire in root // causing SUB1 to SUB5 doSendEventAndConsumeAll(machine, "E1211"); - assertThat(machine.getState().getIds(), contains("SUB5")); + assertThat(machine.getState().getIds()).containsExactly("SUB5"); } @Test @@ -206,19 +202,19 @@ public class EventDeferTests extends AbstractStateMachineTests { TestListener listener = new TestListener(); machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(listener.stateMachineStartedLatch.await(3, TimeUnit.SECONDS), is(true)); + assertThat(listener.stateMachineStartedLatch.await(3, TimeUnit.SECONDS)).isTrue(); doSendEventAndConsumeAll(machine, "E1"); - assertThat(machine.getState().getIds(), containsInAnyOrder("SUB111", "SUB1", "SUB121")); + assertThat(machine.getState().getIds()).containsOnly("SUB111", "SUB1", "SUB121"); doSendEventAndConsumeAll(machine, "E5"); - assertThat(machine.getState().getIds(), containsInAnyOrder("SUB112", "SUB1", "SUB121")); + assertThat(machine.getState().getIds()).containsOnly("SUB112", "SUB1", "SUB121"); // regions defers doSendEventAndConsumeAll(machine, "E3"); Object executor = TestUtils.readField("stateMachineExecutor", machine); Collection readField = TestUtils.readField("deferList", executor); - assertThat(readField.size(), is(0)); + assertThat(readField).isEmpty(); } @Test @@ -229,22 +225,22 @@ public class EventDeferTests extends AbstractStateMachineTests { TestListener listener = new TestListener(); machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(listener.stateMachineStartedLatch.await(3, TimeUnit.SECONDS), is(true)); + assertThat(listener.stateMachineStartedLatch.await(3, TimeUnit.SECONDS)).isTrue(); doSendEventAndConsumeAll(machine, "E1"); - assertThat(machine.getState().getIds(), containsInAnyOrder("SUB111", "SUB1", "SUB121")); + assertThat(machine.getState().getIds()).containsOnly("SUB111", "SUB1", "SUB121"); doSendEventAndConsumeAll(machine, "E5"); - assertThat(machine.getState().getIds(), containsInAnyOrder("SUB112", "SUB1", "SUB121")); + assertThat(machine.getState().getIds()).containsOnly("SUB112", "SUB1", "SUB121"); doSendEventAndConsumeAll(machine, "E8"); - assertThat(machine.getState().getIds(), containsInAnyOrder("SUB112", "SUB1", "SUB122")); + assertThat(machine.getState().getIds()).containsOnly("SUB112", "SUB1", "SUB122"); // regions defers doSendEventAndConsumeAll(machine, "E3"); Object executor = TestUtils.readField("stateMachineExecutor", machine); Collection readField = TestUtils.readField("deferList", executor); - assertThat(readField.size(), is(1)); + assertThat(readField).hasSize(1); } @Test @@ -255,18 +251,18 @@ public class EventDeferTests extends AbstractStateMachineTests { TestListener listener = new TestListener(); machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(listener.stateMachineStartedLatch.await(3, TimeUnit.SECONDS), is(true)); + assertThat(listener.stateMachineStartedLatch.await(3, TimeUnit.SECONDS)).isTrue(); doSendEventAndConsumeAll(machine, "E1"); - assertThat(machine.getState().getIds(), containsInAnyOrder("SUB111", "SUB1", "SUB121")); + assertThat(machine.getState().getIds()).containsOnly("SUB111", "SUB1", "SUB121"); // regions doesn't defer doSendEventAndConsumeAll(machine, "E3"); Object executor = TestUtils.readField("stateMachineExecutor", machine); Collection readField = TestUtils.readField("deferList", executor); - assertThat(readField.size(), is(0)); + assertThat(readField).isEmpty(); - assertThat(machine.getState().getIds(), contains("SUB2")); + assertThat(machine.getState().getIds()).containsExactly("SUB2"); } @Test @@ -276,22 +272,22 @@ public class EventDeferTests extends AbstractStateMachineTests { StateMachine machine = resolveMachine(context); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), containsInAnyOrder("S1")); + assertThat(machine.getState().getIds()).containsOnly("S1"); doSendEventAndConsumeAll(machine, "E2"); - assertThat(machine.getState().getIds(), containsInAnyOrder("S1")); + assertThat(machine.getState().getIds()).containsOnly("S1"); Object executor = TestUtils.readField("stateMachineExecutor", machine); Collection readField = TestUtils.readField("deferList", executor); - assertThat(readField.size(), is(1)); + assertThat(readField).hasSize(1); doSendEventAndConsumeAll(machine, "E1"); - assertThat(machine.getState().getIds(), containsInAnyOrder("S1")); + assertThat(machine.getState().getIds()).containsOnly("S1"); readField = TestUtils.readField("deferList", executor); - assertThat(readField.size(), is(0)); + assertThat(readField).isEmpty(); // deferred event handled so should not get back to S1 doSendEventAndConsumeAll(machine, "E1"); - assertThat(machine.getState().getIds(), containsInAnyOrder("S2")); + assertThat(machine.getState().getIds()).containsOnly("S2"); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/EventHeaderTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/EventHeaderTests.java index 32d9236c..76b88089 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/EventHeaderTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/EventHeaderTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,9 +15,7 @@ */ package org.springframework.statemachine; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.nullValue; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; import static org.springframework.statemachine.TestUtils.resolveMachine; @@ -60,20 +58,20 @@ public class EventHeaderTests extends AbstractStateMachineTests { machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); listener.reset(3); doSendEventAndConsumeAll(machine, MessageBuilder.withPayload("E1").setHeader("testHeader", "testValue").build()); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(3)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(3); - assertThat(headerTestAction1I.testHeader, is("testValue")); - assertThat(headerTestAction1.testHeader, is("testValue")); - assertThat(headerTestAction11.testHeader, is("testValue")); - assertThat(headerTestAction111.testHeader, is("testValue")); - assertThat(headerTestAction112.testHeader, nullValue()); + assertThat(headerTestAction1I.testHeader).isEqualTo("testValue"); + assertThat(headerTestAction1.testHeader).isEqualTo("testValue"); + assertThat(headerTestAction11.testHeader).isEqualTo("testValue"); + assertThat(headerTestAction111.testHeader).isEqualTo("testValue"); + assertThat(headerTestAction112.testHeader).isNull(); headerTestAction1.testHeader = null; headerTestAction11.testHeader = null; @@ -81,13 +79,13 @@ public class EventHeaderTests extends AbstractStateMachineTests { listener.reset(1); doSendEventAndConsumeAll(machine, MessageBuilder.withPayload("E2").setHeader("testHeader", "testValue").build()); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); - assertThat(headerTestAction1.testHeader, nullValue()); - assertThat(headerTestAction11.testHeader, nullValue()); - assertThat(headerTestAction111.testHeader, nullValue()); - assertThat(headerTestAction112.testHeader, is("testValue")); + assertThat(headerTestAction1.testHeader).isNull(); + assertThat(headerTestAction11.testHeader).isNull(); + assertThat(headerTestAction111.testHeader).isNull(); + assertThat(headerTestAction112.testHeader).isEqualTo("testValue"); } @Test @@ -104,19 +102,19 @@ public class EventHeaderTests extends AbstractStateMachineTests { machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); listener.reset(3); doSendEventAndConsumeAll(machine, MessageBuilder.withPayload("E1").setHeader("testHeader", "testValue").build()); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(3)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(3); - assertThat(headerTestAction1.testHeader, is("testValue")); - assertThat(headerTestAction11.testHeader, is("testValue")); - assertThat(headerTestAction111.testHeader, is("testValue")); - assertThat(headerTestAction112.testHeader, nullValue()); + assertThat(headerTestAction1.testHeader).isEqualTo("testValue"); + assertThat(headerTestAction11.testHeader).isEqualTo("testValue"); + assertThat(headerTestAction111.testHeader).isEqualTo("testValue"); + assertThat(headerTestAction112.testHeader).isNull(); headerTestAction1.testHeader = null; headerTestAction11.testHeader = null; @@ -124,13 +122,13 @@ public class EventHeaderTests extends AbstractStateMachineTests { listener.reset(1); doSendEventAndConsumeAll(machine, "E2"); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); - assertThat(headerTestAction1.testHeader, nullValue()); - assertThat(headerTestAction11.testHeader, nullValue()); - assertThat(headerTestAction111.testHeader, nullValue()); - assertThat(headerTestAction112.testHeader, nullValue()); + assertThat(headerTestAction1.testHeader).isNull(); + assertThat(headerTestAction11.testHeader).isNull(); + assertThat(headerTestAction111.testHeader).isNull(); + assertThat(headerTestAction112.testHeader).isNull(); } @Test @@ -148,19 +146,19 @@ public class EventHeaderTests extends AbstractStateMachineTests { machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); listener.reset(3); doSendEventAndConsumeAll(machine, MessageBuilder.withPayload("E1").setHeader("testHeader", "testValue").build()); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(3)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(3); listener.reset(1); doSendEventAndConsumeAll(machine, MessageBuilder.withPayload("E2").setHeader("testHeader", "testValue").build()); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); headerTestAction1I.testHeader = null; headerTestAction1.testHeader = null; @@ -169,14 +167,14 @@ public class EventHeaderTests extends AbstractStateMachineTests { headerTestAction112.testHeader = null; listener.reset(1); doSendEventAndConsumeAll(machine, MessageBuilder.withPayload("E3").setHeader("testHeader", "testValue").build()); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); - assertThat(headerTestAction1I.testHeader, nullValue()); - assertThat(headerTestAction1.testHeader, nullValue()); - assertThat(headerTestAction11.testHeader, nullValue()); - assertThat(headerTestAction111.testHeader, is("testValue")); - assertThat(headerTestAction112.testHeader, nullValue()); + assertThat(headerTestAction1I.testHeader).isNull(); + assertThat(headerTestAction1.testHeader).isNull(); + assertThat(headerTestAction11.testHeader).isNull(); + assertThat(headerTestAction111.testHeader).isEqualTo("testValue"); + assertThat(headerTestAction112.testHeader).isNull(); } @Test @@ -194,20 +192,20 @@ public class EventHeaderTests extends AbstractStateMachineTests { machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); listener.reset(3); doSendEventAndConsumeAll(machine, MessageBuilder.withPayload("E1").setHeader("testHeader", "testValue").build()); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(3)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(3); - assertThat(headerTestAction1I.testHeader, is("testValue")); - assertThat(headerTestAction1.testHeader, is("testValue")); - assertThat(headerTestAction11.testHeader, is("testValue")); - assertThat(headerTestAction111.testHeader, is("testValue")); - assertThat(headerTestAction112.testHeader, nullValue()); + assertThat(headerTestAction1I.testHeader).isEqualTo("testValue"); + assertThat(headerTestAction1.testHeader).isEqualTo("testValue"); + assertThat(headerTestAction11.testHeader).isEqualTo("testValue"); + assertThat(headerTestAction111.testHeader).isEqualTo("testValue"); + assertThat(headerTestAction112.testHeader).isNull(); headerTestAction1.testHeader = null; headerTestAction11.testHeader = null; @@ -215,13 +213,13 @@ public class EventHeaderTests extends AbstractStateMachineTests { listener.reset(1); doSendEventAndConsumeAll(machine, MessageBuilder.withPayload("E2").setHeader("testHeader", "testValue").build()); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); - assertThat(headerTestAction1.testHeader, nullValue()); - assertThat(headerTestAction11.testHeader, nullValue()); - assertThat(headerTestAction111.testHeader, nullValue()); - assertThat(headerTestAction112.testHeader, is("testValue")); + assertThat(headerTestAction1.testHeader).isNull(); + assertThat(headerTestAction11.testHeader).isNull(); + assertThat(headerTestAction111.testHeader).isNull(); + assertThat(headerTestAction112.testHeader).isEqualTo("testValue"); } @Test @@ -238,19 +236,19 @@ public class EventHeaderTests extends AbstractStateMachineTests { machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); listener.reset(3); doSendEventAndConsumeAll(machine, MessageBuilder.withPayload("E1").setHeader("testHeader", "testValue").build()); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(3)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(3); - assertThat(headerTestAction1.testHeader, is("testValue")); - assertThat(headerTestAction11.testHeader, is("testValue")); - assertThat(headerTestAction111.testHeader, is("testValue")); - assertThat(headerTestAction112.testHeader, nullValue()); + assertThat(headerTestAction1.testHeader).isEqualTo("testValue"); + assertThat(headerTestAction11.testHeader).isEqualTo("testValue"); + assertThat(headerTestAction111.testHeader).isEqualTo("testValue"); + assertThat(headerTestAction112.testHeader).isNull(); headerTestAction1.testHeader = null; headerTestAction11.testHeader = null; @@ -258,13 +256,13 @@ public class EventHeaderTests extends AbstractStateMachineTests { listener.reset(1); doSendEventAndConsumeAll(machine, "E2"); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); - assertThat(headerTestAction1.testHeader, nullValue()); - assertThat(headerTestAction11.testHeader, nullValue()); - assertThat(headerTestAction111.testHeader, nullValue()); - assertThat(headerTestAction112.testHeader, nullValue()); + assertThat(headerTestAction1.testHeader).isNull(); + assertThat(headerTestAction11.testHeader).isNull(); + assertThat(headerTestAction111.testHeader).isNull(); + assertThat(headerTestAction112.testHeader).isNull(); } @Test @@ -282,19 +280,19 @@ public class EventHeaderTests extends AbstractStateMachineTests { machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); listener.reset(3); doSendEventAndConsumeAll(machine, MessageBuilder.withPayload("E1").setHeader("testHeader", "testValue").build()); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(3)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(3); listener.reset(1); doSendEventAndConsumeAll(machine, MessageBuilder.withPayload("E2").setHeader("testHeader", "testValue").build()); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); headerTestAction1I.testHeader = null; headerTestAction1.testHeader = null; @@ -303,14 +301,14 @@ public class EventHeaderTests extends AbstractStateMachineTests { headerTestAction112.testHeader = null; listener.reset(1); doSendEventAndConsumeAll(machine, MessageBuilder.withPayload("E3").setHeader("testHeader", "testValue").build()); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); - assertThat(headerTestAction1I.testHeader, nullValue()); - assertThat(headerTestAction1.testHeader, nullValue()); - assertThat(headerTestAction11.testHeader, nullValue()); - assertThat(headerTestAction111.testHeader, is("testValue")); - assertThat(headerTestAction112.testHeader, nullValue()); + assertThat(headerTestAction1I.testHeader).isNull(); + assertThat(headerTestAction1.testHeader).isNull(); + assertThat(headerTestAction11.testHeader).isNull(); + assertThat(headerTestAction111.testHeader).isEqualTo("testValue"); + assertThat(headerTestAction112.testHeader).isNull(); } @Test @@ -326,18 +324,18 @@ public class EventHeaderTests extends AbstractStateMachineTests { machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); listener.reset(3); doSendEventAndConsumeAll(machine, MessageBuilder.withPayload("E1").setHeader("testHeader", "testValue").build()); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(3)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(3); - assertThat(headerTestAction1.testHeader, is("testValue")); - assertThat(headerTestAction2.testHeader, is("testValue")); - assertThat(headerTestAction3.testHeader, is("testValue")); + assertThat(headerTestAction1.testHeader).isEqualTo("testValue"); + assertThat(headerTestAction2.testHeader).isEqualTo("testValue"); + assertThat(headerTestAction3.testHeader).isEqualTo("testValue"); } @Test @@ -353,18 +351,18 @@ public class EventHeaderTests extends AbstractStateMachineTests { machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); listener.reset(3); doSendEventAndConsumeAll(machine, MessageBuilder.withPayload("E1").setHeader("testHeader", "testValue").build()); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(3)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(3); - assertThat(headerTestAction1.testHeader, is("testValue")); - assertThat(headerTestAction2.testHeader, is("testValue")); - assertThat(headerTestAction3.testHeader, is("testValue")); + assertThat(headerTestAction1.testHeader).isEqualTo("testValue"); + assertThat(headerTestAction2.testHeader).isEqualTo("testValue"); + assertThat(headerTestAction3.testHeader).isEqualTo("testValue"); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/RegionMachineTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/RegionMachineTests.java index fac0c2ce..a3448592 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/RegionMachineTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/RegionMachineTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,19 +15,13 @@ */ package org.springframework.statemachine; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.greaterThan; -import static org.hamcrest.Matchers.instanceOf; -import static org.hamcrest.Matchers.lessThan; -import static org.hamcrest.Matchers.notNullValue; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.assertj.core.api.Assertions.assertThat; import java.util.ArrayList; import java.util.Collection; import java.util.concurrent.TimeUnit; import java.util.function.Function; +import java.util.stream.Collectors; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.BeanFactory; @@ -45,7 +39,6 @@ import org.springframework.statemachine.region.Region; import org.springframework.statemachine.region.RegionExecutionPolicy; import org.springframework.statemachine.state.DefaultPseudoState; import org.springframework.statemachine.state.EnumState; -import org.springframework.statemachine.state.ObjectState; import org.springframework.statemachine.state.PseudoState; import org.springframework.statemachine.state.PseudoStateKind; import org.springframework.statemachine.state.RegionState; @@ -118,20 +111,20 @@ public class RegionMachineTests extends AbstractStateMachineTests { regions.add(machine); RegionState state = new RegionState(TestStates.S11, regions); - assertThat(state.isSimple(), is(false)); - assertThat(state.isComposite(), is(true)); - assertThat(state.isOrthogonal(), is(false)); - assertThat(state.isSubmachineState(), is(false)); + assertThat(state.isSimple()).isFalse(); + assertThat(state.isComposite()).isTrue(); + assertThat(state.isOrthogonal()).isFalse(); + assertThat(state.isSubmachineState()).isFalse(); - assertThat(state.getIds(), containsInAnyOrder(TestStates.SI, TestStates.S11)); + assertThat(state.getIds()).containsOnly(TestStates.SI, TestStates.S11); machine.sendEvent(TestEvents.E1); machine.sendEvent(TestEvents.E2); - assertThat(entryActionS1.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(exitActionS1.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(entryActionS1.stateContexts.size(), is(1)); - assertThat(exitActionS1.stateContexts.size(), is(1)); + assertThat(entryActionS1.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(exitActionS1.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(entryActionS1.stateContexts).hasSize(1); + assertThat(exitActionS1.stateContexts).hasSize(1); } @Test @@ -207,58 +200,58 @@ public class RegionMachineTests extends AbstractStateMachineTests { machine.afterPropertiesSet(); machine.start(); - assertThat(entryActionS111.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(exitActionS111.onExecuteLatch.await(1, TimeUnit.SECONDS), is(false)); - assertThat(entryActionS121.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(exitActionS121.onExecuteLatch.await(1, TimeUnit.SECONDS), is(false)); + assertThat(entryActionS111.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(exitActionS111.onExecuteLatch.await(1, TimeUnit.SECONDS)).isFalse(); + assertThat(entryActionS121.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(exitActionS121.onExecuteLatch.await(1, TimeUnit.SECONDS)).isFalse(); - assertThat(entryActionS111.stateContexts.size(), is(1)); - assertThat(exitActionS111.stateContexts.size(), is(0)); - assertThat(entryActionS121.stateContexts.size(), is(1)); - assertThat(exitActionS121.stateContexts.size(), is(0)); + assertThat(entryActionS111.stateContexts).hasSize(1); + assertThat(exitActionS111.stateContexts).isEmpty(); + assertThat(entryActionS121.stateContexts).hasSize(1); + assertThat(exitActionS121.stateContexts).isEmpty(); machine.sendEvent(TestEvents.E2); - assertThat(entryActionS111.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(exitActionS111.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(entryActionS112.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(exitActionS112.onExecuteLatch.await(1, TimeUnit.SECONDS), is(false)); + assertThat(entryActionS111.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(exitActionS111.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(entryActionS112.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(exitActionS112.onExecuteLatch.await(1, TimeUnit.SECONDS)).isFalse(); - assertThat(entryActionS111.stateContexts.size(), is(1)); - assertThat(exitActionS111.stateContexts.size(), is(1)); - assertThat(entryActionS112.stateContexts.size(), is(1)); - assertThat(exitActionS112.stateContexts.size(), is(0)); + assertThat(entryActionS111.stateContexts).hasSize(1); + assertThat(exitActionS111.stateContexts).hasSize(1); + assertThat(entryActionS112.stateContexts).hasSize(1); + assertThat(exitActionS112.stateContexts).isEmpty(); } @Test public void testMultiRegion() throws Exception { context.register(Config1.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); TestStateMachineListener listener = context.getBean(TestStateMachineListener.class); machine.addStateListener(listener); machine.start(); - assertThat(listener.stateMachineStartedLatch.await(5, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S10, TestStates.S20)); + assertThat(listener.stateMachineStartedLatch.await(5, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S10, TestStates.S20); listener.reset(2, 0); machine.sendEvent(TestEvents.E1); - assertThat(listener.stateChangedLatch.await(5, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S11, TestStates.S21)); + assertThat(listener.stateChangedLatch.await(5, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S11, TestStates.S21); listener.reset(1, 0); machine.sendEvent(TestEvents.E2); - assertThat(listener.stateChangedLatch.await(5, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S10, TestStates.S21)); + assertThat(listener.stateChangedLatch.await(5, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S10, TestStates.S21); listener.reset(1, 0); machine.sendEvent(TestEvents.E3); - assertThat(listener.stateChangedLatch.await(5, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S10, TestStates.S20)); + assertThat(listener.stateChangedLatch.await(5, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S10, TestStates.S20); } @SuppressWarnings("unchecked") @@ -268,88 +261,90 @@ public class RegionMachineTests extends AbstractStateMachineTests { context.refresh(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); Collection states = TestUtils.readField("states", machine); - assertThat(states.size(), is(3)); - - assertThat(states, containsInAnyOrder(instanceOf(ObjectState.class), instanceOf(ObjectState.class), instanceOf(RegionState.class))); + assertThat(states).hasSize(3); + assertThat(states.stream().map(s -> s.getClass().getName()).sorted().collect(Collectors.toList())) + .containsExactly("org.springframework.statemachine.state.ObjectState", + "org.springframework.statemachine.state.ObjectState", + "org.springframework.statemachine.state.RegionState"); TestStateMachineListener listener = context.getBean(TestStateMachineListener.class); machine.addStateListener(listener); machine.start(); listener.reset(3, 0); machine.sendEvent(TestEvents.E1); - assertThat(listener.stateChangedLatch.await(5, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S20, TestStates.S30)); + assertThat(listener.stateChangedLatch.await(5, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S20, TestStates.S30); } @Test public void testParallelRegionExecution() throws Exception { context.register(Config3.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); TestSleepAction action1 = context.getBean("action1", TestSleepAction.class); TestSleepAction action2 = context.getBean("action2", TestSleepAction.class); TestStateMachineListener listener = context.getBean(TestStateMachineListener.class); machine.addStateListener(listener); machine.start(); - assertThat(listener.stateMachineStartedLatch.await(5, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S10, TestStates.S20)); + assertThat(listener.stateMachineStartedLatch.await(5, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S10, TestStates.S20); listener.reset(2, 0); machine.sendEvent(TestEvents.E1); - assertThat(listener.stateChangedLatch.await(5, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S11, TestStates.S21)); + assertThat(listener.stateChangedLatch.await(5, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S11, TestStates.S21); listener.reset(1, 0); machine.sendEvent(TestEvents.E2); - assertThat(listener.stateChangedLatch.await(5, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S10, TestStates.S21)); + assertThat(listener.stateChangedLatch.await(5, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S10, TestStates.S21); listener.reset(1, 0); machine.sendEvent(TestEvents.E3); - assertThat(listener.stateChangedLatch.await(5, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S10, TestStates.S20)); + assertThat(listener.stateChangedLatch.await(5, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S10, TestStates.S20); // check that actions are called and that both are executed // within a time which is less than their sleep time, // indicating that we must have paralled execution - assertThat(action1.now, greaterThan(0l)); - assertThat(action2.now, greaterThan(0l)); - assertThat(Math.abs(action1.now-action2.now), lessThan(1999l)); + assertThat(action1.now).isGreaterThan(0l); + assertThat(action2.now).isGreaterThan(0l); + assertThat(Math.abs(action1.now-action2.now)).isLessThan(1999l); } @Test public void testParallelRegionExecutionInInitialState() throws Exception { context.register(Config4.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); TestSleepAction action1 = context.getBean("action1", TestSleepAction.class); TestSleepAction action2 = context.getBean("action2", TestSleepAction.class); TestStateMachineListener listener = context.getBean(TestStateMachineListener.class); machine.addStateListener(listener); machine.start(); - assertThat(listener.stateMachineStartedLatch.await(5, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S10, TestStates.S20)); + assertThat(listener.stateMachineStartedLatch.await(5, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S10, TestStates.S20); listener.reset(2, 0); machine.sendEvent(TestEvents.E1); - assertThat(listener.stateChangedLatch.await(5, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S11, TestStates.S21)); + assertThat(listener.stateChangedLatch.await(5, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S11, TestStates.S21); // check that actions are called and that both are executed // within a time which is less than their sleep time, // indicating that we must have paralled execution - assertThat(action1.now, greaterThan(0l)); - assertThat(action2.now, greaterThan(0l)); - assertThat(Math.abs(action1.now-action2.now), lessThan(1999l)); + assertThat(action1.now).isGreaterThan(0l); + assertThat(action2.now).isGreaterThan(0l); + assertThat(Math.abs(action1.now-action2.now)).isLessThan(1999l); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/RelayTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/RelayTests.java index 42da3465..a41af4a0 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/RelayTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/RelayTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,10 +15,7 @@ */ package org.springframework.statemachine; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.notNullValue; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; import static org.springframework.statemachine.TestUtils.resolveMachine; @@ -50,14 +47,14 @@ public class RelayTests extends AbstractStateMachineTests { context.register(Config1.class); context.refresh(); StateMachine machine = resolveMachine(context); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); TestStateMachineListener listener = new TestStateMachineListener(); machine.addStateListener(listener); doStartAndAssert(machine); listener.reset(3, 0); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(listener.stateChangedLatch.await(5, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), contains(TestStates.S2, TestStates.S21)); + assertThat(listener.stateChangedLatch.await(5, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S2, TestStates.S21); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/StateContextTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/StateContextTests.java index 6475c254..eafc192a 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/StateContextTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/StateContextTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,14 +15,7 @@ */ package org.springframework.statemachine; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.equalTo; -import static org.hamcrest.Matchers.hasSize; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.notNullValue; -import static org.hamcrest.Matchers.nullValue; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; import static org.springframework.statemachine.TestUtils.resolveMachine; @@ -30,9 +23,8 @@ import static org.springframework.statemachine.TestUtils.resolveMachine; import java.util.ArrayList; import java.util.Arrays; import java.util.Map; +import java.util.stream.Collectors; -import org.hamcrest.FeatureMatcher; -import org.hamcrest.Matcher; import org.junit.jupiter.api.Test; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.context.annotation.Bean; @@ -63,95 +55,95 @@ public class StateContextTests extends AbstractStateMachineTests { machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0, States.S1, States.S11)); - assertThat(listener.contexts, hasSize(19)); - - assertThat(listener.contexts, contains( + assertThat(machine.getState().getIds()).containsOnly(States.S0, States.S1, States.S11); + assertThat(listener.contexts).hasSize(19); + assertThat(listener.contexts.stream().map(c -> c.getStage()).collect(Collectors.toList())).containsExactly( Arrays.asList( - hasStage(Stage.TRANSITION_START), - hasStage(Stage.EXTENDED_STATE_CHANGED), - hasStage(Stage.TRANSITION), - hasStage(Stage.STATE_ENTRY), - hasStage(Stage.TRANSITION_START), - hasStage(Stage.TRANSITION), - hasStage(Stage.STATE_ENTRY), - hasStage(Stage.TRANSITION_START), - hasStage(Stage.TRANSITION), - hasStage(Stage.STATE_ENTRY), - hasStage(Stage.STATE_CHANGED), - hasStage(Stage.STATEMACHINE_START), - hasStage(Stage.TRANSITION_END), - hasStage(Stage.STATE_CHANGED), - hasStage(Stage.STATEMACHINE_START), - hasStage(Stage.TRANSITION_END), - hasStage(Stage.STATE_CHANGED), - hasStage(Stage.STATEMACHINE_START), - hasStage(Stage.TRANSITION_END)) - )); + Stage.TRANSITION_START, + Stage.EXTENDED_STATE_CHANGED, + Stage.TRANSITION, + Stage.STATE_ENTRY, + Stage.TRANSITION_START, + Stage.TRANSITION, + Stage.STATE_ENTRY, + Stage.TRANSITION_START, + Stage.TRANSITION, + Stage.STATE_ENTRY, + Stage.STATE_CHANGED, + Stage.STATEMACHINE_START, + Stage.TRANSITION_END, + Stage.STATE_CHANGED, + Stage.STATEMACHINE_START, + Stage.TRANSITION_END, + Stage.STATE_CHANGED, + Stage.STATEMACHINE_START, + Stage.TRANSITION_END + ).toArray(new Stage[0]) + ); - assertThat(listener.contexts.get(0).getStage(), is(Stage.TRANSITION_START)); - assertThat(listener.contexts.get(0).getTransition(), notNullValue()); - assertThat(listener.contexts.get(0).getTransition().getSource(), nullValue()); - assertThat(listener.contexts.get(0).getTransition().getTarget(), notNullValue()); - assertThat(listener.contexts.get(0).getTransition().getTarget().getId(), is(States.S0)); - assertThat(listener.contexts.get(0).getSource(), nullValue()); - assertThat(listener.contexts.get(0).getTarget(), notNullValue()); + assertThat(listener.contexts.get(0).getStage()).isEqualTo(Stage.TRANSITION_START); + assertThat(listener.contexts.get(0).getTransition()).isNotNull(); + assertThat(listener.contexts.get(0).getTransition().getSource()).isNull(); + assertThat(listener.contexts.get(0).getTransition().getTarget()).isNotNull(); + assertThat(listener.contexts.get(0).getTransition().getTarget().getId()).isEqualTo(States.S0); + assertThat(listener.contexts.get(0).getSource()).isNull(); + assertThat(listener.contexts.get(0).getTarget()).isNotNull(); - assertThat(listener.contexts.get(1).getStage(), is(Stage.EXTENDED_STATE_CHANGED)); + assertThat(listener.contexts.get(1).getStage()).isEqualTo(Stage.EXTENDED_STATE_CHANGED); - assertThat(listener.contexts.get(2).getStage(), is(Stage.TRANSITION)); - assertThat(listener.contexts.get(2).getTransition(), notNullValue()); - assertThat(listener.contexts.get(2).getTransition().getSource(), nullValue()); - assertThat(listener.contexts.get(2).getTransition().getTarget(), notNullValue()); - assertThat(listener.contexts.get(2).getTransition().getTarget().getId(), is(States.S0)); - assertThat(listener.contexts.get(2).getSource(), nullValue()); - assertThat(listener.contexts.get(2).getTarget(), notNullValue()); + assertThat(listener.contexts.get(2).getStage()).isEqualTo(Stage.TRANSITION); + assertThat(listener.contexts.get(2).getTransition()).isNotNull(); + assertThat(listener.contexts.get(2).getTransition().getSource()).isNull(); + assertThat(listener.contexts.get(2).getTransition().getTarget()).isNotNull(); + assertThat(listener.contexts.get(2).getTransition().getTarget().getId()).isEqualTo(States.S0); + assertThat(listener.contexts.get(2).getSource()).isNull(); + assertThat(listener.contexts.get(2).getTarget()).isNotNull(); - assertThat(listener.contexts.get(3).getStage(), is(Stage.STATE_ENTRY)); - assertThat(listener.contexts.get(3).getTarget(), notNullValue()); - assertThat(listener.contexts.get(3).getTarget().getId(), is(States.S0)); - assertThat(listener.contexts.get(3).getTransition(), notNullValue()); + assertThat(listener.contexts.get(3).getStage()).isEqualTo(Stage.STATE_ENTRY); + assertThat(listener.contexts.get(3).getTarget()).isNotNull(); + assertThat(listener.contexts.get(3).getTarget().getId()).isEqualTo(States.S0); + assertThat(listener.contexts.get(3).getTransition()).isNotNull(); - assertThat(listener.contexts.get(4).getStage(), is(Stage.TRANSITION_START)); + assertThat(listener.contexts.get(4).getStage()).isEqualTo(Stage.TRANSITION_START); - assertThat(listener.contexts.get(5).getStage(), is(Stage.TRANSITION)); + assertThat(listener.contexts.get(5).getStage()).isEqualTo(Stage.TRANSITION); - assertThat(listener.contexts.get(6).getStage(), is(Stage.STATE_ENTRY)); - assertThat(listener.contexts.get(6).getTarget(), notNullValue()); - assertThat(listener.contexts.get(6).getTarget().getId(), is(States.S1)); - assertThat(listener.contexts.get(6).getTransition(), notNullValue()); + assertThat(listener.contexts.get(6).getStage()).isEqualTo(Stage.STATE_ENTRY); + assertThat(listener.contexts.get(6).getTarget()).isNotNull(); + assertThat(listener.contexts.get(6).getTarget().getId()).isEqualTo(States.S1); + assertThat(listener.contexts.get(6).getTransition()).isNotNull(); - assertThat(listener.contexts.get(7).getStage(), is(Stage.TRANSITION_START)); + assertThat(listener.contexts.get(7).getStage()).isEqualTo(Stage.TRANSITION_START); - assertThat(listener.contexts.get(8).getStage(), is(Stage.TRANSITION)); + assertThat(listener.contexts.get(8).getStage()).isEqualTo(Stage.TRANSITION); - assertThat(listener.contexts.get(9).getStage(), is(Stage.STATE_ENTRY)); - assertThat(listener.contexts.get(9).getTarget(), notNullValue()); - assertThat(listener.contexts.get(9).getTarget().getId(), is(States.S11)); - assertThat(listener.contexts.get(9).getTransition(), notNullValue()); + assertThat(listener.contexts.get(9).getStage()).isEqualTo(Stage.STATE_ENTRY); + assertThat(listener.contexts.get(9).getTarget()).isNotNull(); + assertThat(listener.contexts.get(9).getTarget().getId()).isEqualTo(States.S11); + assertThat(listener.contexts.get(9).getTransition()).isNotNull(); - assertThat(listener.contexts.get(10).getStage(), is(Stage.STATE_CHANGED)); + assertThat(listener.contexts.get(10).getStage()).isEqualTo(Stage.STATE_CHANGED); - assertThat(listener.contexts.get(11).getStage(), is(Stage.STATEMACHINE_START)); - assertThat(listener.contexts.get(11).getTransition(), notNullValue()); + assertThat(listener.contexts.get(11).getStage()).isEqualTo(Stage.STATEMACHINE_START); + assertThat(listener.contexts.get(11).getTransition()).isNotNull(); - assertThat(listener.contexts.get(12).getStage(), is(Stage.TRANSITION_END)); + assertThat(listener.contexts.get(12).getStage()).isEqualTo(Stage.TRANSITION_END); - assertThat(listener.contexts.get(13).getStage(), is(Stage.STATE_CHANGED)); + assertThat(listener.contexts.get(13).getStage()).isEqualTo(Stage.STATE_CHANGED); - assertThat(listener.contexts.get(14).getStage(), is(Stage.STATEMACHINE_START)); - assertThat(listener.contexts.get(14).getTransition(), notNullValue()); + assertThat(listener.contexts.get(14).getStage()).isEqualTo(Stage.STATEMACHINE_START); + assertThat(listener.contexts.get(14).getTransition()).isNotNull(); - assertThat(listener.contexts.get(15).getStage(), is(Stage.TRANSITION_END)); + assertThat(listener.contexts.get(15).getStage()).isEqualTo(Stage.TRANSITION_END); - assertThat(listener.contexts.get(16).getStage(), is(Stage.STATE_CHANGED)); + assertThat(listener.contexts.get(16).getStage()).isEqualTo(Stage.STATE_CHANGED); - assertThat(listener.contexts.get(17).getStage(), is(Stage.STATEMACHINE_START)); - assertThat(listener.contexts.get(17).getTransition(), notNullValue()); + assertThat(listener.contexts.get(17).getStage()).isEqualTo(Stage.STATEMACHINE_START); + assertThat(listener.contexts.get(17).getTransition()).isNotNull(); - assertThat(listener.contexts.get(18).getStage(), is(Stage.TRANSITION_END)); - assertThat(listener.contexts.get(18).getTransition(), notNullValue()); + assertThat(listener.contexts.get(18).getStage()).isEqualTo(Stage.TRANSITION_END); + assertThat(listener.contexts.get(18).getTransition()).isNotNull(); } @Test @@ -169,19 +161,20 @@ public class StateContextTests extends AbstractStateMachineTests { doSendEventAndConsumeAll(machine, Events.J); // all nested machines sends these - assertThat(listener.contexts, contains( + assertThat(listener.contexts.stream().map(c -> c.getStage()).collect(Collectors.toList())).containsExactly( Arrays.asList( - hasStage(Stage.EVENT_NOT_ACCEPTED), - hasStage(Stage.EVENT_NOT_ACCEPTED), - hasStage(Stage.EVENT_NOT_ACCEPTED)) - )); + Stage.EVENT_NOT_ACCEPTED, + Stage.EVENT_NOT_ACCEPTED, + Stage.EVENT_NOT_ACCEPTED + ).toArray(new Stage[0]) + ); - assertThat(listener.contexts.get(0).getStage(), is(Stage.EVENT_NOT_ACCEPTED)); - assertThat(listener.contexts.get(0).getTransition(), nullValue()); - assertThat(listener.contexts.get(0).getEvent(), is(Events.J)); - assertThat(listener.contexts.get(0).getSource(), notNullValue()); - assertThat(listener.contexts.get(0).getSource().getId(), is(States.S0)); - assertThat(listener.contexts.get(0).getTarget(), nullValue()); + assertThat(listener.contexts.get(0).getStage()).isEqualTo(Stage.EVENT_NOT_ACCEPTED); + assertThat(listener.contexts.get(0).getTransition()).isNull(); + assertThat(listener.contexts.get(0).getEvent()).isEqualTo(Events.J); + assertThat(listener.contexts.get(0).getSource()).isNotNull(); + assertThat(listener.contexts.get(0).getSource().getId()).isEqualTo(States.S0); + assertThat(listener.contexts.get(0).getTarget()).isNull(); } static class TestStateMachineListener extends StateMachineListenerAdapter { @@ -194,15 +187,6 @@ public class StateContextTests extends AbstractStateMachineTests { } } - private static Matcher> hasStage(final Stage stage) { - return new FeatureMatcher, Stage>(equalTo(stage), "stage", "stage") { - @Override - protected Stage featureValueOf(final StateContext actual) { - return actual.getStage(); - } - }; - } - @Configuration @EnableStateMachine static class Config1 extends EnumStateMachineConfigurerAdapter { diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/StateMachineFactoryTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/StateMachineFactoryTests.java index 57142788..52063b34 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/StateMachineFactoryTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/StateMachineFactoryTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,10 +15,7 @@ */ package org.springframework.statemachine; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.notNullValue; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; import static org.springframework.statemachine.TestUtils.resolveFactory; @@ -61,8 +58,8 @@ public class StateMachineFactoryTests extends AbstractStateMachineTests { StateMachine machine = factory.getStateMachine(); doStartAndAssert(machine); - assertThat(machine, notNullValue()); - assertThat(machine.getState().getId(), is(TestStates.S1)); + assertThat(machine).isNotNull(); + assertThat(machine.getState().getId()).isEqualTo(TestStates.S1); } @Test @@ -74,9 +71,9 @@ public class StateMachineFactoryTests extends AbstractStateMachineTests { StateMachine machine = stateMachineFactory.getStateMachine(); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(machine.getState().getIds(), contains(TestStates.S2)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S2); } @Test @@ -86,8 +83,8 @@ public class StateMachineFactoryTests extends AbstractStateMachineTests { StateMachineFactory stateMachineFactory = resolveFactory(context); StateMachine machine = stateMachineFactory.getStateMachine(); - assertThat(((SmartLifecycle)machine).isAutoStartup(), is(true)); - assertThat(((SmartLifecycle)machine).isRunning(), is(true)); + assertThat(((SmartLifecycle)machine).isAutoStartup()).isTrue(); + assertThat(((SmartLifecycle)machine).isRunning()).isTrue(); } @Test @@ -97,8 +94,8 @@ public class StateMachineFactoryTests extends AbstractStateMachineTests { StateMachineFactory stateMachineFactory = resolveFactory(context); StateMachine machine = stateMachineFactory.getStateMachine(); - assertThat(((SmartLifecycle)machine).isAutoStartup(), is(false)); - assertThat(((SmartLifecycle)machine).isRunning(), is(false)); + assertThat(((SmartLifecycle)machine).isAutoStartup()).isFalse(); + assertThat(((SmartLifecycle)machine).isRunning()).isFalse(); } @Test @@ -109,7 +106,7 @@ public class StateMachineFactoryTests extends AbstractStateMachineTests { StateMachine machine = stateMachineFactory.getStateMachine(); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); } @Test @@ -124,8 +121,8 @@ public class StateMachineFactoryTests extends AbstractStateMachineTests { doStartAndAssert(machine1); doStartAndAssert(machine2); - assertThat(machine1.getState().getIds(), contains(TestStates.S1)); - assertThat(machine2.getState().getIds(), contains(TestStates.S1)); + assertThat(machine1.getState().getIds()).containsExactly(TestStates.S1); + assertThat(machine2.getState().getIds()).containsExactly(TestStates.S1); } @Test @@ -138,15 +135,15 @@ public class StateMachineFactoryTests extends AbstractStateMachineTests { // factory waits machine to get started so we // should have state immediately - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); // still need to listen state chance manually before // checking state as execution happens in a thread TestStateMachineListener listener = new TestStateMachineListener(); machine.addStateListener(listener); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(listener.latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), contains(TestStates.S2)); + assertThat(listener.latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S2); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/StateMachineResetTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/StateMachineResetTests.java index 956f97ce..185f552f 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/StateMachineResetTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/StateMachineResetTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,12 +15,7 @@ */ package org.springframework.statemachine; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.nullValue; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; import static org.springframework.statemachine.TestUtils.doStopAndAssert; @@ -79,8 +74,8 @@ public class StateMachineResetTests extends AbstractStateMachineTests { machine.getStateMachineAccessor().doWithAllRegions(function -> function.resetStateMachine(stateMachineContext)); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0, States.S1, States.S12)); - assertThat((Integer)machine.getExtendedState().getVariables().get("foo"), is(1)); + assertThat(machine.getState().getIds()).containsOnly(States.S0, States.S1, States.S12); + assertThat((Integer)machine.getExtendedState().getVariables().get("foo")).isEqualTo(1); } @Test @@ -97,8 +92,8 @@ public class StateMachineResetTests extends AbstractStateMachineTests { machine.getStateMachineAccessor().doWithAllRegions(function -> function.resetStateMachine(stateMachineContext)); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0, States.S2, States.S21, States.S211)); - assertThat((Integer)machine.getExtendedState().getVariables().get("foo"), is(1)); + assertThat(machine.getState().getIds()).containsOnly(States.S0, States.S2, States.S21, States.S211); + assertThat((Integer)machine.getExtendedState().getVariables().get("foo")).isEqualTo(1); } @Test @@ -115,8 +110,8 @@ public class StateMachineResetTests extends AbstractStateMachineTests { machine.getStateMachineAccessor().doWithAllRegions(function -> function.resetStateMachine(stateMachineContext)); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0, States.S2, States.S21, States.S211)); - assertThat((Integer)machine.getExtendedState().getVariables().get("foo"), is(1)); + assertThat(machine.getState().getIds()).containsOnly(States.S0, States.S2, States.S21, States.S211); + assertThat((Integer)machine.getExtendedState().getVariables().get("foo")).isEqualTo(1); } @Test @@ -140,7 +135,7 @@ public class StateMachineResetTests extends AbstractStateMachineTests { machine.getStateMachineAccessor().doWithAllRegions(function -> function.resetStateMachine(stateMachineContext)); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S31)); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S31); } @Test @@ -164,7 +159,7 @@ public class StateMachineResetTests extends AbstractStateMachineTests { machine.getStateMachineAccessor().doWithAllRegions(function -> function.resetStateMachine(stateMachineContext)); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S31)); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S31); } @Test @@ -173,9 +168,9 @@ public class StateMachineResetTests extends AbstractStateMachineTests { context.refresh(); StateMachine machine = resolveMachine(context); - assertThat((Integer)machine.getExtendedState().getVariables().get("count"), nullValue()); + assertThat((Integer)machine.getExtendedState().getVariables().get("count")).isNull(); doSendEventAndConsumeAll(machine, Events.A); - assertThat((Integer)machine.getExtendedState().getVariables().get("count"), is(1)); + assertThat((Integer)machine.getExtendedState().getVariables().get("count")).isEqualTo(1); doStopAndAssert(machine); Map variables = new HashMap(); @@ -186,9 +181,9 @@ public class StateMachineResetTests extends AbstractStateMachineTests { machine.getStateMachineAccessor().doWithAllRegions(function -> function.resetStateMachine(stateMachineContext)); doStartAndAssert(machine); - assertThat((Integer)machine.getExtendedState().getVariables().get("count"), is(1)); + assertThat((Integer)machine.getExtendedState().getVariables().get("count")).isEqualTo(1); doSendEventAndConsumeAll(machine, Events.A); - assertThat((Integer)machine.getExtendedState().getVariables().get("count"), is(2)); + assertThat((Integer)machine.getExtendedState().getVariables().get("count")).isEqualTo(2); } @Test @@ -198,18 +193,18 @@ public class StateMachineResetTests extends AbstractStateMachineTests { StateMachine machine = resolveMachine(context); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0, States.S1, States.S11)); - assertThat((Integer)machine.getExtendedState().getVariables().get("foo"), is(0)); + assertThat(machine.getState().getIds()).containsOnly(States.S0, States.S1, States.S11); + assertThat((Integer)machine.getExtendedState().getVariables().get("foo")).isZero(); doSendEventAndConsumeAll(machine, Events.I); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0, States.S1, States.S12)); - assertThat((Integer)machine.getExtendedState().getVariables().get("foo"), is(0)); + assertThat(machine.getState().getIds()).containsOnly(States.S0, States.S1, States.S12); + assertThat((Integer)machine.getExtendedState().getVariables().get("foo")).isZero(); doStopAndAssert(machine); machine.getStateMachineAccessor().doWithAllRegions(function -> function.resetStateMachine(null)); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0, States.S1, States.S11)); - assertThat(machine.getExtendedState().getVariables().size(), is(0)); + assertThat(machine.getState().getIds()).containsOnly(States.S0, States.S1, States.S11); + assertThat(machine.getExtendedState().getVariables()).isEmpty(); } @Test @@ -219,10 +214,10 @@ public class StateMachineResetTests extends AbstractStateMachineTests { StateMachine machine = resolveMachine(context); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0, States.S1, States.S11)); + assertThat(machine.getState().getIds()).containsOnly(States.S0, States.S1, States.S11); doSendEventAndConsumeAll(machine, Events.I); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0, States.S1, States.S12)); + assertThat(machine.getState().getIds()).containsOnly(States.S0, States.S1, States.S12); doStopAndAssert(machine); DefaultStateMachineContext stateMachineContext = new DefaultStateMachineContext( @@ -231,9 +226,9 @@ public class StateMachineResetTests extends AbstractStateMachineTests { .doWithAllRegions(function -> function.resetStateMachine(stateMachineContext)); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0, States.S1, States.S11)); - assertEquals(States.S11, stateMachineContext.getState()); - assertNotEquals(stateMachineContext.getState(), machine.getInitialState()); + assertThat(machine.getState().getIds()).containsOnly(States.S0, States.S1, States.S11); + assertThat(States.S11).isEqualTo(stateMachineContext.getState()); + assertThat(stateMachineContext.getState()).isNotEqualTo(machine.getInitialState()); } @Test @@ -249,7 +244,7 @@ public class StateMachineResetTests extends AbstractStateMachineTests { doStartAndAssert(machine); Thread.sleep(1100); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S2)); + assertThat(machine.getState().getIds()).containsOnly(States.S2); } @@ -261,27 +256,27 @@ public class StateMachineResetTests extends AbstractStateMachineTests { CountListener listener = new CountListener(); machine.addStateListener(listener); - assertThat((Integer)machine.getExtendedState().getVariables().get("count1"), nullValue()); - assertThat(listener.count1, nullValue()); - assertThat(listener.count2, nullValue()); + assertThat((Integer)machine.getExtendedState().getVariables().get("count1")).isNull(); + assertThat(listener.count1).isNull(); + assertThat(listener.count2).isNull(); doSendEventAndConsumeAll(machine, Events.A); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S1, States.S11)); - assertThat((Integer)machine.getExtendedState().getVariables().get("count1"), is(1)); - assertThat(listener.count1, is(1)); + assertThat(machine.getState().getIds()).containsOnly(States.S1, States.S11); + assertThat((Integer)machine.getExtendedState().getVariables().get("count1")).isEqualTo(1); + assertThat(listener.count1).isEqualTo(1); // listener is called before action is executed - assertThat(listener.count2, nullValue()); + assertThat(listener.count2).isNull(); - assertThat((Integer)machine.getExtendedState().getVariables().get("count2"), nullValue()); + assertThat((Integer)machine.getExtendedState().getVariables().get("count2")).isNull(); doSendEventAndConsumeAll(machine, Events.B); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S1, States.S12)); - assertThat((Integer)machine.getExtendedState().getVariables().get("count2"), is(1)); - assertThat(listener.count1, is(1)); - assertThat(listener.count2, nullValue()); + assertThat(machine.getState().getIds()).containsOnly(States.S1, States.S12); + assertThat((Integer)machine.getExtendedState().getVariables().get("count2")).isEqualTo(1); + assertThat(listener.count1).isEqualTo(1); + assertThat(listener.count2).isNull(); doSendEventAndConsumeAll(machine, Events.C); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0)); - assertThat(listener.count1, is(1)); - assertThat(listener.count2, is(1)); + assertThat(machine.getState().getIds()).containsOnly(States.S0); + assertThat(listener.count1).isEqualTo(1); + assertThat(listener.count2).isEqualTo(1); doStopAndAssert(machine); Map variables = new HashMap(); @@ -292,22 +287,22 @@ public class StateMachineResetTests extends AbstractStateMachineTests { machine.getStateMachineAccessor().doWithAllRegions(function -> function.resetStateMachine(stateMachineContext)); doStartAndAssert(machine); - assertThat((Integer)machine.getExtendedState().getVariables().get("count1"), is(1)); - assertThat(listener.count1, is(1)); - assertThat(listener.count2, is(1)); + assertThat((Integer)machine.getExtendedState().getVariables().get("count1")).isEqualTo(1); + assertThat(listener.count1).isEqualTo(1); + assertThat(listener.count2).isEqualTo(1); doSendEventAndConsumeAll(machine, Events.A); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S1, States.S11)); - assertThat((Integer)machine.getExtendedState().getVariables().get("count1"), is(2)); - assertThat(listener.count1, is(2)); + assertThat(machine.getState().getIds()).containsOnly(States.S1, States.S11); + assertThat((Integer)machine.getExtendedState().getVariables().get("count1")).isEqualTo(2); + assertThat(listener.count1).isEqualTo(2); // listener is called before action is executed - assertThat(listener.count2, is(1)); + assertThat(listener.count2).isEqualTo(1); - assertThat((Integer)machine.getExtendedState().getVariables().get("count2"), is(1)); + assertThat((Integer)machine.getExtendedState().getVariables().get("count2")).isEqualTo(1); doSendEventAndConsumeAll(machine, Events.B); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S1, States.S12)); - assertThat((Integer)machine.getExtendedState().getVariables().get("count2"), is(2)); - assertThat(listener.count1, is(2)); - assertThat(listener.count2, is(1)); + assertThat(machine.getState().getIds()).containsOnly(States.S1, States.S12); + assertThat((Integer)machine.getExtendedState().getVariables().get("count2")).isEqualTo(2); + assertThat(listener.count1).isEqualTo(2); + assertThat(listener.count2).isEqualTo(1); } @Test @@ -323,7 +318,7 @@ public class StateMachineResetTests extends AbstractStateMachineTests { machine.getStateMachineAccessor().doWithAllRegions(function -> function.resetStateMachine(stateMachineContext)); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), containsInAnyOrder(SuperState.PARENT, SubState.SUB_NEXT)); + assertThat(machine.getState().getIds()).containsOnly(SuperState.PARENT, SubState.SUB_NEXT); } @Test @@ -339,7 +334,7 @@ public class StateMachineResetTests extends AbstractStateMachineTests { machine.getStateMachineAccessor().doWithAllRegions(function -> function.resetStateMachine(stateMachineContext)); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), containsInAnyOrder(SuperState.INITIAL)); + assertThat(machine.getState().getIds()).containsOnly(SuperState.INITIAL); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/StateMachineTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/StateMachineTests.java index ea1bfc1c..0ca41b6e 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/StateMachineTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/StateMachineTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,12 +15,7 @@ */ package org.springframework.statemachine; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.notNullValue; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; import static org.springframework.statemachine.TestUtils.resolveMachine; @@ -59,9 +54,9 @@ public class StateMachineTests extends AbstractStateMachineTests { public void testLoggingEvents() { context.register(Config1.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); StateMachine machine = resolveMachine(context); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); doStartAndAssert(machine); doSendEventAndConsumeAll(machine, MessageBuilder.withPayload(TestEvents.E1).setHeader("foo", "jee1").build()); doSendEventAndConsumeAll(machine, MessageBuilder.withPayload(TestEvents.E2).setHeader("foo", "jee2").build()); @@ -83,37 +78,37 @@ public class StateMachineTests extends AbstractStateMachineTests { machine.addStateListener(listener); listener.reset(1); doStartAndAssert(machine); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(testAction2.stateContexts.size(), is(0)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(testAction2.stateContexts).isEmpty(); listener.reset(0, 1); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(listener.transitionLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(testAction1.onExecuteLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(testAction1.stateContexts.size(), is(1)); - assertThat(testAction2.onExecuteLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(testAction2.stateContexts.size(), is(1)); + assertThat(listener.transitionLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(testAction1.onExecuteLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(testAction1.stateContexts).hasSize(1); + assertThat(testAction2.onExecuteLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(testAction2.stateContexts).hasSize(1); listener.reset(0, 1); doSendEventAndConsumeAll(machine, TestEvents.E2); - assertThat(listener.transitionLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(testAction3.onExecuteLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(testAction3.stateContexts.size(), is(1)); + assertThat(listener.transitionLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(testAction3.onExecuteLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(testAction3.stateContexts).hasSize(1); // timer still fires but should not cause transition anymore // after we sleep and do next event int timedTriggered = testAction2.stateContexts.size(); Thread.sleep(2000); - assertThat(testAction2.stateContexts.size(), is(timedTriggered)); + assertThat(testAction2.stateContexts).hasSize(timedTriggered); listener.reset(0, 1); doSendEventAndConsumeAll(machine, TestEvents.E3); - assertThat(listener.transitionLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(testAction4.onExecuteLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(testAction4.stateContexts.size(), is(1)); - assertThat(testAction2.stateContexts.size(), is(timedTriggered)); + assertThat(listener.transitionLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(testAction4.onExecuteLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(testAction4.stateContexts).hasSize(1); + assertThat(testAction2.stateContexts).hasSize(timedTriggered); } @Test @@ -124,50 +119,50 @@ public class StateMachineTests extends AbstractStateMachineTests { TestListener listener = new TestListener(); machine.addStateListener(listener); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); listener.reset(1); doStartAndAssert(machine); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), contains(TestStates.SI)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsExactly(TestStates.SI); listener.reset(3); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(listener.stateChangedLatch.await(3, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(3)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S20, TestStates.S30)); + assertThat(listener.stateChangedLatch.await(3, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(3); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S20, TestStates.S30); listener.reset(1); doSendEventAndConsumeAll(machine, TestEvents.E2); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S30)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S30); listener.reset(2); doSendEventAndConsumeAll(machine, TestEvents.E3); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(2)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S4)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(2); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S4); } @Test public void testStringStatesAndEvents() throws Exception { context.register(Config4.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); StateMachine machine = resolveMachine(context); TestListener2 listener = new TestListener2(); machine.addStateListener(listener); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); doStartAndAssert(machine); listener.reset(1); doSendEventAndConsumeAll(machine, MessageBuilder.withPayload("E1").setHeader("foo", "jee1").build()); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder("S1")); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly("S1"); } @Test @@ -175,16 +170,16 @@ public class StateMachineTests extends AbstractStateMachineTests { context.register(Config5.class); context.refresh(); StateMachine machine = resolveMachine(context); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); TestStateEntryExitListener listener = new TestStateEntryExitListener(); machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), contains(TestStates.SI)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.SI); listener.reset(); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(machine.getState().getIds(), contains(TestStates.SI)); - assertThat(listener.exited.size(), is(1)); - assertThat(listener.entered.size(), is(1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.SI); + assertThat(listener.exited).hasSize(1); + assertThat(listener.entered).hasSize(1); } private static class LoggingAction implements Action { diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/SubStateMachineTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/SubStateMachineTests.java index f6115e5e..5258e9a6 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/SubStateMachineTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/SubStateMachineTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,11 +15,7 @@ */ package org.springframework.statemachine; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.notNullValue; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.assertj.core.api.Assertions.assertThat; import java.util.ArrayList; import java.util.Arrays; @@ -144,19 +140,19 @@ public class SubStateMachineTests extends AbstractStateMachineTests { machine.sendEvent(TestEvents.E1); - assertThat(entryActionS111.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(exitActionS111.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(entryActionS11.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(exitActionS11.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(entryActionS1.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(exitActionS1.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); + assertThat(entryActionS111.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(exitActionS111.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(entryActionS11.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(exitActionS11.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(entryActionS1.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(exitActionS1.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); - assertThat(entryActionS111.stateContexts.size(), is(2)); - assertThat(exitActionS111.stateContexts.size(), is(1)); - assertThat(entryActionS11.stateContexts.size(), is(2)); - assertThat(exitActionS11.stateContexts.size(), is(1)); - assertThat(entryActionS1.stateContexts.size(), is(1)); - assertThat(exitActionS1.stateContexts.size(), is(1)); + assertThat(entryActionS111.stateContexts).hasSize(2); + assertThat(exitActionS111.stateContexts).hasSize(1); + assertThat(entryActionS11.stateContexts).hasSize(2); + assertThat(exitActionS11.stateContexts).hasSize(1); + assertThat(entryActionS1.stateContexts).hasSize(1); + assertThat(exitActionS1.stateContexts).hasSize(1); } @Test @@ -235,19 +231,19 @@ public class SubStateMachineTests extends AbstractStateMachineTests { machine.sendEvent(TestEvents.E1); - assertThat(entryActionS111.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(exitActionS111.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(entryActionS112.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(exitActionS112.onExecuteLatch.await(1, TimeUnit.SECONDS), is(false)); - assertThat(entryActionS1.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(exitActionS1.onExecuteLatch.await(1, TimeUnit.SECONDS), is(false)); + assertThat(entryActionS111.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(exitActionS111.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(entryActionS112.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(exitActionS112.onExecuteLatch.await(1, TimeUnit.SECONDS)).isFalse(); + assertThat(entryActionS1.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(exitActionS1.onExecuteLatch.await(1, TimeUnit.SECONDS)).isFalse(); - assertThat(entryActionS111.stateContexts.size(), is(1)); - assertThat(exitActionS111.stateContexts.size(), is(1)); - assertThat(entryActionS112.stateContexts.size(), is(1)); - assertThat(exitActionS112.stateContexts.size(), is(0)); - assertThat(entryActionS1.stateContexts.size(), is(1)); - assertThat(exitActionS1.stateContexts.size(), is(0)); + assertThat(entryActionS111.stateContexts).hasSize(1); + assertThat(exitActionS111.stateContexts).hasSize(1); + assertThat(entryActionS112.stateContexts).hasSize(1); + assertThat(exitActionS112.stateContexts).isEmpty(); + assertThat(entryActionS1.stateContexts).hasSize(1); + assertThat(exitActionS1.stateContexts).isEmpty(); } @@ -335,26 +331,26 @@ public class SubStateMachineTests extends AbstractStateMachineTests { machine.sendEvent(TestEvents.E1); - assertThat(entryActionS111.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(exitActionS111.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(entryActionS11.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(exitActionS11.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(entryActionS1.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(exitActionS1.onExecuteLatch.await(1, TimeUnit.SECONDS), is(false)); + assertThat(entryActionS111.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(exitActionS111.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(entryActionS11.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(exitActionS11.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(entryActionS1.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(exitActionS1.onExecuteLatch.await(1, TimeUnit.SECONDS)).isFalse(); - assertThat(entryActionS111.stateContexts.size(), is(2)); - assertThat(exitActionS111.stateContexts.size(), is(1)); - assertThat(entryActionS11.stateContexts.size(), is(1)); - assertThat(exitActionS11.stateContexts.size(), is(1)); - assertThat(entryActionS1.stateContexts.size(), is(1)); - assertThat(exitActionS1.stateContexts.size(), is(0)); + assertThat(entryActionS111.stateContexts).hasSize(2); + assertThat(exitActionS111.stateContexts).hasSize(1); + assertThat(entryActionS11.stateContexts).hasSize(1); + assertThat(exitActionS11.stateContexts).hasSize(1); + assertThat(entryActionS1.stateContexts).hasSize(1); + assertThat(exitActionS1.stateContexts).isEmpty(); } @Test public void testExternalTransition3() throws Exception { context.register(Config1.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); @@ -370,19 +366,19 @@ public class SubStateMachineTests extends AbstractStateMachineTests { TestEntryAction entryActionS1 = context.getBean("entryActionS1", TestEntryAction.class); TestExitAction exitActionS1 = context.getBean("exitActionS1", TestExitAction.class); - assertThat(entryActionS111.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(exitActionS111.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(entryActionS11.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(exitActionS11.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(entryActionS1.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(exitActionS1.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); + assertThat(entryActionS111.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(exitActionS111.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(entryActionS11.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(exitActionS11.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(entryActionS1.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(exitActionS1.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); - assertThat(entryActionS111.stateContexts.size(), is(2)); - assertThat(exitActionS111.stateContexts.size(), is(1)); - assertThat(entryActionS11.stateContexts.size(), is(2)); - assertThat(exitActionS11.stateContexts.size(), is(1)); - assertThat(entryActionS1.stateContexts.size(), is(1)); - assertThat(exitActionS1.stateContexts.size(), is(1)); + assertThat(entryActionS111.stateContexts).hasSize(2); + assertThat(exitActionS111.stateContexts).hasSize(1); + assertThat(entryActionS11.stateContexts).hasSize(2); + assertThat(exitActionS11.stateContexts).hasSize(1); + assertThat(entryActionS1.stateContexts).hasSize(1); + assertThat(exitActionS1.stateContexts).hasSize(1); } @@ -390,29 +386,29 @@ public class SubStateMachineTests extends AbstractStateMachineTests { public void testMixedStates() throws Exception { context.register(Config2.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); machine.start(); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); - assertThat(machine.getState().getIds(), contains(TestStates.S1, TestStates.S10)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1, TestStates.S10); } @Test public void testStateChangeWithinMachine() { context.register(Config3.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); machine.start(); - assertThat(machine, notNullValue()); - assertThat(machine.getState().getIds(), contains(TestStates2.IDLE, TestStates2.CLOSED)); + assertThat(machine).isNotNull(); + assertThat(machine.getState().getIds()).containsExactly(TestStates2.IDLE, TestStates2.CLOSED); machine.sendEvent(TestEvents2.EJECT); - assertThat(machine.getState().getIds(), contains(TestStates2.IDLE, TestStates2.OPEN)); + assertThat(machine.getState().getIds()).containsExactly(TestStates2.IDLE, TestStates2.OPEN); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/access/StateMachineAccessTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/access/StateMachineAccessTests.java index c389ec5b..08b9ec59 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/access/StateMachineAccessTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/access/StateMachineAccessTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,8 +15,7 @@ */ package org.springframework.statemachine.access; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.sameInstance; +import static org.assertj.core.api.Assertions.assertThat; import java.util.ArrayList; import java.util.Collection; @@ -47,7 +46,7 @@ public class StateMachineAccessTests { final StateMachine stateMachine = mock; stateMachine.getStateMachineAccessor().doWithAllRegions(function -> function.setRelay(stateMachine)); - assertThat(mock.relay, sameInstance(stateMachine)); + assertThat(mock.relay).isSameAs(stateMachine); } @Test @@ -56,7 +55,7 @@ public class StateMachineAccessTests { final StateMachine stateMachine = mock; stateMachine.getStateMachineAccessor().withAllRegions().forEach(access -> access.setRelay(stateMachine)); - assertThat(mock.relay, sameInstance(stateMachine)); + assertThat(mock.relay).isSameAs(stateMachine); } private static class MockStateMachine implements StateMachine, StateMachineAccess { diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/action/ActionAndTimerTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/action/ActionAndTimerTests.java index 270d0ab7..185c44f1 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/action/ActionAndTimerTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/action/ActionAndTimerTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2016-2019 the original author or authors. + * Copyright 2016-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,10 +15,7 @@ */ package org.springframework.statemachine.action; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.nullValue; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; import static org.springframework.statemachine.TestUtils.resolveMachine; @@ -52,12 +49,12 @@ public class ActionAndTimerTests extends AbstractStateMachineTests { TestListener testListener = new TestListener(); machine.addStateListener(testListener); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S1)); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S1); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S2)); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S2); - assertThat(testTimerAction.latch.await(4, TimeUnit.SECONDS), is(true)); - assertThat(testTimerAction.e, nullValue()); + assertThat(testTimerAction.latch.await(4, TimeUnit.SECONDS)).isTrue(); + assertThat(testTimerAction.e).isNull(); // need to sleep for TimerTrigger not causing // next event to get handled with threads, thus @@ -65,10 +62,10 @@ public class ActionAndTimerTests extends AbstractStateMachineTests { Thread.sleep(1000); doSendEventAndConsumeAll(machine, TestEvents.E2); - assertThat(testListener.s3EnteredLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S3)); - assertThat(testExitAction.latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(testExitAction.e, nullValue()); + assertThat(testListener.s3EnteredLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S3); + assertThat(testExitAction.latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(testExitAction.e).isNull(); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/action/ActionErrorTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/action/ActionErrorTests.java index a8d52389..bc4b83fc 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/action/ActionErrorTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/action/ActionErrorTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,9 +15,7 @@ */ package org.springframework.statemachine.action; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; import org.springframework.context.annotation.AnnotationConfigApplicationContext; @@ -43,7 +41,7 @@ public class ActionErrorTests extends AbstractStateMachineTests { public void testActionExceptionNotCausingStateChange() { context.register(Config1.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); @@ -51,14 +49,14 @@ public class ActionErrorTests extends AbstractStateMachineTests { // error in transition should not cause transition and should // not propagate error into a caller. machine.sendEvent(TestEvents.E1); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); } @Test public void testActionExceptionInAnonymousTransition() { context.register(Config2.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); @@ -66,7 +64,7 @@ public class ActionErrorTests extends AbstractStateMachineTests { // error in transition should not cause transition and should // not propagate error into a caller. machine.sendEvent(TestEvents.E1); - assertThat(machine.getState().getIds(), contains(TestStates.S2)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S2); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/action/ActionTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/action/ActionTests.java index 43e366c5..be45c331 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/action/ActionTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/action/ActionTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,10 +15,7 @@ */ package org.springframework.statemachine.action; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.instanceOf; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.notNullValue; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; import static org.springframework.statemachine.TestUtils.resolveMachine; @@ -59,9 +56,9 @@ public class ActionTests extends AbstractStateMachineTests { doSendEventAndConsumeAll(machine, TestEvents.E1); doSendEventAndConsumeAll(machine, TestEvents.E2); doSendEventAndConsumeAll(machine, TestEvents.E3); - assertThat(testAction1.count, is(1)); - assertThat(testAction2.count, is(1)); - assertThat(testAction3.count, is(1)); + assertThat(testAction1.count).isEqualTo(1); + assertThat(testAction2.count).isEqualTo(1); + assertThat(testAction3.count).isEqualTo(1); } @Test @@ -74,12 +71,12 @@ public class ActionTests extends AbstractStateMachineTests { TestCountAction testAction1 = context.getBean("testAction1", TestCountAction.class); TestCountAction testErrorAction = context.getBean("testErrorAction", TestCountAction.class); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(testAction1.count, is(1)); - assertThat(testErrorAction.count, is(1)); - assertThat(testErrorAction.context, notNullValue()); - assertThat(testErrorAction.context.getException(), notNullValue()); - assertThat(testErrorAction.context.getException(), instanceOf(RuntimeException.class)); - assertThat(testErrorAction.context.getException().getMessage(), is("Fake Error")); + assertThat(testAction1.count).isEqualTo(1); + assertThat(testErrorAction.count).isEqualTo(1); + assertThat(testErrorAction.context).isNotNull(); + assertThat(testErrorAction.context.getException()).isNotNull(); + assertThat(testErrorAction.context.getException()).isInstanceOf(RuntimeException.class); + assertThat(testErrorAction.context.getException().getMessage()).isEqualTo("Fake Error"); } @Test @@ -97,33 +94,33 @@ public class ActionTests extends AbstractStateMachineTests { TestCountAction testErrorAction4 = context.getBean("testErrorAction4", TestCountAction.class); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(machine.getState().getId(), is(TestStates.S2)); - assertThat(testErrorAction3.latch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(testErrorAction2.latch.await(1, TimeUnit.SECONDS), is(true)); + assertThat(machine.getState().getId()).isEqualTo(TestStates.S2); + assertThat(testErrorAction3.latch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(testErrorAction2.latch.await(1, TimeUnit.SECONDS)).isTrue(); doSendEventAndConsumeAll(machine, TestEvents.E2); - assertThat(testErrorAction4.latch.await(1, TimeUnit.SECONDS), is(true)); + assertThat(testErrorAction4.latch.await(1, TimeUnit.SECONDS)).isTrue(); - assertThat(testAction2.count, is(1)); - assertThat(testErrorAction2.count, is(1)); - assertThat(testErrorAction2.context, notNullValue()); - assertThat(testErrorAction2.context.getException(), notNullValue()); - assertThat(testErrorAction2.context.getException(), instanceOf(RuntimeException.class)); - assertThat(testErrorAction2.context.getException().getMessage(), is("Fake Error")); + assertThat(testAction2.count).isEqualTo(1); + assertThat(testErrorAction2.count).isEqualTo(1); + assertThat(testErrorAction2.context).isNotNull(); + assertThat(testErrorAction2.context.getException()).isNotNull(); + assertThat(testErrorAction2.context.getException()).isInstanceOf(RuntimeException.class); + assertThat(testErrorAction2.context.getException().getMessage()).isEqualTo("Fake Error"); - assertThat(testAction3.count, is(1)); - assertThat(testErrorAction3.count, is(1)); - assertThat(testErrorAction3.context, notNullValue()); - assertThat(testErrorAction3.context.getException(), notNullValue()); - assertThat(testErrorAction3.context.getException(), instanceOf(RuntimeException.class)); - assertThat(testErrorAction3.context.getException().getMessage(), is("Fake Error")); + assertThat(testAction3.count).isEqualTo(1); + assertThat(testErrorAction3.count).isEqualTo(1); + assertThat(testErrorAction3.context).isNotNull(); + assertThat(testErrorAction3.context.getException()).isNotNull(); + assertThat(testErrorAction3.context.getException()).isInstanceOf(RuntimeException.class); + assertThat(testErrorAction3.context.getException().getMessage()).isEqualTo("Fake Error"); - assertThat(testAction4.count, is(1)); - assertThat(testErrorAction4.count, is(1)); - assertThat(testErrorAction4.context, notNullValue()); - assertThat(testErrorAction4.context.getException(), notNullValue()); - assertThat(testErrorAction4.context.getException(), instanceOf(RuntimeException.class)); - assertThat(testErrorAction4.context.getException().getMessage(), is("Fake Error")); + assertThat(testAction4.count).isEqualTo(1); + assertThat(testErrorAction4.count).isEqualTo(1); + assertThat(testErrorAction4.context).isNotNull(); + assertThat(testErrorAction4.context.getException()).isNotNull(); + assertThat(testErrorAction4.context.getException()).isInstanceOf(RuntimeException.class); + assertThat(testErrorAction4.context.getException().getMessage()).isEqualTo("Fake Error"); } @Test diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/action/DistributedLeaderActionTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/action/DistributedLeaderActionTests.java index 33e7af14..5be19d6a 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/action/DistributedLeaderActionTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/action/DistributedLeaderActionTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2016-2019 the original author or authors. + * Copyright 2016-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,8 +15,7 @@ */ package org.springframework.statemachine.action; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.is; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.resolveFactory; @@ -59,13 +58,13 @@ public class DistributedLeaderActionTests extends AbstractStateMachineTests { StateMachine machine2 = factory.getStateMachine(); doSendEventAndConsumeAll(machine1, "E1"); - assertThat(action.latch.await(1, TimeUnit.SECONDS), is(false)); - assertThat(action.count, is(1)); + assertThat(action.latch.await(1, TimeUnit.SECONDS)).isFalse(); + assertThat(action.count).isEqualTo(1); action.reset(2); doSendEventAndConsumeAll(machine2, "E2"); - assertThat(action.latch.await(1, TimeUnit.SECONDS), is(false)); - assertThat(action.count, is(1)); + assertThat(action.latch.await(1, TimeUnit.SECONDS)).isFalse(); + assertThat(action.count).isEqualTo(1); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/action/ReactiveActionTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/action/ReactiveActionTests.java index 45cef779..74c96750 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/action/ReactiveActionTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/action/ReactiveActionTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2019 the original author or authors. + * Copyright 2019-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,8 +15,7 @@ */ package org.springframework.statemachine.action; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.is; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; import static org.springframework.statemachine.TestUtils.resolveMachine; @@ -59,14 +58,14 @@ public class ReactiveActionTests extends AbstractStateMachineTests { TestCountAction testAction4 = context.getBean("testAction4", TestCountAction.class); doSendEventAndConsumeAll(machine, TestEvents.E1); doSendEventAndConsumeAll(machine, TestEvents.E2); - assertThat(testAction1.latch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(testAction2.latch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(testAction3.latch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(testAction4.latch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(testAction1.count, is(1)); - assertThat(testAction2.count, is(1)); - assertThat(testAction3.count, is(1)); - assertThat(testAction4.count, is(1)); + assertThat(testAction1.latch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(testAction2.latch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(testAction3.latch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(testAction4.latch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(testAction1.count).isEqualTo(1); + assertThat(testAction2.count).isEqualTo(1); + assertThat(testAction3.count).isEqualTo(1); + assertThat(testAction4.count).isEqualTo(1); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/action/SpelExpressionActionTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/action/SpelExpressionActionTests.java index b08be6e1..adbdb384 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/action/SpelExpressionActionTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/action/SpelExpressionActionTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,9 +15,7 @@ */ package org.springframework.statemachine.action; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; import static org.springframework.statemachine.TestUtils.resolveMachine; @@ -51,8 +49,8 @@ public class SpelExpressionActionTests extends AbstractStateMachineTests { listener.reset(2, 0); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(listener.stateChangedLatch.await(5, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), contains(TestStates.S3)); + assertThat(listener.stateChangedLatch.await(5, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S3); ctx.close(); } diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/action/StateDoActivityActionTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/action/StateDoActivityActionTests.java index 6741a363..c6158ff3 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/action/StateDoActivityActionTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/action/StateDoActivityActionTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2016-2019 the original author or authors. + * Copyright 2016-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,9 +15,7 @@ */ package org.springframework.statemachine.action; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.is; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; import static org.springframework.statemachine.TestUtils.resolveMachine; @@ -50,10 +48,10 @@ public class StateDoActivityActionTests extends AbstractStateMachineTests { StateMachine machine = resolveMachine(context); doStartAndAssert(machine); - assertThat(testActionS1.onExecuteLatch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(testActionS1.onExecuteLatch.await(2, TimeUnit.SECONDS)).isTrue(); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(testActionS2.onExecuteLatch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(testActionS2.onExecuteLatch.await(2, TimeUnit.SECONDS)).isTrue(); doSendEventAndConsumeAll(machine, TestEvents.E2); } @@ -66,16 +64,16 @@ public class StateDoActivityActionTests extends AbstractStateMachineTests { StateMachine machine = resolveMachine(context); doStartAndAssert(machine); - assertThat(testActionS1.onExecuteStartLatch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(testActionS1.onExecuteStartLatch.await(2, TimeUnit.SECONDS)).isTrue(); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(testActionS1.interruptedLatch.await(6, TimeUnit.SECONDS), is(true)); - assertThat(testActionS1.onExecuteLatch.await(6, TimeUnit.SECONDS), is(true)); + assertThat(testActionS1.interruptedLatch.await(6, TimeUnit.SECONDS)).isTrue(); + assertThat(testActionS1.onExecuteLatch.await(6, TimeUnit.SECONDS)).isTrue(); - assertThat(testActionS2.onExecuteStartLatch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(testActionS2.onExecuteStartLatch.await(2, TimeUnit.SECONDS)).isTrue(); doSendEventAndConsumeAll(machine, TestEvents.E2); - assertThat(testActionS2.interruptedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(testActionS2.onExecuteLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S3)); + assertThat(testActionS2.interruptedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(testActionS2.onExecuteLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S3); } @Test @@ -89,22 +87,22 @@ public class StateDoActivityActionTests extends AbstractStateMachineTests { StateMachine machine = resolveMachine(context); doStartAndAssert(machine); doSendEventAndConsumeAll(machine, TestEvents.E3); - assertThat(testActionS1I.onExecuteLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(testActionS1.interruptedLatch.await(2, TimeUnit.SECONDS), is(false)); + assertThat(testActionS1I.onExecuteLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(testActionS1.interruptedLatch.await(2, TimeUnit.SECONDS)).isFalse(); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S2)); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S2); doSendEventAndConsumeAll(machine, TestEvents.E4); - assertThat(testActionS2I.onExecuteLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(testActionS2.interruptedLatch.await(2, TimeUnit.SECONDS), is(false)); + assertThat(testActionS2I.onExecuteLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(testActionS2.interruptedLatch.await(2, TimeUnit.SECONDS)).isFalse(); doSendEventAndConsumeAll(machine, TestEvents.E2); - assertThat(testActionS1.interruptedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(testActionS2.interruptedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(testActionS1.onExecuteLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(testActionS2.onExecuteLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S3)); + assertThat(testActionS1.interruptedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(testActionS2.interruptedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(testActionS1.onExecuteLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(testActionS2.onExecuteLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S3); } @Configuration @@ -255,10 +253,10 @@ public class StateDoActivityActionTests extends AbstractStateMachineTests { Message event = MessageBuilder.withPayload(TestEvents.E1) .setHeader(StateMachineMessageHeaders.HEADER_DO_ACTION_TIMEOUT, 4000).build(); doSendEventAndConsumeAll(machine, event); - assertThat(testActionS2.onExecuteStartLatch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(testActionS2.onExecuteStartLatch.await(2, TimeUnit.SECONDS)).isTrue(); doSendEventAndConsumeAll(machine, TestEvents.E2); - assertThat(testActionS2.onExecuteLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(testActionS2.interruptedLatch.await(2, TimeUnit.SECONDS), is(false)); + assertThat(testActionS2.onExecuteLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(testActionS2.interruptedLatch.await(2, TimeUnit.SECONDS)).isFalse(); } @Test @@ -272,10 +270,10 @@ public class StateDoActivityActionTests extends AbstractStateMachineTests { Message event = MessageBuilder.withPayload(TestEvents.E1) .setHeader(StateMachineMessageHeaders.HEADER_DO_ACTION_TIMEOUT, 100).build(); doSendEventAndConsumeAll(machine, event); - assertThat(testActionS2.onExecuteStartLatch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(testActionS2.onExecuteStartLatch.await(2, TimeUnit.SECONDS)).isTrue(); doSendEventAndConsumeAll(machine, TestEvents.E2); - assertThat(testActionS2.onExecuteLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(testActionS2.interruptedLatch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(testActionS2.onExecuteLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(testActionS2.interruptedLatch.await(2, TimeUnit.SECONDS)).isTrue(); } @Test @@ -287,10 +285,10 @@ public class StateDoActivityActionTests extends AbstractStateMachineTests { doStartAndAssert(machine); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(testActionS2.onExecuteStartLatch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(testActionS2.onExecuteStartLatch.await(2, TimeUnit.SECONDS)).isTrue(); doSendEventAndConsumeAll(machine, TestEvents.E2); - assertThat(testActionS2.onExecuteLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(testActionS2.interruptedLatch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(testActionS2.onExecuteLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(testActionS2.interruptedLatch.await(2, TimeUnit.SECONDS)).isTrue(); } @Test @@ -302,10 +300,10 @@ public class StateDoActivityActionTests extends AbstractStateMachineTests { doStartAndAssert(machine); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(testActionS2.onExecuteStartLatch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(testActionS2.onExecuteStartLatch.await(2, TimeUnit.SECONDS)).isTrue(); doSendEventAndConsumeAll(machine, TestEvents.E2); - assertThat(testActionS2.onExecuteLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(testActionS2.interruptedLatch.await(2, TimeUnit.SECONDS), is(false)); + assertThat(testActionS2.onExecuteLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(testActionS2.interruptedLatch.await(2, TimeUnit.SECONDS)).isFalse(); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/annotation/ClassAnnotationTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/annotation/ClassAnnotationTests.java index a9a97fb2..9521100c 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/annotation/ClassAnnotationTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/annotation/ClassAnnotationTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,8 +15,7 @@ */ package org.springframework.statemachine.annotation; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; @@ -51,8 +50,8 @@ public class ClassAnnotationTests extends AbstractStateMachineTests { ObjectStateMachine barMachine = context.getBean("barMachine", ObjectStateMachine.class); - assertThat(context.containsBean("fooMachine"), is(true)); - assertThat(context.containsBean("barMachine"), is(true)); + assertThat(context.containsBean("fooMachine")).isTrue(); + assertThat(context.containsBean("barMachine")).isTrue(); fooMachine.start(); barMachine.start(); @@ -64,16 +63,16 @@ public class ClassAnnotationTests extends AbstractStateMachineTests { // this event should cause 'FooBean.fooMethod' to get called fooMachine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).build()); - assertThat(fooBean.onFooMethodLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(barBean.onBarMethodLatch.await(2, TimeUnit.SECONDS), is(false)); + assertThat(fooBean.onFooMethodLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(barBean.onBarMethodLatch.await(2, TimeUnit.SECONDS)).isFalse(); fooBean.resetMethodLatch(); // this event should cause 'BarBean.barMethod' to get called barMachine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).build()); - assertThat(fooBean.onFooMethodLatch.await(2, TimeUnit.SECONDS), is(false)); - assertThat(barBean.onBarMethodLatch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(fooBean.onFooMethodLatch.await(2, TimeUnit.SECONDS)).isFalse(); + assertThat(barBean.onBarMethodLatch.await(2, TimeUnit.SECONDS)).isTrue(); context.close(); } @@ -87,16 +86,16 @@ public class ClassAnnotationTests extends AbstractStateMachineTests { ObjectStateMachine jeeMachine = context.getBean("jeeMachine", ObjectStateMachine.class); - assertThat(context.containsBean("fooMachine"), is(true)); - assertThat(context.containsBean("jeeMachine"), is(true)); + assertThat(context.containsBean("fooMachine")).isTrue(); + assertThat(context.containsBean("jeeMachine")).isTrue(); JeeBean jeeBean = context.getBean(JeeBean.class); FooBean fooBean = context.getBean(FooBean.class); fooBean.resetMethodLatch(); jeeMachine.start(); jeeMachine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).build()); - assertThat(jeeBean.onJeeMethodLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(fooBean.onFooMethodLatch.await(2, TimeUnit.SECONDS), is(false)); + assertThat(jeeBean.onJeeMethodLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(fooBean.onFooMethodLatch.await(2, TimeUnit.SECONDS)).isFalse(); context.close(); } diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/annotation/MethodAnnotationTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/annotation/MethodAnnotationTests.java index 949c3c0a..a81b5c54 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/annotation/MethodAnnotationTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/annotation/MethodAnnotationTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,10 +15,7 @@ */ package org.springframework.statemachine.annotation; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.notNullValue; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; +import static org.assertj.core.api.Assertions.assertThat; import java.util.EnumSet; import java.util.Map; @@ -60,25 +57,25 @@ public class MethodAnnotationTests extends AbstractStateMachineTests { ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(context.containsBean("fooMachine"), is(true)); + assertThat(context.containsBean("fooMachine")).isTrue(); Bean1 bean1 = context.getBean(Bean1.class); bean1.reset(1, 1, 1, 1, 1, 1, 1, 1); machine.start(); - assertThat(bean1.onTransitionFromS1ToS2Latch.await(1, TimeUnit.SECONDS), is(false)); - assertThat(bean1.onTransitionLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onTransitionFromS1ToS2Count, is(0)); - assertThat(bean1.onTransitionCount, is(1)); + assertThat(bean1.onTransitionFromS1ToS2Latch.await(1, TimeUnit.SECONDS)).isFalse(); + assertThat(bean1.onTransitionLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onTransitionFromS1ToS2Count).isZero(); + assertThat(bean1.onTransitionCount).isEqualTo(1); bean1.reset(1, 1, 1, 1, 1, 1, 1, 1); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).build()); - assertThat(bean1.onTransitionFromS1ToS2Latch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onTransitionLatch.await(1, TimeUnit.SECONDS), is(true)); + assertThat(bean1.onTransitionFromS1ToS2Latch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onTransitionLatch.await(1, TimeUnit.SECONDS)).isTrue(); - assertThat(bean1.onTransitionFromS1ToS2Count, is(1)); - assertThat(bean1.onTransitionCount, is(1)); + assertThat(bean1.onTransitionFromS1ToS2Count).isEqualTo(1); + assertThat(bean1.onTransitionCount).isEqualTo(1); } @Test @@ -89,25 +86,25 @@ public class MethodAnnotationTests extends AbstractStateMachineTests { ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(context.containsBean("fooMachine"), is(true)); + assertThat(context.containsBean("fooMachine")).isTrue(); Bean1 bean1 = context.getBean(Bean1.class); bean1.reset(1, 1, 1, 1, 1, 1, 1, 1); machine.start(); - assertThat(bean1.onStateChangedFromS1ToS2Latch.await(1, TimeUnit.SECONDS), is(false)); - assertThat(bean1.onStateChangedLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onStateChangedFromS1ToS2Count, is(0)); - assertThat(bean1.onStateChangedCount, is(1)); + assertThat(bean1.onStateChangedFromS1ToS2Latch.await(1, TimeUnit.SECONDS)).isFalse(); + assertThat(bean1.onStateChangedLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onStateChangedFromS1ToS2Count).isZero(); + assertThat(bean1.onStateChangedCount).isEqualTo(1); bean1.reset(1, 1, 1, 1, 1, 1, 1, 1); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).build()); - assertThat(bean1.onStateChangedFromS1ToS2Latch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onStateChangedLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onStateChangedFromS1ToS2Count, is(1)); - assertThat(bean1.onStateChangedCount, is(1)); + assertThat(bean1.onStateChangedFromS1ToS2Latch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onStateChangedLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onStateChangedFromS1ToS2Count).isEqualTo(1); + assertThat(bean1.onStateChangedCount).isEqualTo(1); } @Test @@ -117,23 +114,23 @@ public class MethodAnnotationTests extends AbstractStateMachineTests { context.refresh(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(context.containsBean("fooMachine"), is(true)); + assertThat(context.containsBean("fooMachine")).isTrue(); Bean1 bean1 = context.getBean(Bean1.class); bean1.reset(1, 1, 1, 1, 1, 1, 1, 1); machine.start(); - assertThat(bean1.onStateMachineStartLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onStateMachineStartCount, is(1)); - assertThat(bean1.onStateMachineStopLatch.await(1, TimeUnit.SECONDS), is(false)); - assertThat(bean1.onStateMachineStopCount, is(0)); + assertThat(bean1.onStateMachineStartLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onStateMachineStartCount).isEqualTo(1); + assertThat(bean1.onStateMachineStopLatch.await(1, TimeUnit.SECONDS)).isFalse(); + assertThat(bean1.onStateMachineStopCount).isZero(); bean1.reset(1, 1, 1, 1, 1, 1, 1, 1); machine.stop(); - assertThat(bean1.onStateMachineStartLatch.await(1, TimeUnit.SECONDS), is(false)); - assertThat(bean1.onStateMachineStartCount, is(0)); - assertThat(bean1.onStateMachineStopLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onStateMachineStopCount, is(1)); + assertThat(bean1.onStateMachineStartLatch.await(1, TimeUnit.SECONDS)).isFalse(); + assertThat(bean1.onStateMachineStartCount).isZero(); + assertThat(bean1.onStateMachineStopLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onStateMachineStopCount).isEqualTo(1); } @Test @@ -144,23 +141,23 @@ public class MethodAnnotationTests extends AbstractStateMachineTests { ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(context.containsBean("fooMachine"), is(true)); + assertThat(context.containsBean("fooMachine")).isTrue(); Bean5 bean5 = context.getBean(Bean5.class); machine.start(); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).setHeader("V1", "V1val").build()); - assertThat(bean5.onExtendedStateChanged1Latch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(bean5.onExtendedStateChanged1Count, is(1)); + assertThat(bean5.onExtendedStateChanged1Latch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(bean5.onExtendedStateChanged1Count).isEqualTo(1); - assertThat(bean5.onExtendedStateChanged2Latch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(bean5.onExtendedStateChanged2Count, is(1)); - assertThat(bean5.onExtendedStateChanged2Value, is("V1val")); + assertThat(bean5.onExtendedStateChanged2Latch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(bean5.onExtendedStateChanged2Count).isEqualTo(1); + assertThat(bean5.onExtendedStateChanged2Value).isEqualTo("V1val"); - assertThat(bean5.onExtendedStateChangedKeyV1Latch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(bean5.onExtendedStateChangedKeyV1Count, is(1)); + assertThat(bean5.onExtendedStateChangedKeyV1Latch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(bean5.onExtendedStateChangedKeyV1Count).isEqualTo(1); - assertThat(bean5.onExtendedStateChangedKeyV2Latch.await(1, TimeUnit.SECONDS), is(false)); - assertThat(bean5.onExtendedStateChangedKeyV2Count, is(0)); + assertThat(bean5.onExtendedStateChangedKeyV2Latch.await(1, TimeUnit.SECONDS)).isFalse(); + assertThat(bean5.onExtendedStateChangedKeyV2Count).isZero(); } @Test @@ -171,7 +168,7 @@ public class MethodAnnotationTests extends AbstractStateMachineTests { ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(context.containsBean("fooMachine"), is(true)); + assertThat(context.containsBean("fooMachine")).isTrue(); machine.start(); Bean2 bean2 = context.getBean(Bean2.class); @@ -185,19 +182,19 @@ public class MethodAnnotationTests extends AbstractStateMachineTests { .build()); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E2).build()); - assertThat(bean2.onMethod1Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean2.headers, notNullValue()); - assertThat((String)bean2.headers.get("foo"), is("jee")); - assertThat(bean2.extendedState, notNullValue()); + assertThat(bean2.onMethod1Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean2.headers).isNotNull(); + assertThat((String)bean2.headers.get("foo")).isEqualTo("jee"); + assertThat(bean2.extendedState).isNotNull(); - assertThat(bean2.onMethod2Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean2.variable, notNullValue()); - assertThat((String)bean2.variable, is("jee")); + assertThat(bean2.onMethod2Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean2.variable).isNotNull(); + assertThat((String)bean2.variable).isEqualTo("jee"); - assertThat((String)bean2.fooHeader, is("jee")); - assertThat((String)bean2.bar1Header, is("jee1")); - assertThat((String)bean2.bar2Header, is("jee2")); - assertThat(bean2.bar3Header, is("jee3")); + assertThat((String)bean2.fooHeader).isEqualTo("jee"); + assertThat((String)bean2.bar1Header).isEqualTo("jee1"); + assertThat((String)bean2.bar2Header).isEqualTo("jee2"); + assertThat(bean2.bar3Header).isEqualTo("jee3"); } @Test @@ -208,7 +205,7 @@ public class MethodAnnotationTests extends AbstractStateMachineTests { ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(context.containsBean("fooMachine"), is(true)); + assertThat(context.containsBean("fooMachine")).isTrue(); machine.start(); Bean3 bean3 = context.getBean(Bean3.class); @@ -216,7 +213,7 @@ public class MethodAnnotationTests extends AbstractStateMachineTests { // this event should cause 'method1' to get called machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).build()); - assertThat(bean3.onStateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(bean3.onStateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); } @Test @@ -227,23 +224,23 @@ public class MethodAnnotationTests extends AbstractStateMachineTests { ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(context.containsBean("fooMachine"), is(true)); + assertThat(context.containsBean("fooMachine")).isTrue(); Bean4 bean4 = context.getBean(Bean4.class); machine.start(); - assertThat(bean4.onStateEntryLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean4.onStateExitLatch.await(2, TimeUnit.SECONDS), is(false)); - assertThat(bean4.onStateEntryCount, is(1)); - assertThat(bean4.onStateExitCount, is(0)); + assertThat(bean4.onStateEntryLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean4.onStateExitLatch.await(2, TimeUnit.SECONDS)).isFalse(); + assertThat(bean4.onStateEntryCount).isEqualTo(1); + assertThat(bean4.onStateExitCount).isZero(); bean4.reset(1, 1); // this event should cause 'method1' to get called machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).build()); - assertThat(bean4.onStateEntryLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean4.onStateExitLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean4.onStateEntryCount, is(1)); - assertThat(bean4.onStateExitCount, is(1)); + assertThat(bean4.onStateEntryLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean4.onStateExitLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean4.onStateEntryCount).isEqualTo(1); + assertThat(bean4.onStateExitCount).isEqualTo(1); } @Test @@ -258,13 +255,13 @@ public class MethodAnnotationTests extends AbstractStateMachineTests { machine.start(); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E4).build()); - assertThat(bean6.onEventNotAccepted1Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean6.onEventNotAccepted2Latch.await(2, TimeUnit.SECONDS), is(false)); - assertThat(bean6.onEventNotAccepted3Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean6.onEventNotAccepted4Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean6.onEventNotAccepted4Message, notNullValue()); - assertThat(bean6.onEventNotAccepted4Message.getPayload(), is(TestEvents.E4)); - assertThat(bean6.onEventNotAccepted5Latch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(bean6.onEventNotAccepted1Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean6.onEventNotAccepted2Latch.await(2, TimeUnit.SECONDS)).isFalse(); + assertThat(bean6.onEventNotAccepted3Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean6.onEventNotAccepted4Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean6.onEventNotAccepted4Message).isNotNull(); + assertThat(bean6.onEventNotAccepted4Message.getPayload()).isEqualTo(TestEvents.E4); + assertThat(bean6.onEventNotAccepted5Latch.await(2, TimeUnit.SECONDS)).isTrue(); } @Test @@ -282,9 +279,9 @@ public class MethodAnnotationTests extends AbstractStateMachineTests { machine.setStateMachineError(new RuntimeException()); - assertThat(bean7.OnStateMachineError1Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean7.OnStateMachineError2Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean7.OnStateMachineError2Exception, notNullValue()); + assertThat(bean7.OnStateMachineError1Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean7.OnStateMachineError2Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean7.OnStateMachineError2Exception).isNotNull(); } @Test @@ -300,8 +297,8 @@ public class MethodAnnotationTests extends AbstractStateMachineTests { machine.sendEvent(MessageBuilder.withPayload(TestEvents.EF).build()); - assertThat(bean8.OnTransition1Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean8.OnTransition2Latch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(bean8.OnTransition1Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean8.OnTransition2Latch.await(2, TimeUnit.SECONDS)).isTrue(); } @Test @@ -320,9 +317,9 @@ public class MethodAnnotationTests extends AbstractStateMachineTests { machine.sendEvent(TestEvents.E3); machine.sendEvent(TestEvents.E4); - assertThat(machine.getState().getIds(), contains(TestStates.S2, TestStates.S21)); - assertThat(bean9.OnStateEntry1Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean9.OnTransition1Latch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S2, TestStates.S21); + assertThat(bean9.OnStateEntry1Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean9.OnTransition1Latch.await(2, TimeUnit.SECONDS)).isTrue(); } @Test @@ -341,9 +338,9 @@ public class MethodAnnotationTests extends AbstractStateMachineTests { machine.sendEvent(TestEvents.E3); machine.sendEvent(TestEvents.E4); - assertThat(machine.getState().getIds(), contains(TestStates.S2, TestStates.S21)); - assertThat(bean10.OnStateEntry1Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean10.OnTransition1Latch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S2, TestStates.S21); + assertThat(bean10.OnStateEntry1Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean10.OnTransition1Latch.await(2, TimeUnit.SECONDS)).isTrue(); } @Test @@ -359,11 +356,11 @@ public class MethodAnnotationTests extends AbstractStateMachineTests { machine.sendEvent(TestEvents.E1); - assertThat(machine.getState().getIds(), contains(TestStates.S2)); - assertThat(bean11.OnTransition1Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean11.OnTransition2Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean11.count1, is(1)); - assertThat(bean11.count2, is(1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S2); + assertThat(bean11.OnTransition1Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean11.OnTransition2Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean11.count1).isEqualTo(1); + assertThat(bean11.count2).isEqualTo(1); } @WithStateMachine diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/annotation/MethodAnnotationWithBuilderTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/annotation/MethodAnnotationWithBuilderTests.java index 09113476..57f1ba1c 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/annotation/MethodAnnotationWithBuilderTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/annotation/MethodAnnotationWithBuilderTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2017-2019 the original author or authors. + * Copyright 2017-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,9 +15,7 @@ */ package org.springframework.statemachine.annotation; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; import static org.springframework.statemachine.TestUtils.resolveMachine; @@ -51,10 +49,10 @@ public class MethodAnnotationWithBuilderTests extends AbstractStateMachineTests StateMachine machine = resolveMachine(context); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(machine.getState().getIds(), contains(TestStates.S2)); - assertThat(bean1.onStateChangedLatch.await(1, TimeUnit.SECONDS), is(true)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S2); + assertThat(bean1.onStateChangedLatch.await(1, TimeUnit.SECONDS)).isTrue(); } @Test @@ -67,10 +65,10 @@ public class MethodAnnotationWithBuilderTests extends AbstractStateMachineTests StateMachine machine = resolveMachine(context); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(machine.getState().getIds(), contains(TestStates.S2)); - assertThat(bean1.onStateChangedLatch.await(1, TimeUnit.SECONDS), is(true)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S2); + assertThat(bean1.onStateChangedLatch.await(1, TimeUnit.SECONDS)).isTrue(); } @Test @@ -83,10 +81,10 @@ public class MethodAnnotationWithBuilderTests extends AbstractStateMachineTests StateMachine machine = buildMachine(context); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(machine.getState().getIds(), contains(TestStates.S2)); - assertThat(bean1.onStateChangedLatch.await(1, TimeUnit.SECONDS), is(true)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S2); + assertThat(bean1.onStateChangedLatch.await(1, TimeUnit.SECONDS)).isTrue(); } @Test @@ -99,10 +97,10 @@ public class MethodAnnotationWithBuilderTests extends AbstractStateMachineTests StateMachine machine = buildMachine(context); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(machine.getState().getIds(), contains(TestStates.S2)); - assertThat(bean2.onStateChangedLatch.await(1, TimeUnit.SECONDS), is(true)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S2); + assertThat(bean2.onStateChangedLatch.await(1, TimeUnit.SECONDS)).isTrue(); } @WithStateMachine(id = "xxx") diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/annotation/MethodAnnotationWithFactoryTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/annotation/MethodAnnotationWithFactoryTests.java index 80556034..b258b9b9 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/annotation/MethodAnnotationWithFactoryTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/annotation/MethodAnnotationWithFactoryTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2017 the original author or authors. + * Copyright 2017-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,9 +15,7 @@ */ package org.springframework.statemachine.annotation; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; import static org.springframework.statemachine.TestUtils.resolveFactory; @@ -51,10 +49,10 @@ public class MethodAnnotationWithFactoryTests extends AbstractStateMachineTests StateMachine machine = factory.getStateMachine("xxx"); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(machine.getState().getIds(), contains(TestStates.S2)); - assertThat(bean1.onStateChangedLatch.await(1, TimeUnit.SECONDS), is(true)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S2); + assertThat(bean1.onStateChangedLatch.await(1, TimeUnit.SECONDS)).isTrue(); } @WithStateMachine(name = "xxx") diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/ConfigurationErrorTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/ConfigurationErrorTests.java index 2d0928c5..82392894 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/ConfigurationErrorTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/ConfigurationErrorTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2016-2019 the original author or authors. + * Copyright 2016-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,11 +15,8 @@ */ package org.springframework.statemachine.config; -import static org.hamcrest.CoreMatchers.containsString; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.is; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; @@ -44,16 +41,17 @@ public class ConfigurationErrorTests extends AbstractStateMachineTests { @Test public void testInitialStateNotSet1() { - Exception exception = assertThrows(Exception.class, ()-> { + assertThatThrownBy(() -> { context.register(Config1.class); context.refresh(); + }).satisfies(e -> { + assertThat(e.getCause()).isInstanceOf(MalformedConfigurationException.class); }); - assertTrue(exception.getCause() instanceof MalformedConfigurationException); } @Test public void testInitialStateNotSet2() throws Exception { - Exception exception = assertThrows(Exception.class, ()-> { + assertThatThrownBy(() -> { Builder builder = StateMachineBuilder.builder(); builder .configureStates() @@ -66,15 +64,15 @@ public class ConfigurationErrorTests extends AbstractStateMachineTests { .source("S1") .target("S2") .event("E1"); - builder.build(); + }).satisfies(e -> { + assertThat(e.getCause()).isInstanceOf(MalformedConfigurationException.class); }); - assertTrue(exception.getCause() instanceof MalformedConfigurationException); } @Test public void testNoTransitions() throws Exception { - Exception exception = assertThrows(Exception.class, ()-> { + assertThatThrownBy(() -> { Builder builder = StateMachineBuilder.builder(); builder .configureStates() @@ -83,8 +81,9 @@ public class ConfigurationErrorTests extends AbstractStateMachineTests { .state("S1") .state("S2"); builder.build(); + }).satisfies(e -> { + assertThat(e.getCause()).isInstanceOf(MalformedConfigurationException.class); }); - assertTrue(exception.getCause() instanceof MalformedConfigurationException); } @Test @@ -119,12 +118,12 @@ public class ConfigurationErrorTests extends AbstractStateMachineTests { .state("S1") .state("S2"); builder.build(); - assertThat(verifier.latch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(verifier.latch.await(2, TimeUnit.SECONDS)).isTrue(); } @Test public void testPseudostateNoTransition() throws Exception { - Exception exception = assertThrows(Exception.class, ()-> { + assertThatThrownBy(() -> { Builder builder = StateMachineBuilder.builder(); builder.configureStates() .withStates() @@ -137,9 +136,10 @@ public class ConfigurationErrorTests extends AbstractStateMachineTests { .source("S1") .target("S2"); builder.build(); + }).satisfies(e -> { + assertThat(e.getCause()).isInstanceOf(MalformedConfigurationException.class); + assertThat(e.getLocalizedMessage()).contains("No transitions for state S2"); }); - assertTrue(exception.getCause() instanceof MalformedConfigurationException); - assertThat(exception.getLocalizedMessage(), containsString("No transitions for state S2")); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/ConfigurationTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/ConfigurationTests.java index df0dee8c..d21ff169 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/ConfigurationTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/ConfigurationTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,12 +15,8 @@ */ package org.springframework.statemachine.config; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.notNullValue; -import static org.hamcrest.Matchers.sameInstance; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; import java.util.ArrayList; import java.util.Arrays; @@ -69,14 +65,14 @@ public class ConfigurationTests extends AbstractStateMachineTests { public void testStates() { context.register(Config1.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); TestAction testAction = context.getBean("testAction", TestAction.class); TestGuard testGuard = context.getBean("testGuard", TestGuard.class); - assertThat(testAction, notNullValue()); - assertThat(testGuard, notNullValue()); + assertThat(testAction).isNotNull(); + assertThat(testGuard).isNotNull(); } @SuppressWarnings({ "unchecked" }) @@ -84,10 +80,10 @@ public class ConfigurationTests extends AbstractStateMachineTests { public void testSimpleSubmachine() throws Exception { context.register(Config4.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); } @SuppressWarnings({ "unchecked" }) @@ -95,10 +91,10 @@ public class ConfigurationTests extends AbstractStateMachineTests { public void testRegions() throws Exception { context.register(Config6.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); } @SuppressWarnings({ "unchecked" }) @@ -106,10 +102,10 @@ public class ConfigurationTests extends AbstractStateMachineTests { public void testSubmachineWithState() throws Exception { context.register(Config7.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); } @SuppressWarnings({ "unchecked" }) @@ -117,10 +113,10 @@ public class ConfigurationTests extends AbstractStateMachineTests { public void testSubmachineWithRegion() throws Exception { context.register(Config8.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); } @SuppressWarnings({ "unchecked" }) @@ -130,8 +126,8 @@ public class ConfigurationTests extends AbstractStateMachineTests { context.refresh(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine.isAutoStartup(), is(true)); - assertThat(machine.isRunning(), is(true)); + assertThat(machine.isAutoStartup()).isTrue(); + assertThat(machine.isRunning()).isTrue(); } @SuppressWarnings({ "unchecked" }) @@ -141,8 +137,8 @@ public class ConfigurationTests extends AbstractStateMachineTests { context.refresh(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine.isAutoStartup(), is(false)); - assertThat(machine.isRunning(), is(false)); + assertThat(machine.isAutoStartup()).isFalse(); + assertThat(machine.isRunning()).isFalse(); } @SuppressWarnings({ "unchecked" }) @@ -155,7 +151,7 @@ public class ConfigurationTests extends AbstractStateMachineTests { Object o1 = TestUtils.readField("stateListener", machine); Object o2 = TestUtils.readField("listeners", o1); Object o3 = TestUtils.readField("list", o2); - assertThat(((List)o3).size(), is(2)); + assertThat(((List)o3)).hasSize(2); } @Test @@ -166,10 +162,10 @@ public class ConfigurationTests extends AbstractStateMachineTests { @Test public void testEnableStateMachineFactoryNoAdapter() { - assertThrows(BeanCreationException.class, () -> { + assertThatThrownBy(() -> { context.register(Config13.class); context.refresh(); - }); + }).isInstanceOf(BeanCreationException.class); } @Test @@ -185,9 +181,9 @@ public class ConfigurationTests extends AbstractStateMachineTests { Object bfFromMachine = TestUtils.callMethod("getBeanFactory", stateMachine); Object bfFromExecutor = TestUtils.callMethod("getBeanFactory", stateMachineExecutor); - assertThat(bfFromMachine, notNullValue()); - assertThat(bfFromExecutor, notNullValue()); - assertThat(bfFromMachine, sameInstance(bfFromExecutor)); + assertThat(bfFromMachine).isNotNull(); + assertThat(bfFromExecutor).isNotNull(); + assertThat(bfFromMachine).isSameAs(bfFromExecutor); } @Test @@ -203,9 +199,9 @@ public class ConfigurationTests extends AbstractStateMachineTests { Object bfFromMachine = TestUtils.callMethod("getBeanFactory", stateMachine); Object bfFromExecutor = TestUtils.callMethod("getBeanFactory", stateMachineExecutor); - assertThat(bfFromMachine, notNullValue()); - assertThat(bfFromExecutor, notNullValue()); - assertThat(bfFromMachine, sameInstance(Config16.beanFactory)); + assertThat(bfFromMachine).isNotNull(); + assertThat(bfFromExecutor).isNotNull(); + assertThat(bfFromMachine).isSameAs(Config16.beanFactory); } @Test @@ -214,8 +210,8 @@ public class ConfigurationTests extends AbstractStateMachineTests { context.refresh(); @SuppressWarnings("unchecked") StateMachine stateMachine = context.getBean(StateMachine.class); - assertThat(stateMachine, notNullValue()); - assertThat(stateMachine.getId(), is("testid1")); + assertThat(stateMachine).isNotNull(); + assertThat(stateMachine.getId()).isEqualTo("testid1"); } @Test @@ -225,12 +221,12 @@ public class ConfigurationTests extends AbstractStateMachineTests { @SuppressWarnings("unchecked") StateMachineFactory stateMachineFactory = context.getBean(StateMachineFactory.class); StateMachine stateMachine = stateMachineFactory.getStateMachine(); - assertThat(stateMachine, notNullValue()); - assertThat(stateMachine.getId(), is("testid1")); + assertThat(stateMachine).isNotNull(); + assertThat(stateMachine.getId()).isEqualTo("testid1"); stateMachine = stateMachineFactory.getStateMachine("testid2"); - assertThat(stateMachine, notNullValue()); - assertThat(stateMachine.getId(), is("testid2")); + assertThat(stateMachine).isNotNull(); + assertThat(stateMachine.getId()).isEqualTo("testid2"); } @SuppressWarnings("unchecked") @@ -238,19 +234,19 @@ public class ConfigurationTests extends AbstractStateMachineTests { public void testMultipleEndStates() { context.register(Config20.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); Collection> states = machine.getStates(); for (State s : states) { if (s.getId().equals("S3")) { - assertThat(s.getPseudoState(), notNullValue()); - assertThat(s.getPseudoState().getKind(), is(PseudoStateKind.END)); + assertThat(s.getPseudoState()).isNotNull(); + assertThat(s.getPseudoState().getKind()).isEqualTo(PseudoStateKind.END); } if (s.getId().equals("S2")) { - assertThat(s.getPseudoState(), notNullValue()); - assertThat(s.getPseudoState().getKind(), is(PseudoStateKind.END)); + assertThat(s.getPseudoState()).isNotNull(); + assertThat(s.getPseudoState().getKind()).isEqualTo(PseudoStateKind.END); } } } @@ -263,7 +259,7 @@ public class ConfigurationTests extends AbstractStateMachineTests { @SuppressWarnings("unchecked") StateMachineFactory stateMachineFactory22 = context.getBean("stateMachineConfig22", StateMachineFactory.class); StateMachine stateMachine22 = stateMachineFactory22.getStateMachine(); - assertThat(stateMachine22, notNullValue()); + assertThat(stateMachine22).isNotNull(); } diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/MachineTypedTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/MachineTypedTests.java index 9845183e..415c60b4 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/MachineTypedTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/MachineTypedTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2017 the original author or authors. + * Copyright 2017-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,10 +15,7 @@ */ package org.springframework.statemachine.config; -import static org.hamcrest.CoreMatchers.not; -import static org.hamcrest.CoreMatchers.notNullValue; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.sameInstance; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; @@ -43,9 +40,9 @@ public class MachineTypedTests extends AbstractStateMachineTests { context.refresh(); MyBean1 myBean1 = context.getBean(MyBean1.class); - assertThat(myBean1.machine1, notNullValue()); - assertThat(myBean1.machine2, notNullValue()); - assertThat(myBean1.machine1, not(sameInstance(myBean1.machine2))); + assertThat(myBean1.machine1).isNotNull(); + assertThat(myBean1.machine2).isNotNull(); + assertThat(myBean1.machine1).isNotSameAs(myBean1.machine2); } @Test @@ -54,9 +51,9 @@ public class MachineTypedTests extends AbstractStateMachineTests { context.refresh(); MyBean2 myBean2 = context.getBean(MyBean2.class); - assertThat(myBean2.someMachine1, notNullValue()); - assertThat(myBean2.someMachine2, notNullValue()); - assertThat(myBean2.someMachine1, not(sameInstance(myBean2.someMachine2))); + assertThat(myBean2.someMachine1).isNotNull(); + assertThat(myBean2.someMachine2).isNotNull(); + assertThat(myBean2.someMachine1).isNotSameAs(myBean2.someMachine2); } @Test @@ -65,9 +62,9 @@ public class MachineTypedTests extends AbstractStateMachineTests { context.refresh(); MyBean3 myBean3 = context.getBean(MyBean3.class); - assertThat(myBean3.machinefactory1, notNullValue()); - assertThat(myBean3.machinefactory2, notNullValue()); - assertThat(myBean3.machinefactory1, not(sameInstance(myBean3.machinefactory2))); + assertThat(myBean3.machinefactory1).isNotNull(); + assertThat(myBean3.machinefactory2).isNotNull(); + assertThat(myBean3.machinefactory1).isNotSameAs(myBean3.machinefactory2); } @Test @@ -76,9 +73,9 @@ public class MachineTypedTests extends AbstractStateMachineTests { context.refresh(); MyBean4 myBean4 = context.getBean(MyBean4.class); - assertThat(myBean4.someMachineFactory1, notNullValue()); - assertThat(myBean4.someMachineFactory2, notNullValue()); - assertThat(myBean4.someMachineFactory1, not(sameInstance(myBean4.someMachineFactory2))); + assertThat(myBean4.someMachineFactory1).isNotNull(); + assertThat(myBean4.someMachineFactory2).isNotNull(); + assertThat(myBean4.someMachineFactory1).isNotSameAs(myBean4.someMachineFactory2); } @Test @@ -87,9 +84,9 @@ public class MachineTypedTests extends AbstractStateMachineTests { context.refresh(); MyBean5 myBean5 = context.getBean(MyBean5.class); - assertThat(myBean5.someMachineFactory3, notNullValue()); - assertThat(myBean5.someMachineFactory4, notNullValue()); - assertThat(myBean5.someMachineFactory3, not(sameInstance(myBean5.someMachineFactory4))); + assertThat(myBean5.someMachineFactory3).isNotNull(); + assertThat(myBean5.someMachineFactory4).isNotNull(); + assertThat(myBean5.someMachineFactory3).isNotSameAs(myBean5.someMachineFactory4); } @Test @@ -98,9 +95,9 @@ public class MachineTypedTests extends AbstractStateMachineTests { context.refresh(); MyBean6 myBean6 = context.getBean(MyBean6.class); - assertThat(myBean6.someMachine3, notNullValue()); - assertThat(myBean6.someMachine4, notNullValue()); - assertThat(myBean6.someMachine3, not(sameInstance(myBean6.someMachine4))); + assertThat(myBean6.someMachine3).isNotNull(); + assertThat(myBean6.someMachine4).isNotNull(); + assertThat(myBean6.someMachine3).isNotSameAs(myBean6.someMachine4); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/ManualBuilderContextTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/ManualBuilderContextTests.java index 1aebc094..b956ed90 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/ManualBuilderContextTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/ManualBuilderContextTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,9 +15,7 @@ */ package org.springframework.statemachine.config; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.is; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; import static org.springframework.statemachine.TestUtils.resolveMachine; @@ -48,13 +46,13 @@ public class ManualBuilderContextTests extends AbstractStateMachineTests { context.refresh(); TestListener listener = context.getBean(TestListener.class); StateMachine stateMachine = resolveMachine(context); - assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S1")); + assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(stateMachine.getState().getIds()).containsOnly("S1"); listener.reset(1); doSendEventAndConsumeAll(stateMachine, "E1"); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S2")); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(stateMachine.getState().getIds()).containsOnly("S2"); } @Test @@ -64,13 +62,13 @@ public class ManualBuilderContextTests extends AbstractStateMachineTests { TestListener listener = context.getBean(TestListener.class); StateMachine stateMachine = resolveMachine(context); doStartAndAssert(stateMachine); - assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S1")); + assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(stateMachine.getState().getIds()).containsOnly("S1"); listener.reset(1); doSendEventAndConsumeAll(stateMachine, "E1"); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S2")); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(stateMachine.getState().getIds()).containsOnly("S2"); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/ManualBuilderTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/ManualBuilderTests.java index 9a6d487d..ca22bf46 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/ManualBuilderTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/ManualBuilderTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,10 +15,7 @@ */ package org.springframework.statemachine.config; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.notNullValue; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; @@ -63,10 +60,10 @@ public class ManualBuilderTests { stateMachine.addStateListener(listener); doStartAndAssert(stateMachine); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(stateMachine, notNullValue()); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S1")); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(stateMachine).isNotNull(); + assertThat(stateMachine.getState().getIds()).containsOnly("S1"); } @Test @@ -91,15 +88,15 @@ public class ManualBuilderTests { .source("S2").target("S1").event("E2"); StateMachine stateMachine = builder.build(); - assertThat(stateMachine, notNullValue()); + assertThat(stateMachine).isNotNull(); TestListener listener = new TestListener(); stateMachine.addStateListener(listener); doStartAndAssert(stateMachine); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(stateMachine, notNullValue()); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S1")); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(stateMachine).isNotNull(); + assertThat(stateMachine.getState().getIds()).containsOnly("S1"); } @Test @@ -124,22 +121,22 @@ public class ManualBuilderTests { .source(MyStates.S2).target(MyStates.S1).event(MyEvents.E2); StateMachine stateMachine = builder.build(); - assertThat(stateMachine, notNullValue()); + assertThat(stateMachine).isNotNull(); TestListener2 listener = new TestListener2(); stateMachine.addStateListener(listener); doStartAndAssert(stateMachine); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(stateMachine, notNullValue()); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(MyStates.S1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(stateMachine).isNotNull(); + assertThat(stateMachine.getState().getIds()).containsOnly(MyStates.S1); listener.reset(1); doSendEventAndConsumeAll(stateMachine, MyEvents.E1); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(stateMachine, notNullValue()); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(MyStates.S2)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(stateMachine).isNotNull(); + assertThat(stateMachine.getState().getIds()).containsOnly(MyStates.S2); } @Test @@ -163,8 +160,8 @@ public class ManualBuilderTests { StateMachine stateMachine = builder.build(); - assertThat(((SmartLifecycle)stateMachine).isAutoStartup(), is(true)); - assertThat(((SmartLifecycle)stateMachine).isRunning(), is(true)); + assertThat(((SmartLifecycle)stateMachine).isAutoStartup()).isTrue(); + assertThat(((SmartLifecycle)stateMachine).isRunning()).isTrue(); } static enum MyStates { diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/SessionScopedAnnotationTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/SessionScopedAnnotationTests.java index fec6794f..3fd23025 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/SessionScopedAnnotationTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/SessionScopedAnnotationTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,9 +15,7 @@ */ package org.springframework.statemachine.config; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.notNullValue; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content; @@ -80,8 +78,8 @@ public class SessionScopedAnnotationTests { perform(get("/ping").session(session1)). andExpect(status().isOk()); Object machine = session1.getAttribute("scopedTarget.stateMachine"); - assertThat(machine, notNullValue()); - assertThat(TestUtils.callMethod("isRunning", machine), is(true)); + assertThat(machine).isNotNull(); + assertThat(TestUtils.callMethod("isRunning", machine)).isTrue(); } @Test @@ -92,11 +90,11 @@ public class SessionScopedAnnotationTests { mvc. perform(get("/state").session(session1)). andExpect(status().isOk()). - andExpect(content().string(is("SI"))); + andExpect(content().string("SI")); mvc. perform(get("/state").session(session2)). andExpect(status().isOk()). - andExpect(content().string(is("SI"))); + andExpect(content().string("SI")); mvc. perform(post("/state").session(session1).param("event", "E1")). @@ -108,11 +106,11 @@ public class SessionScopedAnnotationTests { mvc. perform(get("/state").session(session1)). andExpect(status().isOk()). - andExpect(content().string(is("S1"))); + andExpect(content().string("S1")); mvc. perform(get("/state").session(session2)). andExpect(status().isOk()). - andExpect(content().string(is("S2"))); + andExpect(content().string("S2")); session1.invalidate(); session2.invalidate(); @@ -124,14 +122,14 @@ public class SessionScopedAnnotationTests { mvc. perform(get("/state").session(session1)). andExpect(status().isOk()). - andExpect(content().string(is("SI"))); + andExpect(content().string("SI")); Object machine = session1.getAttribute("scopedTarget.stateMachine"); machine = TestUtils.readField("object", machine); - assertThat(machine, notNullValue()); - assertThat(TestUtils.callMethod("isRunning", machine), is(true)); + assertThat(machine).isNotNull(); + assertThat(TestUtils.callMethod("isRunning", machine)).isTrue(); session1.invalidate(); - assertThat(TestUtils.callMethod("isRunning", machine), is(false)); + assertThat(TestUtils.callMethod("isRunning", machine)).isFalse(); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/SessionScopedManualTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/SessionScopedManualTests.java index 7076447a..0bec0b4c 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/SessionScopedManualTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/SessionScopedManualTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,9 +15,7 @@ */ package org.springframework.statemachine.config; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.notNullValue; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content; @@ -79,11 +77,11 @@ public class SessionScopedManualTests { mvc. perform(get("/state").session(session1)). andExpect(status().isOk()). - andExpect(content().string(is("S1"))); + andExpect(content().string("S1")); mvc. perform(get("/state").session(session2)). andExpect(status().isOk()). - andExpect(content().string(is("S1"))); + andExpect(content().string("S1")); mvc. perform(post("/state").session(session1).param("event", "E1")). @@ -95,11 +93,11 @@ public class SessionScopedManualTests { mvc. perform(get("/state").session(session1)). andExpect(status().isOk()). - andExpect(content().string(is("S2"))); + andExpect(content().string("S2")); mvc. perform(get("/state").session(session2)). andExpect(status().isOk()). - andExpect(content().string(is("S2"))); + andExpect(content().string("S2")); } @Test @@ -108,12 +106,12 @@ public class SessionScopedManualTests { mvc. perform(get("/state").session(session1)). andExpect(status().isOk()). - andExpect(content().string(is("S1"))); + andExpect(content().string("S1")); Object machine = session1.getAttribute("scopedTarget.stateMachine"); - assertThat(machine, notNullValue()); - assertThat(TestUtils.callMethod("isRunning", machine), is(true)); + assertThat(machine).isNotNull(); + assertThat(TestUtils.callMethod("isRunning", machine)).isTrue(); session1.invalidate(); - assertThat(TestUtils.callMethod("isRunning", machine), is(false)); + assertThat(TestUtils.callMethod("isRunning", machine)).isFalse(); } @Test @@ -123,8 +121,8 @@ public class SessionScopedManualTests { perform(get("/ping").session(session1)). andExpect(status().isOk()); Object machine = session1.getAttribute("scopedTarget.stateMachine"); - assertThat(machine, notNullValue()); - assertThat(TestUtils.callMethod("isRunning", machine), is(true)); + assertThat(machine).isNotNull(); + assertThat(TestUtils.callMethod("isRunning", machine)).isTrue(); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/ComplexAnnotationConfigurationTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/ComplexAnnotationConfigurationTests.java index b032c94a..0ff62f32 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/ComplexAnnotationConfigurationTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/ComplexAnnotationConfigurationTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,11 +15,7 @@ */ package org.springframework.statemachine.config.common.annotation; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.notNullValue; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.assertj.core.api.Assertions.assertThat; import java.util.Iterator; @@ -56,36 +52,36 @@ public class ComplexAnnotationConfigurationTests { @Test public void testSimpleConfig() throws Exception { - assertNotNull(ctx); - assertTrue(ctx.containsBean("complexConfig")); + assertThat(ctx).isNotNull(); + assertThat(ctx.containsBean("complexConfig")).isTrue(); ComplexTestConfig config = ctx.getBean("complexConfig", ComplexTestConfig.class); - assertThat(config.complexData, notNullValue()); - assertThat(config.complexData, is("complexData")); + assertThat(config.complexData).isNotNull(); + assertThat(config.complexData).isEqualTo("complexData"); - assertThat(config.complexProperties, notNullValue()); - assertThat(config.complexProperties.getProperty("complexKey1"), notNullValue()); - assertThat(config.complexProperties.getProperty("complexKey1"), is("complexValue1")); + assertThat(config.complexProperties).isNotNull(); + assertThat(config.complexProperties.getProperty("complexKey1")).isNotNull(); + assertThat(config.complexProperties.getProperty("complexKey1")).isEqualTo("complexValue1"); - assertThat(config.complexBeanA, notNullValue()); - assertThat(config.complexBeanA.dataA, notNullValue()); - assertThat(config.complexBeanA.resources, notNullValue()); + assertThat(config.complexBeanA).isNotNull(); + assertThat(config.complexBeanA.dataA).isNotNull(); + assertThat(config.complexBeanA.resources).isNotNull(); - assertThat(config.complexBeanA.dataA, is("complexDataA")); - assertThat(config.complexBeanA.resources.size(), is(2)); + assertThat(config.complexBeanA.dataA).isEqualTo("complexDataA"); + assertThat(config.complexBeanA.resources).hasSize(2); Iterator iterator = config.complexBeanA.resources.iterator(); String fileName1 = iterator.next().getFilename(); String fileName2 = iterator.next().getFilename(); String[] fileNames = new String[2]; fileNames[0] = fileName1.equals("complexResourceA1") ? fileName1 : fileName2; fileNames[1] = fileName2.equals("complexResourceA2") ? fileName2 : fileName1; - assertThat(fileNames[0], is("complexResourceA1")); - assertThat(fileNames[1], is("complexResourceA2")); + assertThat(fileNames[0]).isEqualTo("complexResourceA1"); + assertThat(fileNames[1]).isEqualTo("complexResourceA2"); - assertTrue(ctx.containsBean("complexConfigData")); - assertTrue(ctx.containsBean("complexConfigBeanB")); + assertThat(ctx.containsBean("complexConfigData")).isTrue(); + assertThat(ctx.containsBean("complexConfigBeanB")).isTrue(); ComplexTestConfigBeanB beanB = ctx.getBean("complexConfigBeanB", ComplexTestConfigBeanB.class); - assertThat(beanB.dataB, is("complexDataB")); - assertThat(beanB.dataBB, is("complexDataBB")); + assertThat(beanB.dataB).isEqualTo("complexDataB"); + assertThat(beanB.dataBB).isEqualTo("complexDataBB"); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/ImportingBeanDefinitionTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/ImportingBeanDefinitionTests.java index 0cce4897..9a83316a 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/ImportingBeanDefinitionTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/ImportingBeanDefinitionTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,8 +15,7 @@ */ package org.springframework.statemachine.config.common.annotation; -import static org.hamcrest.CoreMatchers.sameInstance; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import java.util.UUID; @@ -35,7 +34,7 @@ public class ImportingBeanDefinitionTests { AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(Config.class); Object beanBuilt = ctx.getBean("enableImportingTestBean"); Object beanInjected = ctx.getBean("uuid"); - assertThat(beanBuilt, sameInstance(beanInjected)); + assertThat(beanBuilt).isSameAs(beanInjected); ctx.close(); } diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/MixedAnnotationConfigurationTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/MixedAnnotationConfigurationTests.java index aec8d308..7a36789d 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/MixedAnnotationConfigurationTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/MixedAnnotationConfigurationTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,11 +15,7 @@ */ package org.springframework.statemachine.config.common.annotation; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.notNullValue; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -47,27 +43,26 @@ public class MixedAnnotationConfigurationTests { @Test public void testConfig() throws Exception { - assertNotNull(ctx); - assertTrue(ctx.containsBean("simpleConfig")); + assertThat(ctx.containsBean("simpleConfig")).isTrue(); SimpleTestConfig simpleConfig = ctx.getBean("simpleConfig", SimpleTestConfig.class); - assertThat(simpleConfig.simpleData, notNullValue()); - assertThat(simpleConfig.simpleData, is("simpleData")); + assertThat(simpleConfig.simpleData).isNotNull(); + assertThat(simpleConfig.simpleData).isEqualTo("simpleData"); - assertThat(simpleConfig.simpleProperties, notNullValue()); - assertThat(simpleConfig.simpleProperties.getProperty("simpleKey1"), notNullValue()); - assertThat(simpleConfig.simpleProperties.getProperty("simpleKey1"), is("simpleValue1")); + assertThat(simpleConfig.simpleProperties).isNotNull(); + assertThat(simpleConfig.simpleProperties.getProperty("simpleKey1")).isNotNull(); + assertThat(simpleConfig.simpleProperties.getProperty("simpleKey1")).isEqualTo("simpleValue1"); - assertTrue(ctx.containsBean("complexConfig")); + assertThat(ctx.containsBean("complexConfig")).isTrue(); ComplexTestConfig complexConfig = ctx.getBean("complexConfig", ComplexTestConfig.class); - assertThat(complexConfig.complexData, notNullValue()); - assertThat(complexConfig.complexData, is("complexData")); - assertThat(complexConfig.complexProperties, notNullValue()); - assertThat(complexConfig.complexProperties.getProperty("complexKey1"), notNullValue()); - assertThat(complexConfig.complexProperties.getProperty("complexKey1"), is("complexValue1")); + assertThat(complexConfig.complexData).isNotNull(); + assertThat(complexConfig.complexData).isEqualTo("complexData"); + assertThat(complexConfig.complexProperties).isNotNull(); + assertThat(complexConfig.complexProperties.getProperty("complexKey1")).isNotNull(); + assertThat(complexConfig.complexProperties.getProperty("complexKey1")).isEqualTo("complexValue1"); - assertThat(complexConfig.simpleTestConfig, notNullValue()); - assertThat(complexConfig.simpleTestConfig.simpleData, notNullValue()); - assertThat(complexConfig.simpleTestConfig.simpleData, is("simpleData")); + assertThat(complexConfig.simpleTestConfig).isNotNull(); + assertThat(complexConfig.simpleTestConfig.simpleData).isNotNull(); + assertThat(complexConfig.simpleTestConfig.simpleData).isEqualTo("simpleData"); } diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/MultipleAnnotationConfigurationTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/MultipleAnnotationConfigurationTests.java index 84b5f3c3..09b9f25c 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/MultipleAnnotationConfigurationTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/MultipleAnnotationConfigurationTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,11 +15,7 @@ */ package org.springframework.statemachine.config.common.annotation; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.notNullValue; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -47,24 +43,23 @@ public class MultipleAnnotationConfigurationTests { @Test public void testConfig() throws Exception { - assertNotNull(ctx); - assertTrue(ctx.containsBean("simpleConfig")); + assertThat(ctx.containsBean("simpleConfig")).isTrue(); SimpleTestConfig simpleConfig = ctx.getBean("simpleConfig", SimpleTestConfig.class); - assertThat(simpleConfig.simpleData, notNullValue()); - assertThat(simpleConfig.simpleData, is("simpleData")); + assertThat(simpleConfig.simpleData).isNotNull(); + assertThat(simpleConfig.simpleData).isEqualTo("simpleData"); - assertThat(simpleConfig.simpleProperties, notNullValue()); - assertThat(simpleConfig.simpleProperties.getProperty("simpleKey1"), notNullValue()); - assertThat(simpleConfig.simpleProperties.getProperty("simpleKey1"), is("simpleValue1")); + assertThat(simpleConfig.simpleProperties).isNotNull(); + assertThat(simpleConfig.simpleProperties.getProperty("simpleKey1")).isNotNull(); + assertThat(simpleConfig.simpleProperties.getProperty("simpleKey1")).isEqualTo("simpleValue1"); - assertTrue(ctx.containsBean("complexConfig")); + assertThat(ctx.containsBean("complexConfig")).isTrue(); ComplexTestConfig complexConfig = ctx.getBean("complexConfig", ComplexTestConfig.class); - assertThat(complexConfig.complexData, notNullValue()); - assertThat(complexConfig.complexData, is("complexData")); + assertThat(complexConfig.complexData).isNotNull(); + assertThat(complexConfig.complexData).isEqualTo("complexData"); - assertThat(complexConfig.complexProperties, notNullValue()); - assertThat(complexConfig.complexProperties.getProperty("complexKey1"), notNullValue()); - assertThat(complexConfig.complexProperties.getProperty("complexKey1"), is("complexValue1")); + assertThat(complexConfig.complexProperties).isNotNull(); + assertThat(complexConfig.complexProperties.getProperty("complexKey1")).isNotNull(); + assertThat(complexConfig.complexProperties.getProperty("complexKey1")).isEqualTo("complexValue1"); } diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/SimpleAnnotationConfiguration2Tests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/SimpleAnnotationConfiguration2Tests.java index 483c58a9..bc6d8596 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/SimpleAnnotationConfiguration2Tests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/SimpleAnnotationConfiguration2Tests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,11 +15,7 @@ */ package org.springframework.statemachine.config.common.annotation; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.notNullValue; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.assertj.core.api.Assertions.assertThat; import java.util.Iterator; @@ -54,36 +50,35 @@ public class SimpleAnnotationConfiguration2Tests { @Test public void testSimpleConfig() throws Exception { - assertNotNull(ctx); - assertTrue(ctx.containsBean("simpleConfig")); + assertThat(ctx.containsBean("simpleConfig")).isTrue(); SimpleTestConfig config = ctx.getBean("simpleConfig", SimpleTestConfig.class); - assertThat(config.simpleData, notNullValue()); - assertThat(config.simpleData, is("simpleData")); + assertThat(config.simpleData).isNotNull(); + assertThat(config.simpleData).isEqualTo("simpleData"); - assertThat(config.simpleProperties, notNullValue()); - assertThat(config.simpleProperties.getProperty("simpleKey1"), notNullValue()); - assertThat(config.simpleProperties.getProperty("simpleKey1"), is("simpleValue1")); + assertThat(config.simpleProperties).isNotNull(); + assertThat(config.simpleProperties.getProperty("simpleKey1")).isNotNull(); + assertThat(config.simpleProperties.getProperty("simpleKey1")).isEqualTo("simpleValue1"); - assertThat(config.simpleBeanA, notNullValue()); - assertThat(config.simpleBeanA.dataA, notNullValue()); - assertThat(config.simpleBeanA.resources, notNullValue()); + assertThat(config.simpleBeanA).isNotNull(); + assertThat(config.simpleBeanA.dataA).isNotNull(); + assertThat(config.simpleBeanA.resources).isNotNull(); - assertThat(config.simpleBeanA.dataA, is("simpleDataA")); - assertThat(config.simpleBeanA.resources.size(), is(2)); + assertThat(config.simpleBeanA.dataA).isEqualTo("simpleDataA"); + assertThat(config.simpleBeanA.resources).hasSize(2); Iterator iterator = config.simpleBeanA.resources.iterator(); String fileName1 = iterator.next().getFilename(); String fileName2 = iterator.next().getFilename(); String[] fileNames = new String[2]; fileNames[0] = fileName1.equals("simpleResourceA1") ? fileName1 : fileName2; fileNames[1] = fileName2.equals("simpleResourceA2") ? fileName2 : fileName1; - assertThat(fileNames[0], is("simpleResourceA1")); - assertThat(fileNames[1], is("simpleResourceA2")); + assertThat(fileNames[0]).isEqualTo("simpleResourceA1"); + assertThat(fileNames[1]).isEqualTo("simpleResourceA2"); // assertTrue(ctx.containsBean("simpleConfigData")); // assertTrue(ctx.containsBean("simpleConfigBeanB")); // SimpleTestConfigBeanB beanB = ctx.getBean("simpleConfigBeanB", SimpleTestConfigBeanB.class); -// assertThat(beanB.dataB, is("simpleDataB")); -// assertThat(beanB.dataBB, is("simpleDataBB")); +// assertThat(beanB.dataB).isEqualTo("simpleDataB"); +// assertThat(beanB.dataBB).isEqualTo("simpleDataBB"); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/SimpleAnnotationConfigurationTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/SimpleAnnotationConfigurationTests.java index 8dcd9e0f..9b84f46e 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/SimpleAnnotationConfigurationTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/SimpleAnnotationConfigurationTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,11 +15,7 @@ */ package org.springframework.statemachine.config.common.annotation; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.notNullValue; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.assertj.core.api.Assertions.assertThat; import java.util.Iterator; @@ -55,36 +51,35 @@ public class SimpleAnnotationConfigurationTests { @Test public void testSimpleConfig() throws Exception { - assertNotNull(ctx); - assertTrue(ctx.containsBean("simpleConfig")); + assertThat(ctx.containsBean("simpleConfig")).isTrue(); SimpleTestConfig config = ctx.getBean("simpleConfig", SimpleTestConfig.class); - assertThat(config.simpleData, notNullValue()); - assertThat(config.simpleData, is("simpleData")); + assertThat(config.simpleData).isNotNull(); + assertThat(config.simpleData).isEqualTo("simpleData"); - assertThat(config.simpleProperties, notNullValue()); - assertThat(config.simpleProperties.getProperty("simpleKey1"), notNullValue()); - assertThat(config.simpleProperties.getProperty("simpleKey1"), is("simpleValue1")); + assertThat(config.simpleProperties).isNotNull(); + assertThat(config.simpleProperties.getProperty("simpleKey1")).isNotNull(); + assertThat(config.simpleProperties.getProperty("simpleKey1")).isEqualTo("simpleValue1"); - assertThat(config.simpleBeanA, notNullValue()); - assertThat(config.simpleBeanA.dataA, notNullValue()); - assertThat(config.simpleBeanA.resources, notNullValue()); + assertThat(config.simpleBeanA).isNotNull(); + assertThat(config.simpleBeanA.dataA).isNotNull(); + assertThat(config.simpleBeanA.resources).isNotNull(); - assertThat(config.simpleBeanA.dataA, is("simpleDataA")); - assertThat(config.simpleBeanA.resources.size(), is(2)); + assertThat(config.simpleBeanA.dataA).isEqualTo("simpleDataA"); + assertThat(config.simpleBeanA.resources).hasSize(2); Iterator iterator = config.simpleBeanA.resources.iterator(); String fileName1 = iterator.next().getFilename(); String fileName2 = iterator.next().getFilename(); String[] fileNames = new String[2]; fileNames[0] = fileName1.equals("simpleResourceA1") ? fileName1 : fileName2; fileNames[1] = fileName2.equals("simpleResourceA2") ? fileName2 : fileName1; - assertThat(fileNames[0], is("simpleResourceA1")); - assertThat(fileNames[1], is("simpleResourceA2")); + assertThat(fileNames[0]).isEqualTo("simpleResourceA1"); + assertThat(fileNames[1]).isEqualTo("simpleResourceA2"); - assertTrue(ctx.containsBean("simpleConfigData")); - assertTrue(ctx.containsBean("simpleConfigBeanB")); + assertThat(ctx.containsBean("simpleConfigData")).isTrue(); + assertThat(ctx.containsBean("simpleConfigBeanB")).isTrue(); SimpleTestConfigBeanB beanB = ctx.getBean("simpleConfigBeanB", SimpleTestConfigBeanB.class); - assertThat(beanB.dataB, is("simpleDataB")); - assertThat(beanB.dataBB, is("simpleDataBB")); + assertThat(beanB.dataB).isEqualTo("simpleDataB"); + assertThat(beanB.dataBB).isEqualTo("simpleDataBB"); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/XmlImportDependenciesTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/XmlImportDependenciesTests.java index aaa23268..dc36e742 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/XmlImportDependenciesTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/XmlImportDependenciesTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,10 +15,7 @@ */ package org.springframework.statemachine.config.common.annotation; -import static org.hamcrest.CoreMatchers.notNullValue; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -51,14 +48,13 @@ public class XmlImportDependenciesTests { @Test public void testDependencyBeanFromXml() throws Exception { - assertNotNull(ctx); - assertTrue(ctx.containsBean("simpleConfig")); - assertTrue(ctx.containsBean("simpleConfigBeanB")); - assertTrue(ctx.containsBean("dependencyBean")); + assertThat(ctx.containsBean("simpleConfig")).isTrue(); + assertThat(ctx.containsBean("simpleConfigBeanB")).isTrue(); + assertThat(ctx.containsBean("dependencyBean")).isTrue(); DependencyBean dependencyBean = ctx.getBean(DependencyBean.class); - assertThat(dependencyBean, notNullValue()); - assertThat(dependencyBean.getBeanB(), notNullValue()); + assertThat(dependencyBean).isNotNull(); + assertThat(dependencyBean.getBeanB()).isNotNull(); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/configurers/DefaultStateConfigurerTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/configurers/DefaultStateConfigurerTests.java index 2371de7a..47adbe75 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/configurers/DefaultStateConfigurerTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/configurers/DefaultStateConfigurerTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2016 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,10 +15,7 @@ */ package org.springframework.statemachine.config.configurers; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.notNullValue; -import static org.hamcrest.Matchers.nullValue; +import static org.assertj.core.api.Assertions.assertThat; import java.util.Arrays; import java.util.Collection; @@ -44,9 +41,9 @@ public class DefaultStateConfigurerTests { TestStateMachineStateBuilder builder = new TestStateMachineStateBuilder(); configurer.initial(TestStates.SI); configurer.configure(builder); - assertThat(builder.data, notNullValue()); - assertThat(builder.data.size(), is(1)); - assertThat(builder.data.iterator().next().getState(), is(TestStates.SI)); + assertThat(builder.data).isNotNull(); + assertThat(builder.data).hasSize(1); + assertThat(builder.data.iterator().next().getState()).isEqualTo(TestStates.SI); } @Test @@ -56,9 +53,9 @@ public class DefaultStateConfigurerTests { configurer.initial(TestStates.SI); configurer.state(TestStates.SI); configurer.configure(builder); - assertThat(builder.data, notNullValue()); - assertThat(builder.data.size(), is(1)); - assertThat(builder.data.iterator().next().getState(), is(TestStates.SI)); + assertThat(builder.data).isNotNull(); + assertThat(builder.data).hasSize(1); + assertThat(builder.data.iterator().next().getState()).isEqualTo(TestStates.SI); } @Test @@ -68,9 +65,9 @@ public class DefaultStateConfigurerTests { configurer.state(TestStates.SI); configurer.state(TestStates.SI); configurer.configure(builder); - assertThat(builder.data, notNullValue()); - assertThat(builder.data.size(), is(1)); - assertThat(builder.data.iterator().next().getState(), is(TestStates.SI)); + assertThat(builder.data).isNotNull(); + assertThat(builder.data).hasSize(1); + assertThat(builder.data.iterator().next().getState()).isEqualTo(TestStates.SI); } @Test @@ -80,10 +77,10 @@ public class DefaultStateConfigurerTests { configurer.parent(TestStates.SI); configurer.state(TestStates.S1); configurer.configure(builder); - assertThat(builder.data, notNullValue()); - assertThat(builder.data.size(), is(1)); - assertThat(builder.data.iterator().next().getState(), is(TestStates.S1)); - assertThat((TestStates)builder.data.iterator().next().getParent(), is(TestStates.SI)); + assertThat(builder.data).isNotNull(); + assertThat(builder.data).hasSize(1); + assertThat(builder.data.iterator().next().getState()).isEqualTo(TestStates.S1); + assertThat((TestStates)builder.data.iterator().next().getParent()).isEqualTo(TestStates.SI); } @Test @@ -95,13 +92,13 @@ public class DefaultStateConfigurerTests { configurer.initial(TestStates.S1); configurer.state(TestStates.S1, null, exitActions); configurer.configure(builder); - assertThat(builder.data, notNullValue()); - assertThat(builder.data.size(), is(1)); + assertThat(builder.data).isNotNull(); + assertThat(builder.data).hasSize(1); - assertThat(builder.data.iterator().next().getState(), is(TestStates.S1)); - assertThat(builder.data.iterator().next().getEntryActions(), nullValue()); - assertThat(builder.data.iterator().next().getStateActions(), nullValue()); - assertThat(builder.data.iterator().next().getExitActions(), notNullValue()); + assertThat(builder.data.iterator().next().getState()).isEqualTo(TestStates.S1); + assertThat(builder.data.iterator().next().getEntryActions()).isNull(); + assertThat(builder.data.iterator().next().getStateActions()).isNull(); + assertThat(builder.data.iterator().next().getExitActions()).isNotNull(); } @Test @@ -112,13 +109,13 @@ public class DefaultStateConfigurerTests { TestStateMachineStateBuilder builder = new TestStateMachineStateBuilder(); configurer.state(TestStates.S2, entryActions, null); configurer.configure(builder); - assertThat(builder.data, notNullValue()); - assertThat(builder.data.size(), is(1)); + assertThat(builder.data).isNotNull(); + assertThat(builder.data).hasSize(1); - assertThat(builder.data.iterator().next().getState(), is(TestStates.S2)); - assertThat(builder.data.iterator().next().getExitActions(), nullValue()); - assertThat(builder.data.iterator().next().getStateActions(), nullValue()); - assertThat(builder.data.iterator().next().getEntryActions(), notNullValue()); + assertThat(builder.data.iterator().next().getState()).isEqualTo(TestStates.S2); + assertThat(builder.data.iterator().next().getExitActions()).isNull(); + assertThat(builder.data.iterator().next().getStateActions()).isNull(); + assertThat(builder.data.iterator().next().getEntryActions()).isNotNull(); } @Test @@ -129,13 +126,13 @@ public class DefaultStateConfigurerTests { TestStateMachineStateBuilder builder = new TestStateMachineStateBuilder(); configurer.state(TestStates.S2, stateActions); configurer.configure(builder); - assertThat(builder.data, notNullValue()); - assertThat(builder.data.size(), is(1)); + assertThat(builder.data).isNotNull(); + assertThat(builder.data).hasSize(1); - assertThat(builder.data.iterator().next().getState(), is(TestStates.S2)); - assertThat(builder.data.iterator().next().getExitActions(), nullValue()); - assertThat(builder.data.iterator().next().getStateActions(), notNullValue()); - assertThat(builder.data.iterator().next().getEntryActions(), nullValue()); + assertThat(builder.data.iterator().next().getState()).isEqualTo(TestStates.S2); + assertThat(builder.data.iterator().next().getExitActions()).isNull(); + assertThat(builder.data.iterator().next().getStateActions()).isNotNull(); + assertThat(builder.data.iterator().next().getEntryActions()).isNull(); } @Test @@ -146,16 +143,16 @@ public class DefaultStateConfigurerTests { configurer.stateEntryFunction(TestStates.S2, context -> Mono.empty()); configurer.stateExitFunction(TestStates.S2, context -> Mono.empty()); configurer.configure(builder); - assertThat(builder.data, notNullValue()); - assertThat(builder.data.size(), is(1)); + assertThat(builder.data).isNotNull(); + assertThat(builder.data).hasSize(1); - assertThat(builder.data.iterator().next().getState(), is(TestStates.S2)); - assertThat(builder.data.iterator().next().getExitActions(), notNullValue()); - assertThat(builder.data.iterator().next().getExitActions().size(), is(1)); - assertThat(builder.data.iterator().next().getStateActions(), notNullValue()); - assertThat(builder.data.iterator().next().getStateActions().size(), is(1)); - assertThat(builder.data.iterator().next().getEntryActions(), notNullValue()); - assertThat(builder.data.iterator().next().getEntryActions().size(), is(1)); + assertThat(builder.data.iterator().next().getState()).isEqualTo(TestStates.S2); + assertThat(builder.data.iterator().next().getExitActions()).isNotNull(); + assertThat(builder.data.iterator().next().getExitActions()).hasSize(1); + assertThat(builder.data.iterator().next().getStateActions()).isNotNull(); + assertThat(builder.data.iterator().next().getStateActions()).hasSize(1); + assertThat(builder.data.iterator().next().getEntryActions()).isNotNull(); + assertThat(builder.data.iterator().next().getEntryActions()).hasSize(1); } @Test @@ -164,9 +161,9 @@ public class DefaultStateConfigurerTests { TestStateMachineStateBuilder builder = new TestStateMachineStateBuilder(); configurer.end(TestStates.SF); configurer.configure(builder); - assertThat(builder.data, notNullValue()); - assertThat(builder.data.size(), is(1)); - assertThat(builder.data.iterator().next().getState(), is(TestStates.SF)); + assertThat(builder.data).isNotNull(); + assertThat(builder.data).hasSize(1); + assertThat(builder.data.iterator().next().getState()).isEqualTo(TestStates.SF); } @Test @@ -176,9 +173,9 @@ public class DefaultStateConfigurerTests { configurer.state(TestStates.SF); configurer.end(TestStates.SF); configurer.configure(builder); - assertThat(builder.data, notNullValue()); - assertThat(builder.data.size(), is(1)); - assertThat(builder.data.iterator().next().getState(), is(TestStates.SF)); + assertThat(builder.data).isNotNull(); + assertThat(builder.data).hasSize(1); + assertThat(builder.data.iterator().next().getState()).isEqualTo(TestStates.SF); } @Test @@ -187,10 +184,10 @@ public class DefaultStateConfigurerTests { TestStateMachineStateBuilder builder = new TestStateMachineStateBuilder(); configurer.choice(TestStates.S1); configurer.configure(builder); - assertThat(builder.data, notNullValue()); - assertThat(builder.data.size(), is(1)); - assertThat(builder.data.iterator().next().getState(), is(TestStates.S1)); - assertThat(builder.data.iterator().next().getPseudoStateKind(), is(PseudoStateKind.CHOICE)); + assertThat(builder.data).isNotNull(); + assertThat(builder.data).hasSize(1); + assertThat(builder.data.iterator().next().getState()).isEqualTo(TestStates.S1); + assertThat(builder.data.iterator().next().getPseudoStateKind()).isEqualTo(PseudoStateKind.CHOICE); } private static class TestStateMachineStateBuilder extends StateMachineStateBuilder { diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/model/StateMachineModelFactoryTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/model/StateMachineModelFactoryTests.java index 340e6fe1..c2e8e373 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/model/StateMachineModelFactoryTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/model/StateMachineModelFactoryTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2016-2019 the original author or authors. + * Copyright 2016-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,9 +15,7 @@ */ package org.springframework.statemachine.config.model; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.is; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; import static org.springframework.statemachine.TestUtils.doStopAndAssert; @@ -67,9 +65,9 @@ public class StateMachineModelFactoryTests extends AbstractStateMachineTests { StateMachine stateMachine = factory.getStateMachine(); doStartAndAssert(stateMachine); - assertThat(stateMachine.getState().getIds(), contains("S1")); + assertThat(stateMachine.getState().getIds()).containsExactly("S1"); doSendEventAndConsumeAll(stateMachine, "E1"); - assertThat(stateMachine.getState().getIds(), contains("S2")); + assertThat(stateMachine.getState().getIds()).containsExactly("S2"); } @Test @@ -79,9 +77,9 @@ public class StateMachineModelFactoryTests extends AbstractStateMachineTests { StateMachine stateMachine = resolveMachine(context); doStartAndAssert(stateMachine); - assertThat(stateMachine.getState().getIds(), contains("S1")); + assertThat(stateMachine.getState().getIds()).containsExactly("S1"); doSendEventAndConsumeAll(stateMachine, "E1"); - assertThat(stateMachine.getState().getIds(), contains("S2")); + assertThat(stateMachine.getState().getIds()).containsExactly("S2"); } @Test @@ -93,9 +91,9 @@ public class StateMachineModelFactoryTests extends AbstractStateMachineTests { TestStateMachineModelFactory modelFactory = context.getBean(TestStateMachineModelFactory.class); doStartAndAssert(stateMachine); - assertThat(stateMachine.getState().getIds(), contains("S1")); + assertThat(stateMachine.getState().getIds()).containsExactly("S1"); doSendEventAndConsumeAll(stateMachine, "E1"); - assertThat(stateMachine.getState().getIds(), contains("S2")); + assertThat(stateMachine.getState().getIds()).containsExactly("S2"); doStopAndAssert(stateMachine); modelFactory.state1 = "SS1"; @@ -104,9 +102,9 @@ public class StateMachineModelFactoryTests extends AbstractStateMachineTests { stateMachine = stateMachineFactory.getStateMachine(); doStartAndAssert(stateMachine); - assertThat(stateMachine.getState().getIds(), contains("SS1")); + assertThat(stateMachine.getState().getIds()).containsExactly("SS1"); doSendEventAndConsumeAll(stateMachine, "EE1"); - assertThat(stateMachine.getState().getIds(), contains("SS2")); + assertThat(stateMachine.getState().getIds()).containsExactly("SS2"); doStopAndAssert(stateMachine); } @@ -119,7 +117,7 @@ public class StateMachineModelFactoryTests extends AbstractStateMachineTests { Object o1 = TestUtils.readField("stateListener", stateMachine); Object o2 = TestUtils.readField("listeners", o1); Object o3 = TestUtils.readField("list", o2); - assertThat(((List)o3).size(), is(0)); + assertThat(((List)o3)).isEmpty(); } @Test @@ -131,7 +129,7 @@ public class StateMachineModelFactoryTests extends AbstractStateMachineTests { Object o1 = TestUtils.readField("stateListener", stateMachine); Object o2 = TestUtils.readField("listeners", o1); Object o3 = TestUtils.readField("list", o2); - assertThat(((List)o3).size(), is(1)); + assertThat(((List)o3)).hasSize(1); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/model/StateMachineModelTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/model/StateMachineModelTests.java index e67d3d2b..e95839b4 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/model/StateMachineModelTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/config/model/StateMachineModelTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2016-2019 the original author or authors. + * Copyright 2016-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,9 +15,7 @@ */ package org.springframework.statemachine.config.model; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.containsInAnyOrder; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; @@ -82,9 +80,9 @@ public class StateMachineModelTests { StateMachine stateMachine = factory.getStateMachine(); doStartAndAssert(stateMachine); - assertThat(stateMachine.getState().getIds(), contains("S1")); + assertThat(stateMachine.getState().getIds()).containsExactly("S1"); doSendEventAndConsumeAll(stateMachine, "E1"); - assertThat(stateMachine.getState().getIds(), contains("S2")); + assertThat(stateMachine.getState().getIds()).containsExactly("S2"); } @Test @@ -105,9 +103,9 @@ public class StateMachineModelTests { StateMachine stateMachine = factory.getStateMachine(); doStartAndAssert(stateMachine); - assertThat(stateMachine.getState().getIds(), contains("S1")); + assertThat(stateMachine.getState().getIds()).containsExactly("S1"); doSendEventAndConsumeAll(stateMachine, "E1"); - assertThat(stateMachine.getState().getIds(), contains("S2")); + assertThat(stateMachine.getState().getIds()).containsExactly("S2"); } @Test @@ -145,12 +143,12 @@ public class StateMachineModelTests { StateMachine stateMachine = factory.getStateMachine(); doStartAndAssert(stateMachine); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S1")); + assertThat(stateMachine.getState().getIds()).containsOnly("S1"); doSendEventAndConsumeAll(stateMachine, "E1"); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S2", "S20")); + assertThat(stateMachine.getState().getIds()).containsOnly("S2", "S20"); doSendEventAndConsumeAll(stateMachine, "E2"); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S2", "S21", "S30")); + assertThat(stateMachine.getState().getIds()).containsOnly("S2", "S21", "S30"); doSendEventAndConsumeAll(stateMachine, "E3"); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S2", "S21", "S31")); + assertThat(stateMachine.getState().getIds()).containsOnly("S2", "S21", "S31"); } } diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/docs/DocsConfigurationSampleTests10.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/docs/DocsConfigurationSampleTests10.java index 868c292f..498a4f32 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/docs/DocsConfigurationSampleTests10.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/docs/DocsConfigurationSampleTests10.java @@ -1,5 +1,5 @@ /* - * Copyright 2016-2019 the original author or authors. + * Copyright 2016-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,9 +15,7 @@ */ package org.springframework.statemachine.docs; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.is; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; import static org.springframework.statemachine.TestUtils.resolveMachine; @@ -43,10 +41,10 @@ public class DocsConfigurationSampleTests10 extends AbstractStateMachineTests { context.refresh(); StateMachine machine = resolveMachine(context); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), containsInAnyOrder("S1")); - assertThat(machine.getId(), is("mymachine")); + assertThat(machine.getState().getIds()).containsOnly("S1"); + assertThat(machine.getId()).isEqualTo("mymachine"); doSendEventAndConsumeAll(machine, "E1"); - assertThat(machine.getState().getIds(), containsInAnyOrder("S2")); + assertThat(machine.getState().getIds()).containsOnly("S2"); } @Test @@ -59,10 +57,10 @@ public class DocsConfigurationSampleTests10 extends AbstractStateMachineTests { StateMachine machine = factory.getStateMachine("mymachine"); // end::snippetB[] doStartAndAssert(machine); - assertThat(machine.getState().getIds(), containsInAnyOrder("S1")); - assertThat(machine.getId(), is("mymachine")); + assertThat(machine.getState().getIds()).containsOnly("S1"); + assertThat(machine.getId()).isEqualTo("mymachine"); doSendEventAndConsumeAll(machine, "E1"); - assertThat(machine.getState().getIds(), containsInAnyOrder("S2")); + assertThat(machine.getState().getIds()).containsOnly("S2"); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/docs/DocsConfigurationSampleTests2.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/docs/DocsConfigurationSampleTests2.java index 467913c4..2dd94ccf 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/docs/DocsConfigurationSampleTests2.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/docs/DocsConfigurationSampleTests2.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,8 +15,7 @@ */ package org.springframework.statemachine.docs; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.is; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; import static org.springframework.statemachine.TestUtils.resolveMachine; @@ -206,14 +205,14 @@ public class DocsConfigurationSampleTests2 extends AbstractStateMachineTests { TestListener listener = new TestListener(); machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(listener.stateMachineStartedLatch.await(3, TimeUnit.SECONDS), is(true)); - assertThat(listener.readyStateEnteredLatch.await(3, TimeUnit.SECONDS), is(true)); - assertThat(listener.readyStateEnteredCount, is(1)); + assertThat(listener.stateMachineStartedLatch.await(3, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.readyStateEnteredLatch.await(3, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.readyStateEnteredCount).isEqualTo(1); listener.reset(0, 0, 2); doSendEventAndConsumeAll(machine, "DEPLOY"); doSendEventAndConsumeAll(machine, "DEPLOY"); - assertThat(listener.readyStateEnteredLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.readyStateEnteredCount, is(2)); + assertThat(listener.readyStateEnteredLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.readyStateEnteredCount).isEqualTo(2); } @Test @@ -224,14 +223,14 @@ public class DocsConfigurationSampleTests2 extends AbstractStateMachineTests { TestListener listener = new TestListener(); machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(listener.stateMachineStartedLatch.await(3, TimeUnit.SECONDS), is(true)); - assertThat(listener.readyStateEnteredLatch.await(3, TimeUnit.SECONDS), is(true)); - assertThat(listener.readyStateEnteredCount, is(1)); + assertThat(listener.stateMachineStartedLatch.await(3, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.readyStateEnteredLatch.await(3, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.readyStateEnteredCount).isEqualTo(1); listener.reset(0, 0, 2); doSendEventAndConsumeAll(machine, "DEPLOY"); doSendEventAndConsumeAll(machine, "DEPLOY"); - assertThat(listener.readyStateEnteredLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.readyStateEnteredCount, is(2)); + assertThat(listener.readyStateEnteredLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.readyStateEnteredCount).isEqualTo(2); } @Test @@ -242,14 +241,14 @@ public class DocsConfigurationSampleTests2 extends AbstractStateMachineTests { TestListener listener = new TestListener(); machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(listener.stateMachineStartedLatch.await(3, TimeUnit.SECONDS), is(true)); - assertThat(listener.readyStateEnteredLatch.await(3, TimeUnit.SECONDS), is(true)); - assertThat(listener.readyStateEnteredCount, is(1)); + assertThat(listener.stateMachineStartedLatch.await(3, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.readyStateEnteredLatch.await(3, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.readyStateEnteredCount).isEqualTo(1); listener.reset(0, 0, 2); doSendEventAndConsumeAll(machine, "DEPLOY"); doSendEventAndConsumeAll(machine, "DEPLOY"); - assertThat(listener.readyStateEnteredLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.readyStateEnteredCount, is(2)); + assertThat(listener.readyStateEnteredLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.readyStateEnteredCount).isEqualTo(2); } @Test @@ -260,14 +259,14 @@ public class DocsConfigurationSampleTests2 extends AbstractStateMachineTests { TestListener listener = new TestListener(); machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(listener.stateMachineStartedLatch.await(3, TimeUnit.SECONDS), is(true)); - assertThat(listener.readyStateEnteredLatch.await(3, TimeUnit.SECONDS), is(true)); - assertThat(listener.readyStateEnteredCount, is(1)); + assertThat(listener.stateMachineStartedLatch.await(3, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.readyStateEnteredLatch.await(3, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.readyStateEnteredCount).isEqualTo(1); listener.reset(0, 0, 2); doSendEventAndConsumeAll(machine, "DEPLOY"); doSendEventAndConsumeAll(machine, "DEPLOY"); - assertThat(listener.readyStateEnteredLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.readyStateEnteredCount, is(2)); + assertThat(listener.readyStateEnteredLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.readyStateEnteredCount).isEqualTo(2); } // tag::snippetE[] diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/docs/DocsConfigurationSampleTests5.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/docs/DocsConfigurationSampleTests5.java index 9f0e570e..88ab3716 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/docs/DocsConfigurationSampleTests5.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/docs/DocsConfigurationSampleTests5.java @@ -1,5 +1,5 @@ /* - * Copyright 2016-2019 the original author or authors. + * Copyright 2016-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,8 +15,7 @@ */ package org.springframework.statemachine.docs; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; +import static org.assertj.core.api.Assertions.assertThat; import java.util.HashMap; @@ -63,11 +62,11 @@ public class DocsConfigurationSampleTests5 extends AbstractStateMachineTests { .sendEvent(Mono.just(MessageBuilder .withPayload("E1").build())) .blockLast(); - assertThat(stateMachine1.getState().getIds(), contains("S2")); + assertThat(stateMachine1.getState().getIds()).containsExactly("S2"); persister.persist(stateMachine1, "myid"); persister.restore(stateMachine2, "myid"); - assertThat(stateMachine2.getState().getIds(), contains("S2")); + assertThat(stateMachine2.getState().getIds()).containsExactly("S2"); // end::snippetC[] } diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/docs/DocsConfigurationSampleTests6.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/docs/DocsConfigurationSampleTests6.java index 5ef6f7fe..ef65a22b 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/docs/DocsConfigurationSampleTests6.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/docs/DocsConfigurationSampleTests6.java @@ -1,5 +1,5 @@ /* - * Copyright 2016-2019 the original author or authors. + * Copyright 2016-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,8 +15,7 @@ */ package org.springframework.statemachine.docs; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; @@ -62,9 +61,9 @@ public class DocsConfigurationSampleTests6 { StateMachine stateMachine = factory.getStateMachine(); // end::snippetA[] doStartAndAssert(stateMachine); - assertThat(stateMachine.getState().getIds(), contains("S1")); + assertThat(stateMachine.getState().getIds()).containsExactly("S1"); doSendEventAndConsumeAll(stateMachine, "E1"); - assertThat(stateMachine.getState().getIds(), contains("S2")); + assertThat(stateMachine.getState().getIds()).containsExactly("S2"); } } diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/docs/IntroSample.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/docs/IntroSample.java index 75e72c8a..67baab3f 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/docs/IntroSample.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/docs/IntroSample.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,8 +15,7 @@ */ package org.springframework.statemachine.docs; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsInAnyOrder; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; @@ -116,11 +115,11 @@ public class IntroSample { public void testManual() throws Exception { StateMachine stateMachine = buildMachine(); doStartAndAssert(stateMachine); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(States.STATE1)); + assertThat(stateMachine.getState().getIds()).containsOnly(States.STATE1); doSendEventAndConsumeAll(stateMachine, Events.EVENT1); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(States.STATE2)); + assertThat(stateMachine.getState().getIds()).containsOnly(States.STATE2); doSendEventAndConsumeAll(stateMachine, Events.EVENT2); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(States.STATE1)); + assertThat(stateMachine.getState().getIds()).containsOnly(States.STATE1); } public StateMachine buildMachine() throws Exception { diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/ensemble/DistributedStateMachineTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/ensemble/DistributedStateMachineTests.java index cd4839c5..5e08eff2 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/ensemble/DistributedStateMachineTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/ensemble/DistributedStateMachineTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,8 +15,7 @@ */ package org.springframework.statemachine.ensemble; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; import org.springframework.context.annotation.AnnotationConfigApplicationContext; @@ -60,12 +59,12 @@ public class DistributedStateMachineTests extends AbstractStateMachineTests { machine2s.start(); machine1s.sendEvent("E1"); - assertThat(machine1.getState().getIds(), containsInAnyOrder("S1")); - assertThat(machine2.getState().getIds(), containsInAnyOrder("S1")); + assertThat(machine1.getState().getIds()).containsOnly("S1"); + assertThat(machine2.getState().getIds()).containsOnly("S1"); machine2s.sendEvent("E2"); - assertThat(machine1.getState().getIds(), containsInAnyOrder("S2")); - assertThat(machine2.getState().getIds(), containsInAnyOrder("S2")); + assertThat(machine1.getState().getIds()).containsOnly("S2"); + assertThat(machine2.getState().getIds()).containsOnly("S2"); } @Test @@ -86,14 +85,14 @@ public class DistributedStateMachineTests extends AbstractStateMachineTests { machine1s.start(); machine1s.sendEvent("E1"); - assertThat(machine1.getState().getIds(), containsInAnyOrder("S1")); + assertThat(machine1.getState().getIds()).containsOnly("S1"); DistributedStateMachine machine2s = new DistributedStateMachine(ensemble, machine2); machine2s.afterPropertiesSet(); machine2s.start(); - assertThat(machine2.getState().getIds(), containsInAnyOrder("S1")); + assertThat(machine2.getState().getIds()).containsOnly("S1"); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/event/ContextEventTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/event/ContextEventTests.java index 28c34dbe..2e7f1e50 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/event/ContextEventTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/event/ContextEventTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,9 +15,7 @@ */ package org.springframework.statemachine.event; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.greaterThan; +import static org.assertj.core.api.Assertions.assertThat; import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; @@ -62,7 +60,7 @@ public class ContextEventTests extends AbstractStateMachineTests { machine.sendEvent(TestEvents.E1); StateMachineApplicationEventListener listener = context.getBean(StateMachineApplicationEventListener.class); listener.latch.await(1, TimeUnit.SECONDS); - assertThat(listener.count, greaterThan(1)); + assertThat(listener.count).isGreaterThan(1); } @SuppressWarnings("unchecked") @@ -76,7 +74,7 @@ public class ContextEventTests extends AbstractStateMachineTests { machine.sendEvent(TestEvents.E1); StateMachineApplicationEventListener listener = context.getBean(StateMachineApplicationEventListener.class); listener.latch.await(1, TimeUnit.SECONDS); - assertThat(listener.count, is(0)); + assertThat(listener.count).isZero(); } @SuppressWarnings("unchecked") @@ -90,7 +88,7 @@ public class ContextEventTests extends AbstractStateMachineTests { machine.sendEvent(TestEvents.E1); StateMachineApplicationEventListener listener = context.getBean(StateMachineApplicationEventListener.class); listener.latch.await(1, TimeUnit.SECONDS); - assertThat(listener.count, greaterThan(1)); + assertThat(listener.count).isGreaterThan(1); } @SuppressWarnings("unchecked") @@ -106,7 +104,7 @@ public class ContextEventTests extends AbstractStateMachineTests { listener.reset(); machine.sendEvent(TestEvents.E1); listener.latch.await(1, TimeUnit.SECONDS); - assertThat(listener.count, greaterThan(1)); + assertThat(listener.count).isGreaterThan(1); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/event/StateMachineEventTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/event/StateMachineEventTests.java index 1d387450..17475d1f 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/event/StateMachineEventTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/event/StateMachineEventTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,12 +15,7 @@ */ package org.springframework.statemachine.event; -import static org.hamcrest.CoreMatchers.instanceOf; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.notNullValue; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.assertj.core.api.Assertions.assertThat; import java.util.ArrayList; import java.util.EnumSet; @@ -59,13 +54,13 @@ public class StateMachineEventTests extends AbstractStateMachineTests { public void testContextEvents() throws Exception { context.register(Config1.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); TestEventListener listener = context.getBean(TestEventListener.class); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); machine.start(); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.sendEvent(TestEvents.E1); machine.sendEvent(TestEvents.E2); machine.sendEvent(TestEvents.E3); @@ -74,15 +69,15 @@ public class StateMachineEventTests extends AbstractStateMachineTests { // 6 events instead of 5, first one is initial transition // to SI where source state is null - assertThat(listener.onEventLatch.await(5, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedEvents.size(), is(6)); + assertThat(listener.onEventLatch.await(5, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedEvents).hasSize(6); } @Test public void testEventNotAccepted() throws Exception { context.register(Config1.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); TestEventListener eventListener = context.getBean(TestEventListener.class); TestListener listener = new TestListener(); @SuppressWarnings("unchecked") @@ -91,44 +86,44 @@ public class StateMachineEventTests extends AbstractStateMachineTests { eventListener.reset(2, 0); machine.addStateListener(listener); machine.start(); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.sendEvent(TestEvents.E1); - assertThat(eventListener.onEventLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(eventListener.stateChangedEvents.size(), is(2)); + assertThat(eventListener.onEventLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(eventListener.stateChangedEvents).hasSize(2); eventListener.reset(0, 1); machine.sendEvent(TestEvents.E3); - assertThat(eventListener.onEventLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(eventListener.eventNotAcceptedEvents.size(), is(1)); - assertThat(eventListener.eventNotAcceptedEvents.get(0), instanceOf(OnEventNotAcceptedEvent.class)); - assertThat(((OnEventNotAcceptedEvent)eventListener.eventNotAcceptedEvents.get(0)).getEvent().getPayload(), is(TestEvents.E3)); + assertThat(eventListener.onEventLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(eventListener.eventNotAcceptedEvents).hasSize(1); + assertThat(eventListener.eventNotAcceptedEvents.get(0)).isInstanceOf(OnEventNotAcceptedEvent.class); + assertThat(((OnEventNotAcceptedEvent)eventListener.eventNotAcceptedEvents.get(0)).getEvent().getPayload()).isEqualTo(TestEvents.E3); - assertThat(listener.eventNotAcceptedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.eventNotAccepted.size(), is(1)); + assertThat(listener.eventNotAcceptedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.eventNotAccepted).hasSize(1); } @Test public void testSubmachineHandlesEvent() throws Exception { context.register(Config2.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); machine.start(); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); - assertThat(machine.getState().getIds(), contains(TestStates.S1, TestStates.S10)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1, TestStates.S10); machine.sendEvent(TestEvents.E1); - assertThat(machine.getState().getIds(), contains(TestStates.S1, TestStates.S12)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1, TestStates.S12); } @Test public void testEventNotAcceptedS1() throws Exception { context.register(Config3.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); @@ -136,21 +131,21 @@ public class StateMachineEventTests extends AbstractStateMachineTests { machine.addStateListener(listener); machine.start(); - assertThat(machine.getState().getIds(), contains(TestStates.S1, TestStates.S11, TestStates.S111)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1, TestStates.S11, TestStates.S111); listener.reset(1); boolean accepted = machine.sendEvent(TestEvents.E2); - assertThat(accepted, is(false)); - assertThat(machine.getState().getIds(), contains(TestStates.S1, TestStates.S11, TestStates.S111)); - assertThat(listener.eventNotAcceptedLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(listener.eventNotAccepted.size(), is(3)); + assertThat(accepted).isFalse(); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1, TestStates.S11, TestStates.S111); + assertThat(listener.eventNotAcceptedLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.eventNotAccepted).hasSize(3); } @Test public void testEventAcceptedS1() throws Exception { context.register(Config3.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); @@ -158,21 +153,21 @@ public class StateMachineEventTests extends AbstractStateMachineTests { machine.addStateListener(listener); machine.start(); - assertThat(machine.getState().getIds(), contains(TestStates.S1, TestStates.S11, TestStates.S111)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1, TestStates.S11, TestStates.S111); listener.reset(1); boolean accepted = machine.sendEvent(TestEvents.E1); - assertThat(accepted, is(true)); - assertThat(machine.getState().getIds(), contains(TestStates.S1, TestStates.S11, TestStates.S111)); - assertThat(listener.eventNotAcceptedLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(listener.eventNotAccepted.size(), is(2)); + assertThat(accepted).isTrue(); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1, TestStates.S11, TestStates.S111); + assertThat(listener.eventNotAcceptedLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.eventNotAccepted).hasSize(2); } @Test public void testEventAcceptedS1NoS1Transition() throws Exception { context.register(Config4.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); @@ -180,21 +175,21 @@ public class StateMachineEventTests extends AbstractStateMachineTests { machine.addStateListener(listener); machine.start(); - assertThat(machine.getState().getIds(), contains(TestStates.S1, TestStates.S11, TestStates.S111)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1, TestStates.S11, TestStates.S111); listener.reset(1); boolean accepted = machine.sendEvent(TestEvents.E1); - assertThat(accepted, is(true)); - assertThat(machine.getState().getIds(), contains(TestStates.S1, TestStates.S11, TestStates.S111)); - assertThat(listener.eventNotAcceptedLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(listener.eventNotAccepted.size(), is(2)); + assertThat(accepted).isTrue(); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1, TestStates.S11, TestStates.S111); + assertThat(listener.eventNotAcceptedLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.eventNotAccepted).hasSize(2); } @Test public void testEventAcceptedS1GuardAllow() throws Exception { context.register(Config3.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); @@ -202,22 +197,22 @@ public class StateMachineEventTests extends AbstractStateMachineTests { machine.addStateListener(listener); machine.start(); - assertThat(machine.getState().getIds(), contains(TestStates.S1, TestStates.S11, TestStates.S111)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1, TestStates.S11, TestStates.S111); machine.getExtendedState().getVariables().put("S1E1", true); listener.reset(1); boolean accepted = machine.sendEvent(TestEvents.E1); - assertThat(accepted, is(true)); - assertThat(machine.getState().getIds(), contains(TestStates.S2)); - assertThat(listener.eventNotAcceptedLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(listener.eventNotAccepted.size(), is(2)); + assertThat(accepted).isTrue(); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S2); + assertThat(listener.eventNotAcceptedLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.eventNotAccepted).hasSize(2); } @Test public void testEventAcceptedS11GuardAllow() throws Exception { context.register(Config3.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); @@ -225,22 +220,22 @@ public class StateMachineEventTests extends AbstractStateMachineTests { machine.addStateListener(listener); machine.start(); - assertThat(machine.getState().getIds(), contains(TestStates.S1, TestStates.S11, TestStates.S111)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1, TestStates.S11, TestStates.S111); machine.getExtendedState().getVariables().put("S11E1", true); listener.reset(1); boolean accepted = machine.sendEvent(TestEvents.E1); - assertThat(accepted, is(true)); - assertThat(machine.getState().getIds(), contains(TestStates.S1, TestStates.S12)); - assertThat(listener.eventNotAcceptedLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(listener.eventNotAccepted.size(), is(2)); + assertThat(accepted).isTrue(); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1, TestStates.S12); + assertThat(listener.eventNotAcceptedLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.eventNotAccepted).hasSize(2); } @Test public void testEventAcceptedS111GuardAllow() throws Exception { context.register(Config3.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); @@ -248,15 +243,15 @@ public class StateMachineEventTests extends AbstractStateMachineTests { machine.addStateListener(listener); machine.start(); - assertThat(machine.getState().getIds(), contains(TestStates.S1, TestStates.S11, TestStates.S111)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1, TestStates.S11, TestStates.S111); machine.getExtendedState().getVariables().put("S111E1", true); listener.reset(1); boolean accepted = machine.sendEvent(TestEvents.E1); - assertThat(accepted, is(true)); - assertThat(machine.getState().getIds(), contains(TestStates.S1, TestStates.S11, TestStates.S112)); - assertThat(listener.eventNotAcceptedLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(listener.eventNotAccepted.size(), is(2)); + assertThat(accepted).isTrue(); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1, TestStates.S11, TestStates.S112); + assertThat(listener.eventNotAcceptedLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.eventNotAccepted).hasSize(2); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/guard/GuardTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/guard/GuardTests.java index 0baffa03..67b79099 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/guard/GuardTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/guard/GuardTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,10 +15,7 @@ */ package org.springframework.statemachine.guard; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.notNullValue; +import static org.assertj.core.api.Assertions.assertThat; import java.util.concurrent.TimeUnit; @@ -54,13 +51,13 @@ public class GuardTests { ctx.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); TestGuard testGuard = ctx.getBean("testGuard", TestGuard.class); TestAction testAction = ctx.getBean("testAction", TestAction.class); - assertThat(testGuard, notNullValue()); - assertThat(testAction, notNullValue()); + assertThat(testGuard).isNotNull(); + assertThat(testAction).isNotNull(); machine.start(); machine.sendEvent(TestEvents.E1); - assertThat(testGuard.onEvaluateLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(testAction.onExecuteLatch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(testGuard.onEvaluateLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(testAction.onExecuteLatch.await(2, TimeUnit.SECONDS)).isTrue(); ctx.close(); } @@ -73,16 +70,16 @@ public class GuardTests { ctx.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); TestGuard testGuard = ctx.getBean("testGuard", TestGuard.class); TestAction testAction = ctx.getBean("testAction", TestAction.class); - assertThat(testGuard, notNullValue()); - assertThat(testAction, notNullValue()); + assertThat(testGuard).isNotNull(); + assertThat(testAction).isNotNull(); machine.start(); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); machine.sendEvent(TestEvents.E1); - assertThat(testGuard.onEvaluateLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(testAction.onExecuteLatch.await(2, TimeUnit.SECONDS), is(false)); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(testGuard.onEvaluateLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(testAction.onExecuteLatch.await(2, TimeUnit.SECONDS)).isFalse(); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); ctx.close(); } @@ -94,13 +91,13 @@ public class GuardTests { ObjectStateMachine machine = ctx.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); machine.start(); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); machine.sendEvent(TestEvents.E1); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); machine.sendEvent(TestEvents.E2); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); machine.sendEvent(TestEvents.E3); - assertThat(machine.getState().getIds(), contains(TestStates.S2)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S2); ctx.close(); } diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/guard/SpelExpressionGuardTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/guard/SpelExpressionGuardTests.java index 1bb42678..9d36d366 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/guard/SpelExpressionGuardTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/guard/SpelExpressionGuardTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,10 +15,7 @@ */ package org.springframework.statemachine.guard; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.assertj.core.api.Assertions.assertThat; import java.util.EnumSet; import java.util.HashMap; @@ -61,21 +58,21 @@ public class SpelExpressionGuardTests extends AbstractStateMachineTests { MessageHeaders headers = new MessageHeaders(map); DefaultStateContext stateContext = new DefaultStateContext(null, null, headers, null, null, null, null, null, null); - assertThat(guard.evaluate(stateContext), is(true)); + assertThat(guard.evaluate(stateContext)).isTrue(); } @SuppressWarnings({ "unchecked" }) @Test public void testGuardDenyStateChange() throws Exception { AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(Config1.class); - assertTrue(ctx.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(ctx.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); ObjectStateMachine machine = ctx.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); machine.start(); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).build()); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); ctx.close(); } diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/listener/CompositeStateMachineListenerTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/listener/CompositeStateMachineListenerTests.java index 8dd000b2..b5b64e36 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/listener/CompositeStateMachineListenerTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/listener/CompositeStateMachineListenerTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,14 +15,13 @@ */ package org.springframework.statemachine.listener; +import static org.assertj.core.api.Assertions.assertThat; + import org.junit.jupiter.api.Test; import org.springframework.statemachine.TestUtils; import java.util.List; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.is; - public class CompositeStateMachineListenerTests { @Test @@ -32,7 +31,7 @@ public class CompositeStateMachineListenerTests { listener.register(adapter1); OrderedComposite> listeners = listener.getListeners(); List list = TestUtils.readField("list", listeners); - assertThat(list.size(), is(1)); + assertThat(list).hasSize(1); } @Test @@ -43,7 +42,7 @@ public class CompositeStateMachineListenerTests { listener.unregister(adapter1); OrderedComposite> listeners = listener.getListeners(); List list = TestUtils.readField("list", listeners); - assertThat(list.size(), is(0)); + assertThat(list).isEmpty(); } } diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/listener/ListenerTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/listener/ListenerTests.java index 8006a91c..30d5f686 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/listener/ListenerTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/listener/ListenerTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,11 +15,7 @@ */ package org.springframework.statemachine.listener; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.notNullValue; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.assertj.core.api.Assertions.assertThat; import java.util.ArrayList; import java.util.concurrent.CountDownLatch; @@ -57,7 +53,7 @@ public class ListenerTests extends AbstractStateMachineTests { @Test public void testStateEvents() { AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(Config1.class); - assertTrue(ctx.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(ctx.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = ctx.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); @@ -66,17 +62,17 @@ public class ListenerTests extends AbstractStateMachineTests { TestStateMachineListener listener = new TestStateMachineListener(); machine.addStateListener(listener); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).setHeader("foo", "jee1").build()); - assertThat(listener.states.size(), is(1)); - assertThat(listener.states.get(0).from.getIds(), contains(TestStates.S1)); - assertThat(listener.states.get(0).to.getIds(), contains(TestStates.S2)); + assertThat(listener.states).hasSize(1); + assertThat(listener.states.get(0).from.getIds()).containsExactly(TestStates.S1); + assertThat(listener.states.get(0).to.getIds()).containsExactly(TestStates.S2); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E2).setHeader("foo", "jee2").build()); - assertThat(listener.states.size(), is(2)); - assertThat(listener.states.get(1).from.getIds(), contains(TestStates.S2)); - assertThat(listener.states.get(1).to.getIds(), contains(TestStates.S3)); + assertThat(listener.states).hasSize(2); + assertThat(listener.states.get(1).from.getIds()).containsExactly(TestStates.S2); + assertThat(listener.states.get(1).to.getIds()).containsExactly(TestStates.S3); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E4).setHeader("foo", "jee2").build()); - assertThat(listener.states.size(), is(2)); + assertThat(listener.states).hasSize(2); ctx.close(); } @@ -84,7 +80,7 @@ public class ListenerTests extends AbstractStateMachineTests { @Test public void testStartEndEvents() throws Exception { AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(Config2.class); - assertTrue(ctx.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(ctx.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = ctx.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); @@ -95,16 +91,16 @@ public class ListenerTests extends AbstractStateMachineTests { machine.start(); machine.sendEvent(TestEvents.E1); machine.sendEvent(TestEvents.E2); - assertThat(listener.stopLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.started, is(1)); - assertThat(listener.stopped, is(1)); + assertThat(listener.stopLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.started).isEqualTo(1); + assertThat(listener.stopped).isEqualTo(1); ctx.close(); } @Test public void testExtendedStateEvents() throws Exception { AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(Config2.class); - assertTrue(ctx.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(ctx.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = ctx.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); @@ -114,10 +110,10 @@ public class ListenerTests extends AbstractStateMachineTests { machine.start(); machine.getExtendedState().getVariables().put("foo", "jee"); - assertThat(listener.extendedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.extended.size(), is(1)); - assertThat(listener.extended.get(0).key, is("foo")); - assertThat(listener.extended.get(0).value, is("jee")); + assertThat(listener.extendedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.extended).hasSize(1); + assertThat(listener.extended.get(0).key).isEqualTo("foo"); + assertThat(listener.extended.get(0).value).isEqualTo("jee"); ctx.close(); } diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/monitor/StateMachineMonitorTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/monitor/StateMachineMonitorTests.java index dccc5f34..933dc8fd 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/monitor/StateMachineMonitorTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/monitor/StateMachineMonitorTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2016-2019 the original author or authors. + * Copyright 2016-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,9 +15,7 @@ */ package org.springframework.statemachine.monitor; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.is; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; import static org.springframework.statemachine.TestUtils.resolveMachine; @@ -57,22 +55,22 @@ public class StateMachineMonitorTests extends AbstractStateMachineTests { LatchAction saction = context.getBean("saction", LatchAction.class); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), contains("S1")); + assertThat(machine.getState().getIds()).containsExactly("S1"); doSendEventAndConsumeAll(machine, "E1"); - assertThat(machine.getState().getIds(), contains("S2")); + assertThat(machine.getState().getIds()).containsExactly("S2"); // there's also initial transition, thus 2 instead 1 - assertThat(monitor.transitions.size(), is(2)); - assertThat(saction.latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(monitor.latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(monitor.actions.size(), is(4)); + assertThat(monitor.transitions).hasSize(2); + assertThat(saction.latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(monitor.latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(monitor.actions).hasSize(4); // TODO: REACTOR yeah we wrap action internally so can't match like this anymore // Action taction = context.getBean("taction", Action.class); // Action enaction = context.getBean("enaction", Action.class); // Action exaction = context.getBean("exaction", Action.class); - // assertThat(monitor.actions.keySet(), containsInAnyOrder(taction, enaction, exaction, saction)); + // assertThat(monitor.actions.keySet()).containsOnly(taction, enaction, exaction, saction); monitor.reset(); doSendEventAndConsumeAll(machine, "E2"); - assertThat(machine.getState().getIds(), contains("S1")); + assertThat(machine.getState().getIds()).containsExactly("S1"); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/persist/DefaultStateMachinePersisterTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/persist/DefaultStateMachinePersisterTests.java index e596e835..bf7d55ad 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/persist/DefaultStateMachinePersisterTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/persist/DefaultStateMachinePersisterTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2017-2019 the original author or authors. + * Copyright 2017-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,10 +15,7 @@ */ package org.springframework.statemachine.persist; -import static org.hamcrest.CoreMatchers.anyOf; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.nullValue; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; @@ -49,15 +46,15 @@ public class DefaultStateMachinePersisterTests { StateMachinePersister persister = new DefaultStateMachinePersister<>(persist); persister.persist(machine, "xxx"); StateMachineContext context = persist.contexts.get("xxx"); - assertThat(context.getState(), is("SI")); - assertThat(context.getId(), nullValue()); - assertThat(context.getChilds().isEmpty(), is(true)); + assertThat(context.getState()).isEqualTo("SI"); + assertThat(context.getId()).isNull(); + assertThat(context.getChilds().isEmpty()).isTrue(); doSendEventAndConsumeAll(machine, "E1"); doSendEventAndConsumeAll(machine, "E1"); persister.persist(machine, "xxx"); context = persist.contexts.get("xxx"); - assertThat(context.getState(), is("S1")); + assertThat(context.getState()).isEqualTo("S1"); } @Test @@ -69,27 +66,27 @@ public class DefaultStateMachinePersisterTests { StateMachinePersister persister = new DefaultStateMachinePersister<>(persist); persister.persist(machine, "xxx"); StateMachineContext context = persist.contexts.get("xxx"); - assertThat(context.getState(), is("SI")); - assertThat(context.getId(), nullValue()); - assertThat(context.getChilds().isEmpty(), is(true)); + assertThat(context.getState()).isEqualTo("SI"); + assertThat(context.getId()).isNull(); + assertThat(context.getChilds().isEmpty()).isTrue(); doSendEventAndConsumeAll(machine, "E1"); persister.persist(machine, "xxx"); context = persist.contexts.get("xxx"); - assertThat(context.getState(), is("S1I")); - assertThat(context.getChilds().size(), is(1)); + assertThat(context.getState()).isEqualTo("S1I"); + assertThat(context.getChilds()).hasSize(1); doSendEventAndConsumeAll(machine, "E2"); persister.persist(machine, "xxx"); context = persist.contexts.get("xxx"); - assertThat(context.getState(), is("S11")); - assertThat(context.getChilds().size(), is(1)); + assertThat(context.getState()).isEqualTo("S11"); + assertThat(context.getChilds()).hasSize(1); doSendEventAndConsumeAll(machine, "E3"); persister.persist(machine, "xxx"); context = persist.contexts.get("xxx"); - assertThat(context.getState(), is("S11")); - assertThat(context.getChilds().size(), is(1)); + assertThat(context.getState()).isEqualTo("S11"); + assertThat(context.getChilds()).hasSize(1); } @Test @@ -101,32 +98,56 @@ public class DefaultStateMachinePersisterTests { StateMachinePersister persister = new DefaultStateMachinePersister<>(persist); persister.persist(machine, "xxx"); StateMachineContext context = persist.contexts.get("xxx"); - assertThat(context.getState(), nullValue()); - assertThat(context.getId(), nullValue()); - assertThat(context.getChilds().size(), is(2)); - assertThat(context.getChilds().get(0).getState(), anyOf(is("S111"), is("S21"))); - assertThat(context.getChilds().get(1).getState(), anyOf(is("S111"), is("S21"))); + assertThat(context.getState()).isNull(); + assertThat(context.getId()).isNull(); + assertThat(context.getChilds()).hasSize(2); + assertThat(context.getChilds().get(0).getState()).satisfiesAnyOf( + state -> assertThat(state).isEqualTo("S111"), + state -> assertThat(state).isEqualTo("S21") + ); + assertThat(context.getChilds().get(1).getState()).satisfiesAnyOf( + state -> assertThat(state).isEqualTo("S111"), + state -> assertThat(state).isEqualTo("S21") + ); doSendEventAndConsumeAll(machine, "E1"); persister.persist(machine, "xxx"); context = persist.contexts.get("xxx"); - assertThat(context.getChilds().size(), is(2)); - assertThat(context.getChilds().get(0).getState(), anyOf(is("S12"), is("S21"))); - assertThat(context.getChilds().get(1).getState(), anyOf(is("S12"), is("S21"))); + assertThat(context.getChilds()).hasSize(2); + assertThat(context.getChilds().get(0).getState()).satisfiesAnyOf( + state -> assertThat(state).isEqualTo("S12"), + state -> assertThat(state).isEqualTo("S21") + ); + assertThat(context.getChilds().get(1).getState()).satisfiesAnyOf( + state -> assertThat(state).isEqualTo("S12"), + state -> assertThat(state).isEqualTo("S21") + ); doSendEventAndConsumeAll(machine, "E2"); persister.persist(machine, "xxx"); context = persist.contexts.get("xxx"); - assertThat(context.getChilds().size(), is(2)); - assertThat(context.getChilds().get(0).getState(), anyOf(is("S12"), is("S221"))); - assertThat(context.getChilds().get(1).getState(), anyOf(is("S12"), is("S221"))); + assertThat(context.getChilds()).hasSize(2); + assertThat(context.getChilds().get(0).getState()).satisfiesAnyOf( + state -> assertThat(state).isEqualTo("S12"), + state -> assertThat(state).isEqualTo("S221") + ); + assertThat(context.getChilds().get(1).getState()).satisfiesAnyOf( + state -> assertThat(state).isEqualTo("S12"), + state -> assertThat(state).isEqualTo("S221") + ); doSendEventAndConsumeAll(machine, "E3"); persister.persist(machine, "xxx"); context = persist.contexts.get("xxx"); - assertThat(context.getChilds().size(), is(2)); - assertThat(context.getChilds().get(0).getState(), anyOf(is("S12"), is("S222"))); - assertThat(context.getChilds().get(1).getState(), anyOf(is("S12"), is("S222"))); + assertThat(context.getChilds()).hasSize(2); + assertThat(context.getChilds().get(0).getState()).satisfiesAnyOf( + state -> assertThat(state).isEqualTo("S12"), + state -> assertThat(state).isEqualTo("S222") + ); + assertThat(context.getChilds().get(1).getState()).satisfiesAnyOf( + state -> assertThat(state).isEqualTo("S12"), + state -> assertThat(state).isEqualTo("S222") + ); } @Test @@ -138,42 +159,42 @@ public class DefaultStateMachinePersisterTests { StateMachinePersister persister = new DefaultStateMachinePersister<>(persist); persister.persist(machine, "xxx"); StateMachineContext context = persist.contexts.get("xxx"); - assertThat(context.getState(), is("S2")); + assertThat(context.getState()).isEqualTo("S2"); doSendEventAndConsumeAll(machine, "E1"); persister.persist(machine, "xxx"); context = persist.contexts.get("xxx"); - assertThat(context.getState(), is("S3")); - assertThat(context.getChilds().size(), is(1)); - assertThat(context.getChilds().get(0).getChilds().size(), is(2)); + assertThat(context.getState()).isEqualTo("S3"); + assertThat(context.getChilds()).hasSize(1); + assertThat(context.getChilds().get(0).getChilds()).hasSize(2); doSendEventAndConsumeAll(machine, "E2"); persister.persist(machine, "xxx"); context = persist.contexts.get("xxx"); - assertThat(context.getState(), is("S3")); - assertThat(context.getChilds().size(), is(1)); - assertThat(context.getChilds().get(0).getChilds().size(), is(2)); + assertThat(context.getState()).isEqualTo("S3"); + assertThat(context.getChilds()).hasSize(1); + assertThat(context.getChilds().get(0).getChilds()).hasSize(2); doSendEventAndConsumeAll(machine, "E3"); persister.persist(machine, "xxx"); context = persist.contexts.get("xxx"); - assertThat(context.getState(), is("S3")); - assertThat(context.getChilds().size(), is(1)); - assertThat(context.getChilds().get(0).getChilds().size(), is(2)); + assertThat(context.getState()).isEqualTo("S3"); + assertThat(context.getChilds()).hasSize(1); + assertThat(context.getChilds().get(0).getChilds()).hasSize(2); doSendEventAndConsumeAll(machine, "E4"); persister.persist(machine, "xxx"); context = persist.contexts.get("xxx"); - assertThat(context.getState(), is("S3")); - assertThat(context.getChilds().size(), is(1)); - assertThat(context.getChilds().get(0).getChilds().size(), is(2)); + assertThat(context.getState()).isEqualTo("S3"); + assertThat(context.getChilds()).hasSize(1); + assertThat(context.getChilds().get(0).getChilds()).hasSize(2); doSendEventAndConsumeAll(machine, "E5"); persister.persist(machine, "xxx"); context = persist.contexts.get("xxx"); - assertThat(context.getState(), is("END")); - assertThat(context.getChilds().size(), is(1)); - assertThat(context.getChilds().get(0).getChilds().isEmpty(), is(true)); + assertThat(context.getState()).isEqualTo("END"); + assertThat(context.getChilds()).hasSize(1); + assertThat(context.getChilds().get(0).getChilds().isEmpty()).isTrue(); } private StateMachine buildSimpleFlat() throws Exception { diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/persist/StateMachinePersistTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/persist/StateMachinePersistTests.java index 42f6a5ef..d644187b 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/persist/StateMachinePersistTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/persist/StateMachinePersistTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2016-2019 the original author or authors. + * Copyright 2016-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,11 +15,7 @@ */ package org.springframework.statemachine.persist; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.notNullValue; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; import static org.springframework.statemachine.TestUtils.resolveFactory; @@ -60,17 +56,17 @@ public class StateMachinePersistTests extends AbstractStateMachineTests { doStartAndAssert(stateMachine); doSendEventAndConsumeAll(stateMachine, "E1"); - assertThat(stateMachine.getState().getIds(), contains("S2")); + assertThat(stateMachine.getState().getIds()).containsExactly("S2"); InMemoryStateMachinePersist1 stateMachinePersist = new InMemoryStateMachinePersist1(); StateMachinePersister persister = new DefaultStateMachinePersister<>(stateMachinePersist); persister.persist(stateMachine, "xxx"); persister.restore(stateMachine, "xxx"); - assertThat(stateMachine.getState().getIds(), contains("S2")); + assertThat(stateMachine.getState().getIds()).containsExactly("S2"); doSendEventAndConsumeAll(stateMachine, "E2"); - assertThat(stateMachine.getState().getIds(), contains("S3")); + assertThat(stateMachine.getState().getIds()).containsExactly("S3"); } @Test @@ -80,17 +76,17 @@ public class StateMachinePersistTests extends AbstractStateMachineTests { StateMachine stateMachine = resolveMachine(context); doStartAndAssert(stateMachine); doSendEventAndConsumeAll(stateMachine, TestEvents.E1); - assertThat(stateMachine.getState().getIds(), contains(TestStates.S2)); + assertThat(stateMachine.getState().getIds()).containsExactly(TestStates.S2); InMemoryStateMachinePersist2 stateMachinePersist = new InMemoryStateMachinePersist2(); StateMachinePersister persister = new DefaultStateMachinePersister<>(stateMachinePersist); persister.persist(stateMachine, "xxx"); persister.restore(stateMachine, "xxx"); - assertThat(stateMachine.getState().getIds(), contains(TestStates.S2)); + assertThat(stateMachine.getState().getIds()).containsExactly(TestStates.S2); doSendEventAndConsumeAll(stateMachine, TestEvents.E2); - assertThat(stateMachine.getState().getIds(), contains(TestStates.S3)); + assertThat(stateMachine.getState().getIds()).containsExactly(TestStates.S3); } @Test @@ -109,7 +105,7 @@ public class StateMachinePersistTests extends AbstractStateMachineTests { stateMachine.getExtendedState().getVariables().remove("foo"); stateMachine = persister.restore(stateMachine, "xxx"); - assertThat(stateMachine.getExtendedState().get("foo", String.class), is("bar")); + assertThat(stateMachine.getExtendedState().get("foo", String.class)).isEqualTo("bar"); } @Test @@ -119,22 +115,22 @@ public class StateMachinePersistTests extends AbstractStateMachineTests { StateMachine stateMachine = resolveMachine(context); doStartAndAssert(stateMachine); doSendEventAndConsumeAll(stateMachine, "E1"); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S2", "S21")); + assertThat(stateMachine.getState().getIds()).containsOnly("S2", "S21"); doSendEventAndConsumeAll(stateMachine, "E3"); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S2", "S22")); + assertThat(stateMachine.getState().getIds()).containsOnly("S2", "S22"); InMemoryStateMachinePersist1 stateMachinePersist = new InMemoryStateMachinePersist1(); StateMachinePersister persister = new DefaultStateMachinePersister<>(stateMachinePersist); persister.persist(stateMachine, "xxx"); stateMachine = persister.restore(stateMachine, "xxx"); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S2", "S22")); + assertThat(stateMachine.getState().getIds()).containsOnly("S2", "S22"); doSendEventAndConsumeAll(stateMachine, "E2"); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S3", "S31")); + assertThat(stateMachine.getState().getIds()).containsOnly("S3", "S31"); stateMachine = persister.restore(stateMachine, "xxx"); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S2", "S22")); + assertThat(stateMachine.getState().getIds()).containsOnly("S2", "S22"); } @Test @@ -144,29 +140,29 @@ public class StateMachinePersistTests extends AbstractStateMachineTests { StateMachine stateMachine = resolveMachine(context); doStartAndAssert(stateMachine); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S11", "S21", "S31")); + assertThat(stateMachine.getState().getIds()).containsOnly("S11", "S21", "S31"); doSendEventAndConsumeAll(stateMachine, "E1"); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S12", "S21", "S31")); + assertThat(stateMachine.getState().getIds()).containsOnly("S12", "S21", "S31"); doSendEventAndConsumeAll(stateMachine, "E2"); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S12", "S22", "S31")); + assertThat(stateMachine.getState().getIds()).containsOnly("S12", "S22", "S31"); doSendEventAndConsumeAll(stateMachine, "E3"); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S12", "S22", "S32")); + assertThat(stateMachine.getState().getIds()).containsOnly("S12", "S22", "S32"); InMemoryStateMachinePersist1 stateMachinePersist = new InMemoryStateMachinePersist1(); StateMachinePersister persister = new DefaultStateMachinePersister<>(stateMachinePersist); persister.persist(stateMachine, "xxx"); stateMachine = persister.restore(stateMachine, "xxx"); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S12", "S22", "S32")); + assertThat(stateMachine.getState().getIds()).containsOnly("S12", "S22", "S32"); doSendEventAndConsumeAll(stateMachine, "E4"); doSendEventAndConsumeAll(stateMachine, "E5"); doSendEventAndConsumeAll(stateMachine, "E6"); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S13", "S23", "S33")); + assertThat(stateMachine.getState().getIds()).containsOnly("S13", "S23", "S33"); stateMachine = persister.restore(stateMachine, "xxx"); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S12", "S22", "S32")); + assertThat(stateMachine.getState().getIds()).containsOnly("S12", "S22", "S32"); } @Test @@ -181,24 +177,24 @@ public class StateMachinePersistTests extends AbstractStateMachineTests { StateMachine stateMachine2 = resolveMachine("machine2", context); doStartAndAssert(stateMachine1); - assertThat(stateMachine1.getState().getIds(), containsInAnyOrder("S11", "S111", "S21")); + assertThat(stateMachine1.getState().getIds()).containsOnly("S11", "S111", "S21"); persister.persist(stateMachine1, "xxx"); stateMachine2 = persister.restore(stateMachine2, "xxx"); - assertThat(stateMachine2.getState().getIds(), containsInAnyOrder("S11", "S111", "S21")); + assertThat(stateMachine2.getState().getIds()).containsOnly("S11", "S111", "S21"); doSendEventAndConsumeAll(stateMachine1, "E1"); - assertThat(stateMachine1.getState().getIds(), containsInAnyOrder("S12", "S21")); + assertThat(stateMachine1.getState().getIds()).containsOnly("S12", "S21"); persister.persist(stateMachine1, "xxx"); - assertThat(stateMachine2.getState().getIds(), containsInAnyOrder("S11", "S111", "S21")); + assertThat(stateMachine2.getState().getIds()).containsOnly("S11", "S111", "S21"); stateMachine2 = persister.restore(stateMachine2, "xxx"); - assertThat(stateMachine2.getState().getIds(), containsInAnyOrder("S12", "S21")); + assertThat(stateMachine2.getState().getIds()).containsOnly("S12", "S21"); doSendEventAndConsumeAll(stateMachine1, "E2"); - assertThat(stateMachine1.getState().getIds(), containsInAnyOrder("S12", "S22", "S221")); + assertThat(stateMachine1.getState().getIds()).containsOnly("S12", "S22", "S221"); persister.persist(stateMachine1, "xxx"); - assertThat(stateMachine2.getState().getIds(), containsInAnyOrder("S12", "S21")); + assertThat(stateMachine2.getState().getIds()).containsOnly("S12", "S21"); stateMachine2 = persister.restore(stateMachine2, "xxx"); - assertThat(stateMachine2.getState().getIds(), containsInAnyOrder("S12", "S22", "S221")); + assertThat(stateMachine2.getState().getIds()).containsOnly("S12", "S22", "S221"); } @Test @@ -214,14 +210,14 @@ public class StateMachinePersistTests extends AbstractStateMachineTests { doStartAndAssert(stateMachine1); doSendEventAndConsumeAll(stateMachine1, "E1"); - assertThat(stateMachine1.getState().getIds(), containsInAnyOrder("S12", "S21")); + assertThat(stateMachine1.getState().getIds()).containsOnly("S12", "S21"); doSendEventAndConsumeAll(stateMachine1, "E2"); - assertThat(stateMachine1.getState().getIds(), containsInAnyOrder("S12", "S22", "S221")); + assertThat(stateMachine1.getState().getIds()).containsOnly("S12", "S22", "S221"); doSendEventAndConsumeAll(stateMachine1, "E3"); - assertThat(stateMachine1.getState().getIds(), containsInAnyOrder("S12", "S22", "S222")); + assertThat(stateMachine1.getState().getIds()).containsOnly("S12", "S22", "S222"); persister.persist(stateMachine1, "xxx"); stateMachine2 = persister.restore(stateMachine2, "xxx"); - assertThat(stateMachine2.getState().getIds(), containsInAnyOrder("S12", "S22", "S222")); + assertThat(stateMachine2.getState().getIds()).containsOnly("S12", "S22", "S222"); } @Test @@ -242,16 +238,16 @@ public class StateMachinePersistTests extends AbstractStateMachineTests { // event E1 takes into state S2 doSendEventAndConsumeAll(stateMachine1, "E1"); - assertThat(stateMachine1.getState().getIds(), contains("S2")); + assertThat(stateMachine1.getState().getIds()).containsExactly("S2"); Object history = readHistoryState(stateMachine1); - assertThat(history, is("S2")); + assertThat(history).isEqualTo("S2"); // we persist with state S2 and history keeps same S2 persister.persist(stateMachine1, "xxx"); stateMachine2 = persister.restore(stateMachine2, "xxx"); history = readHistoryState(stateMachine2); - assertThat(history, is("S2")); + assertThat(history).isEqualTo("S2"); } @Test @@ -270,25 +266,25 @@ public class StateMachinePersistTests extends AbstractStateMachineTests { doStartAndAssert(stateMachine1); doSendEventAndConsumeAll(stateMachine1, "E1"); - assertThat(stateMachine1.getState().getIds(), containsInAnyOrder("S2", "S21")); + assertThat(stateMachine1.getState().getIds()).containsOnly("S2", "S21"); doSendEventAndConsumeAll(stateMachine1, "E3"); - assertThat(stateMachine1.getState().getIds(), containsInAnyOrder("S2", "S22")); + assertThat(stateMachine1.getState().getIds()).containsOnly("S2", "S22"); persister.persist(stateMachine1, "xxx"); doSendEventAndConsumeAll(stateMachine1, "E2"); - assertThat(stateMachine1.getState().getIds(), containsInAnyOrder("S1")); + assertThat(stateMachine1.getState().getIds()).containsOnly("S1"); stateMachine2 = persister.restore(stateMachine2, "xxx"); Object history = TestUtils.readField("history", stateMachine1); - assertThat(history, notNullValue()); - assertThat(stateMachine2.getState().getIds(), containsInAnyOrder("S2", "S22")); + assertThat(history).isNotNull(); + assertThat(stateMachine2.getState().getIds()).containsOnly("S2", "S22"); doSendEventAndConsumeAll(stateMachine2, "E2"); - assertThat(stateMachine2.getState().getIds(), containsInAnyOrder("S1")); + assertThat(stateMachine2.getState().getIds()).containsOnly("S1"); doSendEventAndConsumeAll(stateMachine2, "EH3"); - assertThat(stateMachine2.getState().getIds(), containsInAnyOrder("S2", "S22")); + assertThat(stateMachine2.getState().getIds()).containsOnly("S2", "S22"); } @Test @@ -300,21 +296,21 @@ public class StateMachinePersistTests extends AbstractStateMachineTests { StateMachineFactory stateMachineFactory = resolveFactory(context); StateMachine stateMachine = stateMachineFactory.getStateMachine(); - assertThat(stateMachine, notNullValue()); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S1")); + assertThat(stateMachine).isNotNull(); + assertThat(stateMachine.getState().getIds()).containsOnly("S1"); doSendEventAndConsumeAll(stateMachine, "E1"); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S2")); - assertThat(stateMachine.isComplete(), is(true)); + assertThat(stateMachine.getState().getIds()).containsOnly("S2"); + assertThat(stateMachine.isComplete()).isTrue(); persister.persist(stateMachine, "xxx"); stateMachine = stateMachineFactory.getStateMachine(); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S1")); + assertThat(stateMachine.getState().getIds()).containsOnly("S1"); stateMachine = persister.restore(stateMachine, "xxx"); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S2")); - assertThat(stateMachine.isComplete(), is(true)); + assertThat(stateMachine.getState().getIds()).containsOnly("S2"); + assertThat(stateMachine.isComplete()).isTrue(); } @Test @@ -324,29 +320,29 @@ public class StateMachinePersistTests extends AbstractStateMachineTests { StateMachine stateMachine = resolveMachine(context); doStartAndAssert(stateMachine); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S11", "S21", "S31")); + assertThat(stateMachine.getState().getIds()).containsOnly("S11", "S21", "S31"); doSendEventAndConsumeAll(stateMachine, "E1"); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S12", "S21", "S31")); + assertThat(stateMachine.getState().getIds()).containsOnly("S12", "S21", "S31"); doSendEventAndConsumeAll(stateMachine, "E2"); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S12", "S22", "S31")); + assertThat(stateMachine.getState().getIds()).containsOnly("S12", "S22", "S31"); doSendEventAndConsumeAll(stateMachine, "E3"); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S12", "S22", "S32")); + assertThat(stateMachine.getState().getIds()).containsOnly("S12", "S22", "S32"); InMemoryStateMachinePersist1 stateMachinePersist = new InMemoryStateMachinePersist1(); StateMachinePersister persister = new DefaultStateMachinePersister<>(stateMachinePersist); persister.persist(stateMachine, "xxx"); stateMachine = persister.restore(stateMachine, "xxx"); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S12", "S22", "S32")); + assertThat(stateMachine.getState().getIds()).containsOnly("S12", "S22", "S32"); doSendEventAndConsumeAll(stateMachine, "E4"); doSendEventAndConsumeAll(stateMachine, "E5"); doSendEventAndConsumeAll(stateMachine, "E6"); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S13", "S23", "S33")); + assertThat(stateMachine.getState().getIds()).containsOnly("S13", "S23", "S33"); stateMachine = persister.restore(stateMachine, "xxx"); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S12", "S22", "S32")); + assertThat(stateMachine.getState().getIds()).containsOnly("S12", "S22", "S32"); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/persist/StateMachinePersistTests2.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/persist/StateMachinePersistTests2.java index 0dd3672e..1d1be0ca 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/persist/StateMachinePersistTests2.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/persist/StateMachinePersistTests2.java @@ -1,5 +1,5 @@ /* - * Copyright 2016-2019 the original author or authors. + * Copyright 2016-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,9 +15,7 @@ */ package org.springframework.statemachine.persist; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.equalTo; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.resolveFactory; @@ -78,67 +76,67 @@ public class StateMachinePersistTests2 extends AbstractStateMachineTests { StateMachineFactory factory = resolveFactory("LOG_RECORD", context); StateMachine m = factory.getStateMachine(); - assertThat(m.getState().getId(), equalTo(RECORD_AWAITING_CONTENT)); + assertThat(m.getState().getId()).isEqualTo(RECORD_AWAITING_CONTENT); m = loadStateMachine(factory, persister, "xxx"); doSendEventAndConsumeAll(m, UPLOAD_RECORD); - assertThat(m.getState().getIds(), containsInAnyOrder(new String[] { RECORD_LOGGING_ACTIVE, RECORD_AWAITING_LOGGING })); + assertThat(m.getState().getIds()).containsOnly(new String[] { RECORD_LOGGING_ACTIVE, RECORD_AWAITING_LOGGING }); persister.persist(m, "xxx"); m = loadStateMachine(factory, persister, "xxx"); - assertThat(m.getState().getIds(), containsInAnyOrder(new String[]{RECORD_LOGGING_ACTIVE, RECORD_AWAITING_LOGGING})); + assertThat(m.getState().getIds()).containsOnly(new String[]{RECORD_LOGGING_ACTIVE, RECORD_AWAITING_LOGGING}); persister.persist(m, "xxx"); doSendEventAndConsumeAll(m, SUSPEND_RECORD_LOGGING); - assertThat(m.getState().getIds(), containsInAnyOrder(new String[]{RECORD_LOGGING_ACTIVE, RECORD_LOGGING_ON_HOLD})); + assertThat(m.getState().getIds()).containsOnly(new String[]{RECORD_LOGGING_ACTIVE, RECORD_LOGGING_ON_HOLD}); persister.persist(m, "xxx"); m = loadStateMachine(factory, persister, "xxx"); - assertThat(m.getState().getIds(), containsInAnyOrder(new String[]{RECORD_LOGGING_ACTIVE, RECORD_LOGGING_ON_HOLD})); + assertThat(m.getState().getIds()).containsOnly(new String[]{RECORD_LOGGING_ACTIVE, RECORD_LOGGING_ON_HOLD}); persister.persist(m, "xxx"); doSendEventAndConsumeAll(m, START_LOGGING_RECORD); - assertThat(m.getState().getIds(), containsInAnyOrder(new String[]{RECORD_LOGGING_IN_PROGRESS})); + assertThat(m.getState().getIds()).containsOnly(new String[]{RECORD_LOGGING_IN_PROGRESS}); persister.persist(m, "xxx"); m = loadStateMachine(factory, persister, "xxx"); doSendEventAndConsumeAll(m, CANCEL_RECORD_LOGGING); - assertThat(m.getState().getIds(), containsInAnyOrder(new String[]{RECORD_LOGGING_ACTIVE, RECORD_LOGGING_ON_HOLD})); + assertThat(m.getState().getIds()).containsOnly(new String[]{RECORD_LOGGING_ACTIVE, RECORD_LOGGING_ON_HOLD}); persister.persist(m, "xxx"); m = loadStateMachine(factory, persister, "xxx"); doSendEventAndConsumeAll(m, RESUME_RECORD_LOGGING); - assertThat(m.getState().getIds(), containsInAnyOrder(new String[]{RECORD_LOGGING_ACTIVE, RECORD_AWAITING_LOGGING})); + assertThat(m.getState().getIds()).containsOnly(new String[]{RECORD_LOGGING_ACTIVE, RECORD_AWAITING_LOGGING}); persister.persist(m, "xxx"); m = loadStateMachine(factory, persister, "xxx"); doSendEventAndConsumeAll(m, START_LOGGING_RECORD); - assertThat(m.getState().getIds(), containsInAnyOrder(new String[]{RECORD_LOGGING_IN_PROGRESS})); + assertThat(m.getState().getIds()).containsOnly(new String[]{RECORD_LOGGING_IN_PROGRESS}); persister.persist(m, "xxx"); m = loadStateMachine(factory, persister, "xxx"); doSendEventAndConsumeAll(m, CANCEL_RECORD_LOGGING); - assertThat(m.getState().getIds(), containsInAnyOrder(new String[]{RECORD_LOGGING_ACTIVE, RECORD_AWAITING_LOGGING})); + assertThat(m.getState().getIds()).containsOnly(new String[]{RECORD_LOGGING_ACTIVE, RECORD_AWAITING_LOGGING}); persister.persist(m, "xxx"); m = loadStateMachine(factory, persister, "xxx"); doSendEventAndConsumeAll(m, SUSPEND_RECORD_LOGGING_WITH_ERROR); - assertThat(m.getState().getIds(), containsInAnyOrder(new String[]{RECORD_LOGGING_ON_HOLD_WITH_ERROR})); + assertThat(m.getState().getIds()).containsOnly(new String[]{RECORD_LOGGING_ON_HOLD_WITH_ERROR}); persister.persist(m, "xxx"); m = loadStateMachine(factory, persister, "xxx"); doSendEventAndConsumeAll(m, RESUME_RECORD_LOGGING); - assertThat(m.getState().getIds(), containsInAnyOrder(new String[]{RECORD_LOGGING_ACTIVE, RECORD_AWAITING_LOGGING})); + assertThat(m.getState().getIds()).containsOnly(new String[]{RECORD_LOGGING_ACTIVE, RECORD_AWAITING_LOGGING}); persister.persist(m, "xxx"); m = loadStateMachine(factory, persister, "xxx"); doSendEventAndConsumeAll(m, START_LOGGING_RECORD); - assertThat(m.getState().getIds(), containsInAnyOrder(new String[]{RECORD_LOGGING_IN_PROGRESS})); + assertThat(m.getState().getIds()).containsOnly(new String[]{RECORD_LOGGING_IN_PROGRESS}); persister.persist(m, "xxx"); m = loadStateMachine(factory, persister, "xxx"); doSendEventAndConsumeAll(m, LOG_RECORD); - assertThat(m.getState().getIds(), containsInAnyOrder(new String[]{RECORD_LOGGED})); + assertThat(m.getState().getIds()).containsOnly(new String[]{RECORD_LOGGED}); persister.persist(m, "xxx"); } diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/persist/StateMachinePersistTests3.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/persist/StateMachinePersistTests3.java index 92d52c33..3e4b0b94 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/persist/StateMachinePersistTests3.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/persist/StateMachinePersistTests3.java @@ -1,5 +1,5 @@ /* - * Copyright 2016 the original author or authors. + * Copyright 2016-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,10 +15,7 @@ */ package org.springframework.statemachine.persist; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.notNullValue; -import static org.hamcrest.Matchers.nullValue; +import static org.assertj.core.api.Assertions.assertThat; import java.util.HashMap; @@ -55,17 +52,17 @@ public class StateMachinePersistTests3 extends AbstractStateMachineTests { StateMachineFactory stateMachineFactory = context.getBean(StateMachineFactory.class); StateMachine stateMachine = stateMachineFactory.getStateMachine("testid2"); - assertThat(stateMachine, notNullValue()); - assertThat(stateMachine.getId(), is("testid2")); + assertThat(stateMachine).isNotNull(); + assertThat(stateMachine.getId()).isEqualTo("testid2"); persister.persist(stateMachine, "xxx"); stateMachine = stateMachineFactory.getStateMachine(); - assertThat(stateMachine, notNullValue()); - assertThat(stateMachine.getId(), nullValue()); + assertThat(stateMachine).isNotNull(); + assertThat(stateMachine.getId()).isNull(); stateMachine = persister.restore(stateMachine, "xxx"); - assertThat(stateMachine.getId(), is("testid2")); + assertThat(stateMachine.getId()).isEqualTo("testid2"); } @Test @@ -78,19 +75,19 @@ public class StateMachinePersistTests3 extends AbstractStateMachineTests { StateMachineFactory stateMachineFactory = context.getBean(StateMachineFactory.class); StateMachine stateMachine = stateMachineFactory.getStateMachine("testid2"); - assertThat(stateMachine, notNullValue()); - assertThat(stateMachine.getId(), is("testid2")); + assertThat(stateMachine).isNotNull(); + assertThat(stateMachine.getId()).isEqualTo("testid2"); TestUtils.setField("id", stateMachine, "newid"); - assertThat(stateMachine.getId(), is("newid")); + assertThat(stateMachine.getId()).isEqualTo("newid"); persister.persist(stateMachine, "xxx"); stateMachine = stateMachineFactory.getStateMachine(); - assertThat(stateMachine, notNullValue()); - assertThat(stateMachine.getId(), nullValue()); + assertThat(stateMachine).isNotNull(); + assertThat(stateMachine.getId()).isNull(); stateMachine = persister.restore(stateMachine, "xxx"); - assertThat(stateMachine.getId(), is("newid")); + assertThat(stateMachine.getId()).isEqualTo("newid"); } @Test @@ -101,16 +98,16 @@ public class StateMachinePersistTests3 extends AbstractStateMachineTests { StateMachinePersister persister = new DefaultStateMachinePersister<>(stateMachinePersist); @SuppressWarnings("unchecked") StateMachine stateMachine = context.getBean(StateMachine.class); - assertThat(stateMachine, notNullValue()); - assertThat(stateMachine.getId(), nullValue()); + assertThat(stateMachine).isNotNull(); + assertThat(stateMachine.getId()).isNull(); TestUtils.setField("id", stateMachine, "newid"); - assertThat(stateMachine.getId(), is("newid")); + assertThat(stateMachine.getId()).isEqualTo("newid"); persister.persist(stateMachine, "xxx"); TestUtils.setField("id", stateMachine, "xxx"); stateMachine = persister.restore(stateMachine, "xxx"); - assertThat(stateMachine.getId(), is("newid")); + assertThat(stateMachine.getId()).isEqualTo("newid"); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/persist/StateMachinePersistTests4.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/persist/StateMachinePersistTests4.java index eda7004b..f570d7d6 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/persist/StateMachinePersistTests4.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/persist/StateMachinePersistTests4.java @@ -1,5 +1,5 @@ /* - * Copyright 2016 the original author or authors. + * Copyright 2016-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,12 +15,7 @@ */ package org.springframework.statemachine.persist; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.notNullValue; -import static org.hamcrest.Matchers.nullValue; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; import static org.springframework.statemachine.TestUtils.resolveFactory; @@ -71,41 +66,41 @@ public class StateMachinePersistTests4 extends AbstractStateMachineTests { StateMachine stateMachine = stateMachineFactory.getStateMachine("testid"); doStartAndAssert(stateMachine); - assertThat(stateMachine, notNullValue()); - assertThat(stateMachine.getId(), is("testid")); + assertThat(stateMachine).isNotNull(); + assertThat(stateMachine.getId()).isEqualTo("testid"); doSendEventAndConsumeAll(stateMachine, TestEvents.E1); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S20, TestStates.S30)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S20, TestStates.S30); persister.persist(stateMachine, "xxx1"); doSendEventAndConsumeAll(stateMachine, TestEvents.E2); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S30)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S30); persister.persist(stateMachine, "xxx2"); doSendEventAndConsumeAll(stateMachine, TestEvents.E3); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S4)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S4); persister.persist(stateMachine, "xxx3"); stateMachine = stateMachineFactory.getStateMachine(); - assertThat(stateMachine, notNullValue()); - assertThat(stateMachine.getId(), nullValue()); + assertThat(stateMachine).isNotNull(); + assertThat(stateMachine.getId()).isNull(); stateMachine = persister.restore(stateMachine, "xxx1"); - assertThat(stateMachine.getId(), is("testid")); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S20, TestStates.S30)); + assertThat(stateMachine.getId()).isEqualTo("testid"); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S20, TestStates.S30); stateMachine = stateMachineFactory.getStateMachine(); - assertThat(stateMachine, notNullValue()); - assertThat(stateMachine.getId(), nullValue()); + assertThat(stateMachine).isNotNull(); + assertThat(stateMachine.getId()).isNull(); stateMachine = persister.restore(stateMachine, "xxx2"); - assertThat(stateMachine.getId(), is("testid")); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S30)); + assertThat(stateMachine.getId()).isEqualTo("testid"); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S30); stateMachine = stateMachineFactory.getStateMachine(); - assertThat(stateMachine, notNullValue()); - assertThat(stateMachine.getId(), nullValue()); + assertThat(stateMachine).isNotNull(); + assertThat(stateMachine.getId()).isNull(); stateMachine = persister.restore(stateMachine, "xxx3"); - assertThat(stateMachine.getId(), is("testid")); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S4)); + assertThat(stateMachine.getId()).isEqualTo("testid"); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S4); } @Test @@ -122,18 +117,18 @@ public class StateMachinePersistTests4 extends AbstractStateMachineTests { doStartAndAssert(stateMachine); doSendEventAndConsumeAll(stateMachine, TestEvents.E1); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S20, TestStates.S30)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S20, TestStates.S30); persister.persist(stateMachine, "xxx1"); stateMachine = stateMachineFactory.getStateMachine(); stateMachine = persister.restore(stateMachine, "xxx1"); - assertThat(stateMachine.getId(), is("testid")); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S20, TestStates.S30)); + assertThat(stateMachine.getId()).isEqualTo("testid"); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S20, TestStates.S30); doSendEventAndConsumeAll(stateMachine, TestEvents.E2); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S30)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S30); doSendEventAndConsumeAll(stateMachine, TestEvents.E3); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S4)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S4); } @Test @@ -150,27 +145,27 @@ public class StateMachinePersistTests4 extends AbstractStateMachineTests { doStartAndAssert(stateMachine); doSendEventAndConsumeAll(stateMachine, TestEvents.E1); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S20, TestStates.S30)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S20, TestStates.S30); persister.persist(stateMachine, "xxx1"); stateMachine = stateMachineFactory.getStateMachine(); stateMachine = persister.restore(stateMachine, "xxx1"); - assertThat(stateMachine.getId(), is("testid")); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S20, TestStates.S30)); + assertThat(stateMachine.getId()).isEqualTo("testid"); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S20, TestStates.S30); doSendEventAndConsumeAll(stateMachine, TestEvents.E2); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S30)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S30); doSendEventAndConsumeAll(stateMachine, TestEvents.E3); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S4)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S4); stateMachine = persister.restore(stateMachine, "xxx1"); - assertThat(stateMachine.getId(), is("testid")); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S20, TestStates.S30)); + assertThat(stateMachine.getId()).isEqualTo("testid"); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S20, TestStates.S30); doSendEventAndConsumeAll(stateMachine, TestEvents.E2); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S30)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S30); doSendEventAndConsumeAll(stateMachine, TestEvents.E3); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S4)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S4); } @Test @@ -187,17 +182,17 @@ public class StateMachinePersistTests4 extends AbstractStateMachineTests { doStartAndAssert(stateMachine); doSendEventAndConsumeAll(stateMachine, TestEvents.E1); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S20, TestStates.S30)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S20, TestStates.S30); doSendEventAndConsumeAll(stateMachine, TestEvents.E2); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S30)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S30); persister.persist(stateMachine, "xxx1"); stateMachine = persister.restore(stateMachine, "xxx1"); - assertThat(stateMachine.getId(), is("testid")); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S30)); + assertThat(stateMachine.getId()).isEqualTo("testid"); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S30); doSendEventAndConsumeAll(stateMachine, TestEvents.E3); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S4)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S4); } @Test @@ -214,26 +209,26 @@ public class StateMachinePersistTests4 extends AbstractStateMachineTests { doStartAndAssert(stateMachine); doSendEventAndConsumeAll(stateMachine, TestEvents.E1); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S20, TestStates.S30)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S20, TestStates.S30); doSendEventAndConsumeAll(stateMachine, TestEvents.E2); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S30)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S30); persister.persist(stateMachine, "xxx1"); stateMachine = persister.restore(stateMachine, "xxx1"); - assertThat(stateMachine.getId(), is("testid")); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S30)); + assertThat(stateMachine.getId()).isEqualTo("testid"); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S30); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S30)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S30); doSendEventAndConsumeAll(stateMachine, TestEvents.E3); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S4)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S4); stateMachine = persister.restore(stateMachine, "xxx1"); - assertThat(stateMachine.getId(), is("testid")); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S30)); + assertThat(stateMachine.getId()).isEqualTo("testid"); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S30); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S30)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S30); doSendEventAndConsumeAll(stateMachine, TestEvents.E3); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S4)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S4); } @Test @@ -250,18 +245,18 @@ public class StateMachinePersistTests4 extends AbstractStateMachineTests { doStartAndAssert(stateMachine); doSendEventAndConsumeAll(stateMachine, TestEvents.E1); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S20, TestStates.S30)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S20, TestStates.S30); persister.persist(stateMachine, "xxx1"); stateMachine = stateMachineFactory.getStateMachine(); stateMachine = persister.restore(stateMachine, "xxx1"); - assertThat(stateMachine.getId(), is("testid")); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S20, TestStates.S30)); + assertThat(stateMachine.getId()).isEqualTo("testid"); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S20, TestStates.S30); doSendEventAndConsumeAll(stateMachine, TestEvents.E2); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S30)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S30); doSendEventAndConsumeAll(stateMachine, TestEvents.E3); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S4)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S4); } @Test @@ -278,27 +273,27 @@ public class StateMachinePersistTests4 extends AbstractStateMachineTests { doStartAndAssert(stateMachine); doSendEventAndConsumeAll(stateMachine, TestEvents.E1); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S20, TestStates.S30)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S20, TestStates.S30); persister.persist(stateMachine, "xxx1"); stateMachine = stateMachineFactory.getStateMachine(); stateMachine = persister.restore(stateMachine, "xxx1"); - assertThat(stateMachine.getId(), is("testid")); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S20, TestStates.S30)); + assertThat(stateMachine.getId()).isEqualTo("testid"); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S20, TestStates.S30); doSendEventAndConsumeAll(stateMachine, TestEvents.E2); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S30)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S30); doSendEventAndConsumeAll(stateMachine, TestEvents.E3); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S4)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S4); stateMachine = persister.restore(stateMachine, "xxx1"); - assertThat(stateMachine.getId(), is("testid")); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S20, TestStates.S30)); + assertThat(stateMachine.getId()).isEqualTo("testid"); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S20, TestStates.S30); doSendEventAndConsumeAll(stateMachine, TestEvents.E2); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S30)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S30); doSendEventAndConsumeAll(stateMachine, TestEvents.E3); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S4)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S4); } @Test @@ -315,18 +310,18 @@ public class StateMachinePersistTests4 extends AbstractStateMachineTests { doStartAndAssert(stateMachine); doSendEventAndConsumeAll(stateMachine, TestEvents.E1); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S20, TestStates.S30)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S20, TestStates.S30); doSendEventAndConsumeAll(stateMachine, TestEvents.E2); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S30)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S30); persister.persist(stateMachine, "xxx1"); stateMachine = persister.restore(stateMachine, "xxx1"); - assertThat(stateMachine.getId(), is("testid")); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S30)); + assertThat(stateMachine.getId()).isEqualTo("testid"); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S30); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S30)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S30); doSendEventAndConsumeAll(stateMachine, TestEvents.E3); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S4)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S4); } @Test @@ -343,26 +338,26 @@ public class StateMachinePersistTests4 extends AbstractStateMachineTests { doStartAndAssert(stateMachine); doSendEventAndConsumeAll(stateMachine, TestEvents.E1); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S20, TestStates.S30)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S20, TestStates.S30); doSendEventAndConsumeAll(stateMachine, TestEvents.E2); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S30)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S30); persister.persist(stateMachine, "xxx1"); stateMachine = persister.restore(stateMachine, "xxx1"); - assertThat(stateMachine.getId(), is("testid")); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S30)); + assertThat(stateMachine.getId()).isEqualTo("testid"); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S30); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S30)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S30); doSendEventAndConsumeAll(stateMachine, TestEvents.E3); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S4)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S4); stateMachine = persister.restore(stateMachine, "xxx1"); - assertThat(stateMachine.getId(), is("testid")); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S30)); + assertThat(stateMachine.getId()).isEqualTo("testid"); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S30); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S30)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S30); doSendEventAndConsumeAll(stateMachine, TestEvents.E3); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder(TestStates.S4)); + assertThat(stateMachine.getState().getIds()).containsOnly(TestStates.S4); } @@ -379,32 +374,32 @@ public class StateMachinePersistTests4 extends AbstractStateMachineTests { TestListener listener = new TestListener(); machine.addStateListener(listener); listener.reset(1); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); doStartAndAssert(machine); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); listener.reset(3); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(3)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S20, TestStates.S30)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(3); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S20, TestStates.S30); persister.persist(machine, "xxx1"); machine = persister.restore(machine, "xxx1"); listener.reset(1); doSendEventAndConsumeAll(machine, TestEvents.E2); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S30)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S30); listener.reset(2); doSendEventAndConsumeAll(machine, TestEvents.E3); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(2)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(2); - assertThat(machine.getState().getIds(), contains(TestStates.S4)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S4); // try fresh machine machine = stateMachineFactory.getStateMachine("testid"); @@ -413,16 +408,16 @@ public class StateMachinePersistTests4 extends AbstractStateMachineTests { listener.reset(1); doSendEventAndConsumeAll(machine, TestEvents.E2); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S30)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S30); listener.reset(2); doSendEventAndConsumeAll(machine, TestEvents.E3); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(2)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(2); - assertThat(machine.getState().getIds(), contains(TestStates.S4)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S4); } @Test @@ -438,23 +433,23 @@ public class StateMachinePersistTests4 extends AbstractStateMachineTests { TestListener listener = new TestListener(); machine.addStateListener(listener); listener.reset(1); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); doStartAndAssert(machine); assertPseudoStatesHaveOneListener(machine); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); listener.reset(3); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(3)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S20, TestStates.S30)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(3); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S20, TestStates.S30); listener.reset(1); doSendEventAndConsumeAll(machine, TestEvents.E2); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S30)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S30); persister.persist(machine, "xxx1"); @@ -462,29 +457,29 @@ public class StateMachinePersistTests4 extends AbstractStateMachineTests { assertPseudoStatesHaveOneListener(machine); listener.reset(2); doSendEventAndConsumeAll(machine, TestEvents.E3); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(2)); - assertThat(machine.getState().getIds(), contains(TestStates.S4)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(2); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S4); machine = persister.restore(machine, "xxx1"); assertPseudoStatesHaveOneListener(machine); listener.reset(2); doSendEventAndConsumeAll(machine, TestEvents.E3); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(2)); - assertThat(machine.getState().getIds(), contains(TestStates.S4)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(2); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S4); // try fresh machine machine = stateMachineFactory.getStateMachine("testid"); machine = persister.restore(machine, "xxx1"); machine.addStateListener(listener); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S30)); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S30); listener.reset(2); doSendEventAndConsumeAll(machine, TestEvents.E3); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(2)); - assertThat(machine.getState().getIds(), contains(TestStates.S4)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(2); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S4); assertPseudoStatesHaveOneListener(machine); } @@ -496,7 +491,7 @@ public class StateMachinePersistTests4 extends AbstractStateMachineTests { CompositePseudoStateListener pseudoStateListener = TestUtils.readField("pseudoStateListener", ps); OrderedComposite listeners = TestUtils.readField("listeners", pseudoStateListener); List list = TestUtils.readField("list", listeners); - assertThat(list.size(), is(1)); + assertThat(list).hasSize(1); } } } diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/processor/AnnotatedMethodTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/processor/AnnotatedMethodTests.java index a2608321..26313f75 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/processor/AnnotatedMethodTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/processor/AnnotatedMethodTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2018 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,9 +15,7 @@ */ package org.springframework.statemachine.processor; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.is; +import static org.assertj.core.api.Assertions.assertThat; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; @@ -59,9 +57,9 @@ public class AnnotatedMethodTests extends AbstractStateMachineTests { context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); Bean1 bean1 = context.getBean(Bean1.class); machine.start(); - assertThat(bean1.onMethod0Latch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(bean1.onMethod0Latch.await(2, TimeUnit.SECONDS)).isTrue(); machine.sendEvent(TestEvents.E1); - assertThat(bean1.onMethod1Latch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(bean1.onMethod1Latch.await(2, TimeUnit.SECONDS)).isTrue(); } @Test @@ -75,17 +73,17 @@ public class AnnotatedMethodTests extends AbstractStateMachineTests { machine.start(); machine.sendEvent(TestEvents.E1); machine.sendEvent(TestEvents.E2); - assertThat(bean1.onMethod2Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onMethod4Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onMethod6Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onMethod8Latch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(bean1.onMethod2Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onMethod4Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onMethod6Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onMethod8Latch.await(2, TimeUnit.SECONDS)).isTrue(); machine.sendEvent(TestEvents.E3); - assertThat(bean1.onMethod3Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onMethod5Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onMethod7Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onMethod9Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onMethod10Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onMethod10Count, is(1)); + assertThat(bean1.onMethod3Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onMethod5Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onMethod7Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onMethod9Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onMethod10Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onMethod10Count).isEqualTo(1); } @Test @@ -99,17 +97,17 @@ public class AnnotatedMethodTests extends AbstractStateMachineTests { machine.start(); machine.sendEvent(TestEvents.E1); machine.sendEvent(TestEvents.E2); - assertThat(bean1.onMethod2Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onMethod4Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onMethod6Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onMethod8Latch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(bean1.onMethod2Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onMethod4Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onMethod6Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onMethod8Latch.await(2, TimeUnit.SECONDS)).isTrue(); machine.sendEvent(TestEvents.E3); - assertThat(bean1.onMethod3Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onMethod5Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onMethod7Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onMethod9Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onMethod10Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onMethod10Count, is(1)); + assertThat(bean1.onMethod3Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onMethod5Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onMethod7Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onMethod9Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onMethod10Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onMethod10Count).isEqualTo(1); } @Test @@ -123,17 +121,17 @@ public class AnnotatedMethodTests extends AbstractStateMachineTests { machine.start(); machine.sendEvent(TestEvents.E1); machine.sendEvent(TestEvents.E2); - assertThat(bean1.onMethod2Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onMethod4Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onMethod6Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onMethod8Latch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(bean1.onMethod2Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onMethod4Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onMethod6Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onMethod8Latch.await(2, TimeUnit.SECONDS)).isTrue(); machine.sendEvent(TestEvents.E3); - assertThat(bean1.onMethod3Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onMethod5Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onMethod7Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onMethod9Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onMethod10Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onMethod10Count, is(1)); + assertThat(bean1.onMethod3Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onMethod5Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onMethod7Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onMethod9Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onMethod10Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onMethod10Count).isEqualTo(1); } @Test @@ -147,11 +145,11 @@ public class AnnotatedMethodTests extends AbstractStateMachineTests { machine.start(); machine.sendEvent(TestEvents.E1); machine.sendEvent(TestEvents.E2); - assertThat(bean1.onMethod8Latch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(bean1.onMethod8Latch.await(2, TimeUnit.SECONDS)).isTrue(); machine.sendEvent(TestEvents.E3); - assertThat(bean1.onMethod9Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onMethod10Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean1.onMethod10Count, is(1)); + assertThat(bean1.onMethod9Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onMethod10Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean1.onMethod10Count).isEqualTo(1); } @Test @@ -163,7 +161,7 @@ public class AnnotatedMethodTests extends AbstractStateMachineTests { context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); Bean2 bean2 = context.getBean(Bean2.class); machine.start(); - assertThat(bean2.onMethod0Latch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(bean2.onMethod0Latch.await(2, TimeUnit.SECONDS)).isTrue(); } @Test @@ -175,14 +173,14 @@ public class AnnotatedMethodTests extends AbstractStateMachineTests { context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); Bean3 bean3 = context.getBean(Bean3.class); machine.start(); - assertThat(bean3.onMethod0Latch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(bean3.onMethod0Latch.await(2, TimeUnit.SECONDS)).isTrue(); machine.sendEvent(TestEvents.E1); - assertThat(bean3.onMethod1Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(bean3.onMethod11Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S2)); + assertThat(bean3.onMethod1Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(bean3.onMethod11Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S2); machine.sendEvent(TestEvents.E2); - assertThat(bean3.onMethod2Latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S3)); + assertThat(bean3.onMethod2Latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S3); } @Test @@ -198,9 +196,9 @@ public class AnnotatedMethodTests extends AbstractStateMachineTests { machine.start(); // S1 is transitioned during lifecycle start which happens // before all beans are started, so onMethod0Latch is not called - assertThat(bean1.onMethod0Latch.await(2, TimeUnit.SECONDS), is(false)); + assertThat(bean1.onMethod0Latch.await(2, TimeUnit.SECONDS)).isFalse(); machine.sendEvent(TestEvents.E1); - assertThat(bean1.onMethod1Latch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(bean1.onMethod1Latch.await(2, TimeUnit.SECONDS)).isTrue(); } @WithStateMachine diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/processor/MethodParameterTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/processor/MethodParameterTests.java index 653a0658..84115e30 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/processor/MethodParameterTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/processor/MethodParameterTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,8 +15,7 @@ */ package org.springframework.statemachine.processor; -import static org.hamcrest.CoreMatchers.notNullValue; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.Mockito.mock; import java.lang.reflect.Method; @@ -76,12 +75,12 @@ public class MethodParameterTests { @OnTransition public void onTransition(@EventHeaders Map headers, ExtendedState extendedState, StateMachine stateMachine, Message message, Exception e, StateContext stateContext) { - assertThat(headers, notNullValue()); - assertThat(extendedState, notNullValue()); - assertThat(stateMachine, notNullValue()); - assertThat(message, notNullValue()); - assertThat(e, notNullValue()); - assertThat(stateContext, notNullValue()); + assertThat(headers).isNotNull(); + assertThat(extendedState).isNotNull(); + assertThat(stateMachine).isNotNull(); + assertThat(message).isNotNull(); + assertThat(e).isNotNull(); + assertThat(stateContext).isNotNull(); } } diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/processor/StateMachineAnnotationPostProcessorTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/processor/StateMachineAnnotationPostProcessorTests.java index 31849ed7..56e4ebf5 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/processor/StateMachineAnnotationPostProcessorTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/processor/StateMachineAnnotationPostProcessorTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2018 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,8 +15,7 @@ */ package org.springframework.statemachine.processor; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import java.util.EnumSet; import java.util.concurrent.CountDownLatch; @@ -46,14 +45,14 @@ public class StateMachineAnnotationPostProcessorTests extends AbstractStateMachi public void testWithNormalAnnotation() { context.register(Config1.class, BeanConfig1.class); context.refresh(); - assertThat(context.getBeansOfType(StateMachineHandler.class).size(), is(2)); + assertThat(context.getBeansOfType(StateMachineHandler.class)).hasSize(2); } @Test public void testWithNormalAnnotationWithTransactional() { context.register(Config1.class, BeanConfig2.class); context.refresh(); - assertThat(context.getBeansOfType(StateMachineHandler.class).size(), is(1)); + assertThat(context.getBeansOfType(StateMachineHandler.class)).hasSize(1); } @WithStateMachine diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/security/AbstractSecurityTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/security/AbstractSecurityTests.java index 29479b25..718631f5 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/security/AbstractSecurityTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/security/AbstractSecurityTests.java @@ -15,9 +15,7 @@ */ package org.springframework.statemachine.security; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.is; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeResultAsDenied; @@ -38,39 +36,39 @@ import org.springframework.statemachine.state.State; public abstract class AbstractSecurityTests extends AbstractStateMachineTests { protected static void assertTransitionAllowed(StateMachine machine, TestListener listener) throws Exception { - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(States.S0); listener.reset(1); doSendEventAndConsumeAll(machine, Events.A); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(States.S1); } protected static void assertTransitionDenied(StateMachine machine, TestListener listener) throws Exception { - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(States.S0); listener.reset(1); doSendEventAndConsumeAll(machine, Events.A); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(false)); - assertThat(listener.stateChangedCount, is(0)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isFalse(); + assertThat(listener.stateChangedCount).isZero(); + assertThat(machine.getState().getIds()).containsOnly(States.S0); } protected static void assertTransitionDeniedResultAsDenied(StateMachine machine, TestListener listener) throws Exception { - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(States.S0); listener.reset(1); doSendEventAndConsumeResultAsDenied(machine, Events.A); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(false)); - assertThat(listener.stateChangedCount, is(0)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isFalse(); + assertThat(listener.stateChangedCount).isZero(); + assertThat(machine.getState().getIds()).containsOnly(States.S0); } protected static enum States { diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/security/ActionSecurityTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/security/ActionSecurityTests.java index dc1dac79..ec43181e 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/security/ActionSecurityTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/security/ActionSecurityTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,9 +15,7 @@ */ package org.springframework.statemachine.security; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.is; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import java.util.concurrent.CountDownLatch; @@ -77,31 +75,31 @@ public class ActionSecurityTests extends AbstractStateMachineTests { @Test @WithMockUser(roles = { "FOO" }) public void testActionExecutionDenied() throws Exception { - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(States.S0); listener.reset(1); doSendEventAndConsumeAll(machine, Events.A); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S1)); - assertThat(action1.getCount(), is(0)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(States.S1); + assertThat(action1.getCount()).isZero(); } @Test @WithMockUser public void testActionExecutionAllowed() throws Exception { - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(States.S0); listener.reset(1); doSendEventAndConsumeAll(machine, Events.A); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S1)); - assertThat(action1.getCount(), is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(States.S1); + assertThat(action1.getCount()).isEqualTo(1); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/security/SecurityConfigTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/security/SecurityConfigTests.java index 40fa4b2b..463575d3 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/security/SecurityConfigTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/security/SecurityConfigTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,12 +15,7 @@ */ package org.springframework.statemachine.security; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.notNullValue; -import static org.hamcrest.Matchers.nullValue; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.instanceOf; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.assertj.core.api.Assertions.assertThat; import java.util.Collection; import java.util.List; @@ -64,136 +59,136 @@ public class SecurityConfigTests extends AbstractStateMachineTests { public void testSecurityEnabledWithTrue() throws Exception { context.register(Config1.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); StateMachineInterceptorList ilist = TestUtils.readField("interceptors", machine); List> interceptors = TestUtils.readField("interceptors", ilist); - assertThat(interceptors, notNullValue()); - assertThat(interceptors.size(), is(1)); - assertThat(interceptors.get(0), instanceOf(StateMachineSecurityInterceptor.class)); + assertThat(interceptors).isNotNull(); + assertThat(interceptors).hasSize(1); + assertThat(interceptors.get(0)).isInstanceOf(StateMachineSecurityInterceptor.class); Object adm = TestUtils.readField("transitionAccessDecisionManager", interceptors.get(0)); - assertThat(adm, nullValue()); + assertThat(adm).isNull(); } @Test public void testSecurityDisabledWithFalse() throws Exception { context.register(Config2.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); StateMachineInterceptorList ilist = TestUtils.readField("interceptors", machine); List> interceptors = TestUtils.readField("interceptors", ilist); - assertThat(interceptors, notNullValue()); - assertThat(interceptors.size(), is(0)); + assertThat(interceptors).isNotNull(); + assertThat(interceptors).isEmpty(); } @Test public void testSecurityEnabledWithJustWith() throws Exception { context.register(Config3.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); StateMachineInterceptorList ilist = TestUtils.readField("interceptors", machine); List> interceptors = TestUtils.readField("interceptors", ilist); - assertThat(interceptors.size(), is(1)); - assertThat(interceptors.get(0), instanceOf(StateMachineSecurityInterceptor.class)); + assertThat(interceptors).hasSize(1); + assertThat(interceptors.get(0)).isInstanceOf(StateMachineSecurityInterceptor.class); Object adm = TestUtils.readField("transitionAccessDecisionManager", interceptors.get(0)); - assertThat(adm, nullValue()); + assertThat(adm).isNull(); } @Test public void testSecurityDisabledNoSecurityConfigurer() throws Exception { context.register(Config4.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); StateMachineInterceptorList ilist = TestUtils.readField("interceptors", machine); List> interceptors = TestUtils.readField("interceptors", ilist); - assertThat(interceptors, notNullValue()); - assertThat(interceptors.size(), is(0)); + assertThat(interceptors).isNotNull(); + assertThat(interceptors).isEmpty(); } @Test public void testCustomAccessDecisionManager() throws Exception { context.register(Config5.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); StateMachineInterceptorList ilist = TestUtils.readField("interceptors", machine); List> interceptors = TestUtils.readField("interceptors", ilist); - assertThat(interceptors, notNullValue()); - assertThat(interceptors.size(), is(1)); - assertThat(interceptors.get(0), instanceOf(StateMachineSecurityInterceptor.class)); + assertThat(interceptors).isNotNull(); + assertThat(interceptors).hasSize(1); + assertThat(interceptors.get(0)).isInstanceOf(StateMachineSecurityInterceptor.class); Object adm = TestUtils.readField("transitionAccessDecisionManager", interceptors.get(0)); - assertThat(adm, notNullValue()); - assertThat(adm, instanceOf(MockAccessDecisionManager.class)); + assertThat(adm).isNotNull(); + assertThat(adm).isInstanceOf(MockAccessDecisionManager.class); } @Test public void testTransitionExplicit() throws Exception { context.register(Config6.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); Transition transition = machine.getTransitions().iterator().next(); - assertThat(transition.getSecurityRule(), notNullValue()); + assertThat(transition.getSecurityRule()).isNotNull(); } @Test public void testTransitionGlobal() throws Exception { context.register(Config8.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); Transition transition = machine.getTransitions().iterator().next(); - assertThat(transition.getSecurityRule(), notNullValue()); + assertThat(transition.getSecurityRule()).isNotNull(); } @Test public void testEventRule() throws Exception { context.register(Config7.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); StateMachineInterceptorList ilist = TestUtils.readField("interceptors", machine); List> interceptors = TestUtils.readField("interceptors", ilist); - assertThat(interceptors, notNullValue()); - assertThat(interceptors.size(), is(1)); - assertThat(interceptors.get(0), instanceOf(StateMachineSecurityInterceptor.class)); + assertThat(interceptors).isNotNull(); + assertThat(interceptors).hasSize(1); + assertThat(interceptors.get(0)).isInstanceOf(StateMachineSecurityInterceptor.class); Object adm = TestUtils.readField("eventSecurityRule", interceptors.get(0)); - assertThat(adm, notNullValue()); + assertThat(adm).isNotNull(); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/security/SecurityRuleTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/security/SecurityRuleTests.java index fa342667..06c7d79a 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/security/SecurityRuleTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/security/SecurityRuleTests.java @@ -15,9 +15,7 @@ */ package org.springframework.statemachine.security; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.assertj.core.api.Assertions.assertThat; import java.util.ArrayList; import java.util.Collection; @@ -32,21 +30,20 @@ public class SecurityRuleTests { Collection attributes = new ArrayList(); attributes.add("ROLE_1"); attributes.add("ROLE_2"); - assertEquals("ROLE_1, ROLE_2", SecurityRule.securityAttributesToCommaDelimitedList(attributes)); + assertThat("ROLE_1, ROLE_2").isEqualTo(SecurityRule.securityAttributesToCommaDelimitedList(attributes)); } @Test public void testConvertAttributesFromCommaSeparatedString() { Collection attributes = SecurityRule.commaDelimitedListToSecurityAttributes(" ,,ROLE_1, ROLE_2"); - assertEquals(2, attributes.size()); - assertTrue(attributes.contains("ROLE_1")); - assertTrue(attributes.contains("ROLE_2")); + assertThat(attributes.size()).isEqualTo(2); + assertThat(attributes.contains("ROLE_1")).isTrue(); + assertThat(attributes.contains("ROLE_2")).isTrue(); } @Test public void testDefaultComparisonType() { SecurityRule rule = new SecurityRule(); - assertTrue(rule.getComparisonType() == SecurityRule.ComparisonType.ANY); + assertThat(rule.getComparisonType() == SecurityRule.ComparisonType.ANY).isTrue(); } - } diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/security/TransitionSecurityExpressionRootTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/security/TransitionSecurityExpressionRootTests.java index 62f075a1..d7f54e7e 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/security/TransitionSecurityExpressionRootTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/security/TransitionSecurityExpressionRootTests.java @@ -15,8 +15,7 @@ */ package org.springframework.statemachine.security; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.mock; @@ -67,28 +66,28 @@ public class TransitionSecurityExpressionRootTests { when(transition.getTarget()).thenReturn(target); Expression e1 = parser.parseExpression("hasSource('S1')"); - assertTrue(ExpressionUtils.evaluateAsBoolean(e1, ctx)); + assertThat(ExpressionUtils.evaluateAsBoolean(e1, ctx)).isTrue(); Expression e2 = parser.parseExpression("hasTarget('S2')"); - assertTrue(ExpressionUtils.evaluateAsBoolean(e2, ctx)); + assertThat(ExpressionUtils.evaluateAsBoolean(e2, ctx)).isTrue(); } @Test public void canCallMethodsOnVariables() throws Exception { ctx.setVariable("var", "somestring"); Expression e = parser.parseExpression("#var.length() == 10"); - assertTrue(ExpressionUtils.evaluateAsBoolean(e, ctx)); + assertThat(ExpressionUtils.evaluateAsBoolean(e, ctx)).isTrue(); } @Test public void isAnonymousReturnsTrueIfTrustResolverReportsAnonymous() { when(trustResolver.isAnonymous(user)).thenReturn(true); - assertTrue(root.isAnonymous()); + assertThat(root.isAnonymous()).isTrue(); } @Test public void isAnonymousReturnsFalseIfTrustResolverReportsNonAnonymous() { when(trustResolver.isAnonymous(user)).thenReturn(false); - assertFalse(root.isAnonymous()); + assertThat(root.isAnonymous()).isFalse(); } @Test @@ -98,7 +97,7 @@ public class TransitionSecurityExpressionRootTests { ctx.setVariable("domainObject", dummyDomainObject); root.setPermissionEvaluator(pe); when(pe.hasPermission(user, dummyDomainObject, "ignored")).thenReturn(false); - assertFalse(root.hasPermission(dummyDomainObject, "ignored")); + assertThat(root.hasPermission(dummyDomainObject, "ignored")).isFalse(); } @Test @@ -108,7 +107,7 @@ public class TransitionSecurityExpressionRootTests { ctx.setVariable("domainObject", dummyDomainObject); root.setPermissionEvaluator(pe); when(pe.hasPermission(user, dummyDomainObject, "ignored")).thenReturn(true); - assertTrue(root.hasPermission(dummyDomainObject, "ignored")); + assertThat(root.hasPermission(dummyDomainObject, "ignored")).isTrue(); } @Test @@ -121,13 +120,13 @@ public class TransitionSecurityExpressionRootTests { Expression e = parser.parseExpression("hasPermission(#domainObject, 0xA)"); // evaluator returns true - assertTrue(ExpressionUtils.evaluateAsBoolean(e, ctx)); + assertThat(ExpressionUtils.evaluateAsBoolean(e, ctx)).isTrue(); e = parser.parseExpression("hasPermission(#domainObject, 10)"); // evaluator returns true - assertTrue(ExpressionUtils.evaluateAsBoolean(e, ctx)); + assertThat(ExpressionUtils.evaluateAsBoolean(e, ctx)).isTrue(); e = parser.parseExpression("hasPermission(#domainObject, 0xFF)"); // evaluator returns false, make sure return value matches - assertFalse(ExpressionUtils.evaluateAsBoolean(e, ctx)); + assertThat(ExpressionUtils.evaluateAsBoolean(e, ctx)).isFalse(); } } diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/security/TransitionSecurityExpressionTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/security/TransitionSecurityExpressionTests.java index 2f22df51..46c32430 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/security/TransitionSecurityExpressionTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/security/TransitionSecurityExpressionTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,9 +15,7 @@ */ package org.springframework.statemachine.security; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.is; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import java.util.concurrent.CountDownLatch; @@ -67,27 +65,27 @@ public class TransitionSecurityExpressionTests extends AbstractStateMachineTests } private static void assertTransitionAllowed(StateMachine machine, TestListener listener) throws Exception { - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(States.S0); listener.reset(1); doSendEventAndConsumeAll(machine, Events.A); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(States.S1); } private static void assertTransitionDenied(StateMachine machine, TestListener listener) throws Exception { - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(States.S0); listener.reset(1); doSendEventAndConsumeAll(machine, Events.A); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(false)); - assertThat(listener.stateChangedCount, is(0)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isFalse(); + assertThat(listener.stateChangedCount).isZero(); + assertThat(machine.getState().getIds()).containsOnly(States.S0); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/service/DefaultStateMachineServiceTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/service/DefaultStateMachineServiceTests.java index 07c9274d..e7a6eeb3 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/service/DefaultStateMachineServiceTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/service/DefaultStateMachineServiceTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2017-2019 the original author or authors. + * Copyright 2017-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,8 +15,7 @@ */ package org.springframework.statemachine.service; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import java.util.Map; @@ -57,7 +56,7 @@ public class DefaultStateMachineServiceTests extends AbstractStateMachineTests { DefaultStateMachineService service = new DefaultStateMachineService<>(stateMachineFactory); StateMachine machine1 = service.acquireStateMachine("m1", false); - assertThat(((Lifecycle)machine1).isRunning(), is(false)); + assertThat(((Lifecycle)machine1).isRunning()).isFalse(); } @Test @@ -69,7 +68,7 @@ public class DefaultStateMachineServiceTests extends AbstractStateMachineTests { DefaultStateMachineService service = new DefaultStateMachineService<>(stateMachineFactory); StateMachine machine1 = service.acquireStateMachine("m1", true); - assertThat(((Lifecycle)machine1).isRunning(), is(true)); + assertThat(((Lifecycle)machine1).isRunning()).isTrue(); } @Test @@ -81,9 +80,9 @@ public class DefaultStateMachineServiceTests extends AbstractStateMachineTests { DefaultStateMachineService service = new DefaultStateMachineService<>(stateMachineFactory); StateMachine machine1 = service.acquireStateMachine("m1", true); - assertThat(((Lifecycle)machine1).isRunning(), is(true)); + assertThat(((Lifecycle)machine1).isRunning()).isTrue(); service.releaseStateMachine("m1"); - assertThat(((Lifecycle)machine1).isRunning(), is(false)); + assertThat(((Lifecycle)machine1).isRunning()).isFalse(); } @Test @@ -95,9 +94,9 @@ public class DefaultStateMachineServiceTests extends AbstractStateMachineTests { DefaultStateMachineService service = new DefaultStateMachineService<>(stateMachineFactory); StateMachine machine1 = service.acquireStateMachine("m1", true); - assertThat(((Lifecycle)machine1).isRunning(), is(true)); + assertThat(((Lifecycle)machine1).isRunning()).isTrue(); service.releaseStateMachine("m1", false); - assertThat(((Lifecycle)machine1).isRunning(), is(true)); + assertThat(((Lifecycle)machine1).isRunning()).isTrue(); } @Test @@ -110,12 +109,12 @@ public class DefaultStateMachineServiceTests extends AbstractStateMachineTests { DefaultStateMachineService service = new DefaultStateMachineService<>(stateMachineFactory); StateMachine machine1 = service.acquireStateMachine("m1", false); StateMachine machine2 = service.acquireStateMachine("m2", false); - assertThat(((Lifecycle)machine1).isRunning(), is(false)); - assertThat(((Lifecycle)machine2).isRunning(), is(false)); + assertThat(((Lifecycle)machine1).isRunning()).isFalse(); + assertThat(((Lifecycle)machine2).isRunning()).isFalse(); Map machines = TestUtils.readField("machines", service); - assertThat(machines.size(), is(2)); + assertThat(machines).hasSize(2); service.destroy(); - assertThat(machines.size(), is(0)); + assertThat(machines).isEmpty(); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/ChoiceStateTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/ChoiceStateTests.java index 7d0d100b..a5ad5311 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/ChoiceStateTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/ChoiceStateTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,10 +15,7 @@ */ package org.springframework.statemachine.state; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.notNullValue; -import static org.hamcrest.Matchers.is; +import static org.assertj.core.api.Assertions.assertThat; import java.util.ArrayList; import java.util.EnumSet; @@ -58,11 +55,11 @@ public class ChoiceStateTests extends AbstractStateMachineTests { context.refresh(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).setHeader("choice", "s30").build()); - assertThat(machine.getState().getIds(), contains(TestStates.S30)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S30); } @Test @@ -72,11 +69,11 @@ public class ChoiceStateTests extends AbstractStateMachineTests { context.refresh(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).setHeader("choice", "s31").build()); - assertThat(machine.getState().getIds(), contains(TestStates.S31)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S31); } @Test @@ -86,11 +83,11 @@ public class ChoiceStateTests extends AbstractStateMachineTests { context.refresh(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).setHeader("choice", "s32").build()); - assertThat(machine.getState().getIds(), contains(TestStates.S32)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S32); } @Test @@ -100,11 +97,11 @@ public class ChoiceStateTests extends AbstractStateMachineTests { context.refresh(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).build()); - assertThat(machine.getState().getIds(), contains(TestStates.S33)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S33); } @Test @@ -114,11 +111,11 @@ public class ChoiceStateTests extends AbstractStateMachineTests { context.refresh(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).build()); - assertThat(machine.getState().getIds(), contains(TestStates.S33)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S33); } @Test @@ -128,11 +125,11 @@ public class ChoiceStateTests extends AbstractStateMachineTests { context.refresh(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).setHeader("choice", "s2").build()); - assertThat(machine.getState().getIds(), contains(TestStates.S21)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S21); } @Test @@ -142,21 +139,21 @@ public class ChoiceStateTests extends AbstractStateMachineTests { context.refresh(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); TestStateEntryExitListener listener = new TestStateEntryExitListener(); machine.addStateListener(listener); machine.start(); - assertThat(machine.getState().getIds(), contains(TestStates.SI)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.SI); listener.reset(); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).build()); - assertThat(machine.getState().getIds(), contains(TestStates.SI)); - assertThat(listener.exited.size(), is(1)); - assertThat(listener.entered.size(), is(1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.SI); + assertThat(listener.exited).hasSize(1); + assertThat(listener.entered).hasSize(1); listener.reset(); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E2).build()); - assertThat(machine.getState().getIds(), contains(TestStates.S4)); - assertThat(listener.exited.size(), is(1)); - assertThat(listener.entered.size(), is(1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S4); + assertThat(listener.exited).hasSize(1); + assertThat(listener.entered).hasSize(1); } @Test @@ -169,13 +166,13 @@ public class ChoiceStateTests extends AbstractStateMachineTests { LatchAction sIToChoice = context.getBean("sIToChoice", LatchAction.class); LatchAction choiceToS30 = context.getBean("choiceToS30", LatchAction.class); LatchAction choiceToS33 = context.getBean("choiceToS33", LatchAction.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).setHeader("choice", "s30").build()); - assertThat(sIToChoice.latch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(choiceToS30.latch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(choiceToS33.latch.await(1, TimeUnit.SECONDS), is(false)); - assertThat(machine.getState().getIds(), contains(TestStates.S30)); + assertThat(sIToChoice.latch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(choiceToS30.latch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(choiceToS33.latch.await(1, TimeUnit.SECONDS)).isFalse(); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S30); } @Test @@ -188,13 +185,13 @@ public class ChoiceStateTests extends AbstractStateMachineTests { LatchAction sIToChoice = context.getBean("sIToChoice", LatchAction.class); LatchAction choiceToS30 = context.getBean("choiceToS30", LatchAction.class); LatchAction choiceToS33 = context.getBean("choiceToS33", LatchAction.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).build()); - assertThat(sIToChoice.latch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(choiceToS30.latch.await(1, TimeUnit.SECONDS), is(false)); - assertThat(choiceToS33.latch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), contains(TestStates.S33)); + assertThat(sIToChoice.latch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(choiceToS30.latch.await(1, TimeUnit.SECONDS)).isFalse(); + assertThat(choiceToS33.latch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S33); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/CompletionEventTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/CompletionEventTests.java index 200065fb..a0ed58c6 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/CompletionEventTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/CompletionEventTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2019 the original author or authors. + * Copyright 2019-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,9 +16,7 @@ package org.springframework.statemachine.state; import static org.awaitility.Awaitility.await; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.is; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; import static org.springframework.statemachine.TestUtils.resolveMachine; @@ -26,7 +24,6 @@ import static org.springframework.statemachine.TestUtils.resolveMachine; import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; -import org.awaitility.Awaitility; import org.junit.jupiter.api.Test; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.context.annotation.Bean; @@ -57,10 +54,10 @@ public class CompletionEventTests extends AbstractStateMachineTests { doSendEventAndConsumeAll(machine, "E1"); - assertThat(testAction2.latch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(testAction2.count, is(1)); - await().until(() -> machine.getState().getIds(), containsInAnyOrder("S3")); - assertThat(machine.getState().getId(), is("S3")); + assertThat(testAction2.latch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(testAction2.count).isEqualTo(1); + await().untilAsserted(() -> assertThat(machine.getState().getIds()).containsExactly("S3")); + assertThat(machine.getState().getId()).isEqualTo("S3"); } @Test @@ -70,10 +67,10 @@ public class CompletionEventTests extends AbstractStateMachineTests { StateMachine machine = resolveMachine(context); doStartAndAssert(machine); - assertThat(machine.getState().getId(), is("S1")); + assertThat(machine.getState().getId()).isEqualTo("S1"); doSendEventAndConsumeAll(machine, "E1"); - assertThat(machine.getState().getId(), is("S3")); + assertThat(machine.getState().getId()).isEqualTo("S3"); } public void testSubmachineWithStateActionCompletes() throws Exception { @@ -86,10 +83,10 @@ public class CompletionEventTests extends AbstractStateMachineTests { StateMachine machine = resolveMachine(context); doStartAndAssert(machine); - assertThat(machine.getState().getId(), is("S1")); + assertThat(machine.getState().getId()).isEqualTo("S1"); doSendEventAndConsumeAll(machine, "E1"); - assertThat(machine.getState().getId(), is("S3")); + assertThat(machine.getState().getId()).isEqualTo("S3"); } @Test @@ -99,10 +96,10 @@ public class CompletionEventTests extends AbstractStateMachineTests { StateMachine machine = resolveMachine(context); doStartAndAssert(machine); - assertThat(machine.getState().getId(), is("S1")); + assertThat(machine.getState().getId()).isEqualTo("S1"); doSendEventAndConsumeAll(machine, "E1"); - assertThat(machine.getState().getId(), is("S3")); + assertThat(machine.getState().getId()).isEqualTo("S3"); } @Test @@ -112,10 +109,10 @@ public class CompletionEventTests extends AbstractStateMachineTests { StateMachine machine = resolveMachine(context); doStartAndAssert(machine); - assertThat(machine.getState().getId(), is("S1")); + assertThat(machine.getState().getId()).isEqualTo("S1"); doSendEventAndConsumeAll(machine, "E1"); - assertThat(machine.getState().getId(), is("S3")); + assertThat(machine.getState().getId()).isEqualTo("S3"); } @Test @@ -125,15 +122,15 @@ public class CompletionEventTests extends AbstractStateMachineTests { StateMachine machine = resolveMachine(context); doStartAndAssert(machine); - assertThat(machine.getState().getId(), is("S1")); + assertThat(machine.getState().getId()).isEqualTo("S1"); doSendEventAndConsumeAll(machine, "E1"); doSendEventAndConsumeAll(machine, "E2"); // TODO: REACTOR think this change is because we do subcribe // with onComplete so things are not fully changed with sendEvent - Awaitility.await().until(() -> machine.getState().getId(), is("S3")); - // assertThat(machine.getState().getId(), is("S3")); + await().untilAsserted(() -> assertThat(machine.getState().getId()).isEqualTo("S3")); + // assertThat(machine.getState().getId()).isEqualTo("S3"); } @Test @@ -143,15 +140,15 @@ public class CompletionEventTests extends AbstractStateMachineTests { StateMachine machine = resolveMachine(context); doStartAndAssert(machine); - assertThat(machine.getState().getId(), is("S1")); + assertThat(machine.getState().getId()).isEqualTo("S1"); doSendEventAndConsumeAll(machine, "E1"); doSendEventAndConsumeAll(machine, "E3"); // TODO: REACTOR think this change is because we do subcribe // with onComplete so things are not fully changed with sendEvent - Awaitility.await().until(() -> machine.getState().getId(), is("S3")); - // assertThat(machine.getState().getId(), is("S3")); + await().untilAsserted(() -> assertThat(machine.getState().getId()).isEqualTo("S3")); + // assertThat(machine.getState().getId()).isEqualTo("S3"); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/EndStateTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/EndStateTests.java index cead8ccc..b631a969 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/EndStateTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/EndStateTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,12 +15,7 @@ */ package org.springframework.statemachine.state; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.notNullValue; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.assertj.core.api.Assertions.assertThat; import java.util.EnumSet; import java.util.concurrent.TimeUnit; @@ -48,76 +43,76 @@ public class EndStateTests extends AbstractStateMachineTests { public void testEndStateCompletes() { context.register(Config1.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); machine.start(); - assertThat(machine, notNullValue()); - assertThat(machine.isComplete(), is(false)); + assertThat(machine).isNotNull(); + assertThat(machine.isComplete()).isFalse(); machine.sendEvent(TestEvents.E1); - assertThat(machine.isComplete(), is(false)); + assertThat(machine.isComplete()).isFalse(); machine.sendEvent(TestEvents.E2); - assertThat(machine.isComplete(), is(false)); + assertThat(machine.isComplete()).isFalse(); machine.sendEvent(TestEvents.E3); - assertThat(machine.isComplete(), is(false)); + assertThat(machine.isComplete()).isFalse(); machine.sendEvent(TestEvents.E4); - assertThat(machine.isComplete(), is(false)); + assertThat(machine.isComplete()).isFalse(); machine.sendEvent(TestEvents.EF); - assertThat(machine.isComplete(), is(true)); - assertThat(machine.getState().getIds(), contains(TestStates.SF)); + assertThat(machine.isComplete()).isTrue(); + assertThat(machine.getState().getIds()).containsExactly(TestStates.SF); } @Test public void testEndStatesWithRegions() throws InterruptedException { context.register(Config2.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); machine.start(); machine.sendEvent(TestEvents.E1); - assertThat(machine.getState().getIds(), contains(TestStates3.READY)); + assertThat(machine.getState().getIds()).containsExactly(TestStates3.READY); } @Test public void testEndStatesWithRegionsDefinedInStates() throws InterruptedException { context.register(Config3.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); machine.start(); machine.sendEvent(TestEvents.E1); - assertThat(machine.getState().getIds(), contains(TestStates3.READY)); + assertThat(machine.getState().getIds()).containsExactly(TestStates3.READY); } @Test public void testEndStateCompletesSubmachine() { context.register(Config4.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); machine.start(); - assertThat(machine, notNullValue()); - assertThat(machine.isComplete(), is(false)); - assertThat(machine.getState().getIds(), contains(TestStates.SI)); + assertThat(machine).isNotNull(); + assertThat(machine.isComplete()).isFalse(); + assertThat(machine.getState().getIds()).containsExactly(TestStates.SI); machine.sendEvent(TestEvents.E1); - assertThat(machine.isComplete(), is(false)); - assertThat(machine.getState().getIds(), contains(TestStates.S1, TestStates.S11)); + assertThat(machine.isComplete()).isFalse(); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1, TestStates.S11); machine.sendEvent(TestEvents.E2); - assertThat(machine.isComplete(), is(false)); - assertThat(machine.getState().getIds(), contains(TestStates.S1, TestStates.S12)); + assertThat(machine.isComplete()).isFalse(); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1, TestStates.S12); machine.sendEvent(TestEvents.E3); - assertThat(machine.isComplete(), is(false)); - assertThat(machine.getState().getIds(), contains(TestStates.S1, TestStates.SF)); + assertThat(machine.isComplete()).isFalse(); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1, TestStates.SF); } @Test @@ -136,56 +131,56 @@ public class EndStateTests extends AbstractStateMachineTests { public void testEndStateCompletesMultipleEndStates1() { context.register(Config7.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); machine.start(); - assertThat(machine, notNullValue()); - assertThat(machine.isComplete(), is(false)); + assertThat(machine).isNotNull(); + assertThat(machine.isComplete()).isFalse(); machine.sendEvent(TestEvents.E1); - assertThat(machine.isComplete(), is(true)); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.isComplete()).isTrue(); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); } @Test public void testEndStateCompletesMultipleEndStates2() { context.register(Config7.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); machine.start(); - assertThat(machine, notNullValue()); - assertThat(machine.isComplete(), is(false)); + assertThat(machine).isNotNull(); + assertThat(machine.isComplete()).isFalse(); machine.sendEvent(TestEvents.E2); - assertThat(machine.isComplete(), is(true)); - assertThat(machine.getState().getIds(), contains(TestStates.S2)); + assertThat(machine.isComplete()).isTrue(); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S2); } @Test public void testEndStatesWithRegionsCompletionCompletes() throws InterruptedException { context.register(Config8.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); TestStateMachineListener4 listener = new TestStateMachineListener4(); machine.addStateListener(listener); machine.start(); - assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS)).isTrue(); machine.sendEvent(TestEvents.E1); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), contains(TestStates4.DONE)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsExactly(TestStates4.DONE); } @Test public void testEndStatesWithSubmachineCompletionCompletes() throws InterruptedException { context.register(Config9.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); @@ -193,17 +188,17 @@ public class EndStateTests extends AbstractStateMachineTests { listener.reset(5, 1); machine.addStateListener(listener); machine.start(); - assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS)).isTrue(); machine.sendEvent(TestEvents.E1); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), contains(TestStates4.DONE)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsExactly(TestStates4.DONE); } @Test public void testEndStatesWithRegionsCompletionCompletes2() throws InterruptedException { context.register(Config10.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); @@ -212,24 +207,24 @@ public class EndStateTests extends AbstractStateMachineTests { listener.reset(1, 1); machine.start(); - assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), contains(TestStates4.READY)); + assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsExactly(TestStates4.READY); listener.reset(3, 0); machine.sendEvent(TestEvents.E1); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates4.TASKS, TestStates4.T1, TestStates4.T2)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsOnly(TestStates4.TASKS, TestStates4.T1, TestStates4.T2); listener.reset(1, 0); machine.sendEvent(TestEvents.E2); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates4.TASKS, TestStates4.T1E, TestStates4.T2)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsOnly(TestStates4.TASKS, TestStates4.T1E, TestStates4.T2); listener.reset(2, 0); machine.sendEvent(TestEvents.E3); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), contains(TestStates4.DONE)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsExactly(TestStates4.DONE); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/EnumStateTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/EnumStateTests.java index e91c64e5..8e533246 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/EnumStateTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/EnumStateTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,8 +15,7 @@ */ package org.springframework.statemachine.state; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.is; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; import org.springframework.statemachine.AbstractStateMachineTests.TestEvents; @@ -27,10 +26,10 @@ public class EnumStateTests { @Test public void testSimpleEnumState() { State stateSI = new EnumState(TestStates.SI); - assertThat(stateSI.isSimple(), is(true)); - assertThat(stateSI.isComposite(), is(false)); - assertThat(stateSI.isOrthogonal(), is(false)); - assertThat(stateSI.isSubmachineState(), is(false)); + assertThat(stateSI.isSimple()).isTrue(); + assertThat(stateSI.isComposite()).isFalse(); + assertThat(stateSI.isOrthogonal()).isFalse(); + assertThat(stateSI.isSubmachineState()).isFalse(); } } diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/ExitEntryStateTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/ExitEntryStateTests.java index 9ea19dd0..38f746cf 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/ExitEntryStateTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/ExitEntryStateTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2016-2019 the original author or authors. + * Copyright 2016-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,9 +15,7 @@ */ package org.springframework.statemachine.state; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.notNullValue; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; import static org.springframework.statemachine.TestUtils.resolveMachine; @@ -43,18 +41,18 @@ public class ExitEntryStateTests extends AbstractStateMachineTests { context.register(Config1.class); context.refresh(); StateMachine machine = resolveMachine(context); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); TestStateEntryExitListener listener = new TestStateEntryExitListener(); machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), contains("S1")); + assertThat(machine.getState().getIds()).containsExactly("S1"); listener.reset(); doSendEventAndConsumeAll(machine, "ENTRY1"); - assertThat(machine.getState().getIds(), contains("S2", "S22")); - assertThat(listener.exited, contains("S1")); - assertThat(listener.entered, contains("S2", "S22")); + assertThat(machine.getState().getIds()).containsExactly("S2", "S22"); + assertThat(listener.exited).containsExactly("S1"); + assertThat(listener.entered).containsExactly("S2", "S22"); doSendEventAndConsumeAll(machine, "EXIT1"); - assertThat(machine.getState().getIds(), contains("S4")); + assertThat(machine.getState().getIds()).containsExactly("S4"); } @Test @@ -62,16 +60,16 @@ public class ExitEntryStateTests extends AbstractStateMachineTests { context.register(Config1.class); context.refresh(); StateMachine machine = resolveMachine(context); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); TestStateEntryExitListener listener = new TestStateEntryExitListener(); machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), contains("S1")); + assertThat(machine.getState().getIds()).containsExactly("S1"); listener.reset(); doSendEventAndConsumeAll(machine, "ENTRY3"); - assertThat(machine.getState().getIds(), contains("S2", "S21")); - assertThat(listener.exited, contains("S1")); - assertThat(listener.entered, contains("S2", "S21")); + assertThat(machine.getState().getIds()).containsExactly("S2", "S21"); + assertThat(listener.exited).containsExactly("S1"); + assertThat(listener.entered).containsExactly("S2", "S21"); } @Test @@ -79,19 +77,19 @@ public class ExitEntryStateTests extends AbstractStateMachineTests { context.register(Config2.class); context.refresh(); StateMachine machine = resolveMachine(context); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), contains("S1")); + assertThat(machine.getState().getIds()).containsExactly("S1"); doSendEventAndConsumeAll(machine, "E1"); - assertThat(machine.getState().getIds(), contains("S2", "S22")); + assertThat(machine.getState().getIds()).containsExactly("S2", "S22"); doSendEventAndConsumeAll(machine, "EXIT2"); - assertThat(machine.getState().getIds(), contains("S1")); + assertThat(machine.getState().getIds()).containsExactly("S1"); doSendEventAndConsumeAll(machine, "E2"); - assertThat(machine.getState().getIds(), contains("S3", "S32")); + assertThat(machine.getState().getIds()).containsExactly("S3", "S32"); doSendEventAndConsumeAll(machine, "EXIT3"); - assertThat(machine.getState().getIds(), contains("S1")); + assertThat(machine.getState().getIds()).containsExactly("S1"); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/ForkStateTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/ForkStateTests.java index fa0cc02a..0aab3a78 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/ForkStateTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/ForkStateTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,11 +15,7 @@ */ package org.springframework.statemachine.state; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.notNullValue; -import static org.hamcrest.Matchers.nullValue; +import static org.assertj.core.api.Assertions.assertThat; import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; @@ -59,22 +55,22 @@ public class ForkStateTests extends AbstractStateMachineTests { TestEntryAction s21EntryAction = context.getBean("s21EntryAction", TestEntryAction.class); TestEntryAction s30EntryAction = context.getBean("s30EntryAction", TestEntryAction.class); TestEntryAction s31EntryAction = context.getBean("s31EntryAction", TestEntryAction.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); listener.reset(2); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).setHeader("foo", "bar").build()); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(2)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(2); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S31)); - assertThat(s20EntryAction.stateContexts.size(), is(0)); - assertThat(s21EntryAction.stateContexts.size(), is(1)); - assertThat(s30EntryAction.stateContexts.size(), is(0)); - assertThat(s31EntryAction.stateContexts.size(), is(1)); - assertThat((String)s21EntryAction.stateContexts.get(0).getMessageHeader("foo"), is("bar")); - assertThat((String)s31EntryAction.stateContexts.get(0).getMessageHeader("foo"), is("bar")); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S31); + assertThat(s20EntryAction.stateContexts).isEmpty(); + assertThat(s21EntryAction.stateContexts).hasSize(1); + assertThat(s30EntryAction.stateContexts).isEmpty(); + assertThat(s31EntryAction.stateContexts).hasSize(1); + assertThat((String)s21EntryAction.stateContexts.get(0).getMessageHeader("foo")).isEqualTo("bar"); + assertThat((String)s31EntryAction.stateContexts.get(0).getMessageHeader("foo")).isEqualTo("bar"); } @Test @@ -91,22 +87,22 @@ public class ForkStateTests extends AbstractStateMachineTests { TestEntryAction s21EntryAction = context.getBean("s21EntryAction", TestEntryAction.class); TestEntryAction s30EntryAction = context.getBean("s30EntryAction", TestEntryAction.class); TestEntryAction s31EntryAction = context.getBean("s31EntryAction", TestEntryAction.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); listener.reset(3); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).setHeader("foo", "bar").build()); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(3)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(3); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S20, TestStates.S30)); - assertThat(s20EntryAction.stateContexts.size(), is(1)); - assertThat(s21EntryAction.stateContexts.size(), is(0)); - assertThat(s30EntryAction.stateContexts.size(), is(1)); - assertThat(s31EntryAction.stateContexts.size(), is(0)); - assertThat((String)s20EntryAction.stateContexts.get(0).getMessageHeader("foo"), nullValue()); - assertThat((String)s30EntryAction.stateContexts.get(0).getMessageHeader("foo"), nullValue()); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S20, TestStates.S30); + assertThat(s20EntryAction.stateContexts).hasSize(1); + assertThat(s21EntryAction.stateContexts).isEmpty(); + assertThat(s30EntryAction.stateContexts).hasSize(1); + assertThat(s31EntryAction.stateContexts).isEmpty(); + assertThat((String)s20EntryAction.stateContexts.get(0).getMessageHeader("foo")).isNull(); + assertThat((String)s30EntryAction.stateContexts.get(0).getMessageHeader("foo")).isNull(); } @Test @@ -123,22 +119,22 @@ public class ForkStateTests extends AbstractStateMachineTests { TestEntryAction s21EntryAction = context.getBean("s21EntryAction", TestEntryAction.class); TestEntryAction s30EntryAction = context.getBean("s30EntryAction", TestEntryAction.class); TestEntryAction s31EntryAction = context.getBean("s31EntryAction", TestEntryAction.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); listener.reset(2); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).setHeader("foo", "bar").build()); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(2)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(2); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S20, TestStates.S31)); - assertThat(s20EntryAction.stateContexts.size(), is(1)); - assertThat(s21EntryAction.stateContexts.size(), is(0)); - assertThat(s30EntryAction.stateContexts.size(), is(0)); - assertThat(s31EntryAction.stateContexts.size(), is(1)); - assertThat((String)s20EntryAction.stateContexts.get(0).getMessageHeader("foo"), nullValue()); - assertThat((String)s31EntryAction.stateContexts.get(0).getMessageHeader("foo"), is("bar")); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S20, TestStates.S31); + assertThat(s20EntryAction.stateContexts).hasSize(1); + assertThat(s21EntryAction.stateContexts).isEmpty(); + assertThat(s30EntryAction.stateContexts).isEmpty(); + assertThat(s31EntryAction.stateContexts).hasSize(1); + assertThat((String)s20EntryAction.stateContexts.get(0).getMessageHeader("foo")).isNull(); + assertThat((String)s31EntryAction.stateContexts.get(0).getMessageHeader("foo")).isEqualTo("bar"); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/HistoryStateTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/HistoryStateTests.java index ed42099c..4ffa77fd 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/HistoryStateTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/HistoryStateTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,9 +15,7 @@ */ package org.springframework.statemachine.state; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.notNullValue; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; import org.springframework.context.annotation.AnnotationConfigApplicationContext; @@ -45,14 +43,14 @@ public class HistoryStateTests extends AbstractStateMachineTests { context.refresh(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); machine.sendEvent(TestEvents.E1); machine.sendEvent(TestEvents.E2); machine.sendEvent(TestEvents.E3); machine.sendEvent(TestEvents.E4); - assertThat(machine.getState().getIds(), contains(TestStates.S2, TestStates.S21)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S2, TestStates.S21); } @Test @@ -62,11 +60,11 @@ public class HistoryStateTests extends AbstractStateMachineTests { context.refresh(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); machine.sendEvent(TestEvents.E4); - assertThat(machine.getState().getIds(), contains(TestStates.S2, TestStates.S20)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S2, TestStates.S20); } @Test @@ -76,13 +74,13 @@ public class HistoryStateTests extends AbstractStateMachineTests { context.refresh(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); machine.sendEvent(TestEvents.E1); machine.sendEvent(TestEvents.E2); machine.sendEvent(TestEvents.E3); machine.sendEvent(TestEvents.E4); - assertThat(machine.getState().getIds(), contains(TestStates.S2, TestStates.S21, TestStates.S212)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S2, TestStates.S21, TestStates.S212); } @Test @@ -92,14 +90,14 @@ public class HistoryStateTests extends AbstractStateMachineTests { context.refresh(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); machine.sendEvent(TestEvents.E1); machine.sendEvent(TestEvents.E2); machine.sendEvent(TestEvents.E3); machine.sendEvent(TestEvents.E4); - assertThat(machine.getState().getIds(), contains(TestStates.S2, TestStates.S21, TestStates.S211)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S2, TestStates.S21, TestStates.S211); } @Test @@ -109,11 +107,11 @@ public class HistoryStateTests extends AbstractStateMachineTests { context.refresh(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); machine.sendEvent(TestEvents.EH); - assertThat(machine.getState().getIds(), contains(TestStates.S3, TestStates.S33)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S3, TestStates.S33); } @Test @@ -123,17 +121,17 @@ public class HistoryStateTests extends AbstractStateMachineTests { context.refresh(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); machine.sendEvent(TestEvents.E1); - assertThat(machine.getState().getIds(), contains(TestStates.S3, TestStates.S30)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S3, TestStates.S30); machine.sendEvent(TestEvents.EF); - assertThat(machine.getState().getIds(), contains(TestStates.S3, TestStates.SF)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S3, TestStates.SF); machine.sendEvent(TestEvents.E4); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); machine.sendEvent(TestEvents.EH); - assertThat(machine.getState().getIds(), contains(TestStates.S3, TestStates.S33)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S3, TestStates.S33); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/InitialStateTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/InitialStateTests.java index 9bb37ed4..9313ac8a 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/InitialStateTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/InitialStateTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,10 +15,8 @@ */ package org.springframework.statemachine.state; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; import java.util.EnumSet; @@ -46,20 +44,19 @@ public class InitialStateTests extends AbstractStateMachineTests { public void testInitialStateTransition() throws Exception { context.register(Config1.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); machine.start(); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); } @Test public void testInitialStateMissingFailure() throws Exception { - assertThrows(Exception.class, () -> { + assertThatThrownBy(() -> { context.register(Config2.class); context.refresh(); - }); - + }).isInstanceOf(Exception.class); } @SuppressWarnings({ "unchecked" }) @@ -67,13 +64,13 @@ public class InitialStateTests extends AbstractStateMachineTests { public void testInitialNoNeedAsState() throws Exception { context.register(Config3.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); machine.start(); - assertThat(machine.getState().getIds(), contains(TestStates.SI)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.SI); machine.sendEvent(TestEvents.E1); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/JoinPseudoStateTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/JoinPseudoStateTests.java index 2022e00b..c8702443 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/JoinPseudoStateTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/JoinPseudoStateTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2019 the original author or authors. + * Copyright 2019-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,8 +15,7 @@ */ package org.springframework.statemachine.state; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.is; +import static org.assertj.core.api.Assertions.assertThat; import java.util.ArrayList; import java.util.Arrays; @@ -44,21 +43,21 @@ public class JoinPseudoStateTests { Object obj2 = TestUtils.readField("track", obj1); List>> track = (List>>) obj2; - assertThat(track.size(), is(2)); - assertThat(track.get(0).size(), is(1)); - assertThat(track.get(1).size(), is(1)); + assertThat(track).hasSize(2); + assertThat(track.get(0)).hasSize(1); + assertThat(track.get(1)).hasSize(1); pseudoState.reset(Arrays.asList("S1")); - assertThat(track.size(), is(1)); - assertThat(track.get(0).size(), is(1)); + assertThat(track).hasSize(1); + assertThat(track.get(0)).hasSize(1); pseudoState.reset(Arrays.asList("S1", "S2")); - assertThat(track.size(), is(0)); + assertThat(track).isEmpty(); pseudoState.reset(Collections.emptyList()); - assertThat(track.size(), is(2)); - assertThat(track.get(0).size(), is(1)); - assertThat(track.get(1).size(), is(1)); + assertThat(track).hasSize(2); + assertThat(track.get(0)).hasSize(1); + assertThat(track.get(1)).hasSize(1); } @SuppressWarnings("unchecked") @@ -79,20 +78,20 @@ public class JoinPseudoStateTests { Object obj2 = TestUtils.readField("track", obj1); List>> track = (List>>) obj2; - assertThat(track.size(), is(2)); - assertThat(track.get(0).size(), is(2)); - assertThat(track.get(1).size(), is(2)); + assertThat(track).hasSize(2); + assertThat(track.get(0)).hasSize(2); + assertThat(track.get(1)).hasSize(2); pseudoState.reset(Arrays.asList("S11")); - assertThat(track.size(), is(1)); - assertThat(track.get(0).size(), is(2)); + assertThat(track).hasSize(1); + assertThat(track.get(0)).hasSize(2); pseudoState.reset(Arrays.asList("S11", "S21")); - assertThat(track.size(), is(0)); + assertThat(track).isEmpty(); pseudoState.reset(Collections.emptyList()); - assertThat(track.size(), is(2)); - assertThat(track.get(0).size(), is(2)); - assertThat(track.get(1).size(), is(2)); + assertThat(track).hasSize(2); + assertThat(track.get(0)).hasSize(2); + assertThat(track.get(1)).hasSize(2); } } diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/JoinStateTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/JoinStateTests.java index 036e9614..59d6f833 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/JoinStateTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/JoinStateTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,11 +15,7 @@ */ package org.springframework.statemachine.state; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.notNullValue; +import static org.assertj.core.api.Assertions.assertThat; import java.util.ArrayList; import java.util.List; @@ -60,27 +56,27 @@ public class JoinStateTests extends AbstractStateMachineTests { TestListener listener = new TestListener(); machine.addStateListener(listener); listener.reset(1); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); listener.reset(3); machine.sendEvent(TestEvents.E1); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(3)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(3); listener.reset(1); machine.sendEvent(TestEvents.E2); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); listener.reset(2); machine.sendEvent(TestEvents.E3); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(2)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(2); - assertThat(machine.getState().getIds(), contains(TestStates.S4)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S4); } @Test @@ -92,37 +88,37 @@ public class JoinStateTests extends AbstractStateMachineTests { context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); TestListener listener = new TestListener(); machine.addStateListener(listener); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); machine.sendEvent(TestEvents.E1); machine.sendEvent(TestEvents.E2); machine.sendEvent(TestEvents.E3); - assertThat(machine.getState().getIds(), contains(TestStates.S4)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S4); listener.reset(1); machine.sendEvent(TestEvents.E4); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), contains(TestStates.SI)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsExactly(TestStates.SI); listener.reset(3); machine.sendEvent(TestEvents.E1); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(3)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S20, TestStates.S30)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(3); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S20, TestStates.S30); listener.reset(1); machine.sendEvent(TestEvents.E2); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); listener.reset(2); machine.sendEvent(TestEvents.E3); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(2)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(2); - assertThat(machine.getState().getIds(), contains(TestStates.S4)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S4); } @Test @@ -135,27 +131,27 @@ public class JoinStateTests extends AbstractStateMachineTests { TestListener listener = new TestListener(); machine.addStateListener(listener); listener.reset(1); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); listener.reset(3); machine.sendEvent(TestEvents.E1); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(3)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(3); listener.reset(1); machine.sendEvent(TestEvents.E2); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); listener.reset(2); machine.sendEvent(TestEvents.E3); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(2)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(2); - assertThat(machine.getState().getIds(), contains(TestStates.S4)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S4); } @Test @@ -167,36 +163,36 @@ public class JoinStateTests extends AbstractStateMachineTests { context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); TestListener listener = new TestListener(); machine.addStateListener(listener); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); machine.sendEvent(TestEvents.E1); machine.sendEvent(TestEvents.E2); machine.sendEvent(TestEvents.E3); - assertThat(machine.getState().getIds(), contains(TestStates.S4)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S4); listener.reset(1); machine.sendEvent(TestEvents.E4); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), contains(TestStates.SI)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsExactly(TestStates.SI); listener.reset(3); machine.sendEvent(TestEvents.E1); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(3)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(3); listener.reset(1); machine.sendEvent(TestEvents.E2); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); listener.reset(2); machine.sendEvent(TestEvents.E3); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(2)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(2); - assertThat(machine.getState().getIds(), contains(TestStates.S4)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S4); } @Test @@ -209,27 +205,27 @@ public class JoinStateTests extends AbstractStateMachineTests { TestListener listener = new TestListener(); machine.addStateListener(listener); listener.reset(1); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); listener.reset(3); machine.sendEvent(TestEvents.E1); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(3)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(3); listener.reset(1); machine.sendEvent(TestEvents.E2); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); listener.reset(2); machine.sendEvent(TestEvents.E3); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(2)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(2); - assertThat(machine.getState().getIds(), contains(TestStates.S4)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S4); } @Test @@ -242,28 +238,28 @@ public class JoinStateTests extends AbstractStateMachineTests { TestListener listener = new TestListener(); machine.addStateListener(listener); listener.reset(1); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); machine.getExtendedState().getVariables().put("foo", "bar"); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); listener.reset(3); machine.sendEvent(TestEvents.E1); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(3)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(3); listener.reset(1); machine.sendEvent(TestEvents.E2); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); listener.reset(2); machine.sendEvent(TestEvents.E3); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(2)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(2); - assertThat(machine.getState().getIds(), contains(TestStates.SF)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.SF); } @Test @@ -289,28 +285,28 @@ public class JoinStateTests extends AbstractStateMachineTests { }); listener.reset(1); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); listener.reset(3); machine.sendEvent(TestEvents.E1); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(3)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(3); listener.reset(1); machine.sendEvent(TestEvents.E2); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); listener.reset(2); machine.sendEvent(TestEvents.E3); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(2)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(2); - assertThat(machine.getState().getIds(), contains(TestStates.S4)); - assertThat("Interceptor postStateChange has null transition", nullCheck.get(), is(false)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S4); + assertThat(nullCheck.get()).withFailMessage("Interceptor postStateChange has null transition").isFalse(); } @Test @@ -323,27 +319,27 @@ public class JoinStateTests extends AbstractStateMachineTests { TestListener listener = new TestListener(); machine.addStateListener(listener); listener.reset(1); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); listener.reset(3); machine.sendEvent(TestEvents.E1); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(3)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(3); listener.reset(1); machine.sendEvent(TestEvents.E2); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); listener.reset(2); machine.sendEvent(TestEvents.E3); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(2)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(2); - assertThat(machine.getState().getIds(), contains(TestStates.S4)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S4); } @Test @@ -356,27 +352,27 @@ public class JoinStateTests extends AbstractStateMachineTests { TestListener listener = new TestListener(); machine.addStateListener(listener); listener.reset(1); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); listener.reset(3); machine.sendEvent(TestEvents.E1); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(3)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(3); listener.reset(1); machine.sendEvent(TestEvents.E5); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); listener.reset(2); machine.sendEvent(TestEvents.E3); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(2)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(2); - assertThat(machine.getState().getIds(), contains(TestStates.S4)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S4); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/JunctionStateTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/JunctionStateTests.java index 98df2eb7..d061a583 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/JunctionStateTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/JunctionStateTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2016-2019 the original author or authors. + * Copyright 2016-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,10 +15,7 @@ */ package org.springframework.statemachine.state; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.notNullValue; +import static org.assertj.core.api.Assertions.assertThat; import java.util.EnumSet; import java.util.concurrent.CountDownLatch; @@ -55,11 +52,11 @@ public class JunctionStateTests extends AbstractStateMachineTests { context.refresh(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).setHeader("junction", "s30").build()); - assertThat(machine.getState().getIds(), contains(TestStates.S30)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S30); } @Test @@ -69,11 +66,11 @@ public class JunctionStateTests extends AbstractStateMachineTests { context.refresh(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).setHeader("junction", "s31").build()); - assertThat(machine.getState().getIds(), contains(TestStates.S31)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S31); } @Test @@ -83,11 +80,11 @@ public class JunctionStateTests extends AbstractStateMachineTests { context.refresh(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).setHeader("junction", "s32").build()); - assertThat(machine.getState().getIds(), contains(TestStates.S32)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S32); } @Test @@ -97,11 +94,11 @@ public class JunctionStateTests extends AbstractStateMachineTests { context.refresh(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).build()); - assertThat(machine.getState().getIds(), contains(TestStates.S33)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S33); } @Test @@ -111,11 +108,11 @@ public class JunctionStateTests extends AbstractStateMachineTests { context.refresh(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).build()); - assertThat(machine.getState().getIds(), contains(TestStates.S33)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S33); } @Test @@ -125,11 +122,11 @@ public class JunctionStateTests extends AbstractStateMachineTests { context.refresh(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).setHeader("junction", "s2").build()); - assertThat(machine.getState().getIds(), contains(TestStates.S21)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S21); } @Test @@ -142,13 +139,13 @@ public class JunctionStateTests extends AbstractStateMachineTests { LatchAction sIToJunction = context.getBean("sIToJunction", LatchAction.class); LatchAction junctionToS30 = context.getBean("junctionToS30", LatchAction.class); LatchAction junctionToS33 = context.getBean("junctionToS33", LatchAction.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).setHeader("junction", "s30").build()); - assertThat(sIToJunction.latch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(junctionToS30.latch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(junctionToS33.latch.await(1, TimeUnit.SECONDS), is(false)); - assertThat(machine.getState().getIds(), contains(TestStates.S30)); + assertThat(sIToJunction.latch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(junctionToS30.latch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(junctionToS33.latch.await(1, TimeUnit.SECONDS)).isFalse(); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S30); } @Test @@ -161,13 +158,13 @@ public class JunctionStateTests extends AbstractStateMachineTests { LatchAction sIToJunction = context.getBean("sIToJunction", LatchAction.class); LatchAction junctionToS30 = context.getBean("junctionToS30", LatchAction.class); LatchAction junctionToS33 = context.getBean("junctionToS33", LatchAction.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).build()); - assertThat(sIToJunction.latch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(junctionToS30.latch.await(1, TimeUnit.SECONDS), is(false)); - assertThat(junctionToS33.latch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), contains(TestStates.S33)); + assertThat(sIToJunction.latch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(junctionToS30.latch.await(1, TimeUnit.SECONDS)).isFalse(); + assertThat(junctionToS33.latch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S33); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/RegionStateTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/RegionStateTests.java index b821ba8b..55290c54 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/RegionStateTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/RegionStateTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,9 +15,7 @@ */ package org.springframework.statemachine.state; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.is; +import static org.assertj.core.api.Assertions.assertThat; import java.util.ArrayList; import java.util.Collection; @@ -79,12 +77,12 @@ public class RegionStateTests extends AbstractStateMachineTests { regions.add(machine); RegionState state = new RegionState(TestStates.S11, regions); - assertThat(state.isSimple(), is(false)); - assertThat(state.isComposite(), is(true)); - assertThat(state.isOrthogonal(), is(false)); - assertThat(state.isSubmachineState(), is(false)); + assertThat(state.isSimple()).isFalse(); + assertThat(state.isComposite()).isTrue(); + assertThat(state.isOrthogonal()).isFalse(); + assertThat(state.isSubmachineState()).isFalse(); - assertThat(state.getIds(), containsInAnyOrder(TestStates.SI, TestStates.S11)); + assertThat(state.getIds()).containsOnly(TestStates.SI, TestStates.S11); diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/StateActionTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/StateActionTests.java index 2c476043..9a8442da 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/StateActionTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/StateActionTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,10 +15,7 @@ */ package org.springframework.statemachine.state; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.notNullValue; +import static org.assertj.core.api.Assertions.assertThat; import java.util.Arrays; import java.util.Collection; @@ -53,13 +50,13 @@ public class StateActionTests extends AbstractStateMachineTests { ctx.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); TestExitAction testExitAction = ctx.getBean("testExitAction", TestExitAction.class); TestEntryAction testEntryAction = ctx.getBean("testEntryAction", TestEntryAction.class); - assertThat(testExitAction, notNullValue()); - assertThat(testEntryAction, notNullValue()); + assertThat(testExitAction).isNotNull(); + assertThat(testEntryAction).isNotNull(); machine.start(); machine.sendEvent(TestEvents.E1); - assertThat(testExitAction.onExecuteLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(testEntryAction.onExecuteLatch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(testExitAction.onExecuteLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(testEntryAction.onExecuteLatch.await(2, TimeUnit.SECONDS)).isTrue(); ctx.close(); } @@ -73,14 +70,14 @@ public class StateActionTests extends AbstractStateMachineTests { TestEntryAction testEntryAction = ctx.getBean("testEntryAction", TestEntryAction.class); machine.start(); - assertThat(machine, notNullValue()); - assertThat(machine.isComplete(), is(false)); - assertThat(machine.getState().getIds(), contains(TestStates.SI)); + assertThat(machine).isNotNull(); + assertThat(machine.isComplete()).isFalse(); + assertThat(machine.getState().getIds()).containsExactly(TestStates.SI); machine.sendEvent(TestEvents.E1); - assertThat(machine.isComplete(), is(true)); - assertThat(machine.getState().getIds(), contains(TestStates.SF)); - assertThat(testEntryAction.onExecuteLatch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(machine.isComplete()).isTrue(); + assertThat(machine.getState().getIds()).containsExactly(TestStates.SF); + assertThat(testEntryAction.onExecuteLatch.await(2, TimeUnit.SECONDS)).isTrue(); ctx.close(); } diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/SubmachineRefEnumTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/SubmachineRefEnumTests.java index 64815f78..9946ab36 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/SubmachineRefEnumTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/SubmachineRefEnumTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2016-2019 the original author or authors. + * Copyright 2016-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,9 +15,7 @@ */ package org.springframework.statemachine.state; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.notNullValue; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; import static org.springframework.statemachine.TestUtils.resolveMachine; @@ -47,15 +45,15 @@ public class SubmachineRefEnumTests extends AbstractStateMachineTests { context.register(Config2.class, Config1.class); context.refresh(); StateMachine machine = resolveMachine(context); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S1)); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S1); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S20)); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S20); doSendEventAndConsumeAll(machine, TestEvents.E2); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S30)); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S30); doSendEventAndConsumeAll(machine, TestEvents.E3); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S31)); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S21, TestStates.S31); } @Test @@ -63,15 +61,15 @@ public class SubmachineRefEnumTests extends AbstractStateMachineTests { context.register(Config4.class, Config3.class); context.refresh(); StateMachine machine = resolveMachine(context); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), containsInAnyOrder(States1.S1)); + assertThat(machine.getState().getIds()).containsOnly(States1.S1); doSendEventAndConsumeAll(machine, Events1.E1); - assertThat(machine.getState().getIds(), containsInAnyOrder(States1.S2, States2.S20)); + assertThat(machine.getState().getIds()).containsOnly(States1.S2, States2.S20); doSendEventAndConsumeAll(machine, Events2.E2); - assertThat(machine.getState().getIds(), containsInAnyOrder(States1.S2, States2.S21, States2.S30)); + assertThat(machine.getState().getIds()).containsOnly(States1.S2, States2.S21, States2.S30); doSendEventAndConsumeAll(machine, Events2.E3); - assertThat(machine.getState().getIds(), containsInAnyOrder(States1.S2, States2.S21, States2.S31)); + assertThat(machine.getState().getIds()).containsOnly(States1.S2, States2.S21, States2.S31); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/SubmachineRefTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/SubmachineRefTests.java index b419dd28..697fa685 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/SubmachineRefTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/SubmachineRefTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2016-2019 the original author or authors. + * Copyright 2016-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,9 +15,7 @@ */ package org.springframework.statemachine.state; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.notNullValue; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; import static org.springframework.statemachine.TestUtils.resolveFactory; @@ -50,15 +48,15 @@ public class SubmachineRefTests extends AbstractStateMachineTests { context.register(Config2.class, Config1.class); context.refresh(); StateMachine machine = resolveMachine(context); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), containsInAnyOrder("S1")); + assertThat(machine.getState().getIds()).containsOnly("S1"); doSendEventAndConsumeAll(machine, "E1"); - assertThat(machine.getState().getIds(), containsInAnyOrder("S2", "S20")); + assertThat(machine.getState().getIds()).containsOnly("S2", "S20"); doSendEventAndConsumeAll(machine, "E2"); - assertThat(machine.getState().getIds(), containsInAnyOrder("S2", "S21", "S30")); + assertThat(machine.getState().getIds()).containsOnly("S2", "S21", "S30"); doSendEventAndConsumeAll(machine, "E3"); - assertThat(machine.getState().getIds(), containsInAnyOrder("S2", "S21", "S31")); + assertThat(machine.getState().getIds()).containsOnly("S2", "S21", "S31"); } @Test @@ -67,15 +65,15 @@ public class SubmachineRefTests extends AbstractStateMachineTests { context.refresh(); StateMachineFactory factory = resolveFactory(context); StateMachine machine = factory.getStateMachine(); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), containsInAnyOrder("S1")); + assertThat(machine.getState().getIds()).containsOnly("S1"); doSendEventAndConsumeAll(machine, "E1"); - assertThat(machine.getState().getIds(), containsInAnyOrder("S2", "S20")); + assertThat(machine.getState().getIds()).containsOnly("S2", "S20"); doSendEventAndConsumeAll(machine, "E2"); - assertThat(machine.getState().getIds(), containsInAnyOrder("S2", "S21", "S30")); + assertThat(machine.getState().getIds()).containsOnly("S2", "S21", "S30"); doSendEventAndConsumeAll(machine, "E3"); - assertThat(machine.getState().getIds(), containsInAnyOrder("S2", "S21", "S31")); + assertThat(machine.getState().getIds()).containsOnly("S2", "S21", "S31"); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/SubmachineStateTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/SubmachineStateTests.java index 586c116f..1d20c32d 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/SubmachineStateTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/SubmachineStateTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,10 +15,7 @@ */ package org.springframework.statemachine.state; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.notNullValue; +import static org.assertj.core.api.Assertions.assertThat; import java.util.ArrayList; import java.util.Collection; @@ -90,12 +87,12 @@ public class SubmachineStateTests extends AbstractStateMachineTests { StateMachineState state = new StateMachineState(TestStates.S4, machine); - assertThat(state.isSimple(), is(false)); - assertThat(state.isComposite(), is(false)); - assertThat(state.isOrthogonal(), is(false)); - assertThat(state.isSubmachineState(), is(true)); + assertThat(state.isSimple()).isFalse(); + assertThat(state.isComposite()).isFalse(); + assertThat(state.isOrthogonal()).isFalse(); + assertThat(state.isSubmachineState()).isTrue(); - assertThat(state.getIds(), contains(TestStates.S4, TestStates.SI)); + assertThat(state.getIds()).containsExactly(TestStates.S4, TestStates.SI); } @Test @@ -105,14 +102,14 @@ public class SubmachineStateTests extends AbstractStateMachineTests { context.refresh(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); machine.sendEvent(TestEvents.E1); machine.sendEvent(TestEvents.E2); machine.sendEvent(TestEvents.E3); machine.sendEvent(TestEvents.E4); - assertThat(machine.getState().getIds(), contains(TestStates.S2, TestStates.S21)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S2, TestStates.S21); } @Test @@ -122,23 +119,23 @@ public class SubmachineStateTests extends AbstractStateMachineTests { context.refresh(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); machine.sendEvent(TestEvents.E1); - assertThat(machine.isRunning(), is(true)); + assertThat(machine.isRunning()).isTrue(); State s = machine.getState(); StateMachine m = ((StateMachineState) s).getSubmachine(); boolean r = TestUtils.callMethod("isRunning", m); - assertThat(r, is(true)); + assertThat(r).isTrue(); s = m.getState(); m = ((StateMachineState) s).getSubmachine(); r = TestUtils.callMethod("isRunning", m); - assertThat(r, is(true)); + assertThat(r).isTrue(); - assertThat(machine.getState().getIds(), contains(TestStates.S2, TestStates.S20, TestStates.S2011)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S2, TestStates.S20, TestStates.S2011); } @Test @@ -148,23 +145,23 @@ public class SubmachineStateTests extends AbstractStateMachineTests { context.refresh(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); machine.sendEvent(TestEvents.E1); - assertThat(machine.isRunning(), is(true)); + assertThat(machine.isRunning()).isTrue(); State s = machine.getState(); StateMachine m = ((StateMachineState) s).getSubmachine(); boolean r = TestUtils.callMethod("isRunning", m); - assertThat(r, is(true)); + assertThat(r).isTrue(); s = m.getState(); m = ((StateMachineState) s).getSubmachine(); r = TestUtils.callMethod("isRunning", m); - assertThat(r, is(true)); + assertThat(r).isTrue(); - assertThat(machine.getState().getIds(), contains(TestStates.S2, TestStates.S21, TestStates.S212)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S2, TestStates.S21, TestStates.S212); } @Test @@ -174,12 +171,12 @@ public class SubmachineStateTests extends AbstractStateMachineTests { context.refresh(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); - assertThat(machine, notNullValue()); + assertThat(machine).isNotNull(); machine.start(); machine.sendEvent(TestEvents.E1); machine.sendEvent(TestEvents.E2); - assertThat(machine.isRunning(), is(true)); + assertThat(machine.isRunning()).isTrue(); State s1 = machine.getState(); StateMachine m1 = ((StateMachineState) s1).getSubmachine(); @@ -190,11 +187,11 @@ public class SubmachineStateTests extends AbstractStateMachineTests { machine.sendEvent(TestEvents.E3); boolean r1 = TestUtils.callMethod("isRunning", m1); - assertThat(r1, is(false)); + assertThat(r1).isFalse(); boolean r2 = TestUtils.callMethod("isRunning", m2); - assertThat(r2, is(false)); + assertThat(r2).isFalse(); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/support/DefaultStateMachineContextTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/support/DefaultStateMachineContextTests.java index 37a367d3..ad2819b8 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/support/DefaultStateMachineContextTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/support/DefaultStateMachineContextTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2019 the original author or authors. + * Copyright 2019-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,10 +15,9 @@ */ package org.springframework.statemachine.support; -import org.junit.jupiter.api.Test; +import static org.assertj.core.api.Assertions.assertThat; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import org.junit.jupiter.api.Test; import java.util.Arrays; import java.util.HashMap; @@ -32,7 +31,7 @@ public class DefaultStateMachineContextTests { null); DefaultStateMachineContext c2 = new DefaultStateMachineContext(null, null, null, null); - assertThat(c1.equals(c2), is(true)); + assertThat(c1.equals(c2)).isTrue(); DefaultStateMachineContext c0 = new DefaultStateMachineContext(null, null, null, null); @@ -41,10 +40,10 @@ public class DefaultStateMachineContextTests { new HashMap<>(), new DefaultExtendedState(), new HashMap<>(), "id"); c2 = new DefaultStateMachineContext(Arrays.asList("x", "y"), Arrays.asList(c0), "s1", "e1", new HashMap<>(), new DefaultExtendedState(), new HashMap<>(), "id"); - assertThat(c1.equals(c2), is(true)); + assertThat(c1.equals(c2)).isTrue(); c2 = new DefaultStateMachineContext(Arrays.asList("d", "y"), Arrays.asList(c0), "s1", "e1", new HashMap<>(), new DefaultExtendedState(), new HashMap<>(), "id"); - assertThat(c1.equals(c2), is(false)); + assertThat(c1.equals(c2)).isFalse(); } } diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/support/LifecycleObjectSupportTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/support/LifecycleObjectSupportTests.java index b2face2d..66698db3 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/support/LifecycleObjectSupportTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/support/LifecycleObjectSupportTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2019 the original author or authors. + * Copyright 2019-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,8 +15,7 @@ */ package org.springframework.statemachine.support; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import org.junit.jupiter.api.Test; import reactor.test.StepVerifier; @@ -26,20 +25,20 @@ public class LifecycleObjectSupportTests { @Test public void testBlocking() { LifecycleObjectSupport support = new NoopLifecycleObjectSupport(); - assertThat(support.isRunning(), is(false)); + assertThat(support.isRunning()).isFalse(); support.start(); - assertThat(support.isRunning(), is(true)); + assertThat(support.isRunning()).isTrue(); support.stop(); - assertThat(support.isRunning(), is(false)); + assertThat(support.isRunning()).isFalse(); } @Test public void testReactive() { LifecycleObjectSupport support = new NoopLifecycleObjectSupport(); StepVerifier.create(support.startReactively()).expectComplete().verify(); - assertThat(support.isRunning(), is(true)); + assertThat(support.isRunning()).isTrue(); StepVerifier.create(support.stopReactively()).expectComplete().verify(); - assertThat(support.isRunning(), is(false)); + assertThat(support.isRunning()).isFalse(); } private static class NoopLifecycleObjectSupport extends LifecycleObjectSupport { diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/support/ReactiveLifecycleManagerTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/support/ReactiveLifecycleManagerTests.java index 43d4ac7b..15d10c27 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/support/ReactiveLifecycleManagerTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/support/ReactiveLifecycleManagerTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2019 the original author or authors. + * Copyright 2019-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,8 +15,7 @@ */ package org.springframework.statemachine.support; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import java.util.concurrent.atomic.AtomicBoolean; import java.util.function.Supplier; @@ -34,24 +33,24 @@ public class ReactiveLifecycleManagerTests { ReactiveLifecycleManager manager = new ReactiveLifecycleManager(() -> Mono.empty(), () -> Mono.empty(), () -> Mono.empty(), () -> Mono.empty()); - assertThat(manager.isRunning(), is(false)); - assertThat(manager.getLifecycleState(), is(LifecycleState.STOPPED)); + assertThat(manager.isRunning()).isFalse(); + assertThat(manager.getLifecycleState()).isEqualTo(LifecycleState.STOPPED); StepVerifier.create(manager.startReactively()).expectComplete().verify(); - assertThat(manager.isRunning(), is(true)); - assertThat(manager.getLifecycleState(), is(LifecycleState.STARTED)); + assertThat(manager.isRunning()).isTrue(); + assertThat(manager.getLifecycleState()).isEqualTo(LifecycleState.STARTED); StepVerifier.create(manager.stopReactively()).expectComplete().verify(); - assertThat(manager.isRunning(), is(false)); - assertThat(manager.getLifecycleState(), is(LifecycleState.STOPPED)); + assertThat(manager.isRunning()).isFalse(); + assertThat(manager.getLifecycleState()).isEqualTo(LifecycleState.STOPPED); StepVerifier.create(manager.startReactively()).expectComplete().verify(); - assertThat(manager.isRunning(), is(true)); - assertThat(manager.getLifecycleState(), is(LifecycleState.STARTED)); + assertThat(manager.isRunning()).isTrue(); + assertThat(manager.getLifecycleState()).isEqualTo(LifecycleState.STARTED); StepVerifier.create(manager.stopReactively()).expectComplete().verify(); - assertThat(manager.isRunning(), is(false)); - assertThat(manager.getLifecycleState(), is(LifecycleState.STOPPED)); + assertThat(manager.isRunning()).isFalse(); + assertThat(manager.getLifecycleState()).isEqualTo(LifecycleState.STOPPED); } @Test @@ -61,8 +60,8 @@ public class ReactiveLifecycleManagerTests { () -> Mono.empty(), () -> Mono.empty()); startSupplier.setManager(manager); StepVerifier.create(manager.startReactively()).expectComplete().verify(); - assertThat(manager.isRunning(), is(true)); - assertThat(manager.getLifecycleState(), is(LifecycleState.STARTED)); + assertThat(manager.isRunning()).isTrue(); + assertThat(manager.getLifecycleState()).isEqualTo(LifecycleState.STARTED); } @Test @@ -72,8 +71,8 @@ public class ReactiveLifecycleManagerTests { startSupplier, () -> Mono.empty()); startSupplier.setManager(manager); StepVerifier.create(manager.startReactively()).expectComplete().verify(); - assertThat(manager.isRunning(), is(false)); - assertThat(manager.getLifecycleState(), is(LifecycleState.STOPPED)); + assertThat(manager.isRunning()).isFalse(); + assertThat(manager.getLifecycleState()).isEqualTo(LifecycleState.STOPPED); } @Test @@ -83,8 +82,8 @@ public class ReactiveLifecycleManagerTests { () -> Mono.empty(), () -> Mono.empty()); startSupplier.setManager(manager); StepVerifier.create(manager.startReactively()).expectComplete().verify(); -// assertThat(manager.isRunning(), is(false)); - assertThat(manager.getLifecycleState(), is(LifecycleState.STOPPED)); +// assertThat(manager.isRunning()).isFalse(); + assertThat(manager.getLifecycleState()).isEqualTo(LifecycleState.STOPPED); } private static class RecursiveStartRequestSupplier implements Supplier> { diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/support/StateChangeInterceptorTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/support/StateChangeInterceptorTests.java index 76d313bf..8dc66b93 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/support/StateChangeInterceptorTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/support/StateChangeInterceptorTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,9 +15,7 @@ */ package org.springframework.statemachine.support; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.is; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; import static org.springframework.statemachine.TestUtils.resolveMachine; @@ -66,24 +64,24 @@ public class StateChangeInterceptorTests extends AbstractStateMachineTests { doStartAndAssert(machine); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(3)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0, States.S1, States.S11)); - assertThat((Integer)machine.getExtendedState().getVariables().get("foo"), is(0)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(3); + assertThat(machine.getState().getIds()).containsOnly(States.S0, States.S1, States.S11); + assertThat((Integer)machine.getExtendedState().getVariables().get("foo")).isZero(); listener.reset(3); interceptor.reset(1); doSendEventAndConsumeAll(machine, Events.C); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(3)); - assertThat(interceptor.preStateChangeLatch1.await(2, TimeUnit.SECONDS), is(true)); - assertThat(interceptor.preStateChangeCount1, is(1)); - assertThat(interceptor.preStateChangeLatch2.await(2, TimeUnit.SECONDS), is(true)); - assertThat(interceptor.preStateChangeCount2, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0, States.S2, States.S21, States.S211)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(3); + assertThat(interceptor.preStateChangeLatch1.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(interceptor.preStateChangeCount1).isEqualTo(1); + assertThat(interceptor.preStateChangeLatch2.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(interceptor.preStateChangeCount2).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(States.S0, States.S2, States.S21, States.S211); doSendEventAndConsumeAll(machine, Events.H); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0, States.S2, States.S21, States.S211)); - assertThat((Integer)machine.getExtendedState().getVariables().get("foo"), is(1)); + assertThat(machine.getState().getIds()).containsOnly(States.S0, States.S2, States.S21, States.S211); + assertThat((Integer)machine.getExtendedState().getVariables().get("foo")).isEqualTo(1); } @Test @@ -98,42 +96,42 @@ public class StateChangeInterceptorTests extends AbstractStateMachineTests { machine.getStateMachineAccessor().doWithRegion(function -> function.addStateMachineInterceptor(interceptor)); doStartAndAssert(machine); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(States.S0); interceptor.reset(1); listener.reset(1); doSendEventAndConsumeAll(machine, Events.A); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S1)); - assertThat(interceptor.preStateChangeLatch1.await(2, TimeUnit.SECONDS), is(true)); - assertThat(interceptor.preStateChangeCount1, is(1)); - assertThat(interceptor.preStateChangeLatch2.await(2, TimeUnit.SECONDS), is(true)); - assertThat(interceptor.preStateChangeCount2, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(States.S1); + assertThat(interceptor.preStateChangeLatch1.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(interceptor.preStateChangeCount1).isEqualTo(1); + assertThat(interceptor.preStateChangeLatch2.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(interceptor.preStateChangeCount2).isEqualTo(1); interceptor.reset(1); listener.reset(1); doSendEventAndConsumeAll(machine, Events.B); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S2)); - assertThat(interceptor.preStateChangeLatch1.await(2, TimeUnit.SECONDS), is(true)); - assertThat(interceptor.preStateChangeCount1, is(1)); - assertThat(interceptor.preStateChangeLatch2.await(2, TimeUnit.SECONDS), is(true)); - assertThat(interceptor.preStateChangeCount2, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(States.S2); + assertThat(interceptor.preStateChangeLatch1.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(interceptor.preStateChangeCount1).isEqualTo(1); + assertThat(interceptor.preStateChangeLatch2.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(interceptor.preStateChangeCount2).isEqualTo(1); interceptor.reset(1); listener.reset(1); doSendEventAndConsumeAll(machine, Events.C); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0)); - assertThat(interceptor.preStateChangeLatch1.await(2, TimeUnit.SECONDS), is(true)); - assertThat(interceptor.preStateChangeCount1, is(1)); - assertThat(interceptor.preStateChangeLatch2.await(2, TimeUnit.SECONDS), is(true)); - assertThat(interceptor.preStateChangeCount2, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(States.S0); + assertThat(interceptor.preStateChangeLatch1.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(interceptor.preStateChangeCount1).isEqualTo(1); + assertThat(interceptor.preStateChangeLatch2.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(interceptor.preStateChangeCount2).isEqualTo(1); } @Test @@ -148,20 +146,20 @@ public class StateChangeInterceptorTests extends AbstractStateMachineTests { machine.getStateMachineAccessor().doWithRegion(function -> function.addStateMachineInterceptor(interceptor)); doStartAndAssert(machine); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(States.S0); interceptor.reset(1); listener.reset(1); doSendEventAndConsumeAll(machine, Events.A); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S2)); - assertThat(interceptor.preStateChangeLatch1.await(2, TimeUnit.SECONDS), is(true)); - assertThat(interceptor.preStateChangeCount1, is(1)); - assertThat(interceptor.preStateChangeLatch2.await(2, TimeUnit.SECONDS), is(true)); - assertThat(interceptor.preStateChangeCount2, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(States.S2); + assertThat(interceptor.preStateChangeLatch1.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(interceptor.preStateChangeCount1).isEqualTo(1); + assertThat(interceptor.preStateChangeLatch2.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(interceptor.preStateChangeCount2).isEqualTo(1); } @Test @@ -176,30 +174,30 @@ public class StateChangeInterceptorTests extends AbstractStateMachineTests { machine.getStateMachineAccessor().doWithRegion(function -> function.addStateMachineInterceptor(interceptor)); doStartAndAssert(machine); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(States.S0); interceptor.reset(1); listener.reset(1); doSendEventAndConsumeAll(machine, Events.A); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S2)); - assertThat(interceptor.preStateChangeLatch1.await(2, TimeUnit.SECONDS), is(true)); - assertThat(interceptor.preStateChangeCount1, is(1)); - assertThat(interceptor.postStateChangeLatch1.await(2, TimeUnit.SECONDS), is(true)); - assertThat(interceptor.postStateChangeCount1, is(1)); - assertThat(interceptor.preStateChangeStates1.size(), is(1)); - assertThat(interceptor.postStateChangeStates1.size(), is(1)); - assertThat(interceptor.preStateChangeStates1.get(0).getId(), is(interceptor.postStateChangeStates1.get(0).getId())); - assertThat(interceptor.preStateChangeLatch2.await(2, TimeUnit.SECONDS), is(true)); - assertThat(interceptor.preStateChangeCount2, is(1)); - assertThat(interceptor.postStateChangeLatch2.await(2, TimeUnit.SECONDS), is(true)); - assertThat(interceptor.postStateChangeCount2, is(1)); - assertThat(interceptor.preStateChangeStates2.size(), is(1)); - assertThat(interceptor.postStateChangeStates2.size(), is(1)); - assertThat(interceptor.preStateChangeStates2.get(0).getId(), is(interceptor.postStateChangeStates2.get(0).getId())); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(States.S2); + assertThat(interceptor.preStateChangeLatch1.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(interceptor.preStateChangeCount1).isEqualTo(1); + assertThat(interceptor.postStateChangeLatch1.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(interceptor.postStateChangeCount1).isEqualTo(1); + assertThat(interceptor.preStateChangeStates1).hasSize(1); + assertThat(interceptor.postStateChangeStates1).hasSize(1); + assertThat(interceptor.preStateChangeStates1.get(0).getId()).isEqualTo(interceptor.postStateChangeStates1.get(0).getId()); + assertThat(interceptor.preStateChangeLatch2.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(interceptor.preStateChangeCount2).isEqualTo(1); + assertThat(interceptor.postStateChangeLatch2.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(interceptor.postStateChangeCount2).isEqualTo(1); + assertThat(interceptor.preStateChangeStates2).hasSize(1); + assertThat(interceptor.postStateChangeStates2).hasSize(1); + assertThat(interceptor.preStateChangeStates2.get(0).getId()).isEqualTo(interceptor.postStateChangeStates2.get(0).getId()); } @Test @@ -214,30 +212,30 @@ public class StateChangeInterceptorTests extends AbstractStateMachineTests { machine.getStateMachineAccessor().doWithRegion(function -> function.addStateMachineInterceptor(interceptor)); doStartAndAssert(machine); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(States.S0); interceptor.reset(1); listener.reset(1); doSendEventAndConsumeAll(machine, MessageBuilder.withPayload(Events.A).setHeader("test", "exists").build()); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S3)); - assertThat(interceptor.preStateChangeLatch1.await(2, TimeUnit.SECONDS), is(true)); - assertThat(interceptor.preStateChangeCount1, is(1)); - assertThat(interceptor.postStateChangeLatch1.await(2, TimeUnit.SECONDS), is(true)); - assertThat(interceptor.postStateChangeCount1, is(1)); - assertThat(interceptor.preStateChangeStates1.size(), is(1)); - assertThat(interceptor.postStateChangeStates1.size(), is(1)); - assertThat(interceptor.preStateChangeStates1.get(0).getId(), is(interceptor.postStateChangeStates1.get(0).getId())); - assertThat(interceptor.preStateChangeLatch2.await(2, TimeUnit.SECONDS), is(true)); - assertThat(interceptor.preStateChangeCount2, is(1)); - assertThat(interceptor.postStateChangeLatch2.await(2, TimeUnit.SECONDS), is(true)); - assertThat(interceptor.postStateChangeCount2, is(1)); - assertThat(interceptor.preStateChangeStates2.size(), is(1)); - assertThat(interceptor.postStateChangeStates2.size(), is(1)); - assertThat(interceptor.preStateChangeStates2.get(0).getId(), is(interceptor.postStateChangeStates2.get(0).getId())); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(States.S3); + assertThat(interceptor.preStateChangeLatch1.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(interceptor.preStateChangeCount1).isEqualTo(1); + assertThat(interceptor.postStateChangeLatch1.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(interceptor.postStateChangeCount1).isEqualTo(1); + assertThat(interceptor.preStateChangeStates1).hasSize(1); + assertThat(interceptor.postStateChangeStates1).hasSize(1); + assertThat(interceptor.preStateChangeStates1.get(0).getId()).isEqualTo(interceptor.postStateChangeStates1.get(0).getId()); + assertThat(interceptor.preStateChangeLatch2.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(interceptor.preStateChangeCount2).isEqualTo(1); + assertThat(interceptor.postStateChangeLatch2.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(interceptor.postStateChangeCount2).isEqualTo(1); + assertThat(interceptor.preStateChangeStates2).hasSize(1); + assertThat(interceptor.postStateChangeStates2).hasSize(1); + assertThat(interceptor.preStateChangeStates2.get(0).getId()).isEqualTo(interceptor.postStateChangeStates2.get(0).getId()); } @Test @@ -252,31 +250,31 @@ public class StateChangeInterceptorTests extends AbstractStateMachineTests { machine.getStateMachineAccessor().doWithRegion(function -> function.addStateMachineInterceptor(interceptor)); doStartAndAssert(machine); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(States.S0); interceptor.reset(1); listener.reset(1); doSendEventAndConsumeAll(machine, Events.A); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S1)); - assertThat(interceptor.preStateChangeLatch1.await(2, TimeUnit.SECONDS), is(true)); - assertThat(interceptor.preStateChangeCount1, is(1)); - assertThat(interceptor.preStateChangeLatch2.await(2, TimeUnit.SECONDS), is(true)); - assertThat(interceptor.preStateChangeCount2, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(States.S1); + assertThat(interceptor.preStateChangeLatch1.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(interceptor.preStateChangeCount1).isEqualTo(1); + assertThat(interceptor.preStateChangeLatch2.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(interceptor.preStateChangeCount2).isEqualTo(1); interceptor.reset(1); listener.reset(1); doSendEventAndConsumeAll(machine, Events.E); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S2)); - assertThat(interceptor.preStateChangeLatch1.await(2, TimeUnit.SECONDS), is(true)); - assertThat(interceptor.preStateChangeCount1, is(1)); - assertThat(interceptor.preStateChangeLatch2.await(2, TimeUnit.SECONDS), is(true)); - assertThat(interceptor.preStateChangeCount2, is(1)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(States.S2); + assertThat(interceptor.preStateChangeLatch1.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(interceptor.preStateChangeCount1).isEqualTo(1); + assertThat(interceptor.preStateChangeLatch2.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(interceptor.preStateChangeCount2).isEqualTo(1); } @Test @@ -291,33 +289,33 @@ public class StateChangeInterceptorTests extends AbstractStateMachineTests { machine.getStateMachineAccessor().doWithRegion(function -> function.addStateMachineInterceptor(interceptor)); doStartAndAssert(machine); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S0)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(States.S0); interceptor.reset(2); listener.reset(2); doSendEventAndConsumeAll(machine, Events.A); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(2)); - assertThat(machine.getState().getIds(), containsInAnyOrder(States.S2)); - assertThat(interceptor.preStateChangeLatch1.await(2, TimeUnit.SECONDS), is(true)); - assertThat(interceptor.preStateChangeCount1, is(2)); - assertThat(interceptor.preStateChangeLatch2.await(2, TimeUnit.SECONDS), is(true)); - assertThat(interceptor.preStateChangeCount2, is(2)); - assertThat(interceptor.postStateChangeLatch1.await(2, TimeUnit.SECONDS), is(true)); - assertThat(interceptor.postStateChangeCount1, is(2)); - assertThat(interceptor.postStateChangeLatch2.await(2, TimeUnit.SECONDS), is(true)); - assertThat(interceptor.postStateChangeCount2, is(2)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(2); + assertThat(machine.getState().getIds()).containsOnly(States.S2); + assertThat(interceptor.preStateChangeLatch1.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(interceptor.preStateChangeCount1).isEqualTo(2); + assertThat(interceptor.preStateChangeLatch2.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(interceptor.preStateChangeCount2).isEqualTo(2); + assertThat(interceptor.postStateChangeLatch1.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(interceptor.postStateChangeCount1).isEqualTo(2); + assertThat(interceptor.postStateChangeLatch2.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(interceptor.postStateChangeCount2).isEqualTo(2); - assertThat(interceptor.preStateChangeStates1.size(), is(2)); - assertThat(interceptor.postStateChangeStates1.size(), is(2)); + assertThat(interceptor.preStateChangeStates1).hasSize(2); + assertThat(interceptor.postStateChangeStates1).hasSize(2); - assertThat(interceptor.preStateChangeStates1.get(0).getId(), is(States.S1)); - assertThat(interceptor.preStateChangeStates1.get(1).getId(), is(States.S2)); + assertThat(interceptor.preStateChangeStates1.get(0).getId()).isEqualTo(States.S1); + assertThat(interceptor.preStateChangeStates1.get(1).getId()).isEqualTo(States.S2); - assertThat(interceptor.postStateChangeStates1.get(0).getId(), is(States.S1)); - assertThat(interceptor.postStateChangeStates1.get(1).getId(), is(States.S2)); + assertThat(interceptor.postStateChangeStates1.get(0).getId()).isEqualTo(States.S1); + assertThat(interceptor.postStateChangeStates1.get(1).getId()).isEqualTo(States.S2); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/support/StateContextExpressionMethodsTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/support/StateContextExpressionMethodsTests.java index 3f66a764..8db848e9 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/support/StateContextExpressionMethodsTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/support/StateContextExpressionMethodsTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,8 +15,7 @@ */ package org.springframework.statemachine.support; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.is; +import static org.assertj.core.api.Assertions.assertThat; import java.util.ArrayList; import java.util.Collection; @@ -58,14 +57,14 @@ public class StateContextExpressionMethodsTests { StateContextExpressionMethods methods = new StateContextExpressionMethods(evaluationContext); StateContext stateContext = mockStateContext(null); - assertThat(methods.getValue(parser.parseExpression("true"), stateContext, Boolean.class), is(true)); - assertThat(methods.getValue(parser.parseExpression("event.toString().equals('E1')"), stateContext, Boolean.class), is(true)); - assertThat(methods.getValue(parser.parseExpression("event==T(org.springframework.statemachine.support.StateContextExpressionMethodsTests.SpelEvents).E1"), stateContext, Boolean.class), is(true)); - assertThat(methods.getValue(parser.parseExpression("getExtendedState().getVariables().get('boolean1')"), stateContext, Boolean.class), is(true)); - assertThat(methods.getValue(parser.parseExpression("extendedState.variables.get('boolean1')"), stateContext, Boolean.class), is(true)); - assertThat(methods.getValue(parser.parseExpression("extendedState.variables.get('boolean1')&&!extendedState.variables.get('boolean2')"), stateContext, Boolean.class), is(true)); - assertThat(methods.getValue(parser.parseExpression("extendedState.variables.get('boolean3')==NULL"), stateContext, Boolean.class), is(true)); - assertThat(methods.getValue(parser.parseExpression("transition.source.id.toString().equals('S1')"), stateContext, Boolean.class), is(true)); + assertThat(methods.getValue(parser.parseExpression("true"), stateContext, Boolean.class)).isTrue(); + assertThat(methods.getValue(parser.parseExpression("event.toString().equals('E1')"), stateContext, Boolean.class)).isTrue(); + assertThat(methods.getValue(parser.parseExpression("event==T(org.springframework.statemachine.support.StateContextExpressionMethodsTests.SpelEvents).E1"), stateContext, Boolean.class)).isTrue(); + assertThat(methods.getValue(parser.parseExpression("getExtendedState().getVariables().get('boolean1')"), stateContext, Boolean.class)).isTrue(); + assertThat(methods.getValue(parser.parseExpression("extendedState.variables.get('boolean1')"), stateContext, Boolean.class)).isTrue(); + assertThat(methods.getValue(parser.parseExpression("extendedState.variables.get('boolean1')&&!extendedState.variables.get('boolean2')"), stateContext, Boolean.class)).isTrue(); + assertThat(methods.getValue(parser.parseExpression("extendedState.variables.get('boolean3')==NULL"), stateContext, Boolean.class)).isTrue(); + assertThat(methods.getValue(parser.parseExpression("transition.source.id.toString().equals('S1')"), stateContext, Boolean.class)).isTrue(); } @Test @@ -76,8 +75,8 @@ public class StateContextExpressionMethodsTests { MockStatemachine stateMachine = new MockStatemachine(); StateContext stateContext = mockStateContext(stateMachine); - assertThat(methods.getValue(parser.parseExpression("stateMachine.sendEvent(T(org.springframework.statemachine.support.StateContextExpressionMethodsTests.SpelEvents).E1)"), stateContext, Boolean.class), is(true)); - assertThat(stateMachine.events.size(), is(1)); + assertThat(methods.getValue(parser.parseExpression("stateMachine.sendEvent(T(org.springframework.statemachine.support.StateContextExpressionMethodsTests.SpelEvents).E1)"), stateContext, Boolean.class)).isTrue(); + assertThat(stateMachine.events).hasSize(1); } enum SpelStates { diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/support/TransitionComparatorTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/support/TransitionComparatorTests.java index 933c8dd9..4cda38b6 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/support/TransitionComparatorTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/support/TransitionComparatorTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2017-2018 the original author or authors. + * Copyright 2017-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,8 +15,7 @@ */ package org.springframework.statemachine.support; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import java.util.ArrayList; import java.util.Collection; @@ -77,21 +76,21 @@ public class TransitionComparatorTests { stateS11, stateS1, null, TestEvents.E1, null, new EventTrigger(TestEvents.E1)); TransitionComparator comparator = new TransitionComparator<>(null); - assertThat(comparator.compare(transitionFromS111ToS1, transitionFromS11ToS1), is(-1)); - assertThat(comparator.compare(transitionFromS11ToS1, transitionFromS111ToS1), is(1)); - assertThat(comparator.compare(transitionFromS111ToS1, transitionFromS111ToS1), is(0)); - assertThat(comparator.compare(transitionFromS11ToS1, transitionFromS11ToS1), is(0)); + assertThat(comparator.compare(transitionFromS111ToS1, transitionFromS11ToS1)).isEqualTo(-1); + assertThat(comparator.compare(transitionFromS11ToS1, transitionFromS111ToS1)).isEqualTo(1); + assertThat(comparator.compare(transitionFromS111ToS1, transitionFromS111ToS1)).isZero(); + assertThat(comparator.compare(transitionFromS11ToS1, transitionFromS11ToS1)).isZero(); comparator = new TransitionComparator<>(TransitionConflictPolicy.CHILD); - assertThat(comparator.compare(transitionFromS111ToS1, transitionFromS11ToS1), is(-1)); - assertThat(comparator.compare(transitionFromS11ToS1, transitionFromS111ToS1), is(1)); - assertThat(comparator.compare(transitionFromS111ToS1, transitionFromS111ToS1), is(0)); - assertThat(comparator.compare(transitionFromS11ToS1, transitionFromS11ToS1), is(0)); + assertThat(comparator.compare(transitionFromS111ToS1, transitionFromS11ToS1)).isEqualTo(-1); + assertThat(comparator.compare(transitionFromS11ToS1, transitionFromS111ToS1)).isEqualTo(1); + assertThat(comparator.compare(transitionFromS111ToS1, transitionFromS111ToS1)).isZero(); + assertThat(comparator.compare(transitionFromS11ToS1, transitionFromS11ToS1)).isZero(); comparator = new TransitionComparator<>(TransitionConflictPolicy.PARENT); - assertThat(comparator.compare(transitionFromS111ToS1, transitionFromS11ToS1), is(1)); - assertThat(comparator.compare(transitionFromS11ToS1, transitionFromS111ToS1), is(-1)); - assertThat(comparator.compare(transitionFromS111ToS1, transitionFromS111ToS1), is(0)); - assertThat(comparator.compare(transitionFromS11ToS1, transitionFromS11ToS1), is(0)); + assertThat(comparator.compare(transitionFromS111ToS1, transitionFromS11ToS1)).isEqualTo(1); + assertThat(comparator.compare(transitionFromS11ToS1, transitionFromS111ToS1)).isEqualTo(-1); + assertThat(comparator.compare(transitionFromS111ToS1, transitionFromS111ToS1)).isZero(); + assertThat(comparator.compare(transitionFromS11ToS1, transitionFromS11ToS1)).isZero(); } } diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/transition/LocalTransitionTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/transition/LocalTransitionTests.java index f05f5c12..4354f66a 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/transition/LocalTransitionTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/transition/LocalTransitionTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2016-2019 the original author or authors. + * Copyright 2016-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,9 +15,7 @@ */ package org.springframework.statemachine.transition; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; import static org.springframework.statemachine.TestUtils.resolveMachine; @@ -47,15 +45,15 @@ public class LocalTransitionTests extends AbstractStateMachineTests { machine.addStateListener(listener); doStartAndAssert(machine); doSendEventAndConsumeAll(machine, "E1"); - assertThat(machine.getState().getIds(), containsInAnyOrder("S2", "S21")); + assertThat(machine.getState().getIds()).containsOnly("S2", "S21"); listener.reset(); doSendEventAndConsumeAll(machine, "E20"); - assertThat(machine.getState().getIds(), containsInAnyOrder("S2", "S21")); - assertThat(listener.exited.size(), is(2)); - assertThat(listener.entered.size(), is(2)); - assertThat(listener.exited, containsInAnyOrder("S2", "S21")); - assertThat(listener.entered, containsInAnyOrder("S2", "S21")); + assertThat(machine.getState().getIds()).containsOnly("S2", "S21"); + assertThat(listener.exited).hasSize(2); + assertThat(listener.entered).hasSize(2); + assertThat(listener.exited).containsOnly("S2", "S21"); + assertThat(listener.entered).containsOnly("S2", "S21"); } @Test @@ -67,15 +65,15 @@ public class LocalTransitionTests extends AbstractStateMachineTests { machine.addStateListener(listener); doStartAndAssert(machine); doSendEventAndConsumeAll(machine, "E1"); - assertThat(machine.getState().getIds(), containsInAnyOrder("S2", "S21")); + assertThat(machine.getState().getIds()).containsOnly("S2", "S21"); listener.reset(); doSendEventAndConsumeAll(machine, "E30"); - assertThat(machine.getState().getIds(), containsInAnyOrder("S2", "S21")); - assertThat(listener.exited.size(), is(1)); - assertThat(listener.entered.size(), is(1)); - assertThat(listener.exited, containsInAnyOrder("S21")); - assertThat(listener.entered, containsInAnyOrder("S21")); + assertThat(machine.getState().getIds()).containsOnly("S2", "S21"); + assertThat(listener.exited).hasSize(1); + assertThat(listener.entered).hasSize(1); + assertThat(listener.exited).containsOnly("S21"); + assertThat(listener.entered).containsOnly("S21"); } @Test @@ -87,15 +85,15 @@ public class LocalTransitionTests extends AbstractStateMachineTests { machine.addStateListener(listener); doStartAndAssert(machine); doSendEventAndConsumeAll(machine, "E1"); - assertThat(machine.getState().getIds(), containsInAnyOrder("S2", "S21")); + assertThat(machine.getState().getIds()).containsOnly("S2", "S21"); listener.reset(); doSendEventAndConsumeAll(machine, "E21"); - assertThat(machine.getState().getIds(), containsInAnyOrder("S2", "S22")); - assertThat(listener.exited.size(), is(2)); - assertThat(listener.entered.size(), is(2)); - assertThat(listener.exited, containsInAnyOrder("S2", "S21")); - assertThat(listener.entered, containsInAnyOrder("S2", "S22")); + assertThat(machine.getState().getIds()).containsOnly("S2", "S22"); + assertThat(listener.exited).hasSize(2); + assertThat(listener.entered).hasSize(2); + assertThat(listener.exited).containsOnly("S2", "S21"); + assertThat(listener.entered).containsOnly("S2", "S22"); } @Test @@ -107,15 +105,15 @@ public class LocalTransitionTests extends AbstractStateMachineTests { machine.addStateListener(listener); doStartAndAssert(machine); doSendEventAndConsumeAll(machine, "E1"); - assertThat(machine.getState().getIds(), containsInAnyOrder("S2", "S21")); + assertThat(machine.getState().getIds()).containsOnly("S2", "S21"); listener.reset(); doSendEventAndConsumeAll(machine, "E31"); - assertThat(machine.getState().getIds(), containsInAnyOrder("S2", "S22")); - assertThat(listener.exited.size(), is(1)); - assertThat(listener.entered.size(), is(1)); - assertThat(listener.exited, containsInAnyOrder("S21")); - assertThat(listener.entered, containsInAnyOrder("S22")); + assertThat(machine.getState().getIds()).containsOnly("S2", "S22"); + assertThat(listener.exited).hasSize(1); + assertThat(listener.entered).hasSize(1); + assertThat(listener.exited).containsOnly("S21"); + assertThat(listener.entered).containsOnly("S22"); } @Test @@ -127,15 +125,15 @@ public class LocalTransitionTests extends AbstractStateMachineTests { machine.addStateListener(listener); doStartAndAssert(machine); doSendEventAndConsumeAll(machine, "E1"); - assertThat(machine.getState().getIds(), containsInAnyOrder("S2", "S21")); + assertThat(machine.getState().getIds()).containsOnly("S2", "S21"); listener.reset(); doSendEventAndConsumeAll(machine, "E22"); - assertThat(machine.getState().getIds(), containsInAnyOrder("S2", "S21")); - assertThat(listener.exited.size(), is(2)); - assertThat(listener.entered.size(), is(2)); - assertThat(listener.exited, containsInAnyOrder("S2", "S21")); - assertThat(listener.entered, containsInAnyOrder("S2", "S21")); + assertThat(machine.getState().getIds()).containsOnly("S2", "S21"); + assertThat(listener.exited).hasSize(2); + assertThat(listener.entered).hasSize(2); + assertThat(listener.exited).containsOnly("S2", "S21"); + assertThat(listener.entered).containsOnly("S2", "S21"); } @Test @@ -147,15 +145,15 @@ public class LocalTransitionTests extends AbstractStateMachineTests { machine.addStateListener(listener); doStartAndAssert(machine); doSendEventAndConsumeAll(machine, "E1"); - assertThat(machine.getState().getIds(), containsInAnyOrder("S2", "S21")); + assertThat(machine.getState().getIds()).containsOnly("S2", "S21"); listener.reset(); doSendEventAndConsumeAll(machine, "E32"); - assertThat(machine.getState().getIds(), containsInAnyOrder("S2", "S21")); - assertThat(listener.exited.size(), is(1)); - assertThat(listener.entered.size(), is(1)); - assertThat(listener.exited, containsInAnyOrder("S21")); - assertThat(listener.entered, containsInAnyOrder("S21")); + assertThat(machine.getState().getIds()).containsOnly("S2", "S21"); + assertThat(listener.exited).hasSize(1); + assertThat(listener.entered).hasSize(1); + assertThat(listener.exited).containsOnly("S21"); + assertThat(listener.entered).containsOnly("S21"); } @Test @@ -167,23 +165,23 @@ public class LocalTransitionTests extends AbstractStateMachineTests { machine.addStateListener(listener); doStartAndAssert(machine); doSendEventAndConsumeAll(machine, "E1"); - assertThat(machine.getState().getIds(), containsInAnyOrder("S2", "S21")); + assertThat(machine.getState().getIds()).containsOnly("S2", "S21"); listener.reset(); doSendEventAndConsumeAll(machine, "E21"); - assertThat(machine.getState().getIds(), containsInAnyOrder("S2", "S22")); - assertThat(listener.exited.size(), is(2)); - assertThat(listener.entered.size(), is(2)); - assertThat(listener.exited, containsInAnyOrder("S2", "S21")); - assertThat(listener.entered, containsInAnyOrder("S2", "S22")); + assertThat(machine.getState().getIds()).containsOnly("S2", "S22"); + assertThat(listener.exited).hasSize(2); + assertThat(listener.entered).hasSize(2); + assertThat(listener.exited).containsOnly("S2", "S21"); + assertThat(listener.entered).containsOnly("S2", "S22"); listener.reset(); doSendEventAndConsumeAll(machine, "E23"); - assertThat(machine.getState().getIds(), containsInAnyOrder("S2", "S22")); - assertThat(listener.exited.size(), is(2)); - assertThat(listener.entered.size(), is(2)); - assertThat(listener.exited, containsInAnyOrder("S2", "S22")); - assertThat(listener.entered, containsInAnyOrder("S2", "S22")); + assertThat(machine.getState().getIds()).containsOnly("S2", "S22"); + assertThat(listener.exited).hasSize(2); + assertThat(listener.entered).hasSize(2); + assertThat(listener.exited).containsOnly("S2", "S22"); + assertThat(listener.entered).containsOnly("S2", "S22"); } @Test @@ -195,23 +193,23 @@ public class LocalTransitionTests extends AbstractStateMachineTests { machine.addStateListener(listener); doStartAndAssert(machine); doSendEventAndConsumeAll(machine, "E1"); - assertThat(machine.getState().getIds(), containsInAnyOrder("S2", "S21")); + assertThat(machine.getState().getIds()).containsOnly("S2", "S21"); listener.reset(); doSendEventAndConsumeAll(machine, "E31"); - assertThat(machine.getState().getIds(), containsInAnyOrder("S2", "S22")); - assertThat(listener.exited.size(), is(1)); - assertThat(listener.entered.size(), is(1)); - assertThat(listener.exited, containsInAnyOrder("S21")); - assertThat(listener.entered, containsInAnyOrder("S22")); + assertThat(machine.getState().getIds()).containsOnly("S2", "S22"); + assertThat(listener.exited).hasSize(1); + assertThat(listener.entered).hasSize(1); + assertThat(listener.exited).containsOnly("S21"); + assertThat(listener.entered).containsOnly("S22"); listener.reset(); doSendEventAndConsumeAll(machine, "E33"); - assertThat(machine.getState().getIds(), containsInAnyOrder("S2", "S22")); - assertThat(listener.exited.size(), is(1)); - assertThat(listener.entered.size(), is(1)); - assertThat(listener.exited, containsInAnyOrder("S22")); - assertThat(listener.entered, containsInAnyOrder("S22")); + assertThat(machine.getState().getIds()).containsOnly("S2", "S22"); + assertThat(listener.exited).hasSize(1); + assertThat(listener.entered).hasSize(1); + assertThat(listener.exited).containsOnly("S22"); + assertThat(listener.entered).containsOnly("S22"); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/transition/TransitionEventHeaderTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/transition/TransitionEventHeaderTests.java index 72d0d41f..614d6ee2 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/transition/TransitionEventHeaderTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/transition/TransitionEventHeaderTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,11 +15,7 @@ */ package org.springframework.statemachine.transition; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.nullValue; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.assertj.core.api.Assertions.assertThat; import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; @@ -63,7 +59,7 @@ public class TransitionEventHeaderTests extends AbstractStateMachineTests { context.register(Config1.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); ObjectStateMachine machine = context.getBean( StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); @@ -76,18 +72,18 @@ public class TransitionEventHeaderTests extends AbstractStateMachineTests { machine.addStateListener(listener); machine.start(); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); listener.reset(3); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).build()); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(3)); - assertThat(machine.getState().getIds(), contains(TestStates.S4)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(3); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S4); - assertThat(eventCheckAction1.context.getEvent(), nullValue()); - assertThat(eventCheckAction2.context.getEvent(), is(TestEvents.E1)); - assertThat(eventCheckAction3.context.getEvent(), is(TestEvents.E1)); - assertThat(eventCheckAction4.context.getEvent(), is(TestEvents.E1)); + assertThat(eventCheckAction1.context.getEvent()).isNull(); + assertThat(eventCheckAction2.context.getEvent()).isEqualTo(TestEvents.E1); + assertThat(eventCheckAction3.context.getEvent()).isEqualTo(TestEvents.E1); + assertThat(eventCheckAction4.context.getEvent()).isEqualTo(TestEvents.E1); } @SuppressWarnings("unchecked") @@ -96,7 +92,7 @@ public class TransitionEventHeaderTests extends AbstractStateMachineTests { context.register(Config2.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); ObjectStateMachine machine = context.getBean( StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); @@ -109,18 +105,18 @@ public class TransitionEventHeaderTests extends AbstractStateMachineTests { machine.addStateListener(listener); machine.start(); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); listener.reset(1); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).build()); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), contains(TestStates.S4)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S4); - assertThat(eventCheckAction1.context.getEvent(), nullValue()); - assertThat(eventCheckAction3.context, nullValue()); - assertThat(eventCheckAction4.context.getEvent(), is(TestEvents.E1)); - assertThat(eventCheckGuard.context.getEvent(), is(TestEvents.E1)); + assertThat(eventCheckAction1.context.getEvent()).isNull(); + assertThat(eventCheckAction3.context).isNull(); + assertThat(eventCheckAction4.context.getEvent()).isEqualTo(TestEvents.E1); + assertThat(eventCheckGuard.context.getEvent()).isEqualTo(TestEvents.E1); } @SuppressWarnings("unchecked") @@ -129,7 +125,7 @@ public class TransitionEventHeaderTests extends AbstractStateMachineTests { context.register(Config3.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); ObjectStateMachine machine = context.getBean( StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); @@ -142,18 +138,18 @@ public class TransitionEventHeaderTests extends AbstractStateMachineTests { machine.addStateListener(listener); machine.start(); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); listener.reset(1); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).build()); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), contains(TestStates.S3)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S3); - assertThat(eventCheckAction1.context.getEvent(), nullValue()); - assertThat(eventCheckAction3.context.getEvent(), is(TestEvents.E1)); - assertThat(eventCheckAction4.context, nullValue()); - assertThat(eventCheckGuard.context.getEvent(), is(TestEvents.E1)); + assertThat(eventCheckAction1.context.getEvent()).isNull(); + assertThat(eventCheckAction3.context.getEvent()).isEqualTo(TestEvents.E1); + assertThat(eventCheckAction4.context).isNull(); + assertThat(eventCheckGuard.context.getEvent()).isEqualTo(TestEvents.E1); } @SuppressWarnings("unchecked") @@ -162,7 +158,7 @@ public class TransitionEventHeaderTests extends AbstractStateMachineTests { context.register(Config4.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); ObjectStateMachine machine = context.getBean( StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); @@ -175,19 +171,19 @@ public class TransitionEventHeaderTests extends AbstractStateMachineTests { machine.addStateListener(listener); machine.start(); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); listener.reset(2); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).setHeader("foo", "bar").build()); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(2)); - assertThat(machine.getState().getIds(), contains(TestStates.S4)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(2); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S4); - assertThat(eventCheckAction1.context.getEvent(), nullValue()); - assertThat(eventCheckAction2.context.getEvent(), is(TestEvents.E1)); - assertThat(eventCheckAction4.context.getEvent(), is(TestEvents.E1)); - assertThat(eventCheckGuard.context.getEvent(), is(TestEvents.E1)); - assertThat(eventCheckGuard.context.getMessageHeaders().get("foo", String.class), is("bar")); + assertThat(eventCheckAction1.context.getEvent()).isNull(); + assertThat(eventCheckAction2.context.getEvent()).isEqualTo(TestEvents.E1); + assertThat(eventCheckAction4.context.getEvent()).isEqualTo(TestEvents.E1); + assertThat(eventCheckGuard.context.getEvent()).isEqualTo(TestEvents.E1); + assertThat(eventCheckGuard.context.getMessageHeaders().get("foo", String.class)).isEqualTo("bar"); } @SuppressWarnings("unchecked") @@ -196,7 +192,7 @@ public class TransitionEventHeaderTests extends AbstractStateMachineTests { context.register(Config5.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); ObjectStateMachine machine = context.getBean( StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); @@ -209,20 +205,20 @@ public class TransitionEventHeaderTests extends AbstractStateMachineTests { machine.addStateListener(listener); machine.start(); - assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); listener.reset(3); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).setHeader("foo", "bar").build()); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(3)); - assertThat(machine.getState().getIds(), contains(TestStates.S2, TestStates.S212)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(3); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S2, TestStates.S212); - assertThat(eventCheckAction2.context.getEvent(), is(TestEvents.E1)); - assertThat(eventCheckAction20.context.getEvent(), is(TestEvents.E1)); - assertThat(eventCheckAction212.context.getEvent(), is(TestEvents.E1)); - assertThat(eventCheckGuard.context.getEvent(), is(TestEvents.E1)); - assertThat(eventCheckGuard.context.getMessageHeaders().get("foo", String.class), is("bar")); + assertThat(eventCheckAction2.context.getEvent()).isEqualTo(TestEvents.E1); + assertThat(eventCheckAction20.context.getEvent()).isEqualTo(TestEvents.E1); + assertThat(eventCheckAction212.context.getEvent()).isEqualTo(TestEvents.E1); + assertThat(eventCheckGuard.context.getEvent()).isEqualTo(TestEvents.E1); + assertThat(eventCheckGuard.context.getMessageHeaders().get("foo", String.class)).isEqualTo("bar"); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/transition/TransitionOrderTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/transition/TransitionOrderTests.java index e66add63..161b847e 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/transition/TransitionOrderTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/transition/TransitionOrderTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2017-2019 the original author or authors. + * Copyright 2017-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,8 +15,7 @@ */ package org.springframework.statemachine.transition; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.contains; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; import static org.springframework.statemachine.TestUtils.resolveMachine; @@ -59,11 +58,11 @@ public class TransitionOrderTests extends AbstractStateMachineTests { machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); - assertThat(listener.statesEntered, contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); + assertThat(listener.statesEntered).containsExactly(TestStates.S1); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(listener.statesEntered, contains(TestStates.S1, TestStates.S10, TestStates.S1011, TestStates.S1)); + assertThat(listener.statesEntered).containsExactly(TestStates.S1, TestStates.S10, TestStates.S1011, TestStates.S1); } @Test @@ -75,10 +74,10 @@ public class TransitionOrderTests extends AbstractStateMachineTests { machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(listener.statesEntered, contains(TestStates.S1, TestStates.S10, TestStates.S1011, TestStates.S1)); + assertThat(listener.statesEntered).containsExactly(TestStates.S1, TestStates.S10, TestStates.S1011, TestStates.S1); } @Test @@ -90,10 +89,10 @@ public class TransitionOrderTests extends AbstractStateMachineTests { machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(listener.statesEntered, contains(TestStates.S1, TestStates.S10, TestStates.S1011, TestStates.S1012, TestStates.S1)); + assertThat(listener.statesEntered).containsExactly(TestStates.S1, TestStates.S10, TestStates.S1011, TestStates.S1012, TestStates.S1); } @Test @@ -105,10 +104,10 @@ public class TransitionOrderTests extends AbstractStateMachineTests { machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(listener.statesEntered, contains(TestStates.S1, TestStates.S10, TestStates.S1011, TestStates.S1)); + assertThat(listener.statesEntered).containsExactly(TestStates.S1, TestStates.S10, TestStates.S1011, TestStates.S1); } @Test @@ -120,10 +119,10 @@ public class TransitionOrderTests extends AbstractStateMachineTests { machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(listener.statesEntered, contains(TestStates.S1, TestStates.S10, TestStates.S1011, TestStates.S1012)); + assertThat(listener.statesEntered).containsExactly(TestStates.S1, TestStates.S10, TestStates.S1011, TestStates.S1012); } @Test @@ -135,10 +134,10 @@ public class TransitionOrderTests extends AbstractStateMachineTests { machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(listener.statesEntered, contains(TestStates.S1, TestStates.S10, TestStates.S1011, TestStates.S1)); + assertThat(listener.statesEntered).containsExactly(TestStates.S1, TestStates.S10, TestStates.S1011, TestStates.S1); } @Test @@ -150,11 +149,10 @@ public class TransitionOrderTests extends AbstractStateMachineTests { machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(listener.statesEntered, - contains(TestStates.S1, TestStates.S10, TestStates.S1011, TestStates.S1012, TestStates.S2011, TestStates.S1)); + assertThat(listener.statesEntered).containsExactly(TestStates.S1, TestStates.S10, TestStates.S1011, TestStates.S1012, TestStates.S2011, TestStates.S1); } @Test @@ -166,11 +164,10 @@ public class TransitionOrderTests extends AbstractStateMachineTests { machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(listener.statesEntered, - contains(TestStates.S1, TestStates.S10, TestStates.S1011, TestStates.S1)); + assertThat(listener.statesEntered).containsExactly(TestStates.S1, TestStates.S10, TestStates.S1011, TestStates.S1); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/transition/TransitionTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/transition/TransitionTests.java index 53e7c11a..f149c0d4 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/transition/TransitionTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/transition/TransitionTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,12 +15,7 @@ */ package org.springframework.statemachine.transition; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.notNullValue; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.assertj.core.api.Assertions.assertThat; import java.util.Arrays; import java.util.Collection; @@ -69,7 +64,7 @@ public class TransitionTests extends AbstractStateMachineTests { context.register(Config1.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); @@ -77,13 +72,13 @@ public class TransitionTests extends AbstractStateMachineTests { machine.addStateListener(listener); machine.start(); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); listener.reset(2); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).build()); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(2)); - assertThat(machine.getState().getIds(), contains(TestStates.S3)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(2); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S3); } @SuppressWarnings({ "unchecked" }) @@ -91,11 +86,11 @@ public class TransitionTests extends AbstractStateMachineTests { public void testTriggerlessTransitionFromInitial() throws Exception { context.register(Config3.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); machine.start(); - assertThat(machine.getState().getIds(), contains(TestStates.S2)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S2); } @SuppressWarnings({ "unchecked" }) @@ -104,15 +99,15 @@ public class TransitionTests extends AbstractStateMachineTests { context.register(Config4.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); machine.start(); // end state terminates sm so check machine still gives it - assertThat(machine.getState(), notNullValue()); - assertThat(machine.getState().getIds(), contains(TestStates.SF)); - assertThat(machine.isComplete(), is(true)); - assertThat(machine.isRunning(), is(false)); + assertThat(machine.getState()).isNotNull(); + assertThat(machine.getState().getIds()).containsExactly(TestStates.SF); + assertThat(machine.isComplete()).isTrue(); + assertThat(machine.isRunning()).isFalse(); } @SuppressWarnings({ "unchecked" }) @@ -125,21 +120,21 @@ public class TransitionTests extends AbstractStateMachineTests { TestAction testAction20 = context.getBean("testAction20", TestAction.class); TestAction testAction21 = context.getBean("testAction21", TestAction.class); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); machine.start(); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).build()); - assertThat(testAction1.onExecuteLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(testAction1.stateContexts.size(), is(1)); - assertThat(testAction20.onExecuteLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(testAction20.stateContexts.size(), is(1)); - assertThat(testAction21.onExecuteLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(testAction21.stateContexts.size(), is(1)); + assertThat(testAction1.onExecuteLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(testAction1.stateContexts).hasSize(1); + assertThat(testAction20.onExecuteLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(testAction20.stateContexts).hasSize(1); + assertThat(testAction21.onExecuteLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(testAction21.stateContexts).hasSize(1); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S201, TestStates.S211)); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S201, TestStates.S211); } @SuppressWarnings({ "unchecked" }) @@ -147,13 +142,13 @@ public class TransitionTests extends AbstractStateMachineTests { public void testTriggerlessTransitionInRegions() throws Exception { context.register(Config6.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); machine.start(); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).build()); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S201, TestStates.S211)); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S2, TestStates.S201, TestStates.S211); } @SuppressWarnings({ "unchecked" }) @@ -161,7 +156,7 @@ public class TransitionTests extends AbstractStateMachineTests { public void testInternalTransition() throws Exception { context.register(Config2.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); machine.start(); @@ -170,28 +165,28 @@ public class TransitionTests extends AbstractStateMachineTests { TestAction externalTestAction = context.getBean("externalTestAction", TestAction.class); TestAction internalTestAction = context.getBean("internalTestAction", TestAction.class); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); - assertThat(testExitAction.onExecuteLatch.await(1, TimeUnit.SECONDS), is(false)); - assertThat(testEntryAction.onExecuteLatch.await(1, TimeUnit.SECONDS), is(false)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); + assertThat(testExitAction.onExecuteLatch.await(1, TimeUnit.SECONDS)).isFalse(); + assertThat(testEntryAction.onExecuteLatch.await(1, TimeUnit.SECONDS)).isFalse(); machine.sendEvent(TestEvents.E1); - assertThat(testExitAction.onExecuteLatch.await(1, TimeUnit.SECONDS), is(false)); - assertThat(testEntryAction.onExecuteLatch.await(1, TimeUnit.SECONDS), is(false)); - assertThat(internalTestAction.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); + assertThat(testExitAction.onExecuteLatch.await(1, TimeUnit.SECONDS)).isFalse(); + assertThat(testEntryAction.onExecuteLatch.await(1, TimeUnit.SECONDS)).isFalse(); + assertThat(internalTestAction.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); machine.sendEvent(TestEvents.E2); - assertThat(testExitAction.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(testEntryAction.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); - assertThat(externalTestAction.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); + assertThat(testExitAction.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(testEntryAction.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); + assertThat(externalTestAction.onExecuteLatch.await(1, TimeUnit.SECONDS)).isTrue(); - assertThat(machine.getState().getIds(), contains(TestStates.S2)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S2); } @Test public void testTransitDirectlyToSubstateSkipInitial() throws InterruptedException { context.register(Config7.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); @@ -200,22 +195,22 @@ public class TransitionTests extends AbstractStateMachineTests { listener.reset(2); machine.start(); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(2)); - assertThat(machine.getState().getIds(), contains(TestStates2.IDLE, TestStates2.CLOSED)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(2); + assertThat(machine.getState().getIds()).containsExactly(TestStates2.IDLE, TestStates2.CLOSED); listener.reset(0, 2); machine.sendEvent(TestEvents2.PAUSE); - assertThat(listener.stateEnteredLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateEnteredCount, is(3)); - assertThat(machine.getState().getIds(), contains(TestStates2.BUSY, TestStates2.PAUSED)); + assertThat(listener.stateEnteredLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateEnteredCount).isEqualTo(3); + assertThat(machine.getState().getIds()).containsExactly(TestStates2.BUSY, TestStates2.PAUSED); } @Test public void testTransitDeepDirectlyToSubstateSkipInitial() throws InterruptedException { context.register(Config8.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); @SuppressWarnings("unchecked") ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); @@ -224,15 +219,15 @@ public class TransitionTests extends AbstractStateMachineTests { listener.reset(2); machine.start(); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(2)); - assertThat(machine.getState().getIds(), contains(TestStates2.IDLE, TestStates2.CLOSED)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(2); + assertThat(machine.getState().getIds()).containsExactly(TestStates2.IDLE, TestStates2.CLOSED); listener.reset(0, 3); machine.sendEvent(TestEvents2.PAUSE); - assertThat(listener.stateEnteredLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateEnteredCount, is(3)); - assertThat(machine.getState().getIds(), contains(TestStates2.BUSY, TestStates2.PAUSED, TestStates2.PAUSED2)); + assertThat(listener.stateEnteredLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateEnteredCount).isEqualTo(3); + assertThat(machine.getState().getIds()).containsExactly(TestStates2.BUSY, TestStates2.PAUSED, TestStates2.PAUSED2); } @SuppressWarnings("unchecked") @@ -241,7 +236,7 @@ public class TransitionTests extends AbstractStateMachineTests { context.register(Config9.class); context.refresh(); - assertTrue(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)); + assertThat(context.containsBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE)).isTrue(); ObjectStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class); HeaderTestAction testAction1 = context.getBean("testAction1", HeaderTestAction.class); @@ -252,16 +247,16 @@ public class TransitionTests extends AbstractStateMachineTests { machine.addStateListener(listener); machine.start(); - assertThat(machine.getState().getIds(), contains(TestStates.S1)); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S1); listener.reset(4); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).setHeader("testHeader", "testValue").build()); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(4)); - assertThat(machine.getState().getIds(), contains(TestStates.S2, TestStates.S212)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(4); + assertThat(machine.getState().getIds()).containsExactly(TestStates.S2, TestStates.S212); - assertThat(testAction1.testHeader, is("testValue")); - assertThat(testAction2.testHeader, is("testValue")); + assertThat(testAction1.testHeader).isEqualTo("testValue"); + assertThat(testAction2.testHeader).isEqualTo("testValue"); } @Configuration diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/trigger/TimerTriggerTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/trigger/TimerTriggerTests.java index db7faa02..87c71530 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/trigger/TimerTriggerTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/trigger/TimerTriggerTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,12 +15,7 @@ */ package org.springframework.statemachine.trigger; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.greaterThan; -import static org.hamcrest.Matchers.notNullValue; -import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.assertj.core.api.Assertions.assertThat; import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll; import static org.springframework.statemachine.TestUtils.doStartAndAssert; import static org.springframework.statemachine.TestUtils.resolveMachine; @@ -62,8 +57,8 @@ public class TimerTriggerTests extends AbstractStateMachineTests { final int count = 1; @SuppressWarnings("rawtypes") final TimerTrigger timerTrigger = new TimerTrigger(period, count); - assertEquals(period, timerTrigger.getPeriod()); - assertEquals(count, timerTrigger.getCount()); + assertThat(period).isEqualTo(timerTrigger.getPeriod()); + assertThat(count).isEqualTo(timerTrigger.getCount()); } @Test @@ -84,7 +79,7 @@ public class TimerTriggerTests extends AbstractStateMachineTests { timerTrigger.afterPropertiesSet(); timerTrigger.start(); - assertThat(latch.await(1, TimeUnit.SECONDS), is(true)); + assertThat(latch.await(1, TimeUnit.SECONDS)).isTrue(); } @Test @@ -97,18 +92,18 @@ public class TimerTriggerTests extends AbstractStateMachineTests { machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S1)); + assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S1); listener.reset(1); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(listener.stateChangedLatch.await(2100, TimeUnit.MILLISECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S2)); + assertThat(listener.stateChangedLatch.await(2100, TimeUnit.MILLISECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S2); Thread.sleep(1000); // we should have 100, just test 80 due to timing - assertThat(action.count, greaterThan(80)); + assertThat(action.count).isGreaterThan(80); } @Test @@ -121,18 +116,18 @@ public class TimerTriggerTests extends AbstractStateMachineTests { machine.addStateListener(listener); doStartAndAssert(machine); - assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), containsInAnyOrder("READY")); + assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsOnly("READY"); for (int i = 0; i < 4; i++) { listener.reset(2); action.reset(); doSendEventAndConsumeAll(machine, "SWITCH_TO_RUNNING"); - assertThat(action.latch.await(5, TimeUnit.SECONDS), is(true)); - assertThat(action.count, is(1)); - assertThat(listener.stateChangedLatch.await(5, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(2)); - assertThat(machine.getState().getIds(), containsInAnyOrder("RUNNING_TESTING")); + assertThat(action.latch.await(5, TimeUnit.SECONDS)).isTrue(); + assertThat(action.count).isEqualTo(1); + assertThat(listener.stateChangedLatch.await(5, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(2); + assertThat(machine.getState().getIds()).containsOnly("RUNNING_TESTING"); } } @@ -165,30 +160,30 @@ public class TimerTriggerTests extends AbstractStateMachineTests { continue; } } - assertThat(trigger, notNullValue()); + assertThat(trigger).isNotNull(); TestTriggerListener tlistener = new TestTriggerListener(); trigger.addTriggerListener(tlistener); doStartAndAssert(machine); - assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S1)); + assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S1); - assertThat(tlistener.latch.await(2, TimeUnit.SECONDS), is(false)); + assertThat(tlistener.latch.await(2, TimeUnit.SECONDS)).isFalse(); listener.reset(1); doSendEventAndConsumeAll(machine, TestEvents.E1); - assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener.stateChangedCount, is(1)); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S2)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.stateChangedCount).isEqualTo(1); + assertThat(machine.getState().getIds()).containsOnly(TestStates.S2); - assertThat(tlistener.latch.await(1, TimeUnit.SECONDS), is(false)); - assertThat(tlistener.count.get(), is(0)); - assertThat(tlistener.latch.await(4, TimeUnit.SECONDS), is(true)); - assertThat(tlistener.count.get(), is(1)); + assertThat(tlistener.latch.await(1, TimeUnit.SECONDS)).isFalse(); + assertThat(tlistener.count.get()).isZero(); + assertThat(tlistener.latch.await(4, TimeUnit.SECONDS)).isTrue(); + assertThat(tlistener.count.get()).isEqualTo(1); - assertThat(action.latch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(action.latch.await(2, TimeUnit.SECONDS)).isTrue(); action.reset(1); - assertThat(action.latch.await(2, TimeUnit.SECONDS), is(false)); + assertThat(action.latch.await(2, TimeUnit.SECONDS)).isFalse(); } static class Config1 { diff --git a/spring-statemachine-data/src/test/java/org/springframework/statemachine/data/AbstractRepositoryTests.java b/spring-statemachine-data/src/test/java/org/springframework/statemachine/data/AbstractRepositoryTests.java index 3fb860a9..48c91962 100644 --- a/spring-statemachine-data/src/test/java/org/springframework/statemachine/data/AbstractRepositoryTests.java +++ b/spring-statemachine-data/src/test/java/org/springframework/statemachine/data/AbstractRepositoryTests.java @@ -16,7 +16,6 @@ package org.springframework.statemachine.data; import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.Iterator; import java.util.Map; @@ -441,14 +440,14 @@ public abstract class AbstractRepositoryTests { StateMachine stateMachine = stateMachineFactory.getStateMachine(); Map> states = stateMachine.getStates().stream().collect(Collectors.toMap((State s1) -> s1.getId(), s2 -> s2)); - assertEquals(2, states.size()); + assertThat(states.size()).isEqualTo(2); State S1 = (State) states.get("S1"); - assertEquals(1, S1.getExitActions().size()); + assertThat(S1.getExitActions().size()).isEqualTo(1); State S2 = (State)states.get("S2"); - assertEquals(1, S2.getEntryActions().size()); - assertEquals(1, S2.getStateActions().size()); + assertThat(S2.getEntryActions().size()).isEqualTo(1); + assertThat(S2.getStateActions().size()).isEqualTo(1); } @Configuration diff --git a/spring-statemachine-zookeeper/src/test/java/org/springframework/statemachine/zookeeper/ZookeeperStateMachineEnsembleTests.java b/spring-statemachine-zookeeper/src/test/java/org/springframework/statemachine/zookeeper/ZookeeperStateMachineEnsembleTests.java index 8d307430..e4445117 100644 --- a/spring-statemachine-zookeeper/src/test/java/org/springframework/statemachine/zookeeper/ZookeeperStateMachineEnsembleTests.java +++ b/spring-statemachine-zookeeper/src/test/java/org/springframework/statemachine/zookeeper/ZookeeperStateMachineEnsembleTests.java @@ -16,7 +16,7 @@ package org.springframework.statemachine.zookeeper; import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.assertj.core.api.Assertions.assertThatThrownBy; import java.util.ArrayList; import java.util.Collection; @@ -229,8 +229,9 @@ public class ZookeeperStateMachineEnsembleTests extends AbstractZookeeperTests { @Test public void testIllegalLogSize() throws Exception { - assertThrows(IllegalStateException.class, - () -> new ZookeeperStateMachineEnsemble(null, "/foo", true, 3)); + assertThatThrownBy(() -> { + new ZookeeperStateMachineEnsemble(null, "/foo", true, 3); + }).isInstanceOf(IllegalStateException.class); } @Test