SystemsRegistryServiceTest - Code Metrics - Inspection of "v1.19.0" - PROCERGS/login-cidadao - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#790)

by Guilherme

created 2018-07-04 20:14 UTC

SystemsRegistryServiceTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	283
Duplicated Lines	0 %

Importance

Changes	4
Bugs	2	Features	0

Metric	Value
dl	0
loc	283
rs	10
c	4
b	2
f	0
wmc	18

<?php
/**
 * This file is part of the login-cidadao project or it's bundles.
 *
 * (c) Guilherme Donato <guilhermednt on github>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace PROCERGS\LoginCidadao\AccountingBundle\Tests\Service;

use GuzzleHttp\ClientInterface;
use GuzzleHttp\Exception\ClientException;
use function GuzzleHttp\Psr7\stream_for;
use LoginCidadao\OAuthBundle\Entity\Client;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use PROCERGS\LoginCidadao\AccountingBundle\Entity\ProcergsLink;
use PROCERGS\LoginCidadao\AccountingBundle\Entity\ProcergsLinkRepository;
use PROCERGS\LoginCidadao\AccountingBundle\Service\SystemsRegistryService;
use Psr\Http\Message\ResponseInterface;
use Psr\Log\LoggerInterface;

/**
 * @codeCoverageIgnore
 */
class SystemsRegistryServiceTest extends TestCase
{
    private $config = [
        'apiUri' => 'https://api.uri/{host}',
        'organization' => 'MyOrganization',
        'registration_number' => 1234,
        'password' => 'ultra_top_secret_password',
    ];

    public function testGetSystemInitials()
    {
        $client = new Client();
        $client->setSiteUrl('http://host1/path');
        $client->setRedirectUris([
            'http://host1/path',
            'http://host2/path',
            'http://host2/path2',
        ]);

        $queries = [];
        $httpClient = $this->getHttpClient();
        $this->httpClientExpectGet($httpClient, $queries, 3);

        $registry = $this->getRegistry($httpClient);

        $initials = $registry->getSystemInitials($client);

        $this->assertContains('http://host1/path', $queries);
        $this->assertContains('http://host2/path', $queries);
        $this->assertContains('http://host2/path2', $queries);
        $this->assertCount(3, $queries);
        $this->assertContains('XPTO', $initials);
    }

    public function testGetSystemInitialsFromCache()
    {
        $client = new Client();
        $client->setSiteUrl('http://host1/path');
        $client->setRedirectUris([
            'http://host1/path',
            'http://host2/path',
            'http://host2/path2',
        ]);

        $queries = [];
        $httpClient = $this->getHttpClient();
        $this->httpClientExpectGet($httpClient, $queries, 3);

        /** @var LoggerInterface|MockObject $logger */
        $logger = $this->createMock('Psr\Log\LoggerInterface');
        // Logger should be called 11 times:
        //      2 for 'Fetching PROCERGS's system initials for client_id'
        //      6 for 'Searching for ...'
        //      3 for 'Returning cached result for ...'
        $logger->expects($this->exactly(11))->method('log')->with('info');

        $registry = $this->getRegistry($httpClient);
        $registry->setLogger($logger);

        $initials = $registry->getSystemInitials($client);
        $registry->getSystemInitials($client);

        $this->assertContains('http://host1/path', $queries);
        $this->assertContains('http://host2/path', $queries);
        $this->assertContains('http://host2/path2', $queries);
        $this->assertCount(3, $queries);
        $this->assertContains('XPTO', $initials);
    }

    public function testGetSystemInitialsNotFound()
    {
        $client = new Client();
        $client->setSiteUrl('http://host1/path');

        $queries = [];
        $httpClient = $this->getHttpClient();
        $httpClient->expects($this->once())->method('request')->with('get')
            ->willReturnCallback(function ($method, $url) use (&$queries) {
                $this->assertSame('get', $method);
                $queries[] = str_replace('https://api.uri/', '', $url);

                $e = $this->getMockBuilder('GuzzleHttp\Exception\ClientException')
                    ->disableOriginalConstructor()->getMock();
                $e->expects($this->exactly(2))->method('getResponse')
                    ->willReturn($this->getResponse(['error' => 'Not found!'], 404));

                throw $e;
            });

        $registry = $this->getRegistry($httpClient);
        $registry->getSystemInitials($client);

        $this->assertContains('http://host1/path', $queries);
        $this->assertCount(1, $queries);
    }

