AddressPage::chooseDifferentShippingAddress() - Code Metrics - Inspection of "Merge branch '1.6'" - pamil/Sylius - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 047880...b09c02 )

by Kamil

created 2020-01-23 08:55 UTC

AddressPage::chooseDifferentShippingAddress() A

↳ Parent: AddressPage

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	17
rs	9.7
c	0
b	0
f	0
cc	2
nc	2
nop	0

<?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\Page\Shop\Checkout;

use Behat\Mink\Driver\Selenium2Driver;
use Behat\Mink\Element\NodeElement;
use Behat\Mink\Exception\ElementNotFoundException;
use Behat\Mink\Session;
use FriendsOfBehat\PageObjectExtension\Page\SymfonyPage;
use Sylius\Behat\Service\JQueryHelper;
use Sylius\Component\Core\Factory\AddressFactoryInterface;
use Sylius\Component\Core\Model\AddressInterface;
use Symfony\Component\Routing\RouterInterface;
use Webmozart\Assert\Assert;

class AddressPage extends SymfonyPage implements AddressPageInterface
{
    public const TYPE_BILLING = 'billing';

    public const TYPE_SHIPPING = 'shipping';

    /** @var AddressFactoryInterface */
    private $addressFactory;

    public function __construct(
        Session $session,
        $minkParameters,
        RouterInterface $router,
        AddressFactoryInterface $addressFactory
    ) {
        parent::__construct($session, $minkParameters, $router);

        $this->addressFactory = $addressFactory;
    }

    public function getRouteName(): string
    {
        return 'sylius_shop_checkout_address';
    }

    public function chooseDifferentShippingAddress(): void
    {
        $driver = $this->getDriver();
        if ($driver instanceof Selenium2Driver) {
            $this->getElement('different_shipping_address_label')->click();

            return;
        }

        $billingAddressSwitch = $this->getElement('different_shipping_address');
        Assert::false(
            $billingAddressSwitch->isChecked(),
            'Previous state of different billing address switch was true expected to be false'
        );

        $billingAddressSwitch->check();
    }

    public function checkInvalidCredentialsValidation(): bool
    {
        $this->getElement('login_password')->waitFor(5, function () {
            $validationElement = $this->getElement('login_password')->getParent()->find('css', '[data-test-login-errors]');
            if (null === $validationElement) {
                return false;
            }

            return $validationElement->isVisible();
        });

        return $this->checkValidationMessageFor('login_password', 'Invalid credentials.');
    }

    public function checkValidationMessageFor(string $element, string $message): bool
    {
        $foundElement = $this->getFieldElement($element);
        if (null === $foundElement) {
            throw new ElementNotFoundException($this->getSession(), 'Validation message', 'css', '[data-test-validation-error]');
        }

        $validationMessage = $foundElement->find('css', '.sylius-validation-error');
        if (null === $validationMessage) {
            throw new ElementNotFoundException($this->getSession(), 'Validation message', 'css', '[data-test-validation-error]');
        }

        return $message === $validationMessage->getText();
    }

    public function specifyShippingAddress(AddressInterface $shippingAddress): void
    {
        $this->specifyAddress($shippingAddress, self::TYPE_SHIPPING);
    }

    public function selectShippingAddressProvince(string $province): void
    {
        $this->waitForElement(5, 'shipping_country_province');
        $this->getElement('shipping_country_province')->selectOption($province);
    }

    public function specifyBillingAddress(AddressInterface $billingAddress): void
    {
        $this->specifyAddress($billingAddress, self::TYPE_BILLING);
    }

    public function selectBillingAddressProvince(string $province): void
    {
        $this->waitForElement(5, 'billing_country_province');
        $this->getElement('billing_country_province')->selectOption($province);
    }

    public function specifyEmail(?string $email): void
    {
        $this->getElement('customer_email')->setValue($email);
    }

    public function specifyBillingAddressFullName(string $fullName): void
    {
        $names = explode(' ', $fullName);

        $this->getElement('billing_first_name')->setValue($names[0]);
        $this->getElement('billing_last_name')->setValue($names[1]);
    }

    public function canSignIn(): bool
    {
        return $this->waitForElement(5, 'login_button');
    }

    public function signIn(): void
    {
        $this->waitForElement(5, 'login_button');

        try {
            $this->getElement('login_button')->press();
        } catch (ElementNotFoundException $elementNotFoundException) {
            $this->getElement('login_button')->click();
        }

        $this->waitForLoginAction();
    }

