PersonSerializeEventSubscriberTest::getEvent() - Code Metrics - Inspection of "added missing tests PROCERGS#666" - PROCERGS/login-cidadao - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — issue#666 ( 0a0cb9...d66c4e )

by Guilherme

created 2018-02-23 17:39 UTC

PersonSerializeEventSubscriberTest::getEvent() A

↳ Parent: PersonSerializeEventSubscriberTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	2
nc	1
nop	0
dl	0
loc	4
rs	10
c	0
b	0
f	0

<?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 LoginCidadao\RemoteClaimsBundle\Tests\EventSubscriber;

use JMS\Serializer\EventDispatcher\Events;
use JMS\Serializer\EventDispatcher\ObjectEvent;
use JMS\Serializer\GenericSerializationVisitor;
use LoginCidadao\APIBundle\Service\VersionService;
use LoginCidadao\CoreBundle\Model\PersonInterface;
use LoginCidadao\OAuthBundle\Model\AccessTokenManager;
use LoginCidadao\OAuthBundle\Model\ClientInterface;
use LoginCidadao\RemoteClaimsBundle\Entity\RemoteClaim;
use LoginCidadao\RemoteClaimsBundle\Entity\RemoteClaimAuthorization;
use LoginCidadao\RemoteClaimsBundle\EventSubscriber\PersonSerializeEventSubscriber;
use LoginCidadao\RemoteClaimsBundle\Exception\ClaimUriUnavailableException;
use LoginCidadao\RemoteClaimsBundle\Model\ClaimProviderInterface;
use LoginCidadao\RemoteClaimsBundle\Model\RemoteClaimFetcherInterface;
use LoginCidadao\RemoteClaimsBundle\Model\RemoteClaimManagerInterface;
use LoginCidadao\RemoteClaimsBundle\Model\TagUri;

class PersonSerializeEventSubscriberTest extends \PHPUnit_Framework_TestCase
{
    // PersonSerializeEventSubscriber

    public function testGetSubscribedEvents()
    {
        $this->assertEquals([
            [
                'event' => Events::POST_SERIALIZE,
                'method' => 'onPostSerialize',
                'class' => 'LoginCidadao\CoreBundle\Model\PersonInterface',
            ],
        ], PersonSerializeEventSubscriber::getSubscribedEvents());
    }

    public function testRunsOnlyForPersonObjects()
    {
        $event = $this->getEvent();
        $event->expects($this->once())->method('getObject')->willReturn(new \stdClass());

        $subscriber = $this->getSubscriber();
        $subscriber->onPostSerialize($event);
    }

    public function testWontRunForVersion1_2_3()
    {
        $this->checkVersion([1, 2, 3], false);
    }

    public function testWillRunForVersion2_3_4()
    {
        $this->checkVersion([2, 3, 4], true);
    }

    public function testWillRunForVersion3_4_5()
    {
        $this->checkVersion([3, 4, 5], true);
    }

    public function testAddRemoteClaim()
    {
        $dummyJson = [];
        $endpoint = 'https://dummy/endpoint';
        $fetcher = $this->getFetcher();
        $fetcher->expects($this->once())->method('discoverClaimUri')->willReturn($endpoint);

        $this->runAddDistributedAndAggregatedClaimsTest($fetcher, $dummyJson);

        $tag = 'tag:example.com,2018-01:example';
        $accessToken = 'my_secret_access_token';
        $this->assertEquals([
            $tag => [
                'endpoint' => $endpoint,
                'access_token' => $accessToken,
            ],
        ], $dummyJson['_claim_sources']);

        $this->assertEquals([$tag => $tag], $dummyJson['_claim_names']);
    }

    public function testUnknownEndpoint()
    {
        $dummyJson = [];
        $fetcher = $this->getFetcher();
        $fetcher->expects($this->once())->method('discoverClaimUri')
            ->willThrowException(new ClaimUriUnavailableException());

        $this->runAddDistributedAndAggregatedClaimsTest($fetcher, $dummyJson);

        $this->assertEmpty($dummyJson['_claim_names']);
        $this->assertEmpty($dummyJson['_claim_sources']);
    }

