From 2fa227985c250f870bb6e7e789fa520ed9cd5502 Mon Sep 17 00:00:00 2001 From: Janne Valkealahti Date: Sat, 28 Nov 2020 14:43:55 +0000 Subject: [PATCH] Port data tests to assertj --- .../data/jpa/JpaRepositoryTests.java | 102 +++++++++--------- .../data/mongodb/MongoDbRepositoryTests.java | 44 ++++---- .../data/redis/RedisRepositoryTests.java | 44 ++++---- .../data/AbstractRepositoryTests.java | 12 +-- 4 files changed, 97 insertions(+), 105 deletions(-) diff --git a/spring-statemachine-data/jpa/src/test/java/org/springframework/statemachine/data/jpa/JpaRepositoryTests.java b/spring-statemachine-data/jpa/src/test/java/org/springframework/statemachine/data/jpa/JpaRepositoryTests.java index ce4f2b71..cfb5fcdf 100644 --- a/spring-statemachine-data/jpa/src/test/java/org/springframework/statemachine/data/jpa/JpaRepositoryTests.java +++ b/spring-statemachine-data/jpa/src/test/java/org/springframework/statemachine/data/jpa/JpaRepositoryTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2016-2019 the original author or authors. + * Copyright 2016-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,9 +15,7 @@ */ package org.springframework.statemachine.data.jpa; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.Matchers.containsInAnyOrder; -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; @@ -65,24 +63,24 @@ public class JpaRepositoryTests extends AbstractRepositoryTests { JpaStateRepository statesRepository = context.getBean(JpaStateRepository.class); JpaRepositoryState stateS1 = new JpaRepositoryState("S1"); JpaRepositoryState stateS2 = new JpaRepositoryState("S2"); - assertThat(statesRepository.count(), is(0l)); + assertThat(statesRepository.count()).isEqualTo(0l); statesRepository.save(stateS1); statesRepository.save(stateS2); - assertThat(statesRepository.count(), is(2l)); + assertThat(statesRepository.count()).isEqualTo(2l); JpaTransitionRepository transitionsRepository = context.getBean(JpaTransitionRepository.class); JpaRepositoryTransition transition = new JpaRepositoryTransition(stateS1, stateS2, "E1"); transition.setKind(TransitionKind.EXTERNAL); transitionsRepository.save(transition); - assertThat(statesRepository.count(), is(2l)); + assertThat(statesRepository.count()).isEqualTo(2l); JpaRepositoryTransition transition2 = transitionsRepository.findAll().iterator().next(); - assertThat(transition2.getSource().getState(), is("S1")); - assertThat(transition2.getTarget().getState(), is("S2")); - assertThat(transition2.getEvent(), is("E1")); - assertThat(transition2.getKind(), is(TransitionKind.EXTERNAL)); + assertThat(transition2.getSource().getState()).isEqualTo("S1"); + assertThat(transition2.getTarget().getState()).isEqualTo("S2"); + assertThat(transition2.getEvent()).isEqualTo("E1"); + assertThat(transition2.getKind()).isEqualTo(TransitionKind.EXTERNAL); context.close(); } @@ -101,16 +99,16 @@ public class JpaRepositoryTests extends AbstractRepositoryTests { @SuppressWarnings("unchecked") StateRepository statesRepository2 = context.getBean(StateRepository.class); Iterable findAll = statesRepository2.findAll(); - assertThat(findAll.iterator().next().getState(), is("S1")); + assertThat(findAll.iterator().next().getState()).isEqualTo("S1"); @SuppressWarnings("unchecked") TransitionRepository transitionsRepository = context.getBean(TransitionRepository.class); RepositoryTransition transition = new JpaRepositoryTransition(state1, state2, "E1"); transitionsRepository.save(transition); RepositoryTransition transition2 = transitionsRepository.findAll().iterator().next(); - assertThat(transition2.getSource().getState(), is("S1")); - assertThat(transition2.getTarget().getState(), is("S2")); - assertThat(transition2.getEvent(), is("E1")); + assertThat(transition2.getSource().getState()).isEqualTo("S1"); + assertThat(transition2.getTarget().getState()).isEqualTo("S2"); + assertThat(transition2.getEvent()).isEqualTo("E1"); context.close(); } @@ -132,10 +130,10 @@ public class JpaRepositoryTests extends AbstractRepositoryTests { List findByMachineId1 = statesRepository.findByMachineId("machine1"); List findByMachineId2 = statesRepository.findByMachineId("machine2"); - assertThat(findByMachineId1.size(), is(2)); - assertThat(findByMachineId2.size(), is(2)); - assertThat(findByMachineId1.get(0).getMachineId(), is("machine1")); - assertThat(findByMachineId2.get(0).getMachineId(), is("machine2")); + assertThat(findByMachineId1).hasSize(2); + assertThat(findByMachineId2).hasSize(2); + assertThat(findByMachineId1.get(0).getMachineId()).isEqualTo("machine1"); + assertThat(findByMachineId2.get(0).getMachineId()).isEqualTo("machine2"); JpaTransitionRepository transitionsRepository = context.getBean(JpaTransitionRepository.class); @@ -146,10 +144,10 @@ public class JpaRepositoryTests extends AbstractRepositoryTests { List findByMachineId3 = transitionsRepository.findByMachineId("machine1"); List findByMachineId4 = transitionsRepository.findByMachineId("machine2"); - assertThat(findByMachineId3.size(), is(1)); - assertThat(findByMachineId4.size(), is(1)); - assertThat(findByMachineId3.get(0).getMachineId(), is("machine1")); - assertThat(findByMachineId4.get(0).getMachineId(), is("machine2")); + assertThat(findByMachineId3).hasSize(1); + assertThat(findByMachineId4).hasSize(1); + assertThat(findByMachineId3.get(0).getMachineId()).isEqualTo("machine1"); + assertThat(findByMachineId4.get(0).getMachineId()).isEqualTo("machine2"); context.close(); } @@ -165,10 +163,10 @@ public class JpaRepositoryTests extends AbstractRepositoryTests { action1.setName("action1"); actionsRepository.save(action1); - assertThat(actionsRepository.count(), is(1l)); + assertThat(actionsRepository.count()).isEqualTo(1l); JpaRepositoryAction action11 = actionsRepository.findAll().iterator().next(); - assertThat(action1.getSpel(), is(action11.getSpel())); - assertThat(action1.getName(), is(action11.getName())); + assertThat(action1.getSpel()).isEqualTo(action11.getSpel()); + assertThat(action1.getName()).isEqualTo(action11.getName()); } @Test @@ -197,16 +195,16 @@ public class JpaRepositoryTests extends AbstractRepositoryTests { transitionsRepository.save(transition); JpaRepositoryTransition transition2 = transitionsRepository.findAll().iterator().next(); - assertThat(transition2.getSource().getState(), is("S1")); - assertThat(transition2.getTarget().getState(), is("S2")); - assertThat(transition2.getEvent(), is("E1")); + assertThat(transition2.getSource().getState()).isEqualTo("S1"); + assertThat(transition2.getTarget().getState()).isEqualTo("S2"); + assertThat(transition2.getEvent()).isEqualTo("E1"); - assertThat(actionsRepository.count(), is(1l)); + assertThat(actionsRepository.count()).isEqualTo(1l); JpaRepositoryAction action11 = actionsRepository.findAll().iterator().next(); - assertThat(action1.getName(), is(action11.getName())); + assertThat(action1.getName()).isEqualTo(action11.getName()); - assertThat(transition2.getActions().size(), is(1)); + assertThat(transition2.getActions()).hasSize(1); } @Test @@ -221,12 +219,12 @@ public class JpaRepositoryTests extends AbstractRepositoryTests { JpaRepositoryAction action1 = new JpaRepositoryAction(); action1.setName("action1"); actionsRepository.save(action1); - assertThat(actionsRepository.count(), is(1l)); + assertThat(actionsRepository.count()).isEqualTo(1l); JpaRepositoryAction action2 = new JpaRepositoryAction(); action2.setName("action2"); actionsRepository.save(action2); - assertThat(actionsRepository.count(), is(2l)); + assertThat(actionsRepository.count()).isEqualTo(2l); JpaRepositoryState stateS1 = new JpaRepositoryState("S1"); stateS1.setEntryActions(new HashSet<>(Arrays.asList(action1, action2))); @@ -244,12 +242,12 @@ public class JpaRepositoryTests extends AbstractRepositoryTests { JpaRepositoryTransition transition1 = new JpaRepositoryTransition(stateS1, stateS2, "E1"); transition1.setActions(new HashSet<>(Arrays.asList(action1, action2))); transitionsRepository.save(transition1); - assertThat(transitionsRepository.count(), is(1l)); + assertThat(transitionsRepository.count()).isEqualTo(1l); JpaRepositoryTransition transition2 = new JpaRepositoryTransition(stateS2, stateS3, "E2"); transition2.setActions(new HashSet<>(Arrays.asList(action1, action2))); transitionsRepository.save(transition2); - assertThat(transitionsRepository.count(), is(2l)); + assertThat(transitionsRepository.count()).isEqualTo(2l); } @Test @@ -264,14 +262,14 @@ public class JpaRepositoryTests extends AbstractRepositoryTests { machine1.setState("S1"); machine1.setStateMachineContext(new byte[] { 0 }); - assertThat(stateMachineRepository.count(), is(0l)); + assertThat(stateMachineRepository.count()).isEqualTo(0l); stateMachineRepository.save(machine1); - assertThat(stateMachineRepository.count(), is(1l)); + assertThat(stateMachineRepository.count()).isEqualTo(1l); JpaRepositoryStateMachine machine1x = stateMachineRepository.findById("machine1").get(); - assertThat(machine1x.getMachineId(), is(machine1.getMachineId())); - assertThat(machine1x.getState(), is(machine1.getState())); - assertThat(machine1x.getStateMachineContext().length, is(1)); + assertThat(machine1x.getMachineId()).isEqualTo(machine1.getMachineId()); + assertThat(machine1x.getState()).isEqualTo(machine1.getState()); + assertThat(machine1x.getStateMachineContext().length).isEqualTo(1); } @Override @@ -297,11 +295,11 @@ public class JpaRepositoryTests extends AbstractRepositoryTests { StateMachine stateMachine = resolveMachine(context); doStartAndAssert(stateMachine); - assertThat(stateMachine.getState().getId(), is("S1")); + assertThat(stateMachine.getState().getId()).isEqualTo("S1"); doSendEventAndConsumeAll(stateMachine, "E1"); - assertThat(stateMachine.getState().getId(), is("S2")); + assertThat(stateMachine.getState().getId()).isEqualTo("S2"); doSendEventAndConsumeAll(stateMachine, "E2"); - assertThat(stateMachine.getState().getId(), is("S1")); + assertThat(stateMachine.getState().getId()).isEqualTo("S1"); } @Test @@ -311,11 +309,11 @@ public class JpaRepositoryTests extends AbstractRepositoryTests { StateMachine stateMachine = resolveMachine(context); doStartAndAssert(stateMachine); - assertThat(stateMachine.getState().getId(), is(PersistTestStates.S1)); + assertThat(stateMachine.getState().getId()).isEqualTo(PersistTestStates.S1); doSendEventAndConsumeAll(stateMachine, PersistTestEvents.E1); - assertThat(stateMachine.getState().getId(), is(PersistTestStates.S2)); + assertThat(stateMachine.getState().getId()).isEqualTo(PersistTestStates.S2); doSendEventAndConsumeAll(stateMachine, PersistTestEvents.E2); - assertThat(stateMachine.getState().getId(), is(PersistTestStates.S1)); + assertThat(stateMachine.getState().getId()).isEqualTo(PersistTestStates.S1); } @Test @@ -327,18 +325,18 @@ public class JpaRepositoryTests extends AbstractRepositoryTests { StateMachine stateMachine = context.getBean(StateMachine.class); doStartAndAssert(stateMachine); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S10", "S20")); + assertThat(stateMachine.getState().getIds()).containsOnly("S10", "S20"); doSendEventAndConsumeAll(stateMachine, "E1"); - assertThat(stateMachine.getState().getIds(), containsInAnyOrder("S11", "S21")); + assertThat(stateMachine.getState().getIds()).containsOnly("S11", "S21"); - assertThat(stateMachineRepository.count(), is(3l)); + assertThat(stateMachineRepository.count()).isEqualTo(3l); List ids = StreamSupport.stream(stateMachineRepository.findAll().spliterator(), false) .map(jrsm -> jrsm.getMachineId()).collect(Collectors.toList()); - assertThat(ids.size(), is(3)); + assertThat(ids).hasSize(3); // [null#238e8cc0-a932-4583-b696-2c057e5ebefe, null#486e20be-853e-4e4d-9a68-c62c061469ef, testid] - assertThat(ids, containsInAnyOrder("testid", "testid#R1", "testid#R2")); + assertThat(ids).containsOnly("testid", "testid#R1", "testid#R2"); } diff --git a/spring-statemachine-data/mongodb/src/test/java/org/springframework/statemachine/data/mongodb/MongoDbRepositoryTests.java b/spring-statemachine-data/mongodb/src/test/java/org/springframework/statemachine/data/mongodb/MongoDbRepositoryTests.java index beb4bfea..f5a32142 100644 --- a/spring-statemachine-data/mongodb/src/test/java/org/springframework/statemachine/data/mongodb/MongoDbRepositoryTests.java +++ b/spring-statemachine-data/mongodb/src/test/java/org/springframework/statemachine/data/mongodb/MongoDbRepositoryTests.java @@ -15,9 +15,7 @@ */ package org.springframework.statemachine.data.mongodb; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.Matchers.notNullValue; -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; @@ -73,18 +71,18 @@ public class MongoDbRepositoryTests extends AbstractRepositoryTests { MongoDbStateRepository stateRepository = context.getBean(MongoDbStateRepository.class); MongoDbTransitionRepository transitionRepository = context.getBean(MongoDbTransitionRepository.class); - assertThat(stateRepository.count(), is(3l)); - assertThat(transitionRepository.count(), is(3l)); + assertThat(stateRepository.count()).isEqualTo(3l); + assertThat(transitionRepository.count()).isEqualTo(3l); List states = new ArrayList<>(); stateRepository.findAll().iterator().forEachRemaining(states::add); List transitions = new ArrayList<>(); transitionRepository.findAll().iterator().forEachRemaining(transitions::add); - assertThat(states.size(), is(3)); - assertThat(transitions.size(), is(3)); + assertThat(states).hasSize(3); + assertThat(transitions).hasSize(3); MongoDbRepositoryTransition transition1 = transitions.get(0); - assertThat(transition1.getSource(), notNullValue()); - assertThat(transition1.getTarget(), notNullValue()); + assertThat(transition1.getSource()).isNotNull(); + assertThat(transition1.getTarget()).isNotNull(); } @Test @@ -95,27 +93,27 @@ public class MongoDbRepositoryTests extends AbstractRepositoryTests { MongoDbStateRepository statesRepository = context.getBean(MongoDbStateRepository.class); MongoDbRepositoryState stateS1 = new MongoDbRepositoryState("S1"); MongoDbRepositoryState stateS2 = new MongoDbRepositoryState("S2"); - assertThat(statesRepository.count(), is(0l)); + assertThat(statesRepository.count()).isEqualTo(0l); statesRepository.save(stateS1); statesRepository.save(stateS2); - assertThat(statesRepository.count(), is(2l)); + assertThat(statesRepository.count()).isEqualTo(2l); MongoDbTransitionRepository transitionsRepository = context.getBean(MongoDbTransitionRepository.class); MongoDbRepositoryTransition transition = new MongoDbRepositoryTransition(stateS1, stateS2, "E1"); transition.setKind(TransitionKind.EXTERNAL); transitionsRepository.save(transition); - assertThat(statesRepository.count(), is(2l)); + assertThat(statesRepository.count()).isEqualTo(2l); MongoDbRepositoryTransition transition2 = transitionsRepository.findAll().iterator().next(); - assertThat(transition2.getSource().getState(), is("S1")); - assertThat(transition2.getTarget().getState(), is("S2")); - assertThat(transition2.getEvent(), is("E1")); - assertThat(transition2.getKind(), is(TransitionKind.EXTERNAL)); + assertThat(transition2.getSource().getState()).isEqualTo("S1"); + assertThat(transition2.getTarget().getState()).isEqualTo("S2"); + assertThat(transition2.getEvent()).isEqualTo("E1"); + assertThat(transition2.getKind()).isEqualTo(TransitionKind.EXTERNAL); List findByMachineId = statesRepository.findByMachineId(""); - assertThat(findByMachineId.size(), is(2)); + assertThat(findByMachineId).hasSize(2); context.close(); } @@ -127,11 +125,11 @@ public class MongoDbRepositoryTests extends AbstractRepositoryTests { StateMachine stateMachine = resolveMachine(context); doStartAndAssert(stateMachine); - assertThat(stateMachine.getState().getId(), is("S1")); + assertThat(stateMachine.getState().getId()).isEqualTo("S1"); doSendEventAndConsumeAll(stateMachine, "E1"); - assertThat(stateMachine.getState().getId(), is("S2")); + assertThat(stateMachine.getState().getId()).isEqualTo("S2"); doSendEventAndConsumeAll(stateMachine, "E2"); - assertThat(stateMachine.getState().getId(), is("S1")); + assertThat(stateMachine.getState().getId()).isEqualTo("S1"); } @Test @@ -141,11 +139,11 @@ public class MongoDbRepositoryTests extends AbstractRepositoryTests { StateMachine stateMachine = resolveMachine(context); doStartAndAssert(stateMachine); - assertThat(stateMachine.getState().getId(), is(PersistTestStates.S1)); + assertThat(stateMachine.getState().getId()).isEqualTo(PersistTestStates.S1); doSendEventAndConsumeAll(stateMachine, PersistTestEvents.E1); - assertThat(stateMachine.getState().getId(), is(PersistTestStates.S2)); + assertThat(stateMachine.getState().getId()).isEqualTo(PersistTestStates.S2); doSendEventAndConsumeAll(stateMachine, PersistTestEvents.E2); - assertThat(stateMachine.getState().getId(), is(PersistTestStates.S1)); + assertThat(stateMachine.getState().getId()).isEqualTo(PersistTestStates.S1); } @Override diff --git a/spring-statemachine-data/redis/src/test/java/org/springframework/statemachine/data/redis/RedisRepositoryTests.java b/spring-statemachine-data/redis/src/test/java/org/springframework/statemachine/data/redis/RedisRepositoryTests.java index e31dfffb..4a9e9271 100644 --- a/spring-statemachine-data/redis/src/test/java/org/springframework/statemachine/data/redis/RedisRepositoryTests.java +++ b/spring-statemachine-data/redis/src/test/java/org/springframework/statemachine/data/redis/RedisRepositoryTests.java @@ -15,9 +15,7 @@ */ package org.springframework.statemachine.data.redis; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.Matchers.notNullValue; -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; @@ -73,18 +71,18 @@ public class RedisRepositoryTests extends AbstractRepositoryTests { RedisStateRepository stateRepository = context.getBean(RedisStateRepository.class); RedisTransitionRepository transitionRepository = context.getBean(RedisTransitionRepository.class); - assertThat(stateRepository.count(), is(3l)); - assertThat(transitionRepository.count(), is(3l)); + assertThat(stateRepository.count()).isEqualTo(3l); + assertThat(transitionRepository.count()).isEqualTo(3l); List states = new ArrayList<>(); stateRepository.findAll().iterator().forEachRemaining(states::add); List transitions = new ArrayList<>(); transitionRepository.findAll().iterator().forEachRemaining(transitions::add); - assertThat(states.size(), is(3)); - assertThat(transitions.size(), is(3)); + assertThat(states).hasSize(3); + assertThat(transitions).hasSize(3); RedisRepositoryTransition transition1 = transitions.get(0); - assertThat(transition1.getSource(), notNullValue()); - assertThat(transition1.getTarget(), notNullValue()); + assertThat(transition1.getSource()).isNotNull(); + assertThat(transition1.getTarget()).isNotNull(); } @Test @@ -95,27 +93,27 @@ public class RedisRepositoryTests extends AbstractRepositoryTests { RedisStateRepository statesRepository = context.getBean(RedisStateRepository.class); RedisRepositoryState stateS1 = new RedisRepositoryState("S1"); RedisRepositoryState stateS2 = new RedisRepositoryState("S2"); - assertThat(statesRepository.count(), is(0l)); + assertThat(statesRepository.count()).isEqualTo(0l); statesRepository.save(stateS1); statesRepository.save(stateS2); - assertThat(statesRepository.count(), is(2l)); + assertThat(statesRepository.count()).isEqualTo(2l); RedisTransitionRepository transitionsRepository = context.getBean(RedisTransitionRepository.class); RedisRepositoryTransition transition = new RedisRepositoryTransition(stateS1, stateS2, "E1"); transition.setKind(TransitionKind.EXTERNAL); transitionsRepository.save(transition); - assertThat(statesRepository.count(), is(2l)); + assertThat(statesRepository.count()).isEqualTo(2l); RedisRepositoryTransition transition2 = transitionsRepository.findAll().iterator().next(); - assertThat(transition2.getSource().getState(), is("S1")); - assertThat(transition2.getTarget().getState(), is("S2")); - assertThat(transition2.getEvent(), is("E1")); - assertThat(transition2.getKind(), is(TransitionKind.EXTERNAL)); + assertThat(transition2.getSource().getState()).isEqualTo("S1"); + assertThat(transition2.getTarget().getState()).isEqualTo("S2"); + assertThat(transition2.getEvent()).isEqualTo("E1"); + assertThat(transition2.getKind()).isEqualTo(TransitionKind.EXTERNAL); List findByMachineId = statesRepository.findByMachineId(""); - assertThat(findByMachineId.size(), is(2)); + assertThat(findByMachineId).hasSize(2); context.close(); } @@ -127,11 +125,11 @@ public class RedisRepositoryTests extends AbstractRepositoryTests { StateMachine stateMachine = resolveMachine(context); doStartAndAssert(stateMachine); - assertThat(stateMachine.getState().getId(), is("S1")); + assertThat(stateMachine.getState().getId()).isEqualTo("S1"); doSendEventAndConsumeAll(stateMachine, "E1"); - assertThat(stateMachine.getState().getId(), is("S2")); + assertThat(stateMachine.getState().getId()).isEqualTo("S2"); doSendEventAndConsumeAll(stateMachine, "E2"); - assertThat(stateMachine.getState().getId(), is("S1")); + assertThat(stateMachine.getState().getId()).isEqualTo("S1"); } @Test @@ -141,11 +139,11 @@ public class RedisRepositoryTests extends AbstractRepositoryTests { StateMachine stateMachine = resolveMachine(context); doStartAndAssert(stateMachine); - assertThat(stateMachine.getState().getId(), is(PersistTestStates.S1)); + assertThat(stateMachine.getState().getId()).isEqualTo(PersistTestStates.S1); doSendEventAndConsumeAll(stateMachine, PersistTestEvents.E1); - assertThat(stateMachine.getState().getId(), is(PersistTestStates.S2)); + assertThat(stateMachine.getState().getId()).isEqualTo(PersistTestStates.S2); doSendEventAndConsumeAll(stateMachine, PersistTestEvents.E2); - assertThat(stateMachine.getState().getId(), is(PersistTestStates.S1)); + assertThat(stateMachine.getState().getId()).isEqualTo(PersistTestStates.S1); } @Override diff --git a/spring-statemachine-data/src/test/java/org/springframework/statemachine/data/AbstractRepositoryTests.java b/spring-statemachine-data/src/test/java/org/springframework/statemachine/data/AbstractRepositoryTests.java index 53d29091..3fb860a9 100644 --- a/spring-statemachine-data/src/test/java/org/springframework/statemachine/data/AbstractRepositoryTests.java +++ b/spring-statemachine-data/src/test/java/org/springframework/statemachine/data/AbstractRepositoryTests.java @@ -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,9 +15,7 @@ */ package org.springframework.statemachine.data; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.notNullValue; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.Iterator; @@ -349,9 +347,9 @@ public abstract class AbstractRepositoryTests { break; } } - assertThat(endState, notNullValue()); - assertThat(endState.getPseudoState(), notNullValue()); - assertThat(endState.getPseudoState().getKind(), is(PseudoStateKind.END)); + assertThat(endState).isNotNull(); + assertThat(endState.getPseudoState()).isNotNull(); + assertThat(endState.getPseudoState().getKind()).isEqualTo(PseudoStateKind.END); } @SuppressWarnings("unchecked")