Drupal\TqExtension\Utils\FormValueAssertion

Complexity

Total Complexity

15

Size/Duplication

Total Lines	178
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

0%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	1
A	textual()	0	19	1
A	selectable()	0	17	1
A	checkable()	0	12	2
A	restrictElements()	0	18	4
B	assert()	0	20	6

<?php
/**
 * @author Sergii Bondarenko, <sb@firstvector.org>
 */
namespace Drupal\TqExtension\Utils;

// Contexts.
use Drupal\TqExtension\Context\RawTqContext;
// Helpers.
use Behat\DebugExtension\Debugger;
use Behat\Mink\Element\NodeElement;

class FormValueAssertion
{
    use Debugger;

    /**
     * @var RawTqContext
     */
    private $context;
    /**
     * @var string
     *   Field selector.
     */
    private $selector = '';
    /**
     * Found element.
     *
     * @var NodeElement
     */
    private $element;
    /**
     * Expected value.
     *
     * @var string
     */
    private $expected = '';
    /**
     * Field element value.
     *
     * @var string
     */
    private $value = '';
    /**
     * Tag name of found element.
     *
     * @var string
     */
    private $tag = '';
    /**
     * Negate the condition.
     *
     * @var bool
     */
    private $not = false;

    /**
     * @param RawTqContext $context
     *   Behat context.
     * @param string $selector
     *   Field selector.
     * @param bool $not
     *   Negate the condition.
     * @param string $expected
     *   Expected value.
     */
    public function __construct(RawTqContext $context, $selector, $not, $expected = '')
    {
        $this->not = (bool) $not;
        $this->context = $context;
        $this->selector = $selector;
        $this->expected = $expected;

        $this->element = $this->context->element('field', $selector);
        $this->value = $this->element->getValue();

It seems like $this->element->getValue() can also be of type boolean or array. However, the property $value is declared as type string. Maybe add an additional type check?

        $this->tag = $this->element->getTagName();
    }

    /**
     * Check value in inputs and text areas.
     */
    public function textual()
    {
        $this->restrictElements([
            'textarea' => [],
            'input' => [],
        ]);

        self::debug([
            'Expected: %s',
            'Value: %s',
            'Tag: %s',
        ], [
            $this->expected,
            $this->value,
            $this->tag,
        ]);

        $this->assert(trim($this->expected) === $this->value);
    }

    /**
     * Ensure option is selected.
     */
    public function selectable()
    {
        $this->restrictElements(['select' => []]);
        $data = [$this->value, $this->element->find('xpath', "//option[@value='$this->value']")->getText()];

        self::debug([
            'Expected: %s',
            'Value: %s',
            'Tag: %s',
        ], [
            $this->expected,
            implode(' => ', $data),
            $this->tag,
        ]);

        $this->assert(in_array($this->expected, $data), 'selected');
    }

    /**
     * Ensure that checkbox/radio button is checked.
     */
    public function checkable()
    {
        $this->restrictElements(['input' => ['radio', 'checkbox']]);

        if (!in_array($this->element->getAttribute('type'), ['radio', 'checkbox'])) {
            throw new \RuntimeException('Element cannot be checked.');
        }

        self::debug(['%s'], [$this->element->getOuterHtml()]);

        $this->assert($this->element->isChecked(), 'checked');
    }

    /**
     * @param array[] $allowedElements
     *   Element machine names.
     */
    private function restrictElements(array $allowedElements)
    {
        // Match element tag with allowed.
        if (!isset($allowedElements[$this->tag])) {
            throw new \RuntimeException("Tag is not allowed: $this->tag.");
        }

        $types = $allowedElements[$this->tag];

        // Restrict by types only if they are specified.
        if (!empty($types)) {
            $type = $this->element->getAttribute('type');

            if (!in_array($type, $types)) {
                throw new \RuntimeException(sprintf('Type "%s" is not allowed for "%s" tag', $type, $this->tag));
            }
        }
    }

    /**
     * @param bool $value
     *   Value for checking.
     * @param string $word
     *   A word for default message (e.g. "checked", "selected", etc).
     *
     * @throws \Exception
     */
    private function assert($value, $word = '')
    {
        if ($value) {
            if ($this->not) {
                throw new \Exception(
                    empty($word)
                    ? 'Field contain a value, but should not.'
                    : "Element is $word, but should not be."
                );
            }
        } else {
            if (!$this->not) {
                throw new \Exception(
                    empty($word)
                    ? 'Field does not contain a value.'
                    : "Element is not $word."
                );
            }
        }
    }
}