Behatch\Asserter

Complexity

Total Complexity

23

Size/Duplication

Total Lines	105
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	not()	0	11	2
A	assert()	0	6	2
A	assertContains()	0	9	2
A	assertNotContains()	0	8	2
A	assertCount()	0	7	2
A	assertEquals()	0	7	2
A	assertSame()	0	7	2
A	assertArrayHasKey()	0	7	2
A	assertArrayNotHasKey()	0	8	2
A	assertTrue()	0	4	1
A	assertFalse()	0	6	1
A	assertMatch()	0	11	3

<?php

namespace Behatch;

use Behat\Mink\Exception\ExpectationException;
use Behatch\Exception\MissingPackageException;
use Coduo\PHPMatcher\PHPMatcher;

trait Asserter
{
    protected function not(callable $callbable, $errorMessage)
    {
        try {
            $callbable();
        }
        catch (\Exception $e) {
            return;
        }

        throw new ExpectationException($errorMessage, $this->getSession()->getDriver());

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

    }

    protected function assert($test, $message)
    {
        if ($test === false) {
            throw new ExpectationException($message, $this->getSession()->getDriver());

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

        }
    }

    protected function assertContains($expected, $actual, $message = null)
    {
        $regex   = '/' . preg_quote($expected, '/') . '/ui';

        $this->assert(
            preg_match($regex, $actual) > 0,
            $message ?: "The string '$expected' was not found."
        );
    }

    protected function assertNotContains($expected, $actual, $message = null)
    {
        $message = $message ?: "The string '$expected' was found.";

        $this->not(function () use($expected, $actual) {
                $this->assertContains($expected, $actual);
        }, $message);
    }

    protected function assertCount($expected, array $elements, $message = null)
    {
        $this->assert(
            intval($expected) === count($elements),
            $message ?: sprintf('%d elements found, but should be %d.', count($elements), $expected)
        );
    }

    protected function assertEquals($expected, $actual, $message = null)
    {
        $this->assert(
            $expected == $actual,
            $message ?: "The element '$actual' is not equal to '$expected'"
        );
    }

    protected function assertSame($expected, $actual, $message = null)
    {
        $this->assert(
            $expected === $actual,
            $message ?: "The element '$actual' is not equal to '$expected'"
        );
    }

    protected function assertArrayHasKey($key, $array, $message = null)
    {
        $this->assert(
            isset($array[$key]),
            $message ?: "The array has no key '$key'"
        );
    }

    protected function assertArrayNotHasKey($key, $array, $message = null)
    {
        $message = $message ?: "The array has key '$key'";

        $this->not(function () use($key, $array) {
            $this->assertArrayHasKey($key, $array);
        }, $message);
    }

    protected function assertTrue($value, $message = 'The value is false')
    {
        $this->assert($value, $message);
    }

    protected function assertFalse($value, $message = 'The value is true')
    {
        $this->not(function () use($value) {
            $this->assertTrue($value);
        }, $message);
    }

	protected function assertMatch($pattern, $actual, $message = null)
	{
		if (!class_exists(PHPMatcher::class)) {
			throw new MissingPackageException('coduo/php-matcher', 'assertMatch');
		}

		$this->assert(
			PHPMatcher::match($actual, $pattern, $error),

The variable $error does not exist. Did you forget to declare it?

			$message ?: "The element '$actual' do not match '$pattern'"
		);
	}
}