AbstractEditableDiscoveryTest::testAddBindingAcceptsDuplicates() - Code Metrics - puli/discovery - Measure and Improve Code Quality continuously with Scrutinizer

testAddBindingAcceptsDuplicates() A
last analyzed 2016-08-15 14:52 UTC

↳ Parent: AbstractEditableDiscoveryTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	21
Code Lines	9

Duplication

Lines	14
Ratio	66.67 %

Code Coverage

Tests	10
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	14
loc	21
ccs	10
cts	10
cp	1
rs	9.3142
cc	1
eloc	9
nc	1
nop	0
crap	1

<?php

/*
 * This file is part of the puli/discovery package.
 *
 * (c) Bernhard Schussek <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Puli\Discovery\Test;

use Puli\Discovery\Api\Binding\Binding;
use Puli\Discovery\Api\Binding\Initializer\BindingInitializer;
use Puli\Discovery\Api\Discovery;
use Puli\Discovery\Api\EditableDiscovery;
use Puli\Discovery\Api\Type\BindingParameter;
use Puli\Discovery\Api\Type\BindingType;
use Puli\Discovery\Test\Fixtures\Bar;
use Puli\Discovery\Test\Fixtures\Foo;
use Puli\Discovery\Test\Fixtures\StringBinding;
use stdClass;
use Webmozart\Expression\Expr;

/**
 * @since  1.0
 *
 * @author Bernhard Schussek <[email protected]>
 */
abstract class AbstractEditableDiscoveryTest extends AbstractDiscoveryTest
{
    /**
     * Creates a discovery that can be written in the test.
     *
     * @param BindingInitializer[] $initializers
     *
     * @return EditableDiscovery
     */
    abstract protected function createDiscovery(array $initializers = array());

    /**
     * Creates a discovery that can be read in the test.
     *
     * This method is needed to test whether the discovery actually synchronized
     * all in-memory changes to the backing data store:
     *
     *  * If the method returns the passed $discovery, the in-memory data
     *    structures are tested.
     *  * If the method returns a new discovery with the same backing data store,
     *    that data store is tested.
     *
     * @param EditableDiscovery    $discovery
     * @param BindingInitializer[] $initializers
     *
     * @return EditableDiscovery
     */
    abstract protected function loadDiscoveryFromStorage(EditableDiscovery $discovery, array $initializers = array());

    /**
     * @param BindingType[]        $types
     * @param Binding[]            $bindings
     * @param BindingInitializer[] $initializers
     *
     * @return Discovery
     */
    protected function createLoadedDiscovery(array $types = array(), array $bindings = array(), array $initializers = array())
    {
        $discovery = $this->createDiscovery($initializers);

        foreach ($types as $type) {
            $discovery->addBindingType($type);
        }

        foreach ($bindings as $binding) {
            $discovery->addBinding($binding);
        }

        return $this->loadDiscoveryFromStorage($discovery);
    }

    public function testAddBinding()

    {
        $binding = new StringBinding('string', Foo::clazz);

        $discovery = $this->createDiscovery();
        $discovery->addBindingType(new BindingType(Foo::clazz, self::STRING_BINDING));
        $discovery->addBinding($binding);

        $discovery = $this->loadDiscoveryFromStorage($discovery);

        $this->assertCount(1, $discovery->findBindings(Foo::clazz));
        $this->assertCount(1, $discovery->getBindings());
    }

    /**
     * @expectedException \Puli\Discovery\Api\Type\NoSuchTypeException
     * @expectedExceptionMessage Foo
     */
    public function testAddBindingFailsIfTypeNotFound()
    {
        $discovery = $this->createDiscovery();
        $discovery->addBinding(new StringBinding('string', Foo::clazz));
    }

    /**
     * @expectedException \Puli\Discovery\Api\Type\BindingNotAcceptedException
     * @expectedExceptionMessage Foo
     */
    public function testAddBindingFailsIfTypeDoesNotAcceptBinding()
    {
        $discovery = $this->createDiscovery();
        $discovery->addBindingType(new BindingType(Foo::clazz, self::CLASS_BINDING));
        $discovery->addBinding(new StringBinding('string', Foo::clazz));
    }

    public function testAddBindingAcceptsDuplicates()

