Skip to content

Commit 03d74ec

Browse files
Julien KroneggU117293
Julien Kronegg
authored and
U117293
committed
fix: removed mockito InOrder in some tests for #2767 
1 parent 47b94f5 commit 03d74ec

File tree

2 files changed

+155
-82
lines changed

2 files changed

+155
-82
lines changed

‎cucumber-core/src/test/java/io/cucumber/core/runner/HookOrderTest.java

+70-60
Original file line numberDiff line numberDiff line change
@@ -3,25 +3,22 @@
33
import io.cucumber.core.backend.Glue;
44
import io.cucumber.core.backend.HookDefinition;
55
import io.cucumber.core.backend.StubStepDefinition;
6+
import io.cucumber.core.backend.TestCaseState;
67
import io.cucumber.core.eventbus.EventBus;
78
import io.cucumber.core.feature.TestFeatureParser;
89
import io.cucumber.core.gherkin.Feature;
910
import io.cucumber.core.gherkin.Pickle;
1011
import io.cucumber.core.options.RuntimeOptions;
1112
import io.cucumber.core.runtime.TimeServiceEventBus;
1213
import org.junit.jupiter.api.Test;
13-
import org.mockito.ArgumentMatchers;
14-
import org.mockito.InOrder;
1514

1615
import java.net.URI;
1716
import java.time.Clock;
1817
import java.util.ArrayList;
1918
import java.util.List;
2019
import java.util.UUID;
2120

22-
import static org.mockito.Mockito.inOrder;
23-
import static org.mockito.Mockito.mock;
24-
import static org.mockito.Mockito.when;
21+
import static org.junit.jupiter.api.Assertions.assertTrue;
2522

