CheckoutCompleteContext::thisPromotionShouldGiveDiscount() - Code Metrics - Inspection of "Keep all prices in the same currency in checkout" - pamil/Sylius - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — checkout-consistent-prices ( af49ca )

by Kamil

created 2019-06-10 12:40 UTC

A

↳ Parent: CheckoutCompleteContext::iShouldNotBeAbleToConfirmOrderBecauseDoesNotBelongsToShippingCategory()

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	2

<?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 Sylius\Behat\Context\Ui\Shop\Checkout;

use Behat\Behat\Context\Context;
use Sylius\Behat\NotificationType;
use Sylius\Behat\Page\Shop\Checkout\CompletePageInterface;
use Sylius\Behat\Service\NotificationCheckerInterface;
use Sylius\Behat\Service\SharedStorageInterface;
use Sylius\Component\Core\Formatter\StringInflector;
use Sylius\Component\Core\Model\PaymentMethodInterface;
use Sylius\Component\Core\Model\ProductInterface;
use Sylius\Component\Core\Model\PromotionInterface;
use Sylius\Component\Core\Model\ShippingMethodInterface;
use Webmozart\Assert\Assert;

final class CheckoutCompleteContext implements Context
{
    /** @var SharedStorageInterface */
    private $sharedStorage;

    /** @var CompletePageInterface */
    private $completePage;

    /** @var NotificationCheckerInterface */
    private $notificationChecker;

    public function __construct(
        SharedStorageInterface $sharedStorage,
        CompletePageInterface $completePage,
        NotificationCheckerInterface $notificationChecker
    ) {
        $this->sharedStorage = $sharedStorage;
        $this->completePage = $completePage;
        $this->notificationChecker = $notificationChecker;
    }

    /**
     * @When I try to open checkout complete page
     * @When I want to complete checkout
     */
    public function iTryToOpenCheckoutCompletePage()
    {
        $this->completePage->tryToOpen();
    }

    /**
     * @When I decide to change the payment method
     */
    public function iGoToThePaymentStep()
    {
        $this->completePage->changePaymentMethod();
    }

    /**
     * @When /^I provide additional note like "([^"]+)"$/
     */
    public function iProvideAdditionalNotesLike($notes)
    {
        $this->sharedStorage->set('additional_note', $notes);
        $this->completePage->addNotes($notes);
    }

    /**
     * @When I return to the checkout summary step
     */
    public function iReturnToTheCheckoutSummaryStep()
    {
        $this->completePage->open();
    }

    /**
     * @Given I have confirmed order
     * @When I confirm my order
     */
    public function iConfirmMyOrder()
    {
        $this->completePage->confirmOrder();
    }

    /**
     * @Then I should be on the checkout complete step
     * @Then I should be on the checkout summary step
     */
    public function iShouldBeOnTheCheckoutCompleteStep()
    {
        $this->completePage->verify();
    }

    /**
     * @Then my order's shipping address should be to :fullName
     */
    public function iShouldSeeThisShippingAddressAsShippingAddress($fullName)
    {
        $address = $this->sharedStorage->get('shipping_address_' . StringInflector::nameToLowercaseCode($fullName));

        Assert::true($this->completePage->hasShippingAddress($address));
    }

    /**
     * @Then my order's billing address should be to :fullName
     */
    public function iShouldSeeThisBillingAddressAsBillingAddress($fullName)
    {
        $address = $this->sharedStorage->get('billing_address_' . StringInflector::nameToLowercaseCode($fullName));

        Assert::true($this->completePage->hasBillingAddress($address));
    }

    /**
     * @Then address to :fullName should be used for both shipping and billing of my order
     */
    public function iShouldSeeThisShippingAddressAsShippingAndBillingAddress($fullName)
    {
        $this->iShouldSeeThisShippingAddressAsShippingAddress($fullName);
        $this->iShouldSeeThisBillingAddressAsBillingAddress($fullName);
    }

    /**
     * @Then I should have :quantity :productName products in the cart
     */
    public function iShouldHaveProductsInTheCart($quantity, $productName)
    {
        Assert::true($this->completePage->hasItemWithProductAndQuantity($productName, $quantity));
    }

    /**
     * @Then my order shipping should be :price
     */
    public function myOrderShippingShouldBe($price)
    {
        Assert::true($this->completePage->hasShippingTotal($price));
    }