    {
        // The idea behind accepting duplicates is that depending on the use
        // case, multiple modules may define the same binding but the order
        // in which the modules is loaded is important. Hence if we load
        // [m1, m2, m3] and m1 and m3 contain the same binding, we cannot simply
        // discard one of the bindings, since the order might be important for
        // the end user.

        $binding = new StringBinding('string', Foo::clazz);

        $discovery = $this->createDiscovery();
        $discovery->addBindingType(new BindingType(Foo::clazz, self::STRING_BINDING));
        $discovery->addBinding($binding);
        $discovery->addBinding($binding);

        $discovery = $this->loadDiscoveryFromStorage($discovery);

        $this->assertCount(2, $discovery->findBindings(Foo::clazz));
        $this->assertCount(2, $discovery->getBindings());
    }

    public function testRemoveBindings()
    {
        $binding1 = new StringBinding('string1', Foo::clazz);
        $binding2 = new StringBinding('string2', Foo::clazz);

        $discovery = $this->createDiscovery();
        $discovery->addBindingType(new BindingType(Foo::clazz, self::STRING_BINDING));
        $discovery->addBinding($binding1);
        $discovery->addBinding($binding2);
        $discovery->removeBindings();

        $discovery = $this->loadDiscoveryFromStorage($discovery);

        $this->assertCount(0, $discovery->findBindings(Foo::clazz));
        $this->assertCount(0, $discovery->getBindings());
    }

    public function testRemoveBindingsDoesNothingIfNoneFound()

    {
        $discovery = $this->createDiscovery();
        $discovery->removeBindings();

        $discovery = $this->loadDiscoveryFromStorage($discovery);

        $this->assertCount(0, $discovery->getBindings());
    }

    public function testRemoveBindingsWithType()
    {
        $binding1 = new StringBinding('string1', Foo::clazz);
        $binding2 = new StringBinding('string2', Foo::clazz);
        $binding3 = new StringBinding('string3', Bar::clazz);

        $discovery = $this->createDiscovery();
        $discovery->addBindingType(new BindingType(Foo::clazz, self::STRING_BINDING));
        $discovery->addBindingType(new BindingType(Bar::clazz, self::STRING_BINDING));
        $discovery->addBinding($binding1);
        $discovery->addBinding($binding2);
        $discovery->addBinding($binding3);
        $discovery->removeBindings(Foo::clazz);

        $discovery = $this->loadDiscoveryFromStorage($discovery);

        $this->assertEquals(array(), $discovery->findBindings(Foo::clazz));
        $this->assertEquals(array($binding3), $discovery->findBindings(Bar::clazz));
        $this->assertEquals(array($binding3), $discovery->getBindings());
    }

    public function testRemoveBindingsWithTypeDoesNothingIfNoneFound()

    {
        $discovery = $this->createDiscovery();
        $discovery->addBindingType(new BindingType(Foo::clazz, self::STRING_BINDING));
        $discovery->removeBindings(Foo::clazz);

        $discovery = $this->loadDiscoveryFromStorage($discovery);

        $this->assertCount(0, $discovery->getBindings());
    }

    public function testRemoveBindingsWithTypeDoesNothingIfTypeNotFound()

    {
        $discovery = $this->createDiscovery();
        $discovery->removeBindings(Foo::clazz);

        $discovery = $this->loadDiscoveryFromStorage($discovery);

        $this->assertCount(0, $discovery->getBindings());
    }

