PSR7CsrfTest\TokenGeneratorTest

Complexity

Total Complexity

6

Size/Duplication

Total Lines	91
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	testWillRejectInvalidExpirationTime()	0	16	2
A	invalidExpirationTimeProvider()	0	10	1
A	testWillGenerateAValidJWTToken()	0	23	1
A	validExpirationTimeProvider()	0	7	1
A	testWillFailIfTheSessionAttributeIsNotASession()	0	17	1

<?php

declare(strict_types=1);

namespace PSR7CsrfTest;

use Lcobucci\JWT\Signer;
use Lcobucci\JWT\Signer\Hmac\Sha256;
use PHPUnit\Framework\TestCase;
use Psr\Http\Message\ServerRequestInterface;
use PSR7Csrf\Exception\InvalidExpirationTimeException;
use PSR7Csrf\Exception\SessionAttributeNotFoundException;
use PSR7Csrf\Session\ExtractUniqueKeyFromSessionInterface;
use PSR7Csrf\TokenGenerator;
use PSR7Sessions\Storageless\Session\SessionInterface;
use stdClass;

/**
 * @covers \PSR7Csrf\TokenGenerator
 */
final class TokenGeneratorTest extends TestCase
{
    /**
     * @dataProvider invalidExpirationTimeProvider
     *
     * @param int  $invalidExpirationTime
     * @param bool $valid
     */
    public function testWillRejectInvalidExpirationTime(int $invalidExpirationTime, bool $valid)
    {
        /* @var $signer Signer */
        $signer                      = $this->createMock(Signer::class);
        /* @var $extractUniqueKeyFromSession ExtractUniqueKeyFromSessionInterface */
        $extractUniqueKeyFromSession = $this->createMock(ExtractUniqueKeyFromSessionInterface::class);

        if (! $valid) {
            $this->expectException(InvalidExpirationTimeException::class);
        }

        self::assertInstanceOf(
            TokenGenerator::class,
            new TokenGenerator($signer, $extractUniqueKeyFromSession, $invalidExpirationTime, 'session')
        );
    }

    public function invalidExpirationTimeProvider() : array
    {
        return [
            [100, true],
            [1, true],
            [0, false],
            [-1, false],
            [-200, false],
        ];
    }

    /**
     * @dataProvider validExpirationTimeProvider
     *
     * @param int $validExpirationTime
     */
    public function testWillGenerateAValidJWTToken(int $validExpirationTime)
    {
        $signer = new Sha256();
        /* @var $extractUniqueKeyFromSession ExtractUniqueKeyFromSessionInterface|\PHPUnit_Framework_MockObject_MockObject */
        $extractUniqueKeyFromSession = $this->createMock(ExtractUniqueKeyFromSessionInterface::class);
        /* @var $session SessionInterface */
        $session = $this->createMock(SessionInterface::class);
        /* @var $request ServerRequestInterface|\PHPUnit_Framework_MockObject_MockObject */
        $request = $this->createMock(ServerRequestInterface::class);
        $sessionAttribute = uniqid('session', true);

        $generator = new TokenGenerator($signer, $extractUniqueKeyFromSession, $validExpirationTime, $sessionAttribute);

It seems like $extractUniqueKeyFromSession defined by $this->createMock(\PSR7Csrf\Session\ExtractUniqueKeyFromSessionInterface::class) on line 66 can also be of type object<PHPUnit_Framework_MockObject_MockObject>; however, PSR7Csrf\TokenGenerator::__construct() does only seem to accept object<PSR7Csrf\Session\ExtractUniqueKeyFromSessionInterface>, maybe add an additional type check?

        $secretKey = uniqid('secretKey', true);

        $request->expects(self::any())->method('getAttribute')->with($sessionAttribute)->willReturn($session);
        $extractUniqueKeyFromSession->expects(self::any())->method('__invoke')->with($session)->willReturn($secretKey);

        $token = $generator->__invoke($request);

It seems like $request defined by $this->createMock(\Psr\Http\Message\ServerRequestInterface::class) on line 70 can also be of type object<PHPUnit_Framework_MockObject_MockObject>; however, PSR7Csrf\TokenGenerator::__invoke() does only seem to accept object<Psr\Http\Message\ServerRequestInterface>, maybe add an additional type check?

        self::assertTrue($token->verify($signer, $secretKey));
        self::assertLessThanOrEqual(time(), $token->getClaim('iat'));
        self::assertGreaterThan(time(), $token->getClaim('exp'));
    }

    public function validExpirationTimeProvider() : array
    {
        return [
            [10],
            [100],
        ];
    }

    public function testWillFailIfTheSessionAttributeIsNotASession()
    {
        /* @var $extractUniqueKeyFromSession ExtractUniqueKeyFromSessionInterface|\PHPUnit_Framework_MockObject_MockObject */
        $extractUniqueKeyFromSession = $this->createMock(ExtractUniqueKeyFromSessionInterface::class);
        /* @var $request ServerRequestInterface|\PHPUnit_Framework_MockObject_MockObject */
        $request = $this->createMock(ServerRequestInterface::class);
        $sessionAttribute = uniqid('session', true);

        $generator = new TokenGenerator(new Sha256(), $extractUniqueKeyFromSession, 10, $sessionAttribute);

It seems like $extractUniqueKeyFromSession defined by $this->createMock(\PSR7Csrf\Session\ExtractUniqueKeyFromSessionInterface::class) on line 97 can also be of type object<PHPUnit_Framework_MockObject_MockObject>; however, PSR7Csrf\TokenGenerator::__construct() does only seem to accept object<PSR7Csrf\Session\ExtractUniqueKeyFromSessionInterface>, maybe add an additional type check?

        $request->expects(self::any())->method('getAttribute')->with($sessionAttribute)->willReturn(new stdClass());
        $request->expects(self::any())->method('getAttributes')->willReturn([]);

        $this->expectException(SessionAttributeNotFoundException::class);

        $generator->__invoke($request);

It seems like $request defined by $this->createMock(\Psr\Http\Message\ServerRequestInterface::class) on line 99 can also be of type object<PHPUnit_Framework_MockObject_MockObject>; however, PSR7Csrf\TokenGenerator::__invoke() does only seem to accept object<Psr\Http\Message\ServerRequestInterface>, maybe add an additional type check?

    }
}