Spring/spring-statemachine
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Port core tests to assertj

Browse Source
This commit is contained in:
Janne Valkealahti
2020-11-28 17:51:15 +00:00
parent 20daa7cc2d
commit 89afd543f4
97 changed files with 2449 additions and 2683 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
build.gradle
View File

@@ -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'
}

25
spring-statemachine-core/src/test/java/org/springframework/statemachine/EnumStateMachineTests.java
View File

@@ -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<TestStates,TestEvents> initialState = machine.getInitialState();
assertThat(initialState, is(stateSI));
assertThat(initialState).isEqualTo(stateSI);
State<TestStates,TestEvents> 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<TestStates,TestEvents> initialState = machine.getInitialState();
assertThat(initialState, is(stateSI));
assertThat(initialState).isEqualTo(stateSI);
State<TestStates,TestEvents> 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

88
spring-statemachine-core/src/test/java/org/springframework/statemachine/EventDeferTests.java
View File

@@ -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<String, String> machine = resolveMachine(context);
doStartAndAssert(machine);
assertThat(machine.getState().getIds(), contains("S1"));
assertThat(machine.getState().getIds()).containsExactly("S1");
AtomicReference<Throwable> 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<String, String> 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

218
spring-statemachine-core/src/test/java/org/springframework/statemachine/EventHeaderTests.java
View File

@@ -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

141
spring-statemachine-core/src/test/java/org/springframework/statemachine/RegionMachineTests.java
View File

@@ -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<TestStates,TestEvents> state = new RegionState<TestStates,TestEvents>(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<TestStates,TestEvents> 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<TestStates,TestEvents> machine =
context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class);
assertThat(machine, notNullValue());
assertThat(machine).isNotNull();
Collection<Object> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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

13
spring-statemachine-core/src/test/java/org/springframework/statemachine/RelayTests.java
View File

@@ -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<TestStates, TestEvents> 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

182
spring-statemachine-core/src/test/java/org/springframework/statemachine/StateContextTests.java
View File