    public function runAddDistributedAndAggregatedClaimsTest($fetcher, &$dummyJson)
    {
        $person = $this->getPerson();
        $client = $this->getClient();
        $tag = 'tag:example.com,2018-01:example';
        $claimName = TagUri::createFromString($tag);
        $accessToken = 'my_secret_access_token';

        $remoteClaims = [
            [
                'remoteClaim' => (new RemoteClaim())
                    ->setProvider($client)
                    ->setName($claimName),
                'authorization' => (new RemoteClaimAuthorization())
                    ->setAccessToken($accessToken),
            ],
        ];

        $visitor = $this->getVisitor();
        $visitor->expects($this->exactly(2))
            ->method('addData')->willReturnCallback(function ($key, $value) use (&$dummyJson) {
                $this->assertContains($key, ['_claim_names', '_claim_sources']);
                $dummyJson[$key] = $value;
            });

        $event = $this->getEvent();
        $event->expects($this->once())->method('getVisitor')->willReturn($visitor);
        $event->expects($this->exactly(2))->method('getObject')->willReturn($person);

        $accessTokenManager = $this->getAccessTokenManager();
        $accessTokenManager->expects($this->once())->method('getTokenClient')->willReturn($client);

        $remoteClaimManager = $this->getRemoteClaimManager();
        $remoteClaimManager->expects($this->once())
            ->method('getRemoteClaimsWithTokens')->with($client, $person)
            ->willReturn($remoteClaims);

        $versionService = $this->getVersionService([2, 0, 0]);

        $subscriber = $this->getSubscriber($accessTokenManager, $remoteClaimManager, $fetcher, $versionService);
        $subscriber->onPostSerialize($event);
    }

    /**
     * @param array $version
     * @param bool $shouldRun
     */
    private function checkVersion($version, $shouldRun)
    {
        $event = $this->getEvent();
        $event->expects($this->once())->method('getObject')->willReturn($this->getPerson());
        if ($shouldRun) {
            $event->expects($this->once())->method('getVisitor')->willReturn(new \stdClass());
        } else {
            $event->expects($this->never())->method('getVisitor');
        }

        $versionService = $this->getVersionService($version);

        $subscriber = $this->getSubscriber(null, null, null, $versionService);
        $subscriber->onPostSerialize($event);
    }

    /**
     * @return ObjectEvent|\PHPUnit_Framework_MockObject_MockObject
     */
    private function getEvent()
    {
        return $this->getMockBuilder('JMS\Serializer\EventDispatcher\ObjectEvent')
            ->disableOriginalConstructor()->getMock();
    }

    /**
     * @return PersonInterface|\PHPUnit_Framework_MockObject_MockObject
     */
    private function getPerson()
    {
        return $this->getMock('LoginCidadao\CoreBundle\Model\PersonInterface');
    }

    /**
     * @return ClaimProviderInterface|ClientInterface|\PHPUnit_Framework_MockObject_MockObject
     */
    private function getClient()
    {
        return $this->getMock('LoginCidadao\OAuthBundle\Entity\Client');
    }

    /**
     * @return AccessTokenManager|\PHPUnit_Framework_MockObject_MockObject
     */
    private function getAccessTokenManager()
    {
        return $this->getMockBuilder('LoginCidadao\OAuthBundle\Model\AccessTokenManager')
            ->disableOriginalConstructor()->getMock();
    }

    /**
     * @return RemoteClaimManagerInterface|\PHPUnit_Framework_MockObject_MockObject
     */
    private function getRemoteClaimManager()
    {
        return $this->getMock('LoginCidadao\RemoteClaimsBundle\Model\RemoteClaimManagerInterface');
    }

    /**
     * @return RemoteClaimFetcherInterface|\PHPUnit_Framework_MockObject_MockObject
     */
    private function getFetcher()
    {
        return $this->getMock('LoginCidadao\RemoteClaimsBundle\Model\RemoteClaimFetcherInterface');
    }

