GuardTest - Code Metrics - Inspection of "Add Scrutinizer config" - framgia/laravel-jwt - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 6cab55...c82b86 )

by Roman

created 2016-05-18 07:16 UTC

GuardTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	297
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	9

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	297
rs	10
wmc	14
lcom	2
cbo	9

<?php

use Mockery as m;

class GuardTest extends PHPUnit_Framework_TestCase
{
    public function testSetRequest()
    {
        $provider = m::mock(Illuminate\Contracts\Auth\UserProvider::class);
        $blacklist = m::mock(Framgia\Jwt\Blacklist::class);
        $signer = m::mock(Framgia\Jwt\Contracts\Signer::class);

        $firstRequest = Illuminate\Http\Request::create('/');

        $guard = new Framgia\Jwt\Guard($provider, $firstRequest, $blacklist, $signer);

        $reflection = new ReflectionClass($guard);
        $property = $reflection->getProperty('request');
        $property->setAccessible(true);

        $this->assertEquals($firstRequest, $property->getValue($guard));

        $newRequest = Illuminate\Http\Request::create('/foo');

        $guard->setRequest($newRequest);

        $this->assertEquals($newRequest, $property->getValue($guard));
    }

    public function testUserWithRawToken()
    {
        $user = m::mock(\Illuminate\Contracts\Auth\Authenticatable::class);

        $provider = m::mock(Illuminate\Contracts\Auth\UserProvider::class);
        $provider->shouldReceive('retrieveById')->once()->andReturn($user);

        $blacklist = m::mock(Framgia\Jwt\Blacklist::class);
        $signer = m::mock(Framgia\Jwt\Contracts\Signer::class);

        $request = Illuminate\Http\Request::create('/');

        $token = (new \Lcobucci\JWT\Builder())->setSubject(1)->setExpiration(time() + 3600)->getToken();

        $signer->shouldReceive('verify')->once()->andReturn(true);

        $request->headers->set('Authorization', 'Bearer '.$token);

        $guard = new Framgia\Jwt\Guard($provider, $request, $blacklist, $signer);

        $this->assertEquals($user, $guard->user());
    }

    public function testUserWithSignedToken()
    {
        $user = m::mock(\Illuminate\Contracts\Auth\Authenticatable::class);

        $signer = new Framgia\Jwt\Signers\Hmac('test');

        $provider = m::mock(Illuminate\Contracts\Auth\UserProvider::class);
        $provider->shouldReceive('retrieveById')->once()->andReturn($user);

        $blacklist = m::mock(Framgia\Jwt\Blacklist::class);

        $request = Illuminate\Http\Request::create('/');

        $token = $signer->sign((new \Lcobucci\JWT\Builder())->setSubject(1)->setExpiration(time() + 3600))->getToken();

        $request->headers->set('Authorization', 'Bearer '.$token);

        $guard = new Framgia\Jwt\Guard($provider, $request, $blacklist, $signer);

        $this->assertEquals($user, $guard->user());

        // Additional check to test if user provider is called once
        $this->assertEquals($user, $guard->user());
    }

    public function testValidate()
    {
        $credentials = ['foo' => 'bar'];

        $user = m::mock(\Illuminate\Contracts\Auth\Authenticatable::class);
        $provider = m::mock(Illuminate\Contracts\Auth\UserProvider::class);
        $provider->shouldReceive('retrieveByCredentials')->once()->with($credentials)->andReturn($user);
        $provider->shouldReceive('validateCredentials')->once()->with($user, $credentials)->andReturn(true);

        $blacklist = m::mock(Framgia\Jwt\Blacklist::class);
        $signer = m::mock(Framgia\Jwt\Contracts\Signer::class);

        $request = Illuminate\Http\Request::create('/');

        $guard = new Framgia\Jwt\Guard($provider, $request, $blacklist, $signer);

        $this->assertTrue($guard->validate($credentials));
    }

