Expectation::andThrow() - Code Metrics - Inspection of "WIP ->allows() and ->expects() syntax" - padraic/mockery - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#668)

by Dave

created 2017-01-17 18:06 UTC

Expectation::andThrow() A

↳ Parent: Expectation

Complexity

Conditions	2
Paths	2

Size

Total Lines	10
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	2

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	10
ccs	7
cts	7
cp	1
rs	9.4285
cc	2
eloc	7
nc	2
nop	4
crap	2

<?php
/**
 * Mockery
 *
 * LICENSE
 *
 * This source file is subject to the new BSD license that is bundled
 * with this package in the file LICENSE.txt.
 * It is also available through the world-wide-web at this URL:
 * http://github.com/padraic/mockery/blob/master/LICENSE
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to [email protected] so we can send you a copy immediately.
 *
 * @category   Mockery
 * @package    Mockery
 * @copyright  Copyright (c) 2010 Pádraic Brady (http://blog.astrumfutura.com)
 * @license    http://github.com/padraic/mockery/blob/master/LICENSE New BSD License
 */

namespace Mockery;

use Closure;
use Mockery\Matcher\MultiArgumentClosure;

class Expectation implements ExpectationInterface
{
    /**
     * Mock object to which this expectation belongs
     *
     * @var object
     */
    protected $_mock = null;

    /**
     * Method name
     *
     * @var string
     */
    protected $_name = null;

    /**
     * Arguments expected by this expectation
     *
     * @var array
     */
    protected $_expectedArgs = array();

    /**
     * Count validator store
     *
     * @var array
     */
    protected $_countValidators = array();

    /**
     * The count validator class to use
     *
     * @var string
     */
    protected $_countValidatorClass = 'Mockery\CountValidator\Exact';

    /**
     * Actual count of calls to this expectation
     *
     * @var int
     */
    protected $_actualCount = 0;

    /**
     * Value to return from this expectation
     *
     * @var mixed
     */
    protected $_returnValue = null;

    /**
     * Array of return values as a queue for multiple return sequence
     *
     * @var array
     */
    protected $_returnQueue = array();

    /**
     * Array of closures executed with given arguments to generate a result
     * to be returned
     *
     * @var array
     */
    protected $_closureQueue = array();

    /**
     * Array of values to be set when this expectation matches
     *
     * @var array
     */
    protected $_setQueue = array();

    /**
     * Integer representing the call order of this expectation
     *
     * @var int
     */
    protected $_orderNumber = null;

    /**
     * Integer representing the call order of this expectation on a global basis
     *
     * @var int
     */
    protected $_globalOrderNumber = null;

    /**
     * Flag indicating that an exception is expected to be throw (not returned)
     *
     * @var bool
     */
    protected $_throw = false;

    /**
     * Flag indicating whether the order of calling is determined locally or
     * globally
     *
     * @var bool
     */
    protected $_globally = false;

    /**
     * Flag indicating we expect no arguments
     *
     * @var bool
     */
    protected $_noArgsExpectation = false;

    /**
     * Flag indicating if the return value should be obtained from the original
     * class method instead of returning predefined values from the return queue
     *
     * @var bool
     */
    protected $_passthru = false;

    /**
     * Constructor
     *
     * @param \Mockery\MockInterface $mock
     * @param string $name
     */
    public function __construct(\Mockery\MockInterface $mock, $name)
    {
        $this->_mock = $mock;
        $this->_name = $name;
    }

    /**
     * Return a string with the method name and arguments formatted
     *
     * @param string $name Name of the expected method
     * @param array $args List of arguments to the method
     * @return string
     */
    public function __toString()
    {
        return \Mockery::formatArgs($this->_name, $this->_expectedArgs);
    }

    /**
     * Verify the current call, i.e. that the given arguments match those
     * of this expectation
     *
     * @param array $args
     * @return mixed
     */
    public function verifyCall(array $args)
    {
        $this->validateOrder();
        $this->_actualCount++;
        if (true === $this->_passthru) {
            return $this->_mock->mockery_callSubjectMethod($this->_name, $args);
        }
        $return = $this->_getReturnValue($args);
        if ($return instanceof \Exception && $this->_throw === true) {
            throw $return;
        }
        $this->_setValues();
        return $return;
    }

    /**
     * Sets public properties with queued values to the mock object
     *
     * @param array $args
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @return mixed
     */
    protected function _setValues()
    {
        foreach ($this->_setQueue as $name => &$values) {
            if (count($values) > 0) {
                $value = array_shift($values);
                $this->_mock->{$name} = $value;
            }
        }
    }

    /**
     * Fetch the return value for the matching args
     *
     * @param array $args
     * @return mixed
     */
    protected function _getReturnValue(array $args)
    {
        if (count($this->_closureQueue) > 1) {
            return call_user_func_array(array_shift($this->_closureQueue), $args);
        } elseif (count($this->_closureQueue) > 0) {
            return call_user_func_array(current($this->_closureQueue), $args);
        } elseif (count($this->_returnQueue) > 1) {
            return array_shift($this->_returnQueue);
        } elseif (count($this->_returnQueue) > 0) {
            return current($this->_returnQueue);
        }

        return $this->_mock->mockery_returnValueForMethod($this->_name);
    }