    /**
     * @Then /^the ("[^"]+" product) should have unit price discounted by ("\$\d+")$/
     */
    public function theShouldHaveUnitPriceDiscountedFor(ProductInterface $product, $amount)
    {
        Assert::true($this->completePage->hasProductDiscountedUnitPriceBy($product, $amount));
    }

    /**
     * @Then /^my order total should be ("(?:\£|\$)\d+(?:\.\d+)?")$/
     */
    public function myOrderTotalShouldBe($total)
    {
        Assert::true($this->completePage->hasOrderTotal($total));
    }

    /**
     * @Then my order promotion total should be :promotionTotal
     */
    public function myOrderPromotionTotalShouldBe($promotionTotal)
    {
        Assert::true($this->completePage->hasPromotionTotal($promotionTotal));
    }

    /**
     * @Then :promotionName should be applied to my order
     */
    public function shouldBeAppliedToMyOrder($promotionName)
    {
        Assert::true($this->completePage->hasOrderPromotion($promotionName));
    }

    /**
     * @Then :promotionName should be applied to my order shipping
     */
    public function shouldBeAppliedToMyOrderShipping($promotionName)
    {
        Assert::true($this->completePage->hasShippingPromotion($promotionName));
    }

    /**
     * @Given my tax total should be :taxTotal
     */
    public function myTaxTotalShouldBe($taxTotal)
    {
        Assert::true($this->completePage->hasTaxTotal($taxTotal));
    }

    /**
     * @Then my order's shipping method should be :shippingMethod
     */
    public function myOrdersShippingMethodShouldBe(ShippingMethodInterface $shippingMethod)
    {
        Assert::true($this->completePage->hasShippingMethod($shippingMethod));
    }

    /**
     * @Then my order's payment method should be :paymentMethod
     */
    public function myOrdersPaymentMethodShouldBe(PaymentMethodInterface $paymentMethod)
    {
        Assert::same($this->completePage->getPaymentMethodName(), $paymentMethod->getName());
    }

    /**
     * @Then the :product product should have unit price :price
     */
    public function theProductShouldHaveUnitPrice(ProductInterface $product, $price)
    {
        Assert::true($this->completePage->hasProductUnitPrice($product, $price));
    }

    /**
     * @Then /^I should be notified that (this product) does not have sufficient stock$/
     */
    public function iShouldBeNotifiedThatThisProductDoesNotHaveSufficientStock(ProductInterface $product)
    {
        Assert::true($this->completePage->hasProductOutOfStockValidationMessage($product));
    }

    /**
     * @Then /^I should not be notified that (this product) does not have sufficient stock$/
     */
    public function iShouldNotBeNotifiedThatThisProductDoesNotHaveSufficientStock(ProductInterface $product)
    {
        Assert::false($this->completePage->hasProductOutOfStockValidationMessage($product));
    }

    /**
     * @Then my order's locale should be :locale
     */
    public function myOrderLocaleShouldBe($locale)
    {
        Assert::true($this->completePage->hasLocale($locale));
    }

    /**
     * @Then I should see :provinceName in the shipping address
     */
    public function iShouldSeeInTheShippingAddress($provinceName)
    {
        Assert::true($this->completePage->hasShippingProvinceName($provinceName));
    }

    /**
     * @Then I should see :provinceName in the billing address
     */
    public function iShouldSeeInTheBillingAddress($provinceName)
    {
        Assert::true($this->completePage->hasBillingProvinceName($provinceName));
    }

    /**
     * @Then I should not see any information about payment method
     */
    public function iShouldNotSeeAnyInformationAboutPaymentMethod()
    {
        Assert::false($this->completePage->hasPaymentMethod());
    }

    /**
     * @Then I should not be able to confirm order because products does not fit :shippingMethod requirements
     */
    public function iShouldNotBeAbleToConfirmOrderBecauseDoesNotBelongsToShippingCategory(ShippingMethodInterface $shippingMethod)
    {
        $this->completePage->confirmOrder();

        Assert::same(
            $this->completePage->getValidationErrors(),
            sprintf(
                'Product does not fit requirements for %s shipping method. Please reselect your shipping method.',
                $shippingMethod->getName()
            )
        );
    }

