FOS\ElasticaBundle\Tests\Provider\IndexableTest

Complexity

Total Complexity

7

Size/Duplication

Total Lines	84
Duplicated Lines	36.9 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	testIndexableUnknown()	7	7	1
A	testValidIndexableCallbacks()	9	9	1
A	testInvalidIsIndexableCallbacks()	7	7	1
A	provideInvalidIsIndexableCallbacks()	0	10	1
A	testObjectIsNotIndexableIfIndexingDisabled()	8	8	1
A	provideIsIndexableCallbacks()	0	15	1
A	setUp()	0	10	1

<?php

/**
 * This file is part of the FOSElasticaBundle project.
 *
 * (c) Infinite Networks Pty Ltd <http://www.infinite.net.au>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace FOS\ElasticaBundle\Tests\Provider;

use FOS\ElasticaBundle\Provider\Indexable;
use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;

class IndexableTest extends \PHPUnit_Framework_TestCase
{
    public $container;

    public function testIndexableUnknown()

This method seems to be duplicated in your project.

    {
        $indexable = new Indexable(array(), $this->container);
        $index = $indexable->isObjectIndexable('index', 'type', new Entity());

        $this->assertTrue($index);
    }

    /**
     * @dataProvider provideIsIndexableCallbacks
     */
    public function testValidIndexableCallbacks($callback, $return)

This method seems to be duplicated in your project.

    {
        $indexable = new Indexable(array(
            'index/type' => $callback,
        ), $this->container);
        $index = $indexable->isObjectIndexable('index', 'type', new Entity());

        $this->assertEquals($return, $index);
    }

    /**
     * @dataProvider provideInvalidIsIndexableCallbacks
     * @expectedException \InvalidArgumentException
     */
    public function testInvalidIsIndexableCallbacks($callback)

This method seems to be duplicated in your project.

    {
        $indexable = new Indexable(array(
            'index/type' => $callback,
        ), $this->container);
        $indexable->isObjectIndexable('index', 'type', new Entity());
    }

    public function provideInvalidIsIndexableCallbacks()
    {
        return array(
            array('nonexistentEntityMethod'),
            array(array('@indexableService', 'internalMethod')),
            array(array(new IndexableDecider(), 'internalMethod')),
            array(42),
            array('entity.getIsIndexable() && nonexistentEntityFunction()'),
        );
    }

    public function testObjectIsNotIndexableIfIndexingDisabled()

This method seems to be duplicated in your project.

    {
        $indexable = new Indexable(array(), $this->container);
        $indexable->setIndexingEnabled(false);
        $index = $indexable->isObjectIndexable('index', 'type', new Entity());

        $this->assertFalse($index);
    }

    public function provideIsIndexableCallbacks()
    {
        return array(
            array('isIndexable', false),
            array(array(new IndexableDecider(), 'isIndexable'), true),
            array(array('@indexableService', 'isIndexable'), true),
            array(array('@indexableService'), true),
            array(function (Entity $entity) { return $entity->maybeIndex(); }, true),
            array('entity.maybeIndex()', true),
            array('!object.isIndexable() && entity.property == "abc"', true),
            array('entity.property != "abc"', false),
            array('["array", "values"]', true),
            array('[]', false)
        );
    }

    protected function setUp()
    {
        $this->container = $this->getMockBuilder('Symfony\\Component\\DependencyInjection\\ContainerInterface')
            ->getMock();

        $this->container->expects($this->any())
            ->method('get')
            ->with('indexableService')
            ->will($this->returnValue(new IndexableDecider()));
    }
}

class Entity
{
    public $property = 'abc';

    public function isIndexable()
    {
        return false;
    }

    public function maybeIndex()
    {
        return true;
    }
}

class IndexableDecider
{
    public function isIndexable(Entity $entity)
    {
        return !$entity->isIndexable();
    }

    protected function internalMethod()
    {
    }

    public function __invoke($object)
    {
        return true;
    }
}