    public function specifyPassword(string $password): void
    {
        $this->getDocument()->waitFor(5, function () {
            return $this->getElement('login_password')->isVisible();
        });

        $this->getElement('login_password')->setValue($password);
    }

    public function getItemSubtotal(string $itemName): string
    {
        $itemSlug = strtolower(str_replace('\"', '', str_replace(' ', '-', $itemName)));

        $subtotalTable = $this->getElement('checkout_subtotal');

        return $subtotalTable->find('css', sprintf('[data-test-item-subtotal="%s"]', $itemSlug))->getText();
    }

    public function getShippingAddressCountry(): string
    {
        return $this->getElement('shipping_country')->find('css', 'option:selected')->getText();
    }

    public function nextStep(): void
    {
        $this->getElement('next_step')->press();
    }

    public function backToStore(): void
    {
        $this->getDocument()->clickLink('Back to store');
    }

    public function specifyBillingAddressProvince(string $provinceName): void
    {
        $this->waitForElement(5, 'billing_province');
        $this->getElement('billing_province')->setValue($provinceName);
    }

    public function specifyShippingAddressProvince(string $provinceName): void
    {
        $this->waitForElement(5, 'shipping_province');
        $this->getElement('shipping_province')->setValue($provinceName);
    }

    public function hasShippingAddressInput(): bool
    {
        return $this->waitForElement(5, 'shipping_province');
    }

    public function hasBillingAddressInput(): bool
    {
        return $this->waitForElement(5, 'billing_province');
    }

    public function selectShippingAddressFromAddressBook(AddressInterface $address): void
    {
        $this->waitForElement(2, sprintf('%s_province', self::TYPE_SHIPPING));
        $addressBookSelect = $this->getElement('shipping_address_book');

        $addressBookSelect->click();
        $addressOption = $addressBookSelect->waitFor(5, function () use ($address, $addressBookSelect) {
            return $addressBookSelect->find('css', sprintf('.item[data-id="%s"]', $address->getId()));
        });

        if (null === $addressOption) {
            throw new ElementNotFoundException($this->getDriver(), 'option', 'css', sprintf('.item[data-id="%s"]', $address->getId()));
        }

        $addressOption->click();
    }

    public function selectBillingAddressFromAddressBook(AddressInterface $address): void
    {
        $this->waitForElement(2, sprintf('%s_province', self::TYPE_BILLING));
        $addressBookSelect = $this->getElement('billing_address_book');

        $addressBookSelect->click();
        $addressOption = $addressBookSelect->waitFor(5, function () use ($address, $addressBookSelect) {
            return $addressBookSelect->find('css', sprintf('.item[data-id="%s"]', $address->getId()));
        });

        if (null === $addressOption) {
            throw new ElementNotFoundException($this->getDriver(), 'option', 'css', sprintf('.item[data-id="%s"]', $address->getId()));
        }

        $addressOption->click();

        JQueryHelper::waitForFormToStopLoading($this->getDocument());
    }

    public function getPreFilledShippingAddress(): AddressInterface
    {
        return $this->getPreFilledAddress(self::TYPE_SHIPPING);
    }

    public function getPreFilledBillingAddress(): AddressInterface
    {
        return $this->getPreFilledAddress(self::TYPE_BILLING);
    }

    protected function getDefinedElements(): array
    {
        return array_merge(parent::getDefinedElements(), [
            'billing_address_book' => '[data-test-billing-address] [data-test-address-book]',
            'billing_city' => '[data-test-billing-city]',
            'billing_country' => '[data-test-billing-country]',
            'billing_country_province' => '[data-test-billing-address] [data-test-province-code]',
            'billing_first_name' => '[data-test-billing-first-name]',
            'billing_last_name' => '[data-test-billing-last-name]',
            'billing_postcode' => '[data-test-billing-postcode]',
            'billing_province' => '[data-test-billing-address] [data-test-province-name]',
            'billing_street' => '[data-test-billing-street]',
            'checkout_subtotal' => '[data-test-checkout-subtotal]',
            'customer_email' => '[data-test-login-email]',
            'different_billing_address' => '[data-test-different-billing-address]',
            'different_billing_address_label' => '[data-test-different-billing-address-label]',
            'different_shipping_address' => '[data-test-different-shipping-address]',
            'different_shipping_address_label' => '[data-test-different-shipping-address-label]',
            'login_button' => '[data-test-login-button]',
            'login_password' => '[data-test-password-input]',
            'next_step' => '[data-test-next-step]',
            'shipping_address_book' => '[data-test-shipping-address] [data-test-address-book]',
            'shipping_city' => '[data-test-shipping-city]',
            'shipping_country' => '[data-test-shipping-country]',
            'shipping_country_province' => '[data-test-shipping-address] [data-test-province-code]',
            'shipping_first_name' => '[data-test-shipping-first-name]',
            'shipping_last_name' => '[data-test-shipping-last-name]',
            'shipping_postcode' => '[data-test-shipping-postcode]',
            'shipping_province' => '[data-test-shipping-address] [data-test-province-name]',
            'shipping_street' => '[data-test-shipping-street]',
        ]);
    }

