View Javadoc
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      // given
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      // when
38      final boolean breakResult = breakStrategy.shouldBreak(task, executionContext);
39  
40      // then
41      assertThat(breakResult, equalTo(true));
42    }
43  
44    @Test
45    public void shouldBreakWhenMoreThenAllowedNumberOfExecutionsAreInProgress() {
46      // given
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      // when
61      final boolean breakResult = breakStrategy.shouldBreak(task, executionContext);
62  
63      // then
64      assertThat(breakResult, equalTo(true));
65    }
66  
67    @Test
68    public void shouldNotBreakWhenNumberOfAllowedExecutionsIsNotExceeded() {
69      // given
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      // when
84      final boolean breakResult = breakStrategy.shouldBreak(task, executionContext);
85  
86      // then
87      assertThat(breakResult, equalTo(false));
88    }
89  
90  
91  }