    /**
     * @Then /^I should be informed that (this promotion) is no longer applied$/
     */
    public function iShouldBeInformedThatMyPromotionIsNoLongerApplied(PromotionInterface $promotion)
    {
        $this->notificationChecker->checkNotification(
            sprintf('You are no longer eligible for this promotion %s.', $promotion->getName()),
            NotificationType::failure()
        );
    }

    /**
     * @Then /^I should be informed that (this payment method) has been disabled$/
     */
    public function iShouldBeInformedThatThisPaymentMethodHasBeenDisabled(PaymentMethodInterface $paymentMethod)
    {
        Assert::same(
            $this->completePage->getValidationErrors(),
            sprintf(
                'This payment method %s has been disabled. Please reselect your payment method.',
                $paymentMethod->getName()
            )
        );
    }

    /**
     * @Then /^I should be informed that (this product) has been disabled$/
     */
    public function iShouldBeInformedThatThisProductHasBeenDisabled(ProductInterface $product)
    {
        Assert::same(
            $this->completePage->getValidationErrors(),
            sprintf(
                'This product %s has been disabled.',
                $product->getName()
            )
        );
    }

    /**
     * @Then I should be informed that order total has been changed
     */
    public function iShouldBeInformedThatOrderTotalHasBeenChanged()
    {
        $this->notificationChecker->checkNotification(
            'Your order total has been changed, check your order information and confirm it again.',
            NotificationType::failure()
        );
    }