    /**
     * Checks if this expectation is eligible for additional calls
     *
     * @return bool
     */
    public function isEligible()
    {
        foreach ($this->_countValidators as $validator) {
            if (!$validator->isEligible($this->_actualCount)) {
                return false;
            }
        }
        return true;
    }

    /**
     * Check if there is a constraint on call count
     *
     * @return bool
     */
    public function isCallCountConstrained()
    {
        return (count($this->_countValidators) > 0);
    }

    /**
     * Verify call order
     *
     * @return void
     */
    public function validateOrder()
    {
        if ($this->_orderNumber) {
            $this->_mock->mockery_validateOrder((string) $this, $this->_orderNumber, $this->_mock);
        }
        if ($this->_globalOrderNumber) {
            $this->_mock->mockery_getContainer()
                ->mockery_validateOrder((string) $this, $this->_globalOrderNumber, $this->_mock);
        }
    }

    /**
     * Verify this expectation
     *
     * @return bool
     */
    public function verify()
    {
        foreach ($this->_countValidators as $validator) {
            $validator->validate($this->_actualCount);
        }
    }

    /**
     * Check if the registered expectation is a MultiArgumentClosureExpectation.
     * @return bool
     */
    private function isMultiArgumentClosureExpectation()
    {
        return (count($this->_expectedArgs) === 1 && ($this->_expectedArgs[0] instanceof \Mockery\Matcher\MultiArgumentClosure));
    }

    /**
     * Check if passed arguments match an argument expectation
     *
     * @param array $args
     * @return bool
     */
    public function matchArgs(array $args)
    {
        if (empty($this->_expectedArgs) && !$this->_noArgsExpectation) {
            return true;
        }
        if ($this->isMultiArgumentClosureExpectation()) {
            return $this->_matchArg($this->_expectedArgs[0], $args);
        }
        $argCount = count($args);
        if ($argCount !== count($this->_expectedArgs)) {
            return false;
        }
        for ($i=0; $i<$argCount; $i++) {
            $param =& $args[$i];
            if (!$this->_matchArg($this->_expectedArgs[$i], $param)) {
                return false;
            }
        }

        return true;
    }

    /**
     * Check if passed argument matches an argument expectation
     *
     * @param mixed $expected
     * @param mixed &$actual
     * @return bool
     */
    protected function _matchArg($expected, &$actual)
    {
        if ($expected === $actual) {
            return true;
        }
        if (!is_object($expected) && !is_object($actual) && $expected == $actual) {
            return true;
        }
        if (is_string($expected) && !is_array($actual) && !is_object($actual)) {
            # push/pop an error handler here to to make sure no error/exception thrown if $expected is not a regex
            set_error_handler(function () {
            });
            $result = preg_match($expected, (string) $actual);
            restore_error_handler();

            if ($result) {
                return true;
            }
        }
        if (is_string($expected) && is_object($actual)) {
            $result = $actual instanceof $expected;
            if ($result) {
                return true;
            }
        }
        if ($expected instanceof \Mockery\Matcher\MatcherAbstract) {
            return $expected->match($actual);
        }
        if ($expected instanceof \Hamcrest\Matcher || $expected instanceof \Hamcrest_Matcher) {
if ($x instanceof DoesNotExist) {
    // Do something.
}
            return $expected->matches($actual);
        }
        return false;
    }

    /**
     * Expected argument setter for the expectation
     *
     * @param mixed ...
     * @return self
     */
    public function with()
    {
        return $this->withArgs(func_get_args());
    }

    /**
     * Expected arguments for the expectation passed as an array
     *
     * @param array $arguments
     * @return self
     */
    private function withArgsInArray(array $arguments)
    {
        if (empty($arguments)) {
            return $this->withNoArgs();
        }
        $this->_expectedArgs = $arguments;
        $this->_noArgsExpectation = false;
        return $this;
    }

    /**
     * Expected arguments have to be matched by the given closure.
     *
     * @param Closure $closure
     * @return self
     */
    private function withArgsMatchedByClosure(Closure $closure)
    {
        $this->_expectedArgs = [new MultiArgumentClosure($closure)];
        $this->_noArgsExpectation = false;
        return $this;
    }

    /**
     * Expected arguments for the expectation passed as an array or a closure that matches each passed argument on
     * each function call.
     *
     * @param array|Closure $argsOrClosure
     * @return self
     */
    public function withArgs($argsOrClosure)
    {
        if (is_array($argsOrClosure)) {
            $this->withArgsInArray($argsOrClosure);
        } elseif ($argsOrClosure instanceof Closure) {
            $this->withArgsMatchedByClosure($argsOrClosure);
        } else {
            throw new \InvalidArgumentException(sprintf('Call to %s with an invalid argument (%s), only array and '.
                'closure are allowed', __METHOD__, $argsOrClosure));
        }
        return $this;
    }

