Issues in JwtServiceTest.php - All Issues - Inspection of "Clean up some duplicate code and put alias for Cla..." - wisoot/jwt-guard - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( 8c7de8...b64521 )

by Wisoot

created 2016-05-04 23:37 UTC

tests/JwtServiceTest.php (1 issue)

Labels

Severity

Minor 1

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php

use Carbon\Carbon;
use Illuminate\Support\Facades\Config;
use WWON\JwtGuard\Claim;
use WWON\JwtGuard\Contract\ClaimManager;
use WWON\JwtGuard\JwtService;

class JwtServiceTest extends PHPUnit_Framework_TestCase
namespace YourVendor;

class YourClass { }
{

    /**
     * @var Mockery\MockInterface
     */
    private $claimManager;
    
    /**
     * @var JwtService
     */
    private $jwtService;

    /**
     * setUp method
     */
    public function setUp()
    {
        parent::setUp();

        Config::shouldReceive('get')
            ->once()
            ->with('jwt.secret')
            ->andReturn('abcdefg');

        Config::shouldReceive('get')
            ->once()
            ->with('jwt.leeway')
            ->andReturn(0);

        $this->claimManager = Mockery::mock(ClaimManager::class);
        $this->jwtService = new JwtService($this->claimManager);
    }

    /**
     * tearDown method
     */
    public function tearDown()
    {
        unset($this->jwtService);

        parent::tearDown();
    }

    /**
     * testGetTokenForClaim method
     */
    public function testGetTokenForClaim()
    {
        $now = Carbon::now()->timestamp;

        $token = $this->getToken();

        $items = explode('.', $token);
        $claimBody = json_decode(base64_decode($items[1]));

        $this->assertEquals('http://www.test.com', $claimBody->iss);
        $this->assertEquals($now, $claimBody->iat);
        $this->assertEquals($now + 6000, $claimBody->exp);
        $this->assertEquals($now + 6000, $claimBody->nat);
    }

    /**
     * testGetClaimFromToken method
     */
    public function testGetClaimFromToken()
    {
        $token = $this->getToken();

        $this->claimManager->shouldReceive('check')
            ->once()
            ->with(Mockery::on(function($claim) {
                return $claim->sub == 5
                    && $claim->iss == 'http://www.test.com';
            }))
            ->andReturn(true);

        $claim = $this->jwtService->getClaimFromToken($token);

        $this->assertEquals(5, $claim->sub);
        $this->assertEquals('User', $claim->aud);
        $this->assertEquals('http://www.test.com', $claim->iss);
    }

    /**
     * testGetUserIdFromTokenWithInvalidClaim method
     */
    public function testGetUserIdFromTokenWithInvalidClaim()
    {
        $token = $this->getToken();

        $this->claimManager->shouldReceive('check')
            ->once()
            ->with(Mockery::on(function($claim) {
                return $claim->sub == 5
                    && $claim->iss == 'http://www.test.com';
            }))
            ->andReturn(false);

        $this->setExpectedException(\WWON\JwtGuard\Exceptions\InvalidTokenException::class);

        $claim = $this->jwtService->getClaimFromToken($token);
    }

    /**
     * testRefreshToken method
     */
    public function testRefreshToken()
    {
        $now = Carbon::now()->timestamp;

        $token = $this->getToken(true);

        $this->claimManager->shouldReceive('check')
            ->once()
            ->with(Mockery::on(function($claim) {
                return $claim->sub == 5
                    && $claim->iss == 'http://www.test.com';
            }))
            ->andReturn(true);

        $this->claimManager->shouldReceive('remove')
            ->once()
            ->with(Mockery::on(function($claim) {
                return $claim->sub == 5
                    && $claim->iss == 'http://www.test.com';
            }));

        $newToken = $this->jwtService->refreshToken($token);

        $items = explode('.', $newToken);
        $claimBody = json_decode(base64_decode($items[1]));

        $this->assertEquals('http://www.test.com', $claimBody->iss);
        $this->assertEquals($now, $claimBody->iat);
        $this->assertEquals($now + 60000, $claimBody->exp);
        $this->assertEquals($now + 6000, $claimBody->nat);
    }