    public function testValidateFailsWithFakeCredentials()
    {
        $credentials = ['foo' => 'bar'];

        $provider = m::mock(Illuminate\Contracts\Auth\UserProvider::class);
        $provider->shouldReceive('retrieveByCredentials')->once()->with($credentials)->andReturnNull();

        $blacklist = m::mock(Framgia\Jwt\Blacklist::class);
        $signer = m::mock(Framgia\Jwt\Contracts\Signer::class);

        $request = Illuminate\Http\Request::create('/');

        $guard = new Framgia\Jwt\Guard($provider, $request, $blacklist, $signer);

        $this->assertFalse($guard->validate($credentials));
    }

    public function testAttempt()
    {
        $credentials = ['foo' => 'bar'];

        $user = m::mock(\Illuminate\Contracts\Auth\Authenticatable::class);
        $provider = m::mock(Illuminate\Contracts\Auth\UserProvider::class);
        $provider->shouldReceive('retrieveByCredentials')->once()->with($credentials)->andReturn($user);
        $provider->shouldReceive('validateCredentials')->once()->with($user, $credentials)->andReturn(true);

        $blacklist = m::mock(Framgia\Jwt\Blacklist::class);
        $signer = m::mock(Framgia\Jwt\Contracts\Signer::class);

        $request = Illuminate\Http\Request::create('/');

        $guard = new Framgia\Jwt\Guard($provider, $request, $blacklist, $signer);

        $this->assertTrue($guard->validate($credentials));
    }

    public function testUserReturnsNullWithoutToken()
    {
        $signer = m::mock(Framgia\Jwt\Signers\Hmac::class);

        $provider = m::mock(Illuminate\Contracts\Auth\UserProvider::class);
        $provider->shouldNotReceive('retrieveById');

        $blacklist = m::mock(Framgia\Jwt\Blacklist::class);

        $request = Illuminate\Http\Request::create('/');

        $guard = new Framgia\Jwt\Guard($provider, $request, $blacklist, $signer);

        $this->assertNull($guard->user());
    }

    public function testUserReturnsNullWithInvalidToken()
    {
        $credentials = ['foo' => 'bar'];

        $provider = m::mock(Illuminate\Contracts\Auth\UserProvider::class);
        $provider->shouldNotReceive('retrieveById');

        $blacklist = m::mock(Framgia\Jwt\Blacklist::class);
        $signer = m::mock(Framgia\Jwt\Contracts\Signer::class);

        $request = Illuminate\Http\Request::create('/');

        $request->headers->set('Authorization', 'Bearer BAD_TOKEN');

        $guard = new Framgia\Jwt\Guard($provider, $request, $blacklist, $signer);

        $this->assertNull($guard->user());
    }

    public function testAttemptReturnsToken()
    {
        $credentials = ['foo' => 'bar'];

        $user = m::mock(\Illuminate\Contracts\Auth\Authenticatable::class);
        $user->shouldReceive('getAuthIdentifier')->once()->andReturn(1);

        $provider = m::mock(Illuminate\Contracts\Auth\UserProvider::class);
        $provider->shouldReceive('retrieveByCredentials')->once()->with($credentials)->andReturn($user);
        $provider->shouldReceive('validateCredentials')->once()->with($user, $credentials)->andReturn(true);

        $blacklist = m::mock(Framgia\Jwt\Blacklist::class);
        $signer = new Framgia\Jwt\Signers\Hmac('test');

        $request = Illuminate\Http\Request::create('/');

        $guard = new Framgia\Jwt\Guard($provider, $request, $blacklist, $signer);

        /**
         * @var \Lcobucci\JWT\Token
         */
        $token = $guard->attempt($credentials);

        $this->assertInstanceOf(\Lcobucci\JWT\Token::class, $token);
        $this->assertEquals(1, $token->getClaim('sub'));
        $this->assertLessThan($token->getClaim('exp'), time());
        $this->assertNotNull($token->getClaim('jti'));

        $this->assertTrue($guard->validate($credentials));
    }

