From c4f9d68870a7727c5b62c54d7fd404dee5123779 Mon Sep 17 00:00:00 2001 From: Janne Valkealahti Date: Sat, 28 Nov 2020 14:49:50 +0000 Subject: [PATCH] Port zookeeper tests to assertj --- build.gradle | 2 - .../ZookeeperStateMachineEnsembleTests.java | 207 +++++++++--------- .../ZookeeperStateMachinePersistTests.java | 39 ++-- .../zookeeper/ZookeeperStateMachineTests.java | 70 +++--- 4 files changed, 154 insertions(+), 164 deletions(-) diff --git a/build.gradle b/build.gradle index ec90bb34..ab2ef4a1 100644 --- a/build.gradle +++ b/build.gradle @@ -327,8 +327,6 @@ project('spring-statemachine-zookeeper') { } testCompile 'org.apache.curator:curator-test' testCompile 'org.springframework:spring-test' - testCompile 'org.hamcrest:hamcrest-core' - testCompile 'org.hamcrest:hamcrest-library' testCompile("org.junit.jupiter:junit-jupiter-api") testCompile("org.junit.jupiter:junit-jupiter-engine") testRuntime 'org.apache.logging.log4j:log4j-core' diff --git a/spring-statemachine-zookeeper/src/test/java/org/springframework/statemachine/zookeeper/ZookeeperStateMachineEnsembleTests.java b/spring-statemachine-zookeeper/src/test/java/org/springframework/statemachine/zookeeper/ZookeeperStateMachineEnsembleTests.java index 0e848cc3..8d307430 100644 --- a/spring-statemachine-zookeeper/src/test/java/org/springframework/statemachine/zookeeper/ZookeeperStateMachineEnsembleTests.java +++ b/spring-statemachine-zookeeper/src/test/java/org/springframework/statemachine/zookeeper/ZookeeperStateMachineEnsembleTests.java @@ -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.zookeeper; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.greaterThan; -import static org.hamcrest.Matchers.instanceOf; -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.junit.jupiter.api.Assertions.assertThrows; import java.util.ArrayList; @@ -68,8 +63,8 @@ public class ZookeeperStateMachineEnsembleTests extends AbstractZookeeperTests { ensemble.afterPropertiesSet(); - assertThat(curatorClient.checkExists().forPath("/foo/data/current"), notNullValue()); - assertThat(curatorClient.checkExists().forPath("/foo/data/log"), notNullValue()); + assertThat(curatorClient.checkExists().forPath("/foo/data/current")).isNotNull(); + assertThat(curatorClient.checkExists().forPath("/foo/data/log")).isNotNull(); ensemble.start(); } @@ -87,11 +82,11 @@ public class ZookeeperStateMachineEnsembleTests extends AbstractZookeeperTests { ensemble.afterPropertiesSet(); - assertThat(curatorClient.checkExists().forPath("/foo/data/current"), notNullValue()); - assertThat(curatorClient.getData().forPath("/foo/data/current").length, is(0)); + assertThat(curatorClient.checkExists().forPath("/foo/data/current")).isNotNull(); + assertThat(curatorClient.getData().forPath("/foo/data/current")).isEmpty(); ensemble.setState(new DefaultStateMachineContext("S1","E1", new HashMap(), new DefaultExtendedState())); - assertThat(curatorClient.getData().forPath("/foo/data/current").length, greaterThan(0)); + assertThat(curatorClient.getData().forPath("/foo/data/current").length).isGreaterThan(0); ensemble.setState(new DefaultStateMachineContext("S2","E1", new HashMap(), new DefaultExtendedState())); } @@ -114,16 +109,16 @@ public class ZookeeperStateMachineEnsembleTests extends AbstractZookeeperTests { ensemble1.start(); ensemble2.start(); - assertThat(curatorClient.checkExists().forPath("/foo/data/current"), notNullValue()); - assertThat(curatorClient.getData().forPath("/foo/data/current").length, is(0)); + assertThat(curatorClient.checkExists().forPath("/foo/data/current")).isNotNull(); + assertThat(curatorClient.getData().forPath("/foo/data/current")).isEmpty(); ensemble1.setState(new DefaultStateMachineContext("S1","E1", new HashMap(), new DefaultExtendedState())); - assertThat(curatorClient.getData().forPath("/foo/data/current").length, greaterThan(0)); + assertThat(curatorClient.getData().forPath("/foo/data/current").length).isGreaterThan(0); StateMachineContext context = ensemble2.getState(); - assertThat(context, notNullValue()); - assertThat(context.getState(), is("S1")); - assertThat(context.getEvent(), is("E1")); + assertThat(context).isNotNull(); + assertThat(context.getState()).isEqualTo("S1"); + assertThat(context.getEvent()).isEqualTo("E1"); } @Test @@ -154,11 +149,11 @@ public class ZookeeperStateMachineEnsembleTests extends AbstractZookeeperTests { ensemble1.join(stateMachine1); ensemble2.join(stateMachine2); - assertThat(listener1.joinedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener2.joinedLatch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(listener1.joinedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener2.joinedLatch.await(2, TimeUnit.SECONDS)).isTrue(); ensemble1.setState(new DefaultStateMachineContext("S1", "E1", new HashMap(), new DefaultExtendedState())); - assertThat(listener2.eventLatch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(listener2.eventLatch.await(2, TimeUnit.SECONDS)).isTrue(); } @Test @@ -179,7 +174,7 @@ public class ZookeeperStateMachineEnsembleTests extends AbstractZookeeperTests { ensemble1.start(); // we assume that if data is 0, it's re-created - assertThat(curatorClient.getData().forPath("/foo/data/log").length, is(0)); + assertThat(curatorClient.getData().forPath("/foo/data/log")).isEmpty(); } @Test @@ -196,40 +191,40 @@ public class ZookeeperStateMachineEnsembleTests extends AbstractZookeeperTests { ensemble.afterPropertiesSet(); ensemble.start(); - assertThat(curatorClient.checkExists().forPath("/foo/data/log"), notNullValue()); - assertThat(curatorClient.checkExists().forPath("/foo/data/log/0"), notNullValue()); - assertThat(curatorClient.checkExists().forPath("/foo/data/log/1"), notNullValue()); - assertThat(curatorClient.checkExists().forPath("/foo/data/log/2"), notNullValue()); - assertThat(curatorClient.checkExists().forPath("/foo/data/log/3"), notNullValue()); - assertThat(curatorClient.checkExists().forPath("/foo/data/log/4"), nullValue()); - assertThat(curatorClient.getData().forPath("/foo/data/log/0").length, is(0)); - assertThat(curatorClient.getData().forPath("/foo/data/log/1").length, is(0)); - assertThat(curatorClient.getData().forPath("/foo/data/log/2").length, is(0)); - assertThat(curatorClient.getData().forPath("/foo/data/log/3").length, is(0)); + assertThat(curatorClient.checkExists().forPath("/foo/data/log")).isNotNull(); + assertThat(curatorClient.checkExists().forPath("/foo/data/log/0")).isNotNull(); + assertThat(curatorClient.checkExists().forPath("/foo/data/log/1")).isNotNull(); + assertThat(curatorClient.checkExists().forPath("/foo/data/log/2")).isNotNull(); + assertThat(curatorClient.checkExists().forPath("/foo/data/log/3")).isNotNull(); + assertThat(curatorClient.checkExists().forPath("/foo/data/log/4")).isNull(); + assertThat(curatorClient.getData().forPath("/foo/data/log/0")).isEmpty(); + assertThat(curatorClient.getData().forPath("/foo/data/log/1")).isEmpty(); + assertThat(curatorClient.getData().forPath("/foo/data/log/2")).isEmpty(); + assertThat(curatorClient.getData().forPath("/foo/data/log/3")).isEmpty(); ensemble.setState(new DefaultStateMachineContext("S1","E1", new HashMap(), new DefaultExtendedState())); - assertThat(curatorClient.getData().forPath("/foo/data/log/0").length, greaterThan(0)); - assertThat(curatorClient.getData().forPath("/foo/data/log/1").length, is(0)); - assertThat(curatorClient.getData().forPath("/foo/data/log/2").length, is(0)); - assertThat(curatorClient.getData().forPath("/foo/data/log/3").length, is(0)); + assertThat(curatorClient.getData().forPath("/foo/data/log/0").length).isGreaterThan(0); + assertThat(curatorClient.getData().forPath("/foo/data/log/1")).isEmpty(); + assertThat(curatorClient.getData().forPath("/foo/data/log/2")).isEmpty(); + assertThat(curatorClient.getData().forPath("/foo/data/log/3")).isEmpty(); ensemble.setState(new DefaultStateMachineContext("S2","E1", new HashMap(), new DefaultExtendedState())); - assertThat(curatorClient.getData().forPath("/foo/data/log/0").length, greaterThan(0)); - assertThat(curatorClient.getData().forPath("/foo/data/log/1").length, greaterThan(0)); - assertThat(curatorClient.getData().forPath("/foo/data/log/2").length, is(0)); - assertThat(curatorClient.getData().forPath("/foo/data/log/3").length, is(0)); + assertThat(curatorClient.getData().forPath("/foo/data/log/0").length).isGreaterThan(0); + assertThat(curatorClient.getData().forPath("/foo/data/log/1").length).isGreaterThan(0); + assertThat(curatorClient.getData().forPath("/foo/data/log/2")).isEmpty(); + assertThat(curatorClient.getData().forPath("/foo/data/log/3")).isEmpty(); ensemble.setState(new DefaultStateMachineContext("S3","E1", new HashMap(), new DefaultExtendedState())); - assertThat(curatorClient.getData().forPath("/foo/data/log/0").length, greaterThan(0)); - assertThat(curatorClient.getData().forPath("/foo/data/log/1").length, greaterThan(0)); - assertThat(curatorClient.getData().forPath("/foo/data/log/2").length, greaterThan(0)); - assertThat(curatorClient.getData().forPath("/foo/data/log/3").length, is(0)); + assertThat(curatorClient.getData().forPath("/foo/data/log/0").length).isGreaterThan(0); + assertThat(curatorClient.getData().forPath("/foo/data/log/1").length).isGreaterThan(0); + assertThat(curatorClient.getData().forPath("/foo/data/log/2").length).isGreaterThan(0); + assertThat(curatorClient.getData().forPath("/foo/data/log/3")).isEmpty(); ensemble.setState(new DefaultStateMachineContext("S4","E1", new HashMap(), new DefaultExtendedState())); - assertThat(curatorClient.getData().forPath("/foo/data/log/0").length, greaterThan(0)); - assertThat(curatorClient.getData().forPath("/foo/data/log/1").length, greaterThan(0)); - assertThat(curatorClient.getData().forPath("/foo/data/log/2").length, greaterThan(0)); - assertThat(curatorClient.getData().forPath("/foo/data/log/3").length, greaterThan(0)); + assertThat(curatorClient.getData().forPath("/foo/data/log/0").length).isGreaterThan(0); + assertThat(curatorClient.getData().forPath("/foo/data/log/1").length).isGreaterThan(0); + assertThat(curatorClient.getData().forPath("/foo/data/log/2").length).isGreaterThan(0); + assertThat(curatorClient.getData().forPath("/foo/data/log/3").length).isGreaterThan(0); } @Test @@ -254,7 +249,7 @@ public class ZookeeperStateMachineEnsembleTests extends AbstractZookeeperTests { ensemble.afterPropertiesSet(); ensemble.start(); ensemble.join(new TestStateMachine()); - assertThat(listener.joinedLatch.await(3, TimeUnit.SECONDS), is(true)); + assertThat(listener.joinedLatch.await(3, TimeUnit.SECONDS)).isTrue(); listener.reset(0, 10); @@ -263,11 +258,11 @@ public class ZookeeperStateMachineEnsembleTests extends AbstractZookeeperTests { new HashMap(), new DefaultExtendedState())); } - assertThat(listener.eventLatch.await(10, TimeUnit.SECONDS), is(true)); - assertThat(listener.events.size(), is(10)); + assertThat(listener.eventLatch.await(10, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.events).hasSize(10); for (int i = 0; i < 10; i++) { - assertThat(listener.events.get(i).getEvent(), is("E" + i)); + assertThat(listener.events.get(i).getEvent()).isEqualTo("E" + i); } } @@ -295,9 +290,9 @@ public class ZookeeperStateMachineEnsembleTests extends AbstractZookeeperTests { ensemble2.start(); ensemble1.join(new TestStateMachine()); - assertThat(listener1.joinedLatch.await(3, TimeUnit.SECONDS), is(true)); + assertThat(listener1.joinedLatch.await(3, TimeUnit.SECONDS)).isTrue(); ensemble2.join(new TestStateMachine()); - assertThat(listener2.joinedLatch.await(3, TimeUnit.SECONDS), is(true)); + assertThat(listener2.joinedLatch.await(3, TimeUnit.SECONDS)).isTrue(); listener1.reset(0, 10); listener2.reset(0, 10); @@ -307,14 +302,14 @@ public class ZookeeperStateMachineEnsembleTests extends AbstractZookeeperTests { new HashMap(), new DefaultExtendedState())); } - assertThat(listener1.eventLatch.await(10, TimeUnit.SECONDS), is(true)); - assertThat(listener1.events.size(), is(10)); - assertThat(listener2.eventLatch.await(10, TimeUnit.SECONDS), is(true)); - assertThat(listener2.events.size(), is(10)); + assertThat(listener1.eventLatch.await(10, TimeUnit.SECONDS)).isTrue(); + assertThat(listener1.events).hasSize(10); + assertThat(listener2.eventLatch.await(10, TimeUnit.SECONDS)).isTrue(); + assertThat(listener2.events).hasSize(10); for (int i = 0; i < 10; i++) { - assertThat(listener1.events.get(i).getEvent(), is("E" + i)); - assertThat(listener2.events.get(i).getEvent(), is("E" + i)); + assertThat(listener1.events.get(i).getEvent()).isEqualTo("E" + i); + assertThat(listener2.events.get(i).getEvent()).isEqualTo("E" + i); } } @@ -342,9 +337,9 @@ public class ZookeeperStateMachineEnsembleTests extends AbstractZookeeperTests { ensemble2.start(); ensemble1.join(new TestStateMachine()); - assertThat(listener1.joinedLatch.await(3, TimeUnit.SECONDS), is(true)); + assertThat(listener1.joinedLatch.await(3, TimeUnit.SECONDS)).isTrue(); ensemble2.join(new TestStateMachine()); - assertThat(listener2.joinedLatch.await(3, TimeUnit.SECONDS), is(true)); + assertThat(listener2.joinedLatch.await(3, TimeUnit.SECONDS)).isTrue(); listener1.reset(0, 10); listener2.reset(0, 10); @@ -365,18 +360,18 @@ public class ZookeeperStateMachineEnsembleTests extends AbstractZookeeperTests { } if (e != null) { - assertThat(e, instanceOf(StateMachineException.class)); - assertThat(((StateMachineException)e).contains(KeeperException.BadVersionException.class), is(true)); + assertThat(e).isInstanceOf(StateMachineException.class); + assertThat(((StateMachineException)e).contains(KeeperException.BadVersionException.class)).isTrue(); } else { // miracle happened and no cas error, well then check events - assertThat(listener1.eventLatch.await(10, TimeUnit.SECONDS), is(true)); - assertThat(listener1.events.size(), is(10)); - assertThat(listener2.eventLatch.await(10, TimeUnit.SECONDS), is(true)); - assertThat(listener2.events.size(), is(10)); + assertThat(listener1.eventLatch.await(10, TimeUnit.SECONDS)).isTrue(); + assertThat(listener1.events).hasSize(10); + assertThat(listener2.eventLatch.await(10, TimeUnit.SECONDS)).isTrue(); + assertThat(listener2.events).hasSize(10); for (int i = 0; i < 10; i++) { - assertThat(listener1.events.get(i).getEvent(), is("E" + i)); - assertThat(listener2.events.get(i).getEvent(), is("E" + i)); + assertThat(listener1.events.get(i).getEvent()).isEqualTo("E" + i); + assertThat(listener2.events.get(i).getEvent()).isEqualTo("E" + i); } } } @@ -405,9 +400,9 @@ public class ZookeeperStateMachineEnsembleTests extends AbstractZookeeperTests { ensemble2.start(); ensemble1.join(new TestStateMachine()); - assertThat(listener1.joinedLatch.await(3, TimeUnit.SECONDS), is(true)); + assertThat(listener1.joinedLatch.await(3, TimeUnit.SECONDS)).isTrue(); ensemble2.join(new TestStateMachine()); - assertThat(listener2.joinedLatch.await(3, TimeUnit.SECONDS), is(true)); + assertThat(listener2.joinedLatch.await(3, TimeUnit.SECONDS)).isTrue(); for (int i = 0; i < 10; i++) { listener1.reset(0, 1); @@ -419,10 +414,10 @@ public class ZookeeperStateMachineEnsembleTests extends AbstractZookeeperTests { ensemble2.setState(new DefaultStateMachineContext("S" + i, "E" + i, new HashMap(), new DefaultExtendedState())); } - assertThat(listener1.eventLatch.await(10, TimeUnit.SECONDS), is(true)); - assertThat(listener1.events.size(), is(1)); - assertThat(listener2.eventLatch.await(10, TimeUnit.SECONDS), is(true)); - assertThat(listener2.events.size(), is(1)); + assertThat(listener1.eventLatch.await(10, TimeUnit.SECONDS)).isTrue(); + assertThat(listener1.events).hasSize(1); + assertThat(listener2.eventLatch.await(10, TimeUnit.SECONDS)).isTrue(); + assertThat(listener2.events).hasSize(1); } } @@ -444,7 +439,7 @@ public class ZookeeperStateMachineEnsembleTests extends AbstractZookeeperTests { ensemble.start(); ensemble.join(new TestStateMachine()); - assertThat(listener.joinedLatch.await(3, TimeUnit.SECONDS), is(true)); + assertThat(listener.joinedLatch.await(3, TimeUnit.SECONDS)).isTrue(); listener.reset(0, 10); @@ -454,11 +449,11 @@ public class ZookeeperStateMachineEnsembleTests extends AbstractZookeeperTests { Thread.sleep(500); } - assertThat(listener.eventLatch.await(10, TimeUnit.SECONDS), is(true)); - assertThat(listener.events.size(), is(10)); + assertThat(listener.eventLatch.await(10, TimeUnit.SECONDS)).isTrue(); + assertThat(listener.events).hasSize(10); for (int i = 0; i < 10; i++) { - assertThat(listener.events.get(i).getEvent(), is("E" + i)); + assertThat(listener.events.get(i).getEvent()).isEqualTo("E" + i); } } @@ -486,9 +481,9 @@ public class ZookeeperStateMachineEnsembleTests extends AbstractZookeeperTests { ensemble2.start(); ensemble1.join(new TestStateMachine()); - assertThat(listener1.joinedLatch.await(3, TimeUnit.SECONDS), is(true)); + assertThat(listener1.joinedLatch.await(3, TimeUnit.SECONDS)).isTrue(); ensemble2.join(new TestStateMachine()); - assertThat(listener2.joinedLatch.await(3, TimeUnit.SECONDS), is(true)); + assertThat(listener2.joinedLatch.await(3, TimeUnit.SECONDS)).isTrue(); listener1.reset(0, 10); listener2.reset(0, 10); @@ -499,14 +494,14 @@ public class ZookeeperStateMachineEnsembleTests extends AbstractZookeeperTests { Thread.sleep(500); } - assertThat(listener1.eventLatch.await(10, TimeUnit.SECONDS), is(true)); - assertThat(listener1.events.size(), is(10)); - assertThat(listener2.eventLatch.await(10, TimeUnit.SECONDS), is(true)); - assertThat(listener2.events.size(), is(10)); + assertThat(listener1.eventLatch.await(10, TimeUnit.SECONDS)).isTrue(); + assertThat(listener1.events).hasSize(10); + assertThat(listener2.eventLatch.await(10, TimeUnit.SECONDS)).isTrue(); + assertThat(listener2.events).hasSize(10); for (int i = 0; i < 10; i++) { - assertThat(listener1.events.get(i).getEvent(), is("E" + i)); - assertThat(listener2.events.get(i).getEvent(), is("E" + i)); + assertThat(listener1.events.get(i).getEvent()).isEqualTo("E" + i); + assertThat(listener2.events.get(i).getEvent()).isEqualTo("E" + i); } } @@ -534,9 +529,9 @@ public class ZookeeperStateMachineEnsembleTests extends AbstractZookeeperTests { ensemble2.start(); ensemble1.join(new TestStateMachine()); - assertThat(listener1.joinedLatch.await(3, TimeUnit.SECONDS), is(true)); + assertThat(listener1.joinedLatch.await(3, TimeUnit.SECONDS)).isTrue(); ensemble2.join(new TestStateMachine()); - assertThat(listener2.joinedLatch.await(3, TimeUnit.SECONDS), is(true)); + assertThat(listener2.joinedLatch.await(3, TimeUnit.SECONDS)).isTrue(); listener1.reset(0, 9); listener2.reset(0, 9); @@ -546,14 +541,14 @@ public class ZookeeperStateMachineEnsembleTests extends AbstractZookeeperTests { new HashMap(), new DefaultExtendedState())); } - assertThat(listener1.eventLatch.await(10, TimeUnit.SECONDS), is(true)); - assertThat(listener1.events.size(), is(9)); - assertThat(listener2.eventLatch.await(10, TimeUnit.SECONDS), is(true)); - assertThat(listener2.events.size(), is(9)); + assertThat(listener1.eventLatch.await(10, TimeUnit.SECONDS)).isTrue(); + assertThat(listener1.events).hasSize(9); + assertThat(listener2.eventLatch.await(10, TimeUnit.SECONDS)).isTrue(); + assertThat(listener2.events).hasSize(9); for (int i = 0; i < 9; i++) { - assertThat(listener1.events.get(i).getEvent(), is("E" + i)); - assertThat(listener2.events.get(i).getEvent(), is("E" + i)); + assertThat(listener1.events.get(i).getEvent()).isEqualTo("E" + i); + assertThat(listener2.events.get(i).getEvent()).isEqualTo("E" + i); } listener1.reset(0, 1); @@ -565,14 +560,14 @@ public class ZookeeperStateMachineEnsembleTests extends AbstractZookeeperTests { new HashMap(), new DefaultExtendedState())); } - assertThat(listener1.eventLatch.await(10, TimeUnit.SECONDS), is(true)); - assertThat(listener1.events.size(), is(1)); - assertThat(listener2.eventLatch.await(10, TimeUnit.SECONDS), is(true)); - assertThat(listener2.events.size(), is(1)); + assertThat(listener1.eventLatch.await(10, TimeUnit.SECONDS)).isTrue(); + assertThat(listener1.events).hasSize(1); + assertThat(listener2.eventLatch.await(10, TimeUnit.SECONDS)).isTrue(); + assertThat(listener2.events).hasSize(1); for (int i = 0; i < 1; i++) { - assertThat(listener1.events.get(i).getEvent(), is("E" + (i+9))); - assertThat(listener2.events.get(i).getEvent(), is("E" + (i+9))); + assertThat(listener1.events.get(i).getEvent()).isEqualTo("E" + (i+9)); + assertThat(listener2.events.get(i).getEvent()).isEqualTo("E" + (i+9)); } } @@ -592,7 +587,7 @@ public class ZookeeperStateMachineEnsembleTests extends AbstractZookeeperTests { ensemble.start(); ensemble.join(new TestStateMachine()); - assertThat(listener.joinedLatch.await(3, TimeUnit.SECONDS), is(true)); + assertThat(listener.joinedLatch.await(3, TimeUnit.SECONDS)).isTrue(); listener.reset(0, 10, 1); @@ -605,7 +600,7 @@ public class ZookeeperStateMachineEnsembleTests extends AbstractZookeeperTests { ensemble.setState(new DefaultStateMachineContext("S" + i, "E" + i, new HashMap(), new DefaultExtendedState())); } - assertThat(listener.errorLatch.await(2, TimeUnit.SECONDS), is(false)); + assertThat(listener.errorLatch.await(2, TimeUnit.SECONDS)).isFalse(); ensemble.enabled = true; @@ -615,14 +610,14 @@ public class ZookeeperStateMachineEnsembleTests extends AbstractZookeeperTests { if (listener.errors.size() > 0) { reason = listener.errors.get(0).toString(); } - assertThat(reason, listener.errors.size(), is(0)); + assertThat(listener.errors).withFailMessage(reason).isEmpty(); // this should actually cause ensemble to fail for (int i = 10; i < 11; i++) { ensemble.setState(new DefaultStateMachineContext("S" + i, "E" + i, new HashMap(), new DefaultExtendedState())); } - assertThat(listener.errorLatch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(listener.errorLatch.await(2, TimeUnit.SECONDS)).isTrue(); } private class OverflowControlZookeeperStateMachineEnsemble extends ZookeeperStateMachineEnsemble { diff --git a/spring-statemachine-zookeeper/src/test/java/org/springframework/statemachine/zookeeper/ZookeeperStateMachinePersistTests.java b/spring-statemachine-zookeeper/src/test/java/org/springframework/statemachine/zookeeper/ZookeeperStateMachinePersistTests.java index d6a12d9e..0da5f3a3 100644 --- a/spring-statemachine-zookeeper/src/test/java/org/springframework/statemachine/zookeeper/ZookeeperStateMachinePersistTests.java +++ b/spring-statemachine-zookeeper/src/test/java/org/springframework/statemachine/zookeeper/ZookeeperStateMachinePersistTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,8 +15,7 @@ */ package org.springframework.statemachine.zookeeper; -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.HashMap; @@ -56,8 +55,8 @@ public class ZookeeperStateMachinePersistTests extends AbstractZookeeperTests { persist.write(contextOut, new Stat()); StateMachineContext contextIn = persist.read(new Stat()); - assertThat(contextOut.getState(), is(contextIn.getState())); - assertThat(contextOut.getEvent(), is(contextIn.getEvent())); + assertThat(contextOut.getState()).isEqualTo(contextIn.getState()); + assertThat(contextOut.getEvent()).isEqualTo(contextIn.getEvent()); } @Test @@ -86,8 +85,8 @@ public class ZookeeperStateMachinePersistTests extends AbstractZookeeperTests { for (int i = 0; i < 10; i++) { StateMachineContext contextIn = persist.readLog(i, new Stat()); - assertThat(contextIn.getState(), is("S" + i)); - assertThat(contextIn.getEvent(), is("E" + i)); + assertThat(contextIn.getState()).isEqualTo("S" + i); + assertThat(contextIn.getEvent()).isEqualTo("E" + i); } } @@ -111,9 +110,9 @@ public class ZookeeperStateMachinePersistTests extends AbstractZookeeperTests { persist.write(contextOut, new Stat()); StateMachineContext contextIn = persist.read(new Stat()); - assertThat(contextOut.getState(), is(contextIn.getState())); - assertThat(contextOut.getEvent(), is(contextIn.getEvent())); - assertThat(contextOut.getEventHeaders().get("foo"), is(contextIn.getEventHeaders().get("foo"))); + assertThat(contextOut.getState()).isEqualTo(contextIn.getState()); + assertThat(contextOut.getEvent()).isEqualTo(contextIn.getEvent()); + assertThat(contextOut.getEventHeaders().get("foo")).isEqualTo(contextIn.getEventHeaders().get("foo")); } @Test @@ -137,9 +136,9 @@ public class ZookeeperStateMachinePersistTests extends AbstractZookeeperTests { persist.write(contextOut, new Stat()); StateMachineContext contextIn = persist.read(new Stat()); - assertThat(contextOut.getState(), is(contextIn.getState())); - assertThat(contextOut.getEvent(), is(contextIn.getEvent())); - assertThat(contextOut.getEventHeaders().get("foo"), is(contextIn.getEventHeaders().get("foo"))); + assertThat(contextOut.getState()).isEqualTo(contextIn.getState()); + assertThat(contextOut.getEvent()).isEqualTo(contextIn.getEvent()); + assertThat(contextOut.getEventHeaders().get("foo")).isEqualTo(contextIn.getEventHeaders().get("foo")); } @Test @@ -163,9 +162,9 @@ public class ZookeeperStateMachinePersistTests extends AbstractZookeeperTests { persist.write(contextOut, new Stat()); StateMachineContext contextIn = persist.read(new Stat()); - assertThat(contextOut.getState(), is(contextIn.getState())); - assertThat(contextOut.getEvent(), is(contextIn.getEvent())); - assertThat(contextOut.getExtendedState().getVariables().get("foo"), is(contextIn.getExtendedState().getVariables().get("foo"))); + assertThat(contextOut.getState()).isEqualTo(contextIn.getState()); + assertThat(contextOut.getEvent()).isEqualTo(contextIn.getEvent()); + assertThat(contextOut.getExtendedState().getVariables().get("foo")).isEqualTo(contextIn.getExtendedState().getVariables().get("foo")); } @Test @@ -189,11 +188,11 @@ public class ZookeeperStateMachinePersistTests extends AbstractZookeeperTests { persist.write(contextOut, new Stat()); StateMachineContext contextIn = persist.read(new Stat()); - assertThat(contextOut.getState(), is(contextIn.getState())); - assertThat(contextOut.getEvent(), is(contextIn.getEvent())); + assertThat(contextOut.getState()).isEqualTo(contextIn.getState()); + assertThat(contextOut.getEvent()).isEqualTo(contextIn.getEvent()); - assertThat(contextIn.getChilds().size(), is(1)); - assertThat(contextIn.getChilds().get(0).getEvent(), is("E2")); + assertThat(contextIn.getChilds()).hasSize(1); + assertThat(contextIn.getChilds().get(0).getEvent()).isEqualTo("E2"); } } diff --git a/spring-statemachine-zookeeper/src/test/java/org/springframework/statemachine/zookeeper/ZookeeperStateMachineTests.java b/spring-statemachine-zookeeper/src/test/java/org/springframework/statemachine/zookeeper/ZookeeperStateMachineTests.java index d9daf2b0..1a0d389a 100644 --- a/spring-statemachine-zookeeper/src/test/java/org/springframework/statemachine/zookeeper/ZookeeperStateMachineTests.java +++ b/spring-statemachine-zookeeper/src/test/java/org/springframework/statemachine/zookeeper/ZookeeperStateMachineTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2015-2019 the original author or authors. + * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,9 +15,7 @@ */ package org.springframework.statemachine.zookeeper; -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.Map; import java.util.concurrent.CountDownLatch; @@ -100,22 +98,22 @@ public class ZookeeperStateMachineTests extends AbstractZookeeperTests { listener1.reset(1); listener2.reset(1); machine1s.sendEvent("E1"); - assertThat(listener1.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener1.stateChangedCount, is(1)); - assertThat(listener2.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener2.stateChangedCount, is(1)); - assertThat(machine1.getState().getIds(), containsInAnyOrder("S1")); - assertThat(machine2.getState().getIds(), containsInAnyOrder("S1")); + assertThat(listener1.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener1.stateChangedCount).isEqualTo(1); + assertThat(listener2.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener2.stateChangedCount).isEqualTo(1); + assertThat(machine1.getState().getIds()).containsOnly("S1"); + assertThat(machine2.getState().getIds()).containsOnly("S1"); listener1.reset(1); listener2.reset(1); machine1s.sendEvent("E2"); - assertThat(listener1.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener1.stateChangedCount, is(1)); - assertThat(listener2.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener2.stateChangedCount, is(1)); - assertThat(machine1.getState().getIds(), containsInAnyOrder("S2")); - assertThat(machine2.getState().getIds(), containsInAnyOrder("S2")); + assertThat(listener1.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener1.stateChangedCount).isEqualTo(1); + assertThat(listener2.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener2.stateChangedCount).isEqualTo(1); + assertThat(machine1.getState().getIds()).containsOnly("S2"); + assertThat(machine2.getState().getIds()).containsOnly("S2"); } @Test @@ -161,22 +159,22 @@ public class ZookeeperStateMachineTests extends AbstractZookeeperTests { listener1.reset(1); listener2.reset(1); machine1s.sendEvent("E1"); - assertThat(listener1.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener1.stateChangedCount, is(1)); - assertThat(listener2.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener2.stateChangedCount, is(1)); - assertThat(machine1.getState().getIds(), containsInAnyOrder("S1")); - assertThat(machine2.getState().getIds(), containsInAnyOrder("S1")); + assertThat(listener1.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener1.stateChangedCount).isEqualTo(1); + assertThat(listener2.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener2.stateChangedCount).isEqualTo(1); + assertThat(machine1.getState().getIds()).containsOnly("S1"); + assertThat(machine2.getState().getIds()).containsOnly("S1"); listener1.reset(1); listener2.reset(1); machine2s.sendEvent("E2"); - assertThat(listener1.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener1.stateChangedCount, is(1)); - assertThat(listener2.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener2.stateChangedCount, is(1)); - assertThat(machine1.getState().getIds(), containsInAnyOrder("S2")); - assertThat(machine2.getState().getIds(), containsInAnyOrder("S2")); + assertThat(listener1.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener1.stateChangedCount).isEqualTo(1); + assertThat(listener2.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener2.stateChangedCount).isEqualTo(1); + assertThat(machine1.getState().getIds()).containsOnly("S2"); + assertThat(machine2.getState().getIds()).containsOnly("S2"); } @Test @@ -190,10 +188,10 @@ public class ZookeeperStateMachineTests extends AbstractZookeeperTests { StateMachine machine2 = context.getBean("sm2", StateMachine.class); - assertThat(((SmartLifecycle)machine1).isAutoStartup(), is(false)); - assertThat(((SmartLifecycle)machine1).isRunning(), is(false)); - assertThat(((SmartLifecycle)machine2).isAutoStartup(), is(false)); - assertThat(((SmartLifecycle)machine2).isRunning(), is(false)); + assertThat(((SmartLifecycle)machine1).isAutoStartup()).isFalse(); + assertThat(((SmartLifecycle)machine1).isRunning()).isFalse(); + assertThat(((SmartLifecycle)machine2).isAutoStartup()).isFalse(); + assertThat(((SmartLifecycle)machine2).isRunning()).isFalse(); } @Test @@ -484,9 +482,9 @@ public class ZookeeperStateMachineTests extends AbstractZookeeperTests { listener1.reset(1); machine1s.sendEvent("E1"); - assertThat(listener1.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); - assertThat(listener1.stateChangedCount, is(1)); - assertThat(machine1.getState().getIds(), containsInAnyOrder("S1")); + assertThat(listener1.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue(); + assertThat(listener1.stateChangedCount).isEqualTo(1); + assertThat(machine1.getState().getIds()).containsOnly("S1"); ZookeeperStateMachineEnsemble ensemble2 = new ZookeeperStateMachineEnsemble(curatorClient, "/foo"); @@ -497,7 +495,7 @@ public class ZookeeperStateMachineTests extends AbstractZookeeperTests { new DistributedStateMachine(ensemble2, machine2); machine2s.afterPropertiesSet(); machine2s.start(); - assertThat(machine2.getState().getIds(), containsInAnyOrder("S1")); + assertThat(machine2.getState().getIds()).containsOnly("S1"); } @Test