OrderSpec - Code Metrics - Inspection of "Merge pull request #5353 from pamil/fixtures/produ..." - pamil/Sylius - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (b23e60)

by Kamil

created 2016-06-27 08:10 UTC

OrderSpec B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	470
Duplicated Lines	22.98 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes	1
Bugs	1	Features	0

Metric	Value
wmc	40
c	1
b	1
f	0
lcom	1
cbo	4
dl	108
loc	470
rs	8.2608

40 Methods

Rating	Name	Duplication	Size	Complexity
A	it_is_initializable()	0	4	1
A	it_implements_Sylius_order_interface()	0	4	1
A	it_implements_Sylius_adjustable_interface()	0	4	1
A	it_implements_Sylius_timestampable_interface()	0	4	1
A	it_has_no_id_by_default()	0	4	1
A	it_is_not_completed_by_default()	0	4	1
A	it_can_be_completed()	0	5	1
A	it_is_completed_when_completion_date_is_set()	0	6	1
A	it_has_no_completion_date_by_default()	0	4	1
A	its_completion_date_is_mutable()	0	7	1
A	it_has_no_number_by_default()	0	4	1
A	its_number_is_mutable()	0	5	1
A	it_creates_items_collection_by_default()	0	4	1
A	it_creates_identities_collection_by_default()	0	4	1
A	it_adds_identities_properly()	0	7	1
A	it_adds_items_properly()	0	7	1
A	it_removes_identities_properly()	0	10	1
A	it_removes_items_properly()	0	10	1
A	it_has_items_total_equal_to_0_by_default()	0	4	1
A	it_calculates_correct_items_total()	0	23	1
A	it_creates_adjustments_collection_by_default()	0	4	1
A	it_removes_adjustments_properly()	0	16	1
B	it_returns_adjustments_recursively()	0	25	1
A	it_has_adjustments_total_equal_to_0_by_default()	0	4	1
A	it_calculates_correct_adjustments_total()	0	20	1
A	it_returns_adjustments_total_recursively()	0	22	1
A	it_has_total_equal_to_0_by_default()	0	4	1
A	it_calculates_correct_total_after_items_and_adjustments_changes()	0	48	1
A	it_initializes_creation_date_by_default()	0	4	1
A	it_has_no_last_update_date_by_default()	0	4	1
A	it_is_empty_by_default()	0	5	1
A	it_should_be_able_to_clear_items()	0	8	1
B	it_removes_adjustments_recursively_by_type_properly()	0	27	1
A	it_adds_adjustments_properly()	9	9	1
A	it_removes_adjustments_recursively_properly()	13	13	1
A	it_has_total_quantity()	16	16	1
B	it_calculates_correct_total()	26	26	1
B	it_ignores_neutral_adjustments_when_calculating_total()	26	26	1
A	it_calculates_correct_total_when_adjustment_is_bigger_than_cost()	18	18	1
A	it_has_notes()	0	5	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like OrderSpec often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use OrderSpec, and based on these observations, apply Extract Interface, too.

<?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\Order\Model;

use PhpSpec\ObjectBehavior;
use Prophecy\Argument;
use Sylius\Component\Order\Model\AdjustableInterface;
use Sylius\Component\Order\Model\AdjustmentInterface;
use Sylius\Component\Order\Model\IdentityInterface;
use Sylius\Component\Order\Model\OrderInterface;
use Sylius\Component\Order\Model\OrderItemInterface;
use Sylius\Component\Resource\Model\TimestampableInterface;

/**
 * @author Paweł Jędrzejewski <[email protected]>
 */
class OrderSpec extends ObjectBehavior
{
    function it_is_initializable()
    {
        $this->shouldHaveType('Sylius\Component\Order\Model\Order');
    }

    function it_implements_Sylius_order_interface()

    {
        $this->shouldImplement(OrderInterface::class);
    }

    function it_implements_Sylius_adjustable_interface()

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

    function it_implements_Sylius_timestampable_interface()

    {
        $this->shouldImplement(TimestampableInterface::class);
    }

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

    function it_is_not_completed_by_default()
    {
        $this->shouldNotBeCompleted();
    }

    function it_can_be_completed()
    {
        $this->complete();
        $this->shouldBeCompleted();
    }

    function it_is_completed_when_completion_date_is_set()
    {
        $this->shouldNotBeCompleted();
        $this->setCompletedAt(new \DateTime('2 days ago'));
        $this->shouldBeCompleted();
    }

    function it_has_no_completion_date_by_default()
    {
        $this->getCompletedAt()->shouldReturn(null);
    }

    function its_completion_date_is_mutable()
    {
        $date = new \DateTime('1 hour ago');

        $this->setCompletedAt($date);
        $this->getCompletedAt()->shouldReturn($date);
    }

    function it_has_no_number_by_default()
    {
        $this->getNumber()->shouldReturn(null);
    }

