1 package net.secodo.jcircuitbreaker.breakstrategy.impl;
2
3 import net.secodo.jcircuitbreaker.breaker.execution.ExecutedTask;
4 import net.secodo.jcircuitbreaker.breakstrategy.BreakStrategy;
5 import net.secodo.jcircuitbreaker.breaker.execution.ExecutionContext;
6 import net.secodo.jcircuitbreaker.task.Task;
7 import org.junit.Test;
8 import java.util.ArrayList;
9 import java.util.List;
10 import java.util.stream.IntStream;
11 import static org.hamcrest.core.IsEqual.equalTo;
12 import static org.junit.Assert.assertThat;
13 import static org.junit.Assert.assertTrue;
14 import static org.mockito.Mockito.mock;
15 import static org.mockito.Mockito.when;
16
17
18 @SuppressWarnings("unchecked")
19 public class LimitedConcurrentExecutionsStrategyTest {
20 @Test
21 public void shouldBreakWhenTwoExecutionsAllowedAndThirdTaskIsAboutToExecute() {
22
23 final int maxSupportedExecutions = 2;
24 final BreakStrategy breakStrategy = new LimitedConcurrentExecutionsStrategy(maxSupportedExecutions);
25 final Task task = mock(Task.class);
26 final ExecutionContext executionContext = mock(ExecutionContext.class);
27
28 final List<ExecutedTask> executionsInProgress = new ArrayList<ExecutedTask>() {{
29 add(mock(ExecutedTask.class));
30 add(mock(ExecutedTask.class));
31 }};
32
33 assertTrue(executionsInProgress.size() == maxSupportedExecutions);
34
35 when(executionContext.getExecutionsInProgress()).thenReturn(executionsInProgress);
36
37
38 final boolean breakResult = breakStrategy.shouldBreak(task, executionContext);
39
40
41 assertThat(breakResult, equalTo(true));
42 }
43
44 @Test
45 public void shouldBreakWhenMoreThenAllowedNumberOfExecutionsAreInProgress() {
46
47 final int maxSupportedExecutions = 20;
48 final BreakStrategy breakStrategy = new LimitedConcurrentExecutionsStrategy(maxSupportedExecutions);
49 final Task task = mock(Task.class);
50 final ExecutionContext executionContext = mock(ExecutionContext.class);
51
52 final List<ExecutedTask> executionsInProgress = new ArrayList<>();
53 IntStream.range(0, maxSupportedExecutions).forEach(i ->
54 executionsInProgress.add(new ExecutedTask(mock(Task.class), i)));
55
56 assertTrue(executionsInProgress.size() == maxSupportedExecutions);
57
58 when(executionContext.getExecutionsInProgress()).thenReturn(executionsInProgress);
59
60
61 final boolean breakResult = breakStrategy.shouldBreak(task, executionContext);
62
63
64 assertThat(breakResult, equalTo(true));
65 }
66
67 @Test
68 public void shouldNotBreakWhenNumberOfAllowedExecutionsIsNotExceeded() {
69
70 final int maxSupportedExecutions = 20;
71 final BreakStrategy breakStrategy = new LimitedConcurrentExecutionsStrategy(maxSupportedExecutions);
72 final ExecutionContext executionContext = mock(ExecutionContext.class);
73 final Task task = mock(Task.class);
74
75 final List<ExecutedTask> executionsInProgress = new ArrayList<>();
76 IntStream.range(0, maxSupportedExecutions - 1).forEach(i ->
77 executionsInProgress.add(new ExecutedTask(mock(Task.class), i)));
78
79 assertTrue(executionsInProgress.size() < maxSupportedExecutions);
80
81 when(executionContext.getExecutionsInProgress()).thenReturn(executionsInProgress);
82
83
84 final boolean breakResult = breakStrategy.shouldBreak(task, executionContext);
85
86
87 assertThat(breakResult, equalTo(false));
88 }
89
90
91 }