OrderItemSpec::it_adds_adjustments_properly() - Code Metrics - Inspection of "PoC for the Community Organization v2" - pamil/Sylius - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — pull-request/8107 ( aa76b1 )

by Kamil

created 2017-10-18 12:06 UTC

OrderItemSpec::it_adds_adjustments_properly() A

↳ Parent: OrderItemSpec

Complexity

Conditions	1
Paths	1

Size

Total Lines	9
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	9
rs	9.6666
c	0
b	0
f	0
nc	1
cc	1
eloc	6
nop	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.
 */

declare(strict_types=1);

namespace spec\Sylius\Component\Order\Model;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use PhpSpec\ObjectBehavior;
use Sylius\Component\Order\Model\AdjustableInterface;
use Sylius\Component\Order\Model\AdjustmentInterface;
use Sylius\Component\Order\Model\OrderInterface;
use Sylius\Component\Order\Model\OrderItemInterface;
use Sylius\Component\Order\Model\OrderItemUnitInterface;

/**
 * @author Paweł Jędrzejewski <[email protected]>
 * @author Michał Marcinkowski <[email protected]>
 */
final class OrderItemSpec extends ObjectBehavior
{
    function it_implements_an_order_item_interface(): void
    {
        $this->shouldImplement(OrderItemInterface::class);
    }

    function it_implements_an_adjustable_interface(): void
    {
        $this->shouldImplement(AdjustableInterface::class);
    }

    function it_has_no_id_by_default(): void
    {
        $this->getId()->shouldReturn(null);
    }

    function it_does_not_belong_to_an_order_by_default(): void
    {
        $this->getOrder()->shouldReturn(null);
    }

    function it_allows_assigning_itself_to_an_order(OrderInterface $order): void
    {
        $order->hasItem($this)->willReturn(false);
        $order->addItem($this)->shouldBeCalled();

        $this->setOrder($order);
        $this->getOrder()->shouldReturn($order);
    }

    function it_allows_detaching_itself_from_an_order(OrderInterface $order): void
    {
        $order->hasItem($this)->willReturn(false);
        $order->addItem($this)->shouldBeCalled();

        $this->setOrder($order);
        $this->getOrder()->shouldReturn($order);

        $order->hasItem($this)->willReturn(true);
        $order->removeItem($this)->shouldBeCalled();

        $this->setOrder(null);
        $this->getOrder()->shouldReturn(null);
    }

    function it_does_not_set_order_if_it_is_already_set(OrderInterface $order): void
    {
        $order->hasItem($this)->willReturn(false);
        $order->addItem($this)->shouldBeCalled();
        $this->setOrder($order);
        $this->getOrder()->shouldReturn($order);

        $order->hasItem($this)->willReturn(true);
        $this->setOrder($order);
        $this->getOrder()->shouldReturn($order);
    }

    function it_has_quantity_equal_to_0_by_default(): void
    {
        $this->getQuantity()->shouldReturn(0);
    }

    function it_has_unit_price_equal_to_0_by_default(): void
    {
        $this->getUnitPrice()->shouldReturn(0);
    }

    function its_unit_price_should_accept_only_integer(): void
    {
        $this->setUnitPrice(4498);
        $this->getUnitPrice()->shouldReturn(4498);
    }

    function it_has_total_equal_to_0_by_default(): void
    {
        $this->getTotal()->shouldReturn(0);
    }

    function it_initializes_adjustments_collection_by_default(): void
    {
        $this->getAdjustments()->shouldHaveType(Collection::class);
    }

    function it_returns_adjustments_recursively(
        AdjustmentInterface $itemAdjustment,
        AdjustmentInterface $unitAdjustment1,
        AdjustmentInterface $unitAdjustment2,
        OrderItemUnitInterface $unit1,
        OrderItemUnitInterface $unit2
    ): void {
        $unit1->getOrderItem()->willReturn($this);
        $unit1->getTotal()->willReturn(100);
        $unit1->getAdjustments(null)->willReturn(new ArrayCollection([$unitAdjustment1->getWrappedObject()]));

        $unit2->getOrderItem()->willReturn($this);
        $unit2->getTotal()->willReturn(100);
        $unit2->getAdjustments(null)->willReturn(new ArrayCollection([$unitAdjustment2->getWrappedObject()]));

        $this->addUnit($unit1);
        $this->addUnit($unit2);

        $itemAdjustment->setAdjustable($this)->shouldBeCalled();
        $itemAdjustment->isNeutral()->willReturn(true);

        $this->addAdjustment($itemAdjustment);

        $this->getAdjustmentsRecursively()->shouldIterateAs([$itemAdjustment, $unitAdjustment1, $unitAdjustment2]);
    }

