Refactor

spec/Happyr/DoctrineSpecification/DoctrineTransformerSpec.php

@@ -0,0 +1,54 @@
+<?php
+
+namespace spec\Happyr\DoctrineSpecification;
+
+use Doctrine\ORM\Query;
+use Doctrine\ORM\Query\Expr;
+use Doctrine\ORM\QueryBuilder;
+use Happyr\DoctrineSpecification\Filter\Base\FilterInterface;
+use Happyr\DoctrineSpecification\ParametersBag;
+use Happyr\DoctrineSpecification\Specification;
+use Happyr\DoctrineSpecification\Transformer\DoctrineTransformer;
+use Happyr\DoctrineSpecification\Transformer\FilterTransformerInterface;
+use PhpSpec\ObjectBehavior;
+use Prophecy\Argument;
+
+/**
+ * @mixin DoctrineTransformer
+ */
+class DoctrineTransformerSpec extends ObjectBehavior
+{
+    function let(ParametersBag $parameters)
+    {
+        $this->beConstructedWith($parameters);
+    }
+
+    function it_is_initializable()
+    {
+        $this->shouldHaveType('Happyr\DoctrineSpecification\DoctrineTransformer');
+    }
+
+    function it_transforms_specifications_to_query(
+        QueryBuilder $qb,
+        Specification $specification,
+        FilterTransformerInterface $transformer,
+        FilterInterface $filter,
+        ParametersBag $parameters
+    )
+    {
+        $specification->getFilter()->willReturn($filter);
+        $transformer->supports($filter)->willReturn(true);
+        $transformer->transform($filter, $parameters, Argument::type('Doctrine\ORM\QueryBuilder'))->willReturn('DQL');
+        $parameters->clear()->shouldBeCalled();
+        $parameters->has()->willReturn(true);
+        $parameters->get()->willReturn([1 => 'value']);
+
+        $qb->add('where', 'DQL')->shouldBeCalled();
+        $qb->setParameters([1 => 'value'])->shouldBeCalled();
+
+        $this->setQueryBuilder($qb);
+        $this->addTransformer($transformer);
+
+        $this->transform($specification)->shouldReturn($qb);
+    }
+}

spec/Happyr/DoctrineSpecification/ParametersBagSpec.php

@@ -0,0 +1,41 @@
+<?php
+
+
+namespace spec\Happyr\DoctrineSpecification;
+
+use Happyr\DoctrineSpecification\ParametersBag;
+use PhpSpec\ObjectBehavior;
+use Prophecy\Argument;
+
+/**
+ * Class ParametersBagSpec
+ * @mixin ParametersBag
+ */
+class ParametersBagSpec extends ObjectBehavior
+{
+    function it_keep_parameters()
+    {
+        $this->add('value')->shouldReturn('?1');
+        $this->add('value2')->shouldReturn('?2');
+    }
+
+    function it_can_hold_parameters()
+    {
+        $this->has()->shouldReturn(false);
+        $this->add('value');
+        $this->has()->shouldReturn(true);
+    }
+
+    function it_should_be_able_to_reset_itself()
+    {
+        $this->add('value');
+        $this->clear();
+        $this->has()->shouldReturn(false);
+    }
+
+    function it_should_return_values()
+    {
+        $this->add('value');
+        $this->get()->shouldReturn([1 => 'value']);
+    }
+}

spec/Happyr/DoctrineSpecification/Transformer/ComparisonTransformerSpec.php

