spec\Sylius\Component\Core\Promotion\Checker\Rule\HasTaxonRuleCheckerSpec

Complexity

Total Complexity

7

Size/Duplication

Total Lines	77
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	7

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	it_is_initializable()	0	4	1
A	it_is_a_rule_checker()	0	4	1
A	it_recognizes_a_subject_as_eligible_if_product_taxon_is_matched()	0	15	1
A	it_recognizes_a_subject_as_eligible_if_a_product_taxon_is_matched_to_one_of_required_taxons()	0	15	1
A	it_recognizes_a_subject_as_not_eligible_if_a_product_taxon_is_not_matched()	0	15	1
A	it_does_nothing_if_a_configuration_is_invalid()	0	6	1
A	it_throws_an_exception_if_promotion_subject_is_not_order()	0	9	1

<?php

/*
 * This file is part of the Sylius package.
 *
 * (c) Paweł Jędrzejewski
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace spec\Sylius\Component\Core\Promotion\Checker\Rule;

use Doctrine\Common\Collections\Collection;
use PhpSpec\ObjectBehavior;
use Sylius\Component\Core\Model\OrderInterface;
use Sylius\Component\Core\Model\OrderItemInterface;
use Sylius\Component\Core\Model\ProductInterface;
use Sylius\Component\Core\Model\TaxonInterface;
use Sylius\Component\Core\Promotion\Checker\Rule\HasTaxonRuleChecker;
use Sylius\Component\Promotion\Checker\Rule\RuleCheckerInterface;
use Sylius\Component\Promotion\Exception\UnsupportedTypeException;
use Sylius\Component\Promotion\Model\PromotionSubjectInterface;

/**
 * @author Joseph Bielawski <stloyd@gmail.com>
 * @author Mateusz Zalewski <mateusz.zalewski@lakion.com>
 */
final class HasTaxonRuleCheckerSpec extends ObjectBehavior
{
    function it_is_initializable()
    {
        $this->shouldHaveType(HasTaxonRuleChecker::class);
    }

    function it_is_a_rule_checker()
    {
        $this->shouldImplement(RuleCheckerInterface::class);
    }

    function it_recognizes_a_subject_as_eligible_if_product_taxon_is_matched(
        OrderInterface $subject,
        OrderItemInterface $item,
        ProductInterface $bastardSword,
        TaxonInterface $swords
    ) {
        $configuration = ['taxons' => ['swords']];

        $swords->getCode()->willReturn('swords');
        $bastardSword->getTaxons()->willReturn([$swords]);
        $item->getProduct()->willReturn($bastardSword);
        $subject->getItems()->willReturn([$item]);

        $this->isEligible($subject, $configuration)->shouldReturn(true);
    }

    function it_recognizes_a_subject_as_eligible_if_a_product_taxon_is_matched_to_one_of_required_taxons(
        OrderInterface $subject,
        OrderItemInterface $item,
        ProductInterface $bastardSword,
        TaxonInterface $swords
    ) {
        $configuration = ['taxons' => ['swords', 'axes']];

        $swords->getCode()->willReturn('swords');
        $bastardSword->getTaxons()->willReturn([$swords]);
        $item->getProduct()->willReturn($bastardSword);
        $subject->getItems()->willReturn([$item]);

        $this->isEligible($subject, $configuration)->shouldReturn(true);
    }

    function it_recognizes_a_subject_as_not_eligible_if_a_product_taxon_is_not_matched(
        OrderInterface $subject,
        OrderItemInterface $item,
        ProductInterface $reflexBow,
        TaxonInterface $bows
    ) {
        $configuration = ['taxons' => ['swords', 'axes']];

        $bows->getCode()->willReturn('bows');
        $reflexBow->getTaxons()->willReturn([$bows]);
        $item->getProduct()->willReturn($reflexBow);
        $subject->getItems()->willReturn([$item]);

        $this->isEligible($subject, $configuration)->shouldReturn(false);
    }

    function it_does_nothing_if_a_configuration_is_invalid(OrderInterface $subject)
    {
        $subject->getItems()->shouldNotBeCalled();

        $this->isEligible($subject, []);
    }

    function it_throws_an_exception_if_promotion_subject_is_not_order(
        Collection $taxonsCollection,
        PromotionSubjectInterface $subject
    ) {
        $this
            ->shouldThrow(new UnsupportedTypeException($subject->getWrappedObject(), OrderInterface::class))
            ->during('isEligible', [$subject, ['taxons' => $taxonsCollection]])
        ;
    }
}