Sylius\Behat\Page\Admin\Taxon\CreatePage

Complexity

Total Complexity

28

Size/Duplication

Total Lines	253
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	countTaxons()	0	4	1
A	countTaxonsByName()	0	12	3
A	chooseParent()	0	4	1
A	deleteTaxonOnPageByName()	0	21	3
A	describeItAs()	0	4	1
A	hasTaxonWithName()	0	4	1
A	nameIt()	0	4	1
A	specifyPermalink()	0	4	1
A	attachImage()	0	10	1
A	moveUp()	0	4	1
A	moveDown()	0	4	1
A	getFirstLeafName()	0	4	1
A	insertBefore()	0	20	1
A	getLeaves()	0	17	4
A	getDefinedElements()	0	12	1
B	moveLeaf()	0	25	3
A	getLastImageElement()	0	9	1
A	getSeleniumDriver()	0	10	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.
 */

namespace Sylius\Behat\Page\Admin\Taxon;

use Behat\Mink\Driver\Selenium2Driver;
use Behat\Mink\Element\NodeElement;
use Behat\Mink\Exception\ElementNotFoundException;
use Behat\Mink\Exception\UnsupportedDriverActionException;
use Sylius\Behat\Behaviour\SpecifiesItsCode;
use Sylius\Behat\Page\Admin\Crud\CreatePage as BaseCreatePage;
use Sylius\Component\Core\Model\TaxonInterface;
use Webmozart\Assert\Assert;

/**
 * @author Arkadiusz Krakowiak <arkadiusz.krakowiak@lakion.com>
 */
class CreatePage extends BaseCreatePage implements CreatePageInterface
{
    use SpecifiesItsCode;

    /**
     * {@inheritdoc}
     */
    public function countTaxons()
    {
        return count($this->getLeaves());
    }

    /**
     * {@inheritdoc}
     */
    public function countTaxonsByName($name)
    {
        $matchedLeavesCounter = 0;
        $leaves = $this->getLeaves();
        foreach ($leaves as $leaf) {

The expression $leaves of type array<integer,object<Behat\Mink\Element\NodeElement>>|null is not guaranteed to be traversable. How about adding an additional type check?

            if (strpos($leaf->getText(), $name) !== false) {
                $matchedLeavesCounter++;
            }
        }

        return $matchedLeavesCounter;
    }

    /**
     * {@inheritdoc}
     */
    public function chooseParent(TaxonInterface $taxon)
    {
        $this->getElement('parent')->selectOption($taxon->getName(), false);
    }

    /**
     * {@inheritdoc}
     */
    public function deleteTaxonOnPageByName($name)
    {
        $leaves = $this->getLeaves();
        foreach ($leaves as $leaf) {

The expression $leaves of type array<integer,object<Behat\Mink\Element\NodeElement>>|null is not guaranteed to be traversable. How about adding an additional type check?

            if ($leaf->getText() === $name) {
                $leaf = $leaf->getParent();
                $menuButton = $leaf->find('css', '.wrench');
                $menuButton->click();
                $deleteButton = $leaf->find('css', '.sylius-delete-resource');
                $deleteButton->click();

                $deleteButton->waitFor(5, function () {
                    return false;
                });

                return;
            }
        }

        throw new ElementNotFoundException($this->getDriver(), 'Delete button');
    }

    /**
     * {@inheritdoc}
     */
    public function describeItAs($description, $languageCode)
    {
        $this->getDocument()->fillField(sprintf('sylius_taxon_translations_%s_description', $languageCode), $description);
    }

    /**
     * {@inheritdoc}
     */
    public function hasTaxonWithName($name)
    {
        return 0 !== $this->countTaxonsByName($name);
    }

    /**
     * {@inheritdoc}
     */
    public function nameIt($name, $languageCode)
    {
        $this->getDocument()->fillField(sprintf('sylius_taxon_translations_%s_name', $languageCode), $name);
    }

    /**
     * {@inheritdoc}
     */
    public function specifyPermalink($permalink, $languageCode)
    {
        $this->getDocument()->fillField(sprintf('sylius_taxon_translations_%s_permalink', $languageCode), $permalink);
    }

    /**
     * {@inheritdoc}
     */
    public function attachImage($path, $code = null)
    {
        $filesPath = $this->getParameter('files_path');

        $this->getDocument()->find('css', '[data-form-collection="add"]')->click();

        $imageForm = $this->getLastImageElement();
        $imageForm->fillField('Code', $code);
        $imageForm->find('css', 'input[type="file"]')->attachFile($filesPath.$path);
    }