    public function testGetSystemInitialsServerError()
    {
        // Since this is a batch job, we do not handle errors so that the job can fail and alert us.
        $this->expectException(ClientException::class);

        $client = new Client();
        $client->setRedirectUris(['http://host1/path']);

        $queries = [];
        $httpClient = $this->getHttpClient();
        $httpClient->expects($this->once())->method('request')->with('get')
            ->willReturnCallback(function ($url) use (&$queries) {
                $queries[] = str_replace('https://api.uri/', '', $url);

                $e = $this->getMockBuilder(ClientException::class)
                    ->disableOriginalConstructor()->getMock();
                $e->expects($this->once())->method('getResponse')
                    ->willReturn($this->getResponse(null, 500));

                throw $e;
            });

        $registry = $this->getRegistry($httpClient);
        $registry->getSystemInitials($client);
    }

    public function testGetSystemInitialsIgnoreInactiveSystemsWithoutDecommissionDate()
    {
        $queries = [];
        $httpClient = $this->getHttpClient();
        $this->httpClientExpectGet($httpClient, $queries, 1, [
            ['sistema' => 'XPTO1', 'situacao' => 'Implantado'],
            ['sistema' => 'XPTO2', 'situacao' => 'Not Implantado'],
        ]);

        $client = new Client();
        $client->setSiteUrl('http://host1/path');

        $registry = $this->getRegistry($httpClient);
        $initials = $registry->getSystemInitials($client, new \DateTime());

        $this->assertNotEmpty($initials);
        $this->assertContains('XPTO1', $initials);
        $this->assertNotContains('XPTO2', $initials);
    }

    public function testGetSystemInitialsIgnoreInactiveSystemsWithDecommissionDate()
    {
        $queries = [];
        $httpClient = $this->getHttpClient();
        $this->httpClientExpectGet($httpClient, $queries, 1, [
            ['sistema' => 'XPTO1', 'decommissionedOn' => '2018-02-03'],
            ['sistema' => 'XPTO2', 'decommissionedOn' => '2018-01-31'],
        ]);

        $client = new Client();
        $client->setSiteUrl('http://host1/path');

        $registry = $this->getRegistry($httpClient);
        $initials = $registry->getSystemInitials($client, \DateTime::createFromFormat('Y-m-d', '2018-02-01'));

        $this->assertNotEmpty($initials);
        $this->assertContains('XPTO1', $initials);
        $this->assertNotContains('XPTO2', $initials);
    }

    public function testGetSystemOwners()
    {
        $client = new Client();
        $client->setRedirectUris(['https://host1/path', 'https://host2/path']);

        $registry = $this->getRegistry();
        $owners = $registry->getSystemOwners($client);

        $this->assertNotEmpty($owners);
    }

    public function testGetSystemOwnersNotFound()
    {
        $client = new Client();
        $client->setRedirectUris(['https://host1/path', 'https://host2/path']);

        $httpClient = $this->getHttpClient();
        $httpClient->expects($this->atLeastOnce())->method('request')->with('get')
            ->willReturnCallback(function () {
                $e = $this->getMockBuilder('GuzzleHttp\Exception\ClientException')
                    ->disableOriginalConstructor()->getMock();
                $e->expects($this->exactly(2))->method('getResponse')
                    ->willReturn($this->getResponse(['error' => 'Not found!'], 404));

                throw $e;
            });

        $registry = $this->getRegistry($httpClient);
        $owners = $registry->getSystemOwners($client);

        $this->assertEmpty($owners);
    }

    public function testFetchLinked()
    {
        $client = new Client();
        $client->setId(123);

        $link = new ProcergsLink();
        $link->setClient($client)
            ->setSystemType(ProcergsLink::TYPE_INTERNAL);

        /** @var ProcergsLinkRepository|MockObject $repo */
        $repo = $this->getMockBuilder(ProcergsLinkRepository::class)->disableOriginalConstructor()->getMock();
        $repo->expects($this->once())->method('findBy')->willReturn([$link]);

        /** @var ProcergsLinkRepository|MockObject $emptyRepo */
        $emptyRepo = $this->getMockBuilder(ProcergsLinkRepository::class)->disableOriginalConstructor()->getMock();
        $emptyRepo->expects($this->once())->method('findBy')->willReturn([]);

        $registry = $this->getRegistry($this->getHttpClient());
        $empty = $registry->fetchLinked([$client], $emptyRepo);
        $this->assertEmpty($empty);

        $links = $registry->fetchLinked([$client], $repo);
        $this->assertNotEmpty($links);
    }

    /**
     * @return MockObject|ClientInterface
     */
    private function getHttpClient()
    {
        return $this->createMock(ClientInterface::class);
    }

