think\tests\ContainerTest

Complexity

Total Complexity

14

Size/Duplication

Total Lines	239
Duplicated Lines	0 %

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	testInvokeFunctionWithoutMethodThrowsException()	0	6	1
A	testInvokeClassNotExists()	0	11	1
A	testGet()	0	13	1
A	tearDown()	0	3	1
A	testClosureResolution()	0	13	1
A	testExist()	0	13	1
A	resolveContainer()	0	6	1
A	testGetAndSetInstance()	0	15	1
A	testInvoke()	0	39	1
A	testInstance()	0	41	2
A	testInvokeMethodNotExists()	0	6	1
A	testAutoConcreteResolution()	0	8	1
A	testBind()	0	37	1

<?php

Missing file doc comment

namespace think\tests;

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

class Taylor

Missing doc comment for 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()

    {

    }

    public static function static(Container $container)

Missing doc comment for function static()

    {
        return $container;
    }

    public static function __make()

Missing doc comment for function __make()

Method name "Taylor::__make" is invalid; only PHP magic methods should be prefixed with a double underscore

Public method name "Taylor::__make" must not be prefixed with an underscore

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

class SomeClass

Missing doc comment for class SomeClass

{
    public $container;

    public function __construct(Container $container)

Missing doc comment for function __construct()

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

class ContainerTest extends TestCase

Missing doc comment for class ContainerTest

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

        $this->assertContains($object, $container->all());

        $this->assertEquals(count($container->all()), count($container));

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

        $container->flush();

        $this->assertEmpty($container->all());

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

Missing doc comment for function testInvokeFunctionWithoutMethodThrowsException()

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

    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->assertSame($container, $container->invokeMethod(Taylor::class . '::static'));

        $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 . '::static'));

        $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(Exception::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;
    }

}