Sylius\Behat\Context\Ui\Admin\ManagingCurrenciesContext

Complexity

Total Complexity

25

Size/Duplication

Total Lines	308
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	8

Importance

Changes	6
Bugs	0	Features	4

25 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	13	1
A	iWantToAddNewCurrency()	0	4	1
A	iChoose()	0	4	1
A	iAddIt()	0	4	1
A	currencyShouldAppearInTheStore()	0	9	1
A	iWantToEditThisCurrency()	0	4	1
A	iEnableIt()	0	4	1
A	iDisableIt()	0	4	1
A	iSaveMyChanges()	0	4	1
A	thisCurrencyShouldBeDisabled()	0	9	1
A	thisCurrencyShouldBeEnabled()	0	9	1
A	iChangeExchangeRateTo()	0	4	1
A	iSpecifyExchangeRate()	0	4	1
A	iShouldBeNotifiedThatItHasBeenSuccessfullyCreated()	0	4	1
A	iShouldBeNotifiedThatItHasBeenSuccessfullyEdited()	0	4	1
A	thisCurrencyShouldHaveExchangeRate()	0	12	1
A	theCodeFiledShouldBeDisabled()	0	8	1
A	iShouldBeNotifiedThatCurrencyCodeMustBeUnique()	0	7	1
A	thereShouldStillBeOnlyOneCurrencyWithCode()	0	9	1
A	iShouldBeNotifiedThatExchangeRateIsRequired()	0	9	1
A	theCurrencyShouldNotBeAdded()	0	9	1
A	iRemoveItsExchangeRate()	0	4	1
A	theCurrencyShouldStillHaveExchangeRateEquals()	0	14	1
A	iWantToSeeAllCurrenciesInStore()	0	4	1
A	iShouldSeeCurrenciesInTheList()	0	12	1

<?php

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

namespace Sylius\Behat\Context\Ui\Admin;

use Behat\Behat\Context\Context;
use Sylius\Behat\Page\Admin\Currency\CreatePageInterface;
use Sylius\Behat\Page\Admin\Currency\IndexPageInterface;
use Sylius\Behat\Page\Admin\Currency\UpdatePageInterface;
use Sylius\Behat\Service\CurrentPageResolverInterface;
use Sylius\Behat\Service\NotificationCheckerInterface;
use Sylius\Component\Currency\Model\CurrencyInterface;
use Webmozart\Assert\Assert;

/**
 * @author Anna Walasek <anna.walasek@lakion.com>
 */
final class ManagingCurrenciesContext implements Context
{
    const RESOURCE_NAME = 'currency';

    /**
     * @var IndexPageInterface
     */
    private $indexPage;

    /**
     * @var CreatePageInterface
     */
    private $createPage;

    /**
     * @var UpdatePageInterface
     */
    private $updatePage;

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

    /**
     * @var CurrentPageResolverInterface
     */
    private $currentPageResolver;

    /**
     * @param IndexPageInterface $indexPage
     * @param CreatePageInterface $createPage
     * @param UpdatePageInterface $updatePage
     * @param CurrentPageResolverInterface $currentPageResolver
     * @param NotificationCheckerInterface $notificationChecker
     */
    public function __construct(
        IndexPageInterface $indexPage,
        CreatePageInterface $createPage,
        UpdatePageInterface $updatePage,
        CurrentPageResolverInterface $currentPageResolver,
        NotificationCheckerInterface $notificationChecker
    ) {
        $this->createPage = $createPage;
        $this->indexPage = $indexPage;
        $this->updatePage = $updatePage;
        $this->currentPageResolver = $currentPageResolver;
        $this->notificationChecker = $notificationChecker;
    }

    /**
     * @Given I want to add a new currency
     */
    public function iWantToAddNewCurrency()
    {
        $this->createPage->open();
    }

    /**
     * @When I choose :currencyName
     */
    public function iChoose($currencyName)
    {
        $this->createPage->chooseName($currencyName);
    }

    /**
     * @When I add it
     * @When I try to add it
     */
    public function iAddIt()
    {
        $this->createPage->create();
    }

    /**
     * @Then I should be notified that it has been successfully created
     */
    public function iShouldBeNotifiedThatItHasBeenSuccessfullyCreated()
    {
        $this->notificationChecker->checkCreationNotification(self::RESOURCE_NAME);
    }

    /**
     * @When I specify its exchange rate as :exchangeRate
     */
    public function iSpecifyExchangeRate($exchangeRate)
    {
        $this->createPage->specifyExchangeRate($exchangeRate);
    }

    /**
     * @Then the currency :currency should appear in the store
     * @Then I should see the currency :currency in the list
     */
    public function currencyShouldAppearInTheStore(CurrencyInterface $currency)
    {
        $this->indexPage->open();

        Assert::true(
            $this->indexPage->isResourceOnPage(['code' => $currency->getCode()]),
            sprintf('Currency %s should exist but it does not.', $currency->getCode())
        );
    }

    /**
     * @Given /^I want to edit (this currency)$/
     */
    public function iWantToEditThisCurrency(CurrencyInterface $currency)
    {
        $this->updatePage->open(['id' => $currency->getId()]);
    }