    /**
     * Set with() as no arguments expected
     *
     * @return self
     */
    public function withNoArgs()
    {
        $this->_noArgsExpectation = true;
        $this->_expectedArgs = [];
        return $this;
    }

    /**
     * Set expectation that any arguments are acceptable
     *
     * @return self
     */
    public function withAnyArgs()
    {
        $this->_expectedArgs = array();
        return $this;
    }

    /**
     * Set a return value, or sequential queue of return values
     *
     * @param mixed ...
     * @return self
     */
    public function andReturn()
    {
        $this->_returnQueue = func_get_args();
        return $this;
    }

    /**
     * Set a return value, or sequential queue of return values
     *
     * @param mixed ...
     * @return self
     */
    public function andReturns()
    {
        return call_user_func_array([$this, 'andReturn'], func_get_args());
    }

    /**
     * Return this mock, like a fluent interface
     *
     * @return self
     */
    public function andReturnSelf()
    {
        return $this->andReturn($this->_mock);
    }

    /**
     * Set a sequential queue of return values with an array
     *
     * @param array $values
     * @return self
     */
    public function andReturnValues(array $values)
    {
        call_user_func_array(array($this, 'andReturn'), $values);
        return $this;
    }

    /**
     * Set a closure or sequence of closures with which to generate return
     * values. The arguments passed to the expected method are passed to the
     * closures as parameters.
     *
     * @param callable ...
     * @return self
     */
    public function andReturnUsing()
    {
        $this->_closureQueue = func_get_args();
        return $this;
    }

    /**
     * Return a self-returning black hole object.
     *
     * @return self
     */
    public function andReturnUndefined()
    {
        $this->andReturn(new \Mockery\Undefined);
        return $this;
    }

    /**
     * Return null. This is merely a language construct for Mock describing.
     *
     * @return self
     */
    public function andReturnNull()
    {
        return $this;
    }

    public function andReturnFalse()
    {
        return $this->andReturn(false);
    }

    public function andReturnTrue()
    {
        return $this->andReturn(true);
    }

    /**
     * Set Exception class and arguments to that class to be thrown
     *
     * @param string|\Exception $exception
     * @param string $message
     * @param int $code
     * @param \Exception $previous
     * @return self
     */
    public function andThrow($exception, $message = '', $code = 0, \Exception $previous = null)
    {
        $this->_throw = true;
        if (is_object($exception)) {
            $this->andReturn($exception);
        } else {
            $this->andReturn(new $exception($message, $code, $previous));
        }
        return $this;
    }

    /**
     * Set Exception classes to be thrown
     *
     * @param array $exceptions
     * @return self
     */
    public function andThrowExceptions(array $exceptions)
    {
        $this->_throw = true;
        foreach ($exceptions as $exception) {
            if (!is_object($exception)) {
                throw new Exception('You must pass an array of exception objects to andThrowExceptions');
            }
        }
        return $this->andReturnValues($exceptions);
    }

    /**
     * Register values to be set to a public property each time this expectation occurs
     *
     * @param string $name
     * @param mixed $value
     * @return self
     */
    public function andSet($name, $value)
    {
        $values = func_get_args();
        array_shift($values);
        $this->_setQueue[$name] = $values;
        return $this;
    }

    /**
     * Alias to andSet(). Allows the natural English construct
     * - set('foo', 'bar')->andReturn('bar')
     *
     * @param string $name
     * @param mixed $value
     * @return self
     */
    public function set($name, $value)
    {
        return call_user_func_array(array($this, 'andSet'), func_get_args());
    }

    /**
     * Indicates this expectation should occur zero or more times
     *
     * @return self
     */
    public function zeroOrMoreTimes()
    {
        $this->atLeast()->never();
    }

    /**
     * Indicates the number of times this expectation should occur
     *
     * @param int $limit
     * @throws InvalidArgumentException
     * @return self
     */
    public function times($limit = null)
    {
        if (is_null($limit)) {
            return $this;
        }
        if (!is_int($limit)) {
            throw new \InvalidArgumentException('The passed Times limit should be an integer value');
        }
        $this->_countValidators[] = new $this->_countValidatorClass($this, $limit);
        $this->_countValidatorClass = 'Mockery\CountValidator\Exact';
        return $this;
    }

    /**
     * Indicates that this expectation is never expected to be called
     *
     * @return self
     */
    public function never()
    {
        return $this->times(0);
    }

    /**
     * Indicates that this expectation is expected exactly once
     *
     * @return self
     */
    public function once()
    {
        return $this->times(1);
    }

    /**
     * Indicates that this expectation is expected exactly twice
     *
     * @return self
     */
    public function twice()
    {
        return $this->times(2);
    }

    /**
     * Sets next count validator to the AtLeast instance
     *
     * @return self
     */
    public function atLeast()
    {
        $this->_countValidatorClass = 'Mockery\CountValidator\AtLeast';
        return $this;
    }

    /**
     * Sets next count validator to the AtMost instance
     *
     * @return self
     */
    public function atMost()
    {
        $this->_countValidatorClass = 'Mockery\CountValidator\AtMost';
        return $this;
    }

