Yiisoft\Yii\Web\Tests\RateLimiter\RateLimiterMiddlewareTest

Complexity

Total Complexity

4

Size/Duplication

Total Lines	99
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	hp$0 ➔ createRequestHandler()	0	6	1
A	hp$0 ➔ createRequest()	0	3	1
A	counterIdCouldBeSet()	0	6	1
A	hp$0 ➔ createRateLimiter()	0	3	1
A	counterIdCouldBeSetWithCallback()	0	11	1
	createRateLimiter()	0	3	?
	createRequest()	0	3	?
A	singleRequestWorksAsExpected()	0	13	1
A	hp$0 ➔ handle()	0	3	1
	createRequestHandler()	0	6	?
A	limitingIsStartedWhenExpected()	0	27	1

<?php

namespace Yiisoft\Yii\Web\Tests\RateLimiter;

use Nyholm\Psr7\Factory\Psr17Factory;
use Nyholm\Psr7\Response;
use Nyholm\Psr7\ServerRequest;
use PHPUnit\Framework\TestCase;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Yiisoft\Http\Method;
use Yiisoft\Yii\Web\RateLimiter\CounterInterface;
use Yiisoft\Yii\Web\RateLimiter\RateLimiterMiddleware;

final class RateLimiterMiddlewareTest extends TestCase
{
    /**
     * @test
     */
    public function singleRequestWorksAsExpected(): void
    {
        $counter = new FakeCounter(100, 100);
        $response = $this->createRateLimiter($counter)->process($this->createRequest(), $this->createRequestHandler());
        $this->assertEquals(200, $response->getStatusCode());

        $this->assertEquals(
            [
                'X-Rate-Limit-Limit' => ['100'],
                'X-Rate-Limit-Remaining' => ['99'],
                'X-Rate-Limit-Reset' => ['100'],
            ],
            $response->getHeaders()
        );
    }

    /**
     * @test
     */
    public function limitingIsStartedWhenExpected(): void
    {
        $counter = new FakeCounter(2, 100);
        $middleware = $this->createRateLimiter($counter);

        // last allowed request
        $response = $middleware->process($this->createRequest(), $this->createRequestHandler());
        $this->assertEquals(200, $response->getStatusCode());
        $this->assertEquals(
            [
                'X-Rate-Limit-Limit' => ['2'],
                'X-Rate-Limit-Remaining' => ['1'],
                'X-Rate-Limit-Reset' => ['100'],
            ],
            $response->getHeaders()
        );

        // first denied request
        $response = $middleware->process($this->createRequest(), $this->createRequestHandler());
        $this->assertEquals(429, $response->getStatusCode());
        $this->assertEquals(
            [
                'X-Rate-Limit-Limit' => ['2'],
                'X-Rate-Limit-Remaining' => ['0'],
                'X-Rate-Limit-Reset' => ['100'],
            ],
            $response->getHeaders()
        );
    }

    /**
     * @test
     */
    public function counterIdCouldBeSet(): void
    {
        $counter = new FakeCounter(100, 100);
        $middleware = $this->createRateLimiter($counter)->withCounterId('custom-id');
        $middleware->process($this->createRequest(), $this->createRequestHandler());
        $this->assertEquals('custom-id', $counter->getId());
    }

    /**
     * @test
     */
    public function counterIdCouldBeSetWithCallback(): void
    {
        $counter = new FakeCounter(100, 100);
        $middleware = $this->createRateLimiter($counter)->withCounterIdCallback(
            static function (ServerRequestInterface $request) {
                return $request->getMethod();
            }
        );

        $middleware->process($this->createRequest(), $this->createRequestHandler());
        $this->assertEquals('GET', $counter->getId());
    }

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

    private function createRequest(string $method = Method::GET, string $uri = '/'): ServerRequestInterface
    {
        return new ServerRequest($method, $uri);
    }

    private function createRateLimiter(CounterInterface $counter): RateLimiterMiddleware
    {
        return new RateLimiterMiddleware($counter, new Psr17Factory());
    }
}