ServiceTest::testFindAll() - Code Metrics - Inspection of "Feature/travis" - somework/minjust - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#2)

by Igor

created 2019-10-24 13:20 UTC

ServiceTest::testFindAll() A

↳ Parent: ServiceTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	20
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	10
nc	1
nop	0
dl	0
loc	20
rs	9.9332
c	0
b	0
f	0

<?php
/** @noinspection PhpUnhandledExceptionInspection */

namespace SomeWork\Minjust\Tests\Unit;

use Exception;
use Generator;
use Iterator;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Psr\Http\Client\ClientExceptionInterface;
use ReflectionClass;
use ReflectionException;
use SomeWork\Minjust\Client;
use SomeWork\Minjust\Entity\DetailLawyer;
use SomeWork\Minjust\Entity\LawFormation;
use SomeWork\Minjust\Entity\Lawyer;
use SomeWork\Minjust\FindRequest;
use SomeWork\Minjust\FindResponse;
use SomeWork\Minjust\Parser\ParserInterface;
use SomeWork\Minjust\Service;


/**
 * @coversDefaultClass \SomeWork\Minjust\Service
 */
class ServiceTest extends TestCase
{
    /**
     * @covers ::__construct
     */
    public function testConstructor(): void
    {
        $client = $this->createMock(Client::class);
        $parser = $this->createMock(ParserInterface::class);

        $service = new Service($client, $parser);

        $ref = new ReflectionClass(Service::class);

        $privateClient = $ref->getProperty('client');
        $privateClient->setAccessible(true);

        $privateParser = $ref->getProperty('parser');
        $privateParser->setAccessible(true);

        $this->assertEquals($client, $privateClient->getValue($service));
        $this->assertEquals($parser, $privateParser->getValue($service));
    }

    /**
     * @covers ::findAll
     */
    public function testFindAll(): void
    {
        $request = new FindRequest();

        $fn = static function () {
            yield 1;
        };

        /**
         * @var MockObject|Service $service
         */
        $service = $this->createPartialMock(Service::class, ['findFromTo']);

        $service
            ->expects($this->once())
            ->method('findFromTo')
            ->with($request, 1, 0)
            ->willReturn($fn());

        $service->findAll($request);
    }

    /**
     * @covers ::find
     */
    public function testFind(): void
    {
        /**
         * @var ParserInterface|MockObject $parser
         * @var Service|MockObject         $service
         * @var Client|MockObject          $client
         */
        $lawyer = $this->generateLawyer();

        $response = (new FindResponse())
            ->addLawyer($lawyer)
            ->setPage(1)
            ->setTotalPage(1)
            ->setTotal(1);

        $client = $this->createMock(Client::class);
        $client
            ->method('list')
            ->willReturn('');

        $parser = $this->createMock(ParserInterface::class);
        $parser
            ->method('list')
            ->willReturn($response);

        $service = $this
            ->getMockBuilder(Service::class)
            ->onlyMethods(['getDetailLawyersGenerator'])
            ->setConstructorArgs([$client, $parser])
            ->getMock();

        $service
            ->method('getDetailLawyersGenerator')
            ->willReturn($this->generateDetailLawyerGenerator($lawyer));

        $response = $service->find(new FindRequest());

        $this->assertCount(1, $response->getLawyers());
        $this->assertInstanceOf(Lawyer::class, $response->getLawyers()[0]);
        $this->assertInstanceOf(Generator::class, $response->getDetailLawyers());
    }

    protected function generateLawyer(): Lawyer
    {
        try {
            $id = md5(random_bytes(16));
        } catch (Exception $exception) {
            $id = md5(microtime(true));
        }

        return (new Lawyer())
            ->setTerritorialSubject('Тестовая территория')
            ->setCertificateNumber('test/' . $id)
            ->setRegisterNumber('test/' . $id)
            ->setStatus('Тестовый статус')
            ->setFullName('Тестовый Тест Тестович')
            ->setUrl('/test/' . $id . '/');
    }