    function its_number_is_mutable()
    {
        $this->setNumber('001351');
        $this->getNumber()->shouldReturn('001351');
    }

    function it_creates_items_collection_by_default()
    {
        $this->getItems()->shouldHaveType('Doctrine\\Common\\Collections\\Collection');
    }

    function it_creates_identities_collection_by_default()
    {
        $this->getIdentities()->shouldHaveType('Doctrine\\Common\\Collections\\Collection');
    }

    function it_adds_identities_properly(IdentityInterface $identity)
    {
        $this->hasIdentity($identity)->shouldReturn(false);

        $this->addIdentity($identity);
        $this->hasIdentity($identity)->shouldReturn(true);
    }

    function it_adds_items_properly(OrderItemInterface $item)
    {
        $this->hasItem($item)->shouldReturn(false);

        $this->addItem($item);
        $this->hasItem($item)->shouldReturn(true);
    }

    function it_removes_identities_properly(IdentityInterface $identity)
    {
        $this->hasIdentity($identity)->shouldReturn(false);

        $this->addIdentity($identity);
        $this->hasIdentity($identity)->shouldReturn(true);

        $this->removeIdentity($identity);
        $this->hasIdentity($identity)->shouldReturn(false);
    }

    function it_removes_items_properly(OrderItemInterface $item)
    {
        $this->hasItem($item)->shouldReturn(false);

        $this->addItem($item);
        $this->hasItem($item)->shouldReturn(true);

        $this->removeItem($item);
        $this->hasItem($item)->shouldReturn(false);
    }

    function it_has_items_total_equal_to_0_by_default()
    {
        $this->getItemsTotal()->shouldReturn(0);
    }

    function it_calculates_correct_items_total(
        OrderItemInterface $item1,
        OrderItemInterface $item2,
        OrderItemInterface $item3
    ) {
        $item1->getTotal()->willReturn(29999);
        $item2->getTotal()->willReturn(45000);
        $item3->getTotal()->willReturn(250);

        $item1->setOrder($this)->shouldBeCalled();
        $item2->setOrder($this)->shouldBeCalled();
        $item3->setOrder($this)->shouldBeCalled();

        $item1->equals(Argument::any())->willReturn(false);
        $item2->equals(Argument::any())->willReturn(false);
        $item3->equals(Argument::any())->willReturn(false);

        $this->addItem($item1);
        $this->addItem($item2);
        $this->addItem($item3);

        $this->getItemsTotal()->shouldReturn(75249);
    }

    function it_creates_adjustments_collection_by_default()
    {
        $this->getAdjustments()->shouldHaveType('Doctrine\Common\Collections\Collection');
    }

    function it_adds_adjustments_properly(AdjustmentInterface $adjustment)

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

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