@@ -0,0 +1,141 @@
+<?php
+
+
+namespace spec\Happyr\DoctrineSpecification\Transformer;
+
+use Doctrine\ORM\Query\Expr;
+use Doctrine\ORM\QueryBuilder;
+use Happyr\DoctrineSpecification\Exception\InvalidArgumentException;
+use Happyr\DoctrineSpecification\Filter\Base\Comparison;
+use Happyr\DoctrineSpecification\Filter\Equals;
+use Happyr\DoctrineSpecification\Filter\GreaterOrEqualThan;
+use Happyr\DoctrineSpecification\Filter\GreaterThan;
+use Happyr\DoctrineSpecification\Filter\In;
+use Happyr\DoctrineSpecification\Filter\LessOrEqualThan;
+use Happyr\DoctrineSpecification\Filter\LessThan;
+use Happyr\DoctrineSpecification\Filter\Like;
+use Happyr\DoctrineSpecification\Filter\NotEquals;
+use Happyr\DoctrineSpecification\ParametersBag;
+use Happyr\DoctrineSpecification\Specification;
+use PhpSpec\ObjectBehavior;
+use Prophecy\Argument;
+
+class ComparisonTransformerSpec extends ObjectBehavior
+{
+    function it_should_transform_equals(QueryBuilder $queryBuilder, Expr $expr, ParametersBag $parameters)
+    {
+        $parameters->add(Argument::any())->willReturn('?1');
+        $queryBuilder->expr()->willReturn($expr);
+        $expr->eq('field', '?1')->willReturn('field = ?1');
+
+        $this->setQueryBuilder($queryBuilder);
+        $this->transform(new Equals('field', 'value'), $parameters)->shouldReturn('field = ?1');
+    }
+
+    function it_should_transform_greater_than_or_equals(QueryBuilder $queryBuilder, Expr $expr, ParametersBag $parameters)
+    {
+        $parameters->add(Argument::any())->willReturn('?1');
+        $queryBuilder->expr()->willReturn($expr);
+        $expr->gte('field', '?1')->willReturn('field >= ?1');
+
+        $this->setQueryBuilder($queryBuilder);
+        $this->transform(new GreaterOrEqualThan('field', 'value'), $parameters)->shouldReturn('field >= ?1');
+    }
+
+    function it_should_transform_greater_than(QueryBuilder $queryBuilder, Expr $expr, ParametersBag $parameters)
+    {
+        $parameters->add(Argument::any())->willReturn('?1');
+        $queryBuilder->expr()->willReturn($expr);
+        $expr->gt('field', '?1')->willReturn('field > ?1');
+
+        $this->setQueryBuilder($queryBuilder);
+        $this->transform(new GreaterThan('field', 'value'), $parameters)->shouldReturn('field > ?1');
+    }
+
+    function it_should_transform_in(QueryBuilder $queryBuilder, Expr $expr, ParametersBag $parameters)
+    {
+        $parameters->add(Argument::any())->willReturn('?1');
+        $queryBuilder->expr()->willReturn($expr);
+        $expr->in('field', '?1')->willReturn('field IN (\'?1\')');
+
+        $this->setQueryBuilder($queryBuilder);
+        $this->transform(new In('field', [1,2,3]), $parameters)->shouldReturn('field IN (\'?1\')');
+    }
+
+    function it_should_transform_less_or_equals(QueryBuilder $queryBuilder, Expr $expr, ParametersBag $parameters)
+    {
+        $parameters->add(Argument::any())->willReturn('?1');
+        $queryBuilder->expr()->willReturn($expr);
+        $expr->lte('field', '?1')->willReturn('field <= ?1');
+
+        $this->setQueryBuilder($queryBuilder);
+        $this->transform(new LessOrEqualThan('field', 'value'), $parameters)->shouldReturn('field <= ?1');
+    }
+
+    function it_should_transform_less_than_or_equals(QueryBuilder $queryBuilder, Expr $expr, ParametersBag $parameters)
+    {
+        $parameters->add(Argument::any())->willReturn('?1');
+        $queryBuilder->expr()->willReturn($expr);
+        $expr->lt('field', '?1')->willReturn('field < ?1');
+
+        $this->setQueryBuilder($queryBuilder);
+        $this->transform(new LessThan('field', 'value'), $parameters)->shouldReturn('field < ?1');
+    }
+
+    function it_should_transform_like_contains(QueryBuilder $queryBuilder, Expr $expr, ParametersBag $parameters)
+    {
+        $parameters->add(Argument::any())->willReturn('?1');
+        $queryBuilder->expr()->willReturn($expr);
+        $expr->like('field', '?1')->willReturn('field like ?1');
+
+        $this->setQueryBuilder($queryBuilder);
+        $this->transform(new Like('field', 'value', Like::CONTAINS), $parameters)->shouldReturn('field like ?1');
+    }
+
+    function it_should_transform_like_starts_with(QueryBuilder $queryBuilder, Expr $expr, ParametersBag $parameters)
+    {
+        $parameters->add(Argument::any())->willReturn('?1');
+        $queryBuilder->expr()->willReturn($expr);
+        $expr->like('field', '?1')->willReturn('field like ?1');
+
+        $this->setQueryBuilder($queryBuilder);
+        $this->transform(new Like('field', 'value', Like::STARTS_WITH), $parameters)->shouldReturn('field like ?1');
+    }
+
+    function it_should_transform_ends_with(QueryBuilder $queryBuilder, Expr $expr, ParametersBag $parameters)
+    {
+        $parameters->add(Argument::any())->willReturn('?1');
+        $queryBuilder->expr()->willReturn($expr);
+        $expr->like('field', '?1')->willReturn('field like ?1');
+
+        $this->setQueryBuilder($queryBuilder);
+        $this->transform(new Like('field', 'value', Like::ENDS_WITH), $parameters)->shouldReturn('field like ?1');
+    }
+
+    function it_should_transform_not_equals(QueryBuilder $queryBuilder, Expr $expr, ParametersBag $parameters)
+    {
+        $parameters->add(Argument::any())->willReturn('?1');
+        $queryBuilder->expr()->willReturn($expr);
+        $expr->neq('field', '?1')->willReturn('field <> ?1');
+
+        $this->setQueryBuilder($queryBuilder);
+        $this->transform(new NotEquals('field', 'value'), $parameters)->shouldReturn('field <> ?1');
+    }
+
+    function it_should_throw_exception_for_unsupported_filter(QueryBuilder $queryBuilder, Expr $expr, ParametersBag $parameters, Comparison $comparision)
+    {
+        $this->shouldThrow('Happyr\DoctrineSpecification\Exception\InvalidArgumentException')->duringTransform($comparision, $parameters);
+    }
+
+    function it_support_filters()
+    {
+        $this->supports(new Equals('f', 'v'))->shouldReturn(true);
+        $this->supports(new NotEquals('f', 'v'))->shouldReturn(true);
+        $this->supports(new GreaterOrEqualThan('f', 'v'))->shouldReturn(true);
+        $this->supports(new GreaterThan('f', 'v'))->shouldReturn(true);
+        $this->supports(new LessOrEqualThan('f', 'v'))->shouldReturn(true);
+        $this->supports(new LessThan('f', 'v'))->shouldReturn(true);
+        $this->supports(new In('f', 'v'))->shouldReturn(true);
+        $this->supports(new Like('f', 'v'))->shouldReturn(true);
+    }
+}