    /**
     * @param \SomeWork\Minjust\Entity\Lawyer $lawyer
     *
     * @return Generator
     */
    protected function generateDetailLawyerGenerator(Lawyer $lawyer): Generator
    {
        yield DetailLawyer::init($lawyer);
    }

    /**
     * @covers ::findFromTo
     */
    public function testFindFromToOffsetForOnePage(): void
    {
        $lawyer = $this->generateLawyer();

        $response = (new FindResponse())
            ->setTotal(1)
            ->setTotalPage(1)
            ->setPage(1)
            ->addLawyer($lawyer)
            ->setDetailLawyersGenerator(
                $this->generateDetailLawyerGenerator($lawyer)
            );

        $service = $this
            ->createPartialMock(Service::class, ['find']);
        $service
            ->method('find')
            ->willReturn($response);

        $request = new FindRequest();
        $request->setOffset(1000);

        $response = $service->findFromTo($request, 1, 2);
        $this->assertInstanceOf(Generator::class, $response);

        foreach ($response as $lawyer) {
            $this->assertNotInstanceOf(DetailLawyer::class, $lawyer);
        }
        $this->assertEquals(0, $request->getOffset());

        $request->setFullData(true);
        $response = $service->findFromTo($request, 1, 1);

        $this->assertContainsOnlyInstancesOf(DetailLawyer::class, $response);
    }

    /**
     * @covers ::findFromTo
     * @dataProvider multipleProvider
     *
     * @param bool $isMultiple
     *
     * @throws ClientExceptionInterface
     */
    public function testFindFromToOffsetForMultiplePage(bool $isMultiple): void
    {
        $lawyerFirst = $this->generateLawyer();
        $lawyersSecond = $this->generateLawyer();

        $responseFirst = (new FindResponse())
            ->setTotal(1)
            ->setTotalPage(2)
            ->setPage(1)
            ->addLawyer($lawyerFirst)
            ->setDetailLawyersGenerator(
                $this->generateDetailLawyerGenerator($lawyerFirst)
            );

        $responseSecond = (new FindResponse())
            ->setTotal(1)
            ->setTotalPage(2)
            ->setPage(2)
            ->addLawyer($lawyersSecond)
            ->setDetailLawyersGenerator(
                $this->generateDetailLawyerGenerator($lawyersSecond)
            );

        $service = $this
            ->createPartialMock(Service::class, ['find']);

        $service
            ->expects($this->at(0))
            ->method('find')
            ->willReturn($responseFirst);

        $service
            ->expects($this->at(1))
            ->method('find')
            ->willReturn($responseSecond);

        $request = (new FindRequest())
            ->setMax(1);

        if (!$isMultiple) {
            $response = $service->findFromTo($request, 1, 2);

            $lawyer = $response->current();
            $this->assertInstanceOf(Lawyer::class, $lawyer);
            $this->assertEquals($lawyerFirst, $lawyer);

            $response->next();
            $this->assertEquals(1, $request->getOffset());

            $lawyer = $response->current();
            $this->assertInstanceOf(Lawyer::class, $lawyer);
            $this->assertEquals($lawyersSecond, $lawyer);

            $response->next();
            $this->assertFalse($response->valid());

            return;
        }

        $request->setFullData(true);
        $response = $service->findFromTo($request, 1, 2);

        $this->assertContainsOnlyInstancesOf(DetailLawyer::class, $response);
    }

    public function multipleProvider(): Iterator
    {
        yield [false];
        yield [true];
    }

