ManagingChannelsContext::iSpecifyItsCodeAs() - Code Metrics - Inspection of "Update usage of choice type to Symfony3" - pamil/Sylius - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — symfony3 ( 405d0c...88ded0 )

by Kamil

created 2016-11-17 10:13 UTC

ManagingChannelsContext::iSpecifyItsCodeAs() A

↳ Parent: ManagingChannelsContext

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
nc	1
cc	1
eloc	2
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.
 */

namespace Sylius\Behat\Context\Ui\Admin;

use Behat\Behat\Context\Context;
use Sylius\Behat\NotificationType;
use Sylius\Behat\Page\Admin\Channel\CreatePageInterface;
use Sylius\Behat\Page\Admin\Channel\IndexPageInterface;
use Sylius\Behat\Page\Admin\Channel\UpdatePageInterface;
use Sylius\Behat\Service\Resolver\CurrentPageResolverInterface;
use Sylius\Behat\Service\NotificationCheckerInterface;
use Sylius\Component\Core\Formatter\StringInflector;
use Sylius\Component\Core\Model\ChannelInterface;
use Webmozart\Assert\Assert;

/**
 * @author Łukasz Chruściel <[email protected]>
 */
final class ManagingChannelsContext implements Context
{
    /**
     * @var IndexPageInterface
     */
    private $indexPage;

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

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

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

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

    /**
     * @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->indexPage = $indexPage;
        $this->createPage = $createPage;
        $this->updatePage = $updatePage;
        $this->currentPageResolver = $currentPageResolver;
        $this->notificationChecker = $notificationChecker;
    }

    /**
     * @Given I want to create a new channel
     */
    public function iWantToCreateANewChannel()
    {
        $this->createPage->open();
    }

    /**
     * @When I specify its code as :code
     * @When I do not specify its code
     */
    public function iSpecifyItsCodeAs($code = null)
    {
        $this->createPage->specifyCode($code);
    }

    /**
     * @When I name it :name
     * @When I rename it to :name
     * @When I do not name it
     * @When I remove its name
     */
    public function iNameIt($name = null)
    {
        $this->createPage->nameIt($name);
    }

    /**
     * @When I choose :currency as a default currency
     * @When I do not choose default currency
     */
    public function iChooseAsADefaultCurrency($currency = null)
    {
        $this->createPage->chooseDefaultCurrency($currency);
    }

    /**
     * @When I choose :locale as a default locale
     * @When I do not choose default locale
     */
    public function iChooseAsADefaultLocale($locale = null)
    {
        $this->createPage->chooseDefaultLocale($locale);
    }

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

    /**
     * @Then the channel :channelName should appear in the registry
     * @Then the channel :channelName should be in the registry
     */
    public function theChannelShouldAppearInTheRegistry($channelName)
    {
        $this->iWantToBrowseChannels();

        Assert::true($this->indexPage->isSingleResourceOnPage(
            ['nameAndDescription' => $channelName]),
            sprintf('Channel with name %s has not been found.', $channelName)
        );
    }

    /**
     * @Then /^(this channel) should still be in the registry$/
     */
    public function thisChannelShouldAppearInTheRegistry(ChannelInterface $channel)
    {
        $this->theChannelShouldAppearInTheRegistry($channel->getName());
    }

    /**
     * @When I describe it as :description
     */
    public function iDescribeItAs($description)
    {
        $this->createPage->describeItAs($description);
    }

    /**
     * @When I set its hostname as :hostname
     */
    public function iSetItsHostnameAs($hostname)
    {
        $this->createPage->setHostname($hostname);
    }

    /**
     * @When I define its color as :color
     */
    public function iDefineItsColorAs($color)
    {
        $this->createPage->defineColor($color);
    }

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

    /**
     * @When I disable it
     */
    public function iDisableIt()
    {
        $currentPage = $this->currentPageResolver->getCurrentPageWithForm([$this->createPage, $this->updatePage]);

        $currentPage->disable();
    }

    /**
     * @Then I should be notified that at least one channel has to be defined
     */
    public function iShouldBeNotifiedThatAtLeastOneChannelHasToBeDefinedIsRequired()
    {
        /** @var CreatePageInterface|UpdatePageInterface $currentPage */
        $currentPage = $this->currentPageResolver->getCurrentPageWithForm([$this->createPage, $this->updatePage]);

        Assert::same($currentPage->getValidationMessage('enabled'), 'Must have at least one enabled entity');
    }

