ProfileClientTest::setUp() - Code Metrics - php-http/HttplugBundle - Measure and Improve Code Quality continuously with Scrutinizer

ProfileClientTest::setUp() A
last analyzed 2021-02-12 10:16 UTC

↳ Parent: ProfileClientTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	33
rs	9.392
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

declare(strict_types=1);

namespace Http\HttplugBundle\Tests\Unit\Collector;

use GuzzleHttp\Psr7\Request;
use GuzzleHttp\Psr7\Response;
use GuzzleHttp\Psr7\Uri;
use Http\Client\HttpAsyncClient;
use Http\Client\HttpClient;
use Http\HttplugBundle\Collector\Collector;
use Http\HttplugBundle\Collector\Formatter;
use Http\HttplugBundle\Collector\ProfileClient;
use Http\HttplugBundle\Collector\Stack;
use Http\Promise\FulfilledPromise;
use Http\Promise\Promise;
use Http\Promise\RejectedPromise;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\UriInterface;
use Symfony\Component\Stopwatch\Stopwatch;
use Symfony\Component\Stopwatch\StopwatchEvent;

class ProfileClientTest extends TestCase
{
    /**
     * @var Collector
     */
    private $collector;

    /**
     * @var Stack
     */
    private $activeStack;

    /**
     * @var HttpClient|MockObject
     */
    private $client;

    /**
     * @var RequestInterface
     */
    private $request;

    /**
     * @var Formatter|MockObject
     */
    private $formatter;

    /**
     * @var Stopwatch
     */
    private $stopwatch;

    /**
     * @var StopwatchEvent
     */
    private $stopwatchEvent;

    /**
     * @var ProfileClient
     */
    private $subject;

    /**
     * @var ResponseInterface
     */
    private $response;

    /**
     * @var Promise
     */
    private $fulfilledPromise;

    /**
     * @var \Exception
     */
    private $exception;

    /**
     * @var RejectedPromise
     */
    private $rejectedPromise;

    /**
     * @var UriInterface
     */
    private $uri;

    public function setUp(): void
    {
        $this->collector = $this->getMockBuilder(Collector::class)->disableOriginalConstructor()->getMock();

        $this->activeStack = new Stack('default', 'FormattedRequest');
        $this->client = $this->getMockBuilder(ClientInterface::class)->getMock();
        $this->uri = new Uri('https://example.com/target');
        $this->request = new Request('GET', $this->uri);
        $this->formatter = $this->getMockBuilder(Formatter::class)->disableOriginalConstructor()->getMock();
        $this->stopwatch = $this->getMockBuilder(Stopwatch::class)->disableOriginalConstructor()->getMock();

        $this->stopwatchEvent = $this->getMockBuilder(StopwatchEvent::class)->disableOriginalConstructor()->getMock();

        $this->subject = new ProfileClient($this->client, $this->collector, $this->formatter, $this->stopwatch);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $this->response = new Response();
        $this->exception = new \Exception();
        $this->fulfilledPromise = new FulfilledPromise($this->response);
        $this->rejectedPromise = new RejectedPromise($this->exception);

        $this->collector->method('getActiveStack')->willReturn($this->activeStack);

        $this->formatter

            ->method('formatResponse')
            ->with($this->response)
            ->willReturn('FormattedResponse')
        ;

        $this->stopwatch

            ->method('start')
            ->willReturn($this->stopwatchEvent)
        ;

        $this->stopwatchEvent

            ->method('getDuration')
            ->willReturn(42)
        ;
    }

    public function testSendRequest(): void
    {
        $this->client
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('sendRequest')
            ->with($this->identicalTo($this->request))
            ->willReturn($this->response)
        ;

        $response = $this->subject->sendRequest($this->request);

        $this->assertEquals($this->response, $response);
        $this->assertEquals('GET', $this->activeStack->getRequestMethod());
        $this->assertEquals('/target', $this->activeStack->getRequestTarget());
        $this->assertEquals('example.com', $this->activeStack->getRequestHost());
        $this->assertEquals('https', $this->activeStack->getRequestScheme());
    }