    /**
     * @expectedException \InvalidArgumentException
     * @expectedExceptionMessage stdClass
     */
    public function testRemoveBindingsWithTypeFailsIfInvalidType()
    {
        $discovery = $this->createDiscovery();
        $discovery->removeBindings(new stdClass());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    public function testRemoveBindingsWithExpression()

    {
        $binding1 = new StringBinding('string1', Foo::clazz, array('param1' => 'foo', 'param2' => 'bar'));
        $binding2 = new StringBinding('string2', Foo::clazz, array('param1' => 'foo'));
        $binding3 = new StringBinding('string3', Foo::clazz, array('param1' => 'bar'));

        $discovery = $this->createDiscovery();
        $discovery->addBindingType(new BindingType(Foo::clazz, self::STRING_BINDING, array(
            new BindingParameter('param1'),
            new BindingParameter('param2'),
        )));
        $discovery->addBinding($binding1);
        $discovery->addBinding($binding2);
        $discovery->addBinding($binding3);
        $discovery->removeBindings(null, Expr::method('getParameterValue', 'param1', Expr::same('foo')));

        $discovery = $this->loadDiscoveryFromStorage($discovery);

        $this->assertEquals(array($binding3), $discovery->findBindings(Foo::clazz));
        $this->assertEquals(array($binding3), $discovery->getBindings());
    }

    public function testRemoveBindingsWithTypeAndExpression()

    {
        $binding1 = new StringBinding('string1', Foo::clazz, array('param1' => 'foo', 'param2' => 'bar'));
        $binding2 = new StringBinding('string2', Foo::clazz, array('param1' => 'foo'));
        $binding3 = new StringBinding('string3', Foo::clazz, array('param1' => 'bar'));

        $discovery = $this->createDiscovery();
        $discovery->addBindingType(new BindingType(Foo::clazz, self::STRING_BINDING, array(
            new BindingParameter('param1'),
            new BindingParameter('param2'),
        )));
        $discovery->addBinding($binding1);
        $discovery->addBinding($binding2);
        $discovery->addBinding($binding3);
        $discovery->removeBindings(Foo::clazz, Expr::method('getParameterValue', 'param1', Expr::same('foo')));

        $discovery = $this->loadDiscoveryFromStorage($discovery);

        $this->assertEquals(array($binding3), $discovery->findBindings(Foo::clazz));
        $this->assertEquals(array($binding3), $discovery->getBindings());
    }

    public function testRemoveBindingsWithTypeAndParametersDoesNothingIfNoneFound()
    {
        $discovery = $this->createDiscovery();
        $discovery->addBindingType(new BindingType(Foo::clazz, self::STRING_BINDING));
        $discovery->removeBindings(Foo::clazz, Expr::method('getParameterValue', 'param1', Expr::same('foo')));

        $discovery = $this->loadDiscoveryFromStorage($discovery);

        $this->assertCount(0, $discovery->getBindings());
    }

    public function testRemoveBindingsWithTypeAndParametersDoesNothingIfTypeNotFound()
    {
        $discovery = $this->createDiscovery();
        $discovery->removeBindings(Foo::clazz, Expr::method('getParameterValue', 'param1', Expr::same('foo')));

        $discovery = $this->loadDiscoveryFromStorage($discovery);

        $this->assertCount(0, $discovery->getBindings());
    }

    public function testAddBindingType()

    {
        $type = new BindingType(Foo::clazz, self::STRING_BINDING);

        $discovery = $this->createDiscovery();
        $discovery->addBindingType($type);

        $discovery = $this->loadDiscoveryFromStorage($discovery);

        $this->assertEquals($type, $discovery->getBindingType(Foo::clazz));
    }

    public function testAddBindingTypeAfterReadingStorage()
    {
        $type1 = new BindingType(Foo::clazz, self::STRING_BINDING);
        $type2 = new BindingType(Bar::clazz, self::STRING_BINDING);

        $discovery = $this->createDiscovery();
        $discovery->addBindingType($type1);

        // Make sure that the previous call to addBindingType() stored all
        // necessary information in order to add further types (e.g. nextId)
        $discovery = $this->loadDiscoveryFromStorage($discovery);
        $discovery->addBindingType($type2);

        $this->assertEquals($type1, $discovery->getBindingType(Foo::clazz));
        $this->assertEquals($type2, $discovery->getBindingType(Bar::clazz));
    }

    /**
     * @expectedException \Puli\Discovery\Api\Type\DuplicateTypeException
     * @expectedExceptionMessage Foo
     */
    public function testAddBindingTypeFailsIfAlreadyDefined()
    {
        $discovery = $this->createDiscovery();
        $discovery->addBindingType(new BindingType(Foo::clazz, self::STRING_BINDING));
        $discovery->addBindingType(new BindingType(Foo::clazz, self::STRING_BINDING));
    }

    public function testRemoveBindingType()

    {
        $discovery = $this->createDiscovery();
        $discovery->addBindingType($type1 = new BindingType(Foo::clazz, self::STRING_BINDING));
        $discovery->addBindingType(new BindingType(Bar::clazz, self::STRING_BINDING));
        $discovery->removeBindingType(Bar::clazz);

        $discovery = $this->loadDiscoveryFromStorage($discovery);

        $this->assertEquals(array($type1), $discovery->getBindingTypes());
        $this->assertTrue($discovery->hasBindingType(Foo::clazz));
        $this->assertFalse($discovery->hasBindingType(Bar::clazz));
    }

    public function testRemoveBindingTypeIgnoresUnknownTypes()
    {
        $discovery = $this->createDiscovery();
        $discovery->addBindingType(new BindingType(Foo::clazz, self::STRING_BINDING));
        $discovery->removeBindingType(Bar::clazz);

        $discovery = $this->loadDiscoveryFromStorage($discovery);

        $this->assertTrue($discovery->hasBindingType(Foo::clazz));
        $this->assertFalse($discovery->hasBindingType(Bar::clazz));
    }

    /**
     * @expectedException \InvalidArgumentException
     * @expectedExceptionMessage stdClass
     */
    public function testRemoveBindingTypeFailsIfInvalidType()
    {
        $discovery = $this->createDiscovery();
        $discovery->removeBindingType(new stdClass());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    public function testRemoveBindingTypeRemovesCorrespondingBindings()
    {
        $discovery = $this->createDiscovery();
        $discovery->addBindingType(new BindingType(Foo::clazz, self::STRING_BINDING));
        $discovery->addBindingType(new BindingType(Bar::clazz, self::STRING_BINDING));
        $discovery->addBinding($binding1 = new StringBinding('string1', Foo::clazz));
        $discovery->addBinding($binding2 = new StringBinding('string2', Foo::clazz));
        $discovery->addBinding($binding3 = new StringBinding('string3', Bar::clazz));

        $discovery->removeBindingType(Foo::clazz);

        $discovery = $this->loadDiscoveryFromStorage($discovery);

        $this->assertEquals(array($binding3), $discovery->getBindings());
    }

    public function testRemoveBindingTypes()

    {
        $discovery = $this->createDiscovery();
        $discovery->addBindingType(new BindingType(Foo::clazz, self::STRING_BINDING));
        $discovery->addBindingType(new BindingType(Bar::clazz, self::STRING_BINDING));
        $discovery->removeBindingTypes();

        $discovery = $this->loadDiscoveryFromStorage($discovery);

        $this->assertEquals(array(), $discovery->getBindingTypes());
        $this->assertFalse($discovery->hasBindingType(Foo::clazz));
        $this->assertFalse($discovery->hasBindingType(Bar::clazz));
    }

    public function testRemoveBindingTypesRemovesBindings()
    {
        $discovery = $this->createDiscovery();
        $discovery->addBindingType(new BindingType(Foo::clazz, self::STRING_BINDING));
        $discovery->addBindingType(new BindingType(Bar::clazz, self::STRING_BINDING));
        $discovery->addBinding($binding1 = new StringBinding('string1', Foo::clazz));
        $discovery->addBinding($binding2 = new StringBinding('string2', Bar::clazz));
        $discovery->removeBindingTypes();

        $discovery = $this->loadDiscoveryFromStorage($discovery);

        $this->assertCount(0, $discovery->getBindings());
    }
}


1			<?php
2
3			/*
4			* This file is part of the puli/discovery package.
5			*
6			* (c) Bernhard Schussek <[email protected]>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace Puli\Discovery\Test;
13
14			use Puli\Discovery\Api\Binding\Binding;
15			use Puli\Discovery\Api\Binding\Initializer\BindingInitializer;
16			use Puli\Discovery\Api\Discovery;
17			use Puli\Discovery\Api\EditableDiscovery;
18			use Puli\Discovery\Api\Type\BindingParameter;
19			use Puli\Discovery\Api\Type\BindingType;
20			use Puli\Discovery\Test\Fixtures\Bar;
21			use Puli\Discovery\Test\Fixtures\Foo;
22			use Puli\Discovery\Test\Fixtures\StringBinding;
23			use stdClass;
24			use Webmozart\Expression\Expr;
25
26			/**
27			* @since 1.0
28			*
29			* @author Bernhard Schussek <[email protected]>
30			*/
31			abstract class AbstractEditableDiscoveryTest extends AbstractDiscoveryTest
32			{
33			/**
34			* Creates a discovery that can be written in the test.
35			*
36			* @param BindingInitializer[] $initializers
37			*
38			* @return EditableDiscovery
39			*/
40			abstract protected function createDiscovery(array $initializers = array());

puli / discovery

testAddBindingAcceptsDuplicates() A last analyzed 2016-08-15 14:52 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

testAddBindingAcceptsDuplicates() A
last analyzed 2016-08-15 14:52 UTC