    public function testAttemptWithAdditionalCredentials()
    {
        $credentials = ['foo' => 'bar'];

        $user = m::mock(UserWithCredentials::class);
        $user->shouldReceive('getAuthIdentifier')->once()->andReturn(1);
        $user->shouldReceive('getCredentials')->once()->andReturn([
            'admin' => true,
            'foo' => 'bar',
        ]);

        $provider = m::mock(Illuminate\Contracts\Auth\UserProvider::class);
        $provider->shouldReceive('retrieveByCredentials')->once()->with($credentials)->andReturn($user);
        $provider->shouldReceive('validateCredentials')->once()->with($user, $credentials)->andReturn(true);

        $blacklist = m::mock(Framgia\Jwt\Blacklist::class);
        $signer = new Framgia\Jwt\Signers\Hmac('test');

        $request = Illuminate\Http\Request::create('/');

        $guard = new Framgia\Jwt\Guard($provider, $request, $blacklist, $signer);

        $token = $guard->attempt($credentials);

        $this->assertInstanceOf(\Lcobucci\JWT\Token::class, $token);
        $this->assertEquals(true, $token->getClaim('admin'));
        $this->assertEquals('bar', $token->getClaim('foo'));

        $this->assertTrue($guard->validate($credentials));
    }

    public function testAttemptNullWithInvalidCredentials()
    {
        $credentials = ['foo' => 'bar'];

        $provider = m::mock(Illuminate\Contracts\Auth\UserProvider::class);
        $provider->shouldReceive('retrieveByCredentials')->once()->with($credentials)->andReturn(null);

        $blacklist = m::mock(Framgia\Jwt\Blacklist::class);
        $signer = new Framgia\Jwt\Signers\Hmac('test');

        $request = Illuminate\Http\Request::create('/');

        $guard = new Framgia\Jwt\Guard($provider, $request, $blacklist, $signer);

        $this->assertNull($guard->attempt($credentials));
    }

    public function testLogout()
    {
        $provider = m::mock(Illuminate\Contracts\Auth\UserProvider::class);

        $blacklist = m::mock(Framgia\Jwt\Blacklist::class);
        $token = (new \Lcobucci\JWT\Builder())->setId('foo')->setSubject(1)->setExpiration(time() + 3600)->getToken();
        $blacklist->shouldReceive('add')->once()->andReturn(true);

        $signer = m::mock(Framgia\Jwt\Contracts\Signer::class);

        $request = Illuminate\Http\Request::create('/');
        $signer->shouldReceive('verify')->once()->andReturn(true);

        $request->headers->set('Authorization', 'Bearer '.$token);

        $guard = new Framgia\Jwt\Guard($provider, $request, $blacklist, $signer);

        $this->assertTrue($guard->logout());
    }

    public function testLogoutWithoutToken()
    {
        $provider = m::mock(Illuminate\Contracts\Auth\UserProvider::class);

        $blacklist = m::mock(Framgia\Jwt\Blacklist::class);
        $blacklist->shouldNotReceive('add');

        $signer = m::mock(Framgia\Jwt\Contracts\Signer::class);

        $request = Illuminate\Http\Request::create('/');
        $signer->shouldReceive('verify')->once()->andReturn(true);

        $guard = new Framgia\Jwt\Guard($provider, $request, $blacklist, $signer);

        $this->assertTrue($guard->logout());
    }

    public function testLogoutWithInvalidToken()
    {
        $provider = m::mock(Illuminate\Contracts\Auth\UserProvider::class);

        $blacklist = m::mock(Framgia\Jwt\Blacklist::class);
        $blacklist->shouldNotReceive('add');

        $signer = m::mock(Framgia\Jwt\Contracts\Signer::class);

        $request = Illuminate\Http\Request::create('/');
        $request->headers->set('Authorization', 'Bearer BAD_TOKEN');
        $signer->shouldReceive('verify')->once()->andReturn(true);

        $guard = new Framgia\Jwt\Guard($provider, $request, $blacklist, $signer);

        $this->assertFalse($guard->logout());
    }
}

abstract class UserWithCredentials implements \Illuminate\Contracts\Auth\Authenticatable, \Framgia\Jwt\Contracts\ProvidesCredentials {}


