FooClass::bar() - Code Metrics - Inspection of "完善路由单元测试" - top-think/framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Branch — 6.0 (d30585)

by yun
created 2020-04-23 16:29 UTC
FooClass::bar() A

↳ Parent: FooClass
Complexity

Conditions	1
Paths	1
Size

Total Lines	2
Code Lines	0
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	1
eloc	0
nc	1
nop	0
dl	0
loc	2
rs	10
c	1
b	0
f	0
<?php


namespace think\tests;

use Closure;
use Mockery as m;
use Mockery\MockInterface;
use PHPUnit\Framework\TestCase;
use think\helper\Str;
use think\Request;
use think\Route;

class RouteTest extends TestCase
{
    use InteractsWithApp;

    /** @var Route|MockInterface */

    protected $route;

    protected function tearDown(): void

    {
        m::close();
    }

    protected function setUp()

    {
        $this->prepareApp();
        $this->route = new Route($this->app);
        $this->route = new Route(/** @scrutinizer ignore-type */ $this->app);
    }

    /**

     * @param $path

     * @param string $method

     * @param string $host

     * @return m\Mock|Request
     */
    protected function makeRequest($path, $method = 'GET', $host = 'localhost')
    {
        $request = m::mock(Request::class)->makePartial();
        $request->shouldReceive('host')->andReturn($host);
        $request->shouldReceive('pathinfo')->andReturn($path);
        $request->shouldReceive('url')->andReturn('/' . $path);
        $request->shouldReceive('subDomain')->andReturn('');
        $request->shouldReceive('panDomain')->andReturn('');
        $request->shouldReceive('method')->andReturn(strtoupper($method));
        return $request;
    }

    public function testSimpleRequest()

    {
        $this->route->get('foo', function () {

            return 'get-foo';
        });
someFunctionCall(
    $firstArgument,
    $secondArgument,
    $thirdArgument
); // Closing parenthesis on a new line.

        $this->route->put('foo', function () {

            return 'put-foo';
        });
someFunctionCall(
    $firstArgument,
    $secondArgument,
    $thirdArgument
); // Closing parenthesis on a new line.

        $this->route->group(function () {

            $this->route->post('foo', function () {

                return 'post-foo';
            });
someFunctionCall(
    $firstArgument,
    $secondArgument,
    $thirdArgument
); // Closing parenthesis on a new line.
        });
someFunctionCall(
    $firstArgument,
    $secondArgument,
    $thirdArgument
); // Closing parenthesis on a new line.

        $request  = $this->makeRequest('foo', 'post');
        $response = $this->route->dispatch($request);
        $response = $this->route->dispatch(/** @scrutinizer ignore-type */ $request);
        $this->assertEquals(200, $response->getCode());
        $this->assertEquals('post-foo', $response->getContent());

        $request  = $this->makeRequest('foo', 'get');
        $response = $this->route->dispatch($request);
        $this->assertEquals(200, $response->getCode());
        $this->assertEquals('get-foo', $response->getContent());
    }

    public function testOptionsRequest()

    {
        $this->route->get('foo', function () {

            return 'get-foo';
        });
someFunctionCall(
    $firstArgument,
    $secondArgument,
    $thirdArgument
); // Closing parenthesis on a new line.

        $this->route->put('foo', function () {

            return 'put-foo';
        });
someFunctionCall(
    $firstArgument,
    $secondArgument,
    $thirdArgument
); // Closing parenthesis on a new line.

        $this->route->group(function () {

            $this->route->post('foo', function () {

                return 'post-foo';
            });
someFunctionCall(
    $firstArgument,
    $secondArgument,
    $thirdArgument
); // Closing parenthesis on a new line.
        });
someFunctionCall(
    $firstArgument,
    $secondArgument,
    $thirdArgument
); // Closing parenthesis on a new line.

        $this->route->resource('bar', 'SomeClass');

        $request  = $this->makeRequest('foo', 'options');
        $response = $this->route->dispatch($request);
        $response = $this->route->dispatch(/** @scrutinizer ignore-type */ $request);
        $this->assertEquals(204, $response->getCode());
        $this->assertEquals('GET, PUT, POST', $response->getHeader('Allow'));

        $request  = $this->makeRequest('bar', 'options');
        $response = $this->route->dispatch($request);
        $this->assertEquals(204, $response->getCode());
        $this->assertEquals('GET, POST', $response->getHeader('Allow'));

        $request  = $this->makeRequest('bar/1', 'options');
        $response = $this->route->dispatch($request);
        $this->assertEquals(204, $response->getCode());
        $this->assertEquals('GET, PUT, DELETE', $response->getHeader('Allow'));
    }

