testIsAvailableWhenIsNotOpenAndIsNotReachRateLimitThenReturnTrue()   A
last analyzed

Complexity

Conditions 1
Paths 1

Size

Total Lines 19
Code Lines 11

Duplication

Lines 0
Ratio 0 %

Importance

Changes 1
Bugs 0 Features 1
Metric Value
eloc 11
c 1
b 0
f 1
dl 0
loc 19
rs 9.9
cc 1
nc 1
nop 0
1
<?php declare(strict_types=1);
2
3
use LeoCarmo\CircuitBreaker\Adapters\AdapterInterface;
4
use LeoCarmo\CircuitBreaker\CircuitBreaker;
5
use PHPUnit\Framework\TestCase;
6
7
class CircuitBreakerTest extends TestCase
8
{
9
    public function testGetAdapter()
10
    {
11
        $expected = $this->createMock(AdapterInterface::class);
12
13
        $circuitBreaker = new CircuitBreaker($expected, 'service');
14
15
        $adapter = $circuitBreaker->getAdapter();
16
17
        static::assertEquals($expected, $adapter);
18
    }
19
20
    public function testGetSettings()
21
    {
22
        $settings = ['timeWindow' => 10];
23
24
        $adapter = $this->createMock(AdapterInterface::class);
25
        $circuitBreaker = new CircuitBreaker($adapter, 'service');
26
27
        $circuitBreaker->setSettings($settings);
28
29
        $globalSettings = $circuitBreaker->getSettings();
30
31
        $expected = [
32
            'timeWindow' => $settings['timeWindow'],
33
            'failureRateThreshold' => CircuitBreaker::FAILURE_RATE_THRESHOLD,
34
            'intervalToHalfOpen' => CircuitBreaker::INTERVAL_TO_HALF_OPEN,
35
        ];
36
37
        static::assertEquals($expected, $globalSettings);
38
    }
39
40
    public function testIsAvailableWhenIsOpenThenReturnFalse()
41
    {
42
        $service = 'service';
43
44
        $adapter = $this->createMock(AdapterInterface::class);
45
46
        $adapter->method('isOpen')
47
            ->with($service)
48
            ->willReturn(true);
49
50
        $circuitBreaker = new CircuitBreaker($adapter, $service);
51
52
        $isAvailable = $circuitBreaker->isAvailable();
53
54
        static::assertFalse($isAvailable);
55
    }
56
57
    public function testIsAvailableWhenReachRateLimitThenReturnFalse()
58
    {
59
        $service = 'service';
60
61
        $adapter = $this->createMock(AdapterInterface::class);
62
63
        $adapter->method('isOpen')
64
            ->with($service)
65
            ->willReturn(false);
66
67
        $adapter->method('reachRateLimit')
68
            ->with($service, CircuitBreaker::FAILURE_RATE_THRESHOLD)
69
            ->willReturn(true);
70
71
        $adapter->expects(self::once())
72
            ->method('setOpenCircuit')
73
            ->with($service, CircuitBreaker::TIME_WINDOW);
74
75
        $adapter->expects(self::once())
76
            ->method('setHalfOpenCircuit')
77
            ->with($service, CircuitBreaker::TIME_WINDOW, CircuitBreaker::INTERVAL_TO_HALF_OPEN);
78
79
        $circuitBreaker = new CircuitBreaker($adapter, $service);
80
81
        $isAvailable = $circuitBreaker->isAvailable();
82
83
        static::assertFalse($isAvailable);
84
    }
85
86
    public function testIsAvailableWhenIsNotOpenAndIsNotReachRateLimitThenReturnTrue()
87
    {
88
        $service = 'service';
89
90
        $adapter = $this->createMock(AdapterInterface::class);
91
92
        $adapter->method('isOpen')
93
            ->with($service)
94
            ->willReturn(false);
95
96
        $adapter->method('reachRateLimit')
97
            ->with($service, CircuitBreaker::FAILURE_RATE_THRESHOLD)
98
            ->willReturn(false);
99
100
        $circuitBreaker = new CircuitBreaker($adapter, $service);
101
102
        $isAvailable = $circuitBreaker->isAvailable();
103
104
        static::assertTrue($isAvailable);
105
    }
106
107
    public function testSuccess()
108
    {
109
        $service = 'service';
110
111
        $adapter = $this->createMock(AdapterInterface::class);
112
113
        $adapter->expects(self::once())
114
            ->method('setSuccess')
115
            ->with($service);
116
117
        $circuitBreaker = new CircuitBreaker($adapter, $service);
118
119
        $circuitBreaker->success();
120
    }
121
}
122