    private function getRegistry($client = null, $options = null)
    {
        if (!$client) {
            $client = $this->getHttpClient();
            $client->expects($this->any())
                ->method('request')->with('get')
                ->willReturn($this->getResponse([
                    [
                        'sistema' => 'XPTO',
                        'clienteDono' => 'CLIENT',
                        'urls' => [
                            'url' => 'https://url.tld/',
                            'ambiente' => 'Produção',
                        ],
                    ],
                ]));
        }

        if (!$options) {
            $options = $this->config;
        }

        return new SystemsRegistryService($client, $options);
    }

    /**
     * @param $json
     * @param null $statusCode
     * @return ResponseInterface|MockObject
     */
    private function getResponse($json = null, $statusCode = null)
    {
        $response = $this->createMock(ResponseInterface::class);
        if ($json) {
            $response->expects($this->atLeastOnce())->method('getBody')->willReturn(stream_for(json_encode($json)));
        }

        if ($statusCode) {
            $response->expects($this->once())->method('getStatusCode')
                ->willReturn($statusCode);
        }

        return $response;
    }

    /**
     * @param ClientInterface|MockObject $httpClient
     * @param $queries
     * @param $count
     * @param array|null $payload
     */
    private function httpClientExpectGet(&$httpClient, &$queries, $count, $payload = null)
    {
        $httpClient->expects($this->exactly($count))->method('request')->with('get')
            ->willReturnCallback(function ($method, $url, $options) use (&$queries, $payload) {
                $this->assertSame('get', $method);
                $queries[] = str_replace('https://api.uri/', '', $url);

                $headers = $options['headers'];
                $this->assertEquals($this->config['organization'], $headers['organizacao']);

                $response = $this->getResponse($payload ?: [['sistema' => 'XPTO']]);

                return $response;
            });
    }
}


