CsrfTest.php$0 ➔ getBodyRequestParamsByToken() - Code Metrics - Inspection of "unit tests for csrf middleware" - yiisoft/yii-web - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#112)

unknown

created 2019-09-06 21:15 UTC

CsrfTest.php$0 ➔ getBodyRequestParamsByToken() A

↳ Parent: CsrfTest

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
c	0
b	0
f	0
dl	0
loc	4
rs	10

<?php


namespace Yiisoft\Yii\Web\Tests\Middleware;

use Nyholm\Psr7\Factory\Psr17Factory;
use Nyholm\Psr7\Response;
use Nyholm\Psr7\ServerRequest;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Yiisoft\Router\Method;
use Yiisoft\Security\Random;
use Yiisoft\Security\TokenMasker;
use Yiisoft\Yii\Web\Middleware\Csrf;
use Yiisoft\Yii\Web\Session\SessionInterface;

final class CsrfTest extends TestCase
{
    private const PARAM_NAME = 'csrf';

    /**
     * @test
     */
    public function validTokenInBodyPostRequestResultIn200()
    {
        $token      = $this->generateToken();
        $middleware = $this->createCsrfMiddlewareWithToken($token);
        $response   = $middleware->process($this->createPostServerRequestWithBodyToken($token), $this->createRequestHandler());
        $this->assertEquals(200, $response->getStatusCode());
    }

    /**
     * @test
     */
    public function validTokenInBodyPutRequestResultIn200()
    {
        $token      = $this->generateToken();
        $middleware = $this->createCsrfMiddlewareWithToken($token);
        $response   = $middleware->process($this->createPutServerRequestWithBodyToken($token), $this->createRequestHandler());
        $this->assertEquals(200, $response->getStatusCode());
    }

    /**
     * @test
     */
    public function validTokenInBodyDeleteRequestResultIn200()
    {
        $token      = $this->generateToken();
        $middleware = $this->createCsrfMiddlewareWithToken($token);
        $response   = $middleware->process($this->createDeleteServerRequestWithBodyToken($token), $this->createRequestHandler());
        $this->assertEquals(200, $response->getStatusCode());
    }

    /**
     * @test
     */
    public function validTokenInHeaderResultIn200()
    {
        $token      = $this->generateToken();
        $middleware = $this->createCsrfMiddlewareWithToken($token);
        $response   = $middleware->process($this->createPostServerRequestWithHeaderToken($token), $this->createRequestHandler());
        $this->assertEquals(200, $response->getStatusCode());
    }

    /**
     * @test
     */
    public function getIsAlwaysAllowed()
    {
        $middleware = $this->createCsrfMiddlewareWithToken('');
        $response   = $middleware->process($this->createServerRequest(Method::GET), $this->createRequestHandler());
        $this->assertEquals(200, $response->getStatusCode());
    }

    /**
     * @test
     */
    public function invalidTokenResultIn400()
    {
        $middleware = $this->createCsrfMiddlewareWithToken($this->generateToken());
        $response   = $middleware->process($this->createPostServerRequestWithBodyToken($this->generateToken()), $this->createRequestHandler());
        $this->assertEquals(400, $response->getStatusCode());
    }

    /**
     * @test
     */
    public function emptyTokenInSessionResultIn400()
    {
        $middleware = $this->createCsrfMiddlewareWithToken('');
        $response   = $middleware->process($this->createPostServerRequestWithBodyToken($this->generateToken()), $this->createRequestHandler());
        $this->assertEquals(400, $response->getStatusCode());
    }

    /**
     * @test
     */
    public function emptyTokenInRequestResultIn400()
    {
        $middleware = $this->createCsrfMiddlewareWithToken($this->generateToken());
        $response   = $middleware->process($this->createServerRequest(), $this->createRequestHandler());
        $this->assertEquals(400, $response->getStatusCode());
    }


    private function createServerRequest(string $method = Method::POST, array $bodyParams = [], array $headParams = []): ServerRequestInterface
    {
        $request = new ServerRequest($method, '/', $headParams);

        return $request->withParsedBody($bodyParams);
    }

