Peridot\Leo\Matcher\ExceptionMatcher

Complexity

Total Complexity

24

Size/Duplication

Total Lines	235
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	setArguments()	0	5	1
A	setExpectedMessage()	0	5	1
A	setMessage()	0	4	1
A	getArguments()	0	4	1
A	getExpectedMessage()	0	4	1
A	getMessage()	0	4	1
A	getTemplate()	0	7	2
A	setMessageTemplate()	0	5	1
A	getMessageTemplate()	0	7	2
A	getDefaultTemplate()	0	9	1
A	getDefaultMessageTemplate()	0	7	1
C	match()	0	38	7
A	doMatch()	0	4	1
A	validateCallable()	0	7	2

<?php
namespace Peridot\Leo\Matcher;

use Exception;
use Peridot\Leo\Matcher\Template\ArrayTemplate;
use Peridot\Leo\Matcher\Template\TemplateInterface;
use Throwable;

/**
 * ExceptionMatcher executes a callable and determines if an exception of a given type was thrown. It optionally
 * matches the exception message.
 *
 * @package Peridot\Leo\Matcher
 */
class ExceptionMatcher extends AbstractMatcher
{
    /**
     * @var array
     */
    protected $arguments = [];

    /**
     * @var string
     */
    protected $expectedMessage = "";

    /**
     * A captured exception message
     *
     * @var string $message
     */
    protected $message;

    /**
     * @var TemplateInterface
     */
    protected $messageTemplate;

    /**
     * @param callable $expected

There is no parameter named $expected. Was it maybe removed?

     */
    public function __construct($exceptionType)
    {
        $this->expected = $exceptionType;
    }

    /**
     * Set arguments to be passed to the callable.
     *
     * @param array $arguments
     * @return $this
     */
    public function setArguments(array $arguments)
    {
        $this->arguments = $arguments;
        return $this;
    }

    /**
     * Set the expected message of the exception.
     *
     * @param string $message
     * @return $this
     */
    public function setExpectedMessage($message)
    {
        $this->expectedMessage = $message;
        return $this;
    }

    /**
     * Set the message thrown from an exception resulting from the
     * callable being invoked.
     *
     * @param string $message
     */
    public function setMessage($message)
    {
        $this->message = $message;
    }

    /**
     * Returns the arguments passed to the callable.
     *
     * @return array
     */
    public function getArguments()
    {
        return $this->arguments;
    }

    /**
     * Return the expected exception message.
     *
     * @return string
     */
    public function getExpectedMessage()
    {
        return $this->expectedMessage;
    }

    /**
     * Return the message thrown by an exception resulting from the callable
     * being invoked.
     *
     * @return string
     */
    public function getMessage()
    {
        return $this->message;
    }

    /**
     * {@inheritdoc}
     *
     * If the expected message has been set, the message template will be used.
     *
     * @return TemplateInterface
     */
    public function getTemplate()
    {
        if ($this->expectedMessage) {
            return $this->getMessageTemplate();
        }
        return parent::getTemplate();
    }

    /**
     * Set the template to be used when an expected exception message is provided.
     *
     * @param TemplateInterface $template
     * @return $this
     */
    public function setMessageTemplate(TemplateInterface $template)
    {
        $this->messageTemplate = $template;
        return $this;
    }

    /**
     * Return a template for rendering exception message templates.
     *
     * return TemplateInterface
     */
    public function getMessageTemplate()
    {
        if ($this->messageTemplate) {
            return $this->messageTemplate;
        }
        return $this->getDefaultMessageTemplate();
    }

    /**
     * {@inheritdoc}
     *
     * @return TemplateInterface
     */
    public function getDefaultTemplate()
    {
        $template = new ArrayTemplate([
            'default' => 'Expected exception of type {{expected}}',
            'negated' => 'Expected type of exception not to be {{expected}}'
        ]);

        return $template;
    }

    /**
     * Return a default template for exception message assertions.
     *
     * @return ArrayTemplate
     */
    public function getDefaultMessageTemplate()
    {
        return new ArrayTemplate([
            'default' => 'Expected exception message {{expected}}, got {{actual}}',
            'negated' => 'Expected exception message {{actual}} not to equal {{expected}}'
        ]);
    }

    /**
     * Executes the callable and matches the exception type and exception message.
     *
     * @param $actual
     * @return Match
     */
    public function match($actual)
    {
        $this->validateCallable($actual);
        $exception = null;

        try {
            call_user_func_array($actual, $this->arguments);
            $isMatch = false;

$isMatch is not used, you could remove the assignment.

        } catch (Exception $exception) {
            // fall-through ...
        } catch (Throwable $exception) {
            // fall-through ...
        }

        if ($exception) {
            $isMatch = $exception instanceof $this->expected;
            $message = $exception->getMessage();

The method getMessage does only exist in Exception, but not in Throwable.

            $this->setMessage($message);
        } else {
            $isMatch = false;
        }

        if ($isMatch && $this->expectedMessage) {
            $isMatch = $message == $this->expectedMessage;

The variable $message does not seem to be defined for all execution paths leading up to this point.

            $expected = $this->expectedMessage;
            $actual = $message;
        } else {
            $expected = $this->expected;
        }

        $isNegated = $this->isNegated();

        if ($isNegated) {
            $isMatch = !$isMatch;
        }

        return new Match($isMatch, $expected, $actual, $isNegated);
    }

    /**
     * Executes the callable and matches the exception type and exception message.
     *
     * @param $actual
     * @return bool
     */
    protected function doMatch($actual)
    {
        // unused
    }

    /**
     * Validate that expected is indeed a valid callable.
     *
     * @throws \BadFunctionCallException
     */
    protected function validateCallable($callable)
    {
        if (!is_callable($callable)) {
            $callable = rtrim(print_r($callable, true));
            throw new \BadFunctionCallException("Invalid callable " . $callable . " given");
        }
    }
}