ClientTest::getPerson() - Code Metrics - Inspection of "trying to reduce CRAP index PROCERGS#765" - PROCERGS/login-cidadao - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Push — issue#765 ( 54a2c2...25bda7 )

by Guilherme

created 2018-04-23 19:09 UTC

ClientTest::getPerson() A

↳ Parent: ClientTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
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\OAuthBundle\Tests\Entity;

use Doctrine\Common\Collections\ArrayCollection;
use LoginCidadao\OAuthBundle\Entity\Client;
use OAuth2\OAuth2;
use Symfony\Component\HttpFoundation\File\UploadedFile;
use LoginCidadao\OpenIDBundle\Entity\ClientMetadata;

class ClientTest extends \PHPUnit_Framework_TestCase
{
    public function testGetAllGrants()
    {
        $this->assertCount(6, Client::getAllGrants());
        $this->assertContains(OAuth2::GRANT_TYPE_AUTH_CODE, Client::getAllGrants());
        $this->assertContains(OAuth2::GRANT_TYPE_IMPLICIT, Client::getAllGrants());
        $this->assertContains(OAuth2::GRANT_TYPE_USER_CREDENTIALS, Client::getAllGrants());
        $this->assertContains(OAuth2::GRANT_TYPE_CLIENT_CREDENTIALS, Client::getAllGrants());
        $this->assertContains(OAuth2::GRANT_TYPE_REFRESH_TOKEN, Client::getAllGrants());
        $this->assertContains(OAuth2::GRANT_TYPE_EXTENSIONS, Client::getAllGrants());
    }

    public function testClientWithoutMetadata()
    {
        $id = 123;
        $randomId = 'randomId';
        $secret = 'mySuperSecret Key Here!';
        $name = 'Client Name';
        $description = 'Some Client description here...';
        $siteUrl = 'https://site.url';
        $landingPageUrl = 'https://landing.page.url';
        $tosUrl = 'https://tos.url';
        $allowedScope = ['scope1', 'scope2'];
        $owners = [$this->getMock('LoginCidadao\CoreBundle\Model\PersonInterface')];
        $uid = 'client-uid';
        $redirectUris = ['https://redirect.uri'];
        /** @var UploadedFile $image */
        $image = $this->getMock('Psr\Http\Message\UploadedFileInterface');
        $imageName = 'image.name';

        $client = new Client();

        $this->assertContains('public_profile', $client->getAllowedScopes());
        $this->assertContains('openid', $client->getAllowedScopes());

        $client
            ->setId($id)
            ->setName($name)
            ->setDescription($description)
            ->setSiteUrl($siteUrl)
            ->setLandingPageUrl($landingPageUrl)
            ->setTermsOfUseUrl($tosUrl)
            ->setAllowedScopes($allowedScope)
            ->setVisible(true)
            ->setPublished(true)
            ->setOwners($owners)
            ->setUid($uid)
            ->setRedirectUris($redirectUris)
            ->setImage($image)
            ->setImageName($imageName)
            ->setUpdatedAt();
        $client->setRandomId($randomId);
        $client->setSecret($secret);

        $this->assertEquals($id, $client->getId());
        $this->assertEquals($name, $client->getName());
        $this->assertEquals($description, $client->getDescription());
        $this->assertEquals($siteUrl, $client->getSiteUrl());
        $this->assertEquals($landingPageUrl, $client->getLandingPageUrl());
        $this->assertEquals($tosUrl, $client->getTermsOfUseUrl());
        $this->assertEquals($allowedScope, $client->getAllowedScopes());
        $this->assertTrue($client->isVisible());
        $this->assertTrue($client->isPublished());
        $this->assertContains(reset($owners), $client->getOwners());
        $this->assertEquals($uid, $client->getUid());
        $this->assertEquals($redirectUris, $client->getRedirectUris());
        $this->assertEquals($image, $client->getImage());
        $this->assertEquals($imageName, $client->getImageName());
        $this->assertEquals($secret, $client->getSecret());
        $this->assertEquals($secret, $client->getClientSecret());
        $this->assertEquals("{$id}_{$randomId}", $client->getPublicId());
        $this->assertEquals("{$id}_{$randomId}", $client->getClientId());

        $autoDate = $client->getUpdatedAt();
        $this->assertInstanceOf('\DateTime', $autoDate);

        $date = new \DateTime();
        $client->setUpdatedAt($date);
        $this->assertNotSame($autoDate, $date);
        $this->assertSame($date, $client->getUpdatedAt());

        return $client;
    }