    function it_adds_and_removes_units(OrderItemUnitInterface $orderItemUnit1, OrderItemUnitInterface $orderItemUnit2): void
    {
        $orderItemUnit1->getOrderItem()->willReturn($this->getWrappedObject());
        $orderItemUnit1->getTotal()->willReturn(0);
        $orderItemUnit2->getOrderItem()->willReturn($this->getWrappedObject());
        $orderItemUnit2->getTotal()->willReturn(0);
        $this->getUnits()->shouldHaveType(Collection::class);

        $this->addUnit($orderItemUnit1);
        $this->addUnit($orderItemUnit2);
        $this->hasUnit($orderItemUnit1)->shouldReturn(true);
        $this->hasUnit($orderItemUnit2)->shouldReturn(true);

        $this->removeUnit($orderItemUnit1);
        $this->hasUnit($orderItemUnit1)->shouldReturn(false);
        $this->hasUnit($orderItemUnit2)->shouldReturn(true);
    }

    function it_adds_only_unit_that_is_assigned_to_it(OrderItemUnitInterface $orderItemUnit1, OrderItemInterface $orderItem): void
    {
        $orderItemUnit1->getOrderItem()->willReturn($orderItem);
        $this
            ->shouldThrow(new \LogicException('This order item unit is assigned to a different order item.'))
            ->duringAddUnit($orderItemUnit1)
        ;
    }

    function it_recalculates_units_total_on_unit_price_change(
        OrderItemUnitInterface $orderItemUnit1,
        OrderItemUnitInterface $orderItemUnit2
    ): void {
        $orderItemUnit1->getOrderItem()->willReturn($this->getWrappedObject());
        $orderItemUnit1->getTotal()->willReturn(0, 100);
        $orderItemUnit2->getOrderItem()->willReturn($this->getWrappedObject());
        $orderItemUnit2->getTotal()->willReturn(0, 100);

        $this->addUnit($orderItemUnit1);
        $this->addUnit($orderItemUnit2);

        $this->setUnitPrice(100);
    }

    function it_adds_adjustments_properly(AdjustmentInterface $adjustment): void
    {
        $adjustment->isNeutral()->willReturn(true);
        $adjustment->setAdjustable($this)->shouldBeCalled();

        $this->hasAdjustment($adjustment)->shouldReturn(false);
        $this->addAdjustment($adjustment);
        $this->hasAdjustment($adjustment)->shouldReturn(true);
    }

    function it_removes_adjustments_properly(AdjustmentInterface $adjustment): void
    {
        $adjustment->isNeutral()->willReturn(true);
        $adjustment->setAdjustable($this)->shouldBeCalled();

        $this->hasAdjustment($adjustment)->shouldReturn(false);
        $this->addAdjustment($adjustment);
        $this->hasAdjustment($adjustment)->shouldReturn(true);

        $adjustment->setAdjustable(null)->shouldBeCalled();
        $adjustment->isLocked()->willReturn(false);

        $this->removeAdjustment($adjustment);
        $this->hasAdjustment($adjustment)->shouldReturn(false);
    }

    function it_has_correct_total_based_on_unit_items(
        OrderItemUnitInterface $orderItemUnit1,
        OrderItemUnitInterface $orderItemUnit2
    ): void {
        $orderItemUnit1->getOrderItem()->willReturn($this->getWrappedObject());
        $orderItemUnit1->getTotal()->willReturn(1499);
        $orderItemUnit2->getOrderItem()->willReturn($this->getWrappedObject());
        $orderItemUnit2->getTotal()->willReturn(1499);

        $this->addUnit($orderItemUnit1);
        $this->addUnit($orderItemUnit2);
        $this->getTotal()->shouldReturn(2998);
    }

    function it_has_correct_total_after_unit_item_remove(
        OrderItemUnitInterface $orderItemUnit1,
        OrderItemUnitInterface $orderItemUnit2
    ): void {
        $orderItemUnit1->getOrderItem()->willReturn($this->getWrappedObject());
        $orderItemUnit1->getTotal()->willReturn(2000);
        $orderItemUnit2->getOrderItem()->willReturn($this->getWrappedObject());
        $orderItemUnit2->getTotal()->willReturn(1000);

        $this->addUnit($orderItemUnit1);
        $this->addUnit($orderItemUnit2);
        $this->getTotal()->shouldReturn(3000);

        $this->removeUnit($orderItemUnit2);
        $this->getTotal()->shouldReturn(2000);
    }

    function it_has_correct_total_after_negative_adjustment_add(
        AdjustmentInterface $adjustment,
        OrderItemUnitInterface $orderItemUnit1,
        OrderItemUnitInterface $orderItemUnit2
    ): void {
        $orderItemUnit1->getOrderItem()->willReturn($this->getWrappedObject());
        $orderItemUnit1->getTotal()->willReturn(1499);
        $orderItemUnit2->getOrderItem()->willReturn($this->getWrappedObject());
        $orderItemUnit2->getTotal()->willReturn(1499);

        $adjustment->isNeutral()->willReturn(false);
        $adjustment->getAmount()->willReturn(-1000);
        $adjustment->setAdjustable($this)->shouldBeCalled();

        $this->addUnit($orderItemUnit1);
        $this->addUnit($orderItemUnit2);
        $this->addAdjustment($adjustment);
        $this->getTotal()->shouldReturn(1998);
    }