    /**
     * @return GenericSerializationVisitor|\PHPUnit_Framework_MockObject_MockObject
     */
    private function getVisitor()
    {
        return $this->getMockBuilder('JMS\Serializer\GenericSerializationVisitor')
            ->disableOriginalConstructor()->getMock();
    }

    /**
     * @param array|null $version
     * @return VersionService|\PHPUnit_Framework_MockObject_MockObject
     */
    private function getVersionService($version = null)
    {
        $versionService = $this->getMockBuilder('LoginCidadao\APIBundle\Service\VersionService')
            ->disableOriginalConstructor()->getMock();

        if ($version !== null) {
            $versionString = implode('.', $version);
            $version = [
                'major' => $version[0],
                'minor' => $version[1],
                'patch' => $version[2],
            ];

            $versionService->expects($this->once())->method('getVersionFromRequest')->willReturn($version);
            $versionService->expects($this->once())->method('getString')->with($version)->willReturn($versionString);
        }

        return $versionService;
    }

    private function getSubscriber(
        $accessTokenManager = null,
        $remoteClaimManager = null,
        $fetcher = null,
        $versionService = null
    ) {
        if ($accessTokenManager === null) {
            $accessTokenManager = $this->getAccessTokenManager();
        }
        if ($remoteClaimManager === null) {
            $remoteClaimManager = $this->getRemoteClaimManager();
        }
        if ($fetcher === null) {
            $fetcher = $this->getFetcher();
        }
        if ($versionService === null) {
            $versionService = $this->getVersionService();
        }

        return new PersonSerializeEventSubscriber($accessTokenManager, $remoteClaimManager, $fetcher, $versionService);
    }
}


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 LoginCidadao\RemoteClaimsBundle\Tests\EventSubscriber;
12
13			use JMS\Serializer\EventDispatcher\Events;
14			use JMS\Serializer\EventDispatcher\ObjectEvent;
15			use JMS\Serializer\GenericSerializationVisitor;
16			use LoginCidadao\APIBundle\Service\VersionService;
17			use LoginCidadao\CoreBundle\Model\PersonInterface;
18			use LoginCidadao\OAuthBundle\Model\AccessTokenManager;
19			use LoginCidadao\OAuthBundle\Model\ClientInterface;
20			use LoginCidadao\RemoteClaimsBundle\Entity\RemoteClaim;
21			use LoginCidadao\RemoteClaimsBundle\Entity\RemoteClaimAuthorization;
22			use LoginCidadao\RemoteClaimsBundle\EventSubscriber\PersonSerializeEventSubscriber;
23			use LoginCidadao\RemoteClaimsBundle\Exception\ClaimUriUnavailableException;
24			use LoginCidadao\RemoteClaimsBundle\Model\ClaimProviderInterface;
25			use LoginCidadao\RemoteClaimsBundle\Model\RemoteClaimFetcherInterface;
26			use LoginCidadao\RemoteClaimsBundle\Model\RemoteClaimManagerInterface;
27			use LoginCidadao\RemoteClaimsBundle\Model\TagUri;
28
29			class PersonSerializeEventSubscriberTest extends \PHPUnit_Framework_TestCase
30			{
31			// PersonSerializeEventSubscriber
32
33			public function testGetSubscribedEvents()
34			{
35			$this->assertEquals([
36			[
37			'event' => Events::POST_SERIALIZE,
38			'method' => 'onPostSerialize',
39			'class' => 'LoginCidadao\CoreBundle\Model\PersonInterface',
40			],
41			], PersonSerializeEventSubscriber::getSubscribedEvents());
42			}
43
44			public function testRunsOnlyForPersonObjects()
45			{
46			$event = $this->getEvent();
47			$event->expects($this->once())->method('getObject')->willReturn(new \stdClass());
48
49			$subscriber = $this->getSubscriber();
50			$subscriber->onPostSerialize($event);
51			}
52
53			public function testWontRunForVersion1_2_3()
54			{
55			$this->checkVersion([1, 2, 3], false);
56			}
57
58			public function testWillRunForVersion2_3_4()
59			{
60			$this->checkVersion([2, 3, 4], true);
61			}
62
63			public function testWillRunForVersion3_4_5()
64			{
65			$this->checkVersion([3, 4, 5], true);
66			}
67
68			public function testAddRemoteClaim()
69			{
70			$dummyJson = [];
71			$endpoint = 'https://dummy/endpoint';
72			$fetcher = $this->getFetcher();
73			$fetcher->expects($this->once())->method('discoverClaimUri')->willReturn($endpoint);
74
75			$this->runAddDistributedAndAggregatedClaimsTest($fetcher, $dummyJson);
76
77			$tag = 'tag:example.com,2018-01:example';
78			$accessToken = 'my_secret_access_token';
79			$this->assertEquals([
80			$tag => [
81			'endpoint' => $endpoint,
82			'access_token' => $accessToken,
83			],
84			], $dummyJson['_claim_sources']);
85
86			$this->assertEquals([$tag => $tag], $dummyJson['_claim_names']);
87			}
88
89			public function testUnknownEndpoint()
90			{
91			$dummyJson = [];
92			$fetcher = $this->getFetcher();
93			$fetcher->expects($this->once())->method('discoverClaimUri')
94			->willThrowException(new ClaimUriUnavailableException());
95
96			$this->runAddDistributedAndAggregatedClaimsTest($fetcher, $dummyJson);
97
98			$this->assertEmpty($dummyJson['_claim_names']);
99			$this->assertEmpty($dummyJson['_claim_sources']);
100			}
101
102			public function runAddDistributedAndAggregatedClaimsTest($fetcher, &$dummyJson)
103			{
104			$person = $this->getPerson();
105			$client = $this->getClient();
106			$tag = 'tag:example.com,2018-01:example';
107			$claimName = TagUri::createFromString($tag);
108			$accessToken = 'my_secret_access_token';
109
110			$remoteClaims = [
111			[
112			'remoteClaim' => (new RemoteClaim())
113			->setProvider($client)
114			->setName($claimName),
115			'authorization' => (new RemoteClaimAuthorization())
116			->setAccessToken($accessToken),
117			],
118			];
119
120			$visitor = $this->getVisitor();
121			$visitor->expects($this->exactly(2))
122			->method('addData')->willReturnCallback(function ($key, $value) use (&$dummyJson) {
123			$this->assertContains($key, ['_claim_names', '_claim_sources']);
124			$dummyJson[$key] = $value;
125			});
126
127			$event = $this->getEvent();
128			$event->expects($this->once())->method('getVisitor')->willReturn($visitor);
129			$event->expects($this->exactly(2))->method('getObject')->willReturn($person);
130
131			$accessTokenManager = $this->getAccessTokenManager();
132			$accessTokenManager->expects($this->once())->method('getTokenClient')->willReturn($client);
133
134			$remoteClaimManager = $this->getRemoteClaimManager();
135			$remoteClaimManager->expects($this->once())
136			->method('getRemoteClaimsWithTokens')->with($client, $person)
137			->willReturn($remoteClaims);
138
139			$versionService = $this->getVersionService([2, 0, 0]);
140
141			$subscriber = $this->getSubscriber($accessTokenManager, $remoteClaimManager, $fetcher, $versionService);
142			$subscriber->onPostSerialize($event);
143			}
144
145			/**
146			* @param array $version
147			* @param bool $shouldRun
148			*/
149			private function checkVersion($version, $shouldRun)
150			{
151			$event = $this->getEvent();
152			$event->expects($this->once())->method('getObject')->willReturn($this->getPerson());
153			if ($shouldRun) {
154			$event->expects($this->once())->method('getVisitor')->willReturn(new \stdClass());
155			} else {
156			$event->expects($this->never())->method('getVisitor');
157			}
158
159			$versionService = $this->getVersionService($version);
160
161			$subscriber = $this->getSubscriber(null, null, null, $versionService);
162			$subscriber->onPostSerialize($event);
163			}
164
165			/**
166			* @return ObjectEvent\|\PHPUnit_Framework_MockObject_MockObject
167			*/
168			private function getEvent()
169			{
170			return $this->getMockBuilder('JMS\Serializer\EventDispatcher\ObjectEvent')
171			->disableOriginalConstructor()->getMock();
172			}
173
174			/**
175			* @return PersonInterface\|\PHPUnit_Framework_MockObject_MockObject
176			*/
177			private function getPerson()
178			{
179			return $this->getMock('LoginCidadao\CoreBundle\Model\PersonInterface');
180			}
181
182			/**
183			* @return ClaimProviderInterface\|ClientInterface\|\PHPUnit_Framework_MockObject_MockObject
184			*/
185			private function getClient()
186			{
187			return $this->getMock('LoginCidadao\OAuthBundle\Entity\Client');
188			}
189
190			/**
191			* @return AccessTokenManager\|\PHPUnit_Framework_MockObject_MockObject
192			*/
193			private function getAccessTokenManager()
194			{
195			return $this->getMockBuilder('LoginCidadao\OAuthBundle\Model\AccessTokenManager')
196			->disableOriginalConstructor()->getMock();
197			}
198
199			/**
200			* @return RemoteClaimManagerInterface\|\PHPUnit_Framework_MockObject_MockObject
201			*/
202			private function getRemoteClaimManager()
203			{
204			return $this->getMock('LoginCidadao\RemoteClaimsBundle\Model\RemoteClaimManagerInterface');
205			}
206
207			/**
208			* @return RemoteClaimFetcherInterface\|\PHPUnit_Framework_MockObject_MockObject
209			*/
210			private function getFetcher()
211			{
212			return $this->getMock('LoginCidadao\RemoteClaimsBundle\Model\RemoteClaimFetcherInterface');
213			}
214
215			/**
216			* @return GenericSerializationVisitor\|\PHPUnit_Framework_MockObject_MockObject
217			*/
218			private function getVisitor()
219			{
220			return $this->getMockBuilder('JMS\Serializer\GenericSerializationVisitor')
221			->disableOriginalConstructor()->getMock();
222			}
223
224			/**
225			* @param array\|null $version
226			* @return VersionService\|\PHPUnit_Framework_MockObject_MockObject
227			*/
228			private function getVersionService($version = null)
229			{
230			$versionService = $this->getMockBuilder('LoginCidadao\APIBundle\Service\VersionService')
231			->disableOriginalConstructor()->getMock();
232
233			if ($version !== null) {
234			$versionString = implode('.', $version);
235			$version = [
236			'major' => $version[0],
237			'minor' => $version[1],
238			'patch' => $version[2],
239			];
240
241			$versionService->expects($this->once())->method('getVersionFromRequest')->willReturn($version);
242			$versionService->expects($this->once())->method('getString')->with($version)->willReturn($versionString);
243			}
244
245			return $versionService;
246			}
247
248			private function getSubscriber(
249			$accessTokenManager = null,
250			$remoteClaimManager = null,
251			$fetcher = null,
252			$versionService = null
253			) {
254			if ($accessTokenManager === null) {
255			$accessTokenManager = $this->getAccessTokenManager();
256			}
257			if ($remoteClaimManager === null) {
258			$remoteClaimManager = $this->getRemoteClaimManager();
259			}
260			if ($fetcher === null) {
261			$fetcher = $this->getFetcher();
262			}
263			if ($versionService === null) {
264			$versionService = $this->getVersionService();
265			}
266
267			return new PersonSerializeEventSubscriber($accessTokenManager, $remoteClaimManager, $fetcher, $versionService);
268			}
269			}
270

PROCERGS / login-cidadao

Push — issue#666 ( 0a0cb9...d66c4e )

PersonSerializeEventSubscriberTest::getEvent() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like