    public function testUpdateMetadata()
    {
        // Client data
        $name = 'Client Name';
        $siteUrl = 'https://site.url';
        $landingPageUrl = 'https://landing.page.url';
        $tosUrl = 'https://tos.url';
        $redirectUris = ['https://redirect.uri'];
        $grantTypes = [OAuth2::GRANT_TYPE_AUTH_CODE];

        // ClientMetadata
        $metadataName = 'ClientMetadata Name';
        $metadataSiteUrl = 'https://metadata.site.url';
        $metadataLandingPageUrl = 'https://metadata.landing.page.url';
        $metadataToSUrl = 'http://metadata.tos.url';
        $metadataRedirectUris = ['https://metadata.redirect.uri'];
        $metadataGrantTypes = [OAuth2::GRANT_TYPE_IMPLICIT];

        $client = new Client();
        $client
            ->setName($name)
            ->setSiteUrl($siteUrl)
            ->setLandingPageUrl($landingPageUrl)
            ->setTermsOfUseUrl($tosUrl)
            ->setRedirectUris($redirectUris)
            ->setAllowedGrantTypes($grantTypes);

        $metadata = new ClientMetadata();
        $metadata
            ->setClientName($metadataName)
            ->setClientUri($metadataSiteUrl)
            ->setInitiateLoginUri($metadataLandingPageUrl)
            ->setTosUri($metadataToSUrl)
            ->setRedirectUris($metadataRedirectUris)
            ->setGrantTypes($metadataGrantTypes);

        $this->assertNotEquals($metadataName, $client->getName());
        $this->assertNotEquals($metadataSiteUrl, $client->getSiteUrl());
        $this->assertNotEquals($metadataLandingPageUrl, $client->getLandingPageUrl());
        $this->assertNotEquals($metadataToSUrl, $client->getTermsOfUseUrl());
        $this->assertNotEquals($metadataRedirectUris, $client->getRedirectUris());
        $this->assertNotEquals($metadataGrantTypes, $client->getAllowedGrantTypes());

        $client->setMetadata($metadata);

        $this->assertEquals($metadataName, $client->getName());
        $this->assertEquals($metadataSiteUrl, $client->getSiteUrl());
        $this->assertEquals($metadataLandingPageUrl, $client->getLandingPageUrl());
        $this->assertEquals($metadataToSUrl, $client->getTermsOfUseUrl());
        $this->assertEquals($metadataRedirectUris, $client->getRedirectUris());
        $this->assertEquals($metadataGrantTypes, $client->getAllowedGrantTypes());

        $changedName = 'Changed Name';
        $changedUrl = 'https://changed.url';
        $client->setName($changedName);
        $client->setSiteUrl($changedUrl);
        $client->setLandingPageUrl($changedUrl);
        $client->setTermsOfUseUrl($changedUrl);
        $client->setRedirectUris([$changedUrl]);

        $this->assertEquals($changedName, $metadata->getClientName());
        $this->assertEquals($changedUrl, $metadata->getClientUri());
        $this->assertEquals($changedUrl, $metadata->getInitiateLoginUri());
        $this->assertEquals($changedUrl, $metadata->getTosUri());
        $this->assertContains($changedUrl, $metadata->getRedirectUris());
    }

    public function testOwnsDomain()
    {
        $client = new Client();
        $client->setRedirectUris(['https://domain1.com/', 'https://domain2.com']);

        $this->assertTrue($client->ownsDomain('domain1.com'));
        $this->assertTrue($client->ownsDomain('domain2.com'));
        $this->assertFalse($client->ownsDomain('domain3.com'));
        $this->assertFalse($client->ownsDomain('sub.domain2.com'));
    }

