HttpTest::prepareApp() - Code Metrics - Inspection of "Http单元测试" - top-think/framework - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — 6.0 ( 0b31ac...12bd4b )

by yun
created 2019-04-03 07:56 UTC
HttpTest::prepareApp() A

↳ Parent: HttpTest
Complexity

Conditions	2
Paths	1
Size

Total Lines	25
Code Lines	15
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	2
eloc	15
nc	1
nop	2
dl	0
loc	25
rs	9.7666
c	0
b	0
f	0
<?php


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

{
    /** @var App|MockInterface */

    protected $app;

    /** @var Http|MockInterface */

    protected $http;

    protected function tearDown(): void

    {
        m::close();
    }

    protected function setUp()

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

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

    protected function prepareApp($request, $response)

    {
        $this->app->shouldReceive('instance')->once()->with('request', $request);
                    shouldReceive('instance')->once()->with('request', $request);
        $this->app->shouldReceive('initialized')->once()->andReturnFalse();
        $this->app->shouldReceive('initialized')->once()->/** @scrutinizer ignore-call */ andReturnFalse();
        $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) {

            if ($withRoute) {
                $withRoute();
            }
            return $req === $request;
        })->andReturn($response);
someFunctionCall(
    $firstArgument,
    $secondArgument,
    $thirdArgument
); // Closing parenthesis 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()

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

            'app'   => [
                'controller'     => [],
                'middleware.php' => '<?php return [];',
            ],
            'route' => [
                'route.php' => '<?php return [];',
            ],
        ]);
someFunctionCall(
    $firstArgument,
    $secondArgument,
    $thirdArgument
); // Closing parenthesis 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));
        $this->assertEquals($response, $this->http->run(/** @scrutinizer ignore-type */ $request));

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

    /**

     * @param $request

     * @param $auto

     * @param $name

     * @dataProvider multiAppRunProvider
     */

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

            '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 [];',
            ],
        ]);
someFunctionCall(
    $firstArgument,
    $secondArgument,
    $thirdArgument
); // Closing parenthesis 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([

            'www.domain.com' => 'app1',
            'app2'           => 'app2',
        ]);
someFunctionCall(
    $firstArgument,
    $secondArgument,
    $thirdArgument
); // Closing parenthesis on a new line.

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

            'some1' => 'app3',
        ]);
someFunctionCall(
    $firstArgument,
    $secondArgument,
    $thirdArgument
); // Closing parenthesis 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();
                         shouldReceive('reportException')->once();

            $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());
            $this->assertEquals($name, $this->http->/** @scrutinizer ignore-call */ getName());
        }

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

    public 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()

    {
        $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));
        $this->assertEquals($response, $this->http->run(/** @scrutinizer ignore-type */ $request));
    }

    public 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);
        $this->http->end(/** @scrutinizer ignore-type */ $response);
    }

}

top-think / framework

Push — 6.0 ( 0b31ac...12bd4b )

HttpTest::prepareApp() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
