think\tests\Taylor

Complexity

Total Complexity

5

Size/Duplication

Total Lines	26
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	some()	0	2	1
A	__make()	0	3	1
A	protectionFun()	0	3	1
A	test()	0	3	1

<?php

Missing file doc comment

namespace think\tests;

use PHPUnit\Framework\TestCase;
use ReflectionMethod;
use stdClass;
use think\Container;
use think\exception\ClassNotFoundException;
use think\exception\FuncNotFoundException;

class Taylor
{
    public $name;

    public function __construct($name)

Missing doc comment for function __construct()

    {
        $this->name = $name;
    }

    public function some(Container $container)

The parameter $container is not used and could be removed.

Missing doc comment for function some()

    {
    }

    protected function protectionFun()

Missing doc comment for function protectionFun()

    {
        return true;
    }

    public static function test(Container $container)

Missing doc comment for function test()

    {
        return $container;
    }

    public static function __make()

Missing doc comment for function __make()

    {
        return new self('Taylor');
    }
}

class SomeClass
{
    public $container;

    public $count = 0;

    public function __construct(Container $container)

Missing doc comment for function __construct()

    {
        $this->container = $container;
    }
}

class ContainerTest extends TestCase
{
    protected function tearDown(): void

Missing doc comment for function tearDown()

    {
        Container::setInstance(null);
    }

    public function testClosureResolution()

Missing doc comment for function testClosureResolution()

    {
        $container = new Container;

        Container::setInstance($container);

        $container->bind('name', function () {

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

            return 'Taylor';
        });

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

        $this->assertEquals('Taylor', $container->make('name'));

        $this->assertEquals('Taylor', Container::pull('name'));
    }

    public function testGet()

Missing doc comment for function testGet()

    {
        $container = new Container;

        $this->expectException(ClassNotFoundException::class);
        $this->expectExceptionMessage('class not exists: name');
        $container->get('name');

        $container->bind('name', function () {

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

            return 'Taylor';
        });

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

        $this->assertSame('Taylor', $container->get('name'));
    }

    public function testExist()

Missing doc comment for function testExist()

    {
        $container = new Container;

        $container->bind('name', function () {

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

            return 'Taylor';
        });

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

        $this->assertFalse($container->exists("name"));

        $container->make('name');

        $this->assertTrue($container->exists('name'));
    }

    public function testInstance()

Missing doc comment for function testInstance()

    {
        $container = new Container;

        $container->bind('name', function () {

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

            return 'Taylor';
        });

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

        $this->assertEquals('Taylor', $container->get('name'));

        $container->bind('name2', Taylor::class);

        $object = new stdClass();

        $this->assertFalse($container->exists('name2'));

        $container->instance('name2', $object);

        $this->assertTrue($container->exists('name2'));

        $this->assertTrue($container->exists(Taylor::class));

        $this->assertEquals($object, $container->make(Taylor::class));

        unset($container->name1);

The property name1 does not exist on think\Container. Since you implemented __get, consider adding a @property annotation.

        $this->assertFalse($container->exists('name1'));

        $container->delete('name2');

        $this->assertFalse($container->exists('name2'));

        foreach ($container as $class => $instance) {

        }
    }

    public function testBind()

Missing doc comment for function testBind()

    {
        $container = new Container;

        $object = new stdClass();

        $container->bind(['name' => Taylor::class]);

        $container->bind('name2', $object);

        $container->bind('name3', Taylor::class);

        $container->name4 = $object;

The property name4 does not exist on think\Container. Since you implemented __set, consider adding a @property annotation.

        $container['name5'] = $object;

        $this->assertTrue(isset($container->name4));

The property name4 does not exist on think\Container. Since you implemented __get, consider adding a @property annotation.

        $this->assertTrue(isset($container['name5']));

        $this->assertInstanceOf(Taylor::class, $container->get('name'));

        $this->assertSame($object, $container->get('name2'));

        $this->assertSame($object, $container->name4);

        $this->assertSame($object, $container['name5']);

        $this->assertInstanceOf(Taylor::class, $container->get('name3'));

        unset($container['name']);

        $this->assertFalse(isset($container['name']));

        unset($container->name3);

The property name3 does not exist on think\Container. Since you implemented __get, consider adding a @property annotation.

        $this->assertFalse(isset($container->name3));
    }

    public function testAutoConcreteResolution()

Missing doc comment for function testAutoConcreteResolution()