    public function testGetContacts()
    {
        $person1Email = '[email protected]';
        $person2Email = '[email protected]';
        $person1 = $this->getPerson();
        $person1->expects($this->once())
            ->method('getEmail')->willReturn($person1Email);

        $person2 = $this->getPerson();
        $person2->expects($this->once())
            ->method('getEmail')->willReturn($person2Email);

        $client = new Client();
        $client->setOwners([$person1, $person2]);

        $contacts = $client->getContacts();
        $this->assertContains($person1Email, $contacts);
        $this->assertContains($person2Email, $contacts);

        $metadata = new ClientMetadata();
        $client->setMetadata($metadata);
        $metadata->setContacts(['[email protected]', '[email protected]']);

        $contacts = $client->getContacts();
        $this->assertContains($person1Email, $contacts);
        $this->assertContains($person2Email, $contacts);
    }

    public function testRemoveAuthorizationAsArray()
    {
        $authorization = $this->getMock('LoginCidadao\CoreBundle\Entity\Authorization');
        $authorization->expects($this->any())
            ->method('getId')->willReturn('1');

        $client = new Client();
        $this->assertEmpty($client->getAuthorizations());

        $client->setAuthorizations([$authorization]);
        $this->assertContains($authorization, $client->getAuthorizations());

        $client->removeAuthorization($authorization);
        $this->assertEmpty($client->getAuthorizations());
    }

    public function testRemoveAuthorizationAsArrayCollection()
    {
        $authorization = $this->getMock('LoginCidadao\CoreBundle\Entity\Authorization');
        $authorization->expects($this->any())
            ->method('getId')->willReturn('1');

        $client = new Client();
        $this->assertEmpty($client->getAuthorizations());

        $client->setAuthorizations(new ArrayCollection([$authorization]));
        $this->assertContains($authorization, $client->getAuthorizations());

        $client->removeAuthorization($authorization);
        $this->assertEmpty($client->getAuthorizations());
    }

