Assert::throws() - Code Metrics - Inspection of "Support for traversables in InclusionMatcher" - peridot-php/leo - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#23)

by Erin

created 2016-06-10 07:14 UTC

Assert::throws() A

↳ Parent: Assert

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	5
rs	9.4285
cc	1
eloc	3
nc	1
nop	4

<?php
namespace Peridot\Leo\Interfaces;

use Peridot\Leo\Interfaces\Assert\CollectionAssertTrait;
use Peridot\Leo\Interfaces\Assert\ObjectAssertTrait;
use Peridot\Leo\Interfaces\Assert\TypeAssertTrait;
use Peridot\Leo\Assertion;
use Peridot\Leo\Leo;
use Peridot\Leo\Responder\ResponderInterface;

/**
 * Assert is a non-chainable, object oriented interface
 * on top of a Leo Assertion.
 *
 * @method instanceOf() instanceOf(object $actual, string $expected, string $message = "") Perform an instanceof assertion.
 * @method include() include(array $haystack, string $expected, string $message = "") Perform an inclusion assertion.
 *
 * @package Peridot\Leo\Interfaces
 */
class Assert
{
    use TypeAssertTrait;
    use ObjectAssertTrait;
    use CollectionAssertTrait;

    /**
     * An array of operators mapping to assertions.
     *
     * @var array
     */
    public static $operators = [
        '==' => 'loosely->equal',
        '===' => 'equal',
        '>' => 'above',
        '>=' => 'least',
        '<' => 'below',
        '<=' => 'most',
        '!=' => 'not->loosely->equal',
        '!==' => 'not->equal'
    ];

    /**
     * @var Assertion
     */
    protected $assertion;

    /**
     * @param ResponderInterface $responder
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     */
    public function __construct(Assertion $assertion = null)
    {
        if (is_null($assertion)) {
            $assertion = Leo::assertion();
        }
        $this->assertion = $assertion;
    }

    /**
     * Perform an a loose equality assertion.
     *
     * @param mixed $actual
     * @param mixed $expected
     * @param string $message
     */
    public function equal($actual, $expected, $message = "")
    {
        $this->assertion->setActual($actual);
        return $this->assertion->to->loosely->equal($expected, $message);

    }

    /**
     * Perform a negated loose equality assertion.
     *
     * @param mixed $actual
     * @param mixed $expected
     * @param string $message
     */
    public function notEqual($actual, $expected, $message = "")
    {
        $this->assertion->setActual($actual);
        return $this->assertion->to->not->equal($expected, $message);

    }

    /**
     * Performs a throw assertion.
     *
     * @param callable $fn
     * @param $exceptionType
     * @param string $exceptionMessage
     * @param string $message
     */
    public function throws(callable $fn, $exceptionType, $exceptionMessage = "", $message = "")
    {
        $this->assertion->setActual($fn);
        return $this->assertion->to->throw($exceptionType, $exceptionMessage, $message);

    }

    /**
     * Performs a negated throw assertion.
     *
     * @param callable $fn
     * @param $exceptionType
     * @param string $exceptionMessage
     * @param string $message
     */
    public function doesNotThrow(callable $fn, $exceptionType, $exceptionMessage = "", $message = "")
    {
        $this->assertion->setActual($fn);
        return $this->assertion->not->to->throw($exceptionType, $exceptionMessage, $message);

    }

    /**
     * Perform an ok assertion.
     *
     * @param mixed $object
     * @param string $message
     */
    public function ok($object, $message = "")
    {
        $this->assertion->setActual($object);
        return $this->assertion->to->be->ok($message);

    }

    /**
     * Perform a negated assertion.
     *
     * @param mixed $object
     * @param string $message
     */
    public function notOk($object, $message = "")
    {
        $this->assertion->setActual($object);
        return $this->assertion->to->not->be->ok($message);

    }

    /**
     * Perform a strict equality assertion.
     *
     * @param mixed $actual
     * @param mixed $expected
     * @param string $message
     */
    public function strictEqual($actual, $expected, $message = "")
    {
        $this->assertion->setActual($actual);
        return $this->assertion->to->equal($expected, $message);

    }

    /**
     * Perform a negated strict equality assertion.
     *
     * @param mixed $actual
     * @param mixed $expected
     * @param string $message
     */
    public function notStrictEqual($actual, $expected, $message = "")
    {
        $this->assertion->setActual($actual);
        return $this->assertion->to->not->equal($expected, $message);

    }

    /**
     * Perform a pattern assertion.
     *
     * @param string $value
     * @param string $pattern
     * @param string $message
     */
    public function match($value, $pattern, $message = "")
    {
        $this->assertion->setActual($value);
        return $this->assertion->to->match($pattern, $message);

    }