    public function testAllowCrossDomain()

    {
        $this->route->get('foo', function () {

            return 'get-foo';
        })->allowCrossDomain(['some' => 'bar']);
someFunctionCall(
    $firstArgument,
    $secondArgument,
    $thirdArgument
); // Closing parenthesis on a new line.

        $request  = $this->makeRequest('foo', 'get');
        $response = $this->route->dispatch($request);
        $response = $this->route->dispatch(/** @scrutinizer ignore-type */ $request);

        $this->assertEquals('bar', $response->getHeader('some'));
        $this->assertArrayHasKey('Access-Control-Allow-Credentials', $response->getHeader());

        $request  = $this->makeRequest('foo', 'options');
        $response = $this->route->dispatch($request);

        $this->assertEquals(204, $response->getCode());
        $this->assertArrayHasKey('Access-Control-Allow-Credentials', $response->getHeader());
        $this->assertEquals('GET', $response->getHeader('Allow'));
    }

    public function testControllerDispatch()

    {
        $this->route->get('foo', 'foo/bar');

        $controller = m::Mock(\stdClass::class);

        $this->app->shouldReceive('parseClass')->with('controller', 'Foo')->andReturn($controller->mockery_getName());
                    shouldReceive('parseClass')->with('controller', 'Foo')->andReturn($controller->mockery_getName());
        $this->app->shouldReceive('make')->with($controller->mockery_getName(), [], true)->andReturn($controller);

        $controller->shouldReceive('bar')->andReturn('bar');

        $request  = $this->makeRequest('foo');
        $response = $this->route->dispatch($request);
        $response = $this->route->dispatch(/** @scrutinizer ignore-type */ $request);
        $this->assertEquals('bar', $response->getContent());
    }

    public function testEmptyControllerDispatch()

    {
        $this->route->get('foo', 'foo/bar');

        $controller = m::Mock(\stdClass::class);

        $this->app->shouldReceive('parseClass')->with('controller', 'Error')->andReturn($controller->mockery_getName());
        $this->app->shouldReceive('make')->with($controller->mockery_getName(), [], true)->andReturn($controller);

        $controller->shouldReceive('bar')->andReturn('bar');

        $request  = $this->makeRequest('foo');
        $response = $this->route->dispatch($request);
        $response = $this->route->dispatch(/** @scrutinizer ignore-type */ $request);
        $this->assertEquals('bar', $response->getContent());
    }

    protected function createMiddleware($times = 1)

    {
        $middleware = m::mock(Str::random(5));
        $middleware->shouldReceive('handle')->times($times)->andReturnUsing(function ($request, Closure $next) {
        $middleware->shouldReceive('handle')->times($times)->/** @scrutinizer ignore-call */ andReturnUsing(function ($request, Closure $next) {
            return $next($request);
        });
someFunctionCall(
    $firstArgument,
    $secondArgument,
    $thirdArgument
); // Closing parenthesis on a new line.
        $this->app->shouldReceive('make')->with($middleware->mockery_getName())->andReturn($middleware);

        return $middleware;
    }

    public function testControllerWithMiddleware()

    {
        $this->route->get('foo', 'foo/bar');

        $controller = m::mock(FooClass::class);

        $controller->middleware = [

            $this->createMiddleware()->mockery_getName() . ":params1:params2",
            $this->createMiddleware(0)->mockery_getName() => ['except' => 'bar'],
            $this->createMiddleware()->mockery_getName()  => ['only' => 'bar'],
        ];

        $this->app->shouldReceive('parseClass')->with('controller', 'Foo')->andReturn($controller->mockery_getName());
        $this->app->shouldReceive('make')->with($controller->mockery_getName(), [], true)->andReturn($controller);

        $controller->shouldReceive('bar')->once()->andReturn('bar');

        $request  = $this->makeRequest('foo');
        $response = $this->route->dispatch($request);
        $response = $this->route->dispatch(/** @scrutinizer ignore-type */ $request);
        $this->assertEquals('bar', $response->getContent());
    }
}

class FooClass
{
    public $middleware = [];

    public function bar()

    {

    }
}

top-think / framework

Branch — 6.0 (d30585)

FooClass::bar() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