@@ -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<States, Events> {
@@ -194,15 +187,6 @@ public class StateContextTests extends AbstractStateMachineTests {
}
}
private static Matcher<StateContext<?, ?>> hasStage(final Stage stage) {
return new FeatureMatcher<StateContext<?, ?>, Stage>(equalTo(stage), "stage", "stage") {
@Override
protected Stage featureValueOf(final StateContext<?, ?> actual) {
return actual.getStage();
}
};
}
@Configuration
@EnableStateMachine
static class Config1 extends EnumStateMachineConfigurerAdapter<States, Events> {

35
spring-statemachine-core/src/test/java/org/springframework/statemachine/StateMachineFactoryTests.java
View File

@@ -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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates, TestEvents> stateMachineFactory = resolveFactory(context);
StateMachine<TestStates,TestEvents> 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<TestStates, TestEvents> stateMachineFactory = resolveFactory(context);
StateMachine<TestStates,TestEvents> 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<TestStates,TestEvents> 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

115
spring-statemachine-core/src/test/java/org/springframework/statemachine/StateMachineResetTests.java
View File

@@ -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<States, Events> 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<Object, Object> variables = new HashMap<Object, Object>();
@@ -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<States, Events> 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<States, Events> 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<States, Events> stateMachineContext = new DefaultStateMachineContext<States, Events>(
@@ -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<Object, Object> variables = new HashMap<Object, Object>();
@@ -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

91
spring-statemachine-core/src/test/java/org/springframework/statemachine/StateMachineTests.java
View File

@@ -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<TestStates, TestEvents> 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<String, String> 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<TestStates, TestEvents> 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<TestStates, TestEvents> {

120
spring-statemachine-core/src/test/java/org/springframework/statemachine/SubStateMachineTests.java
View File

@@ -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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates2,TestEvents2> 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

9
spring-statemachine-core/src/test/java/org/springframework/statemachine/access/StateMachineAccessTests.java
View File

@@ -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<String, String> 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<String, String> 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<String, String>, StateMachineAccess<String, String> {

23
spring-statemachine-core/src/test/java/org/springframework/statemachine/action/ActionAndTimerTests.java
View File

@@ -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

14
spring-statemachine-core/src/test/java/org/springframework/statemachine/action/ActionErrorTests.java
View File

@@ -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<TestStates,TestEvents> 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<TestStates,TestEvents> 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

69
spring-statemachine-core/src/test/java/org/springframework/statemachine/action/ActionTests.java
View File

@@ -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

13
spring-statemachine-core/src/test/java/org/springframework/statemachine/action/DistributedLeaderActionTests.java
View File

@@ -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<String, String> 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

21
spring-statemachine-core/src/test/java/org/springframework/statemachine/action/ReactiveActionTests.java
View File

@@ -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

10
spring-statemachine-core/src/test/java/org/springframework/statemachine/action/SpelExpressionActionTests.java
View File

@@ -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();
}

68
spring-statemachine-core/src/test/java/org/springframework/statemachine/action/StateDoActivityActionTests.java
View File

@@ -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<TestStates, TestEvents> 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<TestStates, TestEvents> 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<TestStates, TestEvents> 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<TestEvents> 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<TestEvents> 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

25
spring-statemachine-core/src/test/java/org/springframework/statemachine/annotation/ClassAnnotationTests.java
View File

@@ -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<TestStates,TestEvents> 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<TestStates,TestEvents> 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();
}

173
spring-statemachine-core/src/test/java/org/springframework/statemachine/annotation/MethodAnnotationTests.java
View File

@@ -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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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

30
spring-statemachine-core/src/test/java/org/springframework/statemachine/annotation/MethodAnnotationWithBuilderTests.java
View File

@@ -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<TestStates, TestEvents> 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<TestStates, TestEvents> 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<TestStates, TestEvents> 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<TestStates, TestEvents> 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")

12
spring-statemachine-core/src/test/java/org/springframework/statemachine/annotation/MethodAnnotationWithFactoryTests.java
View File

@@ -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<TestStates,TestEvents> 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")

34
spring-statemachine-core/src/test/java/org/springframework/statemachine/config/ConfigurationErrorTests.java
View File

@@ -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<String, String> 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<String, String> 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<String, String> 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

84
spring-statemachine-core/src/test/java/org/springframework/statemachine/config/ConfigurationTests.java
View File

@@ -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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<String, String> 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<String, String> stateMachineFactory = context.getBean(StateMachineFactory.class);
StateMachine<String,String> 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<String, String> machine =
context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class);
Collection<State<String, String>> states = machine.getStates();
for (State<String, String> 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<String, String> stateMachineFactory22 = context.getBean("stateMachineConfig22", StateMachineFactory.class);
StateMachine<String,String> stateMachine22 = stateMachineFactory22.getStateMachine();
assertThat(stateMachine22, notNullValue());
assertThat(stateMachine22).isNotNull();
}

43
spring-statemachine-core/src/test/java/org/springframework/statemachine/config/MachineTypedTests.java
View File

@@ -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

26
spring-statemachine-core/src/test/java/org/springframework/statemachine/config/ManualBuilderContextTests.java
View File

@@ -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<String, String> 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<String, String> 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

47
spring-statemachine-core/src/test/java/org/springframework/statemachine/config/ManualBuilderTests.java
View File

@@ -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<String, String> 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<MyStates, MyEvents> 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<String, String> 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 {

26
spring-statemachine-core/src/test/java/org/springframework/statemachine/config/SessionScopedAnnotationTests.java
View File

@@ -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.<Boolean>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.<Boolean>callMethod("isRunning", machine)).isTrue();
session1.invalidate();
assertThat(TestUtils.callMethod("isRunning", machine), is(false));
assertThat(TestUtils.<Boolean>callMethod("isRunning", machine)).isFalse();
}
@Configuration

26
spring-statemachine-core/src/test/java/org/springframework/statemachine/config/SessionScopedManualTests.java
View File

@@ -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.<Boolean>callMethod("isRunning", machine)).isTrue();
session1.invalidate();
assertThat(TestUtils.callMethod("isRunning", machine), is(false));
assertThat(TestUtils.<Boolean>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.<Boolean>callMethod("isRunning", machine)).isTrue();
}
@Configuration

44
spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/ComplexAnnotationConfigurationTests.java
View File

@@ -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<Resource> 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

7
spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/ImportingBeanDefinitionTests.java
View File

@@ -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();
}

39
spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/MixedAnnotationConfigurationTests.java
View File

@@ -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");
}

33
spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/MultipleAnnotationConfigurationTests.java
View File

@@ -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");
}

39
spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/SimpleAnnotationConfiguration2Tests.java
View File

@@ -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<Resource> 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

43
spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/SimpleAnnotationConfigurationTests.java
View File

@@ -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<Resource> 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

18
spring-statemachine-core/src/test/java/org/springframework/statemachine/config/common/annotation/XmlImportDependenciesTests.java
View File