    /**
     * @Then /^(this promotion) should give "([^"]+)" discount on shipping$/
     */
    public function thisPromotionShouldGiveDiscountOnShipping(PromotionInterface $promotion, string $discount): void
    {
        Assert::true($this->completePage->hasShippingPromotionWithDiscount($promotion->getName(), $discount));
    }
}


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 Sylius\Behat\Context\Ui\Shop\Checkout;
15
16			use Behat\Behat\Context\Context;
17			use Sylius\Behat\NotificationType;
18			use Sylius\Behat\Page\Shop\Checkout\CompletePageInterface;
19			use Sylius\Behat\Service\NotificationCheckerInterface;
20			use Sylius\Behat\Service\SharedStorageInterface;
21			use Sylius\Component\Core\Formatter\StringInflector;
22			use Sylius\Component\Core\Model\PaymentMethodInterface;
23			use Sylius\Component\Core\Model\ProductInterface;
24			use Sylius\Component\Core\Model\PromotionInterface;
25			use Sylius\Component\Core\Model\ShippingMethodInterface;
26			use Webmozart\Assert\Assert;
27
28			final class CheckoutCompleteContext implements Context
29			{
30			/** @var SharedStorageInterface */
31			private $sharedStorage;
32
33			/** @var CompletePageInterface */
34			private $completePage;
35
36			/** @var NotificationCheckerInterface */
37			private $notificationChecker;
38
39			public function __construct(
40			SharedStorageInterface $sharedStorage,
41			CompletePageInterface $completePage,
42			NotificationCheckerInterface $notificationChecker
43			) {
44			$this->sharedStorage = $sharedStorage;
45			$this->completePage = $completePage;
46			$this->notificationChecker = $notificationChecker;
47			}
48
49			/**
50			* @When I try to open checkout complete page
51			* @When I want to complete checkout
52			*/
53			public function iTryToOpenCheckoutCompletePage()
54			{
55			$this->completePage->tryToOpen();
56			}
57
58			/**
59			* @When I decide to change the payment method
60			*/
61			public function iGoToThePaymentStep()
62			{
63			$this->completePage->changePaymentMethod();
64			}
65
66			/**
67			* @When /^I provide additional note like "([^"]+)"$/
68			*/
69			public function iProvideAdditionalNotesLike($notes)
70			{
71			$this->sharedStorage->set('additional_note', $notes);
72			$this->completePage->addNotes($notes);
73			}
74
75			/**
76			* @When I return to the checkout summary step
77			*/
78			public function iReturnToTheCheckoutSummaryStep()
79			{
80			$this->completePage->open();
81			}
82
83			/**
84			* @Given I have confirmed order
85			* @When I confirm my order
86			*/
87			public function iConfirmMyOrder()
88			{
89			$this->completePage->confirmOrder();
90			}
91
92			/**
93			* @Then I should be on the checkout complete step
94			* @Then I should be on the checkout summary step
95			*/
96			public function iShouldBeOnTheCheckoutCompleteStep()
97			{
98			$this->completePage->verify();
99			}
100
101			/**
102			* @Then my order's shipping address should be to :fullName
103			*/
104			public function iShouldSeeThisShippingAddressAsShippingAddress($fullName)
105			{
106			$address = $this->sharedStorage->get('shipping_address_' . StringInflector::nameToLowercaseCode($fullName));
107
108			Assert::true($this->completePage->hasShippingAddress($address));
109			}
110
111			/**
112			* @Then my order's billing address should be to :fullName
113			*/
114			public function iShouldSeeThisBillingAddressAsBillingAddress($fullName)
115			{
116			$address = $this->sharedStorage->get('billing_address_' . StringInflector::nameToLowercaseCode($fullName));
117
118			Assert::true($this->completePage->hasBillingAddress($address));
119			}
120
121			/**
122			* @Then address to :fullName should be used for both shipping and billing of my order
123			*/
124			public function iShouldSeeThisShippingAddressAsShippingAndBillingAddress($fullName)
125			{
126			$this->iShouldSeeThisShippingAddressAsShippingAddress($fullName);
127			$this->iShouldSeeThisBillingAddressAsBillingAddress($fullName);
128			}
129
130			/**
131			* @Then I should have :quantity :productName products in the cart
132			*/
133			public function iShouldHaveProductsInTheCart($quantity, $productName)
134			{
135			Assert::true($this->completePage->hasItemWithProductAndQuantity($productName, $quantity));
136			}
137
138			/**
139			* @Then my order shipping should be :price
140			*/
141			public function myOrderShippingShouldBe($price)
142			{
143			Assert::true($this->completePage->hasShippingTotal($price));
144			}
145
146			/**
147			* @Then /^the ("[^"]+" product) should have unit price discounted by ("\$\d+")$/
148			*/
149			public function theShouldHaveUnitPriceDiscountedFor(ProductInterface $product, $amount)
150			{
151			Assert::true($this->completePage->hasProductDiscountedUnitPriceBy($product, $amount));
152			}
153
154			/**
155			* @Then /^my order total should be ("(?:\£\|\$)\d+(?:\.\d+)?")$/
156			*/
157			public function myOrderTotalShouldBe($total)
158			{
159			Assert::true($this->completePage->hasOrderTotal($total));
160			}
161
162			/**
163			* @Then my order promotion total should be :promotionTotal
164			*/
165			public function myOrderPromotionTotalShouldBe($promotionTotal)
166			{
167			Assert::true($this->completePage->hasPromotionTotal($promotionTotal));
168			}
169
170			/**
171			* @Then :promotionName should be applied to my order
172			*/
173			public function shouldBeAppliedToMyOrder($promotionName)
174			{
175			Assert::true($this->completePage->hasOrderPromotion($promotionName));
176			}
177
178			/**
179			* @Then :promotionName should be applied to my order shipping
180			*/
181			public function shouldBeAppliedToMyOrderShipping($promotionName)
182			{
183			Assert::true($this->completePage->hasShippingPromotion($promotionName));
184			}
185
186			/**
187			* @Given my tax total should be :taxTotal
188			*/
189			public function myTaxTotalShouldBe($taxTotal)
190			{
191			Assert::true($this->completePage->hasTaxTotal($taxTotal));
192			}
193
194			/**
195			* @Then my order's shipping method should be :shippingMethod
196			*/
197			public function myOrdersShippingMethodShouldBe(ShippingMethodInterface $shippingMethod)
198			{
199			Assert::true($this->completePage->hasShippingMethod($shippingMethod));
200			}
201
202			/**
203			* @Then my order's payment method should be :paymentMethod
204			*/
205			public function myOrdersPaymentMethodShouldBe(PaymentMethodInterface $paymentMethod)
206			{
207			Assert::same($this->completePage->getPaymentMethodName(), $paymentMethod->getName());
208			}
209
210			/**
211			* @Then the :product product should have unit price :price
212			*/
213			public function theProductShouldHaveUnitPrice(ProductInterface $product, $price)
214			{
215			Assert::true($this->completePage->hasProductUnitPrice($product, $price));
216			}
217
218			/**
219			* @Then /^I should be notified that (this product) does not have sufficient stock$/
220			*/
221			public function iShouldBeNotifiedThatThisProductDoesNotHaveSufficientStock(ProductInterface $product)
222			{
223			Assert::true($this->completePage->hasProductOutOfStockValidationMessage($product));
224			}
225
226			/**
227			* @Then /^I should not be notified that (this product) does not have sufficient stock$/
228			*/
229			public function iShouldNotBeNotifiedThatThisProductDoesNotHaveSufficientStock(ProductInterface $product)
230			{
231			Assert::false($this->completePage->hasProductOutOfStockValidationMessage($product));
232			}
233
234			/**
235			* @Then my order's locale should be :locale
236			*/
237			public function myOrderLocaleShouldBe($locale)
238			{
239			Assert::true($this->completePage->hasLocale($locale));
240			}
241
242			/**
243			* @Then I should see :provinceName in the shipping address
244			*/
245			public function iShouldSeeInTheShippingAddress($provinceName)
246			{
247			Assert::true($this->completePage->hasShippingProvinceName($provinceName));
248			}
249
250			/**
251			* @Then I should see :provinceName in the billing address
252			*/
253			public function iShouldSeeInTheBillingAddress($provinceName)
254			{
255			Assert::true($this->completePage->hasBillingProvinceName($provinceName));
256			}
257
258			/**
259			* @Then I should not see any information about payment method
260			*/
261			public function iShouldNotSeeAnyInformationAboutPaymentMethod()
262			{
263			Assert::false($this->completePage->hasPaymentMethod());
264			}
265
266			/**
267			* @Then I should not be able to confirm order because products does not fit :shippingMethod requirements
268			*/
269			public function iShouldNotBeAbleToConfirmOrderBecauseDoesNotBelongsToShippingCategory(ShippingMethodInterface $shippingMethod)
270			{
271			$this->completePage->confirmOrder();
272
273			Assert::same(
274			$this->completePage->getValidationErrors(),
275			sprintf(
276			'Product does not fit requirements for %s shipping method. Please reselect your shipping method.',
277			$shippingMethod->getName()
278			)
279			);
280			}
281
282			/**
283			* @Then /^I should be informed that (this promotion) is no longer applied$/
284			*/
285			public function iShouldBeInformedThatMyPromotionIsNoLongerApplied(PromotionInterface $promotion)
286			{
287			$this->notificationChecker->checkNotification(
288			sprintf('You are no longer eligible for this promotion %s.', $promotion->getName()),
289			NotificationType::failure()
290			);
291			}
292
293			/**
294			* @Then /^I should be informed that (this payment method) has been disabled$/
295			*/
296			public function iShouldBeInformedThatThisPaymentMethodHasBeenDisabled(PaymentMethodInterface $paymentMethod)
297			{
298			Assert::same(
299			$this->completePage->getValidationErrors(),
300			sprintf(
301			'This payment method %s has been disabled. Please reselect your payment method.',
302			$paymentMethod->getName()
303			)
304			);
305			}
306
307			/**
308			* @Then /^I should be informed that (this product) has been disabled$/
309			*/
310			public function iShouldBeInformedThatThisProductHasBeenDisabled(ProductInterface $product)
311			{
312			Assert::same(
313			$this->completePage->getValidationErrors(),
314			sprintf(
315			'This product %s has been disabled.',
316			$product->getName()
317			)
318			);
319			}
320
321			/**
322			* @Then I should be informed that order total has been changed
323			*/
324			public function iShouldBeInformedThatOrderTotalHasBeenChanged()
325			{
326			$this->notificationChecker->checkNotification(
327			'Your order total has been changed, check your order information and confirm it again.',
328			NotificationType::failure()
329			);
330			}
331
332			/**
333			* @Then /^(this promotion) should give "([^"]+)" discount on shipping$/
334			*/
335			public function thisPromotionShouldGiveDiscountOnShipping(PromotionInterface $promotion, string $discount): void
336			{
337			Assert::true($this->completePage->hasShippingPromotionWithDiscount($promotion->getName(), $discount));
338			}
339			}
340

pamil / Sylius

Push — checkout-consistent-prices ( af49ca )

A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like