    private function getPreFilledAddress(string $type): AddressInterface
    {
        $this->assertAddressType($type);

        /** @var AddressInterface $address */
        $address = $this->addressFactory->createNew();

        $address->setFirstName($this->getElement(sprintf('%s_first_name', $type))->getValue());
        $address->setLastName($this->getElement(sprintf('%s_last_name', $type))->getValue());
        $address->setStreet($this->getElement(sprintf('%s_street', $type))->getValue());
        $address->setCountryCode($this->getElement(sprintf('%s_country', $type))->getValue());
        $address->setCity($this->getElement(sprintf('%s_city', $type))->getValue());
        $address->setPostcode($this->getElement(sprintf('%s_postcode', $type))->getValue());
        $this->waitForElement(5, sprintf('%s_province', $type));

        try {
            $address->setProvinceName($this->getElement(sprintf('%s_province', $type))->getValue());
        } catch (ElementNotFoundException $exception) {
            $address->setProvinceCode($this->getElement(sprintf('%s_country_province', $type))->getValue());
        }

        return $address;
    }

    private function specifyAddress(AddressInterface $address, string $type): void
    {
        $this->assertAddressType($type);

        $this->getElement(sprintf('%s_first_name', $type))->setValue($address->getFirstName());
        $this->getElement(sprintf('%s_last_name', $type))->setValue($address->getLastName());
        $this->getElement(sprintf('%s_street', $type))->setValue($address->getStreet());
        $this->getElement(sprintf('%s_country', $type))->selectOption($address->getCountryCode() ?: 'Select');
        $this->getElement(sprintf('%s_city', $type))->setValue($address->getCity());
        $this->getElement(sprintf('%s_postcode', $type))->setValue($address->getPostcode());

        JQueryHelper::waitForFormToStopLoading($this->getDocument());

        if (null !== $address->getProvinceName()) {
            $this->waitForElement(5, sprintf('%s_province', $type));
            $this->getElement(sprintf('%s_province', $type))->setValue($address->getProvinceName());
        }
        if (null !== $address->getProvinceCode()) {
            $this->waitForElement(5, sprintf('%s_country_province', $type));
            $this->getElement(sprintf('%s_country_province', $type))->selectOption($address->getProvinceCode());
        }
    }

    private function getFieldElement(string $element): ?NodeElement
    {
        $element = $this->getElement($element);
        while (null !== $element && !$element->hasClass('field')) {
            $element = $element->getParent();
        }

        return $element;
    }

    private function waitForLoginAction(): bool

    {
        return $this->getDocument()->waitFor(5, function () {
            return !$this->hasElement('login_password');
        });
    }

    private function waitForElement(int $timeout, string $elementName): bool

    {
        return $this->getDocument()->waitFor($timeout, function () use ($elementName) {
            return $this->hasElement($elementName);
        });
    }