@@ -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

107
spring-statemachine-core/src/test/java/org/springframework/statemachine/config/configurers/DefaultStateConfigurerTests.java
View File

@@ -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<TestStates, TestEvents> {

26
spring-statemachine-core/src/test/java/org/springframework/statemachine/config/model/StateMachineModelFactoryTests.java
View File

@@ -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<String,String> 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<String, String> 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

22
spring-statemachine-core/src/test/java/org/springframework/statemachine/config/model/StateMachineModelTests.java
View File

@@ -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<String,String> 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<String,String> 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<String,String> 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");
}
}

18
spring-statemachine-core/src/test/java/org/springframework/statemachine/docs/DocsConfigurationSampleTests10.java
View File

@@ -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<String, String> 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<String, String> 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

45
spring-statemachine-core/src/test/java/org/springframework/statemachine/docs/DocsConfigurationSampleTests2.java
View File

@@ -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[]

9
spring-statemachine-core/src/test/java/org/springframework/statemachine/docs/DocsConfigurationSampleTests5.java
View File

@@ -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[]
}

9
spring-statemachine-core/src/test/java/org/springframework/statemachine/docs/DocsConfigurationSampleTests6.java
View File

@@ -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<String, String> 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");
}
}

11
spring-statemachine-core/src/test/java/org/springframework/statemachine/docs/IntroSample.java
View File

@@ -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<States, Events> 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<States, Events> buildMachine() throws Exception {

17
spring-statemachine-core/src/test/java/org/springframework/statemachine/ensemble/DistributedStateMachineTests.java
View File

@@ -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<String, String> machine2s =
new DistributedStateMachine<String, String>(ensemble, machine2);
machine2s.afterPropertiesSet();
machine2s.start();
assertThat(machine2.getState().getIds(), containsInAnyOrder("S1"));
assertThat(machine2.getState().getIds()).containsOnly("S1");
}
@Configuration

14
spring-statemachine-core/src/test/java/org/springframework/statemachine/event/ContextEventTests.java
View File

@@ -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

117
spring-statemachine-core/src/test/java/org/springframework/statemachine/event/StateMachineEventTests.java
View File

@@ -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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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

35
spring-statemachine-core/src/test/java/org/springframework/statemachine/guard/GuardTests.java
View File

@@ -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<TestStates,TestEvents> 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();
}

15
spring-statemachine-core/src/test/java/org/springframework/statemachine/guard/SpelExpressionGuardTests.java
View File

@@ -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<TestStates, TestEvents> stateContext = new DefaultStateContext<TestStates, TestEvents>(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<TestStates,TestEvents> 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();
}

11
spring-statemachine-core/src/test/java/org/springframework/statemachine/listener/CompositeStateMachineListenerTests.java
View File

@@ -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<StateMachineListener<String, String>> listeners = listener.getListeners();
List<Object> 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<StateMachineListener<String, String>> listeners = listener.getListeners();
List<Object> list = TestUtils.readField("list", listeners);
assertThat(list.size(), is(0));
assertThat(list).isEmpty();
}
}

44
spring-statemachine-core/src/test/java/org/springframework/statemachine/listener/ListenerTests.java
View File

@@ -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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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();
}

22
spring-statemachine-core/src/test/java/org/springframework/statemachine/monitor/StateMachineMonitorTests.java
View File

@@ -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<String, String> taction = context.getBean("taction", Action.class);
// Action<String, String> enaction = context.getBean("enaction", Action.class);
// Action<String, String> 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

117
spring-statemachine-core/src/test/java/org/springframework/statemachine/persist/DefaultStateMachinePersisterTests.java
View File

@@ -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<String, String, String> persister = new DefaultStateMachinePersister<>(persist);
persister.persist(machine, "xxx");
StateMachineContext<String, String> 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<String, String, String> persister = new DefaultStateMachinePersister<>(persist);
persister.persist(machine, "xxx");
StateMachineContext<String, String> 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<String, String, String> persister = new DefaultStateMachinePersister<>(persist);
persister.persist(machine, "xxx");
StateMachineContext<String, String> 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<String, String, String> persister = new DefaultStateMachinePersister<>(persist);
persister.persist(machine, "xxx");
StateMachineContext<String, String> 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<String, String> buildSimpleFlat() throws Exception {

118
spring-statemachine-core/src/test/java/org/springframework/statemachine/persist/StateMachinePersistTests.java
View File

@@ -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<String, String, String> 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<TestStates, TestEvents> 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<TestStates, TestEvents, String> 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<String, String> 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<String, String, String> 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<String, String> 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<String, String, String> 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<String, String> 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<String, String> stateMachineFactory = resolveFactory(context);
StateMachine<String,String> 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<String, String> 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<String, String, String> 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

34
spring-statemachine-core/src/test/java/org/springframework/statemachine/persist/StateMachinePersistTests2.java
View File

@@ -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<String, String> factory = resolveFactory("LOG_RECORD", context);
StateMachine<String,String> 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");
}