    /**
     * @Then channel with :element :value should not be added
     */
    public function channelWithShouldNotBeAdded($element, $value)
    {
        $this->iWantToBrowseChannels();

        Assert::false(
            $this->indexPage->isSingleResourceOnPage([$element => $value]),
            sprintf('Channel with %s "%s" was created, but it should not.', $element, $value)
        );
    }

    /**
     * @Then /^I should be notified that ([^"]+) is required$/
     */
    public function iShouldBeNotifiedThatIsRequired($element)
    {
        /** @var CreatePageInterface|UpdatePageInterface $currentPage */
        $currentPage = $this->currentPageResolver->getCurrentPageWithForm([$this->createPage, $this->updatePage]);

        Assert::same(
            $currentPage->getValidationMessage(StringInflector::nameToCode($element)),
            sprintf('Please enter channel %s.', $element)
        );
    }

    /**
     * @Given I want to modify a channel :channel
     * @Given /^I want to modify (this channel)$/
     */
    public function iWantToModifyChannel(ChannelInterface $channel)
    {
        $this->updatePage->open(['id' => $channel->getId()]);
    }

    /**
     * @Then /^(this channel) name should be "([^"]+)"$/
     * @Then /^(this channel) should still be named "([^"]+)"$/
     */
    public function thisChannelNameShouldBe(ChannelInterface $channel, $channelName)
    {
        $this->iWantToBrowseChannels();

        Assert::true(
            $this->indexPage->isSingleResourceOnPage(
                [
                    'code' => $channel->getCode(),
                    'nameAndDescription' => $channelName,
                ]
            ),
            sprintf('Channel name %s has not been assigned properly.', $channelName)
        );
    }

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

    /**
     * @Then I should be notified that channel with this code already exists
     */
    public function iShouldBeNotifiedThatChannelWithThisCodeAlreadyExists()
    {
        Assert::same($this->createPage->getValidationMessage('code'), 'Channel code has to be unique.');
    }