    private function createPostServerRequestWithBodyToken(string $token): ServerRequestInterface
    {
        return $this->createServerRequest(Method::POST, $this->getBodyRequestParamsByToken($token));
    }

    private function createPutServerRequestWithBodyToken(string $token): ServerRequestInterface
    {
        return $this->createServerRequest(Method::PUT, $this->getBodyRequestParamsByToken($token));
    }

    private function createDeleteServerRequestWithBodyToken(string $token): ServerRequestInterface
    {
        return $this->createServerRequest(Method::DELETE, $this->getBodyRequestParamsByToken($token));
    }

    private function createPostServerRequestWithHeaderToken(string $token): ServerRequestInterface
    {
        return $this->createServerRequest(Method::POST, [], [
            Csrf::HEADER_NAME => TokenMasker::mask($token),
        ]);
    }

    private function createRequestHandler(): RequestHandlerInterface
    {
        return new class implements RequestHandlerInterface
        {
            public function handle(ServerRequestInterface $request): ResponseInterface
            {
                return new Response(200);
            }
        };
    }

    private function createSessionMock(string $returnToken)
    {
        /**
         * @var SessionInterface|MockObject $sessionMock
         */
        $sessionMock = $this->createMock(SessionInterface::class);

        $sessionMock
            ->expects($this->once())
            ->method('get')
            ->willReturn($returnToken);

        return $sessionMock;
    }


    private function createCsrfMiddlewareWithToken(string $token): Csrf
    {
        $middleware = new Csrf(new Psr17Factory(), $this->createSessionMock($token));
        $middleware->setName(self::PARAM_NAME);

        return $middleware;
    }

    private function generateToken(): string
    {
        return Random::string();
    }

    private function getBodyRequestParamsByToken(string $token): array
    {
        return [
            self::PARAM_NAME => TokenMasker::mask($token),
        ];
    }
}