37
spring-statemachine-core/src/test/java/org/springframework/statemachine/persist/StateMachinePersistTests3.java
View File

@@ -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<String, String> stateMachineFactory = context.getBean(StateMachineFactory.class);
StateMachine<String,String> 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<String, String> stateMachineFactory = context.getBean(StateMachineFactory.class);
StateMachine<String,String> 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<String, String, String> persister = new DefaultStateMachinePersister<>(stateMachinePersist);
@SuppressWarnings("unchecked")
StateMachine<String,String> 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

237
spring-statemachine-core/src/test/java/org/springframework/statemachine/persist/StateMachinePersistTests4.java
View File

@@ -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<TestStates, TestEvents> 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);
}
}
}

96
spring-statemachine-core/src/test/java/org/springframework/statemachine/processor/AnnotatedMethodTests.java
View File

@@ -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

17
spring-statemachine-core/src/test/java/org/springframework/statemachine/processor/MethodParameterTests.java
View File

@@ -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<String, Object> 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();
}
}

9
spring-statemachine-core/src/test/java/org/springframework/statemachine/processor/StateMachineAnnotationPostProcessorTests.java
View File

@@ -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

40
spring-statemachine-core/src/test/java/org/springframework/statemachine/security/AbstractSecurityTests.java
View File

@@ -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<States, Events> 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<States, Events> 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<States, Events> 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 {

34
spring-statemachine-core/src/test/java/org/springframework/statemachine/security/ActionSecurityTests.java
View File

@@ -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

85
spring-statemachine-core/src/test/java/org/springframework/statemachine/security/SecurityConfigTests.java
View File

@@ -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<String, String> machine =
context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class);
assertThat(machine, notNullValue());
assertThat(machine).isNotNull();
StateMachineInterceptorList<?, ?> ilist = TestUtils.readField("interceptors", machine);
List<StateMachineInterceptor<?, ?>> 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<String, String> machine =
context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class);
assertThat(machine, notNullValue());
assertThat(machine).isNotNull();
StateMachineInterceptorList<?, ?> ilist = TestUtils.readField("interceptors", machine);
List<StateMachineInterceptor<?, ?>> 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<String, String> machine =
context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class);
assertThat(machine, notNullValue());
assertThat(machine).isNotNull();
StateMachineInterceptorList<?, ?> ilist = TestUtils.readField("interceptors", machine);
List<StateMachineInterceptor<?, ?>> 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<String, String> machine =
context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class);
assertThat(machine, notNullValue());
assertThat(machine).isNotNull();
StateMachineInterceptorList<?, ?> ilist = TestUtils.readField("interceptors", machine);
List<StateMachineInterceptor<?, ?>> 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<String, String> machine =
context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class);
assertThat(machine, notNullValue());
assertThat(machine).isNotNull();
StateMachineInterceptorList<?, ?> ilist = TestUtils.readField("interceptors", machine);
List<StateMachineInterceptor<?, ?>> 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<String, String> machine =
context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class);
assertThat(machine, notNullValue());
assertThat(machine).isNotNull();
Transition<String, String> 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<String, String> machine =
context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class);
assertThat(machine, notNullValue());
assertThat(machine).isNotNull();
Transition<String, String> 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<String, String> machine =
context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class);
assertThat(machine, notNullValue());
assertThat(machine).isNotNull();
StateMachineInterceptorList<?, ?> ilist = TestUtils.readField("interceptors", machine);
List<StateMachineInterceptor<?, ?>> 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

15
spring-statemachine-core/src/test/java/org/springframework/statemachine/security/SecurityRuleTests.java
View File

@@ -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<String> attributes = new ArrayList<String>();
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<String> 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();
}
}

23
spring-statemachine-core/src/test/java/org/springframework/statemachine/security/TransitionSecurityExpressionRootTests.java
View File

@@ -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();
}
}