    /**
     * @covers ::getDetailLawyersGenerator
     */
    public function testGetDetailLawyersGenerator(): void
    {
        $detailFirst = $this->generateDetailLawyer();
        $detailSecond = $this->generateDetailLawyer();

        $lawyerFirst = $this->generateLawyer();
        $lawyerSecond = $this->generateLawyer();

        $client = $this->createMock(Client::class);
        $client
            ->method('detail')
            ->willReturn('');

        $parser = $this->createMock(ParserInterface::class);
        $parser
            ->expects($this->at(0))
            ->method('detail')
            ->willReturn($detailFirst);

        $parser
            ->expects($this->at(1))
            ->method('detail')
            ->willReturn($detailSecond);

        $service = new Service($client, $parser);
        $generator = $this->invokeMethod($service, 'getDetailLawyersGenerator', [[$lawyerFirst, $lawyerSecond]]);

        $this->assertInstanceOf(Generator::class, $generator);

        /**
         * @var DetailLawyer $lawyer
         */
        $lawyer = $generator->current();
        $this->assertInstanceOf(DetailLawyer::class, $lawyer);
        $this->assertEquals($lawyerFirst->getUrl(), $lawyer->getUrl());
        $this->assertEquals($lawyerFirst->getTerritorialSubject(), $lawyer->getTerritorialSubject());
        $this->assertEquals($lawyerFirst->getStatus(), $lawyer->getStatus());
        $this->assertEquals($lawyerFirst->getCertificateNumber(), $lawyer->getCertificateNumber());
        $this->assertEquals($lawyerFirst->getRegisterNumber(), $lawyer->getRegisterNumber());
        $this->assertEquals($lawyerFirst->getFullName(), $lawyer->getFullName());
        $this->assertEquals($detailFirst, $lawyer);

        $generator->next();
        $lawyer = $generator->current();
        $this->assertInstanceOf(DetailLawyer::class, $lawyer);
        $this->assertEquals($lawyerSecond->getUrl(), $lawyer->getUrl());
        $this->assertEquals($lawyerSecond->getTerritorialSubject(), $lawyer->getTerritorialSubject());
        $this->assertEquals($lawyerSecond->getStatus(), $lawyer->getStatus());
        $this->assertEquals($lawyerSecond->getCertificateNumber(), $lawyer->getCertificateNumber());
        $this->assertEquals($lawyerSecond->getRegisterNumber(), $lawyer->getRegisterNumber());
        $this->assertEquals($lawyerSecond->getFullName(), $lawyer->getFullName());
        $this->assertEquals($detailSecond, $lawyer);
    }

    protected function generateDetailLawyer(?Lawyer $lawyer = null): DetailLawyer
    {
        try {
            $id = md5(random_bytes(16));
        } catch (Exception $exception) {
            $id = md5(microtime(true));
        }

        $detailLawyer = (new DetailLawyer())
            ->setChamberOfLaw('Палата ' . $id)
            ->setLawFormation(
                (new LawFormation())
                    ->setPhone('88004443459')
                    ->setAddress('г. Москва, ул. Беговая, д. 2')
                    ->setName('ООО "Бреви Ману" ID: ' . $id)
                    ->setEmail('[email protected]')
            );

        return $lawyer !== null ? $detailLawyer->loadFromLawyer($lawyer) : $detailLawyer;
    }

    /**
     * Call protected/private method of a class.
     *
     * @param object &$object     Instantiated object that we will run method on.
     * @param string  $methodName Method name to call
     * @param array   $parameters Array of parameters to pass into method.
     *
     * @return mixed Method return.
     * @throws ReflectionException
     */
    public function invokeMethod(&$object, $methodName, array $parameters = [])
    {
        $reflection = new ReflectionClass(get_class($object));
        $method = $reflection->getMethod($methodName);
        $method->setAccessible(true);

        return $method->invokeArgs($object, $parameters);
    }

    /**
     * @covers ::getDetailLawyersGenerator
     */
    public function testGetDetailLawyersGeneratorOnEmpty(): void
    {
        $client = $this->createMock(Client::class);
        $parser = $this->createMock(ParserInterface::class);

        $service = new Service($client, $parser);

        /**
         * @var Generator $generator
         */
        $generator = $this->invokeMethod($service, 'getDetailLawyersGenerator', [[]]);
        $this->assertInstanceOf(Generator::class, $generator);
        $this->assertFalse($generator->valid());
    }
}