    /**
     * Shorthand for setting minimum and maximum constraints on call counts
     *
     * @param int $minimum
     * @param int $maximum
     */
    public function between($minimum, $maximum)
    {
        return $this->atLeast()->times($minimum)->atMost()->times($maximum);
    }

    /**
     * Indicates that this expectation must be called in a specific given order
     *
     * @param string $group Name of the ordered group
     * @return self
     */
    public function ordered($group = null)
    {
        if ($this->_globally) {
            $this->_globalOrderNumber = $this->_defineOrdered($group, $this->_mock->mockery_getContainer());
        } else {
            $this->_orderNumber = $this->_defineOrdered($group, $this->_mock);
        }
        $this->_globally = false;
        return $this;
    }

    /**
     * Indicates call order should apply globally
     *
     * @return self
     */
    public function globally()
    {
        $this->_globally = true;
        return $this;
    }

    /**
     * Setup the ordering tracking on the mock or mock container
     *
     * @param string $group
     * @param object $ordering
     * @return int
     */
    protected function _defineOrdered($group, $ordering)
    {
        $groups = $ordering->mockery_getGroups();
        if (is_null($group)) {
            $result = $ordering->mockery_allocateOrder();
        } elseif (isset($groups[$group])) {
            $result = $groups[$group];
        } else {
            $result = $ordering->mockery_allocateOrder();
            $ordering->mockery_setGroup($group, $result);
        }
        return $result;
    }

    /**
     * Return order number
     *
     * @return int
     */
    public function getOrderNumber()
    {
        return $this->_orderNumber;
    }

    /**
     * Mark this expectation as being a default
     *
     * @return self
     */
    public function byDefault()
    {
        $director = $this->_mock->mockery_getExpectationsFor($this->_name);
        if (!empty($director)) {
            $director->makeExpectationDefault($this);
        }
        return $this;
    }

    /**
     * Return the parent mock of the expectation
     *
     * @return \Mockery\MockInterface
     */
    public function getMock()
    {
        return $this->_mock;
    }

    /**
     * Flag this expectation as calling the original class method with the
     * any provided arguments instead of using a return value queue.
     *
     * @return self
     */
    public function passthru()
    {
        if ($this->_mock instanceof Mock) {
            throw new Exception(
                'Mock Objects not created from a loaded/existing class are '
                . 'incapable of passing method calls through to a parent class'
            );
        }
        $this->_passthru = true;
        return $this;
    }

    /**
     * Cloning logic
     *
     */
    public function __clone()
    {
        $newValidators = array();
        $countValidators = $this->_countValidators;
        foreach ($countValidators as $validator) {
            $newValidators[] = clone $validator;
        }
        $this->_countValidators = $newValidators;
    }

    public function getName()
    {
        return $this->_name;
    }
}