30
spring-statemachine-core/src/test/java/org/springframework/statemachine/security/TransitionSecurityExpressionTests.java
View File

@@ -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<States, Events> 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<States, Events> 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

25
spring-statemachine-core/src/test/java/org/springframework/statemachine/service/DefaultStateMachineServiceTests.java
View File

@@ -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<TestStates, TestEvents> service = new DefaultStateMachineService<>(stateMachineFactory);
StateMachine<TestStates,TestEvents> 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<TestStates, TestEvents> service = new DefaultStateMachineService<>(stateMachineFactory);
StateMachine<TestStates,TestEvents> 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<TestStates, TestEvents> service = new DefaultStateMachineService<>(stateMachineFactory);
StateMachine<TestStates,TestEvents> 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<TestStates, TestEvents> service = new DefaultStateMachineService<>(stateMachineFactory);
StateMachine<TestStates,TestEvents> 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<TestStates, TestEvents> service = new DefaultStateMachineService<>(stateMachineFactory);
StateMachine<TestStates,TestEvents> machine1 = service.acquireStateMachine("m1", false);
StateMachine<TestStates,TestEvents> 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

67
spring-statemachine-core/src/test/java/org/springframework/statemachine/state/ChoiceStateTests.java
View File

@@ -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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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

43
spring-statemachine-core/src/test/java/org/springframework/statemachine/state/CompletionEventTests.java
View File

@@ -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<String,String> 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<String,String> 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<String,String> 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<String,String> 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<String,String> 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<String,String> 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

111
spring-statemachine-core/src/test/java/org/springframework/statemachine/state/EndStateTests.java
View File

@@ -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<TestStates,TestEvents> 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<TestStates3,TestEvents> 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<TestStates3,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates4,TestEvents> 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<TestStates4,TestEvents> 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<TestStates4,TestEvents> 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

13
spring-statemachine-core/src/test/java/org/springframework/statemachine/state/EnumStateTests.java
View File

@@ -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<TestStates,TestEvents> stateSI = new EnumState<TestStates,TestEvents>(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();
}
}

40
spring-statemachine-core/src/test/java/org/springframework/statemachine/state/ExitEntryStateTests.java
View File

@@ -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<String, String> 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<String, String> 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<String, String> 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

68
spring-statemachine-core/src/test/java/org/springframework/statemachine/state/ForkStateTests.java
View File

@@ -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

40
spring-statemachine-core/src/test/java/org/springframework/statemachine/state/HistoryStateTests.java
View File

@@ -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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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

23
spring-statemachine-core/src/test/java/org/springframework/statemachine/state/InitialStateTests.java
View File

@@ -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<TestStates,TestEvents> 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<TestStates,TestEvents> 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

41
spring-statemachine-core/src/test/java/org/springframework/statemachine/state/JoinPseudoStateTests.java
View File

@@ -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<List<State<String, String>>> track = (List<List<State<String, String>>>) 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<List<State<String, String>>> track = (List<List<State<String, String>>>) 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);
}
}

200
spring-statemachine-core/src/test/java/org/springframework/statemachine/state/JoinStateTests.java
View File

@@ -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

51
spring-statemachine-core/src/test/java/org/springframework/statemachine/state/JunctionStateTests.java
View File

@@ -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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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

16
spring-statemachine-core/src/test/java/org/springframework/statemachine/state/RegionStateTests.java
View File

@@ -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<TestStates,TestEvents> state = new RegionState<TestStates,TestEvents>(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);

27
spring-statemachine-core/src/test/java/org/springframework/statemachine/state/StateActionTests.java
View File

@@ -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();
}

26
spring-statemachine-core/src/test/java/org/springframework/statemachine/state/SubmachineRefEnumTests.java
View File

@@ -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<TestStates, TestEvents> 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<Object, Object> 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

26
spring-statemachine-core/src/test/java/org/springframework/statemachine/state/SubmachineRefTests.java
View File

@@ -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<String, String> 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<String, String> factory = resolveFactory(context);
StateMachine<String, String> 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

51
spring-statemachine-core/src/test/java/org/springframework/statemachine/state/SubmachineStateTests.java
View File

