Zenstruck\Browser\Extension\Html

Complexity

Total Complexity

27

Size/Duplication

Total Lines	250
Duplicated Lines	0 %

Importance

Changes

0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	assertNotSeeIn()	0	4	1
A	selectFieldOptions()	0	7	2
A	assertNotSeeElement()	0	4	1
A	click()	0	10	2
A	assertSeeElement()	0	4	1
A	assertElementAttributeContains()	0	4	1
A	follow()	0	5	1
A	assertNotSee()	0	4	1
A	fillField()	0	5	1
A	checkField()	0	5	1
A	uncheckField()	0	5	1
A	selectFieldOption()	0	5	1
A	assertNotSelected()	0	12	2
A	assertSeeIn()	0	4	1
A	assertChecked()	0	4	1
A	assertFieldNotEquals()	0	4	1
A	assertSelected()	0	12	2
A	attachFile()	0	5	1
A	assertNotChecked()	0	4	1
A	assertElementAttributeNotContains()	0	4	1
A	assertSee()	0	4	1
A	assertFieldEquals()	0	4	1
A	assertElementCount()	0	4	1

<?php

namespace Zenstruck\Browser\Extension;

use Behat\Mink\Exception\ElementNotFoundException;
use Behat\Mink\Exception\ExpectationException;
use PHPUnit\Framework\Assert as PHPUnit;

The type PHPUnit\Framework\Assert was not found. Maybe you did not declare it correctly or list all dependencies?

/**
 * @author Kevin Bond <kevinbond@gmail.com>
 */
trait Html
{
    /**
     * @return static
     */
    final public function follow(string $link): self
    {
        $this->documentElement()->clickLink($link);

It seems like documentElement() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        return $this;
    }

    /**
     * @return static
     */
    final public function fillField(string $selector, string $value): self
    {
        $this->documentElement()->fillField($selector, $value);

        return $this;
    }

    /**
     * @return static
     */
    public function checkField(string $selector): self
    {
        $this->documentElement()->checkField($selector);

        return $this;
    }

    /**
     * @return static
     */
    public function uncheckField(string $selector): self
    {
        $this->documentElement()->uncheckField($selector);

        return $this;
    }

    /**
     * @return static
     */
    public function selectFieldOption(string $selector, string $value): self
    {
        $this->documentElement()->selectFieldOption($selector, $value);

        return $this;
    }

    /**
     * @return static
     */
    public function selectFieldOptions(string $selector, array $values): self
    {
        foreach ($values as $value) {
            $this->documentElement()->selectFieldOption($selector, $value, true);
        }

        return $this;
    }

    /**
     * @return static
     */
    final public function attachFile(string $selector, string $path): self
    {
        $this->documentElement()->attachFileToField($selector, $path);

        return $this;
    }

    /**
     * @return static
     */
    final public function click(string $selector): self
    {
        try {
            $this->documentElement()->pressButton($selector);
        } catch (ElementNotFoundException $e) {
            // try link
            $this->documentElement()->clickLink($selector);
        }

        return $this;
    }

    /**
     * @return static
     */
    final public function assertSee(string $expected): self
    {
        return $this->wrapMinkExpectation(

It seems like wrapMinkExpectation() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            fn() => $this->webAssert()->pageTextContains($expected)

It seems like webAssert() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        );
    }

    /**
     * @return static
     */
    final public function assertNotSee(string $expected): self
    {
        return $this->wrapMinkExpectation(
            fn() => $this->webAssert()->pageTextNotContains($expected)
        );
    }

    /**
     * @return static
     */
    final public function assertSeeIn(string $selector, string $expected): self
    {
        return $this->wrapMinkExpectation(
            fn() => $this->webAssert()->elementTextContains('css', $selector, $expected)
        );
    }

    /**
     * @return static
     */
    final public function assertNotSeeIn(string $selector, string $expected): self
    {
        return $this->wrapMinkExpectation(
            fn() => $this->webAssert()->elementTextNotContains('css', $selector, $expected)
        );
    }

    /**
     * @return static
     */
    final public function assertSeeElement(string $selector): self
    {
        return $this->wrapMinkExpectation(
            fn() => $this->webAssert()->elementExists('css', $selector)
        );
    }

    /**
     * @return static
     */
    final public function assertNotSeeElement(string $selector): self
    {
        return $this->wrapMinkExpectation(
            fn() => $this->webAssert()->elementNotExists('css', $selector)
        );
    }

    /**
     * @return static
     */
    final public function assertElementCount(string $selector, int $count): self
    {
        return $this->wrapMinkExpectation(
            fn() => $this->webAssert()->elementsCount('css', $selector, $count)
        );
    }

    /**
     * @return static
     */
    final public function assertFieldEquals(string $selector, string $expected): self
    {
        return $this->wrapMinkExpectation(
            fn() => $this->webAssert()->fieldValueEquals($selector, $expected)
        );
    }

    /**
     * @return static
     */
    final public function assertFieldNotEquals(string $selector, string $expected): self
    {
        return $this->wrapMinkExpectation(
            fn() => $this->webAssert()->fieldValueNotEquals($selector, $expected)
        );
    }

    /**
     * @return static
     */
    final public function assertSelected(string $selector, string $expected): self
    {
        try {
            $field = $this->webAssert()->fieldExists($selector);
            PHPUnit::assertTrue(true);
        } catch (ExpectationException $e) {
            PHPUnit::fail($e->getMessage());
        }

        PHPUnit::assertContains($expected, (array) $field->getValue());

        return $this;
    }

    /**
     * @return static
     */
    final public function assertNotSelected(string $selector, string $expected): self
    {
        try {
            $field = $this->webAssert()->fieldExists($selector);
            PHPUnit::assertTrue(true);
        } catch (ExpectationException $e) {
            PHPUnit::fail($e->getMessage());
        }

        PHPUnit::assertNotContains($expected, (array) $field->getValue());

        return $this;
    }

    /**
     * @return static
     */
    final public function assertChecked(string $selector): self
    {
        return $this->wrapMinkExpectation(
            fn() => $this->webAssert()->checkboxChecked($selector)
        );
    }

    /**
     * @return static
     */
    final public function assertNotChecked(string $selector): self
    {
        return $this->wrapMinkExpectation(
            fn() => $this->webAssert()->checkboxNotChecked($selector)
        );
    }

    /**
     * @return static
     */
    final public function assertElementAttributeContains(string $selector, string $attribute, string $expected): self
    {
        return $this->wrapMinkExpectation(
            fn() => $this->webAssert()->elementAttributeContains('css', $selector, $attribute, $expected)
        );
    }

    /**
     * @return static
     */
    final public function assertElementAttributeNotContains(string $selector, string $attribute, string $expected): self
    {
        return $this->wrapMinkExpectation(
            fn() => $this->webAssert()->elementAttributeNotContains('css', $selector, $attribute, $expected)
        );
    }
}