    /**
     * testRefreshUnRefreshableToken method
     */
    public function testRefreshUnRefreshableToken()
    {
        $now = Carbon::now()->timestamp;

        $token = $this->getToken();

        $this->claimManager->shouldReceive('check')
            ->once()
            ->with(Mockery::on(function($claim) {
                return $claim->sub == 5
                    && $claim->iss == 'http://www.test.com';
            }))
            ->andReturn(true);

        $this->setExpectedException(\WWON\JwtGuard\Exceptions\UnRefreshableException::class);

        $newToken = $this->jwtService->refreshToken($token);
    }

    /**
     * testInvalidateToken method
     */
    public function testInvalidateToken()
    {
        $now = Carbon::now()->timestamp;

        $token = $this->getToken();

        $this->claimManager->shouldReceive('check')
            ->once()
            ->with(Mockery::on(function($claim) {
                return $claim->sub == 5
                    && $claim->iss == 'http://www.test.com';
            }))
            ->andReturn(true);

        $this->claimManager->shouldReceive('remove')
            ->once()
            ->with(Mockery::on(function($claim) {
                return $claim->sub == 5
                    && $claim->iss == 'http://www.test.com';
            }));

        $this->jwtService->invalidateToken($token);
    }

    /**
     * testWipeUserTokens method
     */
    public function testWipeUserTokens()
    {
        $claim = $this->getClaim();

        $this->claimManager->shouldReceive('removeAll')
            ->once()
            ->with(Mockery::on(function($claim) {
                return $claim->sub == 5
                    && $claim->iss == 'http://www.test.com';
            }));

        $this->jwtService->wipeUserTokens($claim);
    }

    /**
     * getToken method
     *
     * @param bool $refreshable
     * @param int $ttl
     * @return string
     */
    protected function getToken($refreshable = false, $ttl = 100)
    {
        $claim = $this->getClaim($refreshable, $ttl);

        $this->claimManager->shouldReceive('add')
            ->once()
            ->with(Mockery::on(function($claim) {
                return $claim->sub == 5
                    && $claim->iss == 'http://www.test.com';
            }));

        $token = $this->jwtService->getTokenForClaim($claim);

        return $token;
    }

    /**
     * getClaim method
     *
     * @param bool $refreshable
     * @param int $ttl
     * @return Claim
     */
    protected function getClaim($refreshable = false, $ttl = 100)
    {
        Config::shouldReceive('get')
            ->once()
            ->with('app.url')
            ->andReturn('http://www.test.com');

        Config::shouldReceive('get')
            ->once()
            ->with('jwt.ttl')
            ->andReturn($ttl);

        Config::shouldReceive('get')
            ->once()
            ->with('jwt.ttl')
            ->andReturn($ttl);

        Config::shouldReceive('get')
            ->once()
            ->with('jwt.leeway')
            ->andReturn(0);

        Config::shouldReceive('get')
            ->once()
            ->with('jwt.algo')
            ->andReturn('HS256');

        $claim = new Claim([
            'sub' => 5,
            'aud' => 'User',
            'refresh' => $refreshable
        ]);

        return $claim;
    }

}

1		<?php
2
3		use Carbon\Carbon;
4		use Illuminate\Support\Facades\Config;
5		use WWON\JwtGuard\Claim;
6		use WWON\JwtGuard\Contract\ClaimManager;
7		use WWON\JwtGuard\JwtService;
8
9		class JwtServiceTest extends PHPUnit_Framework_TestCase
		0 ignored issues – show Coding Style Compatibility introduced 2016-04-28 05:30 UTC by Report Bug Copy Issue Report Show Similar Issues like this PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions. You can fix this by adding a namespace to your class: namespace YourVendor; class YourClass { } When choosing a vendor namespace, try to pick something that is not too generic to avoid conflicts with other libraries. Loading history...