    private function assertAddressType(string $type): void
    {
        $availableTypes = [self::TYPE_BILLING, self::TYPE_SHIPPING];

        Assert::oneOf($type, $availableTypes, sprintf('There are only two available types %s, %s. %s given', self::TYPE_BILLING, self::TYPE_SHIPPING, $type));
    }
}


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\Page\Shop\Checkout;
15
16			use Behat\Mink\Driver\Selenium2Driver;
17			use Behat\Mink\Element\NodeElement;
18			use Behat\Mink\Exception\ElementNotFoundException;
19			use Behat\Mink\Session;
20			use FriendsOfBehat\PageObjectExtension\Page\SymfonyPage;
21			use Sylius\Behat\Service\JQueryHelper;
22			use Sylius\Component\Core\Factory\AddressFactoryInterface;
23			use Sylius\Component\Core\Model\AddressInterface;
24			use Symfony\Component\Routing\RouterInterface;
25			use Webmozart\Assert\Assert;
26
27			class AddressPage extends SymfonyPage implements AddressPageInterface
28			{
29			public const TYPE_BILLING = 'billing';
30
31			public const TYPE_SHIPPING = 'shipping';
32
33			/** @var AddressFactoryInterface */
34			private $addressFactory;
35
36			public function __construct(
37			Session $session,
38			$minkParameters,
39			RouterInterface $router,
40			AddressFactoryInterface $addressFactory
41			) {
42			parent::__construct($session, $minkParameters, $router);
43
44			$this->addressFactory = $addressFactory;
45			}
46
47			public function getRouteName(): string
48			{
49			return 'sylius_shop_checkout_address';
50			}
51
52			public function chooseDifferentShippingAddress(): void
53			{
54			$driver = $this->getDriver();
55			if ($driver instanceof Selenium2Driver) {
56			$this->getElement('different_shipping_address_label')->click();
57
58			return;
59			}
60
61			$billingAddressSwitch = $this->getElement('different_shipping_address');
62			Assert::false(
63			$billingAddressSwitch->isChecked(),
64			'Previous state of different billing address switch was true expected to be false'
65			);
66
67			$billingAddressSwitch->check();
68			}
69
70			public function checkInvalidCredentialsValidation(): bool
71			{
72			$this->getElement('login_password')->waitFor(5, function () {
73			$validationElement = $this->getElement('login_password')->getParent()->find('css', '[data-test-login-errors]');
74			if (null === $validationElement) {
75			return false;
76			}
77
78			return $validationElement->isVisible();
79			});
80
81			return $this->checkValidationMessageFor('login_password', 'Invalid credentials.');
82			}
83
84			public function checkValidationMessageFor(string $element, string $message): bool
85			{
86			$foundElement = $this->getFieldElement($element);
87			if (null === $foundElement) {
88			throw new ElementNotFoundException($this->getSession(), 'Validation message', 'css', '[data-test-validation-error]');
89			}
90
91			$validationMessage = $foundElement->find('css', '.sylius-validation-error');
92			if (null === $validationMessage) {
93			throw new ElementNotFoundException($this->getSession(), 'Validation message', 'css', '[data-test-validation-error]');
94			}
95
96			return $message === $validationMessage->getText();
97			}
98
99			public function specifyShippingAddress(AddressInterface $shippingAddress): void
100			{
101			$this->specifyAddress($shippingAddress, self::TYPE_SHIPPING);
102			}
103
104			public function selectShippingAddressProvince(string $province): void
105			{
106			$this->waitForElement(5, 'shipping_country_province');
107			$this->getElement('shipping_country_province')->selectOption($province);
108			}
109
110			public function specifyBillingAddress(AddressInterface $billingAddress): void
111			{
112			$this->specifyAddress($billingAddress, self::TYPE_BILLING);
113			}
114
115			public function selectBillingAddressProvince(string $province): void
116			{
117			$this->waitForElement(5, 'billing_country_province');
118			$this->getElement('billing_country_province')->selectOption($province);
119			}
120
121			public function specifyEmail(?string $email): void
122			{
123			$this->getElement('customer_email')->setValue($email);
124			}
125
126			public function specifyBillingAddressFullName(string $fullName): void
127			{
128			$names = explode(' ', $fullName);
129
130			$this->getElement('billing_first_name')->setValue($names[0]);
131			$this->getElement('billing_last_name')->setValue($names[1]);
132			}
133
134			public function canSignIn(): bool
135			{
136			return $this->waitForElement(5, 'login_button');
137			}
138
139			public function signIn(): void
140			{
141			$this->waitForElement(5, 'login_button');
142
143			try {
144			$this->getElement('login_button')->press();
145			} catch (ElementNotFoundException $elementNotFoundException) {
146			$this->getElement('login_button')->click();
147			}
148
149			$this->waitForLoginAction();
150			}
151
152			public function specifyPassword(string $password): void
153			{
154			$this->getDocument()->waitFor(5, function () {
155			return $this->getElement('login_password')->isVisible();
156			});
157
158			$this->getElement('login_password')->setValue($password);
159			}
160
161			public function getItemSubtotal(string $itemName): string
162			{
163			$itemSlug = strtolower(str_replace('\"', '', str_replace(' ', '-', $itemName)));
164
165			$subtotalTable = $this->getElement('checkout_subtotal');
166
167			return $subtotalTable->find('css', sprintf('[data-test-item-subtotal="%s"]', $itemSlug))->getText();
168			}
169
170			public function getShippingAddressCountry(): string
171			{
172			return $this->getElement('shipping_country')->find('css', 'option:selected')->getText();
173			}
174
175			public function nextStep(): void
176			{
177			$this->getElement('next_step')->press();
178			}
179
180			public function backToStore(): void
181			{
182			$this->getDocument()->clickLink('Back to store');
183			}
184
185			public function specifyBillingAddressProvince(string $provinceName): void
186			{
187			$this->waitForElement(5, 'billing_province');
188			$this->getElement('billing_province')->setValue($provinceName);
189			}
190
191			public function specifyShippingAddressProvince(string $provinceName): void
192			{
193			$this->waitForElement(5, 'shipping_province');
194			$this->getElement('shipping_province')->setValue($provinceName);
195			}
196
197			public function hasShippingAddressInput(): bool
198			{
199			return $this->waitForElement(5, 'shipping_province');
200			}
201
202			public function hasBillingAddressInput(): bool
203			{
204			return $this->waitForElement(5, 'billing_province');
205			}
206
207			public function selectShippingAddressFromAddressBook(AddressInterface $address): void
208			{
209			$this->waitForElement(2, sprintf('%s_province', self::TYPE_SHIPPING));
210			$addressBookSelect = $this->getElement('shipping_address_book');
211
212			$addressBookSelect->click();
213			$addressOption = $addressBookSelect->waitFor(5, function () use ($address, $addressBookSelect) {
214			return $addressBookSelect->find('css', sprintf('.item[data-id="%s"]', $address->getId()));
215			});
216
217			if (null === $addressOption) {
218			throw new ElementNotFoundException($this->getDriver(), 'option', 'css', sprintf('.item[data-id="%s"]', $address->getId()));
219			}
220
221			$addressOption->click();
222			}
223
224			public function selectBillingAddressFromAddressBook(AddressInterface $address): void
225			{
226			$this->waitForElement(2, sprintf('%s_province', self::TYPE_BILLING));
227			$addressBookSelect = $this->getElement('billing_address_book');
228
229			$addressBookSelect->click();
230			$addressOption = $addressBookSelect->waitFor(5, function () use ($address, $addressBookSelect) {
231			return $addressBookSelect->find('css', sprintf('.item[data-id="%s"]', $address->getId()));
232			});
233
234			if (null === $addressOption) {
235			throw new ElementNotFoundException($this->getDriver(), 'option', 'css', sprintf('.item[data-id="%s"]', $address->getId()));
236			}
237
238			$addressOption->click();
239
240			JQueryHelper::waitForFormToStopLoading($this->getDocument());
241			}
242
243			public function getPreFilledShippingAddress(): AddressInterface
244			{
245			return $this->getPreFilledAddress(self::TYPE_SHIPPING);
246			}
247
248			public function getPreFilledBillingAddress(): AddressInterface
249			{
250			return $this->getPreFilledAddress(self::TYPE_BILLING);
251			}
252
253			protected function getDefinedElements(): array
254			{
255			return array_merge(parent::getDefinedElements(), [
256			'billing_address_book' => '[data-test-billing-address] [data-test-address-book]',
257			'billing_city' => '[data-test-billing-city]',
258			'billing_country' => '[data-test-billing-country]',
259			'billing_country_province' => '[data-test-billing-address] [data-test-province-code]',
260			'billing_first_name' => '[data-test-billing-first-name]',
261			'billing_last_name' => '[data-test-billing-last-name]',
262			'billing_postcode' => '[data-test-billing-postcode]',
263			'billing_province' => '[data-test-billing-address] [data-test-province-name]',
264			'billing_street' => '[data-test-billing-street]',
265			'checkout_subtotal' => '[data-test-checkout-subtotal]',
266			'customer_email' => '[data-test-login-email]',
267			'different_billing_address' => '[data-test-different-billing-address]',
268			'different_billing_address_label' => '[data-test-different-billing-address-label]',
269			'different_shipping_address' => '[data-test-different-shipping-address]',
270			'different_shipping_address_label' => '[data-test-different-shipping-address-label]',
271			'login_button' => '[data-test-login-button]',
272			'login_password' => '[data-test-password-input]',
273			'next_step' => '[data-test-next-step]',
274			'shipping_address_book' => '[data-test-shipping-address] [data-test-address-book]',
275			'shipping_city' => '[data-test-shipping-city]',
276			'shipping_country' => '[data-test-shipping-country]',
277			'shipping_country_province' => '[data-test-shipping-address] [data-test-province-code]',
278			'shipping_first_name' => '[data-test-shipping-first-name]',
279			'shipping_last_name' => '[data-test-shipping-last-name]',
280			'shipping_postcode' => '[data-test-shipping-postcode]',
281			'shipping_province' => '[data-test-shipping-address] [data-test-province-name]',
282			'shipping_street' => '[data-test-shipping-street]',
283			]);
284			}
285
286			private function getPreFilledAddress(string $type): AddressInterface
287			{
288			$this->assertAddressType($type);
289
290			/** @var AddressInterface $address */
291			$address = $this->addressFactory->createNew();
292
293			$address->setFirstName($this->getElement(sprintf('%s_first_name', $type))->getValue());
294			$address->setLastName($this->getElement(sprintf('%s_last_name', $type))->getValue());
295			$address->setStreet($this->getElement(sprintf('%s_street', $type))->getValue());
296			$address->setCountryCode($this->getElement(sprintf('%s_country', $type))->getValue());
297			$address->setCity($this->getElement(sprintf('%s_city', $type))->getValue());
298			$address->setPostcode($this->getElement(sprintf('%s_postcode', $type))->getValue());
299			$this->waitForElement(5, sprintf('%s_province', $type));
300
301			try {
302			$address->setProvinceName($this->getElement(sprintf('%s_province', $type))->getValue());
303			} catch (ElementNotFoundException $exception) {
304			$address->setProvinceCode($this->getElement(sprintf('%s_country_province', $type))->getValue());
305			}
306
307			return $address;
308			}
309
310			private function specifyAddress(AddressInterface $address, string $type): void
311			{
312			$this->assertAddressType($type);
313
314			$this->getElement(sprintf('%s_first_name', $type))->setValue($address->getFirstName());
315			$this->getElement(sprintf('%s_last_name', $type))->setValue($address->getLastName());
316			$this->getElement(sprintf('%s_street', $type))->setValue($address->getStreet());
317			$this->getElement(sprintf('%s_country', $type))->selectOption($address->getCountryCode() ?: 'Select');
318			$this->getElement(sprintf('%s_city', $type))->setValue($address->getCity());
319			$this->getElement(sprintf('%s_postcode', $type))->setValue($address->getPostcode());
320
321			JQueryHelper::waitForFormToStopLoading($this->getDocument());
322
323			if (null !== $address->getProvinceName()) {
324			$this->waitForElement(5, sprintf('%s_province', $type));
325			$this->getElement(sprintf('%s_province', $type))->setValue($address->getProvinceName());
326			}
327			if (null !== $address->getProvinceCode()) {
328			$this->waitForElement(5, sprintf('%s_country_province', $type));
329			$this->getElement(sprintf('%s_country_province', $type))->selectOption($address->getProvinceCode());
330			}
331			}
332
333			private function getFieldElement(string $element): ?NodeElement
334			{
335			$element = $this->getElement($element);
336			while (null !== $element && !$element->hasClass('field')) {
337			$element = $element->getParent();
338			}
339
340			return $element;
341			}
342
343			private function waitForLoginAction(): bool
			0 ignored issues – show Coding Style introduced 2017-07-31 07:39 UTC by Report Bug Copy Issue Report `function waitForLoginAction()` does not seem to conform to the naming convention (`^(?:is\|has\|should\|may\|supports)`). 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...
344			{
345			return $this->getDocument()->waitFor(5, function () {
346			return !$this->hasElement('login_password');
347			});
348			}
349
350			private function waitForElement(int $timeout, string $elementName): bool
			0 ignored issues – show Coding Style introduced 2019-12-17 13:22 UTC by Report Bug Copy Issue Report `function waitForElement()` does not seem to conform to the naming convention (`^(?:is\|has\|should\|may\|supports)`). 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...
351			{
352			return $this->getDocument()->waitFor($timeout, function () use ($elementName) {
353			return $this->hasElement($elementName);
354			});
355			}
356
357			private function assertAddressType(string $type): void
358			{
359			$availableTypes = [self::TYPE_BILLING, self::TYPE_SHIPPING];
360
361			Assert::oneOf($type, $availableTypes, sprintf('There are only two available types %s, %s. %s given', self::TYPE_BILLING, self::TYPE_SHIPPING, $type));
362			}
363			}
364

pamil / Sylius

Push — master ( 047880...b09c02 )

AddressPage::chooseDifferentShippingAddress() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like