    function it_has_correct_total_after_adjustment_add_and_remove(AdjustmentInterface $adjustment): void
    {
        $adjustment->isNeutral()->willReturn(false);
        $adjustment->getAmount()->willReturn(200);
        $adjustment->setAdjustable($this)->shouldBeCalled();

        $this->addAdjustment($adjustment);
        $this->getTotal()->shouldReturn(200);

        $adjustment->setAdjustable(null)->shouldBeCalled();
        $adjustment->isLocked()->willReturn(false);

        $this->removeAdjustment($adjustment);
        $this->getTotal()->shouldReturn(0);
    }

    function it_has_correct_total_after_neutral_adjustment_add_and_remove(AdjustmentInterface $adjustment): void
    {
        $adjustment->isNeutral()->willReturn(true);
        $adjustment->getAmount()->willReturn(200);
        $adjustment->setAdjustable($this)->shouldBeCalled();

        $this->addAdjustment($adjustment);
        $this->getTotal()->shouldReturn(0);

        $adjustment->setAdjustable(null)->shouldBeCalled();
        $adjustment->isLocked()->willReturn(false);

        $this->removeAdjustment($adjustment);
        $this->getTotal()->shouldReturn(0);
    }

    function it_has_0_total_when_adjustment_decreases_total_under_0(
        AdjustmentInterface $adjustment,
        OrderItemUnitInterface $orderItemUnit1
    ): void {
        $orderItemUnit1->getOrderItem()->willReturn($this->getWrappedObject());
        $orderItemUnit1->getTotal()->willReturn(1499);

        $adjustment->isNeutral()->willReturn(false);
        $adjustment->getAmount()->willReturn(-2000);
        $adjustment->setAdjustable($this)->shouldBeCalled();

        $this->addUnit($orderItemUnit1);
        $this->addAdjustment($adjustment);
        $this->getTotal()->shouldReturn(0);
    }

    function it_has_correct_total_after_unit_price_change(
        OrderItemUnitInterface $orderItemUnit1,
        OrderItemUnitInterface $orderItemUnit2
    ): void {
        $orderItemUnit1->getOrderItem()->willReturn($this->getWrappedObject());
        $orderItemUnit1->getTotal()->willReturn(0, 100);
        $orderItemUnit2->getOrderItem()->willReturn($this->getWrappedObject());
        $orderItemUnit2->getTotal()->willReturn(0, 100);

        $this->addUnit($orderItemUnit1);
        $this->addUnit($orderItemUnit2);

        $this->setUnitPrice(100);
        $this->getTotal()->shouldReturn(200);
    }

    function it_has_correct_total_after_order_item_unit_total_change(
        OrderItemUnitInterface $orderItemUnit1,
        OrderItemUnitInterface $orderItemUnit2
    ): void {
        $orderItemUnit1->getOrderItem()->willReturn($this->getWrappedObject());
        $orderItemUnit1->getTotal()->willReturn(0);
        $orderItemUnit2->getOrderItem()->willReturn($this->getWrappedObject());
        $orderItemUnit2->getTotal()->willReturn(0, 100);

        $this->addUnit($orderItemUnit1);
        $this->addUnit($orderItemUnit2);

        $this->getTotal()->shouldReturn(0);
        $this->recalculateUnitsTotal();
        $this->getTotal()->shouldReturn(100);
    }

    function it_has_correct_total_after_adjustment_amount_change(
        AdjustmentInterface $adjustment1,
        AdjustmentInterface $adjustment2
    ): void {
        $adjustment1->getAmount()->willReturn(100);
        $adjustment1->isNeutral()->willReturn(false);
        $adjustment1->setAdjustable($this)->shouldBeCalled();
        $adjustment2->getAmount()->willReturn(500, 300);
        $adjustment2->isNeutral()->willReturn(false);
        $adjustment2->setAdjustable($this)->shouldBeCalled();

        $this->addAdjustment($adjustment1);
        $this->addAdjustment($adjustment2);

        $this->getTotal()->shouldReturn(600);
        $this->recalculateAdjustmentsTotal();
        $this->getTotal()->shouldReturn(400);
    }

    function it_returns_correct_adjustments_total(
        AdjustmentInterface $adjustment1,
        AdjustmentInterface $adjustment2
    ): void {
        $adjustment1->getAmount()->willReturn(100);
        $adjustment1->isNeutral()->willReturn(false);
        $adjustment1->setAdjustable($this)->shouldBeCalled();
        $adjustment2->getAmount()->willReturn(500);
        $adjustment2->isNeutral()->willReturn(false);
        $adjustment2->setAdjustable($this)->shouldBeCalled();

        $this->addAdjustment($adjustment1);
        $this->addAdjustment($adjustment2);

        $this->getAdjustmentsTotal()->shouldReturn(600);
    }