1			<?php
2			/**
3			* This file is part of the login-cidadao project or it's bundles.
4			*
5			* (c) Guilherme Donato <guilhermednt on github>
6			*
7			* For the full copyright and license information, please view the LICENSE
8			* file that was distributed with this source code.
9			*/
10
11			namespace PROCERGS\LoginCidadao\AccountingBundle\Tests\Service;
12
13			use GuzzleHttp\ClientInterface;
14			use GuzzleHttp\Exception\ClientException;
15			use function GuzzleHttp\Psr7\stream_for;
16			use LoginCidadao\OAuthBundle\Entity\Client;
17			use PHPUnit\Framework\MockObject\MockObject;
18			use PHPUnit\Framework\TestCase;
19			use PROCERGS\LoginCidadao\AccountingBundle\Entity\ProcergsLink;
20			use PROCERGS\LoginCidadao\AccountingBundle\Entity\ProcergsLinkRepository;
21			use PROCERGS\LoginCidadao\AccountingBundle\Service\SystemsRegistryService;
22			use Psr\Http\Message\ResponseInterface;
23			use Psr\Log\LoggerInterface;
24
25			/**
26			* @codeCoverageIgnore
27			*/
28			class SystemsRegistryServiceTest extends TestCase
29			{
30			private $config = [
31			'apiUri' => 'https://api.uri/{host}',
32			'organization' => 'MyOrganization',
33			'registration_number' => 1234,
34			'password' => 'ultra_top_secret_password',
35			];
36
37			public function testGetSystemInitials()
38			{
39			$client = new Client();
40			$client->setSiteUrl('http://host1/path');
41			$client->setRedirectUris([
42			'http://host1/path',
43			'http://host2/path',
44			'http://host2/path2',
45			]);
46
47			$queries = [];
48			$httpClient = $this->getHttpClient();
49			$this->httpClientExpectGet($httpClient, $queries, 3);
50
51			$registry = $this->getRegistry($httpClient);
52
53			$initials = $registry->getSystemInitials($client);
54
55			$this->assertContains('http://host1/path', $queries);
56			$this->assertContains('http://host2/path', $queries);
57			$this->assertContains('http://host2/path2', $queries);
58			$this->assertCount(3, $queries);
59			$this->assertContains('XPTO', $initials);
60			}
61
62			public function testGetSystemInitialsFromCache()
63			{
64			$client = new Client();
65			$client->setSiteUrl('http://host1/path');
66			$client->setRedirectUris([
67			'http://host1/path',
68			'http://host2/path',
69			'http://host2/path2',
70			]);
71
72			$queries = [];
73			$httpClient = $this->getHttpClient();
74			$this->httpClientExpectGet($httpClient, $queries, 3);
75
76			/** @var LoggerInterface\|MockObject $logger */
77			$logger = $this->createMock('Psr\Log\LoggerInterface');
78			// Logger should be called 11 times:
79			// 2 for 'Fetching PROCERGS's system initials for client_id'
80			// 6 for 'Searching for ...'
81			// 3 for 'Returning cached result for ...'
82			$logger->expects($this->exactly(11))->method('log')->with('info');
83
84			$registry = $this->getRegistry($httpClient);
85			$registry->setLogger($logger);
86
87			$initials = $registry->getSystemInitials($client);
88			$registry->getSystemInitials($client);
89
90			$this->assertContains('http://host1/path', $queries);
91			$this->assertContains('http://host2/path', $queries);
92			$this->assertContains('http://host2/path2', $queries);
93			$this->assertCount(3, $queries);
94			$this->assertContains('XPTO', $initials);
95			}
96
97			public function testGetSystemInitialsNotFound()
98			{
99			$client = new Client();
100			$client->setSiteUrl('http://host1/path');
101
102			$queries = [];
103			$httpClient = $this->getHttpClient();
104			$httpClient->expects($this->once())->method('request')->with('get')
105			->willReturnCallback(function ($method, $url) use (&$queries) {
106			$this->assertSame('get', $method);
107			$queries[] = str_replace('https://api.uri/', '', $url);
108
109			$e = $this->getMockBuilder('GuzzleHttp\Exception\ClientException')
110			->disableOriginalConstructor()->getMock();
111			$e->expects($this->exactly(2))->method('getResponse')
112			->willReturn($this->getResponse(['error' => 'Not found!'], 404));
113
114			throw $e;
115			});
116
117			$registry = $this->getRegistry($httpClient);
118			$registry->getSystemInitials($client);
119
120			$this->assertContains('http://host1/path', $queries);
121			$this->assertCount(1, $queries);
122			}
123
124			public function testGetSystemInitialsServerError()
125			{
126			// Since this is a batch job, we do not handle errors so that the job can fail and alert us.
127			$this->expectException(ClientException::class);
128
129			$client = new Client();
130			$client->setRedirectUris(['http://host1/path']);
131
132			$queries = [];
133			$httpClient = $this->getHttpClient();
134			$httpClient->expects($this->once())->method('request')->with('get')
135			->willReturnCallback(function ($url) use (&$queries) {
136			$queries[] = str_replace('https://api.uri/', '', $url);
137
138			$e = $this->getMockBuilder(ClientException::class)
139			->disableOriginalConstructor()->getMock();
140			$e->expects($this->once())->method('getResponse')
141			->willReturn($this->getResponse(null, 500));
142
143			throw $e;
144			});
145
146			$registry = $this->getRegistry($httpClient);
147			$registry->getSystemInitials($client);
148			}
149
150			public function testGetSystemInitialsIgnoreInactiveSystemsWithoutDecommissionDate()
151			{
152			$queries = [];
153			$httpClient = $this->getHttpClient();
154			$this->httpClientExpectGet($httpClient, $queries, 1, [
155			['sistema' => 'XPTO1', 'situacao' => 'Implantado'],
156			['sistema' => 'XPTO2', 'situacao' => 'Not Implantado'],
157			]);
158
159			$client = new Client();
160			$client->setSiteUrl('http://host1/path');
161
162			$registry = $this->getRegistry($httpClient);
163			$initials = $registry->getSystemInitials($client, new \DateTime());
164
165			$this->assertNotEmpty($initials);
166			$this->assertContains('XPTO1', $initials);
167			$this->assertNotContains('XPTO2', $initials);
168			}
169
170			public function testGetSystemInitialsIgnoreInactiveSystemsWithDecommissionDate()
171			{
172			$queries = [];
173			$httpClient = $this->getHttpClient();
174			$this->httpClientExpectGet($httpClient, $queries, 1, [
175			['sistema' => 'XPTO1', 'decommissionedOn' => '2018-02-03'],
176			['sistema' => 'XPTO2', 'decommissionedOn' => '2018-01-31'],
177			]);
178
179			$client = new Client();
180			$client->setSiteUrl('http://host1/path');
181
182			$registry = $this->getRegistry($httpClient);
183			$initials = $registry->getSystemInitials($client, \DateTime::createFromFormat('Y-m-d', '2018-02-01'));
184
185			$this->assertNotEmpty($initials);
186			$this->assertContains('XPTO1', $initials);
187			$this->assertNotContains('XPTO2', $initials);
188			}
189
190			public function testGetSystemOwners()
191			{
192			$client = new Client();
193			$client->setRedirectUris(['https://host1/path', 'https://host2/path']);
194
195			$registry = $this->getRegistry();
196			$owners = $registry->getSystemOwners($client);
197
198			$this->assertNotEmpty($owners);
199			}
200
201			public function testGetSystemOwnersNotFound()
202			{
203			$client = new Client();
204			$client->setRedirectUris(['https://host1/path', 'https://host2/path']);
205
206			$httpClient = $this->getHttpClient();
207			$httpClient->expects($this->atLeastOnce())->method('request')->with('get')
208			->willReturnCallback(function () {
209			$e = $this->getMockBuilder('GuzzleHttp\Exception\ClientException')
210			->disableOriginalConstructor()->getMock();
211			$e->expects($this->exactly(2))->method('getResponse')
212			->willReturn($this->getResponse(['error' => 'Not found!'], 404));
213
214			throw $e;
215			});
216
217			$registry = $this->getRegistry($httpClient);
218			$owners = $registry->getSystemOwners($client);
219
220			$this->assertEmpty($owners);
221			}
222
223			public function testFetchLinked()
224			{
225			$client = new Client();
226			$client->setId(123);
227
228			$link = new ProcergsLink();
229			$link->setClient($client)
230			->setSystemType(ProcergsLink::TYPE_INTERNAL);
231
232			/** @var ProcergsLinkRepository\|MockObject $repo */
233			$repo = $this->getMockBuilder(ProcergsLinkRepository::class)->disableOriginalConstructor()->getMock();
234			$repo->expects($this->once())->method('findBy')->willReturn([$link]);
235
236			/** @var ProcergsLinkRepository\|MockObject $emptyRepo */
237			$emptyRepo = $this->getMockBuilder(ProcergsLinkRepository::class)->disableOriginalConstructor()->getMock();
238			$emptyRepo->expects($this->once())->method('findBy')->willReturn([]);
239
240			$registry = $this->getRegistry($this->getHttpClient());
241			$empty = $registry->fetchLinked([$client], $emptyRepo);
242			$this->assertEmpty($empty);
243
244			$links = $registry->fetchLinked([$client], $repo);
245			$this->assertNotEmpty($links);
246			}
247
248			/**
249			* @return MockObject\|ClientInterface
250			*/
251			private function getHttpClient()
252			{
253			return $this->createMock(ClientInterface::class);
254			}
255
256			private function getRegistry($client = null, $options = null)
257			{
258			if (!$client) {
259			$client = $this->getHttpClient();
260			$client->expects($this->any())
261			->method('request')->with('get')
262			->willReturn($this->getResponse([
263			[
264			'sistema' => 'XPTO',
265			'clienteDono' => 'CLIENT',
266			'urls' => [
267			'url' => 'https://url.tld/',
268			'ambiente' => 'Produção',
269			],
270			],
271			]));
272			}
273
274			if (!$options) {
275			$options = $this->config;
276			}
277
278			return new SystemsRegistryService($client, $options);
279			}
280
281			/**
282			* @param $json
283			* @param null $statusCode
284			* @return ResponseInterface\|MockObject
285			*/
286			private function getResponse($json = null, $statusCode = null)
287			{
288			$response = $this->createMock(ResponseInterface::class);
289			if ($json) {
290			$response->expects($this->atLeastOnce())->method('getBody')->willReturn(stream_for(json_encode($json)));
291			}
292
293			if ($statusCode) {
294			$response->expects($this->once())->method('getStatusCode')
295			->willReturn($statusCode);
296			}
297
298			return $response;
299			}
300
301			/**
302			* @param ClientInterface\|MockObject $httpClient
303			* @param $queries
304			* @param $count
305			* @param array\|null $payload
306			*/
307			private function httpClientExpectGet(&$httpClient, &$queries, $count, $payload = null)
308			{
309			$httpClient->expects($this->exactly($count))->method('request')->with('get')
310			->willReturnCallback(function ($method, $url, $options) use (&$queries, $payload) {
311			$this->assertSame('get', $method);
312			$queries[] = str_replace('https://api.uri/', '', $url);
313
314			$headers = $options['headers'];
315			$this->assertEquals($this->config['organization'], $headers['organizacao']);
316
317			$response = $this->getResponse($payload ?: [['sistema' => 'XPTO']]);
318
319			return $response;
320			});
321			}
322			}
323

PROCERGS / login-cidadao

Pull Request — master (#790)

SystemsRegistryServiceTest A

Complexity

Size/Duplication

Importance

Duplication Side-by-Side

Filter issues like