1			<?php
2			/** @noinspection PhpUnhandledExceptionInspection */
3
4			namespace SomeWork\Minjust\Tests\Unit;
5
6			use Exception;
7			use Generator;
8			use Iterator;
9			use PHPUnit\Framework\MockObject\MockObject;
10			use PHPUnit\Framework\TestCase;
11			use Psr\Http\Client\ClientExceptionInterface;
12			use ReflectionClass;
13			use ReflectionException;
14			use SomeWork\Minjust\Client;
15			use SomeWork\Minjust\Entity\DetailLawyer;
16			use SomeWork\Minjust\Entity\LawFormation;
17			use SomeWork\Minjust\Entity\Lawyer;
18			use SomeWork\Minjust\FindRequest;
19			use SomeWork\Minjust\FindResponse;
20			use SomeWork\Minjust\Parser\ParserInterface;
21			use SomeWork\Minjust\Service;
22
23
24			/**
25			* @coversDefaultClass \SomeWork\Minjust\Service
26			*/
27			class ServiceTest extends TestCase
28			{
29			/**
30			* @covers ::__construct
31			*/
32			public function testConstructor(): void
33			{
34			$client = $this->createMock(Client::class);
35			$parser = $this->createMock(ParserInterface::class);
36
37			$service = new Service($client, $parser);
38
39			$ref = new ReflectionClass(Service::class);
40
41			$privateClient = $ref->getProperty('client');
42			$privateClient->setAccessible(true);
43
44			$privateParser = $ref->getProperty('parser');
45			$privateParser->setAccessible(true);
46
47			$this->assertEquals($client, $privateClient->getValue($service));
48			$this->assertEquals($parser, $privateParser->getValue($service));
49			}
50
51			/**
52			* @covers ::findAll
53			*/
54			public function testFindAll(): void
55			{
56			$request = new FindRequest();
57
58			$fn = static function () {
59			yield 1;
60			};
61
62			/**
63			* @var MockObject\|Service $service
64			*/
65			$service = $this->createPartialMock(Service::class, ['findFromTo']);
66
67			$service
68			->expects($this->once())
69			->method('findFromTo')
70			->with($request, 1, 0)
71			->willReturn($fn());
72
73			$service->findAll($request);
74			}
75
76			/**
77			* @covers ::find
78			*/
79			public function testFind(): void
80			{
81			/**
82			* @var ParserInterface\|MockObject $parser
83			* @var Service\|MockObject $service
84			* @var Client\|MockObject $client
85			*/
86			$lawyer = $this->generateLawyer();
87
88			$response = (new FindResponse())
89			->addLawyer($lawyer)
90			->setPage(1)
91			->setTotalPage(1)
92			->setTotal(1);
93
94			$client = $this->createMock(Client::class);
95			$client
96			->method('list')
97			->willReturn('');
98
99			$parser = $this->createMock(ParserInterface::class);
100			$parser
101			->method('list')
102			->willReturn($response);
103
104			$service = $this
105			->getMockBuilder(Service::class)
106			->onlyMethods(['getDetailLawyersGenerator'])
107			->setConstructorArgs([$client, $parser])
108			->getMock();
109
110			$service
111			->method('getDetailLawyersGenerator')
112			->willReturn($this->generateDetailLawyerGenerator($lawyer));
113
114			$response = $service->find(new FindRequest());
115
116			$this->assertCount(1, $response->getLawyers());
117			$this->assertInstanceOf(Lawyer::class, $response->getLawyers()[0]);
118			$this->assertInstanceOf(Generator::class, $response->getDetailLawyers());
119			}
120
121			protected function generateLawyer(): Lawyer
122			{
123			try {
124			$id = md5(random_bytes(16));
125			} catch (Exception $exception) {
126			$id = md5(microtime(true));
127			}
128
129			return (new Lawyer())
130			->setTerritorialSubject('Тестовая территория')
131			->setCertificateNumber('test/' . $id)
132			->setRegisterNumber('test/' . $id)
133			->setStatus('Тестовый статус')
134			->setFullName('Тестовый Тест Тестович')
135			->setUrl('/test/' . $id . '/');
136			}
137
138			/**
139			* @param \SomeWork\Minjust\Entity\Lawyer $lawyer
140			*
141			* @return Generator
142			*/
143			protected function generateDetailLawyerGenerator(Lawyer $lawyer): Generator
144			{
145			yield DetailLawyer::init($lawyer);
146			}
147
148			/**
149			* @covers ::findFromTo
150			*/
151			public function testFindFromToOffsetForOnePage(): void
152			{
153			$lawyer = $this->generateLawyer();
154
155			$response = (new FindResponse())
156			->setTotal(1)
157			->setTotalPage(1)
158			->setPage(1)
159			->addLawyer($lawyer)
160			->setDetailLawyersGenerator(
161			$this->generateDetailLawyerGenerator($lawyer)
162			);
163
164			$service = $this
165			->createPartialMock(Service::class, ['find']);
166			$service
167			->method('find')
168			->willReturn($response);
169
170			$request = new FindRequest();
171			$request->setOffset(1000);
172
173			$response = $service->findFromTo($request, 1, 2);
174			$this->assertInstanceOf(Generator::class, $response);
175
176			foreach ($response as $lawyer) {
177			$this->assertNotInstanceOf(DetailLawyer::class, $lawyer);
178			}
179			$this->assertEquals(0, $request->getOffset());
180
181			$request->setFullData(true);
182			$response = $service->findFromTo($request, 1, 1);
183
184			$this->assertContainsOnlyInstancesOf(DetailLawyer::class, $response);
185			}
186
187			/**
188			* @covers ::findFromTo
189			* @dataProvider multipleProvider
190			*
191			* @param bool $isMultiple
192			*
193			* @throws ClientExceptionInterface
194			*/
195			public function testFindFromToOffsetForMultiplePage(bool $isMultiple): void
196			{
197			$lawyerFirst = $this->generateLawyer();
198			$lawyersSecond = $this->generateLawyer();
199
200			$responseFirst = (new FindResponse())
201			->setTotal(1)
202			->setTotalPage(2)
203			->setPage(1)
204			->addLawyer($lawyerFirst)
205			->setDetailLawyersGenerator(
206			$this->generateDetailLawyerGenerator($lawyerFirst)
207			);
208
209			$responseSecond = (new FindResponse())
210			->setTotal(1)
211			->setTotalPage(2)
212			->setPage(2)
213			->addLawyer($lawyersSecond)
214			->setDetailLawyersGenerator(
215			$this->generateDetailLawyerGenerator($lawyersSecond)
216			);
217
218			$service = $this
219			->createPartialMock(Service::class, ['find']);
220
221			$service
222			->expects($this->at(0))
223			->method('find')
224			->willReturn($responseFirst);
225
226			$service
227			->expects($this->at(1))
228			->method('find')
229			->willReturn($responseSecond);
230
231			$request = (new FindRequest())
232			->setMax(1);
233
234			if (!$isMultiple) {
235			$response = $service->findFromTo($request, 1, 2);
236
237			$lawyer = $response->current();
238			$this->assertInstanceOf(Lawyer::class, $lawyer);
239			$this->assertEquals($lawyerFirst, $lawyer);
240
241			$response->next();
242			$this->assertEquals(1, $request->getOffset());
243
244			$lawyer = $response->current();
245			$this->assertInstanceOf(Lawyer::class, $lawyer);
246			$this->assertEquals($lawyersSecond, $lawyer);
247
248			$response->next();
249			$this->assertFalse($response->valid());
250
251			return;
252			}
253
254			$request->setFullData(true);
255			$response = $service->findFromTo($request, 1, 2);
256
257			$this->assertContainsOnlyInstancesOf(DetailLawyer::class, $response);
258			}
259
260			public function multipleProvider(): Iterator
261			{
262			yield [false];
263			yield [true];
264			}
265
266			/**
267			* @covers ::getDetailLawyersGenerator
268			*/
269			public function testGetDetailLawyersGenerator(): void
270			{
271			$detailFirst = $this->generateDetailLawyer();
272			$detailSecond = $this->generateDetailLawyer();
273
274			$lawyerFirst = $this->generateLawyer();
275			$lawyerSecond = $this->generateLawyer();
276
277			$client = $this->createMock(Client::class);
278			$client
279			->method('detail')
280			->willReturn('');
281
282			$parser = $this->createMock(ParserInterface::class);
283			$parser
284			->expects($this->at(0))
285			->method('detail')
286			->willReturn($detailFirst);
287
288			$parser
289			->expects($this->at(1))
290			->method('detail')
291			->willReturn($detailSecond);
292
293			$service = new Service($client, $parser);
294			$generator = $this->invokeMethod($service, 'getDetailLawyersGenerator', [[$lawyerFirst, $lawyerSecond]]);
295
296			$this->assertInstanceOf(Generator::class, $generator);
297
298			/**
299			* @var DetailLawyer $lawyer
300			*/
301			$lawyer = $generator->current();
302			$this->assertInstanceOf(DetailLawyer::class, $lawyer);
303			$this->assertEquals($lawyerFirst->getUrl(), $lawyer->getUrl());
304			$this->assertEquals($lawyerFirst->getTerritorialSubject(), $lawyer->getTerritorialSubject());
305			$this->assertEquals($lawyerFirst->getStatus(), $lawyer->getStatus());
306			$this->assertEquals($lawyerFirst->getCertificateNumber(), $lawyer->getCertificateNumber());
307			$this->assertEquals($lawyerFirst->getRegisterNumber(), $lawyer->getRegisterNumber());
308			$this->assertEquals($lawyerFirst->getFullName(), $lawyer->getFullName());
309			$this->assertEquals($detailFirst, $lawyer);
310
311			$generator->next();
312			$lawyer = $generator->current();
313			$this->assertInstanceOf(DetailLawyer::class, $lawyer);
314			$this->assertEquals($lawyerSecond->getUrl(), $lawyer->getUrl());
315			$this->assertEquals($lawyerSecond->getTerritorialSubject(), $lawyer->getTerritorialSubject());
316			$this->assertEquals($lawyerSecond->getStatus(), $lawyer->getStatus());
317			$this->assertEquals($lawyerSecond->getCertificateNumber(), $lawyer->getCertificateNumber());
318			$this->assertEquals($lawyerSecond->getRegisterNumber(), $lawyer->getRegisterNumber());
319			$this->assertEquals($lawyerSecond->getFullName(), $lawyer->getFullName());
320			$this->assertEquals($detailSecond, $lawyer);
321			}
322
323			protected function generateDetailLawyer(?Lawyer $lawyer = null): DetailLawyer
324			{
325			try {
326			$id = md5(random_bytes(16));
327			} catch (Exception $exception) {
328			$id = md5(microtime(true));
329			}
330
331			$detailLawyer = (new DetailLawyer())
332			->setChamberOfLaw('Палата ' . $id)
333			->setLawFormation(
334			(new LawFormation())
335			->setPhone('88004443459')
336			->setAddress('г. Москва, ул. Беговая, д. 2')
337			->setName('ООО "Бреви Ману" ID: ' . $id)
338			->setEmail('[email protected]')
339			);
340
341			return $lawyer !== null ? $detailLawyer->loadFromLawyer($lawyer) : $detailLawyer;
342			}
343
344			/**
345			* Call protected/private method of a class.
346			*
347			* @param object &$object Instantiated object that we will run method on.
348			* @param string $methodName Method name to call
349			* @param array $parameters Array of parameters to pass into method.
350			*
351			* @return mixed Method return.
352			* @throws ReflectionException
353			*/
354			public function invokeMethod(&$object, $methodName, array $parameters = [])
355			{
356			$reflection = new ReflectionClass(get_class($object));
357			$method = $reflection->getMethod($methodName);
358			$method->setAccessible(true);
359
360			return $method->invokeArgs($object, $parameters);
361			}
362
363			/**
364			* @covers ::getDetailLawyersGenerator
365			*/
366			public function testGetDetailLawyersGeneratorOnEmpty(): void
367			{
368			$client = $this->createMock(Client::class);
369			$parser = $this->createMock(ParserInterface::class);
370
371			$service = new Service($client, $parser);
372
373			/**
374			* @var Generator $generator
375			*/
376			$generator = $this->invokeMethod($service, 'getDetailLawyersGenerator', [[]]);
377			$this->assertInstanceOf(Generator::class, $generator);
378			$this->assertFalse($generator->valid());
379			}
380			}
381

somework / minjust

Pull Request — master (#2)

ServiceTest::testFindAll() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like