think\tests\HttpTest::testMultiAppRun()

Complexity

Conditions	8
Paths	64

Size

Total Lines	76
Code Lines	44

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	HttpTest::testRunWithException()	0	21	1
A	HttpTest::testEnd()	0	11	1

<?php

Missing file doc comment

namespace think\tests;

use Mockery as m;
use Mockery\MockInterface;
use org\bovigo\vfs\vfsStream;
use PHPUnit\Framework\TestCase;
use think\App;
use think\Console;
use think\Event;
use think\event\HttpEnd;
use think\Exception;
use think\exception\Handle;
use think\Http;
use think\Log;
use think\Request;
use think\Response;
use think\Route;

class HttpTest extends TestCase
{
    /** @var App|MockInterface */

The open comment tag must be the only content on the line

Missing short description in doc comment

The close comment tag must be the only content on the line

    protected $app;

    /** @var Http|MockInterface */

The open comment tag must be the only content on the line

Missing short description in doc comment

The close comment tag must be the only content on the line

    protected $http;

    protected function tearDown(): void

Missing doc comment for function tearDown()

    {
        m::close();
    }

    protected function setUp()

Missing doc comment for function setUp()

    {
        $this->app = m::mock(App::class)->makePartial();

        $this->http = m::mock(Http::class, [$this->app])->shouldAllowMockingProtectedMethods()->makePartial();
    }

    protected function prepareApp($request, $response)

Missing doc comment for function prepareApp()

    {
        $this->app->shouldReceive('instance')->once()->with('request', $request);

The method shouldReceive() does not exist on think\App.

        $this->app->shouldReceive('initialized')->once()->andReturnFalse();

The method andReturnFalse() does not exist on Mockery\ExpectationInterface. Did you maybe mean andReturn()?

        $this->app->shouldReceive('initialize')->once();
        $this->app->shouldReceive('get')->with('request')->andReturn($request);

        $route = m::mock(Route::class);

        $route->shouldReceive('dispatch')->withArgs(function ($req, $withRoute) use ($request) {

The opening parenthesis of a multi-line function call should be the last content on the line.

            if ($withRoute) {
                $withRoute();
            }
            return $req === $request;
        })->andReturn($response);

For multi-line function calls, the closing parenthesis should be on a new line.

        $route->shouldReceive('config')->with('route_annotation')->andReturn(true);

        $this->app->shouldReceive('get')->with('route')->andReturn($route);

        $console = m::mock(Console::class);

        $console->shouldReceive('call');

        $this->app->shouldReceive('get')->with('console')->andReturn($console);
    }

    public function testRun()

Missing doc comment for function testRun()

    {
        $root = vfsStream::setup('rootDir', null, [

The opening parenthesis of a multi-line function call should be the last content on the line.

            'app'   => [
                'controller'     => [],
                'middleware.php' => '<?php return [];',
            ],
            'route' => [
                'route.php' => '<?php return [];',
            ],
        ]);

For multi-line function calls, the closing parenthesis should be on a new line.

        $this->http->multi(false);

The method multi() does not exist on think\Http.

        $this->app->shouldReceive('getBasePath')->andReturn($root->getChild('app')->url() . DIRECTORY_SEPARATOR);
        $this->app->shouldReceive('getRootPath')->andReturn($root->url() . DIRECTORY_SEPARATOR);

        $request  = m::mock(Request::class)->makePartial();
        $response = m::mock(Response::class)->makePartial();

        $this->prepareApp($request, $response);

        $this->assertEquals($response, $this->http->run($request));

$request of type Mockery\Mock is incompatible with the type null|think\Request expected by parameter $request of think\Http::run().

    }

    public function multiAppRunProvider()

Missing doc comment for function multiAppRunProvider()

    {
        $request1 = m::mock(Request::class)->makePartial();
        $request1->shouldReceive('subDomain')->andReturn('www');
        $request1->shouldReceive('host')->andReturn('www.domain.com');

        $request2 = m::mock(Request::class)->makePartial();
        $request2->shouldReceive('subDomain')->andReturn('app2');
        $request2->shouldReceive('host')->andReturn('app2.domain.com');

        $request3 = m::mock(Request::class)->makePartial();
        $request3->shouldReceive('pathinfo')->andReturn('some1/a/b/c');

        $request4 = m::mock(Request::class)->makePartial();
        $request4->shouldReceive('pathinfo')->andReturn('app3/a/b/c');

        $request5 = m::mock(Request::class)->makePartial();
        $request5->shouldReceive('pathinfo')->andReturn('some2/a/b/c');

        return [
            [$request1, true, 'app1'],
            [$request2, true, 'app2'],
            [$request3, true, 'app3'],
            [$request4, true, null],
            [$request5, true, 'some2', 'path'],
            [$request1, false, 'some3'],
        ];
    }

    public function testRunWithException()

Missing doc comment for function testRunWithException()

    {
        $request  = m::mock(Request::class);
        $response = m::mock(Response::class);

        $this->app->shouldReceive('instance')->once()->with('request', $request);

        $exception = new Exception();

        $this->http->shouldReceive('runWithRequest')->once()->with($request)->andThrow($exception);

The method shouldReceive() does not exist on think\Http.

        $handle = m::mock(Handle::class);

        $handle->shouldReceive('report')->once()->with($exception);
        $handle->shouldReceive('render')->once()->with($request, $exception)->andReturn($response);

        $this->app->shouldReceive('make')->with(Handle::class)->andReturn($handle);

        $response->shouldReceive('setCookie')->andReturn($response);

        $this->assertEquals($response, $this->http->run($request));

$request of type Mockery\LegacyMockInterface|Mockery\MockInterface is incompatible with the type null|think\Request expected by parameter $request of think\Http::run().

    }

    public function testEnd()

Missing doc comment for function testEnd()

    {
        $response = m::mock(Response::class);
        $event    = m::mock(Event::class);
        $event->shouldReceive('trigger')->once()->with(HttpEnd::class, $response);
        $this->app->shouldReceive('get')->once()->with('event')->andReturn($event);
        $log = m::mock(Log::class);
        $log->shouldReceive('save')->once();
        $this->app->shouldReceive('get')->once()->with('log')->andReturn($log);

        $this->http->end($response);

$response of type Mockery\LegacyMockInterface|Mockery\MockInterface is incompatible with the type think\Response expected by parameter $response of think\Http::end().

    }

}