    function it_returns_correct_adjustments_total_by_type(
        AdjustmentInterface $adjustment1,
        AdjustmentInterface $adjustment2,
        AdjustmentInterface $adjustment3
    ): void {
        $adjustment1->getType()->willReturn('tax');
        $adjustment1->getAmount()->willReturn(200);
        $adjustment1->isNeutral()->willReturn(false);
        $adjustment1->setAdjustable($this)->shouldBeCalled();
        $adjustment2->getType()->willReturn('tax');
        $adjustment2->getAmount()->willReturn(-50);
        $adjustment2->isNeutral()->willReturn(false);
        $adjustment2->setAdjustable($this)->shouldBeCalled();

        $adjustment3->getType()->willReturn('promotion');
        $adjustment3->getAmount()->willReturn(-1000);
        $adjustment3->isNeutral()->willReturn(false);
        $adjustment3->setAdjustable($this)->shouldBeCalled();

        $this->addAdjustment($adjustment1);
        $this->addAdjustment($adjustment2);
        $this->addAdjustment($adjustment3);

        $this->getAdjustmentsTotal('tax')->shouldReturn(150);
        $this->getAdjustmentsTotal('promotion')->shouldReturn(-1000);
        $this->getAdjustmentsTotal('any')->shouldReturn(0);
    }

    function it_returns_correct_adjustments_total_recursively(
        AdjustmentInterface $adjustment1,
        AdjustmentInterface $taxAdjustment1,
        AdjustmentInterface $taxAdjustment2,
        OrderItemUnitInterface $orderItemUnit1,
        OrderItemUnitInterface $orderItemUnit2
    ): void {
        $adjustment1->getAmount()->willReturn(200);
        $adjustment1->isNeutral()->willReturn(false);
        $adjustment1->setAdjustable($this)->shouldBeCalled();

        $taxAdjustment1->getAmount()->willReturn(150);
        $taxAdjustment1->isNeutral()->willReturn(false);
        $taxAdjustment2->getAmount()->willReturn(100);
        $taxAdjustment2->isNeutral()->willReturn(false);

        $orderItemUnit1->getOrderItem()->willReturn($this->getWrappedObject());
        $orderItemUnit1->getTotal()->willReturn(500);
        $orderItemUnit1->getAdjustments(null)->willReturn(new ArrayCollection([$taxAdjustment1->getWrappedObject()]));
        $orderItemUnit2->getOrderItem()->willReturn($this->getWrappedObject());
        $orderItemUnit2->getTotal()->willReturn(300);
        $orderItemUnit2->getAdjustments(null)->willReturn(new ArrayCollection([$taxAdjustment2->getWrappedObject()]));

        $this->addAdjustment($adjustment1);
        $this->addUnit($orderItemUnit1);
        $this->addUnit($orderItemUnit2);

        $this->getAdjustmentsTotalRecursively()->shouldReturn(450);
    }

    function it_returns_correct_adjustments_total_by_type_recursively(
        AdjustmentInterface $adjustment1,
        AdjustmentInterface $promotionAdjustment,
        AdjustmentInterface $taxAdjustment1,
        AdjustmentInterface $taxAdjustment2,
        OrderItemUnitInterface $orderItemUnit1,
        OrderItemUnitInterface $orderItemUnit2
    ): void {
        $adjustment1->getType()->willReturn('tax');
        $adjustment1->getAmount()->willReturn(200);
        $adjustment1->isNeutral()->willReturn(false);
        $adjustment1->setAdjustable($this)->shouldBeCalled();

        $promotionAdjustment->getAmount()->willReturn(30);
        $promotionAdjustment->isNeutral()->willReturn(false);
        $taxAdjustment1->getAmount()->willReturn(150);
        $taxAdjustment1->isNeutral()->willReturn(false);
        $taxAdjustment2->getAmount()->willReturn(100);
        $taxAdjustment2->isNeutral()->willReturn(false);

        $orderItemUnit1->getOrderItem()->willReturn($this->getWrappedObject());
        $orderItemUnit1->getTotal()->willReturn(500);
        $orderItemUnit1->getAdjustments('tax')->willReturn(new ArrayCollection([$taxAdjustment1->getWrappedObject()]));
        $orderItemUnit1->getAdjustments('promotion')->willReturn(new ArrayCollection([$promotionAdjustment->getWrappedObject()]));
        $orderItemUnit2->getOrderItem()->willReturn($this->getWrappedObject());
        $orderItemUnit2->getTotal()->willReturn(300);
        $orderItemUnit2->getAdjustments('tax')->willReturn(new ArrayCollection([$taxAdjustment2->getWrappedObject()]));
        $orderItemUnit2->getAdjustments('promotion')->willReturn(new ArrayCollection());

        $this->addAdjustment($adjustment1);
        $this->addUnit($orderItemUnit1);
        $this->addUnit($orderItemUnit2);

        $this->getAdjustmentsTotalRecursively('tax')->shouldReturn(450);
        $this->getAdjustmentsTotalRecursively('promotion')->shouldReturn(30);
    }

    function it_can_be_immutable(): void
    {
        $this->setImmutable(true);
        $this->isImmutable()->shouldReturn(true);
    }
}


