CircuitBreakerServiceTest - Code Metrics - Inspection of "Merge branch 'master' of github.com:lemonde/php-ci..." - lemonde/php-circuit-breaker-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Branch — master (de56ad)

by Jonathan

created 2016-12-28 14:53 UTC

CircuitBreakerServiceTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	239
Duplicated Lines	56.9 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

Metric	Value
wmc	12
lcom	1
cbo	3
dl	136
loc	239
rs	10
c	0
b	0
f	0

How to fix Duplicated Code

<?php

namespace Tests\CircuitBreakerBundle\Service;

use CircuitBreakerBundle\Service\CircuitBreakerService;

class CircuitBreakerServiceTest extends \PHPUnit_Framework_TestCase
{
    public function setUp()
    {
        $this->mockCacheApp = $this->getMockBuilder('Symfony\Component\Cache\Adapter\AbstractAdapter')
            ->disableOriginalConstructor()
            ->setMethods(['getItem', 'save', 'doHave', 'doFetch', 'doClear', 'doSave', 'doDelete'])
            ->getMock();

        $this->mockLogger = $this->getMockBuilder('Psr\Log\LoggerInterface')
            ->disableOriginalConstructor()
            ->setMethods(['log', 'emergency', 'alert', 'error', 'info', 'debug', 'notice', 'critical', 'warning'])
            ->getMock();

        $this->mockItem = $this->getMockBuilder('Psr\Cache\CacheItemInterface')
            ->disableOriginalConstructor()
            ->setMethods(['get', 'set', 'getKey', 'isHit', 'expiresAt', 'expiresAfter'])
            ->getMock();
    }

    public function testIsClosedByDefault()
    {
        $this->mockCacheApp->expects($this->any())
            ->method('getItem')
            ->willReturn($this->mockItem);

        $service = new CircuitBreakerService($this->mockCacheApp, 2, 20);
        $this->assertEquals(false, $service->isOpen('test'));
    }

    public function testIsClosedWithCallSucceeds()
    {
        $this->mockCacheApp->expects($this->once())
            ->method('getItem')
            ->willReturn($this->mockItem);

        $service = new CircuitBreakerService($this->mockCacheApp, 2, 20);
        $service->setLogger($this->mockLogger);
        $service->save('test', true);

        $this->assertEquals(false, $service->isOpen('test'));
    }

    public function testIsClosedWithManyCallSucceeds()
    {
        $this->mockCacheApp->expects($this->any())
            ->method('getItem')
            ->with('test')
            ->willReturn($this->mockItem);

        $service = new CircuitBreakerService($this->mockCacheApp, 5, 20);
        $service->setLogger($this->mockLogger);
        $service->save('test', true);
        $service->save('test', true);
        $service->save('test', true);
        $service->save('test', true);

        $this->assertEquals(false, $service->isOpen('test'));
    }

    public function testIsClosedWithOneFail()
    {
        $this->mockItem->expects($this->once())
            ->method('set')
            ->with(1);

        $this->mockItem->expects($this->once())
            ->method('expiresAfter')
            ->with(20);

        $this->mockCacheApp->expects($this->once())
            ->method('getItem')
            ->willReturn($this->mockItem);

        $service = new CircuitBreakerService($this->mockCacheApp, 2, 20);
        $service->setLogger($this->mockLogger);
        $service->save('test', false);

        $this->assertEquals(false, $service->isOpen('test'));
    }

    public function testIsClosedWithFailLessThanThreshold()
    {
        $this->mockItem->expects($this->exactly(3))
            ->method('set');

        $this->mockItem->expects($this->exactly(3))
            ->method('expiresAfter')
            ->with(20);

        $this->mockCacheApp->expects($this->exactly(3))
            ->method('getItem')
            ->willReturn($this->mockItem);

        $service = new CircuitBreakerService($this->mockCacheApp, 5, 20);
        $service->setLogger($this->mockLogger);
        $service->save('test', false);
        $service->save('test', false);
        $service->save('test', false);

        $this->assertEquals(false, $service->isOpen('test'));
    }

