Deployer\Component\Pimple\PimpleTest

Complexity

Total Complexity

44

Size/Duplication

Total Lines	548
Duplicated Lines	0 %

Importance

Changes

0

43 Methods

Rating	Name	Duplication	Size	Complexity
A	testLegacyExtendFailsForKeysNotContainingServiceDefinitions()	0	8	1
A	testIsset()	0	14	1
A	badServiceDefinitionProvider()	0	5	1
A	testExtendFailsForInvalidServiceDefinitions()	0	6	1
A	settingNonInvokableObjectShouldTreatItAsParameter()	0	6	1
A	settingAnInvokableObjectShouldTreatItAsFactory()	0	6	1
A	testExtend()	0	25	1
A	testExtendValidatesKeyIsPresent()	0	7	1
A	testExtendingProtectedClosureDeprecation()	0	12	1
A	testLegacyProtectFailsForInvalidServiceDefinitions()	0	5	1
A	testUnset()	0	11	1
A	testWithString()	0	6	1
A	testLegacyOffsetGetValidatesKeyIsPresent()	0	7	1
A	testRawHonorsNullValues()	0	5	1
A	serviceDefinitionProvider()	0	10	1
A	testExtendingServiceAfterOtherServiceFreeze()	0	15	1
A	testLegacyExtendValidatesKeyIsPresent()	0	7	1
A	testConstructorInjection()	0	6	1
A	testExtendDoesNotLeakWithFactories()	0	22	2
A	testShouldPassContainerAsParameter()	0	12	1
A	testShare()	0	12	1
A	testLegacyExtendFailsForInvalidServiceDefinitions()	0	6	1
A	testWithClosure()	0	8	1
A	testRaw()	0	7	1
A	testGlobalFunctionNameAsParameterValue()	0	5	1
A	testServicesShouldBeDifferent()	0	14	1
A	testExtendFailsForKeysNotContainingServiceDefinitions()	0	8	1
A	testFactoryFailsForInvalidServiceDefinitions()	0	5	1
A	testRawValidatesKeyIsPresent()	0	7	1
A	testLegacyOverridingServiceAfterFreeze()	0	13	1
A	testOffsetGetHonorsNullValues()	0	5	1
A	testOffsetGetValidatesKeyIsPresent()	0	7	1
A	testOverridingServiceAfterFreeze()	0	13	1
A	testLegacyFactoryFailsForInvalidServiceDefinitions()	0	5	1
A	testProtect()	0	6	1
A	testLegacyRawValidatesKeyIsPresent()	0	7	1
A	testKeys()	0	7	1
A	testExtendFailsIfFrozenServiceIsInvokable()	0	12	1
A	testRemovingServiceAfterFreeze()	0	13	1
A	testDefiningNewServiceAfterFreeze()	0	12	1
A	testProtectFailsForInvalidServiceDefinitions()	0	5	1
A	testExtendingService()	0	13	1
A	testExtendFailsIfFrozenServiceIsNonInvokable()	0	12	1

<?php