1			<?php
2
3			/*
4			* This file is part of the Sylius package.
5			*
6			* (c) Paweł Jędrzejewski
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			declare(strict_types=1);
13
14			namespace spec\Sylius\Component\Order\Model;
15
16			use Doctrine\Common\Collections\ArrayCollection;
17			use Doctrine\Common\Collections\Collection;
18			use PhpSpec\ObjectBehavior;
19			use Sylius\Component\Order\Model\AdjustableInterface;
20			use Sylius\Component\Order\Model\AdjustmentInterface;
21			use Sylius\Component\Order\Model\OrderInterface;
22			use Sylius\Component\Order\Model\OrderItemInterface;
23			use Sylius\Component\Order\Model\OrderItemUnitInterface;
24
25			/**
26			* @author Paweł Jędrzejewski <[email protected]>
27			* @author Michał Marcinkowski <[email protected]>
28			*/
29			final class OrderItemSpec extends ObjectBehavior
30			{
31			function it_implements_an_order_item_interface(): void
32			{
33			$this->shouldImplement(OrderItemInterface::class);
34			}
35
36			function it_implements_an_adjustable_interface(): void
37			{
38			$this->shouldImplement(AdjustableInterface::class);
39			}
40
41			function it_has_no_id_by_default(): void
42			{
43			$this->getId()->shouldReturn(null);
44			}
45
46			function it_does_not_belong_to_an_order_by_default(): void
47			{
48			$this->getOrder()->shouldReturn(null);
49			}
50
51			function it_allows_assigning_itself_to_an_order(OrderInterface $order): void
52			{
53			$order->hasItem($this)->willReturn(false);
54			$order->addItem($this)->shouldBeCalled();
55
56			$this->setOrder($order);
57			$this->getOrder()->shouldReturn($order);
58			}
59
60			function it_allows_detaching_itself_from_an_order(OrderInterface $order): void
61			{
62			$order->hasItem($this)->willReturn(false);
63			$order->addItem($this)->shouldBeCalled();
64
65			$this->setOrder($order);
66			$this->getOrder()->shouldReturn($order);
67
68			$order->hasItem($this)->willReturn(true);
69			$order->removeItem($this)->shouldBeCalled();
70
71			$this->setOrder(null);
72			$this->getOrder()->shouldReturn(null);
73			}
74
75			function it_does_not_set_order_if_it_is_already_set(OrderInterface $order): void
76			{
77			$order->hasItem($this)->willReturn(false);
78			$order->addItem($this)->shouldBeCalled();
79			$this->setOrder($order);
80			$this->getOrder()->shouldReturn($order);
81
82			$order->hasItem($this)->willReturn(true);
83			$this->setOrder($order);
84			$this->getOrder()->shouldReturn($order);
85			}
86
87			function it_has_quantity_equal_to_0_by_default(): void
88			{
89			$this->getQuantity()->shouldReturn(0);
90			}
91
92			function it_has_unit_price_equal_to_0_by_default(): void
93			{
94			$this->getUnitPrice()->shouldReturn(0);
95			}
96
97			function its_unit_price_should_accept_only_integer(): void
98			{
99			$this->setUnitPrice(4498);
100			$this->getUnitPrice()->shouldReturn(4498);
101			}
102
103			function it_has_total_equal_to_0_by_default(): void
104			{
105			$this->getTotal()->shouldReturn(0);
106			}
107
108			function it_initializes_adjustments_collection_by_default(): void
109			{
110			$this->getAdjustments()->shouldHaveType(Collection::class);
111			}
112
113			function it_returns_adjustments_recursively(
114			AdjustmentInterface $itemAdjustment,
115			AdjustmentInterface $unitAdjustment1,
116			AdjustmentInterface $unitAdjustment2,
117			OrderItemUnitInterface $unit1,
118			OrderItemUnitInterface $unit2
119			): void {
120			$unit1->getOrderItem()->willReturn($this);
121			$unit1->getTotal()->willReturn(100);
122			$unit1->getAdjustments(null)->willReturn(new ArrayCollection([$unitAdjustment1->getWrappedObject()]));
123
124			$unit2->getOrderItem()->willReturn($this);
125			$unit2->getTotal()->willReturn(100);
126			$unit2->getAdjustments(null)->willReturn(new ArrayCollection([$unitAdjustment2->getWrappedObject()]));
127
128			$this->addUnit($unit1);
129			$this->addUnit($unit2);
130
131			$itemAdjustment->setAdjustable($this)->shouldBeCalled();
132			$itemAdjustment->isNeutral()->willReturn(true);
133
134			$this->addAdjustment($itemAdjustment);
135
136			$this->getAdjustmentsRecursively()->shouldIterateAs([$itemAdjustment, $unitAdjustment1, $unitAdjustment2]);
137			}
138
139			function it_adds_and_removes_units(OrderItemUnitInterface $orderItemUnit1, OrderItemUnitInterface $orderItemUnit2): void
140			{
141			$orderItemUnit1->getOrderItem()->willReturn($this->getWrappedObject());
142			$orderItemUnit1->getTotal()->willReturn(0);
143			$orderItemUnit2->getOrderItem()->willReturn($this->getWrappedObject());
144			$orderItemUnit2->getTotal()->willReturn(0);
145			$this->getUnits()->shouldHaveType(Collection::class);
146
147			$this->addUnit($orderItemUnit1);
148			$this->addUnit($orderItemUnit2);
149			$this->hasUnit($orderItemUnit1)->shouldReturn(true);
150			$this->hasUnit($orderItemUnit2)->shouldReturn(true);
151
152			$this->removeUnit($orderItemUnit1);
153			$this->hasUnit($orderItemUnit1)->shouldReturn(false);
154			$this->hasUnit($orderItemUnit2)->shouldReturn(true);
155			}
156
157			function it_adds_only_unit_that_is_assigned_to_it(OrderItemUnitInterface $orderItemUnit1, OrderItemInterface $orderItem): void
158			{
159			$orderItemUnit1->getOrderItem()->willReturn($orderItem);
160			$this
161			->shouldThrow(new \LogicException('This order item unit is assigned to a different order item.'))
162			->duringAddUnit($orderItemUnit1)
163			;
164			}
165
166			function it_recalculates_units_total_on_unit_price_change(
167			OrderItemUnitInterface $orderItemUnit1,
168			OrderItemUnitInterface $orderItemUnit2
169			): void {
170			$orderItemUnit1->getOrderItem()->willReturn($this->getWrappedObject());
171			$orderItemUnit1->getTotal()->willReturn(0, 100);
172			$orderItemUnit2->getOrderItem()->willReturn($this->getWrappedObject());
173			$orderItemUnit2->getTotal()->willReturn(0, 100);
174
175			$this->addUnit($orderItemUnit1);
176			$this->addUnit($orderItemUnit2);
177
178			$this->setUnitPrice(100);
179			}
180
181			function it_adds_adjustments_properly(AdjustmentInterface $adjustment): void
182			{
183			$adjustment->isNeutral()->willReturn(true);
184			$adjustment->setAdjustable($this)->shouldBeCalled();
185
186			$this->hasAdjustment($adjustment)->shouldReturn(false);
187			$this->addAdjustment($adjustment);
188			$this->hasAdjustment($adjustment)->shouldReturn(true);
189			}
190
191			function it_removes_adjustments_properly(AdjustmentInterface $adjustment): void
192			{
193			$adjustment->isNeutral()->willReturn(true);
194			$adjustment->setAdjustable($this)->shouldBeCalled();
195
196			$this->hasAdjustment($adjustment)->shouldReturn(false);
197			$this->addAdjustment($adjustment);
198			$this->hasAdjustment($adjustment)->shouldReturn(true);
199
200			$adjustment->setAdjustable(null)->shouldBeCalled();
201			$adjustment->isLocked()->willReturn(false);
202
203			$this->removeAdjustment($adjustment);
204			$this->hasAdjustment($adjustment)->shouldReturn(false);
205			}
206
207			function it_has_correct_total_based_on_unit_items(
208			OrderItemUnitInterface $orderItemUnit1,
209			OrderItemUnitInterface $orderItemUnit2
210			): void {
211			$orderItemUnit1->getOrderItem()->willReturn($this->getWrappedObject());
212			$orderItemUnit1->getTotal()->willReturn(1499);
213			$orderItemUnit2->getOrderItem()->willReturn($this->getWrappedObject());
214			$orderItemUnit2->getTotal()->willReturn(1499);
215
216			$this->addUnit($orderItemUnit1);
217			$this->addUnit($orderItemUnit2);
218			$this->getTotal()->shouldReturn(2998);
219			}
220
221			function it_has_correct_total_after_unit_item_remove(
222			OrderItemUnitInterface $orderItemUnit1,
223			OrderItemUnitInterface $orderItemUnit2
224			): void {
225			$orderItemUnit1->getOrderItem()->willReturn($this->getWrappedObject());
226			$orderItemUnit1->getTotal()->willReturn(2000);
227			$orderItemUnit2->getOrderItem()->willReturn($this->getWrappedObject());
228			$orderItemUnit2->getTotal()->willReturn(1000);
229
230			$this->addUnit($orderItemUnit1);
231			$this->addUnit($orderItemUnit2);
232			$this->getTotal()->shouldReturn(3000);
233
234			$this->removeUnit($orderItemUnit2);
235			$this->getTotal()->shouldReturn(2000);
236			}
237
238			function it_has_correct_total_after_negative_adjustment_add(
239			AdjustmentInterface $adjustment,
240			OrderItemUnitInterface $orderItemUnit1,
241			OrderItemUnitInterface $orderItemUnit2
242			): void {
243			$orderItemUnit1->getOrderItem()->willReturn($this->getWrappedObject());
244			$orderItemUnit1->getTotal()->willReturn(1499);
245			$orderItemUnit2->getOrderItem()->willReturn($this->getWrappedObject());
246			$orderItemUnit2->getTotal()->willReturn(1499);
247
248			$adjustment->isNeutral()->willReturn(false);
249			$adjustment->getAmount()->willReturn(-1000);
250			$adjustment->setAdjustable($this)->shouldBeCalled();
251
252			$this->addUnit($orderItemUnit1);
253			$this->addUnit($orderItemUnit2);
254			$this->addAdjustment($adjustment);
255			$this->getTotal()->shouldReturn(1998);
256			}
257
258			function it_has_correct_total_after_adjustment_add_and_remove(AdjustmentInterface $adjustment): void
259			{
260			$adjustment->isNeutral()->willReturn(false);
261			$adjustment->getAmount()->willReturn(200);
262			$adjustment->setAdjustable($this)->shouldBeCalled();
263
264			$this->addAdjustment($adjustment);
265			$this->getTotal()->shouldReturn(200);
266
267			$adjustment->setAdjustable(null)->shouldBeCalled();
268			$adjustment->isLocked()->willReturn(false);
269
270			$this->removeAdjustment($adjustment);
271			$this->getTotal()->shouldReturn(0);
272			}
273
274			function it_has_correct_total_after_neutral_adjustment_add_and_remove(AdjustmentInterface $adjustment): void
275			{
276			$adjustment->isNeutral()->willReturn(true);
277			$adjustment->getAmount()->willReturn(200);
278			$adjustment->setAdjustable($this)->shouldBeCalled();
279
280			$this->addAdjustment($adjustment);
281			$this->getTotal()->shouldReturn(0);
282
283			$adjustment->setAdjustable(null)->shouldBeCalled();
284			$adjustment->isLocked()->willReturn(false);
285
286			$this->removeAdjustment($adjustment);
287			$this->getTotal()->shouldReturn(0);
288			}
289
290			function it_has_0_total_when_adjustment_decreases_total_under_0(
291			AdjustmentInterface $adjustment,
292			OrderItemUnitInterface $orderItemUnit1
293			): void {
294			$orderItemUnit1->getOrderItem()->willReturn($this->getWrappedObject());
295			$orderItemUnit1->getTotal()->willReturn(1499);
296
297			$adjustment->isNeutral()->willReturn(false);
298			$adjustment->getAmount()->willReturn(-2000);
299			$adjustment->setAdjustable($this)->shouldBeCalled();
300
301			$this->addUnit($orderItemUnit1);
302			$this->addAdjustment($adjustment);
303			$this->getTotal()->shouldReturn(0);
304			}
305
306			function it_has_correct_total_after_unit_price_change(
307			OrderItemUnitInterface $orderItemUnit1,
308			OrderItemUnitInterface $orderItemUnit2
309			): void {
310			$orderItemUnit1->getOrderItem()->willReturn($this->getWrappedObject());
311			$orderItemUnit1->getTotal()->willReturn(0, 100);
312			$orderItemUnit2->getOrderItem()->willReturn($this->getWrappedObject());
313			$orderItemUnit2->getTotal()->willReturn(0, 100);
314
315			$this->addUnit($orderItemUnit1);
316			$this->addUnit($orderItemUnit2);
317
318			$this->setUnitPrice(100);
319			$this->getTotal()->shouldReturn(200);
320			}
321
322			function it_has_correct_total_after_order_item_unit_total_change(
323			OrderItemUnitInterface $orderItemUnit1,
324			OrderItemUnitInterface $orderItemUnit2
325			): void {
326			$orderItemUnit1->getOrderItem()->willReturn($this->getWrappedObject());
327			$orderItemUnit1->getTotal()->willReturn(0);
328			$orderItemUnit2->getOrderItem()->willReturn($this->getWrappedObject());
329			$orderItemUnit2->getTotal()->willReturn(0, 100);
330
331			$this->addUnit($orderItemUnit1);
332			$this->addUnit($orderItemUnit2);
333
334			$this->getTotal()->shouldReturn(0);
335			$this->recalculateUnitsTotal();
336			$this->getTotal()->shouldReturn(100);
337			}
338
339			function it_has_correct_total_after_adjustment_amount_change(
340			AdjustmentInterface $adjustment1,
341			AdjustmentInterface $adjustment2
342			): void {
343			$adjustment1->getAmount()->willReturn(100);
344			$adjustment1->isNeutral()->willReturn(false);
345			$adjustment1->setAdjustable($this)->shouldBeCalled();
346			$adjustment2->getAmount()->willReturn(500, 300);
347			$adjustment2->isNeutral()->willReturn(false);
348			$adjustment2->setAdjustable($this)->shouldBeCalled();
349
350			$this->addAdjustment($adjustment1);
351			$this->addAdjustment($adjustment2);
352
353			$this->getTotal()->shouldReturn(600);
354			$this->recalculateAdjustmentsTotal();
355			$this->getTotal()->shouldReturn(400);
356			}
357
358			function it_returns_correct_adjustments_total(
359			AdjustmentInterface $adjustment1,
360			AdjustmentInterface $adjustment2
361			): void {
362			$adjustment1->getAmount()->willReturn(100);
363			$adjustment1->isNeutral()->willReturn(false);
364			$adjustment1->setAdjustable($this)->shouldBeCalled();
365			$adjustment2->getAmount()->willReturn(500);
366			$adjustment2->isNeutral()->willReturn(false);
367			$adjustment2->setAdjustable($this)->shouldBeCalled();
368
369			$this->addAdjustment($adjustment1);
370			$this->addAdjustment($adjustment2);
371
372			$this->getAdjustmentsTotal()->shouldReturn(600);
373			}
374
375			function it_returns_correct_adjustments_total_by_type(
376			AdjustmentInterface $adjustment1,
377			AdjustmentInterface $adjustment2,
378			AdjustmentInterface $adjustment3
379			): void {
380			$adjustment1->getType()->willReturn('tax');
381			$adjustment1->getAmount()->willReturn(200);
382			$adjustment1->isNeutral()->willReturn(false);
383			$adjustment1->setAdjustable($this)->shouldBeCalled();
384			$adjustment2->getType()->willReturn('tax');
385			$adjustment2->getAmount()->willReturn(-50);
386			$adjustment2->isNeutral()->willReturn(false);
387			$adjustment2->setAdjustable($this)->shouldBeCalled();
388
389			$adjustment3->getType()->willReturn('promotion');
390			$adjustment3->getAmount()->willReturn(-1000);
391			$adjustment3->isNeutral()->willReturn(false);
392			$adjustment3->setAdjustable($this)->shouldBeCalled();
393
394			$this->addAdjustment($adjustment1);
395			$this->addAdjustment($adjustment2);
396			$this->addAdjustment($adjustment3);
397
398			$this->getAdjustmentsTotal('tax')->shouldReturn(150);
399			$this->getAdjustmentsTotal('promotion')->shouldReturn(-1000);
400			$this->getAdjustmentsTotal('any')->shouldReturn(0);
401			}
402
403			function it_returns_correct_adjustments_total_recursively(
404			AdjustmentInterface $adjustment1,
405			AdjustmentInterface $taxAdjustment1,
406			AdjustmentInterface $taxAdjustment2,
407			OrderItemUnitInterface $orderItemUnit1,
408			OrderItemUnitInterface $orderItemUnit2
409			): void {
410			$adjustment1->getAmount()->willReturn(200);
411			$adjustment1->isNeutral()->willReturn(false);
412			$adjustment1->setAdjustable($this)->shouldBeCalled();
413
414			$taxAdjustment1->getAmount()->willReturn(150);
415			$taxAdjustment1->isNeutral()->willReturn(false);
416			$taxAdjustment2->getAmount()->willReturn(100);
417			$taxAdjustment2->isNeutral()->willReturn(false);
418
419			$orderItemUnit1->getOrderItem()->willReturn($this->getWrappedObject());
420			$orderItemUnit1->getTotal()->willReturn(500);
421			$orderItemUnit1->getAdjustments(null)->willReturn(new ArrayCollection([$taxAdjustment1->getWrappedObject()]));
422			$orderItemUnit2->getOrderItem()->willReturn($this->getWrappedObject());
423			$orderItemUnit2->getTotal()->willReturn(300);
424			$orderItemUnit2->getAdjustments(null)->willReturn(new ArrayCollection([$taxAdjustment2->getWrappedObject()]));
425
426			$this->addAdjustment($adjustment1);
427			$this->addUnit($orderItemUnit1);
428			$this->addUnit($orderItemUnit2);
429
430			$this->getAdjustmentsTotalRecursively()->shouldReturn(450);
431			}
432
433			function it_returns_correct_adjustments_total_by_type_recursively(
434			AdjustmentInterface $adjustment1,
435			AdjustmentInterface $promotionAdjustment,
436			AdjustmentInterface $taxAdjustment1,
437			AdjustmentInterface $taxAdjustment2,
438			OrderItemUnitInterface $orderItemUnit1,
439			OrderItemUnitInterface $orderItemUnit2
440			): void {
441			$adjustment1->getType()->willReturn('tax');
442			$adjustment1->getAmount()->willReturn(200);
443			$adjustment1->isNeutral()->willReturn(false);
444			$adjustment1->setAdjustable($this)->shouldBeCalled();
445
446			$promotionAdjustment->getAmount()->willReturn(30);
447			$promotionAdjustment->isNeutral()->willReturn(false);
448			$taxAdjustment1->getAmount()->willReturn(150);
449			$taxAdjustment1->isNeutral()->willReturn(false);
450			$taxAdjustment2->getAmount()->willReturn(100);
451			$taxAdjustment2->isNeutral()->willReturn(false);
452
453			$orderItemUnit1->getOrderItem()->willReturn($this->getWrappedObject());
454			$orderItemUnit1->getTotal()->willReturn(500);
455			$orderItemUnit1->getAdjustments('tax')->willReturn(new ArrayCollection([$taxAdjustment1->getWrappedObject()]));
456			$orderItemUnit1->getAdjustments('promotion')->willReturn(new ArrayCollection([$promotionAdjustment->getWrappedObject()]));
457			$orderItemUnit2->getOrderItem()->willReturn($this->getWrappedObject());
458			$orderItemUnit2->getTotal()->willReturn(300);
459			$orderItemUnit2->getAdjustments('tax')->willReturn(new ArrayCollection([$taxAdjustment2->getWrappedObject()]));
460			$orderItemUnit2->getAdjustments('promotion')->willReturn(new ArrayCollection());
461
462			$this->addAdjustment($adjustment1);
463			$this->addUnit($orderItemUnit1);
464			$this->addUnit($orderItemUnit2);
465
466			$this->getAdjustmentsTotalRecursively('tax')->shouldReturn(450);
467			$this->getAdjustmentsTotalRecursively('promotion')->shouldReturn(30);
468			}
469
470			function it_can_be_immutable(): void
471			{
472			$this->setImmutable(true);
473			$this->isImmutable()->shouldReturn(true);
474			}
475			}
476

pamil / Sylius

Push — pull-request/8107 ( aa76b1 )

OrderItemSpec::it_adds_adjustments_properly() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like