1			<?php
2
3			use Mockery as m;
4
5			class GuardTest extends PHPUnit_Framework_TestCase
6			{
7			public function testSetRequest()
8			{
9			$provider = m::mock(Illuminate\Contracts\Auth\UserProvider::class);
10			$blacklist = m::mock(Framgia\Jwt\Blacklist::class);
11			$signer = m::mock(Framgia\Jwt\Contracts\Signer::class);
12
13			$firstRequest = Illuminate\Http\Request::create('/');
14
15			$guard = new Framgia\Jwt\Guard($provider, $firstRequest, $blacklist, $signer);
16
17			$reflection = new ReflectionClass($guard);
18			$property = $reflection->getProperty('request');
19			$property->setAccessible(true);
20
21			$this->assertEquals($firstRequest, $property->getValue($guard));
22
23			$newRequest = Illuminate\Http\Request::create('/foo');
24
25			$guard->setRequest($newRequest);
26
27			$this->assertEquals($newRequest, $property->getValue($guard));
28			}
29
30			public function testUserWithRawToken()
31			{
32			$user = m::mock(\Illuminate\Contracts\Auth\Authenticatable::class);
33
34			$provider = m::mock(Illuminate\Contracts\Auth\UserProvider::class);
35			$provider->shouldReceive('retrieveById')->once()->andReturn($user);
36
37			$blacklist = m::mock(Framgia\Jwt\Blacklist::class);
38			$signer = m::mock(Framgia\Jwt\Contracts\Signer::class);
39
40			$request = Illuminate\Http\Request::create('/');
41
42			$token = (new \Lcobucci\JWT\Builder())->setSubject(1)->setExpiration(time() + 3600)->getToken();
43
44			$signer->shouldReceive('verify')->once()->andReturn(true);
45
46			$request->headers->set('Authorization', 'Bearer '.$token);
47
48			$guard = new Framgia\Jwt\Guard($provider, $request, $blacklist, $signer);
49
50			$this->assertEquals($user, $guard->user());
51			}
52
53			public function testUserWithSignedToken()
54			{
55			$user = m::mock(\Illuminate\Contracts\Auth\Authenticatable::class);
56
57			$signer = new Framgia\Jwt\Signers\Hmac('test');
58
59			$provider = m::mock(Illuminate\Contracts\Auth\UserProvider::class);
60			$provider->shouldReceive('retrieveById')->once()->andReturn($user);
61
62			$blacklist = m::mock(Framgia\Jwt\Blacklist::class);
63
64			$request = Illuminate\Http\Request::create('/');
65
66			$token = $signer->sign((new \Lcobucci\JWT\Builder())->setSubject(1)->setExpiration(time() + 3600))->getToken();
67
68			$request->headers->set('Authorization', 'Bearer '.$token);
69
70			$guard = new Framgia\Jwt\Guard($provider, $request, $blacklist, $signer);
71
72			$this->assertEquals($user, $guard->user());
73
74			// Additional check to test if user provider is called once
75			$this->assertEquals($user, $guard->user());
76			}
77
78			public function testValidate()
79			{
80			$credentials = ['foo' => 'bar'];
81
82			$user = m::mock(\Illuminate\Contracts\Auth\Authenticatable::class);
83			$provider = m::mock(Illuminate\Contracts\Auth\UserProvider::class);
84			$provider->shouldReceive('retrieveByCredentials')->once()->with($credentials)->andReturn($user);
85			$provider->shouldReceive('validateCredentials')->once()->with($user, $credentials)->andReturn(true);
86
87			$blacklist = m::mock(Framgia\Jwt\Blacklist::class);
88			$signer = m::mock(Framgia\Jwt\Contracts\Signer::class);
89
90			$request = Illuminate\Http\Request::create('/');
91
92			$guard = new Framgia\Jwt\Guard($provider, $request, $blacklist, $signer);
93
94			$this->assertTrue($guard->validate($credentials));
95			}
96
97			public function testValidateFailsWithFakeCredentials()
98			{
99			$credentials = ['foo' => 'bar'];
100
101			$provider = m::mock(Illuminate\Contracts\Auth\UserProvider::class);
102			$provider->shouldReceive('retrieveByCredentials')->once()->with($credentials)->andReturnNull();
103
104			$blacklist = m::mock(Framgia\Jwt\Blacklist::class);
105			$signer = m::mock(Framgia\Jwt\Contracts\Signer::class);
106
107			$request = Illuminate\Http\Request::create('/');
108
109			$guard = new Framgia\Jwt\Guard($provider, $request, $blacklist, $signer);
110
111			$this->assertFalse($guard->validate($credentials));
112			}
113
114			public function testAttempt()
115			{
116			$credentials = ['foo' => 'bar'];
117
118			$user = m::mock(\Illuminate\Contracts\Auth\Authenticatable::class);
119			$provider = m::mock(Illuminate\Contracts\Auth\UserProvider::class);
120			$provider->shouldReceive('retrieveByCredentials')->once()->with($credentials)->andReturn($user);
121			$provider->shouldReceive('validateCredentials')->once()->with($user, $credentials)->andReturn(true);
122
123			$blacklist = m::mock(Framgia\Jwt\Blacklist::class);
124			$signer = m::mock(Framgia\Jwt\Contracts\Signer::class);
125
126			$request = Illuminate\Http\Request::create('/');
127
128			$guard = new Framgia\Jwt\Guard($provider, $request, $blacklist, $signer);
129
130			$this->assertTrue($guard->validate($credentials));
131			}
132
133			public function testUserReturnsNullWithoutToken()
134			{
135			$signer = m::mock(Framgia\Jwt\Signers\Hmac::class);
136
137			$provider = m::mock(Illuminate\Contracts\Auth\UserProvider::class);
138			$provider->shouldNotReceive('retrieveById');
139
140			$blacklist = m::mock(Framgia\Jwt\Blacklist::class);
141
142			$request = Illuminate\Http\Request::create('/');
143
144			$guard = new Framgia\Jwt\Guard($provider, $request, $blacklist, $signer);
145
146			$this->assertNull($guard->user());
147			}
148
149			public function testUserReturnsNullWithInvalidToken()
150			{
151			$credentials = ['foo' => 'bar'];
152
153			$provider = m::mock(Illuminate\Contracts\Auth\UserProvider::class);
154			$provider->shouldNotReceive('retrieveById');
155
156			$blacklist = m::mock(Framgia\Jwt\Blacklist::class);
157			$signer = m::mock(Framgia\Jwt\Contracts\Signer::class);
158
159			$request = Illuminate\Http\Request::create('/');
160
161			$request->headers->set('Authorization', 'Bearer BAD_TOKEN');
162
163			$guard = new Framgia\Jwt\Guard($provider, $request, $blacklist, $signer);
164
165			$this->assertNull($guard->user());
166			}
167
168			public function testAttemptReturnsToken()
169			{
170			$credentials = ['foo' => 'bar'];
171
172			$user = m::mock(\Illuminate\Contracts\Auth\Authenticatable::class);
173			$user->shouldReceive('getAuthIdentifier')->once()->andReturn(1);
174
175			$provider = m::mock(Illuminate\Contracts\Auth\UserProvider::class);
176			$provider->shouldReceive('retrieveByCredentials')->once()->with($credentials)->andReturn($user);
177			$provider->shouldReceive('validateCredentials')->once()->with($user, $credentials)->andReturn(true);
178
179			$blacklist = m::mock(Framgia\Jwt\Blacklist::class);
180			$signer = new Framgia\Jwt\Signers\Hmac('test');
181
182			$request = Illuminate\Http\Request::create('/');
183
184			$guard = new Framgia\Jwt\Guard($provider, $request, $blacklist, $signer);
185
186			/**
187			* @var \Lcobucci\JWT\Token
188			*/
189			$token = $guard->attempt($credentials);
190
191			$this->assertInstanceOf(\Lcobucci\JWT\Token::class, $token);
192			$this->assertEquals(1, $token->getClaim('sub'));
193			$this->assertLessThan($token->getClaim('exp'), time());
194			$this->assertNotNull($token->getClaim('jti'));
195
196			$this->assertTrue($guard->validate($credentials));
197			}
198
199			public function testAttemptWithAdditionalCredentials()
200			{
201			$credentials = ['foo' => 'bar'];
202
203			$user = m::mock(UserWithCredentials::class);
204			$user->shouldReceive('getAuthIdentifier')->once()->andReturn(1);
205			$user->shouldReceive('getCredentials')->once()->andReturn([
206			'admin' => true,
207			'foo' => 'bar',
208			]);
209
210			$provider = m::mock(Illuminate\Contracts\Auth\UserProvider::class);
211			$provider->shouldReceive('retrieveByCredentials')->once()->with($credentials)->andReturn($user);
212			$provider->shouldReceive('validateCredentials')->once()->with($user, $credentials)->andReturn(true);
213
214			$blacklist = m::mock(Framgia\Jwt\Blacklist::class);
215			$signer = new Framgia\Jwt\Signers\Hmac('test');
216
217			$request = Illuminate\Http\Request::create('/');
218
219			$guard = new Framgia\Jwt\Guard($provider, $request, $blacklist, $signer);
220
221			$token = $guard->attempt($credentials);
222
223			$this->assertInstanceOf(\Lcobucci\JWT\Token::class, $token);
224			$this->assertEquals(true, $token->getClaim('admin'));
225			$this->assertEquals('bar', $token->getClaim('foo'));
226
227			$this->assertTrue($guard->validate($credentials));
228			}
229
230			public function testAttemptNullWithInvalidCredentials()
231			{
232			$credentials = ['foo' => 'bar'];
233
234			$provider = m::mock(Illuminate\Contracts\Auth\UserProvider::class);
235			$provider->shouldReceive('retrieveByCredentials')->once()->with($credentials)->andReturn(null);
236
237			$blacklist = m::mock(Framgia\Jwt\Blacklist::class);
238			$signer = new Framgia\Jwt\Signers\Hmac('test');
239
240			$request = Illuminate\Http\Request::create('/');
241
242			$guard = new Framgia\Jwt\Guard($provider, $request, $blacklist, $signer);
243
244			$this->assertNull($guard->attempt($credentials));
245			}
246
247			public function testLogout()
248			{
249			$provider = m::mock(Illuminate\Contracts\Auth\UserProvider::class);
250
251			$blacklist = m::mock(Framgia\Jwt\Blacklist::class);
252			$token = (new \Lcobucci\JWT\Builder())->setId('foo')->setSubject(1)->setExpiration(time() + 3600)->getToken();
253			$blacklist->shouldReceive('add')->once()->andReturn(true);
254
255			$signer = m::mock(Framgia\Jwt\Contracts\Signer::class);
256
257			$request = Illuminate\Http\Request::create('/');
258			$signer->shouldReceive('verify')->once()->andReturn(true);
259
260			$request->headers->set('Authorization', 'Bearer '.$token);
261
262			$guard = new Framgia\Jwt\Guard($provider, $request, $blacklist, $signer);
263
264			$this->assertTrue($guard->logout());
265			}
266
267			public function testLogoutWithoutToken()
268			{
269			$provider = m::mock(Illuminate\Contracts\Auth\UserProvider::class);
270
271			$blacklist = m::mock(Framgia\Jwt\Blacklist::class);
272			$blacklist->shouldNotReceive('add');
273
274			$signer = m::mock(Framgia\Jwt\Contracts\Signer::class);
275
276			$request = Illuminate\Http\Request::create('/');
277			$signer->shouldReceive('verify')->once()->andReturn(true);
278
279			$guard = new Framgia\Jwt\Guard($provider, $request, $blacklist, $signer);
280
281			$this->assertTrue($guard->logout());
282			}
283
284			public function testLogoutWithInvalidToken()
285			{
286			$provider = m::mock(Illuminate\Contracts\Auth\UserProvider::class);
287
288			$blacklist = m::mock(Framgia\Jwt\Blacklist::class);
289			$blacklist->shouldNotReceive('add');
290
291			$signer = m::mock(Framgia\Jwt\Contracts\Signer::class);
292
293			$request = Illuminate\Http\Request::create('/');
294			$request->headers->set('Authorization', 'Bearer BAD_TOKEN');
295			$signer->shouldReceive('verify')->once()->andReturn(true);
296
297			$guard = new Framgia\Jwt\Guard($provider, $request, $blacklist, $signer);
298
299			$this->assertFalse($guard->logout());
300			}
301			}
302
303			abstract class UserWithCredentials implements \Illuminate\Contracts\Auth\Authenticatable, \Framgia\Jwt\Contracts\ProvidesCredentials {}
304

framgia / laravel-jwt

Push — master ( 6cab55...c82b86 )

GuardTest A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

Duplication Side-by-Side

Filter issues like