2623
class HookOrderTest {
2724

@@ -34,10 +31,12 @@ class HookOrderTest {
3431
" Scenario: Test scenario\n" +
3532
" Given I have 4 cukes in my belly\n");
3633
private final Pickle pickle = feature.getPickles().get(0);
34+
private final List<HookDefinition> listener = new ArrayList<>();
3735

3836
@Test
3937
void before_hooks_execute_in_order() {
40-
final List<HookDefinition> hooks = mockHooks(3, Integer.MAX_VALUE, 1, -1, 0, 10000, Integer.MIN_VALUE);
38+
final List<HookDefinition> hooks = mockHooks(listener, 3, Integer.MAX_VALUE, 1, -1, 0, 10000,
39+
Integer.MIN_VALUE);
4140

4241
TestRunnerSupplier runnerSupplier = new TestRunnerSupplier(bus, runtimeOptions) {
4342
@Override
@@ -52,31 +51,37 @@ public void loadGlue(Glue glue, List<URI> gluePaths) {
5251

5352
runnerSupplier.get().runPickle(pickle);
5453

55-
InOrder inOrder = inOrder(hooks.toArray());
56-
inOrder.verify(hooks.get(6)).execute(ArgumentMatchers.any());
57-
inOrder.verify(hooks.get(3)).execute(ArgumentMatchers.any());
58-
inOrder.verify(hooks.get(4)).execute(ArgumentMatchers.any());
59-
inOrder.verify(hooks.get(2)).execute(ArgumentMatchers.any());
60-
inOrder.verify(hooks.get(0)).execute(ArgumentMatchers.any());
61-
inOrder.verify(hooks.get(5)).execute(ArgumentMatchers.any());
62-
inOrder.verify(hooks.get(1)).execute(ArgumentMatchers.any());
54+
verifyHookDefinitionExecutedInOrder();
6355
}
6456

65-
private List<HookDefinition> mockHooks(int... ordering) {
57+
private void verifyHookDefinitionExecutedInOrder() {
58+
long previousOrder = Long.MIN_VALUE;
59+
for (HookDefinition hd : listener) {
60+
assertTrue(hd.getOrder() >= previousOrder);
61+
previousOrder = hd.getOrder();
62+
}
63+
}
64+
65+
private void verifyHookDefinitionExecutedInReverseOrder() {
66+
long previousOrder = Long.MAX_VALUE;
67+
for (HookDefinition hd : listener) {
68+
assertTrue(hd.getOrder() <= previousOrder);
69+
previousOrder = hd.getOrder();
70+
}
71+
}
72+
73+
private List<HookDefinition> mockHooks(List<HookDefinition> listener, int... ordering) {
6674
List<HookDefinition> hooks = new ArrayList<>();
6775
for (int order : ordering) {
68-
HookDefinition hook = mock(HookDefinition.class, "Mock number " + order);
69-
when(hook.getOrder()).thenReturn(order);
70-
when(hook.getTagExpression()).thenReturn("");
71-
when(hook.getLocation()).thenReturn("Mock location");
72-
hooks.add(hook);
76+
hooks.add(new MockHookDefinition(order, listener));
7377
}
7478
return hooks;
7579
}
7680

7781
@Test
7882
void before_step_hooks_execute_in_order() {
79-
final List<HookDefinition> hooks = mockHooks(3, Integer.MAX_VALUE, 1, -1, 0, 10000, Integer.MIN_VALUE);
83+
final List<HookDefinition> hooks = mockHooks(listener, 3, Integer.MAX_VALUE, 1, -1, 0, 10000,
84+
Integer.MIN_VALUE);
8085

8186
TestRunnerSupplier runnerSupplier = new TestRunnerSupplier(bus, runtimeOptions) {
8287
@Override
@@ -91,19 +96,13 @@ public void loadGlue(Glue glue, List<URI> gluePaths) {
9196

9297
runnerSupplier.get().runPickle(pickle);
9398

94-
InOrder inOrder = inOrder(hooks.toArray());
95-
inOrder.verify(hooks.get(6)).execute(ArgumentMatchers.any());
96-
inOrder.verify(hooks.get(3)).execute(ArgumentMatchers.any());
97-
inOrder.verify(hooks.get(4)).execute(ArgumentMatchers.any());
98-
inOrder.verify(hooks.get(2)).execute(ArgumentMatchers.any());
99-
inOrder.verify(hooks.get(0)).execute(ArgumentMatchers.any());
100-
inOrder.verify(hooks.get(5)).execute(ArgumentMatchers.any());
101-
inOrder.verify(hooks.get(1)).execute(ArgumentMatchers.any());
99+
verifyHookDefinitionExecutedInOrder();
102100
}
103101

104102
@Test
105103
void after_hooks_execute_in_reverse_order() {
106-
final List<HookDefinition> hooks = mockHooks(Integer.MIN_VALUE, 2, Integer.MAX_VALUE, 4, -1, 0, 10000);
104+
final List<HookDefinition> hooks = mockHooks(listener, Integer.MIN_VALUE, 2, Integer.MAX_VALUE, 4, -1, 0,
105+
10000);
107106

108107
TestRunnerSupplier runnerSupplier = new TestRunnerSupplier(bus, runtimeOptions) {
109108
@Override
@@ -118,19 +117,13 @@ public void loadGlue(Glue glue, List<URI> gluePaths) {
118117

119118
runnerSupplier.get().runPickle(pickle);
120119

121-
InOrder inOrder = inOrder(hooks.toArray());
122-
inOrder.verify(hooks.get(2)).execute(ArgumentMatchers.any());
123-
inOrder.verify(hooks.get(6)).execute(ArgumentMatchers.any());
124-
inOrder.verify(hooks.get(3)).execute(ArgumentMatchers.any());
125-
inOrder.verify(hooks.get(1)).execute(ArgumentMatchers.any());
126-
inOrder.verify(hooks.get(5)).execute(ArgumentMatchers.any());
127-
inOrder.verify(hooks.get(4)).execute(ArgumentMatchers.any());
128-
inOrder.verify(hooks.get(0)).execute(ArgumentMatchers.any());
120+
verifyHookDefinitionExecutedInReverseOrder();
129121
}
130122

131123
@Test
132124
void after_step_hooks_execute_in_reverse_order() {
133-
final List<HookDefinition> hooks = mockHooks(Integer.MIN_VALUE, 2, Integer.MAX_VALUE, 4, -1, 0, 10000);
125+
final List<HookDefinition> hooks = mockHooks(listener, Integer.MIN_VALUE, 2, Integer.MAX_VALUE, 4, -1, 0,
126+
10000);
134127

135128
TestRunnerSupplier runnerSupplier = new TestRunnerSupplier(bus, runtimeOptions) {
136129
@Override
@@ -145,20 +138,13 @@ public void loadGlue(Glue glue, List<URI> gluePaths) {
145138

146139
runnerSupplier.get().runPickle(pickle);
147140

148-
InOrder inOrder = inOrder(hooks.toArray());
149-
inOrder.verify(hooks.get(2)).execute(ArgumentMatchers.any());
150-
inOrder.verify(hooks.get(6)).execute(ArgumentMatchers.any());
151-
inOrder.verify(hooks.get(3)).execute(ArgumentMatchers.any());
152-
inOrder.verify(hooks.get(1)).execute(ArgumentMatchers.any());
153-
inOrder.verify(hooks.get(5)).execute(ArgumentMatchers.any());
154-
inOrder.verify(hooks.get(4)).execute(ArgumentMatchers.any());
155-
inOrder.verify(hooks.get(0)).execute(ArgumentMatchers.any());
141+
verifyHookDefinitionExecutedInReverseOrder();
156142
}
157143

158144
@Test
159145
void hooks_order_across_many_backends() {
160-
final List<HookDefinition> backend1Hooks = mockHooks(3, Integer.MAX_VALUE, 1);
161-
final List<HookDefinition> backend2Hooks = mockHooks(2, Integer.MAX_VALUE, 4);
146+
final List<HookDefinition> backend1Hooks = mockHooks(listener, 3, Integer.MAX_VALUE, 1);
147+
final List<HookDefinition> backend2Hooks = mockHooks(listener, 2, Integer.MAX_VALUE, 4);
162148

163149
TestRunnerSupplier runnerSupplier = new TestRunnerSupplier(bus, runtimeOptions) {
164150
@Override
@@ -177,17 +163,41 @@ public void loadGlue(Glue glue, List<URI> gluePaths) {
177163

178164
runnerSupplier.get().runPickle(pickle);
179165

180-
List<HookDefinition> allHooks = new ArrayList<>();
181-
allHooks.addAll(backend1Hooks);
182-
allHooks.addAll(backend2Hooks);
183-
184-
InOrder inOrder = inOrder(allHooks.toArray());
185-
inOrder.verify(backend1Hooks.get(2)).execute(ArgumentMatchers.any());
186-
inOrder.verify(backend2Hooks.get(0)).execute(ArgumentMatchers.any());
187-
inOrder.verify(backend1Hooks.get(0)).execute(ArgumentMatchers.any());
188-
inOrder.verify(backend2Hooks.get(2)).execute(ArgumentMatchers.any());
189-
inOrder.verify(backend1Hooks.get(1)).execute(ArgumentMatchers.any());
190-
inOrder.verify(backend2Hooks.get(1)).execute(ArgumentMatchers.any());
166+
verifyHookDefinitionExecutedInOrder();
191167
}
192168

169+
private static class MockHookDefinition implements HookDefinition {
170+
private final int order;
171+
private final List<HookDefinition> listener;
172+
173+
public MockHookDefinition(int order, List<HookDefinition> listener) {
174+
this.order = order;
175+
this.listener = listener;
176+
}
177+
178+
@Override
179+
public void execute(TestCaseState state) {
180+
listener.add(this);
181+
}
182+
183+
@Override
184+
public String getTagExpression() {
185+
return "";
186+
}
187+
188+
@Override
189+
public int getOrder() {
190+
return order;
191+
}
192+
193+
@Override
194+
public boolean isDefinedAt(StackTraceElement stackTraceElement) {
195+
return false;
196+
}
197+
198+
@Override
199+
public String getLocation() {
200+
return "Mock location";
201+
}
202+
}
193203
}

‎cucumber-core/src/test/java/io/cucumber/core/runner/HookTestStepTest.java

+85-22
Original file line numberDiff line numberDiff line change
@@ -1,37 +1,38 @@
11
package io.cucumber.core.runner;
22

3+
import io.cucumber.core.backend.HookDefinition;
34
import io.cucumber.core.eventbus.EventBus;
45
import io.cucumber.core.feature.TestFeatureParser;
56
import io.cucumber.core.gherkin.Feature;
7+
import io.cucumber.messages.types.Envelope;
8+
import io.cucumber.plugin.event.EventHandler;
69
import io.cucumber.plugin.event.HookType;
710
import io.cucumber.plugin.event.TestStepFinished;
811
import io.cucumber.plugin.event.TestStepStarted;
9-
import org.junit.jupiter.api.BeforeEach;
1012
import org.junit.jupiter.api.Test;
11-
import org.mockito.InOrder;
12-
import org.mockito.Mockito;
1313

1414
import java.time.Instant;
15+
import java.util.ArrayList;
1516
import java.util.Collections;
17+
import java.util.List;
1618
import java.util.UUID;
1719

1820
import static io.cucumber.core.backend.Status.PASSED;
1921
import static io.cucumber.core.backend.Status.SKIPPED;
2022
import static org.hamcrest.MatcherAssert.assertThat;
2123
import static org.hamcrest.core.Is.is;
2224
import static org.hamcrest.core.IsEqual.equalTo;
23-
import static org.mockito.ArgumentMatchers.isA;
24-
import static org.mockito.Mockito.inOrder;
25-
import static org.mockito.Mockito.mock;
26-
import static org.mockito.Mockito.never;
25+
import static org.junit.jupiter.api.Assertions.assertEquals;
26+
import static org.junit.jupiter.api.Assertions.assertInstanceOf;
2727

2828
class HookTestStepTest {
2929

3030
private final Feature feature = TestFeatureParser.parse("" +
3131
"Feature: Test feature\n" +
3232
" Scenario: Test scenario\n" +
3333
" Given I have 4 cukes in my belly\n");
34-
private final CoreHookDefinition hookDefintion = mock(CoreHookDefinition.class);
34+
List<Object> listener = new ArrayList<>();
35+
private final CoreHookDefinition hookDefintion = CoreHookDefinition.create(new MockHookDefinition(listener));
3536
private final HookDefinitionMatch definitionMatch = new HookDefinitionMatch(hookDefintion);
3637
private final TestCase testCase = new TestCase(
3738
UUID.randomUUID(),
@@ -40,34 +41,26 @@ class HookTestStepTest {
4041
Collections.emptyList(),
4142
feature.getPickles().get(0),
4243
false);
43-
private final EventBus bus = mock(EventBus.class);
44+
private final EventBus bus = new MockEventBus(listener);
4445
private final UUID testExecutionId = UUID.randomUUID();
4546
private final TestCaseState state = new TestCaseState(bus, testExecutionId, testCase);
4647
private final HookTestStep step = new HookTestStep(UUID.randomUUID(), HookType.AFTER_STEP, definitionMatch);
4748

48-
@BeforeEach
49-
void init() {
50-
Mockito.when(bus.getInstant()).thenReturn(Instant.now());
51-
}
52-
5349
@Test
5450
void run_does_run() {
5551
step.run(testCase, bus, state, ExecutionMode.RUN);
5652

57-
InOrder order = inOrder(bus, hookDefintion);
58-
order.verify(bus).send(isA(TestStepStarted.class));
59-
order.verify(hookDefintion).execute(state);
60-
order.verify(bus).send(isA(TestStepFinished.class));
53+
assertInstanceOf(TestStepStarted.class, listener.get(0));
54+
assertEquals("HookDefinition.execute", listener.get(1));
55+
assertInstanceOf(TestStepFinished.class, listener.get(2));
6156
}
6257

6358
@Test
6459
void run_does_dry_run() {
6560
step.run(testCase, bus, state, ExecutionMode.DRY_RUN);
6661

67-
InOrder order = inOrder(bus, hookDefintion);
68-
order.verify(bus).send(isA(TestStepStarted.class));
69-
order.verify(hookDefintion, never()).execute(state);
70-
order.verify(bus).send(isA(TestStepFinished.class));
62+
assertInstanceOf(TestStepStarted.class, listener.get(0));
63+
assertInstanceOf(TestStepFinished.class, listener.get(1));
7164
}
7265

7366
@Test
@@ -91,4 +84,74 @@ void next_execution_mode_is_dry_run_when_step_passes_dry_run() {
9184
assertThat(state.getStatus(), is(equalTo(PASSED)));
9285
}
9386

87+
private static class MockHookDefinition implements HookDefinition {
88+
private final List<Object> listener;
89+
public MockHookDefinition(List<Object> listener) {
90+
this.listener = listener;
91+
}
92+
93+
@Override
94+
public void execute(io.cucumber.core.backend.TestCaseState state) {
95+
listener.add("HookDefinition.execute");
96+
}
97+
98+
@Override
99+
public String getTagExpression() {
100+
return "";
101+
}
102+
103+
@Override
104+
public int getOrder() {
105+
return 0;
106+
}
107+
108+
@Override
109+
public boolean isDefinedAt(StackTraceElement stackTraceElement) {
110+
return false;
111+
}
112+
113+
@Override
114+
public String getLocation() {
115+
return null;
116+
}
117+
}
118+
119+
private static class MockEventBus implements EventBus {
120+
private final List<Object> listener;
121+
public MockEventBus(List<Object> listener) {
122+
this.listener = listener;
123+
}
124+
125+
@Override
126+
public Instant getInstant() {
127+
return Instant.now();
128+
}
129+
130+
@Override
131+
public UUID generateId() {
132+
return null;
133+
}
134+
135+
@Override
136+
public <T> void send(T event) {
137+
if (!(event instanceof Envelope)) {
138+
listener.add(event);
139+
}
140+
}
141+
142+
@Override
143+
public <T> void sendAll(Iterable<T> queue) {
144+
145+
}
146+
147+
@Override
148+
public <T> void registerHandlerFor(Class<T> eventType, EventHandler<T> handler) {
149+
150+
}
151+
152+
@Override
153+
public <T> void removeHandlerFor(Class<T> eventType, EventHandler<T> handler) {
154+
155+
}
156+
}
94157
}

0 commit comments

Comments
 (0)