    /**
     * Perform a negated pattern assertion.
     *
     * @param string $value
     * @param string $pattern
     * @param string $message
     */
    public function notMatch($value, $pattern, $message = "")
    {
        $this->assertion->setActual($value);
        return $this->assertion->to->not->match($pattern, $message);

    }

    /**
     * Compare two values using the given operator.
     *
     * @param mixed $left
     * @param string $operator
     * @param mixed $right
     * @param string $message
     */
    public function operator($left, $operator, $right, $message = "")
    {
        if (!isset(static::$operators[$operator])) {
            throw new \InvalidArgumentException("Invalid operator $operator");
        }
        $this->assertion->setActual($left);
        return $this->assertion->{static::$operators[$operator]}($right, $message);
    }

    /**
     * Defined to allow use of reserved words for methods.
     *
     * @param $method
     * @param $args
     */
    public function __call($method, $args)
    {
        switch ($method) {
            case 'instanceOf':
                return call_user_func_array([$this, 'isInstanceOf'], $args);
            case 'include':
                return call_user_func_array([$this, 'isIncluded'], $args);
            default:
                throw new \BadMethodCallException("Call to undefined method $method");
        }
    }
}


1			<?php
2			namespace Peridot\Leo\Interfaces;
3
4			use Peridot\Leo\Interfaces\Assert\CollectionAssertTrait;
5			use Peridot\Leo\Interfaces\Assert\ObjectAssertTrait;
6			use Peridot\Leo\Interfaces\Assert\TypeAssertTrait;
7			use Peridot\Leo\Assertion;
8			use Peridot\Leo\Leo;
9			use Peridot\Leo\Responder\ResponderInterface;
10
11			/**
12			* Assert is a non-chainable, object oriented interface
13			* on top of a Leo Assertion.
14			*
15			* @method instanceOf() instanceOf(object $actual, string $expected, string $message = "") Perform an instanceof assertion.
16			* @method include() include(array $haystack, string $expected, string $message = "") Perform an inclusion assertion.
17			*
18			* @package Peridot\Leo\Interfaces
19			*/
20			class Assert
21			{
22			use TypeAssertTrait;
23			use ObjectAssertTrait;
24			use CollectionAssertTrait;
25
26			/**
27			* An array of operators mapping to assertions.
28			*
29			* @var array
30			*/
31			public static $operators = [
32			'==' => 'loosely->equal',
33			'===' => 'equal',
34			'>' => 'above',
35			'>=' => 'least',
36			'<' => 'below',
37			'<=' => 'most',
38			'!=' => 'not->loosely->equal',
39			'!==' => 'not->equal'
40			];
41
42			/**
43			* @var Assertion
44			*/
45			protected $assertion;
46
47			/**
48			* @param ResponderInterface $responder
			0 ignored issues – show Bug introduced 2016-02-23 04:35 UTC by Report Bug Copy Issue Report There is no parameter named `$responder`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
49			*/
50			public function __construct(Assertion $assertion = null)
51			{
52			if (is_null($assertion)) {
53			$assertion = Leo::assertion();
54			}
55			$this->assertion = $assertion;
56			}
57
58			/**
59			* Perform an a loose equality assertion.
60			*
61			* @param mixed $actual
62			* @param mixed $expected
63			* @param string $message
64			*/
65			public function equal($actual, $expected, $message = "")
66			{
67			$this->assertion->setActual($actual);
68			return $this->assertion->to->loosely->equal($expected, $message);
			0 ignored issues – show Unused Code introduced 2016-02-23 04:35 UTC by Report Bug Copy Issue Report The call to `Assertion::equal()` has too many arguments starting with `$expected`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
69			}
70
71			/**
72			* Perform a negated loose equality assertion.
73			*
74			* @param mixed $actual
75			* @param mixed $expected
76			* @param string $message
77			*/
78			public function notEqual($actual, $expected, $message = "")
79			{
80			$this->assertion->setActual($actual);
81			return $this->assertion->to->not->equal($expected, $message);
			0 ignored issues – show Unused Code introduced 2016-02-23 04:35 UTC by Report Bug Copy Issue Report The call to `Assertion::equal()` has too many arguments starting with `$expected`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
82			}
83
84			/**
85			* Performs a throw assertion.
86			*
87			* @param callable $fn
88			* @param $exceptionType
89			* @param string $exceptionMessage
90			* @param string $message
91			*/
92			public function throws(callable $fn, $exceptionType, $exceptionMessage = "", $message = "")
93			{
94			$this->assertion->setActual($fn);
95			return $this->assertion->to->throw($exceptionType, $exceptionMessage, $message);
			0 ignored issues – show Unused Code introduced 2016-02-23 04:35 UTC by Report Bug Copy Issue Report The call to `Assertion::throw()` has too many arguments starting with `$exceptionType`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
96			}
97
98			/**
99			* Performs a negated throw assertion.
100			*
101			* @param callable $fn
102			* @param $exceptionType
103			* @param string $exceptionMessage
104			* @param string $message
105			*/
106			public function doesNotThrow(callable $fn, $exceptionType, $exceptionMessage = "", $message = "")
107			{
108			$this->assertion->setActual($fn);
109			return $this->assertion->not->to->throw($exceptionType, $exceptionMessage, $message);
			0 ignored issues – show Unused Code introduced 2016-02-23 04:35 UTC by Report Bug Copy Issue Report The call to `Assertion::throw()` has too many arguments starting with `$exceptionType`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
110			}
111
112			/**
113			* Perform an ok assertion.
114			*
115			* @param mixed $object
116			* @param string $message
117			*/
118			public function ok($object, $message = "")
119			{
120			$this->assertion->setActual($object);
121			return $this->assertion->to->be->ok($message);
			0 ignored issues – show Unused Code introduced 2016-02-23 04:35 UTC by Report Bug Copy Issue Report The call to `Assertion::ok()` has too many arguments starting with `$message`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
122			}
123
124			/**
125			* Perform a negated assertion.
126			*
127			* @param mixed $object
128			* @param string $message
129			*/
130			public function notOk($object, $message = "")
131			{
132			$this->assertion->setActual($object);
133			return $this->assertion->to->not->be->ok($message);
			0 ignored issues – show Unused Code introduced 2016-02-23 04:35 UTC by Report Bug Copy Issue Report The call to `Assertion::ok()` has too many arguments starting with `$message`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
134			}
135
136			/**
137			* Perform a strict equality assertion.
138			*
139			* @param mixed $actual
140			* @param mixed $expected
141			* @param string $message
142			*/
143			public function strictEqual($actual, $expected, $message = "")
144			{
145			$this->assertion->setActual($actual);
146			return $this->assertion->to->equal($expected, $message);
			0 ignored issues – show Unused Code introduced 2016-02-23 04:35 UTC by Report Bug Copy Issue Report The call to `Assertion::equal()` has too many arguments starting with `$expected`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
147			}
148
149			/**
150			* Perform a negated strict equality assertion.
151			*
152			* @param mixed $actual
153			* @param mixed $expected
154			* @param string $message
155			*/
156			public function notStrictEqual($actual, $expected, $message = "")
157			{
158			$this->assertion->setActual($actual);
159			return $this->assertion->to->not->equal($expected, $message);
			0 ignored issues – show Unused Code introduced 2016-02-23 04:35 UTC by Report Bug Copy Issue Report The call to `Assertion::equal()` has too many arguments starting with `$expected`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
160			}
161
162			/**
163			* Perform a pattern assertion.
164			*
165			* @param string $value
166			* @param string $pattern
167			* @param string $message
168			*/
169			public function match($value, $pattern, $message = "")
170			{
171			$this->assertion->setActual($value);
172			return $this->assertion->to->match($pattern, $message);
			0 ignored issues – show Unused Code introduced 2016-02-23 04:35 UTC by Report Bug Copy Issue Report The call to `Assertion::match()` has too many arguments starting with `$pattern`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
173			}
174
175			/**
176			* Perform a negated pattern assertion.
177			*
178			* @param string $value
179			* @param string $pattern
180			* @param string $message
181			*/
182			public function notMatch($value, $pattern, $message = "")
183			{
184			$this->assertion->setActual($value);
185			return $this->assertion->to->not->match($pattern, $message);
			0 ignored issues – show Unused Code introduced 2016-02-23 04:35 UTC by Report Bug Copy Issue Report The call to `Assertion::match()` has too many arguments starting with `$pattern`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
186			}
187
188			/**
189			* Compare two values using the given operator.
190			*
191			* @param mixed $left
192			* @param string $operator
193			* @param mixed $right
194			* @param string $message
195			*/
196			public function operator($left, $operator, $right, $message = "")
197			{
198			if (!isset(static::$operators[$operator])) {
199			throw new \InvalidArgumentException("Invalid operator $operator");
200			}
201			$this->assertion->setActual($left);
202			return $this->assertion->{static::$operators[$operator]}($right, $message);
203			}
204
205			/**
206			* Defined to allow use of reserved words for methods.
207			*
208			* @param $method
209			* @param $args
210			*/
211			public function __call($method, $args)
212			{
213			switch ($method) {
214			case 'instanceOf':
215			return call_user_func_array([$this, 'isInstanceOf'], $args);
216			case 'include':
217			return call_user_func_array([$this, 'isIncluded'], $args);
218			default:
219			throw new \BadMethodCallException("Call to undefined method $method");
220			}
221			}
222			}
223

peridot-php / leo

Pull Request — master (#23)

Assert::throws() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like