Gecko [ unitednationsplay.com ]

Name	Size	Permission	Date
CallableStub.php	108 B	-rw-r--r--	2018-04-10 09:00
DecodeChunkedStreamTest.php	7.87 KB	-rw-r--r--	2018-04-10 09:00
FunctionalIntegrationTest.php	5.31 KB	-rw-r--r--	2018-04-10 09:00
RequestDataTest.php	4.51 KB	-rw-r--r--	2018-04-10 09:00
RequestTest.php	22.34 KB	-rw-r--r--	2018-04-10 09:00
ResponseTest.php	4.09 KB	-rw-r--r--	2018-04-10 09:00
TestCase.php	1.17 KB	-rw-r--r--	2018-04-10 09:00
bootstrap.php	206 B	-rw-r--r--	2018-04-10 09:00

Rename

<?php

namespace React\Tests\HttpClient;

use React\HttpClient\Request;
use React\HttpClient\RequestData;
use React\Stream\Stream;
use React\Stream\DuplexResourceStream;
use React\Promise\RejectedPromise;
use React\Promise\Deferred;
use React\Promise\Promise;

class RequestTest extends TestCase
{
    private $connector;
    private $stream;

public function setUp()
    {
        $this->stream = $this->getMockBuilder('React\Socket\ConnectionInterface')
            ->disableOriginalConstructor()
            ->getMock();

$this->connector = $this->getMockBuilder('React\Socket\ConnectorInterface')
            ->getMock();

$this->response = $this->getMockBuilder('React\HttpClient\Response')
            ->disableOriginalConstructor()
            ->getMock();
    }

/** @test */
    public function requestShouldBindToStreamEventsAndUseconnector()
    {
        $requestData = new RequestData('GET', 'http://www.example.com');
        $request = new Request($this->connector, $requestData);

$this->successfulConnectionMock();

$this->stream
            ->expects($this->at(0))
            ->method('on')
            ->with('drain', $this->identicalTo(array($request, 'handleDrain')));
        $this->stream
            ->expects($this->at(1))
            ->method('on')
            ->with('data', $this->identicalTo(array($request, 'handleData')));
        $this->stream
            ->expects($this->at(2))
            ->method('on')
            ->with('end', $this->identicalTo(array($request, 'handleEnd')));
        $this->stream
            ->expects($this->at(3))
            ->method('on')
            ->with('error', $this->identicalTo(array($request, 'handleError')));
        $this->stream
            ->expects($this->at(4))
            ->method('on')
            ->with('close', $this->identicalTo(array($request, 'handleClose')));
        $this->stream
            ->expects($this->at(6))
            ->method('removeListener')
            ->with('drain', $this->identicalTo(array($request, 'handleDrain')));
        $this->stream
            ->expects($this->at(7))
            ->method('removeListener')
            ->with('data', $this->identicalTo(array($request, 'handleData')));
        $this->stream
            ->expects($this->at(8))
            ->method('removeListener')
            ->with('end', $this->identicalTo(array($request, 'handleEnd')));
        $this->stream
            ->expects($this->at(9))
            ->method('removeListener')
            ->with('error', $this->identicalTo(array($request, 'handleError')));
        $this->stream
            ->expects($this->at(10))
            ->method('removeListener')
            ->with('close', $this->identicalTo(array($request, 'handleClose')));

$response = $this->response;

$this->stream->expects($this->once())
            ->method('emit')
            ->with('data', $this->identicalTo(array('body')));

$response->expects($this->at(0))
            ->method('on')
            ->with('close', $this->anything())
            ->will($this->returnCallback(function ($event, $cb) use (&$endCallback) {
                $endCallback = $cb;
            }));

$factory = $this->createCallableMock();
        $factory->expects($this->once())
            ->method('__invoke')
            ->with('HTTP', '1.0', '200', 'OK', array('Content-Type' => 'text/plain'))
            ->will($this->returnValue($response));

$request->setResponseFactory($factory);

$handler = $this->createCallableMock();
        $handler->expects($this->once())
            ->method('__invoke')
            ->with($response);

$request->on('response', $handler);
        $request->on('end', $this->expectCallableNever());

$handler = $this->createCallableMock();
        $handler->expects($this->once())
            ->method('__invoke');

$request->on('close', $handler);
        $request->end();

$request->handleData("HTTP/1.0 200 OK\r\n");
        $request->handleData("Content-Type: text/plain\r\n");
        $request->handleData("\r\nbody");

$this->assertNotNull($endCallback);
        call_user_func($endCallback);
    }

/** @test */
    public function requestShouldEmitErrorIfConnectionFails()
    {
        $requestData = new RequestData('GET', 'http://www.example.com');
        $request = new Request($this->connector, $requestData);

$this->rejectedConnectionMock();

$handler = $this->createCallableMock();
        $handler->expects($this->once())
            ->method('__invoke')
            ->with(
                $this->isInstanceOf('RuntimeException')
            );

$request->on('error', $handler);

$handler = $this->createCallableMock();
        $handler->expects($this->once())
            ->method('__invoke');

$request->on('close', $handler);
        $request->on('end', $this->expectCallableNever());

$request->end();
    }

/** @test */
    public function requestShouldEmitErrorIfConnectionClosesBeforeResponseIsParsed()
    {
        $requestData = new RequestData('GET', 'http://www.example.com');
        $request = new Request($this->connector, $requestData);

$this->successfulConnectionMock();

$request->on('error', $handler);

$handler = $this->createCallableMock();
        $handler->expects($this->once())
            ->method('__invoke');

$request->on('close', $handler);
        $request->on('end', $this->expectCallableNever());

$request->end();
        $request->handleEnd();
    }

/** @test */
    public function requestShouldEmitErrorIfConnectionEmitsError()
    {
        $requestData = new RequestData('GET', 'http://www.example.com');
        $request = new Request($this->connector, $requestData);

$this->successfulConnectionMock();

$handler = $this->createCallableMock();
        $handler->expects($this->once())
            ->method('__invoke')
            ->with(
                $this->isInstanceOf('Exception')
            );

$request->on('error', $handler);

$handler = $this->createCallableMock();
        $handler->expects($this->once())
            ->method('__invoke');

$request->on('close', $handler);
        $request->on('end', $this->expectCallableNever());

$request->end();
        $request->handleError(new \Exception('test'));
    }

/** @test */
    public function requestShouldEmitErrorIfGuzzleParseThrowsException()
    {
        $requestData = new RequestData('GET', 'http://www.example.com');
        $request = new Request($this->connector, $requestData);

$this->successfulConnectionMock();

$handler = $this->createCallableMock();
        $handler->expects($this->once())
            ->method('__invoke')
            ->with(
                $this->isInstanceOf('\InvalidArgumentException')
            );

$request->on('error', $handler);

$request->end();
        $request->handleData("\r\n\r\n");
    }

/**
     * @test
     */
    public function requestShouldEmitErrorIfUrlIsInvalid()
    {
        $requestData = new RequestData('GET', 'ftp://www.example.com');
        $request = new Request($this->connector, $requestData);

$request->on('error', $handler);

$this->connector->expects($this->never())
            ->method('connect');

$request->end();
    }

/**
     * @test
     */
    public function requestShouldEmitErrorIfUrlHasNoScheme()
    {
        $requestData = new RequestData('GET', 'www.example.com');
        $request = new Request($this->connector, $requestData);

$request->on('error', $handler);

$this->connector->expects($this->never())
            ->method('connect');

$request->end();
    }

/** @test */
    public function postRequestShouldSendAPostRequest()
    {
        $requestData = new RequestData('POST', 'http://www.example.com');
        $request = new Request($this->connector, $requestData);

$this->successfulConnectionMock();

$this->stream
            ->expects($this->once())
            ->method('write')
            ->with($this->matchesRegularExpression("#^POST / HTTP/1\.0\r\nHost: www.example.com\r\nUser-Agent:.*\r\n\r\nsome post data$#"));

$factory = $this->createCallableMock();
        $factory->expects($this->once())
            ->method('__invoke')
            ->will($this->returnValue($this->response));

$request->setResponseFactory($factory);
        $request->end('some post data');

$request->handleData("HTTP/1.0 200 OK\r\n");
        $request->handleData("Content-Type: text/plain\r\n");
        $request->handleData("\r\nbody");
    }

/** @test */
    public function writeWithAPostRequestShouldSendToTheStream()
    {
        $requestData = new RequestData('POST', 'http://www.example.com');
        $request = new Request($this->connector, $requestData);

$this->successfulConnectionMock();

$this->stream
            ->expects($this->at(5))
            ->method('write')
            ->with($this->matchesRegularExpression("#^POST / HTTP/1\.0\r\nHost: www.example.com\r\nUser-Agent:.*\r\n\r\nsome$#"));
        $this->stream
            ->expects($this->at(6))
            ->method('write')
            ->with($this->identicalTo("post"));
        $this->stream
            ->expects($this->at(7))
            ->method('write')
            ->with($this->identicalTo("data"));

$factory = $this->createCallableMock();
        $factory->expects($this->once())
            ->method('__invoke')
            ->will($this->returnValue($this->response));

$request->setResponseFactory($factory);

$request->write("some");
        $request->write("post");
        $request->end("data");

$request->handleData("HTTP/1.0 200 OK\r\n");
        $request->handleData("Content-Type: text/plain\r\n");
        $request->handleData("\r\nbody");
    }

/** @test */
    public function writeWithAPostRequestShouldSendBodyAfterHeadersAndEmitDrainEvent()
    {
        $requestData = new RequestData('POST', 'http://www.example.com');
        $request = new Request($this->connector, $requestData);

$resolveConnection = $this->successfulAsyncConnectionMock();

$this->stream
            ->expects($this->at(5))
            ->method('write')
            ->with($this->matchesRegularExpression("#^POST / HTTP/1\.0\r\nHost: www.example.com\r\nUser-Agent:.*\r\n\r\nsomepost$#"))
            ->willReturn(true);
        $this->stream
            ->expects($this->at(6))
            ->method('write')
            ->with($this->identicalTo("data"));

$factory = $this->createCallableMock();
        $factory->expects($this->once())
            ->method('__invoke')
            ->will($this->returnValue($this->response));

$request->setResponseFactory($factory);

$this->assertFalse($request->write("some"));
        $this->assertFalse($request->write("post"));

$request->on('drain', $this->expectCallableOnce());
        $request->once('drain', function () use ($request) {
            $request->write("data");
            $request->end();
        });

$resolveConnection();

$request->handleData("HTTP/1.0 200 OK\r\n");
        $request->handleData("Content-Type: text/plain\r\n");
        $request->handleData("\r\nbody");
    }

/** @test */
    public function writeWithAPostRequestShouldForwardDrainEventIfFirstChunkExceedsBuffer()
    {
        $requestData = new RequestData('POST', 'http://www.example.com');
        $request = new Request($this->connector, $requestData);

$this->stream = $this->getMockBuilder('React\Socket\Connection')
            ->disableOriginalConstructor()
            ->setMethods(array('write'))
            ->getMock();

$resolveConnection = $this->successfulAsyncConnectionMock();

$this->stream
            ->expects($this->at(0))
            ->method('write')
            ->with($this->matchesRegularExpression("#^POST / HTTP/1\.0\r\nHost: www.example.com\r\nUser-Agent:.*\r\n\r\nsomepost$#"))
            ->willReturn(false);
        $this->stream
            ->expects($this->at(1))
            ->method('write')
            ->with($this->identicalTo("data"));

$factory = $this->createCallableMock();
        $factory->expects($this->once())
            ->method('__invoke')
            ->will($this->returnValue($this->response));

$request->setResponseFactory($factory);

$this->assertFalse($request->write("some"));
        $this->assertFalse($request->write("post"));

$request->on('drain', $this->expectCallableOnce());
        $request->once('drain', function () use ($request) {
            $request->write("data");
            $request->end();
        });

$resolveConnection();
        $this->stream->emit('drain');

$request->handleData("HTTP/1.0 200 OK\r\n");
        $request->handleData("Content-Type: text/plain\r\n");
        $request->handleData("\r\nbody");
    }

/** @test */
    public function pipeShouldPipeDataIntoTheRequestBody()
    {
        $requestData = new RequestData('POST', 'http://www.example.com');
        $request = new Request($this->connector, $requestData);

$this->successfulConnectionMock();

$factory = $this->createCallableMock();
        $factory->expects($this->once())
            ->method('__invoke')
            ->will($this->returnValue($this->response));

$loop = $this
            ->getMockBuilder('React\EventLoop\LoopInterface')
            ->getMock();

$request->setResponseFactory($factory);

$stream = fopen('php://memory', 'r+');
        $stream = class_exists('React\Stream\DuplexResourceStream') ? new DuplexResourceStream($stream, $loop) : new Stream($stream, $loop);

$stream->pipe($request);
        $stream->emit('data', array('some'));
        $stream->emit('data', array('post'));
        $stream->emit('data', array('data'));

$request->handleData("HTTP/1.0 200 OK\r\n");
        $request->handleData("Content-Type: text/plain\r\n");
        $request->handleData("\r\nbody");
    }

/**
     * @test
     */
    public function writeShouldStartConnecting()
    {
        $requestData = new RequestData('POST', 'http://www.example.com');
        $request = new Request($this->connector, $requestData);

$this->connector->expects($this->once())
                        ->method('connect')
                        ->with('www.example.com:80')
                        ->willReturn(new Promise(function () { }));

$request->write('test');
    }

/**
     * @test
     */
    public function endShouldStartConnectingAndChangeStreamIntoNonWritableMode()
    {
        $requestData = new RequestData('POST', 'http://www.example.com');
        $request = new Request($this->connector, $requestData);

$request->end();

$this->assertFalse($request->isWritable());
    }

/**
     * @test
     */
    public function closeShouldEmitCloseEvent()
    {
        $requestData = new RequestData('POST', 'http://www.example.com');
        $request = new Request($this->connector, $requestData);

$request->on('close', $this->expectCallableOnce());
        $request->close();
    }

/**
     * @test
     */
    public function writeAfterCloseReturnsFalse()
    {
        $requestData = new RequestData('POST', 'http://www.example.com');
        $request = new Request($this->connector, $requestData);

$request->close();

$this->assertFalse($request->isWritable());
        $this->assertFalse($request->write('nope'));
    }

/**
     * @test
     */
    public function endAfterCloseIsNoOp()
    {
        $requestData = new RequestData('POST', 'http://www.example.com');
        $request = new Request($this->connector, $requestData);

$this->connector->expects($this->never())
                        ->method('connect');

$request->close();
        $request->end();
    }

/**
     * @test
     */
    public function closeShouldCancelPendingConnectionAttempt()
    {
        $requestData = new RequestData('POST', 'http://www.example.com');
        $request = new Request($this->connector, $requestData);

$promise = new Promise(function () {}, function () {
            throw new \RuntimeException();
        });

$this->connector->expects($this->once())
            ->method('connect')
            ->with('www.example.com:80')
            ->willReturn($promise);

$request->end();

$request->on('error', $this->expectCallableNever());
        $request->on('close', $this->expectCallableOnce());

$request->close();
        $request->close();
    }

/** @test */
    public function requestShouldRelayErrorEventsFromResponse()
    {
        $requestData = new RequestData('GET', 'http://www.example.com');
        $request = new Request($this->connector, $requestData);

$this->successfulConnectionMock();

$response = $this->response;

$response->expects($this->at(0))
            ->method('on')
            ->with('close', $this->anything());
        $response->expects($this->at(1))
            ->method('on')
            ->with('error', $this->anything())
            ->will($this->returnCallback(function ($event, $cb) use (&$errorCallback) {
                $errorCallback = $cb;
            }));

$request->setResponseFactory($factory);
        $request->end();

$request->handleData("HTTP/1.0 200 OK\r\n");
        $request->handleData("Content-Type: text/plain\r\n");
        $request->handleData("\r\nbody");

$this->assertNotNull($errorCallback);
        call_user_func($errorCallback, new \Exception('test'));
    }

/** @test */
    public function requestShouldRemoveAllListenerAfterClosed()
    {
        $requestData = new RequestData('GET', 'http://www.example.com');
        $request = new Request($this->connector, $requestData);

$request->on('close', function () {});
        $this->assertCount(1, $request->listeners('close'));

$request->close();
        $this->assertCount(0, $request->listeners('close'));
    }

private function successfulConnectionMock()
    {
        call_user_func($this->successfulAsyncConnectionMock());
    }

private function successfulAsyncConnectionMock()
    {
        $deferred = new Deferred();

$this->connector
            ->expects($this->once())
            ->method('connect')
            ->with('www.example.com:80')
            ->will($this->returnValue($deferred->promise()));

$stream = $this->stream;
        return function () use ($deferred, $stream) {
            $deferred->resolve($stream);
        };
    }

private function rejectedConnectionMock()
    {
        $this->connector
            ->expects($this->once())
            ->method('connect')
            ->with('www.example.com:80')
            ->will($this->returnValue(new RejectedPromise(new \RuntimeException())));
    }

/** @test */
    public function multivalueHeader()
    {
        $requestData = new RequestData('GET', 'http://www.example.com');
        $request = new Request($this->connector, $requestData);

$this->successfulConnectionMock();

$response = $this->response;

$response->expects($this->at(0))
        ->method('on')
        ->with('close', $this->anything());
        $response->expects($this->at(1))
        ->method('on')
        ->with('error', $this->anything())
        ->will($this->returnCallback(function ($event, $cb) use (&$errorCallback) {
            $errorCallback = $cb;
        }));

$factory = $this->createCallableMock();
        $factory->expects($this->once())
        ->method('__invoke')
        ->with('HTTP', '1.0', '200', 'OK', array('Content-Type' => 'text/plain', 'X-Xss-Protection' => '1; mode=block', 'Cache-Control' => 'public, must-revalidate, max-age=0'))
        ->will($this->returnValue($response));

$request->setResponseFactory($factory);
        $request->end();

$request->handleData("HTTP/1.0 200 OK\r\n");
        $request->handleData("Content-Type: text/plain\r\n");
        $request->handleData("X-Xss-Protection:1; mode=block\r\n");
        $request->handleData("Cache-Control:public, must-revalidate, max-age=0\r\n");
        $request->handleData("\r\nbody");

$this->assertNotNull($errorCallback);
        call_user_func($errorCallback, new \Exception('test'));
    }

/** @test */
    public function chunkedStreamDecoder()
    {
        $requestData = new RequestData('GET', 'http://www.example.com');
        $request = new Request($this->connector, $requestData);

$this->successfulConnectionMock();

$request->end();

$this->stream->expects($this->once())
            ->method('emit')
            ->with('data', array("1\r\nb\r"));

$request->handleData("HTTP/1.0 200 OK\r\n");
        $request->handleData("Transfer-Encoding: chunked\r\n");
        $request->handleData("\r\n1\r\nb\r");
        $request->handleData("\n3\t\nody\r\n0\t\n\r\n");

}
}