declare(strict_types=1);
/* (c) Anton Medvedev <anton@medv.io>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Deployer\Component\Pimple;

use Deployer\Component\Pimple\Exception\FrozenServiceException;
use Deployer\Component\Pimple\Exception\InvalidServiceIdentifierException;
use Deployer\Component\Pimple\Exception\UnknownIdentifierException;
use InvalidArgumentException;
use PHPUnit\Framework\TestCase;
use ReflectionProperty;
use RuntimeException;

use function extension_loaded;

class PimpleTest extends TestCase
{
    public function testWithString()
    {
        $pimple = new Container();
        $pimple['param'] = 'value';

        $this->assertEquals('value', $pimple['param']);
    }

    public function testWithClosure()
    {
        $pimple = new Container();
        $pimple['service'] = function () {
            return new Service();
        };

        $this->assertInstanceOf(Service::class, $pimple['service']);
    }

    public function testServicesShouldBeDifferent()
    {
        $pimple = new Container();
        $pimple['service'] = $pimple->factory(function () {
            return new Service();
        });

        $serviceOne = $pimple['service'];
        $this->assertInstanceOf(Service::class, $serviceOne);

        $serviceTwo = $pimple['service'];
        $this->assertInstanceOf(Service::class, $serviceTwo);

        $this->assertNotSame($serviceOne, $serviceTwo);
    }

    public function testShouldPassContainerAsParameter()
    {
        $pimple = new Container();
        $pimple['service'] = function () {
            return new Service();
        };
        $pimple['container'] = function ($container) {
            return $container;
        };

        $this->assertNotSame($pimple, $pimple['service']);
        $this->assertSame($pimple, $pimple['container']);
    }

    public function testIsset()
    {
        $pimple = new Container();
        $pimple['param'] = 'value';
        $pimple['service'] = function () {
            return new Service();
        };

        $pimple['null'] = null;

        $this->assertTrue(isset($pimple['param']));
        $this->assertTrue(isset($pimple['service']));
        $this->assertTrue(isset($pimple['null']));
        $this->assertFalse(isset($pimple['non_existent']));
    }

    public function testConstructorInjection()
    {
        $params = ['param' => 'value'];
        $pimple = new Container($params);

        $this->assertSame($params['param'], $pimple['param']);
    }

    public function testOffsetGetValidatesKeyIsPresent()
    {
        $this->expectException(UnknownIdentifierException::class);
        $this->expectExceptionMessage('Identifier "foo" is not defined.');

        $pimple = new Container();
        echo $pimple['foo'];
    }

    /**
     * @group legacy
     */
    public function testLegacyOffsetGetValidatesKeyIsPresent()
    {
        $this->expectException(InvalidArgumentException::class);
        $this->expectExceptionMessage('Identifier "foo" is not defined.');

        $pimple = new Container();
        echo $pimple['foo'];
    }

    public function testOffsetGetHonorsNullValues()
    {
        $pimple = new Container();
        $pimple['foo'] = null;
        $this->assertNull($pimple['foo']);
    }

    public function testUnset()
    {
        $pimple = new Container();
        $pimple['param'] = 'value';
        $pimple['service'] = function () {
            return new Service();
        };

        unset($pimple['param'], $pimple['service']);
        $this->assertFalse(isset($pimple['param']));
        $this->assertFalse(isset($pimple['service']));
    }

    /**
     * @dataProvider serviceDefinitionProvider
     */
    public function testShare($service)
    {
        $pimple = new Container();
        $pimple['shared_service'] = $service;

        $serviceOne = $pimple['shared_service'];
        $this->assertInstanceOf(Service::class, $serviceOne);

        $serviceTwo = $pimple['shared_service'];
        $this->assertInstanceOf(Service::class, $serviceTwo);

        $this->assertSame($serviceOne, $serviceTwo);
    }

    /**
     * @dataProvider serviceDefinitionProvider
     */
    public function testProtect($service)
    {
        $pimple = new Container();
        $pimple['protected'] = $pimple->protect($service);

        $this->assertSame($service, $pimple['protected']);
    }

    public function testGlobalFunctionNameAsParameterValue()
    {
        $pimple = new Container();
        $pimple['global_function'] = 'strlen';
        $this->assertSame('strlen', $pimple['global_function']);
    }

    public function testRaw()
    {
        $pimple = new Container();
        $pimple['service'] = $definition = $pimple->factory(function () {
            return 'foo';
        });
        $this->assertSame($definition, $pimple->raw('service'));
    }

    public function testRawHonorsNullValues()
    {
        $pimple = new Container();
        $pimple['foo'] = null;
        $this->assertNull($pimple->raw('foo'));
    }

    public function testRawValidatesKeyIsPresent()
    {
        $this->expectException(UnknownIdentifierException::class);
        $this->expectExceptionMessage('Identifier "foo" is not defined.');

        $pimple = new Container();
        $pimple->raw('foo');
    }

    /**
     * @group legacy
     */
    public function testLegacyRawValidatesKeyIsPresent()
    {
        $this->expectException(InvalidArgumentException::class);
        $this->expectExceptionMessage('Identifier "foo" is not defined.');

        $pimple = new Container();
        $pimple->raw('foo');
    }

    /**
     * @dataProvider serviceDefinitionProvider
     */
    public function testExtend($service)
    {
        $pimple = new Container();
        $pimple['shared_service'] = function () {
            return new Service();
        };
        $pimple['factory_service'] = $pimple->factory(function () {
            return new Service();
        });

        $pimple->extend('shared_service', $service);
        $serviceOne = $pimple['shared_service'];
        $this->assertInstanceOf(Service::class, $serviceOne);
        $serviceTwo = $pimple['shared_service'];
        $this->assertInstanceOf(Service::class, $serviceTwo);
        $this->assertSame($serviceOne, $serviceTwo);
        $this->assertSame($serviceOne->value, $serviceTwo->value);

        $pimple->extend('factory_service', $service);

$service of type object is incompatible with the type callable expected by parameter $callable of Deployer\Component\Pimple\Container::extend().

        $serviceOne = $pimple['factory_service'];
        $this->assertInstanceOf(Service::class, $serviceOne);
        $serviceTwo = $pimple['factory_service'];
        $this->assertInstanceOf(Service::class, $serviceTwo);
        $this->assertNotSame($serviceOne, $serviceTwo);
        $this->assertNotSame($serviceOne->value, $serviceTwo->value);
    }

    public function testExtendDoesNotLeakWithFactories()
    {
        if (extension_loaded('pimple')) {
            $this->markTestSkipped('Pimple extension does not support this test');
        }
        $pimple = new Container();

        $pimple['foo'] = $pimple->factory(function () {
            return;
        });
        $pimple['foo'] = $pimple->extend('foo', function ($foo, $pimple) {

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

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

            return;
        });
        unset($pimple['foo']);

        $p = new ReflectionProperty($pimple, 'values');
        $p->setAccessible(true);
        $this->assertEmpty($p->getValue($pimple));

        $p = new ReflectionProperty($pimple, 'factories');
        $p->setAccessible(true);
        $this->assertCount(0, $p->getValue($pimple));
    }

    public function testExtendValidatesKeyIsPresent()
    {
        $this->expectException(UnknownIdentifierException::class);
        $this->expectExceptionMessage('Identifier "foo" is not defined.');

        $pimple = new Container();
        $pimple->extend('foo', function () {});
    }

    /**
     * @group legacy
     */
    public function testLegacyExtendValidatesKeyIsPresent()
    {
        $this->expectException(InvalidArgumentException::class);
        $this->expectExceptionMessage('Identifier "foo" is not defined.');

        $pimple = new Container();
        $pimple->extend('foo', function () {});
    }

    public function testKeys()
    {
        $pimple = new Container();
        $pimple['foo'] = 123;
        $pimple['bar'] = 123;

        $this->assertEquals(['foo', 'bar'], $pimple->keys());
    }

    /** @test */
    public function settingAnInvokableObjectShouldTreatItAsFactory()
    {
        $pimple = new Container();
        $pimple['invokable'] = new Invokable();

        $this->assertInstanceOf(Service::class, $pimple['invokable']);
    }

    /** @test */
    public function settingNonInvokableObjectShouldTreatItAsParameter()
    {
        $pimple = new Container();
        $pimple['non_invokable'] = new NonInvokable();

        $this->assertInstanceOf(NonInvokable::class, $pimple['non_invokable']);
    }

    /**
     * @dataProvider badServiceDefinitionProvider
     */
    public function testFactoryFailsForInvalidServiceDefinitions($service)
    {
        $this->expectException(\TypeError::class);
        $pimple = new Container();
        $pimple->factory($service);
    }

    /**
     * @group legacy
     * @dataProvider badServiceDefinitionProvider
     */
    public function testLegacyFactoryFailsForInvalidServiceDefinitions($service)
    {
        $this->expectException(\TypeError::class);
        $pimple = new Container();
        $pimple->factory($service);
    }

    /**
     * @dataProvider badServiceDefinitionProvider
     */
    public function testProtectFailsForInvalidServiceDefinitions($service)
    {
        $this->expectException(\TypeError::class);
        $pimple = new Container();
        $pimple->protect($service);
    }

    /**
     * @group legacy
     * @dataProvider badServiceDefinitionProvider
     */
    public function testLegacyProtectFailsForInvalidServiceDefinitions($service)
    {
        $this->expectException(\TypeError::class);
        $pimple = new Container();
        $pimple->protect($service);
    }

    /**
     * @dataProvider badServiceDefinitionProvider
     */
    public function testExtendFailsForKeysNotContainingServiceDefinitions($service)
    {
        $this->expectException(InvalidServiceIdentifierException::class);
        $this->expectExceptionMessage('Identifier "foo" does not contain an object definition.');

        $pimple = new Container();
        $pimple['foo'] = $service;
        $pimple->extend('foo', function () {});
    }

    /**
     * @group legacy
     * @dataProvider badServiceDefinitionProvider
     */
    public function testLegacyExtendFailsForKeysNotContainingServiceDefinitions($service)
    {
        $this->expectException(InvalidArgumentException::class);
        $this->expectExceptionMessage('Identifier "foo" does not contain an object definition.');

        $pimple = new Container();
        $pimple['foo'] = $service;
        $pimple->extend('foo', function () {});
    }

    /**
     * @group legacy
     * @expectedDeprecation How Pimple behaves when extending protected closures will be fixed in Pimple 4. Are you sure "foo" should be protected?
     */
    public function testExtendingProtectedClosureDeprecation()
    {
        $pimple = new Container();
        $pimple['foo'] = $pimple->protect(function () {
            return 'bar';
        });

        $pimple->extend('foo', function ($value) {
            return $value . '-baz';
        });

        $this->assertSame('bar-baz', $pimple['foo']);
    }

    /**
     * @dataProvider badServiceDefinitionProvider
     */
    public function testExtendFailsForInvalidServiceDefinitions($service)
    {
        $this->expectException(\TypeError::class);
        $pimple = new Container();
        $pimple['foo'] = function () {};
        $pimple->extend('foo', $service);
    }

    /**
     * @group legacy
     * @dataProvider badServiceDefinitionProvider
     */
    public function testLegacyExtendFailsForInvalidServiceDefinitions($service)
    {
        $this->expectException(\TypeError::class);
        $pimple = new Container();
        $pimple['foo'] = function () {};
        $pimple->extend('foo', $service);
    }

    public function testExtendFailsIfFrozenServiceIsNonInvokable()
    {
        $this->expectException(FrozenServiceException::class);
        $this->expectExceptionMessage('Cannot override frozen service "foo".');

        $pimple = new Container();
        $pimple['foo'] = function () {
            return new NonInvokable();
        };
        $foo = $pimple['foo'];

The assignment to $foo is dead and can be removed.

        $pimple->extend('foo', function () {});
    }

    public function testExtendFailsIfFrozenServiceIsInvokable()
    {
        $this->expectException(FrozenServiceException::class);
        $this->expectExceptionMessage('Cannot override frozen service "foo".');

        $pimple = new Container();
        $pimple['foo'] = function () {
            return new Invokable();
        };
        $foo = $pimple['foo'];

The assignment to $foo is dead and can be removed.

        $pimple->extend('foo', function () {});
    }

    /**
     * Provider for invalid service definitions.
     */
    public static function badServiceDefinitionProvider()
    {
        return [
            [123],
            [new NonInvokable()],
        ];
    }

    /**
     * Provider for service definitions.
     */
    public static function serviceDefinitionProvider()
    {
        return [
            [function ($value) {
                $service = new Service();
                $service->value = $value;

                return $service;
            }],
            [new Invokable()],
        ];
    }

    public function testDefiningNewServiceAfterFreeze()
    {
        $pimple = new Container();
        $pimple['foo'] = function () {
            return 'foo';
        };
        $foo = $pimple['foo'];

The assignment to $foo is dead and can be removed.

        $pimple['bar'] = function () {
            return 'bar';
        };
        $this->assertSame('bar', $pimple['bar']);
    }

    public function testOverridingServiceAfterFreeze()
    {
        $this->expectException(FrozenServiceException::class);
        $this->expectExceptionMessage('Cannot override frozen service "foo".');

        $pimple = new Container();
        $pimple['foo'] = function () {
            return 'foo';
        };
        $foo = $pimple['foo'];

The assignment to $foo is dead and can be removed.

        $pimple['foo'] = function () {
            return 'bar';
        };
    }

    /**
     * @group legacy
     */
    public function testLegacyOverridingServiceAfterFreeze()
    {
        $this->expectException(RuntimeException::class);
        $this->expectExceptionMessage('Cannot override frozen service "foo".');

        $pimple = new Container();
        $pimple['foo'] = function () {
            return 'foo';
        };
        $foo = $pimple['foo'];

The assignment to $foo is dead and can be removed.

        $pimple['foo'] = function () {
            return 'bar';
        };
    }

    public function testRemovingServiceAfterFreeze()
    {
        $pimple = new Container();
        $pimple['foo'] = function () {
            return 'foo';
        };
        $foo = $pimple['foo'];

The assignment to $foo is dead and can be removed.

        unset($pimple['foo']);
        $pimple['foo'] = function () {
            return 'bar';
        };
        $this->assertSame('bar', $pimple['foo']);
    }

    public function testExtendingService()
    {
        $pimple = new Container();
        $pimple['foo'] = function () {
            return 'foo';
        };
        $pimple['foo'] = $pimple->extend('foo', function ($foo, $app) {

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

            return "$foo.bar";
        });
        $pimple['foo'] = $pimple->extend('foo', function ($foo, $app) {

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

            return "$foo.baz";
        });
        $this->assertSame('foo.bar.baz', $pimple['foo']);
    }

    public function testExtendingServiceAfterOtherServiceFreeze()
    {
        $pimple = new Container();
        $pimple['foo'] = function () {
            return 'foo';
        };
        $pimple['bar'] = function () {
            return 'bar';
        };
        $foo = $pimple['foo'];

The assignment to $foo is dead and can be removed.

        $pimple['bar'] = $pimple->extend('bar', function ($bar, $app) {

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

            return "$bar.baz";
        });
        $this->assertSame('bar.baz', $pimple['bar']);
    }
}

class Invokable
{
    public function __invoke($value = null)
    {
        $service = new Service();
        $service->value = $value;

        return $service;
    }
}

class NonInvokable
{
    public function __call($a, $b) {}
}

class Service
{
    public $value;
}