    /**
     * @When I enable it
     */
    public function iEnableIt()
    {
        $this->updatePage->enable();
    }

    /**
     * @When I disable it
     */
    public function iDisableIt()
    {
        $this->updatePage->disable();
    }

    /**
     * @When I save my changes
     * @When I try to save my changes
     */
    public function iSaveMyChanges()
    {
        $this->updatePage->saveChanges();
    }

    /**
     * @Then I should be notified that it has been successfully edited
     */
    public function iShouldBeNotifiedThatItHasBeenSuccessfullyEdited()
    {
        $this->notificationChecker->checkEditionNotification(self::RESOURCE_NAME);
    }

    /**
     * @Then /^(this currency) should be disabled$/
     */
    public function thisCurrencyShouldBeDisabled(CurrencyInterface $currency)
    {
        $this->indexPage->open();

        Assert::true(
            $this->indexPage->isCurrencyDisabled($currency),
            sprintf('Currency %s should be disabled but it is not.', $currency->getCode())
        );
    }

    /**
     * @Then /^(this currency) should be enabled$/
     */
    public function thisCurrencyShouldBeEnabled(CurrencyInterface $currency)
    {
        $this->indexPage->open();

        Assert::true(
            $this->indexPage->isCurrencyEnabled($currency),
            sprintf('Currency %s should be enabled but it is not.', $currency->getCode())
        );
    }

    /**
     * @When I change exchange rate to :exchangeRate
     */
    public function iChangeExchangeRateTo($exchangeRate)
    {
       $this->updatePage->changeExchangeRate($exchangeRate);
    }

    /**
     * @Then this currency should have exchange rate :exchangeRate
     */
    public function thisCurrencyShouldHaveExchangeRate($exchangeRate)
    {
        Assert::eq(
            $exchangeRate,
            $this->updatePage->getExchangeRateValue(),
            sprintf(
                'Currency exchange rate should be equal %s, but was %s.',
                $exchangeRate,
                $this->updatePage->getExchangeRateValue()
            )
        );
    }

    /**
     * @Then the code field should be disabled
     */
    public function theCodeFiledShouldBeDisabled()
    {
        Assert::eq(
            'disabled',
            $this->updatePage->getCodeDisabledAttribute(),
            'Code field should be disabled but is not.'
        );
    }

    /**
     * @Then I should be notified that currency code must be unique
     */
    public function iShouldBeNotifiedThatCurrencyCodeMustBeUnique()
    {
        Assert::true(
            $this->createPage->checkValidationMessageFor('code', 'Currency code must be unique.'),
            'Unique code violation message should appear on page, but it does not.'
        );
    }

    /**
     * @Then there should still be only one currency with :element :code
     */
    public function thereShouldStillBeOnlyOneCurrencyWithCode($element, $codeValue)
    {
        $this->indexPage->open();

        Assert::true(
            $this->indexPage->isResourceOnPage([$element => $codeValue]),
            sprintf('Currency with %s %s cannot be found.', $element, $codeValue)
        );
    }

    /**
     * @Then I should be notified that exchange rate is required
     */
    public function iShouldBeNotifiedThatExchangeRateIsRequired()
    {
        $currentPage = $this->currentPageResolver->getCurrentPageWithForm($this->createPage, $this->updatePage);

        Assert::true(
            $currentPage->checkValidationMessageFor('exchangeRate', 'Please enter exchange rate.'),
            'Currency exchange rate should be required.'
        );
    }

    /**
     * @Then the currency :currencyName should not be added
     */
    public function theCurrencyShouldNotBeAdded($currencyName)
    {
        $this->indexPage->open();

        Assert::false(
            $this->indexPage->isResourceOnPage(['name' => $currencyName]),
            sprintf('Currency with name %s was created, but it should not.', $currencyName)
        );
    }

    /**
     * @When I remove its exchange rate
     */
    public function iRemoveItsExchangeRate()
    {
        $this->updatePage->changeExchangeRate('');
    }

    /**
     * @Then /^(this currency) should still have exchange rate equal to ((\d+)\.(\d+))$/
     */
    public function theCurrencyShouldStillHaveExchangeRateEquals(CurrencyInterface $currency, $exchangeRate)
    {
        $this->updatePage->open(['id' => $currency->getId()]);

        Assert::eq(
            $exchangeRate,
            $this->updatePage->getExchangeRateValue(),
            sprintf(
                'Currency exchange rate should be equal %s, but was %s.',
                $exchangeRate,
                $this->updatePage->getExchangeRateValue()
            )
        );
    }

    /**
     * @Given I browse currencies of the store
     */
    public function iWantToSeeAllCurrenciesInStore()
    {
        $this->indexPage->open();
    }

    /**
     * @Then /^I should see (\d+) currencies in the list$/
     */
    public function iShouldSeeCurrenciesInTheList($amountOfCurrencies)
    {
        Assert::eq(
            $amountOfCurrencies,
            $this->indexPage->countItems(),
            sprintf(
                'Amount of currencies should be equal %d, but was %d.',
                $amountOfCurrencies,
                $this->indexPage->countItems()
            )
        );
    }
}