ElasticaSpecification\QueryFactory\NotFactoryTest

Complexity

Total Complexity

5

Size/Duplication

Total Lines	68
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	testConstruct()	0	6	1
A	testCreateReturnsNotQuery()	0	15	1
A	createNot()	0	6	1
A	createRegistry()	0	15	1
A	testCreateThrowExceptionIfNotNotSpecification()	0	10	1

<?php

namespace ElasticaSpecification\QueryFactory;

use Elastica\QueryBuilder;
use Elastica\Query\AbstractQuery;
use Elastica\Query\BoolQuery;
use GBProd\ElasticaSpecification\QueryFactory\Factory;
use GBProd\ElasticaSpecification\QueryFactory\NotFactory;
use GBProd\ElasticaSpecification\Registry;
use GBProd\Specification\Not;
use GBProd\Specification\Specification;
use PHPUnit\Framework\TestCase;

class NotFactoryTest extends TestCase
{
    public function testConstruct()
    {
        $factory = new NotFactory(new Registry());

        $this->assertInstanceOf(NotFactory::class, $factory);
    }

    public function testCreateReturnsNotQuery()
    {
        $not = $this->createNot();
        $registry = $this->createRegistry($not);

        $factory = new NotFactory($registry);

        $query = $factory->create($not, new QueryBuilder());

        $this->assertInstanceOf(BoolQuery::class, $query);

        $this->assertArrayHasKey('bool', $query->toArray());
        $this->assertArrayHasKey('must_not', $query->toArray()['bool']);
        $this->assertCount(1, $query->toArray()['bool']['must_not']);
    }

    /**
     * @return Not
     */
    private function createNot()
    {
        return new Not(
            $this->createMock(Specification::class)

$this->createMock(\GBProd\Specification\Specification::class) is of type object<PHPUnit\Framework\MockObject\MockObject>, but the function expects a object<GBProd\Specification\Specification>.

        );
    }

    /**
     * @param Not $not
     *
     * @return Registry
     */
    private function createRegistry($not)
    {
        $factory = $this->createMock(Factory::class);
        $factory
            ->expects($this->any())
            ->method('create')
            ->willReturn($this->createMock(AbstractQuery::class))
        ;

        $registry = new Registry();

        $registry->register(get_class($not->getWrappedSpecification()), $factory);

$factory is of type object<PHPUnit\Framework\MockObject\MockObject>, but the function expects a object<GBProd\ElasticaSpecification\QueryFactory\Factory>.

        return $registry;
    }


    public function testCreateThrowExceptionIfNotNotSpecification()
    {
        $spec = $this->createMock(Specification::class);
        $registry = new Registry();
        $factory = new NotFactory($registry);

        $this->expectException(\InvalidArgumentException::class);

        $factory->create($spec, new QueryBuilder());

$spec is of type object<PHPUnit\Framework\MockObject\MockObject>, but the function expects a object<GBProd\Specification\Specification>.

    }
}