gbprod / elastica-specification

use GBProd\Specification\AndX;

use GBProd\Specification\Specification;

class AndXBuilderTest extends \PHPUnit_Framework_TestCase

{

    public function testConstruct()

    {

        $builder = new AndXBuilder(new Registry());

        $this->assertInstanceOf(AndXBuilder::class, $builder);

    }

    public function testBuildReturnsAndxExpression()

    {

        $andx = $this->createAndX();

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

        $builder = new AndXBuilder($registry);

        $query = $builder->build($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)

    {

        $builder = $this->createMock(Builder::class);

        $builder

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

            ->method('build')

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

        ;

        $registry = new Registry();

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

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

        return $registry;

    }

    public function testBuildThrowExceptionIfNotAndXSpecification()

    {

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

        $registry = new Registry();

        $builder = new AndXBuilder($registry);

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

        $expr = $builder->build($spec, new QueryBuilder());

    }

}

use GBProd\Specification\OrX;

use GBProd\Specification\Specification;

class OrXBuilderTest extends \PHPUnit_Framework_TestCase

{

    public function testConstruct()

    {

        $builder = new OrXBuilder(new Registry());

        $this->assertInstanceOf(OrXBuilder::class, $builder);

    }

    public function testBuildReturnsOrxExpression()

    {

        $orx = $this->createOrX();

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

        $builder = new OrXBuilder($registry);

        $query = $builder->build($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)

    {

        $builder = $this->createMock(Builder::class);

        $builder

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

            ->method('build')

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

        ;

        $registry = new Registry();

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

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

        return $registry;

    }

    public function testBuildThrowExceptionIfNotOrXSpecification()

    {

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

        $registry = new Registry();

        $builder = new OrXBuilder($registry);

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

        $expr = $builder->build($spec, new QueryBuilder());

    }

}