    public function testSendRequestTypeError()
    {
        $this->client
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('sendRequest')
            ->willReturnCallback(function () {
                throw new \Error('You set string to int prop');

            });
        $this->formatter
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('formatException')
            ->with($this->isInstanceOf(\Error::class));

        $this->expectException(\Error::class);
        $this->expectExceptionMessage('You set string to int prop');
        $this->subject->sendRequest($this->request);
    }

    public function testSendAsyncRequest(): void
    {
        $this->client
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('sendAsyncRequest')
            ->with($this->identicalTo($this->request))
            ->willReturn($this->fulfilledPromise)
        ;

        $this->collector

            ->expects($this->once())
            ->method('deactivateStack')
        ;

        $promise = $this->subject->sendAsyncRequest($this->request);

        $this->assertEquals($this->fulfilledPromise, $promise);
        $this->assertEquals('GET', $this->activeStack->getRequestMethod());
        $this->assertEquals('/target', $this->activeStack->getRequestTarget());
        $this->assertEquals('example.com', $this->activeStack->getRequestHost());
        $this->assertEquals('https', $this->activeStack->getRequestScheme());
    }

    public function testOnFulfilled(): void

    {
        $this->collector

            ->expects($this->once())
            ->method('activateStack')
            ->with($this->activeStack)
        ;

        $this->stopwatchEvent

            ->expects($this->once())
            ->method('stop')
        ;

        $this->client
            ->method('sendAsyncRequest')
            ->willReturn($this->fulfilledPromise)
        ;

        $this->subject->sendAsyncRequest($this->request);

        $this->assertEquals(42, $this->activeStack->getDuration());
        $this->assertEquals(200, $this->activeStack->getResponseCode());
        $this->assertEquals('FormattedResponse', $this->activeStack->getClientResponse());
    }

    public function testOnRejected(): void

    {
        $this->collector

            ->expects($this->once())
            ->method('activateStack')
            ->with($this->activeStack)
        ;

        $this->stopwatchEvent

            ->expects($this->once())
            ->method('stop')
        ;

        $this->client
            ->method('sendAsyncRequest')
            ->willReturn($this->rejectedPromise)
        ;

        $this->formatter
            ->method('formatException')
            ->with($this->exception)
            ->willReturn('FormattedException')
        ;

        $this->subject->sendAsyncRequest($this->request);

        $this->assertEquals(42, $this->activeStack->getDuration());
        $this->assertEquals('FormattedException', $this->activeStack->getClientException());
    }
}

interface ClientInterface extends HttpClient, HttpAsyncClient
{
}


ProfileClientTest::setUp() A
last analyzed 2021-02-12 10:16 UTC

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1			<?php
2
3			declare(strict_types=1);
4
5			namespace Http\HttplugBundle\Tests\Unit\Collector;
6
7			use GuzzleHttp\Psr7\Request;
8			use GuzzleHttp\Psr7\Response;
9			use GuzzleHttp\Psr7\Uri;
10			use Http\Client\HttpAsyncClient;
11			use Http\Client\HttpClient;
12			use Http\HttplugBundle\Collector\Collector;
13			use Http\HttplugBundle\Collector\Formatter;
14			use Http\HttplugBundle\Collector\ProfileClient;
15			use Http\HttplugBundle\Collector\Stack;
16			use Http\Promise\FulfilledPromise;
17			use Http\Promise\Promise;
18			use Http\Promise\RejectedPromise;
19			use PHPUnit\Framework\MockObject\MockObject;
20			use PHPUnit\Framework\TestCase;
21			use Psr\Http\Message\RequestInterface;
22			use Psr\Http\Message\ResponseInterface;
23			use Psr\Http\Message\UriInterface;
24			use Symfony\Component\Stopwatch\Stopwatch;
25			use Symfony\Component\Stopwatch\StopwatchEvent;
26
27			class ProfileClientTest extends TestCase
28			{
29			/**
30			* @var Collector
31			*/
32			private $collector;
33
34			/**
35			* @var Stack
36			*/
37			private $activeStack;
38
39			/**
40			* @var HttpClient\|MockObject

php-http / HttplugBundle

ProfileClientTest::setUp() A last analyzed 2021-02-12 10:16 UTC

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like

ProfileClientTest::setUp() A
last analyzed 2021-02-12 10:16 UTC