@@ -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<TestStates,TestEvents> state = new StateMachineState<TestStates,TestEvents>(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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates, TestEvents> s = machine.getState();
StateMachine<TestStates, TestEvents> m = ((StateMachineState<TestStates, TestEvents>) s).getSubmachine();
boolean r = TestUtils.callMethod("isRunning", m);
assertThat(r, is(true));
assertThat(r).isTrue();
s = m.getState();
m = ((StateMachineState<TestStates, TestEvents>) 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<TestStates,TestEvents> 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<TestStates, TestEvents> s = machine.getState();
StateMachine<TestStates, TestEvents> m = ((StateMachineState<TestStates, TestEvents>) s).getSubmachine();
boolean r = TestUtils.callMethod("isRunning", m);
assertThat(r, is(true));
assertThat(r).isTrue();
s = m.getState();
m = ((StateMachineState<TestStates, TestEvents>) 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<TestStates,TestEvents> 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<TestStates, TestEvents> s1 = machine.getState();
StateMachine<TestStates, TestEvents> m1 = ((StateMachineState<TestStates, TestEvents>) 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

13
spring-statemachine-core/src/test/java/org/springframework/statemachine/support/DefaultStateMachineContextTests.java
View File

@@ -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<String, String> c2 = new DefaultStateMachineContext<String, String>(null, null, null,
null);
assertThat(c1.equals(c2), is(true));
assertThat(c1.equals(c2)).isTrue();
DefaultStateMachineContext<String, String> c0 = new DefaultStateMachineContext<String, String>(null, null, null,
null);
@@ -41,10 +40,10 @@ public class DefaultStateMachineContextTests {
new HashMap<>(), new DefaultExtendedState(), new HashMap<>(), "id");
c2 = new DefaultStateMachineContext<String, String>(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<String, String>(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();
}
}

15
spring-statemachine-core/src/test/java/org/springframework/statemachine/support/LifecycleObjectSupportTests.java
View File

@@ -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 {

37
spring-statemachine-core/src/test/java/org/springframework/statemachine/support/ReactiveLifecycleManagerTests.java
View File

@@ -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<Mono<Void>> {

254
spring-statemachine-core/src/test/java/org/springframework/statemachine/support/StateChangeInterceptorTests.java
View File

@@ -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

25
spring-statemachine-core/src/test/java/org/springframework/statemachine/support/StateContextExpressionMethodsTests.java
View File

@@ -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<SpelStates, SpelEvents> 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<SpelStates, SpelEvents> 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 {

29
spring-statemachine-core/src/test/java/org/springframework/statemachine/support/TransitionComparatorTests.java
View File

@@ -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<TestStates, TestEvents>(TestEvents.E1));
TransitionComparator<TestStates, TestEvents> 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();
}
}

122
spring-statemachine-core/src/test/java/org/springframework/statemachine/transition/LocalTransitionTests.java
View File

@@ -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

104
spring-statemachine-core/src/test/java/org/springframework/statemachine/transition/TransitionEventHeaderTests.java
View File

@@ -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<TestStates, TestEvents> 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<TestStates, TestEvents> 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<TestStates, TestEvents> 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<TestStates, TestEvents> 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<TestStates, TestEvents> 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

41
spring-statemachine-core/src/test/java/org/springframework/statemachine/transition/TransitionOrderTests.java
View File

@@ -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

121
spring-statemachine-core/src/test/java/org/springframework/statemachine/transition/TransitionTests.java
View File

@@ -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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates,TestEvents> 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<TestStates2,TestEvents2> 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<TestStates2,TestEvents2> 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<TestStates,TestEvents> 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

67
spring-statemachine-core/src/test/java/org/springframework/statemachine/trigger/TimerTriggerTests.java
View File

@@ -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 {

9
spring-statemachine-data/src/test/java/org/springframework/statemachine/data/AbstractRepositoryTests.java
View File

@@ -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<String, String> stateMachine = stateMachineFactory.getStateMachine();
Map<String, State<String, String>> states = stateMachine.getStates().stream().collect(Collectors.toMap((State<String, String> s1) -> s1.getId(), s2 -> s2));
assertEquals(2, states.size());
assertThat(states.size()).isEqualTo(2);
State<String,String> S1 = (State<String, String>) states.get("S1");
assertEquals(1, S1.getExitActions().size());
assertThat(S1.getExitActions().size()).isEqualTo(1);
State<String,String> S2 = (State<String,String>)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

7
spring-statemachine-zookeeper/src/test/java/org/springframework/statemachine/zookeeper/ZookeeperStateMachineEnsembleTests.java
View File

@@ -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<String, String>(null, "/foo", true, 3));
assertThatThrownBy(() -> {
new ZookeeperStateMachineEnsemble<String, String>(null, "/foo", true, 3);
}).isInstanceOf(IllegalStateException.class);
}
@Test