    /**
     * {@inheritDoc}
     */
    public function moveUp(TaxonInterface $taxon)
    {
        $this->moveLeaf($taxon, self::MOVE_DIRECTION_UP);
    }

    /**
     * {@inheritDoc}
     */
    public function moveDown(TaxonInterface $taxon)
    {
        $this->moveLeaf($taxon, self::MOVE_DIRECTION_DOWN);
    }

    /**
     * {@inheritDoc}
     */
    public function getFirstLeafName(TaxonInterface $parentTaxon = null)
    {
        return $this->getLeaves($parentTaxon)[0]->getText();
    }

    /**
     * {@inheritDoc}
     */
    public function insertBefore(TaxonInterface $draggableTaxon, TaxonInterface $targetTaxon)
    {
        $seleniumDriver = $this->getSeleniumDriver();
        $draggableTaxonLocator = sprintf('.item[data-id="%s"]', $draggableTaxon->getId());

The variable name $draggableTaxonLocator exceeds the maximum configured length of 20.

        $targetTaxonLocator = sprintf('.item[data-id="%s"]', $targetTaxon->getId());

        $script = <<<JS
(function ($) {
    $('$draggableTaxonLocator').simulate('drag-n-drop',{
        dragTarget: $('$targetTaxonLocator'),
        interpolation: {stepWidth: 10, stepDelay: 30} 
    });    
})(jQuery);
JS;

        $seleniumDriver->executeScript($script);
        $this->getDocument()->waitFor(5, function () {
            return false;
        });
    }

    /**
     * {@inheritdoc}
     */
    public function getLeaves(TaxonInterface $parentTaxon = null)
    {
        $tree = $this->getElement('tree');
        Assert::notNull($tree);
        /** @var NodeElement[] $leaves */
        $leaves = $tree->findAll('css', '.item > .content > .header');

        if (null === $parentTaxon) {
            return $leaves;
        }

        foreach ($leaves as $leaf) {
            if ($leaf->getText() === $parentTaxon->getName()) {
                return $leaf->findAll('css', '.item > .content > .header');
            }
        }
    }

    /**
     * {@inheritdoc}
     */
    protected function getDefinedElements()
    {
        return array_merge(parent::getDefinedElements(), [
            'code' => '#sylius_taxon_code',
            'description' => '#sylius_taxon_translations_en_US_description',
            'images' => '#sylius_taxon_images',
            'name' => '#sylius_taxon_translations_en_US_name',
            'parent' => '#sylius_taxon_parent',
            'permalink' => '#sylius_taxon_translations_en_US_permalink',
            'tree' => '.ui.list',
        ]);
    }

    /**
     * @param TaxonInterface $taxon
     * @param string $direction
     *
     * @throws ElementNotFoundException
     */
    private function moveLeaf(TaxonInterface $taxon, $direction)
    {
        Assert::oneOf($direction, [self::MOVE_DIRECTION_UP, self::MOVE_DIRECTION_DOWN]);

        $leaves = $this->getLeaves();
        foreach ($leaves as $leaf) {

The expression $leaves of type array<integer,object<Behat\Mink\Element\NodeElement>>|null is not guaranteed to be traversable. How about adding an additional type check?

            if ($leaf->getText() === $taxon->getName()) {
                $leaf = $leaf->getParent();
                $menuButton = $leaf->find('css', '.wrench');
                $menuButton->click();
                $moveButton = $leaf->find('css', sprintf('.%s', $direction));
                $moveButton->click();
                $moveButton->waitFor(5, function () use ($taxon) {
                    return $this->getFirstLeafName() === $taxon->getName();
                });

                return;
            }
        }

        throw new ElementNotFoundException(
            $this->getDriver(),
            sprintf('Move %s button for %s taxon', $direction, $taxon->getName())
        );
    }

    /**
     * @return NodeElement
     */
    private function getLastImageElement()
    {
        $images = $this->getElement('images');
        $items = $images->findAll('css', 'div[data-form-collection="item"]');

        Assert::notEmpty($items);

        return end($items);
    }

    /**
     * @return Selenium2Driver
     *
     * @throws UnsupportedDriverActionException
     */
    private function getSeleniumDriver()
    {
        /** @var Selenium2Driver $driver */
        $driver = $this->getDriver();
        if (!$driver instanceof Selenium2Driver) {
            throw new UnsupportedDriverActionException('This action is not supported by %s', $driver);
        }

        return $driver;
    }
}