think\tests\HttpTest

Complexity

Total Complexity

16

Size/Duplication

Total Lines	225
Duplicated Lines	0 %

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	prepareApp()	0	25	2
A	testRunWithException()	0	21	1
A	tearDown()	0	3	1
A	testRun()	0	25	1
A	testEnd()	0	14	1
A	multiAppRunProvider()	0	26	1
A	setUp()	0	5	1
B	testMultiAppRun()	0	76	8

<?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\Config;
use think\Console;
use think\Event;
use think\Exception;
use think\exception\Handle;
use think\Http;
use think\Log;
use think\Request;
use think\Response;
use think\Route;
use think\Session;

class HttpTest extends TestCase

Missing doc comment for class HttpTest

{
    /** @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);

        $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().

        $this->assertFalse($this->http->isMulti());
    }

    /**

Missing short description in doc comment

Parameter $request should have a doc-comment as per coding-style.

Parameter $auto should have a doc-comment as per coding-style.

Parameter $name should have a doc-comment as per coding-style.

Parameter $path should have a doc-comment as per coding-style.

     * @param $request

Missing parameter name

Tag value for @param tag indented incorrectly; expected 8 spaces but found 1

     * @param $auto

Missing parameter name

Tag value for @param tag indented incorrectly; expected 8 spaces but found 1

     * @param $name

Missing parameter name

Tag value for @param tag indented incorrectly; expected 8 spaces but found 1

     * @dataProvider multiAppRunProvider
     */

Missing @return tag in function comment

    public function testMultiAppRun($request, $auto, $name, $path = null)
    {
        $root = vfsStream::setup('rootDir', null, [

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

            'app'    => [
                'middleware.php' => '<?php return [];',
                'app1'           => [
                    'common.php'     => '',
                    'event.php'      => '<?php return ["bind"=>[],"listen"=>[],"subscribe"=>[]];',
                    'provider.php'   => '<?php return [];',
                    'middleware.php' => '<?php return [];',
                    'config'         => [
                        'app.php' => '<?php return [];',
                    ],
                ],
            ],
            'config' => [
                'app.php' => '<?php return [];',
                'app1'    => [
                    'app.php' => '<?php return [];',
                ],
            ],
            'route'  => [
                'route.php' => '<?php return [];',
            ],
        ]);

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

        $config = m::mock(Config::class)->makePartial();

        $config->shouldReceive('get')->with('app.auto_multi_app', false)->andReturn($auto);

        $config->shouldReceive('get')->with('app.domain_bind', [])->andReturn([

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

            'www.domain.com' => 'app1',
            'app2'           => 'app2',
        ]);

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

        $config->shouldReceive('get')->with('app.app_map', [])->andReturn([

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

            'some1' => 'app3',
        ]);

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

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

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

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

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

        $this->assertTrue($this->http->isMulti());

        if ($name === null) {
            $this->http->shouldReceive('reportException')->once();

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

            $this->http->shouldReceive('renderException')->once()->andReturn($response);
        }

        if (!$auto) {
            $this->http->name($name);
        }

        if ($path) {
            $this->http->path($path);
        }

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

        if ($name !== null) {
            $this->assertEquals($name, $this->http->getName());

The method getName() does not exist on Mockery\MockInterface. Did you maybe mean mockery_getName()?

        }

        if ($name === 'app1' || $name === 'app2') {
            $this->assertTrue($this->http->isBindDomain());
        }
        if ($path) {
            $this->assertEquals($path, $this->app->getAppPath());
        }
    }

    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);

        $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\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', $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);
        $session = m::mock(Session::class);
        $session->shouldReceive('save')->once();
        $this->app->shouldReceive('get')->once()->with('session')->andReturn($session);

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

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

    }

}