    function it_removes_adjustments_properly(AdjustmentInterface $adjustment)
    {
        $this->hasAdjustment($adjustment)->shouldReturn(false);

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

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

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

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

    function it_removes_adjustments_recursively_properly(

        AdjustmentInterface $orderAdjustment,
        OrderItemInterface $item
    ) {
        $this->addAdjustment($orderAdjustment);
        $this->addItem($item);

        $item->removeAdjustmentsRecursively(null)->shouldBeCalled();

        $this->removeAdjustmentsRecursively();

        $this->hasAdjustment($orderAdjustment)->shouldReturn(false);
    }

    function it_removes_adjustments_recursively_by_type_properly(
        AdjustmentInterface $orderPromotionAdjustment,

        AdjustmentInterface $orderTaxAdjustment,
        OrderItemInterface $item
    ) {
        $orderPromotionAdjustment->getType()->willReturn('promotion');
        $orderPromotionAdjustment->isNeutral()->willReturn(true);
        $orderPromotionAdjustment->setAdjustable($this)->shouldBeCalled();
        $orderPromotionAdjustment->isLocked()->willReturn(false);

        $orderTaxAdjustment->getType()->willReturn('tax');
        $orderTaxAdjustment->isNeutral()->willReturn(true);
        $orderTaxAdjustment->setAdjustable($this)->shouldBeCalled();
        $orderTaxAdjustment->isLocked()->willReturn(false);

        $this->addAdjustment($orderPromotionAdjustment);
        $this->addAdjustment($orderTaxAdjustment);
        $this->addItem($item);

        $item->removeAdjustmentsRecursively('tax')->shouldBeCalled();
        $orderTaxAdjustment->setAdjustable(null)->shouldBeCalled();

        $this->removeAdjustmentsRecursively('tax');

        $this->hasAdjustment($orderPromotionAdjustment)->shouldReturn(true);
        $this->hasAdjustment($orderTaxAdjustment)->shouldReturn(false);
    }

    function it_returns_adjustments_recursively(
        AdjustmentInterface $orderAdjustment,
        AdjustmentInterface $itemAdjustment1,
        AdjustmentInterface $itemAdjustment2,
        OrderItemInterface $item1,
        OrderItemInterface $item2
    ) {
        $item1->setOrder($this)->shouldBeCalled();
        $item1->getTotal()->willReturn(100);
        $item1->getAdjustmentsRecursively(null)->willReturn([$itemAdjustment1]);

        $item2->setOrder($this)->shouldBeCalled();
        $item2->getTotal()->willReturn(100);
        $item2->getAdjustmentsRecursively(null)->willReturn([$itemAdjustment2]);

        $this->addItem($item1);
        $this->addItem($item2);

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

        $this->addAdjustment($orderAdjustment);

        $this->getAdjustmentsRecursively()->shouldReturn([$orderAdjustment, $itemAdjustment1, $itemAdjustment2]);
    }

    function it_has_adjustments_total_equal_to_0_by_default()
    {
        $this->getAdjustmentsTotal()->shouldReturn(0);
    }

    function it_calculates_correct_adjustments_total(AdjustmentInterface $adjustment1, AdjustmentInterface $adjustment2, AdjustmentInterface $adjustment3)
    {
        $adjustment1->getAmount()->willReturn(10000);
        $adjustment2->getAmount()->willReturn(-4999);
        $adjustment3->getAmount()->willReturn(1929);

        $adjustment1->isNeutral()->willReturn(false);
        $adjustment2->isNeutral()->willReturn(false);
        $adjustment3->isNeutral()->willReturn(false);

        $adjustment1->setAdjustable($this)->shouldBeCalled();
        $adjustment2->setAdjustable($this)->shouldBeCalled();
        $adjustment3->setAdjustable($this)->shouldBeCalled();

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

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

    function it_returns_adjustments_total_recursively(
        AdjustmentInterface $itemAdjustment,
        AdjustmentInterface $orderAdjustment,
        OrderItemInterface $orderItem
    ) {
        $itemAdjustment->getAmount()->willReturn(10000);
        $orderAdjustment->getAmount()->willReturn(5000);

        $itemAdjustment->isNeutral()->willReturn(false);
        $orderAdjustment->isNeutral()->willReturn(false);

        $orderAdjustment->setAdjustable($this)->shouldBeCalled();

        $orderItem->getAdjustmentsRecursively(null)->willReturn([$itemAdjustment]);
        $orderItem->setOrder($this)->shouldBeCalled();
        $orderItem->getTotal()->willReturn(15000);

        $this->addItem($orderItem);
        $this->addAdjustment($orderAdjustment);

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

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

    function it_has_total_quantity(OrderItemInterface $orderItem1, OrderItemInterface $orderItem2)

    {
        $orderItem1->getQuantity()->willReturn(10);
        $orderItem1->setOrder($this)->shouldBeCalled();
        $orderItem1->getTotal()->willReturn(500);

        $orderItem2->getQuantity()->willReturn(30);
        $orderItem2->setOrder($this)->shouldBeCalled();
        $orderItem2->equals($orderItem1)->willReturn(false);
        $orderItem2->getTotal()->willReturn(1000);

        $this->addItem($orderItem1);
        $this->addItem($orderItem2);

        $this->getTotalQuantity()->shouldReturn(40);
    }

    function it_calculates_correct_total(OrderItemInterface $item1, OrderItemInterface $item2, AdjustmentInterface $adjustment1, AdjustmentInterface $adjustment2)

    {
        $item1->getTotal()->willReturn(29999);
        $item2->getTotal()->willReturn(45000);

        $item1->equals(Argument::any())->willReturn(false);
        $item2->equals(Argument::any())->willReturn(false);

        $item1->setOrder($this)->shouldBeCalled();
        $item2->setOrder($this)->shouldBeCalled();

        $adjustment1->isNeutral()->willReturn(false);
        $adjustment1->getAmount()->willReturn(10000);
        $adjustment2->isNeutral()->willReturn(false);
        $adjustment2->getAmount()->willReturn(-4999);

        $adjustment1->setAdjustable($this)->shouldBeCalled();
        $adjustment2->setAdjustable($this)->shouldBeCalled();

        $this->addItem($item1);
        $this->addItem($item2);
        $this->addAdjustment($adjustment1);
        $this->addAdjustment($adjustment2);

        $this->getTotal()->shouldReturn(80000);
    }

    function it_calculates_correct_total_after_items_and_adjustments_changes(
        AdjustmentInterface $adjustment1,
        AdjustmentInterface $adjustment2,
        OrderItemInterface $item1,
        OrderItemInterface $item2,
        OrderItemInterface $item3
    ) {
        $item1->getTotal()->willReturn(29999);
        $item2->getTotal()->willReturn(45000);

        $item1->equals(Argument::any())->willReturn(false);
        $item2->equals(Argument::any())->willReturn(false);

        $item1->setOrder($this)->shouldBeCalled();
        $item2->setOrder($this)->shouldBeCalled();

        $adjustment1->isNeutral()->willReturn(false);
        $adjustment1->getAmount()->willReturn(10000);
        $adjustment1->setAdjustable($this)->shouldBeCalled();

        $this->addItem($item1);
        $this->addItem($item2);
        $this->addAdjustment($adjustment1);

        $this->getTotal()->shouldReturn(84999);

        $item2->setOrder(null)->shouldBeCalled();

        $this->removeItem($item2);

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

        $adjustment2->isNeutral()->willReturn(false);
        $adjustment2->getAmount()->willReturn(-4999);
        $adjustment2->setAdjustable($this)->shouldBeCalled();

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

        $item3->getTotal()->willReturn(55000);
        $item3->equals(Argument::any())->willReturn(false);
        $item3->setOrder($this)->shouldBeCalled();

        $this->addItem($item3);

        $this->getTotal()->shouldReturn(80000);
    }

    function it_ignores_neutral_adjustments_when_calculating_total(OrderItemInterface $item1, OrderItemInterface $item2, AdjustmentInterface $adjustment1, AdjustmentInterface $adjustment2)

    {
        $item1->getTotal()->willReturn(29999);
        $item2->getTotal()->willReturn(45000);

        $item1->equals(Argument::any())->willReturn(false);
        $item2->equals(Argument::any())->willReturn(false);

        $item1->setOrder($this)->shouldBeCalled();
        $item2->setOrder($this)->shouldBeCalled();

        $adjustment1->isNeutral()->willReturn(true);
        $adjustment1->getAmount()->willReturn(10000);
        $adjustment2->isNeutral()->willReturn(false);
        $adjustment2->getAmount()->willReturn(-4999);

        $adjustment1->setAdjustable($this)->shouldBeCalled();
        $adjustment2->setAdjustable($this)->shouldBeCalled();

        $this->addItem($item1);
        $this->addItem($item2);
        $this->addAdjustment($adjustment1);
        $this->addAdjustment($adjustment2);

        $this->getTotal()->shouldReturn(70000);
    }

    function it_calculates_correct_total_when_adjustment_is_bigger_than_cost(OrderItemInterface $item, AdjustmentInterface $adjustment)

    {
        $item->getTotal()->willReturn(45000);

        $item->equals(Argument::any())->willReturn(false);

        $item->setOrder($this)->shouldBeCalled();

        $adjustment->isNeutral()->willReturn(false);
        $adjustment->getAmount()->willReturn(-100000);

        $adjustment->setAdjustable($this)->shouldBeCalled();

        $this->addItem($item);
        $this->addAdjustment($adjustment);

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

    function it_initializes_creation_date_by_default()
    {
        $this->getCreatedAt()->shouldHaveType('DateTime');
    }

    function it_has_no_last_update_date_by_default()
    {
        $this->getUpdatedAt()->shouldReturn(null);
    }

    function it_is_empty_by_default()
    {
        $this->countItems()->shouldReturn(0);
        $this->shouldBeEmpty();
    }

    function it_should_be_able_to_clear_items(OrderItemInterface $item)
    {
        $this->shouldBeEmpty();
        $this->addItem($item);
        $this->countItems()->shouldReturn(1);
        $this->clearItems();
        $this->shouldBeEmpty();
    }

    function it_has_notes()
    {
        $this->setNotes('something squishy');
        $this->getNotes()->shouldReturn('something squishy');
    }
}


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		namespace spec\Sylius\Component\Order\Model;
13
14		use PhpSpec\ObjectBehavior;
15		use Prophecy\Argument;
16		use Sylius\Component\Order\Model\AdjustableInterface;
17		use Sylius\Component\Order\Model\AdjustmentInterface;
18		use Sylius\Component\Order\Model\IdentityInterface;
19		use Sylius\Component\Order\Model\OrderInterface;
20		use Sylius\Component\Order\Model\OrderItemInterface;
21		use Sylius\Component\Resource\Model\TimestampableInterface;
22
23		/**
24		* @author Paweł Jędrzejewski <[email protected]>
25		*/
26		class OrderSpec extends ObjectBehavior
27		{
28		function it_is_initializable()
29		{
30		$this->shouldHaveType('Sylius\Component\Order\Model\Order');
31		}
32
33		function it_implements_Sylius_order_interface()
		0 ignored issues – show Coding Style introduced 2016-06-24 14:31 UTC by Report Bug Copy Issue Report `function it_implements_Sylius_order_interface()` does not seem to conform to the naming convention (`^(?:(?:[a-z]\|__)[a-zA-Z0-9]\|[a-z][a-z0-9_])$`). This check examines a number of code elements and verifies that they conform to the given naming conventions. You can set conventions for local variables, abstract classes, utility classes, constant, properties, methods, parameters, interfaces, classes, exceptions and special methods. Loading history...
34		{
35		$this->shouldImplement(OrderInterface::class);
36		}
37
38		function it_implements_Sylius_adjustable_interface()
		0 ignored issues – show Coding Style introduced 2016-06-24 14:31 UTC by Report Bug Copy Issue Report `function it_implements_S..._adjustable_interface()` does not seem to conform to the naming convention (`^(?:(?:[a-z]\|__)[a-zA-Z0-9]\|[a-z][a-z0-9_])$`). This check examines a number of code elements and verifies that they conform to the given naming conventions. You can set conventions for local variables, abstract classes, utility classes, constant, properties, methods, parameters, interfaces, classes, exceptions and special methods. Loading history...
39		{
40		$this->shouldImplement(AdjustableInterface::class);
41		}
42
43		function it_implements_Sylius_timestampable_interface()
		0 ignored issues – show Coding Style introduced 2016-06-24 14:31 UTC by Report Bug Copy Issue Report `function it_implements_S...mestampable_interface()` does not seem to conform to the naming convention (`^(?:(?:[a-z]\|__)[a-zA-Z0-9]\|[a-z][a-z0-9_])$`). This check examines a number of code elements and verifies that they conform to the given naming conventions. You can set conventions for local variables, abstract classes, utility classes, constant, properties, methods, parameters, interfaces, classes, exceptions and special methods. Loading history...
44		{
45		$this->shouldImplement(TimestampableInterface::class);
46		}
47
48		function it_has_no_id_by_default()
49		{
50		$this->getId()->shouldReturn(null);
51		}
52
53		function it_is_not_completed_by_default()
54		{
55		$this->shouldNotBeCompleted();
56		}
57
58		function it_can_be_completed()
59		{
60		$this->complete();
61		$this->shouldBeCompleted();
62		}
63
64		function it_is_completed_when_completion_date_is_set()
65		{
66		$this->shouldNotBeCompleted();
67		$this->setCompletedAt(new \DateTime('2 days ago'));
68		$this->shouldBeCompleted();
69		}
70
71		function it_has_no_completion_date_by_default()
72		{
73		$this->getCompletedAt()->shouldReturn(null);
74		}
75
76		function its_completion_date_is_mutable()
77		{
78		$date = new \DateTime('1 hour ago');
79
80		$this->setCompletedAt($date);
81		$this->getCompletedAt()->shouldReturn($date);
82		}
83
84		function it_has_no_number_by_default()
85		{
86		$this->getNumber()->shouldReturn(null);
87		}
88
89		function its_number_is_mutable()
90		{
91		$this->setNumber('001351');
92		$this->getNumber()->shouldReturn('001351');
93		}
94
95		function it_creates_items_collection_by_default()
96		{
97		$this->getItems()->shouldHaveType('Doctrine\\Common\\Collections\\Collection');
98		}
99
100		function it_creates_identities_collection_by_default()
101		{
102		$this->getIdentities()->shouldHaveType('Doctrine\\Common\\Collections\\Collection');
103		}
104
105		function it_adds_identities_properly(IdentityInterface $identity)
106		{
107		$this->hasIdentity($identity)->shouldReturn(false);
108
109		$this->addIdentity($identity);
110		$this->hasIdentity($identity)->shouldReturn(true);
111		}
112
113		function it_adds_items_properly(OrderItemInterface $item)
114		{
115		$this->hasItem($item)->shouldReturn(false);
116
117		$this->addItem($item);
118		$this->hasItem($item)->shouldReturn(true);
119		}
120
121		function it_removes_identities_properly(IdentityInterface $identity)
122		{
123		$this->hasIdentity($identity)->shouldReturn(false);
124
125		$this->addIdentity($identity);
126		$this->hasIdentity($identity)->shouldReturn(true);
127
128		$this->removeIdentity($identity);
129		$this->hasIdentity($identity)->shouldReturn(false);
130		}
131
132		function it_removes_items_properly(OrderItemInterface $item)
133		{
134		$this->hasItem($item)->shouldReturn(false);
135
136		$this->addItem($item);
137		$this->hasItem($item)->shouldReturn(true);
138
139		$this->removeItem($item);
140		$this->hasItem($item)->shouldReturn(false);
141		}
142
143		function it_has_items_total_equal_to_0_by_default()
144		{
145		$this->getItemsTotal()->shouldReturn(0);
146		}
147
148		function it_calculates_correct_items_total(
149		OrderItemInterface $item1,
150		OrderItemInterface $item2,
151		OrderItemInterface $item3
152		) {
153		$item1->getTotal()->willReturn(29999);
154		$item2->getTotal()->willReturn(45000);
155		$item3->getTotal()->willReturn(250);
156
157		$item1->setOrder($this)->shouldBeCalled();
158		$item2->setOrder($this)->shouldBeCalled();
159		$item3->setOrder($this)->shouldBeCalled();
160
161		$item1->equals(Argument::any())->willReturn(false);
162		$item2->equals(Argument::any())->willReturn(false);
163		$item3->equals(Argument::any())->willReturn(false);
164
165		$this->addItem($item1);
166		$this->addItem($item2);
167		$this->addItem($item3);
168
169		$this->getItemsTotal()->shouldReturn(75249);
170		}
171
172		function it_creates_adjustments_collection_by_default()
173		{
174		$this->getAdjustments()->shouldHaveType('Doctrine\Common\Collections\Collection');
175		}
176
177	View Code Duplication	function it_adds_adjustments_properly(AdjustmentInterface $adjustment)
		0 ignored issues – show Duplication introduced 2016-06-24 14:31 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
178		{
179		$adjustment->setAdjustable($this)->shouldBeCalled();
180		$adjustment->isNeutral()->willReturn(true);
181
182		$this->hasAdjustment($adjustment)->shouldReturn(false);
183		$this->addAdjustment($adjustment);
184		$this->hasAdjustment($adjustment)->shouldReturn(true);
185		}
186
187		function it_removes_adjustments_properly(AdjustmentInterface $adjustment)
188		{
189		$this->hasAdjustment($adjustment)->shouldReturn(false);
190
191		$adjustment->setAdjustable($this)->shouldBeCalled();
192		$adjustment->isNeutral()->willReturn(true);
193
194		$this->addAdjustment($adjustment);
195		$this->hasAdjustment($adjustment)->shouldReturn(true);
196
197		$adjustment->isLocked()->willReturn(false);
198		$adjustment->setAdjustable(null)->shouldBeCalled();
199		$this->removeAdjustment($adjustment);
200
201		$this->hasAdjustment($adjustment)->shouldReturn(false);
202		}
203
204	View Code Duplication	function it_removes_adjustments_recursively_properly(
		0 ignored issues – show Duplication introduced 2016-06-24 14:31 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
205		AdjustmentInterface $orderAdjustment,
206		OrderItemInterface $item
207		) {
208		$this->addAdjustment($orderAdjustment);
209		$this->addItem($item);
210
211		$item->removeAdjustmentsRecursively(null)->shouldBeCalled();
212
213		$this->removeAdjustmentsRecursively();
214
215		$this->hasAdjustment($orderAdjustment)->shouldReturn(false);
216		}
217
218		function it_removes_adjustments_recursively_by_type_properly(
219		AdjustmentInterface $orderPromotionAdjustment,
		0 ignored issues – show Comprehensibility Naming introduced 2016-06-24 14:31 UTC by Report Bug Copy Issue Report The variable name `$orderPromotionAdjustment` exceeds the maximum configured length of `20`. Very long variable names usually make code harder to read. It is therefore recommended not to make variable names too verbose. Loading history...
220		AdjustmentInterface $orderTaxAdjustment,
221		OrderItemInterface $item
222		) {
223		$orderPromotionAdjustment->getType()->willReturn('promotion');
224		$orderPromotionAdjustment->isNeutral()->willReturn(true);
225		$orderPromotionAdjustment->setAdjustable($this)->shouldBeCalled();
226		$orderPromotionAdjustment->isLocked()->willReturn(false);
227
228		$orderTaxAdjustment->getType()->willReturn('tax');
229		$orderTaxAdjustment->isNeutral()->willReturn(true);
230		$orderTaxAdjustment->setAdjustable($this)->shouldBeCalled();
231		$orderTaxAdjustment->isLocked()->willReturn(false);
232
233		$this->addAdjustment($orderPromotionAdjustment);
234		$this->addAdjustment($orderTaxAdjustment);
235		$this->addItem($item);
236
237		$item->removeAdjustmentsRecursively('tax')->shouldBeCalled();
238		$orderTaxAdjustment->setAdjustable(null)->shouldBeCalled();
239
240		$this->removeAdjustmentsRecursively('tax');
241
242		$this->hasAdjustment($orderPromotionAdjustment)->shouldReturn(true);
243		$this->hasAdjustment($orderTaxAdjustment)->shouldReturn(false);
244		}
245
246		function it_returns_adjustments_recursively(
247		AdjustmentInterface $orderAdjustment,
248		AdjustmentInterface $itemAdjustment1,
249		AdjustmentInterface $itemAdjustment2,
250		OrderItemInterface $item1,
251		OrderItemInterface $item2
252		) {
253		$item1->setOrder($this)->shouldBeCalled();
254		$item1->getTotal()->willReturn(100);
255		$item1->getAdjustmentsRecursively(null)->willReturn([$itemAdjustment1]);
256
257		$item2->setOrder($this)->shouldBeCalled();
258		$item2->getTotal()->willReturn(100);
259		$item2->getAdjustmentsRecursively(null)->willReturn([$itemAdjustment2]);
260
261		$this->addItem($item1);
262		$this->addItem($item2);
263
264		$orderAdjustment->setAdjustable($this)->shouldBeCalled();
265		$orderAdjustment->isNeutral()->willReturn(true);
266
267		$this->addAdjustment($orderAdjustment);
268
269		$this->getAdjustmentsRecursively()->shouldReturn([$orderAdjustment, $itemAdjustment1, $itemAdjustment2]);
270		}
271
272		function it_has_adjustments_total_equal_to_0_by_default()
273		{
274		$this->getAdjustmentsTotal()->shouldReturn(0);
275		}
276
277		function it_calculates_correct_adjustments_total(AdjustmentInterface $adjustment1, AdjustmentInterface $adjustment2, AdjustmentInterface $adjustment3)
278		{
279		$adjustment1->getAmount()->willReturn(10000);
280		$adjustment2->getAmount()->willReturn(-4999);
281		$adjustment3->getAmount()->willReturn(1929);
282
283		$adjustment1->isNeutral()->willReturn(false);
284		$adjustment2->isNeutral()->willReturn(false);
285		$adjustment3->isNeutral()->willReturn(false);
286
287		$adjustment1->setAdjustable($this)->shouldBeCalled();
288		$adjustment2->setAdjustable($this)->shouldBeCalled();
289		$adjustment3->setAdjustable($this)->shouldBeCalled();
290
291		$this->addAdjustment($adjustment1);
292		$this->addAdjustment($adjustment2);
293		$this->addAdjustment($adjustment3);
294
295		$this->getAdjustmentsTotal()->shouldReturn(6930);
296		}
297
298		function it_returns_adjustments_total_recursively(
299		AdjustmentInterface $itemAdjustment,
300		AdjustmentInterface $orderAdjustment,
301		OrderItemInterface $orderItem
302		) {
303		$itemAdjustment->getAmount()->willReturn(10000);
304		$orderAdjustment->getAmount()->willReturn(5000);
305
306		$itemAdjustment->isNeutral()->willReturn(false);
307		$orderAdjustment->isNeutral()->willReturn(false);
308
309		$orderAdjustment->setAdjustable($this)->shouldBeCalled();
310
311		$orderItem->getAdjustmentsRecursively(null)->willReturn([$itemAdjustment]);
312		$orderItem->setOrder($this)->shouldBeCalled();
313		$orderItem->getTotal()->willReturn(15000);
314
315		$this->addItem($orderItem);
316		$this->addAdjustment($orderAdjustment);
317
318		$this->getAdjustmentsTotalRecursively()->shouldReturn(15000);
319		}
320
321		function it_has_total_equal_to_0_by_default()
322		{
323		$this->getTotal()->shouldReturn(0);
324		}
325
326	View Code Duplication	function it_has_total_quantity(OrderItemInterface $orderItem1, OrderItemInterface $orderItem2)
		0 ignored issues – show Duplication introduced 2016-06-24 14:31 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
327		{
328		$orderItem1->getQuantity()->willReturn(10);
329		$orderItem1->setOrder($this)->shouldBeCalled();
330		$orderItem1->getTotal()->willReturn(500);
331
332		$orderItem2->getQuantity()->willReturn(30);
333		$orderItem2->setOrder($this)->shouldBeCalled();
334		$orderItem2->equals($orderItem1)->willReturn(false);
335		$orderItem2->getTotal()->willReturn(1000);
336
337		$this->addItem($orderItem1);
338		$this->addItem($orderItem2);
339
340		$this->getTotalQuantity()->shouldReturn(40);
341		}
342
343	View Code Duplication	function it_calculates_correct_total(OrderItemInterface $item1, OrderItemInterface $item2, AdjustmentInterface $adjustment1, AdjustmentInterface $adjustment2)
		0 ignored issues – show Duplication introduced 2016-06-24 14:31 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
344		{
345		$item1->getTotal()->willReturn(29999);
346		$item2->getTotal()->willReturn(45000);
347
348		$item1->equals(Argument::any())->willReturn(false);
349		$item2->equals(Argument::any())->willReturn(false);
350
351		$item1->setOrder($this)->shouldBeCalled();
352		$item2->setOrder($this)->shouldBeCalled();
353
354		$adjustment1->isNeutral()->willReturn(false);
355		$adjustment1->getAmount()->willReturn(10000);
356		$adjustment2->isNeutral()->willReturn(false);
357		$adjustment2->getAmount()->willReturn(-4999);
358
359		$adjustment1->setAdjustable($this)->shouldBeCalled();
360		$adjustment2->setAdjustable($this)->shouldBeCalled();
361
362		$this->addItem($item1);
363		$this->addItem($item2);
364		$this->addAdjustment($adjustment1);
365		$this->addAdjustment($adjustment2);
366
367		$this->getTotal()->shouldReturn(80000);
368		}
369
370		function it_calculates_correct_total_after_items_and_adjustments_changes(
371		AdjustmentInterface $adjustment1,
372		AdjustmentInterface $adjustment2,
373		OrderItemInterface $item1,
374		OrderItemInterface $item2,
375		OrderItemInterface $item3
376		) {
377		$item1->getTotal()->willReturn(29999);
378		$item2->getTotal()->willReturn(45000);
379
380		$item1->equals(Argument::any())->willReturn(false);
381		$item2->equals(Argument::any())->willReturn(false);
382
383		$item1->setOrder($this)->shouldBeCalled();
384		$item2->setOrder($this)->shouldBeCalled();
385
386		$adjustment1->isNeutral()->willReturn(false);
387		$adjustment1->getAmount()->willReturn(10000);
388		$adjustment1->setAdjustable($this)->shouldBeCalled();
389
390		$this->addItem($item1);
391		$this->addItem($item2);
392		$this->addAdjustment($adjustment1);
393
394		$this->getTotal()->shouldReturn(84999);
395
396		$item2->setOrder(null)->shouldBeCalled();
397
398		$this->removeItem($item2);
399
400		$adjustment1->setAdjustable(null)->shouldBeCalled();
401		$adjustment1->isLocked()->willReturn(false);
402
403		$adjustment2->isNeutral()->willReturn(false);
404		$adjustment2->getAmount()->willReturn(-4999);
405		$adjustment2->setAdjustable($this)->shouldBeCalled();
406
407		$this->removeAdjustment($adjustment1);
408		$this->addAdjustment($adjustment2);
409
410		$item3->getTotal()->willReturn(55000);
411		$item3->equals(Argument::any())->willReturn(false);
412		$item3->setOrder($this)->shouldBeCalled();
413
414		$this->addItem($item3);
415
416		$this->getTotal()->shouldReturn(80000);
417		}
418
419	View Code Duplication	function it_ignores_neutral_adjustments_when_calculating_total(OrderItemInterface $item1, OrderItemInterface $item2, AdjustmentInterface $adjustment1, AdjustmentInterface $adjustment2)
		0 ignored issues – show Duplication introduced 2016-06-24 14:31 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
420		{
421		$item1->getTotal()->willReturn(29999);
422		$item2->getTotal()->willReturn(45000);
423
424		$item1->equals(Argument::any())->willReturn(false);
425		$item2->equals(Argument::any())->willReturn(false);
426
427		$item1->setOrder($this)->shouldBeCalled();
428		$item2->setOrder($this)->shouldBeCalled();
429
430		$adjustment1->isNeutral()->willReturn(true);
431		$adjustment1->getAmount()->willReturn(10000);
432		$adjustment2->isNeutral()->willReturn(false);
433		$adjustment2->getAmount()->willReturn(-4999);
434
435		$adjustment1->setAdjustable($this)->shouldBeCalled();
436		$adjustment2->setAdjustable($this)->shouldBeCalled();
437
438		$this->addItem($item1);
439		$this->addItem($item2);
440		$this->addAdjustment($adjustment1);
441		$this->addAdjustment($adjustment2);
442
443		$this->getTotal()->shouldReturn(70000);
444		}
445
446	View Code Duplication	function it_calculates_correct_total_when_adjustment_is_bigger_than_cost(OrderItemInterface $item, AdjustmentInterface $adjustment)
		0 ignored issues – show Duplication introduced 2016-06-24 14:31 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
447		{
448		$item->getTotal()->willReturn(45000);
449
450		$item->equals(Argument::any())->willReturn(false);
451
452		$item->setOrder($this)->shouldBeCalled();
453
454		$adjustment->isNeutral()->willReturn(false);
455		$adjustment->getAmount()->willReturn(-100000);
456
457		$adjustment->setAdjustable($this)->shouldBeCalled();
458
459		$this->addItem($item);
460		$this->addAdjustment($adjustment);
461
462		$this->getTotal()->shouldReturn(0);
463		}
464
465		function it_initializes_creation_date_by_default()
466		{
467		$this->getCreatedAt()->shouldHaveType('DateTime');
468		}
469
470		function it_has_no_last_update_date_by_default()
471		{
472		$this->getUpdatedAt()->shouldReturn(null);
473		}
474
475		function it_is_empty_by_default()
476		{
477		$this->countItems()->shouldReturn(0);
478		$this->shouldBeEmpty();
479		}
480
481		function it_should_be_able_to_clear_items(OrderItemInterface $item)
482		{
483		$this->shouldBeEmpty();
484		$this->addItem($item);
485		$this->countItems()->shouldReturn(1);
486		$this->clearItems();
487		$this->shouldBeEmpty();
488		}
489
490		function it_has_notes()
491		{
492		$this->setNotes('something squishy');
493		$this->getNotes()->shouldReturn('something squishy');
494		}
495		}
496

pamil / Sylius