    {
        $container = new Container;

        $taylor = $container->make(Taylor::class);

        $this->assertInstanceOf(Taylor::class, $taylor);
        $this->assertAttributeSame('Taylor', 'name', $taylor);

The function PHPUnit\Framework\Assert::assertAttributeSame() has been deprecated: https://github.com/sebastianbergmann/phpunit/issues/3338

    }

    public function testGetAndSetInstance()

Missing doc comment for function testGetAndSetInstance()

    {
        $this->assertInstanceOf(Container::class, Container::getInstance());

        $object = new stdClass();

        Container::setInstance($object);

        $this->assertSame($object, Container::getInstance());

        Container::setInstance(function () {

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

            return $this;
        });

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

        $this->assertSame($this, Container::getInstance());
    }

    public function testResolving()

Missing doc comment for function testResolving()

    {
        $container = new Container();
        $container->bind(Container::class, $container);

        $container->resolving(function (SomeClass $taylor, Container $container) {

The parameter $container is not used and could be removed.

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

            $taylor->count++;
        });

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

        $container->resolving(SomeClass::class, function (SomeClass $taylor, Container $container) {

The parameter $container is not used and could be removed.

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

            $taylor->count++;
        });

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

        /** @var SomeClass $someClass */

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

        $someClass = $container->invokeClass(SomeClass::class);
        $this->assertEquals(2, $someClass->count);
    }

    public function testInvokeFunctionWithoutMethodThrowsException()

Missing doc comment for function testInvokeFunctionWithoutMethodThrowsException()

    {
        $this->expectException(FuncNotFoundException::class);
        $this->expectExceptionMessage('function not exists: ContainerTestCallStub()');
        $container = new Container();
        $container->invokeFunction('ContainerTestCallStub', []);
    }

    public function testInvokeProtectionMethod()

Missing doc comment for function testInvokeProtectionMethod()

    {
        $container = new Container();
        $this->assertTrue($container->invokeMethod([Taylor::class, 'protectionFun'], [], true));
    }

    public function testInvoke()

Missing doc comment for function testInvoke()

    {
        $container = new Container();

        Container::setInstance($container);

        $container->bind(Container::class, $container);

        $stub = $this->createMock(Taylor::class);

        $stub->expects($this->once())->method('some')->with($container)->will($this->returnSelf());

        $container->invokeMethod([$stub, 'some']);

        $this->assertEquals('48', $container->invoke('ord', ['0']));

        $this->assertSame($container, $container->invoke(Taylor::class . '::test', []));

        $this->assertSame($container, $container->invokeMethod(Taylor::class . '::test'));

        $reflect = new ReflectionMethod($container, 'exists');

        $this->assertTrue($container->invokeReflectMethod($container, $reflect, [Container::class]));

        $this->assertSame($container, $container->invoke(function (Container $container) {

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

            return $container;
        }));

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

        $this->assertSame($container, $container->invoke(Taylor::class . '::test'));

        $object = $container->invokeClass(SomeClass::class);
        $this->assertInstanceOf(SomeClass::class, $object);
        $this->assertSame($container, $object->container);

        $stdClass = new stdClass();

        $container->invoke(function (Container $container, stdClass $stdObject, $key1, $lowKey, $key2 = 'default') use ($stdClass) {

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

            $this->assertEquals('value1', $key1);
            $this->assertEquals('default', $key2);
            $this->assertEquals('value2', $lowKey);
            $this->assertSame($stdClass, $stdObject);
            return $container;
        }, ['some' => $stdClass, 'key1' => 'value1', 'low_key' => 'value2']);

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

    }

    public function testInvokeMethodNotExists()

Missing doc comment for function testInvokeMethodNotExists()

    {
        $container = $this->resolveContainer();
        $this->expectException(FuncNotFoundException::class);

        $container->invokeMethod([SomeClass::class, 'any']);
    }

    public function testInvokeClassNotExists()

Missing doc comment for function testInvokeClassNotExists()

    {
        $container = new Container();

        Container::setInstance($container);

        $container->bind(Container::class, $container);

        $this->expectExceptionObject(new ClassNotFoundException('class not exists: SomeClass'));

        $container->invokeClass('SomeClass');
    }

    protected function resolveContainer()

Missing doc comment for function resolveContainer()

    {
        $container = new Container();

        Container::setInstance($container);
        return $container;
    }

}