    public function testGetName()
    {
        $name = 'Client Name';

        $metadata = new ClientMetadata();

        $client = new Client();
        $client->setName($name);
        $client->setMetadata($metadata);

        $this->assertNull($metadata->getClientName());

        $client->getName();
        $this->assertEquals($name, $metadata->getClientName());
    }

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


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\OAuthBundle\Tests\Entity;
12
13			use Doctrine\Common\Collections\ArrayCollection;
14			use LoginCidadao\OAuthBundle\Entity\Client;
15			use OAuth2\OAuth2;
16			use Symfony\Component\HttpFoundation\File\UploadedFile;
17			use LoginCidadao\OpenIDBundle\Entity\ClientMetadata;
18
19			class ClientTest extends \PHPUnit_Framework_TestCase
20			{
21			public function testGetAllGrants()
22			{
23			$this->assertCount(6, Client::getAllGrants());
24			$this->assertContains(OAuth2::GRANT_TYPE_AUTH_CODE, Client::getAllGrants());
25			$this->assertContains(OAuth2::GRANT_TYPE_IMPLICIT, Client::getAllGrants());
26			$this->assertContains(OAuth2::GRANT_TYPE_USER_CREDENTIALS, Client::getAllGrants());
27			$this->assertContains(OAuth2::GRANT_TYPE_CLIENT_CREDENTIALS, Client::getAllGrants());
28			$this->assertContains(OAuth2::GRANT_TYPE_REFRESH_TOKEN, Client::getAllGrants());
29			$this->assertContains(OAuth2::GRANT_TYPE_EXTENSIONS, Client::getAllGrants());
30			}
31
32			public function testClientWithoutMetadata()
33			{
34			$id = 123;
35			$randomId = 'randomId';
36			$secret = 'mySuperSecret Key Here!';
37			$name = 'Client Name';
38			$description = 'Some Client description here...';
39			$siteUrl = 'https://site.url';
40			$landingPageUrl = 'https://landing.page.url';
41			$tosUrl = 'https://tos.url';
42			$allowedScope = ['scope1', 'scope2'];
43			$owners = [$this->getMock('LoginCidadao\CoreBundle\Model\PersonInterface')];
44			$uid = 'client-uid';
45			$redirectUris = ['https://redirect.uri'];
46			/** @var UploadedFile $image */
47			$image = $this->getMock('Psr\Http\Message\UploadedFileInterface');
48			$imageName = 'image.name';
49
50			$client = new Client();
51
52			$this->assertContains('public_profile', $client->getAllowedScopes());
53			$this->assertContains('openid', $client->getAllowedScopes());
54
55			$client
56			->setId($id)
57			->setName($name)
58			->setDescription($description)
59			->setSiteUrl($siteUrl)
60			->setLandingPageUrl($landingPageUrl)
61			->setTermsOfUseUrl($tosUrl)
62			->setAllowedScopes($allowedScope)
63			->setVisible(true)
64			->setPublished(true)
65			->setOwners($owners)
66			->setUid($uid)
67			->setRedirectUris($redirectUris)
68			->setImage($image)
69			->setImageName($imageName)
70			->setUpdatedAt();
71			$client->setRandomId($randomId);
72			$client->setSecret($secret);
73
74			$this->assertEquals($id, $client->getId());
75			$this->assertEquals($name, $client->getName());
76			$this->assertEquals($description, $client->getDescription());
77			$this->assertEquals($siteUrl, $client->getSiteUrl());
78			$this->assertEquals($landingPageUrl, $client->getLandingPageUrl());
79			$this->assertEquals($tosUrl, $client->getTermsOfUseUrl());
80			$this->assertEquals($allowedScope, $client->getAllowedScopes());
81			$this->assertTrue($client->isVisible());
82			$this->assertTrue($client->isPublished());
83			$this->assertContains(reset($owners), $client->getOwners());
84			$this->assertEquals($uid, $client->getUid());
85			$this->assertEquals($redirectUris, $client->getRedirectUris());
86			$this->assertEquals($image, $client->getImage());
87			$this->assertEquals($imageName, $client->getImageName());
88			$this->assertEquals($secret, $client->getSecret());
89			$this->assertEquals($secret, $client->getClientSecret());
90			$this->assertEquals("{$id}_{$randomId}", $client->getPublicId());
91			$this->assertEquals("{$id}_{$randomId}", $client->getClientId());
92
93			$autoDate = $client->getUpdatedAt();
94			$this->assertInstanceOf('\DateTime', $autoDate);
95
96			$date = new \DateTime();
97			$client->setUpdatedAt($date);
98			$this->assertNotSame($autoDate, $date);
99			$this->assertSame($date, $client->getUpdatedAt());
100
101			return $client;
102			}
103
104			public function testUpdateMetadata()
105			{
106			// Client data
107			$name = 'Client Name';
108			$siteUrl = 'https://site.url';
109			$landingPageUrl = 'https://landing.page.url';
110			$tosUrl = 'https://tos.url';
111			$redirectUris = ['https://redirect.uri'];
112			$grantTypes = [OAuth2::GRANT_TYPE_AUTH_CODE];
113
114			// ClientMetadata
115			$metadataName = 'ClientMetadata Name';
116			$metadataSiteUrl = 'https://metadata.site.url';
117			$metadataLandingPageUrl = 'https://metadata.landing.page.url';
118			$metadataToSUrl = 'http://metadata.tos.url';
119			$metadataRedirectUris = ['https://metadata.redirect.uri'];
120			$metadataGrantTypes = [OAuth2::GRANT_TYPE_IMPLICIT];
121
122			$client = new Client();
123			$client
124			->setName($name)
125			->setSiteUrl($siteUrl)
126			->setLandingPageUrl($landingPageUrl)
127			->setTermsOfUseUrl($tosUrl)
128			->setRedirectUris($redirectUris)
129			->setAllowedGrantTypes($grantTypes);
130
131			$metadata = new ClientMetadata();
132			$metadata
133			->setClientName($metadataName)
134			->setClientUri($metadataSiteUrl)
135			->setInitiateLoginUri($metadataLandingPageUrl)
136			->setTosUri($metadataToSUrl)
137			->setRedirectUris($metadataRedirectUris)
138			->setGrantTypes($metadataGrantTypes);
139
140			$this->assertNotEquals($metadataName, $client->getName());
141			$this->assertNotEquals($metadataSiteUrl, $client->getSiteUrl());
142			$this->assertNotEquals($metadataLandingPageUrl, $client->getLandingPageUrl());
143			$this->assertNotEquals($metadataToSUrl, $client->getTermsOfUseUrl());
144			$this->assertNotEquals($metadataRedirectUris, $client->getRedirectUris());
145			$this->assertNotEquals($metadataGrantTypes, $client->getAllowedGrantTypes());
146
147			$client->setMetadata($metadata);
148
149			$this->assertEquals($metadataName, $client->getName());
150			$this->assertEquals($metadataSiteUrl, $client->getSiteUrl());
151			$this->assertEquals($metadataLandingPageUrl, $client->getLandingPageUrl());
152			$this->assertEquals($metadataToSUrl, $client->getTermsOfUseUrl());
153			$this->assertEquals($metadataRedirectUris, $client->getRedirectUris());
154			$this->assertEquals($metadataGrantTypes, $client->getAllowedGrantTypes());
155
156			$changedName = 'Changed Name';
157			$changedUrl = 'https://changed.url';
158			$client->setName($changedName);
159			$client->setSiteUrl($changedUrl);
160			$client->setLandingPageUrl($changedUrl);
161			$client->setTermsOfUseUrl($changedUrl);
162			$client->setRedirectUris([$changedUrl]);
163
164			$this->assertEquals($changedName, $metadata->getClientName());
165			$this->assertEquals($changedUrl, $metadata->getClientUri());
166			$this->assertEquals($changedUrl, $metadata->getInitiateLoginUri());
167			$this->assertEquals($changedUrl, $metadata->getTosUri());
168			$this->assertContains($changedUrl, $metadata->getRedirectUris());
169			}
170
171			public function testOwnsDomain()
172			{
173			$client = new Client();
174			$client->setRedirectUris(['https://domain1.com/', 'https://domain2.com']);
175
176			$this->assertTrue($client->ownsDomain('domain1.com'));
177			$this->assertTrue($client->ownsDomain('domain2.com'));
178			$this->assertFalse($client->ownsDomain('domain3.com'));
179			$this->assertFalse($client->ownsDomain('sub.domain2.com'));
180			}
181
182			public function testGetContacts()
183			{
184			$person1Email = '[email protected]';
185			$person2Email = '[email protected]';
186			$person1 = $this->getPerson();
187			$person1->expects($this->once())
188			->method('getEmail')->willReturn($person1Email);
189
190			$person2 = $this->getPerson();
191			$person2->expects($this->once())
192			->method('getEmail')->willReturn($person2Email);
193
194			$client = new Client();
195			$client->setOwners([$person1, $person2]);
196
197			$contacts = $client->getContacts();
198			$this->assertContains($person1Email, $contacts);
199			$this->assertContains($person2Email, $contacts);
200
201			$metadata = new ClientMetadata();
202			$client->setMetadata($metadata);
203			$metadata->setContacts(['[email protected]', '[email protected]']);
204
205			$contacts = $client->getContacts();
206			$this->assertContains($person1Email, $contacts);
207			$this->assertContains($person2Email, $contacts);
208			}
209
210			public function testRemoveAuthorizationAsArray()
211			{
212			$authorization = $this->getMock('LoginCidadao\CoreBundle\Entity\Authorization');
213			$authorization->expects($this->any())
214			->method('getId')->willReturn('1');
215
216			$client = new Client();
217			$this->assertEmpty($client->getAuthorizations());
218
219			$client->setAuthorizations([$authorization]);
220			$this->assertContains($authorization, $client->getAuthorizations());
221
222			$client->removeAuthorization($authorization);
223			$this->assertEmpty($client->getAuthorizations());
224			}
225
226			public function testRemoveAuthorizationAsArrayCollection()
227			{
228			$authorization = $this->getMock('LoginCidadao\CoreBundle\Entity\Authorization');
229			$authorization->expects($this->any())
230			->method('getId')->willReturn('1');
231
232			$client = new Client();
233			$this->assertEmpty($client->getAuthorizations());
234
235			$client->setAuthorizations(new ArrayCollection([$authorization]));
236			$this->assertContains($authorization, $client->getAuthorizations());
237
238			$client->removeAuthorization($authorization);
239			$this->assertEmpty($client->getAuthorizations());
240			}
241
242			public function testGetName()
243			{
244			$name = 'Client Name';
245
246			$metadata = new ClientMetadata();
247
248			$client = new Client();
249			$client->setName($name);
250			$client->setMetadata($metadata);
251
252			$this->assertNull($metadata->getClientName());
253
254			$client->getName();
255			$this->assertEquals($name, $metadata->getClientName());
256			}
257
258			private function getPerson()
259			{
260			return $this->getMock('LoginCidadao\CoreBundle\Model\PersonInterface');
261			}
262			}
263

PROCERGS / login-cidadao

Push — issue#765 ( 54a2c2...25bda7 )

ClientTest::getPerson() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like