gbprod / elastica-specification

use GBProd\Specification\AndX;

use GBProd\Specification\Specification;

class AndXFactoryTest extends \PHPUnit_Framework_TestCase

{

    public function testConstruct()

    {

        $factory = new AndXFactory(new Registry());

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

    }

    public function testCreateReturnsAndxQuery()

    {

        $andx = $this->createAndX();

        $registry = $this->createRegistry($andx);

        $factory = new AndXFactory($registry);

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

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

        $this->assertArrayHasKey('bool', $query->toArray());

        $this->assertArrayHasKey('must', $query->toArray()['bool']);

        $this->assertCount(2, $query->toArray()['bool']['must']);

    }

    /**

     * @return AndX

     */

    private function createAndX()

    {

        return new AndX(

            $this->createMock(Specification::class),

            $this->createMock(Specification::class)

        );

    }

    /**

     * @param AndX $andx

     *

     * @return Registry

     */

    private function createRegistry($andx)

    {

        $factory = $this->createMock(Factory::class);

        $factory

            ->expects($this->any())

            ->method('create')

            ->willReturn($this->createMock(AbstractQuery::class))

        ;

        $registry = new Registry();

        $registry->register(get_class($andx->getFirstPart()), $factory);

        $registry->register(get_class($andx->getSecondPart()), $factory);

        return $registry;

    }

    public function testCreateThrowExceptionIfNotAndXSpecification()

    {

        $spec = $this->createMock(Specification::class);

        $registry = new Registry();

        $factory = new AndXFactory($registry);

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

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

    }

}

use GBProd\Specification\OrX;

use GBProd\Specification\Specification;

class OrXFactoryTest extends \PHPUnit_Framework_TestCase

{

    public function testConstruct()

    {

        $factory = new OrXFactory(new Registry());

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

    }

    public function testCreateReturnsOrxQuery()

    {

        $orx = $this->createOrX();

        $registry = $this->createRegistry($orx);

        $factory = new OrXFactory($registry);

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

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

        $this->assertArrayHasKey('bool', $query->toArray());

        $this->assertArrayHasKey('should', $query->toArray()['bool']);

        $this->assertCount(2, $query->toArray()['bool']['should']);

    }

    /**

     * @return OrX

     */

    private function createOrX()

    {

        return new OrX(

            $this->createMock(Specification::class),

            $this->createMock(Specification::class)

        );

    }

    /**

     * @param OrX $orx

     *

     * @return Registry

     */

    private function createRegistry($orx)

    {

        $factory = $this->createMock(Factory::class);

        $factory

            ->expects($this->any())

            ->method('create')

            ->willReturn($this->createMock(AbstractQuery::class))

        ;

        $registry = new Registry();

        $registry->register(get_class($orx->getFirstPart()), $factory);

        $registry->register(get_class($orx->getSecondPart()), $factory);

        return $registry;

    }

    public function testCreateThrowExceptionIfNotOrXSpecification()

    {

        $spec = $this->createMock(Specification::class);

        $registry = new Registry();

        $factory = new OrXFactory($registry);

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

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

    }

}