    /**
     * @Then there should still be only one channel with :element :value
     */
    public function thereShouldStillBeOnlyOneChannelWithCode($element, $value)
    {
        $this->iWantToBrowseChannels();

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

    /**
     * @When /^I want to browse channels$/
     */
    public function iWantToBrowseChannels()
    {
        $this->indexPage->open();
    }

    /**
     * @Then I should see :numberOfChannels channels in the list
     */
    public function iShouldSeeChannelsInTheList($numberOfChannels)
    {
        $foundRows = $this->indexPage->countItems();

        Assert::eq(
            (int) $numberOfChannels,
            $foundRows,
            sprintf('%s rows with channels should appear on page, %s rows has been found', $numberOfChannels, $foundRows)
        );
    }

    /**
     * @Then the code field should be disabled
     */
    public function theCodeFieldShouldBeDisabled()
    {
        Assert::true(
            $this->updatePage->isCodeDisabled(),
            'Code should be immutable, but it does not.'
        );
    }

    /**
     * @Then /^(this channel) should be disabled$/
     */
    public function thisChannelShouldBeDisabled(ChannelInterface $channel)
    {
        $this->assertChannelState($channel, false);
    }

    /**
     * @Then /^(this channel) should be enabled$/
     * @Then channel with name :channel should still be enabled
     */
    public function thisChannelShouldBeEnabled(ChannelInterface $channel)
    {
        $this->assertChannelState($channel, true);
    }

    /**
     * @When I delete channel :channel
     */
    public function iDeleteChannel(ChannelInterface $channel)
    {
        $this->indexPage->open();
        $this->indexPage->deleteResourceOnPage(['nameAndDescription' => $channel->getName()]);
    }

    /**
     * @Then the :channelName channel should no longer exist in the registry
     */
    public function thisChannelShouldNoLongerExistInTheRegistry($channelName)
    {
        Assert::false(
            $this->indexPage->isSingleResourceOnPage(['nameAndDescription' => $channelName]),
            sprintf('Channel with name %s exists but should not.', $channelName)
        );
    }

    /**
     * @Then I should be notified that it cannot be deleted
     */
    public function iShouldBeNotifiedThatItCannotBeDeleted()
    {
        $this->notificationChecker->checkNotification(
            "The channel cannot be deleted. At least one enabled channel is required.",
<?php

$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";

print $doubleQuoted;
            NotificationType::failure()
        );
    }

    /**
     * @When I make it available in :locale
     */
    public function iMakeItAvailableIn($locale)
    {
        $currentPage = $this->currentPageResolver->getCurrentPageWithForm([$this->createPage, $this->updatePage]);

        $currentPage->chooseLocale($locale);
    }

    /**
     * @Then the channel :channel should be available in :locale
     */
    public function theChannelShouldBeAvailableIn(ChannelInterface $channel, $locale)
    {
        $this->updatePage->open(['id' => $channel->getId()]);

        Assert::true(
            $this->updatePage->isLocaleChosen($locale),
            sprintf('Language %s should be selected but it is not', $locale)
        );
    }

    /**
     * @When I allow for paying in :currencyCode
     */
    public function iAllowToPayingForThisChannel($currencyCode)
    {
        $currentPage = $this->currentPageResolver->getCurrentPageWithForm([$this->createPage, $this->updatePage]);

        $currentPage->chooseCurrency($currencyCode);
    }

    /**
     * @Then paying in :currencyCode should be possible for the :channel channel
     */
    public function payingInEuroShouldBePossibleForTheChannel($currencyCode, ChannelInterface $channel)
    {
        $this->updatePage->open(['id' => $channel->getId()]);

        Assert::true(
            $this->updatePage->isCurrencyChosen($currencyCode),
            sprintf('Currency %s should be selected but it is not', $currencyCode)
        );
    }

    /**
     * @When I select the :taxZone as default tax zone
     */
    public function iSelectDefaultTaxZone($taxZone)
    {
        $currentPage = $this->currentPageResolver->getCurrentPageWithForm([$this->createPage, $this->updatePage]);

        $currentPage->chooseDefaultTaxZone($taxZone);
    }

    /**
     * @Given I remove its default tax zone
     */
    public function iRemoveItsDefaultTaxZone()
    {
        $this->updatePage->chooseDefaultTaxZone(null);
    }

    /**
     * @When I select the :taxCalculationStrategy as tax calculation strategy
     */
    public function iSelectTaxCalculationStrategy($taxCalculationStrategy)

    {
        $currentPage = $this->currentPageResolver->getCurrentPageWithForm([$this->createPage, $this->updatePage]);

        $currentPage->chooseTaxCalculationStrategy($taxCalculationStrategy);
    }

    /**
     * @Then the default tax zone for the :channel channel should be :taxZone
     */
    public function theDefaultTaxZoneForTheChannelShouldBe(ChannelInterface $channel, $taxZone)
    {
        $this->updatePage->open(['id' => $channel->getId()]);

        Assert::true(
            $this->updatePage->isDefaultTaxZoneChosen($taxZone),
            sprintf('Default tax zone %s should be selected, but it is not', $taxZone)
        );
    }

    /**
     * @Given channel :channel should not have default tax zone
     */
    public function channelShouldNotHaveDefaultTaxZone(ChannelInterface $channel)
    {
        $this->updatePage->open(['id' => $channel->getId()]);

        Assert::false(
            $this->updatePage->isAnyDefaultTaxZoneChosen(),
            'Channel should not have default tax zone, but it has.'
        );
    }

    /**
     * @Then the tax calculation strategy for the :channel channel should be :taxCalculationStrategy
     */
    public function theTaxCalculationStrategyForTheChannelShouldBe(ChannelInterface $channel, $taxCalculationStrategy)

    {
        $this->updatePage->open(['id' => $channel->getId()]);

        Assert::true(
            $this->updatePage->isTaxCalculationStrategyChosen($taxCalculationStrategy),
            sprintf('Tax calculation strategy %s should be selected, but it is not', $taxCalculationStrategy)
        );
    }

    /**
     * @param ChannelInterface $channel
     * @param bool $state
     */
    private function assertChannelState(ChannelInterface $channel, $state)
    {
        $this->iWantToBrowseChannels();

        Assert::true(
            $this->indexPage->isSingleResourceOnPage(
                [
                    'nameAndDescription' => $channel->getName(),
                    'enabled' => $state,
                ]
            ), sprintf('Channel with name %s and state %s has not been found.', $channel->getName(), $state)
        );
    }
}


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 Sylius\Behat\Context\Ui\Admin;
13
14			use Behat\Behat\Context\Context;
15			use Sylius\Behat\NotificationType;
16			use Sylius\Behat\Page\Admin\Channel\CreatePageInterface;
17			use Sylius\Behat\Page\Admin\Channel\IndexPageInterface;
18			use Sylius\Behat\Page\Admin\Channel\UpdatePageInterface;
19			use Sylius\Behat\Service\Resolver\CurrentPageResolverInterface;
20			use Sylius\Behat\Service\NotificationCheckerInterface;
21			use Sylius\Component\Core\Formatter\StringInflector;
22			use Sylius\Component\Core\Model\ChannelInterface;
23			use Webmozart\Assert\Assert;
24
25			/**
26			* @author Łukasz Chruściel <[email protected]>
27			*/
28			final class ManagingChannelsContext implements Context
29			{
30			/**
31			* @var IndexPageInterface
32			*/
33			private $indexPage;
34
35			/**
36			* @var CreatePageInterface
37			*/
38			private $createPage;
39
40			/**
41			* @var UpdatePageInterface
42			*/
43			private $updatePage;
44
45			/**
46			* @var CurrentPageResolverInterface
47			*/
48			private $currentPageResolver;
49
50			/**
51			* @var NotificationCheckerInterface
52			*/
53			private $notificationChecker;
54
55			/**
56			* @param IndexPageInterface $indexPage
57			* @param CreatePageInterface $createPage
58			* @param UpdatePageInterface $updatePage
59			* @param CurrentPageResolverInterface $currentPageResolver
60			* @param NotificationCheckerInterface $notificationChecker
61			*/
62			public function __construct(
63			IndexPageInterface $indexPage,
64			CreatePageInterface $createPage,
65			UpdatePageInterface $updatePage,
66			CurrentPageResolverInterface $currentPageResolver,
67			NotificationCheckerInterface $notificationChecker
68			) {
69			$this->indexPage = $indexPage;
70			$this->createPage = $createPage;
71			$this->updatePage = $updatePage;
72			$this->currentPageResolver = $currentPageResolver;
73			$this->notificationChecker = $notificationChecker;
74			}
75
76			/**
77			* @Given I want to create a new channel
78			*/
79			public function iWantToCreateANewChannel()
80			{
81			$this->createPage->open();
82			}
83
84			/**
85			* @When I specify its code as :code
86			* @When I do not specify its code
87			*/
88			public function iSpecifyItsCodeAs($code = null)
89			{
90			$this->createPage->specifyCode($code);
91			}
92
93			/**
94			* @When I name it :name
95			* @When I rename it to :name
96			* @When I do not name it
97			* @When I remove its name
98			*/
99			public function iNameIt($name = null)
100			{
101			$this->createPage->nameIt($name);
102			}
103
104			/**
105			* @When I choose :currency as a default currency
106			* @When I do not choose default currency
107			*/
108			public function iChooseAsADefaultCurrency($currency = null)
109			{
110			$this->createPage->chooseDefaultCurrency($currency);
111			}
112
113			/**
114			* @When I choose :locale as a default locale
115			* @When I do not choose default locale
116			*/
117			public function iChooseAsADefaultLocale($locale = null)
118			{
119			$this->createPage->chooseDefaultLocale($locale);
120			}
121
122			/**
123			* @When I add it
124			* @When I try to add it
125			*/
126			public function iAddIt()
127			{
128			$this->createPage->create();
129			}
130
131			/**
132			* @Then the channel :channelName should appear in the registry
133			* @Then the channel :channelName should be in the registry
134			*/
135			public function theChannelShouldAppearInTheRegistry($channelName)
136			{
137			$this->iWantToBrowseChannels();
138
139			Assert::true($this->indexPage->isSingleResourceOnPage(
140			['nameAndDescription' => $channelName]),
141			sprintf('Channel with name %s has not been found.', $channelName)
142			);
143			}
144
145			/**
146			* @Then /^(this channel) should still be in the registry$/
147			*/
148			public function thisChannelShouldAppearInTheRegistry(ChannelInterface $channel)
149			{
150			$this->theChannelShouldAppearInTheRegistry($channel->getName());
151			}
152
153			/**
154			* @When I describe it as :description
155			*/
156			public function iDescribeItAs($description)
157			{
158			$this->createPage->describeItAs($description);
159			}
160
161			/**
162			* @When I set its hostname as :hostname
163			*/
164			public function iSetItsHostnameAs($hostname)
165			{
166			$this->createPage->setHostname($hostname);
167			}
168
169			/**
170			* @When I define its color as :color
171			*/
172			public function iDefineItsColorAs($color)
173			{
174			$this->createPage->defineColor($color);
175			}
176
177			/**
178			* @When I enable it
179			*/
180			public function iEnableIt()
181			{
182			$this->updatePage->enable();
183			}
184
185			/**
186			* @When I disable it
187			*/
188			public function iDisableIt()
189			{
190			$currentPage = $this->currentPageResolver->getCurrentPageWithForm([$this->createPage, $this->updatePage]);
191
192			$currentPage->disable();
193			}
194
195			/**
196			* @Then I should be notified that at least one channel has to be defined
197			*/
198			public function iShouldBeNotifiedThatAtLeastOneChannelHasToBeDefinedIsRequired()
199			{
200			/** @var CreatePageInterface\|UpdatePageInterface $currentPage */
201			$currentPage = $this->currentPageResolver->getCurrentPageWithForm([$this->createPage, $this->updatePage]);
202
203			Assert::same($currentPage->getValidationMessage('enabled'), 'Must have at least one enabled entity');
204			}
205
206			/**
207			* @Then channel with :element :value should not be added
208			*/
209			public function channelWithShouldNotBeAdded($element, $value)
210			{
211			$this->iWantToBrowseChannels();
212
213			Assert::false(
214			$this->indexPage->isSingleResourceOnPage([$element => $value]),
215			sprintf('Channel with %s "%s" was created, but it should not.', $element, $value)
216			);
217			}
218
219			/**
220			* @Then /^I should be notified that ([^"]+) is required$/
221			*/
222			public function iShouldBeNotifiedThatIsRequired($element)
223			{
224			/** @var CreatePageInterface\|UpdatePageInterface $currentPage */
225			$currentPage = $this->currentPageResolver->getCurrentPageWithForm([$this->createPage, $this->updatePage]);
226
227			Assert::same(
228			$currentPage->getValidationMessage(StringInflector::nameToCode($element)),
229			sprintf('Please enter channel %s.', $element)
230			);
231			}
232
233			/**
234			* @Given I want to modify a channel :channel
235			* @Given /^I want to modify (this channel)$/
236			*/
237			public function iWantToModifyChannel(ChannelInterface $channel)
238			{
239			$this->updatePage->open(['id' => $channel->getId()]);
240			}
241
242			/**
243			* @Then /^(this channel) name should be "([^"]+)"$/
244			* @Then /^(this channel) should still be named "([^"]+)"$/
245			*/
246			public function thisChannelNameShouldBe(ChannelInterface $channel, $channelName)
247			{
248			$this->iWantToBrowseChannels();
249
250			Assert::true(
251			$this->indexPage->isSingleResourceOnPage(
252			[
253			'code' => $channel->getCode(),
254			'nameAndDescription' => $channelName,
255			]
256			),
257			sprintf('Channel name %s has not been assigned properly.', $channelName)
258			);
259			}
260
261			/**
262			* @When I save my changes
263			* @When I try to save my changes
264			*/
265			public function iSaveMyChanges()
266			{
267			$this->updatePage->saveChanges();
268			}
269
270			/**
271			* @Then I should be notified that channel with this code already exists
272			*/
273			public function iShouldBeNotifiedThatChannelWithThisCodeAlreadyExists()
274			{
275			Assert::same($this->createPage->getValidationMessage('code'), 'Channel code has to be unique.');
276			}
277
278			/**
279			* @Then there should still be only one channel with :element :value
280			*/
281			public function thereShouldStillBeOnlyOneChannelWithCode($element, $value)
282			{
283			$this->iWantToBrowseChannels();
284
285			Assert::true(
286			$this->indexPage->isSingleResourceOnPage([$element => $value]),
287			sprintf('Channel with %s %s cannot be found.', $element, $value)
288			);
289			}
290
291			/**
292			* @When /^I want to browse channels$/
293			*/
294			public function iWantToBrowseChannels()
295			{
296			$this->indexPage->open();
297			}
298
299			/**
300			* @Then I should see :numberOfChannels channels in the list
301			*/
302			public function iShouldSeeChannelsInTheList($numberOfChannels)
303			{
304			$foundRows = $this->indexPage->countItems();
305
306			Assert::eq(
307			(int) $numberOfChannels,
308			$foundRows,
309			sprintf('%s rows with channels should appear on page, %s rows has been found', $numberOfChannels, $foundRows)
310			);
311			}
312
313			/**
314			* @Then the code field should be disabled
315			*/
316			public function theCodeFieldShouldBeDisabled()
317			{
318			Assert::true(
319			$this->updatePage->isCodeDisabled(),
320			'Code should be immutable, but it does not.'
321			);
322			}
323
324			/**
325			* @Then /^(this channel) should be disabled$/
326			*/
327			public function thisChannelShouldBeDisabled(ChannelInterface $channel)
328			{
329			$this->assertChannelState($channel, false);
330			}
331
332			/**
333			* @Then /^(this channel) should be enabled$/
334			* @Then channel with name :channel should still be enabled
335			*/
336			public function thisChannelShouldBeEnabled(ChannelInterface $channel)
337			{
338			$this->assertChannelState($channel, true);
339			}
340
341			/**
342			* @When I delete channel :channel
343			*/
344			public function iDeleteChannel(ChannelInterface $channel)
345			{
346			$this->indexPage->open();
347			$this->indexPage->deleteResourceOnPage(['nameAndDescription' => $channel->getName()]);
348			}
349
350			/**
351			* @Then the :channelName channel should no longer exist in the registry
352			*/
353			public function thisChannelShouldNoLongerExistInTheRegistry($channelName)
354			{
355			Assert::false(
356			$this->indexPage->isSingleResourceOnPage(['nameAndDescription' => $channelName]),
357			sprintf('Channel with name %s exists but should not.', $channelName)
358			);
359			}
360
361			/**
362			* @Then I should be notified that it cannot be deleted
363			*/
364			public function iShouldBeNotifiedThatItCannotBeDeleted()
365			{
366			$this->notificationChecker->checkNotification(
367			"The channel cannot be deleted. At least one enabled channel is required.",
			0 ignored issues – show Coding Style Comprehensibility introduced 2016-06-24 14:31 UTC by Report Bug Copy Issue Report The string literal `The channel cannot be de...ed channel is required.` does not require double quotes, as per coding-style, please use single quotes. PHP provides two ways to mark string literals. Either with single quotes `'literal'` or with double quotes `"literal"`. The difference between these is that string literals in double quotes may contain variables with are evaluated at run-time as well as escape sequences. String literals in single quotes on the other hand are evaluated very literally and the only two characters that needs escaping in the literal are the single quote itself (`\'`) and the backslash (`\\`). Every other character is displayed as is. Double quoted string literals may contain other variables or more complex escape sequences. <?php $singleQuoted = 'Value'; $doubleQuoted = "\tSingle is $singleQuoted"; print $doubleQuoted; will print an indented: `Single is Value` If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
368			NotificationType::failure()
369			);
370			}
371
372			/**
373			* @When I make it available in :locale
374			*/
375			public function iMakeItAvailableIn($locale)
376			{
377			$currentPage = $this->currentPageResolver->getCurrentPageWithForm([$this->createPage, $this->updatePage]);
378
379			$currentPage->chooseLocale($locale);
380			}
381
382			/**
383			* @Then the channel :channel should be available in :locale
384			*/
385			public function theChannelShouldBeAvailableIn(ChannelInterface $channel, $locale)
386			{
387			$this->updatePage->open(['id' => $channel->getId()]);
388
389			Assert::true(
390			$this->updatePage->isLocaleChosen($locale),
391			sprintf('Language %s should be selected but it is not', $locale)
392			);
393			}
394
395			/**
396			* @When I allow for paying in :currencyCode
397			*/
398			public function iAllowToPayingForThisChannel($currencyCode)
399			{
400			$currentPage = $this->currentPageResolver->getCurrentPageWithForm([$this->createPage, $this->updatePage]);
401
402			$currentPage->chooseCurrency($currencyCode);
403			}
404
405			/**
406			* @Then paying in :currencyCode should be possible for the :channel channel
407			*/
408			public function payingInEuroShouldBePossibleForTheChannel($currencyCode, ChannelInterface $channel)
409			{
410			$this->updatePage->open(['id' => $channel->getId()]);
411
412			Assert::true(
413			$this->updatePage->isCurrencyChosen($currencyCode),
414			sprintf('Currency %s should be selected but it is not', $currencyCode)
415			);
416			}
417
418			/**
419			* @When I select the :taxZone as default tax zone
420			*/
421			public function iSelectDefaultTaxZone($taxZone)
422			{
423			$currentPage = $this->currentPageResolver->getCurrentPageWithForm([$this->createPage, $this->updatePage]);
424
425			$currentPage->chooseDefaultTaxZone($taxZone);
426			}
427
428			/**
429			* @Given I remove its default tax zone
430			*/
431			public function iRemoveItsDefaultTaxZone()
432			{
433			$this->updatePage->chooseDefaultTaxZone(null);
434			}
435
436			/**
437			* @When I select the :taxCalculationStrategy as tax calculation strategy
438			*/
439			public function iSelectTaxCalculationStrategy($taxCalculationStrategy)
			0 ignored issues – show Comprehensibility Naming introduced 2016-10-20 17:46 UTC by Report Bug Copy Issue Report The variable name `$taxCalculationStrategy` 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...
440			{
441			$currentPage = $this->currentPageResolver->getCurrentPageWithForm([$this->createPage, $this->updatePage]);
442
443			$currentPage->chooseTaxCalculationStrategy($taxCalculationStrategy);
444			}
445
446			/**
447			* @Then the default tax zone for the :channel channel should be :taxZone
448			*/
449			public function theDefaultTaxZoneForTheChannelShouldBe(ChannelInterface $channel, $taxZone)
450			{
451			$this->updatePage->open(['id' => $channel->getId()]);
452
453			Assert::true(
454			$this->updatePage->isDefaultTaxZoneChosen($taxZone),
455			sprintf('Default tax zone %s should be selected, but it is not', $taxZone)
456			);
457			}
458
459			/**
460			* @Given channel :channel should not have default tax zone
461			*/
462			public function channelShouldNotHaveDefaultTaxZone(ChannelInterface $channel)
463			{
464			$this->updatePage->open(['id' => $channel->getId()]);
465
466			Assert::false(
467			$this->updatePage->isAnyDefaultTaxZoneChosen(),
468			'Channel should not have default tax zone, but it has.'
469			);
470			}
471
472			/**
473			* @Then the tax calculation strategy for the :channel channel should be :taxCalculationStrategy
474			*/
475			public function theTaxCalculationStrategyForTheChannelShouldBe(ChannelInterface $channel, $taxCalculationStrategy)
			0 ignored issues – show Comprehensibility Naming introduced 2016-10-20 17:46 UTC by Report Bug Copy Issue Report The variable name `$taxCalculationStrategy` 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...
476			{
477			$this->updatePage->open(['id' => $channel->getId()]);
478
479			Assert::true(
480			$this->updatePage->isTaxCalculationStrategyChosen($taxCalculationStrategy),
481			sprintf('Tax calculation strategy %s should be selected, but it is not', $taxCalculationStrategy)
482			);
483			}
484
485			/**
486			* @param ChannelInterface $channel
487			* @param bool $state
488			*/
489			private function assertChannelState(ChannelInterface $channel, $state)
490			{
491			$this->iWantToBrowseChannels();
492
493			Assert::true(
494			$this->indexPage->isSingleResourceOnPage(
495			[
496			'nameAndDescription' => $channel->getName(),
497			'enabled' => $state,
498			]
499			), sprintf('Channel with name %s and state %s has not been found.', $channel->getName(), $state)
500			);
501			}
502			}
503

pamil / Sylius

Push — symfony3 ( 405d0c...88ded0 )

ManagingChannelsContext::iSpecifyItsCodeAs() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like