1 package net.secodo.jcircuitbreaker.breakstrategy.impl;
2
3 import net.secodo.jcircuitbreaker.breaker.execution.ExecutedTask;
4 import net.secodo.jcircuitbreaker.task.Task;
5 import net.secodo.jcircuitbreaker.util.TimeUtil;
6 import org.junit.Test;
7 import net.secodo.jcircuitbreaker.breaker.execution.ExecutionContext;
8 import java.lang.reflect.Field;
9 import java.util.ArrayList;
10 import java.util.Collection;
11 import java.util.Collections;
12 import java.util.stream.IntStream;
13 import static org.hamcrest.core.IsEqual.equalTo;
14 import static org.junit.Assert.assertThat;
15 import static org.mockito.Mockito.mock;
16 import static org.mockito.Mockito.reset;
17 import static org.mockito.Mockito.when;
18
19
20 @SuppressWarnings("unchecked")
21 public class LimitedCurrentAverageExecutionTimeStrategyTest {
22 @Test
23 public void shouldNotBreakWhenThereIsNoExecutionYet() throws Exception {
24
25 final Task task = mock(Task.class);
26 final ExecutionContext executionContext = mock(ExecutionContext.class);
27 when(executionContext.getExecutionsInProgress()).thenReturn(Collections.EMPTY_LIST);
28
29 final LimitedCurrentAverageExecutionTimeStrategy strategy = new LimitedCurrentAverageExecutionTimeStrategy(10000);
30
31
32 final boolean shouldBreak = strategy.shouldBreak(task, executionContext);
33
34
35 assertThat(shouldBreak, equalTo(false));
36
37
38 }
39
40 @Test
41 public void shouldNotBreakWhenAverageExecutionTimeIsLessThenMaxTime_1() throws Exception {
42
43 final long maxAllowedExecutionTimeMilis = 8;
44 final int percentageOfLongestTimesToSkip = 0;
45
46 final Collection<ExecutedTask> tasksInProgress = new ArrayList<>();
47
48 final Task task = mock(Task.class);
49 final ExecutionContext executionContext = mock(ExecutionContext.class);
50 when(executionContext.getExecutionsInProgress()).thenReturn(tasksInProgress);
51
52 final TimeUtil timeUtil = mock(TimeUtil.class);
53
54
55 IntStream.range(0, 10).forEach(i -> {
56 ExecutedTask executedTask = new ExecutedTask(mock(Task.class), i);
57 tasksInProgress.add(executedTask);
58 });
59
60 final LimitedCurrentAverageExecutionTimeStrategy strategy = new LimitedCurrentAverageExecutionTimeStrategy(
61 maxAllowedExecutionTimeMilis,
62 percentageOfLongestTimesToSkip);
63
64 final Field timeUtilField = LimitedCurrentAverageExecutionTimeStrategy.class.getDeclaredField("timeUtil");
65 timeUtilField.setAccessible(true);
66 timeUtilField.set(strategy, timeUtil);
67
68 final long currentTimeForStrategy = 10;
69 when(timeUtil.getCurrentTimeMilis()).thenReturn(currentTimeForStrategy);
70
71
72 final boolean shouldBreakResult = strategy.shouldBreak(task, executionContext);
73
74
75 assertThat(shouldBreakResult, equalTo(false));
76
77
78 }
79
80 @Test
81 public void shouldNotBreakWhenAverageExecutionTimeIsLessThenMaxTime_with10PercentOfTimesToSkip() throws Exception {
82
83 final long maxAllowedExecutionTimeMilis = 8;
84 final int percentageOfLongestTimesToSkip = 10;
85
86 final Collection<ExecutedTask> tasksInProgress = new ArrayList<>();
87
88 final Task task = mock(Task.class);
89 final ExecutionContext executionContext = mock(ExecutionContext.class);
90 when(executionContext.getExecutionsInProgress()).thenReturn(tasksInProgress);
91
92 final TimeUtil timeUtil = mock(TimeUtil.class);
93
94
95 IntStream.range(0, 10).forEach(i -> {
96 ExecutedTask executedTask = new ExecutedTask(mock(Task.class), i);
97 tasksInProgress.add(executedTask);
98 });
99
100 final LimitedCurrentAverageExecutionTimeStrategy strategy = new LimitedCurrentAverageExecutionTimeStrategy(
101 maxAllowedExecutionTimeMilis,
102 percentageOfLongestTimesToSkip);
103
104 final Field timeUtilField = LimitedCurrentAverageExecutionTimeStrategy.class.getDeclaredField("timeUtil");
105 timeUtilField.setAccessible(true);
106 timeUtilField.set(strategy, timeUtil);
107
108 final long currentTimeForStrategy = 10;
109 when(timeUtil.getCurrentTimeMilis()).thenReturn(currentTimeForStrategy);
110
111
112 final boolean shouldBreakResult = strategy.shouldBreak(task, executionContext);
113
114
115 assertThat(shouldBreakResult, equalTo(false));
116
117
118 }
119
120 @Test
121 public void shouldNotBreakWhenAverageExecutionTimeIsLessThenMaxTime_with20PercentOfTimesToSkip() throws Exception {
122
123 final long maxAllowedExecutionTimeMilis = 8;
124 final int percentageOfLongestTimesToSkip = 20;
125
126 final Collection<ExecutedTask> tasksInProgress = new ArrayList<>();
127
128 final Task task = mock(Task.class);
129 final ExecutionContext executionContext = mock(ExecutionContext.class);
130 when(executionContext.getExecutionsInProgress()).thenReturn(tasksInProgress);
131
132 final TimeUtil timeUtil = mock(TimeUtil.class);
133
134
135 IntStream.range(0, 10).forEach(i -> {
136 ExecutedTask executedTask = new ExecutedTask(mock(Task.class), i);
137 tasksInProgress.add(executedTask);
138 });
139
140 final LimitedCurrentAverageExecutionTimeStrategy strategy = new LimitedCurrentAverageExecutionTimeStrategy(
141 maxAllowedExecutionTimeMilis,
142 percentageOfLongestTimesToSkip);
143
144 final Field timeUtilField = LimitedCurrentAverageExecutionTimeStrategy.class.getDeclaredField("timeUtil");
145 timeUtilField.setAccessible(true);
146 timeUtilField.set(strategy, timeUtil);
147
148 final long currentTimeForStrategy = 10;
149 when(timeUtil.getCurrentTimeMilis()).thenReturn(currentTimeForStrategy);
150
151
152 final boolean shouldBreakResult = strategy.shouldBreak(task, executionContext);
153
154
155 assertThat(shouldBreakResult, equalTo(false));
156
157
158 }
159
160 @Test
161 public void shouldNotBreakWhenAverageExecutionTimeIsLessThenMaxTime_with30PercentOfTimesToSkip() throws Exception {
162
163 final long maxAllowedExecutionTimeMilis = 8;
164 final int percentageOfLongestTimesToSkip = 30;
165
166 final Collection<ExecutedTask> tasksInProgress = new ArrayList<>();
167
168 final Task task = mock(Task.class);
169 final ExecutionContext executionContext = mock(ExecutionContext.class);
170 when(executionContext.getExecutionsInProgress()).thenReturn(tasksInProgress);
171
172 final TimeUtil timeUtil = mock(TimeUtil.class);
173
174
175 IntStream.range(0, 10).forEach(i -> {
176 ExecutedTask executedTask = new ExecutedTask(mock(Task.class), i);
177 tasksInProgress.add(executedTask);
178 });
179
180 final LimitedCurrentAverageExecutionTimeStrategy strategy = new LimitedCurrentAverageExecutionTimeStrategy(
181 maxAllowedExecutionTimeMilis,
182 percentageOfLongestTimesToSkip);
183
184 final Field timeUtilField = LimitedCurrentAverageExecutionTimeStrategy.class.getDeclaredField("timeUtil");
185 timeUtilField.setAccessible(true);
186 timeUtilField.set(strategy, timeUtil);
187
188 final long currentTimeForStrategy = 10;
189 when(timeUtil.getCurrentTimeMilis()).thenReturn(currentTimeForStrategy);
190
191
192 final boolean shouldBreakResult = strategy.shouldBreak(task, executionContext);
193
194
195 assertThat(shouldBreakResult, equalTo(false));
196 }
197
198 @Test
199 public void shouldNotBreakWhenAverageExecutionTimeIsLessThenMaxTime_with40PercentOfTimesToSkip() throws Exception {
200
201 final long maxAllowedExecutionTimeMilis = 8;
202 final int percentageOfLongestTimesToSkip = 40;
203
204 final Collection<ExecutedTask> tasksInProgress = new ArrayList<>();
205
206 final Task task = mock(Task.class);
207 final ExecutionContext executionContext = mock(ExecutionContext.class);
208 when(executionContext.getExecutionsInProgress()).thenReturn(tasksInProgress);
209
210 final TimeUtil timeUtil = mock(TimeUtil.class);
211
212
213 IntStream.range(0, 10).forEach(i -> {
214 ExecutedTask executedTask = new ExecutedTask(mock(Task.class), i);
215 tasksInProgress.add(executedTask);
216 });
217
218 final LimitedCurrentAverageExecutionTimeStrategy strategy = new LimitedCurrentAverageExecutionTimeStrategy(
219 maxAllowedExecutionTimeMilis,
220 percentageOfLongestTimesToSkip);
221
222 final Field timeUtilField = LimitedCurrentAverageExecutionTimeStrategy.class.getDeclaredField("timeUtil");
223 timeUtilField.setAccessible(true);
224 timeUtilField.set(strategy, timeUtil);
225
226 final long currentTimeForStrategy = 10;
227 when(timeUtil.getCurrentTimeMilis()).thenReturn(currentTimeForStrategy);
228
229
230 final boolean shouldBreakResult = strategy.shouldBreak(task, executionContext);
231
232
233 assertThat(shouldBreakResult, equalTo(false));
234 }
235
236 @Test
237 public void shouldNotBreakWhenAverageExecutionTimeIsLessThenMaxTime_with50PercentOfTimesToSkip() throws Exception {
238
239 final long maxAllowedExecutionTimeMilis = 8;
240 final int percentageOfLongestTimesToSkip = 50;
241
242 final Collection<ExecutedTask> tasksInProgress = new ArrayList<>();
243
244 final Task task = mock(Task.class);
245 final ExecutionContext executionContext = mock(ExecutionContext.class);
246 when(executionContext.getExecutionsInProgress()).thenReturn(tasksInProgress);
247
248 final TimeUtil timeUtil = mock(TimeUtil.class);
249
250
251 IntStream.range(0, 10).forEach(i -> {
252 ExecutedTask executedTask = new ExecutedTask(mock(Task.class), i);
253 tasksInProgress.add(executedTask);
254 });
255
256 final LimitedCurrentAverageExecutionTimeStrategy strategy = new LimitedCurrentAverageExecutionTimeStrategy(
257 maxAllowedExecutionTimeMilis,
258 percentageOfLongestTimesToSkip);
259
260 final Field timeUtilField = LimitedCurrentAverageExecutionTimeStrategy.class.getDeclaredField("timeUtil");
261 timeUtilField.setAccessible(true);
262 timeUtilField.set(strategy, timeUtil);
263
264 final long currentTimeForStrategy = 10;
265 when(timeUtil.getCurrentTimeMilis()).thenReturn(currentTimeForStrategy);
266
267
268 final boolean shouldBreakResult = strategy.shouldBreak(task, executionContext);
269
270
271 assertThat(shouldBreakResult, equalTo(false));
272 }
273
274 @Test
275 public void shouldNotBreakWhenAverageExecutionTimeIsLessThenMaxTime_with60PercentOfTimesToSkip() throws Exception {
276
277 final long maxAllowedExecutionTimeMilis = 8;
278 final int percentageOfLongestTimesToSkip = 60;
279
280 final Collection<ExecutedTask> tasksInProgress = new ArrayList<>();
281
282 final Task task = mock(Task.class);
283 final ExecutionContext executionContext = mock(ExecutionContext.class);
284 when(executionContext.getExecutionsInProgress()).thenReturn(tasksInProgress);
285
286 final TimeUtil timeUtil = mock(TimeUtil.class);
287
288
289 IntStream.range(0, 10).forEach(i -> {
290 ExecutedTask executedTask = new ExecutedTask(mock(Task.class), i);
291 tasksInProgress.add(executedTask);
292 });
293
294 final LimitedCurrentAverageExecutionTimeStrategy strategy = new LimitedCurrentAverageExecutionTimeStrategy(
295 maxAllowedExecutionTimeMilis,
296 percentageOfLongestTimesToSkip);
297
298 final Field timeUtilField = LimitedCurrentAverageExecutionTimeStrategy.class.getDeclaredField("timeUtil");
299 timeUtilField.setAccessible(true);
300 timeUtilField.set(strategy, timeUtil);
301
302 final long currentTimeForStrategy = 10;
303 when(timeUtil.getCurrentTimeMilis()).thenReturn(currentTimeForStrategy);
304
305
306 final boolean shouldBreakResult = strategy.shouldBreak(task, executionContext);
307
308
309 assertThat(shouldBreakResult, equalTo(true));
310 }
311
312 @Test
313 public void shouldNotBreakWhenAverageExecutionTimeIsLessThenMaxTime_with70PercentOfTimesToSkip() throws Exception {
314
315 final long maxAllowedExecutionTimeMilis = 8;
316 final int percentageOfLongestTimesToSkip = 70;
317
318 final Collection<ExecutedTask> tasksInProgress = new ArrayList<>();
319
320 final Task task = mock(Task.class);
321 final ExecutionContext executionContext = mock(ExecutionContext.class);
322 when(executionContext.getExecutionsInProgress()).thenReturn(tasksInProgress);
323
324 final TimeUtil timeUtil = mock(TimeUtil.class);
325
326
327 IntStream.range(0, 10).forEach(i -> {
328 ExecutedTask executedTask = new ExecutedTask(mock(Task.class), i);
329 tasksInProgress.add(executedTask);
330 });
331
332 final LimitedCurrentAverageExecutionTimeStrategy strategy = new LimitedCurrentAverageExecutionTimeStrategy(
333 maxAllowedExecutionTimeMilis,
334 percentageOfLongestTimesToSkip);
335
336 final Field timeUtilField = LimitedCurrentAverageExecutionTimeStrategy.class.getDeclaredField("timeUtil");
337 timeUtilField.setAccessible(true);
338 timeUtilField.set(strategy, timeUtil);
339
340 final long currentTimeForStrategy = 10;
341 when(timeUtil.getCurrentTimeMilis()).thenReturn(currentTimeForStrategy);
342
343
344 final boolean shouldBreakResult = strategy.shouldBreak(task, executionContext);
345
346
347 assertThat(shouldBreakResult, equalTo(true));
348 }
349
350 @Test
351 public void shouldNotBreakWhenAverageExecutionTimeIsLessThenMaxTime_with80PercentOfTimesToSkip() throws Exception {
352
353 final long maxAllowedExecutionTimeMilis = 8;
354 final int percentageOfLongestTimesToSkip = 80;
355
356 final Collection<ExecutedTask> tasksInProgress = new ArrayList<>();
357
358 final Task task = mock(Task.class);
359 final ExecutionContext executionContext = mock(ExecutionContext.class);
360 when(executionContext.getExecutionsInProgress()).thenReturn(tasksInProgress);
361
362 final TimeUtil timeUtil = mock(TimeUtil.class);
363
364
365 IntStream.range(0, 10).forEach(i -> {
366 ExecutedTask executedTask = new ExecutedTask(mock(Task.class), i);
367 tasksInProgress.add(executedTask);
368 });
369
370 final LimitedCurrentAverageExecutionTimeStrategy strategy = new LimitedCurrentAverageExecutionTimeStrategy(
371 maxAllowedExecutionTimeMilis,
372 percentageOfLongestTimesToSkip);
373
374 final Field timeUtilField = LimitedCurrentAverageExecutionTimeStrategy.class.getDeclaredField("timeUtil");
375 timeUtilField.setAccessible(true);
376 timeUtilField.set(strategy, timeUtil);
377
378 final long currentTimeForStrategy = 10;
379 when(timeUtil.getCurrentTimeMilis()).thenReturn(currentTimeForStrategy);
380
381
382 final boolean shouldBreakResult = strategy.shouldBreak(task, executionContext);
383
384
385 assertThat(shouldBreakResult, equalTo(true));
386 }
387
388 @Test
389 public void shouldNotBreakWhenAverageExecutionTimeIsLessThenMaxTime_with90PercentOfTimesToSkip() throws Exception {
390
391 final long maxAllowedExecutionTimeMilis = 8;
392 final int percentageOfLongestTimesToSkip = 90;
393
394 final Collection<ExecutedTask> tasksInProgress = new ArrayList<>();
395
396 final Task task = mock(Task.class);
397 final ExecutionContext executionContext = mock(ExecutionContext.class);
398 when(executionContext.getExecutionsInProgress()).thenReturn(tasksInProgress);
399
400 final TimeUtil timeUtil = mock(TimeUtil.class);
401
402
403 IntStream.range(0, 10).forEach(i -> {
404 ExecutedTask executedTask = new ExecutedTask(mock(Task.class), i);
405 tasksInProgress.add(executedTask);
406 });
407
408 final LimitedCurrentAverageExecutionTimeStrategy strategy = new LimitedCurrentAverageExecutionTimeStrategy(
409 maxAllowedExecutionTimeMilis,
410 percentageOfLongestTimesToSkip);
411
412 final Field timeUtilField = LimitedCurrentAverageExecutionTimeStrategy.class.getDeclaredField("timeUtil");
413 timeUtilField.setAccessible(true);
414 timeUtilField.set(strategy, timeUtil);
415
416 final long currentTimeForStrategy = 10;
417 when(timeUtil.getCurrentTimeMilis()).thenReturn(currentTimeForStrategy);
418
419
420 final boolean shouldBreakResult = strategy.shouldBreak(task, executionContext);
421
422
423 assertThat(shouldBreakResult, equalTo(true));
424 }
425
426 @Test
427 public void shouldNotBreakWhenAverageExecutionTimeIsLessThenMaxTime_with99PercentOfTimesToSkip() throws Exception {
428
429 final long maxAllowedExecutionTimeMilis = 8;
430 final int percentageOfLongestTimesToSkip = 99;
431
432 final Collection<ExecutedTask> tasksInProgress = new ArrayList<>();
433
434 final Task task = mock(Task.class);
435 final ExecutionContext executionContext = mock(ExecutionContext.class);
436 when(executionContext.getExecutionsInProgress()).thenReturn(tasksInProgress);
437
438 final TimeUtil timeUtil = mock(TimeUtil.class);
439
440
441 IntStream.range(0, 10).forEach(i -> {
442 ExecutedTask executedTask = new ExecutedTask(mock(Task.class), i);
443 tasksInProgress.add(executedTask);
444 });
445
446 final LimitedCurrentAverageExecutionTimeStrategy strategy = new LimitedCurrentAverageExecutionTimeStrategy(
447 maxAllowedExecutionTimeMilis,
448 percentageOfLongestTimesToSkip);
449
450 final Field timeUtilField = LimitedCurrentAverageExecutionTimeStrategy.class.getDeclaredField("timeUtil");
451 timeUtilField.setAccessible(true);
452 timeUtilField.set(strategy, timeUtil);
453
454 final long currentTimeForStrategy = 10;
455 when(timeUtil.getCurrentTimeMilis()).thenReturn(currentTimeForStrategy);
456
457
458 final boolean shouldBreakResult = strategy.shouldBreak(task, executionContext);
459
460
461 assertThat(shouldBreakResult, equalTo(false));
462 }
463
464 @Test
465 public void shouldNotBreakWhenAverageExecutionTimeIsLessThenMaxTime_with100PercentOfTimesToSkip() throws Exception {
466
467 final long maxAllowedExecutionTimeMilis = 8;
468 final int percentageOfLongestTimesToSkip = 100;
469
470 final Collection<ExecutedTask> tasksInProgress = new ArrayList<>();
471
472 final Task task = mock(Task.class);
473 final ExecutionContext executionContext = mock(ExecutionContext.class);
474 when(executionContext.getExecutionsInProgress()).thenReturn(tasksInProgress);
475
476 final TimeUtil timeUtil = mock(TimeUtil.class);
477
478
479 IntStream.range(0, 10).forEach(i -> {
480 ExecutedTask executedTask = new ExecutedTask(mock(Task.class), i);
481 tasksInProgress.add(executedTask);
482 });
483
484 final LimitedCurrentAverageExecutionTimeStrategy strategy = new LimitedCurrentAverageExecutionTimeStrategy(
485 maxAllowedExecutionTimeMilis,
486 percentageOfLongestTimesToSkip);
487
488 final Field timeUtilField = LimitedCurrentAverageExecutionTimeStrategy.class.getDeclaredField("timeUtil");
489 timeUtilField.setAccessible(true);
490 timeUtilField.set(strategy, timeUtil);
491
492 final long currentTimeForStrategy = 10;
493 when(timeUtil.getCurrentTimeMilis()).thenReturn(currentTimeForStrategy);
494
495
496 final boolean shouldBreakResult = strategy.shouldBreak(task, executionContext);
497
498
499 assertThat(shouldBreakResult, equalTo(false));
500 }
501
502 @Test
503 public void shouldNotBreakWhenAverageExecutionTimeIsLessThenMaxTime_with105PercentOfTimesToSkip() throws Exception {
504
505 final long maxAllowedExecutionTimeMilis = 8;
506 final int percentageOfLongestTimesToSkip = 105;
507
508 final Collection<ExecutedTask> tasksInProgress = new ArrayList<>();
509
510 final Task task = mock(Task.class);
511 final ExecutionContext executionContext = mock(ExecutionContext.class);
512 when(executionContext.getExecutionsInProgress()).thenReturn(tasksInProgress);
513
514 final TimeUtil timeUtil = mock(TimeUtil.class);
515
516
517 IntStream.range(0, 10).forEach(i -> {
518 ExecutedTask executedTask = new ExecutedTask(mock(Task.class), i);
519 tasksInProgress.add(executedTask);
520 });
521
522 final LimitedCurrentAverageExecutionTimeStrategy strategy = new LimitedCurrentAverageExecutionTimeStrategy(
523 maxAllowedExecutionTimeMilis,
524 percentageOfLongestTimesToSkip);
525
526 final Field timeUtilField = LimitedCurrentAverageExecutionTimeStrategy.class.getDeclaredField("timeUtil");
527 timeUtilField.setAccessible(true);
528 timeUtilField.set(strategy, timeUtil);
529
530 final long currentTimeForStrategy = 10;
531 when(timeUtil.getCurrentTimeMilis()).thenReturn(currentTimeForStrategy);
532
533
534 final boolean shouldBreakResult = strategy.shouldBreak(task, executionContext);
535
536
537 assertThat(shouldBreakResult, equalTo(false));
538 }
539
540 @Test
541 public void shouldNotBreakWhenAverageExecutionTimeIsLessThenMaxTime_withMinus1PercentOfTimesToSkip()
542 throws Exception {
543
544 final long maxAllowedExecutionTimeMilis = 8;
545 final int percentageOfLongestTimesToSkip = -1;
546
547 final Collection<ExecutedTask> tasksInProgress = new ArrayList<>();
548
549 final Task task = mock(Task.class);
550 final ExecutionContext executionContext = mock(ExecutionContext.class);
551 when(executionContext.getExecutionsInProgress()).thenReturn(tasksInProgress);
552
553 final TimeUtil timeUtil = mock(TimeUtil.class);
554
555
556 IntStream.range(0, 10).forEach(i -> {
557 ExecutedTask executedTask = new ExecutedTask(mock(Task.class), i);
558 tasksInProgress.add(executedTask);
559 });
560
561 final LimitedCurrentAverageExecutionTimeStrategy strategy = new LimitedCurrentAverageExecutionTimeStrategy(
562 maxAllowedExecutionTimeMilis,
563 percentageOfLongestTimesToSkip);
564
565 final Field timeUtilField = LimitedCurrentAverageExecutionTimeStrategy.class.getDeclaredField("timeUtil");
566 timeUtilField.setAccessible(true);
567 timeUtilField.set(strategy, timeUtil);
568
569 final long currentTimeForStrategy = 10;
570 when(timeUtil.getCurrentTimeMilis()).thenReturn(currentTimeForStrategy);
571
572
573 final boolean shouldBreakResult = strategy.shouldBreak(task, executionContext);
574
575
576 assertThat(shouldBreakResult, equalTo(false));
577 }
578 }