    public function testIsClosedWithFailAndSucceedsAlternaly()
    {
        $this->mockItem->expects($this->exactly(3))
            ->method('set');

        $this->mockItem->expects($this->exactly(2))
            ->method('expiresAfter')
            ->with(20);

        $this->mockCacheApp->expects($this->exactly(3))
            ->method('getItem')
            ->willReturn($this->mockItem);

        $service = new CircuitBreakerService($this->mockCacheApp, 3, 20);
        $service->setLogger($this->mockLogger);
        $service->save('test', false);
        $service->save('test', false);
        $service->save('test', true);

        $this->assertEquals(false, $service->isOpen('test'));
    }

    public function testIsOpenAfterFailExactlyThreshold()
    {
        $this->mockItem->expects($this->any())
            ->method('set');

        $this->mockItem->expects($this->any())
            ->method('get')
            ->willReturn(3);

        $this->mockItem->expects($this->any())
            ->method('expiresAfter')
            ->with(20);

        $this->mockCacheApp->expects($this->any())
            ->method('getItem')
            ->willReturn($this->mockItem);

        $service = new CircuitBreakerService($this->mockCacheApp, 3, 20);
        $service->setLogger($this->mockLogger);
        $service->save('test', false);

        $this->assertEquals(true, $service->isOpen('test'));
    }

    public function testIsOpenAfterFailMoreThreshold()
    {
        $this->mockItem->expects($this->any())
            ->method('set');

        $this->mockItem->expects($this->any())
            ->method('get')
            ->willReturn(5);

        $this->mockItem->expects($this->any())
            ->method('expiresAfter')
            ->with(20);

        $this->mockCacheApp->expects($this->any())
            ->method('getItem')
            ->willReturn($this->mockItem);

        $service = new CircuitBreakerService($this->mockCacheApp, 3, 20);
        $service->setLogger($this->mockLogger);
        $service->save('test', false);

        $this->assertEquals(true, $service->isOpen('test'));
    }

    public function testIsOpenAfterFailAgainAfterThreshold()
    {
        $this->mockItem->expects($this->any())
            ->method('set');

        $this->mockItem->expects($this->any())
            ->method('get')
            ->willReturn(5);

        $this->mockItem->expects($this->any())
            ->method('expiresAfter')
            ->with(20);

        $this->mockCacheApp->expects($this->any())
            ->method('getItem')
            ->willReturn($this->mockItem);

        $service = new CircuitBreakerService($this->mockCacheApp, 3, 20);
        $service->setLogger($this->mockLogger);
        $service->save('test', false);
        $service->save('test', false);

        $this->assertEquals(true, $service->isOpen('test'));
    }

    public function testIsClosedAfterHalfOpenWithCallSucceeds()
    {
        $this->mockItem->expects($this->any())
            ->method('set');

        $this->mockItem->expects($this->any())
            ->method('get')
            ->willReturn(5);

        $this->mockItem->expects($this->any())
            ->method('expiresAfter')
            ->with(20);

        $this->mockCacheApp->expects($this->any())
            ->method('getItem')
            ->willReturn($this->mockItem);

        $service = new CircuitBreakerService($this->mockCacheApp, 3, 20);
        $service->setLogger($this->mockLogger);
        $service->save('test', false);
        $service->save('test', true);

        $this->assertEquals(false, $service->isOpen('test'));
    }

    public function testIsOpenWhenCacheValueOverThreshold()
    {
        $this->mockItem->expects($this->once())
            ->method('get')
            ->will($this->returnValue(15));

        $this->mockCacheApp->expects($this->once())
            ->method('getItem')
            ->willReturn($this->mockItem);

        $service = new CircuitBreakerService($this->mockCacheApp, 3, 20);
        $service->setLogger($this->mockLogger);

        $this->assertEquals(true, $service->isOpen('test'));
    }
}