Pull Request — master (#668)

Expectation::andThrow() A

Complexity

Size

Duplication

Code Coverage

Importance

1. Missing dependencies

2. Missing use statement

1		<?php
2		/**
3		* Mockery
4		*
5		* LICENSE
6		*
7		* This source file is subject to the new BSD license that is bundled
8		* with this package in the file LICENSE.txt.
9		* It is also available through the world-wide-web at this URL:
10		* http://github.com/padraic/mockery/blob/master/LICENSE
11		* If you did not receive a copy of the license and are unable to
12		* obtain it through the world-wide-web, please send an email
13		* to [email protected] so we can send you a copy immediately.
14		*
15		* @category Mockery
16		* @package Mockery
17		* @copyright Copyright (c) 2010 Pádraic Brady (http://blog.astrumfutura.com)
18		* @license http://github.com/padraic/mockery/blob/master/LICENSE New BSD License
19		*/
20
21		namespace Mockery;
22
23		use Closure;
24		use Mockery\Matcher\MultiArgumentClosure;
25
26		class Expectation implements ExpectationInterface
27		{
28		/**
29		* Mock object to which this expectation belongs
30		*
31		* @var object
32		*/
33		protected $_mock = null;
34
35		/**
36		* Method name
37		*
38		* @var string
39		*/
40		protected $_name = null;
41
42		/**
43		* Arguments expected by this expectation
44		*
45		* @var array
46		*/
47		protected $_expectedArgs = array();
48
49		/**
50		* Count validator store
51		*
52		* @var array
53		*/
54		protected $_countValidators = array();
55
56		/**
57		* The count validator class to use
58		*
59		* @var string
60		*/
61		protected $_countValidatorClass = 'Mockery\CountValidator\Exact';
62
63		/**
64		* Actual count of calls to this expectation
65		*
66		* @var int
67		*/
68		protected $_actualCount = 0;
69
70		/**
71		* Value to return from this expectation
72		*
73		* @var mixed
74		*/
75		protected $_returnValue = null;
76
77		/**
78		* Array of return values as a queue for multiple return sequence
79		*
80		* @var array
81		*/
82		protected $_returnQueue = array();
83
84		/**
85		* Array of closures executed with given arguments to generate a result
86		* to be returned
87		*
88		* @var array
89		*/
90		protected $_closureQueue = array();
91
92		/**
93		* Array of values to be set when this expectation matches
94		*
95		* @var array
96		*/
97		protected $_setQueue = array();
98
99		/**
100		* Integer representing the call order of this expectation
101		*
102		* @var int
103		*/
104		protected $_orderNumber = null;
105
106		/**
107		* Integer representing the call order of this expectation on a global basis
108		*
109		* @var int
110		*/
111		protected $_globalOrderNumber = null;
112
113		/**
114		* Flag indicating that an exception is expected to be throw (not returned)
115		*
116		* @var bool
117		*/
118		protected $_throw = false;
119
120		/**
121		* Flag indicating whether the order of calling is determined locally or
122		* globally
123		*
124		* @var bool
125		*/
126		protected $_globally = false;
127
128		/**
129		* Flag indicating we expect no arguments
130		*
131		* @var bool
132		*/
133		protected $_noArgsExpectation = false;
134
135		/**
136		* Flag indicating if the return value should be obtained from the original
137		* class method instead of returning predefined values from the return queue
138		*
139		* @var bool
140		*/
141		protected $_passthru = false;
142
143		/**
144		* Constructor
145		*
146		* @param \Mockery\MockInterface $mock
147		* @param string $name
148		*/
149	314	public function __construct(\Mockery\MockInterface $mock, $name)
150		{
151	314	$this->_mock = $mock;
152	314	$this->_name = $name;
153	314	}
154
155		/**
156		* Return a string with the method name and arguments formatted
157		*
158		* @param string $name Name of the expected method
159		* @param array $args List of arguments to the method
160		* @return string
161		*/
162	46	public function __toString()
163		{
164	46	return \Mockery::formatArgs($this->_name, $this->_expectedArgs);
165		}
166
167		/**
168		* Verify the current call, i.e. that the given arguments match those
169		* of this expectation
170		*
171		* @param array $args
172		* @return mixed
173		*/
174	241	public function verifyCall(array $args)
175		{
176	241	$this->validateOrder();
177	241	$this->_actualCount++;
178	241	if (true === $this->_passthru) {
179	3	return $this->_mock->mockery_callSubjectMethod($this->_name, $args);
180		}
181	239	$return = $this->_getReturnValue($args);
182	239	if ($return instanceof \Exception && $this->_throw === true) {
183	7	throw $return;
184		}
185	233	$this->_setValues();
186	233	return $return;
187		}
188
189		/**
190		* Sets public properties with queued values to the mock object
191		*
192		* @param array $args
		0 ignored issues – show Bug introduced 2016-03-01 17:54 UTC by Report Bug Copy Issue Report There is no parameter named `$args`. 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...
193		* @return mixed
194		*/
195	233	protected function _setValues()
196		{
197	233	foreach ($this->_setQueue as $name => &$values) {
198	8	if (count($values) > 0) {
199	8	$value = array_shift($values);
200	8	$this->_mock->{$name} = $value;
201	8	}
202	233	}
203	233	}
204
205		/**
206		* Fetch the return value for the matching args
207		*
208		* @param array $args
209		* @return mixed
210		*/
211	239	protected function _getReturnValue(array $args)
212		{
213	239	if (count($this->_closureQueue) > 1) {
214		return call_user_func_array(array_shift($this->_closureQueue), $args);
215	239	} elseif (count($this->_closureQueue) > 0) {
216	1	return call_user_func_array(current($this->_closureQueue), $args);
217	238	} elseif (count($this->_returnQueue) > 1) {
218	5	return array_shift($this->_returnQueue);
219	237	} elseif (count($this->_returnQueue) > 0) {
220	100	return current($this->_returnQueue);
221		}
222
223	138	return $this->_mock->mockery_returnValueForMethod($this->_name);
224		}
225
226		/**
227		* Checks if this expectation is eligible for additional calls
228		*
229		* @return bool
230		*/
231	281	public function isEligible()
232		{
233	281	foreach ($this->_countValidators as $validator) {
234	141	if (!$validator->isEligible($this->_actualCount)) {
235	23	return false;
236		}
237	278	}
238	278	return true;
239		}
240
241		/**
242		* Check if there is a constraint on call count
243		*
244		* @return bool
245		*/
246		public function isCallCountConstrained()
247		{
248		return (count($this->_countValidators) > 0);
249		}
250
251		/**
252		* Verify call order
253		*
254		* @return void
255		*/
256	241	public function validateOrder()
257		{
258	241	if ($this->_orderNumber) {
259	17	$this->_mock->mockery_validateOrder((string) $this, $this->_orderNumber, $this->_mock);
260	17	}
261	241	if ($this->_globalOrderNumber) {
262	1	$this->_mock->mockery_getContainer()
263	1	->mockery_validateOrder((string) $this, $this->_globalOrderNumber, $this->_mock);
264	1	}
265	241	}
266
267		/**
268		* Verify this expectation
269		*
270		* @return bool
271		*/
272	151	public function verify()
273		{
274	151	foreach ($this->_countValidators as $validator) {
275	121	$validator->validate($this->_actualCount);
276	135	}
277	133	}
278
279		/**
280		* Check if the registered expectation is a MultiArgumentClosureExpectation.
281		* @return bool
282		*/
283	125	private function isMultiArgumentClosureExpectation()
284		{
285	125	return (count($this->_expectedArgs) === 1 && ($this->_expectedArgs[0] instanceof \Mockery\Matcher\MultiArgumentClosure));
286		}
287
288		/**
289		* Check if passed arguments match an argument expectation
290		*
291		* @param array $args
292		* @return bool
293		*/
294	287	public function matchArgs(array $args)
295		{
296	287	if (empty($this->_expectedArgs) && !$this->_noArgsExpectation) {
297	166	return true;
298		}
299	125	if ($this->isMultiArgumentClosureExpectation()) {
300	6	return $this->_matchArg($this->_expectedArgs[0], $args);
301		}
302	119	$argCount = count($args);
303	119	if ($argCount !== count($this->_expectedArgs)) {
304	8	return false;
305		}
306	113	for ($i=0; $i<$argCount; $i++) {
307	110	$param =& $args[$i];
308	110	if (!$this->_matchArg($this->_expectedArgs[$i], $param)) {
309	47	return false;
310		}
311	72	}
312
313	75	return true;
314		}
315
316		/**
317		* Check if passed argument matches an argument expectation
318		*
319		* @param mixed $expected
320		* @param mixed &$actual
321		* @return bool
322		*/
323	116	protected function _matchArg($expected, &$actual)
324		{
325	116	if ($expected === $actual) {
326	33	return true;
327		}
328	95	if (!is_object($expected) && !is_object($actual) && $expected == $actual) {
329	1	return true;
330		}
331	94	if (is_string($expected) && !is_array($actual) && !is_object($actual)) {
332		# push/pop an error handler here to to make sure no error/exception thrown if $expected is not a regex
333	6	set_error_handler(function () {
334	6	});
335	6	$result = preg_match($expected, (string) $actual);
336	6	restore_error_handler();
337
338	6	if ($result) {
339	3	return true;
340		}
341	3	}
342	93	if (is_string($expected) && is_object($actual)) {
343	1	$result = $actual instanceof $expected;
344	1	if ($result) {
345	1	return true;
346		}
347		}
348	92	if ($expected instanceof \Mockery\Matcher\MatcherAbstract) {
349	70	return $expected->match($actual);
350		}
351	22	if ($expected instanceof \Hamcrest\Matcher \|\| $expected instanceof \Hamcrest_Matcher) {
		0 ignored issues – show Bug introduced 2016-02-02 11:18 UTC by Report Bug Copy Issue Report The class `Hamcrest_Matcher` does not exist. Did you forget a USE statement, or did you not list all dependencies? This error could be the result of: 1. Missing dependencies PHP Analyzer uses your `composer.json` file (if available) to determine the dependencies of your project and to determine all the available classes and functions. It expects the `composer.json` to be in the root folder of your repository. Are you sure this class is defined by one of your dependencies, or did you maybe not list a dependency in either the `require` or `require-dev` section? 2. Missing use statement PHP does not complain about undefined classes in `ìnstanceof` checks. For example, the following PHP code will work perfectly fine: if ($x instanceof DoesNotExist) { // Do something. } If you have not tested against this specific condition, such errors might go unnoticed. Loading history...
352	3	return $expected->matches($actual);
353		}
354	19	return false;
355		}
356
357		/**
358		* Expected argument setter for the expectation
359		*
360		* @param mixed ...
361		* @return self
362		*/
363	140	public function with()
364		{
365	140	return $this->withArgs(func_get_args());
366		}
367
368		/**
369		* Expected arguments for the expectation passed as an array
370		*
371		* @param array $arguments
372		* @return self
373		*/
374	147	private function withArgsInArray(array $arguments)
375		{
376	147	if (empty($arguments)) {
377	6	return $this->withNoArgs();
378		}
379	144	$this->_expectedArgs = $arguments;
380	144	$this->_noArgsExpectation = false;
381	144	return $this;
382		}
383
384		/**
385		* Expected arguments have to be matched by the given closure.
386		*
387		* @param Closure $closure
388		* @return self
389		*/
390	6	private function withArgsMatchedByClosure(Closure $closure)
391		{
392	6	$this->_expectedArgs = [new MultiArgumentClosure($closure)];
393	6	$this->_noArgsExpectation = false;
394	6	return $this;
395		}
396
397		/**
398		* Expected arguments for the expectation passed as an array or a closure that matches each passed argument on
399		* each function call.
400		*
401		* @param array\|Closure $argsOrClosure
402		* @return self
403		*/
404	154	public function withArgs($argsOrClosure)
405		{
406	154	if (is_array($argsOrClosure)) {
407	147	$this->withArgsInArray($argsOrClosure);
408	154	} elseif ($argsOrClosure instanceof Closure) {
409	6	$this->withArgsMatchedByClosure($argsOrClosure);
410	6	} else {
411	1	throw new \InvalidArgumentException(sprintf('Call to %s with an invalid argument (%s), only array and '.
412	1	'closure are allowed', __METHOD__, $argsOrClosure));
413		}
414	153	return $this;
415		}
416
417		/**
418		* Set with() as no arguments expected
419		*
420		* @return self
421		*/
422	10	public function withNoArgs()
423		{
424	10	$this->_noArgsExpectation = true;
425	10	$this->_expectedArgs = [];
426	10	return $this;
427		}
428
429		/**
430		* Set expectation that any arguments are acceptable
431		*
432		* @return self
433		*/
434	2	public function withAnyArgs()
435		{
436	2	$this->_expectedArgs = array();
437	2	return $this;
438		}
439
440		/**
441		* Set a return value, or sequential queue of return values
442		*
443		* @param mixed ...
444		* @return self
445		*/
446	115	public function andReturn()
447		{
448	115	$this->_returnQueue = func_get_args();
449	115	return $this;
450		}
451
452		/**
453		* Set a return value, or sequential queue of return values
454		*
455		* @param mixed ...
456		* @return self
457		*/
458		public function andReturns()
459		{
460		return call_user_func_array([$this, 'andReturn'], func_get_args());
461		}
462
463		/**
464		* Return this mock, like a fluent interface
465		*
466		* @return self
467		*/
468	1	public function andReturnSelf()
469		{
470	1	return $this->andReturn($this->_mock);
471		}
472
473		/**
474		* Set a sequential queue of return values with an array
475		*
476		* @param array $values
477		* @return self
478		*/
479	2	public function andReturnValues(array $values)
480		{
481	2	call_user_func_array(array($this, 'andReturn'), $values);
482	2	return $this;
483		}
484
485		/**
486		* Set a closure or sequence of closures with which to generate return
487		* values. The arguments passed to the expected method are passed to the
488		* closures as parameters.
489		*
490		* @param callable ...
491		* @return self
492		*/
493	1	public function andReturnUsing()
494		{
495	1	$this->_closureQueue = func_get_args();
496	1	return $this;
497		}
498
499		/**
500		* Return a self-returning black hole object.
501		*
502		* @return self
503		*/
504	1	public function andReturnUndefined()
505		{
506	1	$this->andReturn(new \Mockery\Undefined);
507	1	return $this;
508		}
509
510		/**
511		* Return null. This is merely a language construct for Mock describing.
512		*
513		* @return self
514		*/
515	1	public function andReturnNull()
516		{
517	1	return $this;
518		}
519
520	1	public function andReturnFalse()
521		{
522	1	return $this->andReturn(false);
523		}
524
525	1	public function andReturnTrue()
526		{
527	1	return $this->andReturn(true);
528		}
529
530		/**
531		* Set Exception class and arguments to that class to be thrown
532		*
533		* @param string\|\Exception $exception
534		* @param string $message
535		* @param int $code
536		* @param \Exception $previous
537		* @return self
538		*/
539	6	public function andThrow($exception, $message = '', $code = 0, \Exception $previous = null)
540		{
541	6	$this->_throw = true;
542	6	if (is_object($exception)) {
543	2	$this->andReturn($exception);
544	2	} else {
545	4	$this->andReturn(new $exception($message, $code, $previous));
546		}
547	6	return $this;
548		}
549
550		/**
551		* Set Exception classes to be thrown
552		*
553		* @param array $exceptions
554		* @return self
555		*/
556	2	public function andThrowExceptions(array $exceptions)
557		{
558	2	$this->_throw = true;
559	2	foreach ($exceptions as $exception) {
560	2	if (!is_object($exception)) {
561	1	throw new Exception('You must pass an array of exception objects to andThrowExceptions');
562		}
563	1	}
564	1	return $this->andReturnValues($exceptions);
565		}
566
567		/**
568		* Register values to be set to a public property each time this expectation occurs
569		*
570		* @param string $name
571		* @param mixed $value
572		* @return self
573		*/
574	8	public function andSet($name, $value)
575		{
576	8	$values = func_get_args();
577	8	array_shift($values);
578	8	$this->_setQueue[$name] = $values;
579	8	return $this;
580		}
581
582		/**
583		* Alias to andSet(). Allows the natural English construct
584		* - set('foo', 'bar')->andReturn('bar')
585		*
586		* @param string $name
587		* @param mixed $value
588		* @return self
589		*/
590	3	public function set($name, $value)
591		{
592	3	return call_user_func_array(array($this, 'andSet'), func_get_args());
593		}
594
595		/**
596		* Indicates this expectation should occur zero or more times
597		*
598		* @return self
599		*/
600	2	public function zeroOrMoreTimes()
601		{
602	2	$this->atLeast()->never();
603	2	}
604
605		/**
606		* Indicates the number of times this expectation should occur
607		*
608		* @param int $limit
609		* @throws InvalidArgumentException
610		* @return self
611		*/
612	160	public function times($limit = null)
613		{
614	160	if (is_null($limit)) {
615		return $this;
616		}
617	160	if (!is_int($limit)) {
618	1	throw new \InvalidArgumentException('The passed Times limit should be an integer value');
619		}
620	159	$this->_countValidators[] = new $this->_countValidatorClass($this, $limit);
621	159	$this->_countValidatorClass = 'Mockery\CountValidator\Exact';
622	159	return $this;
623		}
624
625		/**
626		* Indicates that this expectation is never expected to be called
627		*
628		* @return self
629		*/
630	38	public function never()
631		{
632	38	return $this->times(0);
633		}
634
635		/**
636		* Indicates that this expectation is expected exactly once
637		*
638		* @return self
639		*/
640	110	public function once()
641		{
642	110	return $this->times(1);
643		}
644
645		/**
646		* Indicates that this expectation is expected exactly twice
647		*
648		* @return self
649		*/
650	18	public function twice()
651		{
652	18	return $this->times(2);
653		}
654
655		/**
656		* Sets next count validator to the AtLeast instance
657		*
658		* @return self
659		*/
660	14	public function atLeast()
661		{
662	14	$this->_countValidatorClass = 'Mockery\CountValidator\AtLeast';
663	14	return $this;
664		}
665
666		/**
667		* Sets next count validator to the AtMost instance
668		*
669		* @return self
670		*/
671	7	public function atMost()
672		{
673	7	$this->_countValidatorClass = 'Mockery\CountValidator\AtMost';
674	7	return $this;
675		}
676
677		/**
678		* Shorthand for setting minimum and maximum constraints on call counts
679		*
680		* @param int $minimum
681		* @param int $maximum
682		*/
683		public function between($minimum, $maximum)
684		{
685		return $this->atLeast()->times($minimum)->atMost()->times($maximum);
686		}
687
688		/**
689		* Indicates that this expectation must be called in a specific given order
690		*
691		* @param string $group Name of the ordered group
692		* @return self
693		*/
694	20	public function ordered($group = null)
695		{
696	20	if ($this->_globally) {
697	1	$this->_globalOrderNumber = $this->_defineOrdered($group, $this->_mock->mockery_getContainer());
698	1	} else {
699	19	$this->_orderNumber = $this->_defineOrdered($group, $this->_mock);
700		}
701	20	$this->_globally = false;
702	20	return $this;
703		}
704
705		/**
706		* Indicates call order should apply globally
707		*
708		* @return self
709		*/
710	1	public function globally()
711		{
712	1	$this->_globally = true;
713	1	return $this;
714		}
715
716		/**
717		* Setup the ordering tracking on the mock or mock container
718		*
719		* @param string $group
720		* @param object $ordering
721		* @return int
722		*/
723	20	protected function _defineOrdered($group, $ordering)
724		{
725	20	$groups = $ordering->mockery_getGroups();
726	20	if (is_null($group)) {
727	19	$result = $ordering->mockery_allocateOrder();
728	20	} elseif (isset($groups[$group])) {
729	2	$result = $groups[$group];
730	2	} else {
731	4	$result = $ordering->mockery_allocateOrder();
732	4	$ordering->mockery_setGroup($group, $result);
733		}
734	20	return $result;
735		}
736
737		/**
738		* Return order number
739		*
740		* @return int
741		*/
742	1	public function getOrderNumber()
743		{
744	1	return $this->_orderNumber;
745		}
746
747		/**
748		* Mark this expectation as being a default
749		*
750		* @return self
751		*/
752	25	public function byDefault()
753		{
754	25	$director = $this->_mock->mockery_getExpectationsFor($this->_name);
755	25	if (!empty($director)) {
756	25	$director->makeExpectationDefault($this);
757	24	}
758	24	return $this;
759		}
760
761		/**
762		* Return the parent mock of the expectation
763		*
764		* @return \Mockery\MockInterface
765		*/
766	29	public function getMock()
767		{
768	29	return $this->_mock;
769		}
770
771		/**
772		* Flag this expectation as calling the original class method with the
773		* any provided arguments instead of using a return value queue.
774		*
775		* @return self
776		*/
777	3	public function passthru()
778		{
779	3	if ($this->_mock instanceof Mock) {
780		throw new Exception(
781		'Mock Objects not created from a loaded/existing class are '
782		. 'incapable of passing method calls through to a parent class'
783		);
784		}
785	3	$this->_passthru = true;
786	3	return $this;
787		}
788
789		/**
790		* Cloning logic
791		*
792		*/
793	9	public function __clone()
794		{
795	9	$newValidators = array();
796	9	$countValidators = $this->_countValidators;
797	9	foreach ($countValidators as $validator) {
798	6	$newValidators[] = clone $validator;
799	9	}
800	9	$this->_countValidators = $newValidators;
801	9	}
802
803	6	public function getName()
804		{
805	6	return $this->_name;
806		}
807		}
808

padraic / mockery

Pull Request — master (#668)

Expectation::andThrow() A

Complexity

Size

Duplication

Code Coverage

Importance

1. Missing dependencies

2. Missing use statement

Duplication Side-by-Side

Filter issues like