1			<?php
2
3
4			namespace Yiisoft\Yii\Web\Tests\Middleware;
5
6			use Nyholm\Psr7\Factory\Psr17Factory;
7			use Nyholm\Psr7\Response;
8			use Nyholm\Psr7\ServerRequest;
9			use PHPUnit\Framework\MockObject\MockObject;
10			use PHPUnit\Framework\TestCase;
11			use Psr\Http\Message\ResponseInterface;
12			use Psr\Http\Message\ServerRequestInterface;
13			use Psr\Http\Server\RequestHandlerInterface;
14			use Yiisoft\Router\Method;
15			use Yiisoft\Security\Random;
16			use Yiisoft\Security\TokenMasker;
17			use Yiisoft\Yii\Web\Middleware\Csrf;
18			use Yiisoft\Yii\Web\Session\SessionInterface;
19
20			final class CsrfTest extends TestCase
21			{
22			private const PARAM_NAME = 'csrf';
23
24			/**
25			* @test
26			*/
27			public function validTokenInBodyPostRequestResultIn200()
28			{
29			$token = $this->generateToken();
30			$middleware = $this->createCsrfMiddlewareWithToken($token);
31			$response = $middleware->process($this->createPostServerRequestWithBodyToken($token), $this->createRequestHandler());
32			$this->assertEquals(200, $response->getStatusCode());
33			}
34
35			/**
36			* @test
37			*/
38			public function validTokenInBodyPutRequestResultIn200()
39			{
40			$token = $this->generateToken();
41			$middleware = $this->createCsrfMiddlewareWithToken($token);
42			$response = $middleware->process($this->createPutServerRequestWithBodyToken($token), $this->createRequestHandler());
43			$this->assertEquals(200, $response->getStatusCode());
44			}
45
46			/**
47			* @test
48			*/
49			public function validTokenInBodyDeleteRequestResultIn200()
50			{
51			$token = $this->generateToken();
52			$middleware = $this->createCsrfMiddlewareWithToken($token);
53			$response = $middleware->process($this->createDeleteServerRequestWithBodyToken($token), $this->createRequestHandler());
54			$this->assertEquals(200, $response->getStatusCode());
55			}
56
57			/**
58			* @test
59			*/
60			public function validTokenInHeaderResultIn200()
61			{
62			$token = $this->generateToken();
63			$middleware = $this->createCsrfMiddlewareWithToken($token);
64			$response = $middleware->process($this->createPostServerRequestWithHeaderToken($token), $this->createRequestHandler());
65			$this->assertEquals(200, $response->getStatusCode());
66			}
67
68			/**
69			* @test
70			*/
71			public function getIsAlwaysAllowed()
72			{
73			$middleware = $this->createCsrfMiddlewareWithToken('');
74			$response = $middleware->process($this->createServerRequest(Method::GET), $this->createRequestHandler());
75			$this->assertEquals(200, $response->getStatusCode());
76			}
77
78			/**
79			* @test
80			*/
81			public function invalidTokenResultIn400()
82			{
83			$middleware = $this->createCsrfMiddlewareWithToken($this->generateToken());
84			$response = $middleware->process($this->createPostServerRequestWithBodyToken($this->generateToken()), $this->createRequestHandler());
85			$this->assertEquals(400, $response->getStatusCode());
86			}
87
88			/**
89			* @test
90			*/
91			public function emptyTokenInSessionResultIn400()
92			{
93			$middleware = $this->createCsrfMiddlewareWithToken('');
94			$response = $middleware->process($this->createPostServerRequestWithBodyToken($this->generateToken()), $this->createRequestHandler());
95			$this->assertEquals(400, $response->getStatusCode());
96			}
97
98			/**
99			* @test
100			*/
101			public function emptyTokenInRequestResultIn400()
102			{
103			$middleware = $this->createCsrfMiddlewareWithToken($this->generateToken());
104			$response = $middleware->process($this->createServerRequest(), $this->createRequestHandler());
105			$this->assertEquals(400, $response->getStatusCode());
106			}
107
108
109			private function createServerRequest(string $method = Method::POST, array $bodyParams = [], array $headParams = []): ServerRequestInterface
110			{
111			$request = new ServerRequest($method, '/', $headParams);
112
113			return $request->withParsedBody($bodyParams);
114			}
115
116			private function createPostServerRequestWithBodyToken(string $token): ServerRequestInterface
117			{
118			return $this->createServerRequest(Method::POST, $this->getBodyRequestParamsByToken($token));
119			}
120
121			private function createPutServerRequestWithBodyToken(string $token): ServerRequestInterface
122			{
123			return $this->createServerRequest(Method::PUT, $this->getBodyRequestParamsByToken($token));
124			}
125
126			private function createDeleteServerRequestWithBodyToken(string $token): ServerRequestInterface
127			{
128			return $this->createServerRequest(Method::DELETE, $this->getBodyRequestParamsByToken($token));
129			}
130
131			private function createPostServerRequestWithHeaderToken(string $token): ServerRequestInterface
132			{
133			return $this->createServerRequest(Method::POST, [], [
134			Csrf::HEADER_NAME => TokenMasker::mask($token),
135			]);
136			}
137
138			private function createRequestHandler(): RequestHandlerInterface
139			{
140			return new class implements RequestHandlerInterface
141			{
142			public function handle(ServerRequestInterface $request): ResponseInterface
143			{
144			return new Response(200);
145			}
146			};
147			}
148
149			private function createSessionMock(string $returnToken)
150			{
151			/**
152			* @var SessionInterface\|MockObject $sessionMock
153			*/
154			$sessionMock = $this->createMock(SessionInterface::class);
155
156			$sessionMock
157			->expects($this->once())
158			->method('get')
159			->willReturn($returnToken);
160
161			return $sessionMock;
162			}
163
164
165			private function createCsrfMiddlewareWithToken(string $token): Csrf
166			{
167			$middleware = new Csrf(new Psr17Factory(), $this->createSessionMock($token));
168			$middleware->setName(self::PARAM_NAME);
169
170			return $middleware;
171			}
172
173			private function generateToken(): string
174			{
175			return Random::string();
176			}
177
178			private function getBodyRequestParamsByToken(string $token): array
179			{
180			return [
181			self::PARAM_NAME => TokenMasker::mask($token),
182			];
183			}
184			}
185

yiisoft / yii-web

Pull Request — master (#112)

CsrfTest.php$0 ➔ getBodyRequestParamsByToken() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like