1			<?php
2
3			namespace Tests\CircuitBreakerBundle\Service;
4
5			use CircuitBreakerBundle\Service\CircuitBreakerService;
6
7			class CircuitBreakerServiceTest extends \PHPUnit_Framework_TestCase
8			{
9			public function setUp()
10			{
11			$this->mockCacheApp = $this->getMockBuilder('Symfony\Component\Cache\Adapter\AbstractAdapter')
12			->disableOriginalConstructor()
13			->setMethods(['getItem', 'save', 'doHave', 'doFetch', 'doClear', 'doSave', 'doDelete'])
14			->getMock();
15
16			$this->mockLogger = $this->getMockBuilder('Psr\Log\LoggerInterface')
17			->disableOriginalConstructor()
18			->setMethods(['log', 'emergency', 'alert', 'error', 'info', 'debug', 'notice', 'critical', 'warning'])
19			->getMock();
20
21			$this->mockItem = $this->getMockBuilder('Psr\Cache\CacheItemInterface')
22			->disableOriginalConstructor()
23			->setMethods(['get', 'set', 'getKey', 'isHit', 'expiresAt', 'expiresAfter'])
24			->getMock();
25			}
26
27			public function testIsClosedByDefault()
28			{
29			$this->mockCacheApp->expects($this->any())
30			->method('getItem')
31			->willReturn($this->mockItem);
32
33			$service = new CircuitBreakerService($this->mockCacheApp, 2, 20);
34			$this->assertEquals(false, $service->isOpen('test'));
35			}
36
37			public function testIsClosedWithCallSucceeds()
38			{
39			$this->mockCacheApp->expects($this->once())
40			->method('getItem')
41			->willReturn($this->mockItem);
42
43			$service = new CircuitBreakerService($this->mockCacheApp, 2, 20);
44			$service->setLogger($this->mockLogger);
45			$service->save('test', true);
46
47			$this->assertEquals(false, $service->isOpen('test'));
48			}
49
50			public function testIsClosedWithManyCallSucceeds()
51			{
52			$this->mockCacheApp->expects($this->any())
53			->method('getItem')
54			->with('test')
55			->willReturn($this->mockItem);
56
57			$service = new CircuitBreakerService($this->mockCacheApp, 5, 20);
58			$service->setLogger($this->mockLogger);
59			$service->save('test', true);
60			$service->save('test', true);
61			$service->save('test', true);
62			$service->save('test', true);
63
64			$this->assertEquals(false, $service->isOpen('test'));
65			}
66
67			public function testIsClosedWithOneFail()
68			{
69			$this->mockItem->expects($this->once())
70			->method('set')
71			->with(1);
72
73			$this->mockItem->expects($this->once())
74			->method('expiresAfter')
75			->with(20);
76
77			$this->mockCacheApp->expects($this->once())
78			->method('getItem')
79			->willReturn($this->mockItem);
80
81			$service = new CircuitBreakerService($this->mockCacheApp, 2, 20);
82			$service->setLogger($this->mockLogger);
83			$service->save('test', false);
84
85			$this->assertEquals(false, $service->isOpen('test'));
86			}
87
88			public function testIsClosedWithFailLessThanThreshold()
89			{
90			$this->mockItem->expects($this->exactly(3))
91			->method('set');
92
93			$this->mockItem->expects($this->exactly(3))
94			->method('expiresAfter')
95			->with(20);
96
97			$this->mockCacheApp->expects($this->exactly(3))
98			->method('getItem')
99			->willReturn($this->mockItem);
100
101			$service = new CircuitBreakerService($this->mockCacheApp, 5, 20);
102			$service->setLogger($this->mockLogger);
103			$service->save('test', false);
104			$service->save('test', false);
105			$service->save('test', false);
106
107			$this->assertEquals(false, $service->isOpen('test'));
108			}
109
110			public function testIsClosedWithFailAndSucceedsAlternaly()
111			{
112			$this->mockItem->expects($this->exactly(3))
113			->method('set');
114
115			$this->mockItem->expects($this->exactly(2))
116			->method('expiresAfter')
117			->with(20);
118
119			$this->mockCacheApp->expects($this->exactly(3))
120			->method('getItem')
121			->willReturn($this->mockItem);
122
123			$service = new CircuitBreakerService($this->mockCacheApp, 3, 20);
124			$service->setLogger($this->mockLogger);
125			$service->save('test', false);
126			$service->save('test', false);
127			$service->save('test', true);
128
129			$this->assertEquals(false, $service->isOpen('test'));
130			}
131
132			public function testIsOpenAfterFailExactlyThreshold()
133			{
134			$this->mockItem->expects($this->any())
135			->method('set');
136
137			$this->mockItem->expects($this->any())
138			->method('get')
139			->willReturn(3);
140
141			$this->mockItem->expects($this->any())
142			->method('expiresAfter')
143			->with(20);
144
145			$this->mockCacheApp->expects($this->any())
146			->method('getItem')
147			->willReturn($this->mockItem);
148
149			$service = new CircuitBreakerService($this->mockCacheApp, 3, 20);
150			$service->setLogger($this->mockLogger);
151			$service->save('test', false);
152
153			$this->assertEquals(true, $service->isOpen('test'));
154			}
155
156			public function testIsOpenAfterFailMoreThreshold()
157			{
158			$this->mockItem->expects($this->any())
159			->method('set');
160
161			$this->mockItem->expects($this->any())
162			->method('get')
163			->willReturn(5);
164
165			$this->mockItem->expects($this->any())
166			->method('expiresAfter')
167			->with(20);
168
169			$this->mockCacheApp->expects($this->any())
170			->method('getItem')
171			->willReturn($this->mockItem);
172
173			$service = new CircuitBreakerService($this->mockCacheApp, 3, 20);
174			$service->setLogger($this->mockLogger);
175			$service->save('test', false);
176
177			$this->assertEquals(true, $service->isOpen('test'));
178			}
179
180			public function testIsOpenAfterFailAgainAfterThreshold()
181			{
182			$this->mockItem->expects($this->any())
183			->method('set');
184
185			$this->mockItem->expects($this->any())
186			->method('get')
187			->willReturn(5);
188
189			$this->mockItem->expects($this->any())
190			->method('expiresAfter')
191			->with(20);
192
193			$this->mockCacheApp->expects($this->any())
194			->method('getItem')
195			->willReturn($this->mockItem);
196
197			$service = new CircuitBreakerService($this->mockCacheApp, 3, 20);
198			$service->setLogger($this->mockLogger);
199			$service->save('test', false);
200			$service->save('test', false);
201
202			$this->assertEquals(true, $service->isOpen('test'));
203			}
204
205			public function testIsClosedAfterHalfOpenWithCallSucceeds()
206			{
207			$this->mockItem->expects($this->any())
208			->method('set');
209
210			$this->mockItem->expects($this->any())
211			->method('get')
212			->willReturn(5);
213
214			$this->mockItem->expects($this->any())
215			->method('expiresAfter')
216			->with(20);
217
218			$this->mockCacheApp->expects($this->any())
219			->method('getItem')
220			->willReturn($this->mockItem);
221
222			$service = new CircuitBreakerService($this->mockCacheApp, 3, 20);
223			$service->setLogger($this->mockLogger);
224			$service->save('test', false);
225			$service->save('test', true);
226
227			$this->assertEquals(false, $service->isOpen('test'));
228			}
229
230			public function testIsOpenWhenCacheValueOverThreshold()
231			{
232			$this->mockItem->expects($this->once())
233			->method('get')
234			->will($this->returnValue(15));
235
236			$this->mockCacheApp->expects($this->once())
237			->method('getItem')
238			->willReturn($this->mockItem);
239
240			$service = new CircuitBreakerService($this->mockCacheApp, 3, 20);
241			$service->setLogger($this->mockLogger);
242
243			$this->assertEquals(true, $service->isOpen('test'));
244			}
245			}
246

lemonde / php-circuit-breaker-bundle

GitHub Access Token became invalid

Branch — master (de56ad)

CircuitBreakerServiceTest A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like