10		{
11
12		/**
13		* @var Mockery\MockInterface
14		*/
15		private $claimManager;
16
17		/**
18		* @var JwtService
19		*/
20		private $jwtService;
21
22		/**
23		* setUp method
24		*/
25		public function setUp()
26		{
27		parent::setUp();
28
29		Config::shouldReceive('get')
30		->once()
31		->with('jwt.secret')
32		->andReturn('abcdefg');
33
34		Config::shouldReceive('get')
35		->once()
36		->with('jwt.leeway')
37		->andReturn(0);
38
39		$this->claimManager = Mockery::mock(ClaimManager::class);
40		$this->jwtService = new JwtService($this->claimManager);
41		}
42
43		/**
44		* tearDown method
45		*/
46		public function tearDown()
47		{
48		unset($this->jwtService);
49
50		parent::tearDown();
51		}
52
53		/**
54		* testGetTokenForClaim method
55		*/
56		public function testGetTokenForClaim()
57		{
58		$now = Carbon::now()->timestamp;
59
60		$token = $this->getToken();
61
62		$items = explode('.', $token);
63		$claimBody = json_decode(base64_decode($items[1]));
64
65		$this->assertEquals('http://www.test.com', $claimBody->iss);
66		$this->assertEquals($now, $claimBody->iat);
67		$this->assertEquals($now + 6000, $claimBody->exp);
68		$this->assertEquals($now + 6000, $claimBody->nat);
69		}
70
71		/**
72		* testGetClaimFromToken method
73		*/
74		public function testGetClaimFromToken()
75		{
76		$token = $this->getToken();
77
78		$this->claimManager->shouldReceive('check')
79		->once()
80		->with(Mockery::on(function($claim) {
81		return $claim->sub == 5
82		&& $claim->iss == 'http://www.test.com';
83		}))
84		->andReturn(true);
85
86		$claim = $this->jwtService->getClaimFromToken($token);
87
88		$this->assertEquals(5, $claim->sub);
89		$this->assertEquals('User', $claim->aud);
90		$this->assertEquals('http://www.test.com', $claim->iss);
91		}
92
93		/**
94		* testGetUserIdFromTokenWithInvalidClaim method
95		*/
96	View Code Duplication	public function testGetUserIdFromTokenWithInvalidClaim()
97		{
98		$token = $this->getToken();
99
100		$this->claimManager->shouldReceive('check')
101		->once()
102		->with(Mockery::on(function($claim) {
103		return $claim->sub == 5
104		&& $claim->iss == 'http://www.test.com';
105		}))
106		->andReturn(false);
107
108		$this->setExpectedException(\WWON\JwtGuard\Exceptions\InvalidTokenException::class);
109
110		$claim = $this->jwtService->getClaimFromToken($token);
111		}
112
113		/**
114		* testRefreshToken method
115		*/
116		public function testRefreshToken()
117		{
118		$now = Carbon::now()->timestamp;
119
120		$token = $this->getToken(true);
121
122		$this->claimManager->shouldReceive('check')
123		->once()
124		->with(Mockery::on(function($claim) {
125		return $claim->sub == 5
126		&& $claim->iss == 'http://www.test.com';
127		}))
128		->andReturn(true);
129
130		$this->claimManager->shouldReceive('remove')
131		->once()
132		->with(Mockery::on(function($claim) {
133		return $claim->sub == 5
134		&& $claim->iss == 'http://www.test.com';
135		}));
136
137		$newToken = $this->jwtService->refreshToken($token);
138
139		$items = explode('.', $newToken);
140		$claimBody = json_decode(base64_decode($items[1]));
141
142		$this->assertEquals('http://www.test.com', $claimBody->iss);
143		$this->assertEquals($now, $claimBody->iat);
144		$this->assertEquals($now + 60000, $claimBody->exp);
145		$this->assertEquals($now + 6000, $claimBody->nat);
146		}
147
148		/**
149		* testRefreshUnRefreshableToken method
150		*/
151	View Code Duplication	public function testRefreshUnRefreshableToken()
152		{
153		$now = Carbon::now()->timestamp;
154
155		$token = $this->getToken();
156
157		$this->claimManager->shouldReceive('check')
158		->once()
159		->with(Mockery::on(function($claim) {
160		return $claim->sub == 5
161		&& $claim->iss == 'http://www.test.com';
162		}))
163		->andReturn(true);
164
165		$this->setExpectedException(\WWON\JwtGuard\Exceptions\UnRefreshableException::class);
166
167		$newToken = $this->jwtService->refreshToken($token);
168		}
169
170		/**
171		* testInvalidateToken method
172		*/
173		public function testInvalidateToken()
174		{
175		$now = Carbon::now()->timestamp;
176
177		$token = $this->getToken();
178
179		$this->claimManager->shouldReceive('check')
180		->once()
181		->with(Mockery::on(function($claim) {
182		return $claim->sub == 5
183		&& $claim->iss == 'http://www.test.com';
184		}))
185		->andReturn(true);
186
187		$this->claimManager->shouldReceive('remove')
188		->once()
189		->with(Mockery::on(function($claim) {
190		return $claim->sub == 5
191		&& $claim->iss == 'http://www.test.com';
192		}));
193
194		$this->jwtService->invalidateToken($token);
195		}
196
197		/**
198		* testWipeUserTokens method
199		*/
200		public function testWipeUserTokens()
201		{
202		$claim = $this->getClaim();
203
204		$this->claimManager->shouldReceive('removeAll')
205		->once()
206		->with(Mockery::on(function($claim) {
207		return $claim->sub == 5
208		&& $claim->iss == 'http://www.test.com';
209		}));
210
211		$this->jwtService->wipeUserTokens($claim);
212		}
213
214		/**
215		* getToken method
216		*
217		* @param bool $refreshable
218		* @param int $ttl
219		* @return string
220		*/
221		protected function getToken($refreshable = false, $ttl = 100)
222		{
223		$claim = $this->getClaim($refreshable, $ttl);
224
225		$this->claimManager->shouldReceive('add')
226		->once()
227		->with(Mockery::on(function($claim) {
228		return $claim->sub == 5
229		&& $claim->iss == 'http://www.test.com';
230		}));
231
232		$token = $this->jwtService->getTokenForClaim($claim);
233
234		return $token;
235		}
236
237		/**
238		* getClaim method
239		*
240		* @param bool $refreshable
241		* @param int $ttl
242		* @return Claim
243		*/
244		protected function getClaim($refreshable = false, $ttl = 100)
245		{
246		Config::shouldReceive('get')
247		->once()
248		->with('app.url')
249		->andReturn('http://www.test.com');
250
251		Config::shouldReceive('get')
252		->once()
253		->with('jwt.ttl')
254		->andReturn($ttl);
255
256		Config::shouldReceive('get')
257		->once()
258		->with('jwt.ttl')
259		->andReturn($ttl);
260
261		Config::shouldReceive('get')
262		->once()
263		->with('jwt.leeway')
264		->andReturn(0);
265
266		Config::shouldReceive('get')
267		->once()
268		->with('jwt.algo')
269		->andReturn('HS256');
270
271		$claim = new Claim([
272		'sub' => 5,
273		'aud' => 'User',
274		'refresh' => $refreshable
275		]);
276
277		return $claim;
278		}
279
280		}

wisoot / jwt-guard

Push — develop ( 8c7de8...b64521 )

tests/JwtServiceTest.php (1 issue)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like