Mockery

https://docs.mockery.io/
Admin
Mockery is a simple yet flexible PHP mock object framework for use in unit testing with PHPUnit,...
Tokens:70,818
Snippets:587
Trust Score:6.5
Update:1 week ago
Show doc for...
Tokens:
Raw
### Install Mockery with Composer update

Source: https://docs.mockery.io/en/latest/_sources/getting_started/installation.rst.txt

Runs Composer update to install dependencies defined in composer.json. Mockery is installed as a development dependency and will not be installed with --no-dev.

```bash
php composer.phar update
```

--------------------------------

### Mock expectation example

Source: https://docs.mockery.io/en/latest/_sources/reference/spies.rst.txt

Shows the Arrange-Expect-Act-Assert style with a mock, where expectations are set before acting on the SUT.

```php
// arrange
$mock = \Mockery::mock('MyDependency');
$sut = new MyClass($mock);

// expect
$mock->shouldReceive('foo')
    ->once()
    ->with('bar');

// act
$sut->callFoo();

// assert
\Mockery::close();
```

--------------------------------

### Create a mock with interfaces as second argument

Source: https://docs.mockery.io/en/latest/_sources/reference/creating_test_doubles.rst.txt

Creates a mock of 'MyClass' that implements the interfaces listed in the second argument. Equivalent to the previous example.

```php
$mock = \Mockery::mock('MyClass', 'MyInterface, OtherInterface');
```

--------------------------------

### Fetcher and MyClass with non-static fetch()

Source: https://docs.mockery.io/en/latest/cookbook/class_constants.html

Alternative version of the example classes where fetch() is an instance method and MyClass receives the fetcher as a parameter.

```php
class Fetcher
{
    const SUCCESS = 0;
    const FAILURE = 1;

    public function fetch()
    {
        // Fetcher gets something for us from somewhere...
        return self::SUCCESS;
    }
}

class MyClass
{
    public function doFetching($fetcher)
    {
        $response = $fetcher->fetch();

        if ($response == Fetcher::SUCCESS) {
            echo "Thanks!" . PHP_EOL;
        } else {
            echo "Try again!" . PHP_EOL;
        }
    }
}
```

--------------------------------

### Fetcher class with constants for constants map example

Source: https://docs.mockery.io/en/latest/cookbook/class_constants.html

Class with constants used to demonstrate the constants map configuration.

```php
class Fetcher
{
    const SUCCESS = 0;
    const FAILURE = 1;

    public function fetch()
    {
        // Fetcher gets something for us from somewhere...
        return self::SUCCESS;
    }
}
```

--------------------------------

### withSomeOfArgs example with integer arguments

Source: https://docs.mockery.io/en/latest/_sources/reference/expectations.rst.txt

This example shows using withSomeOfArgs to match calls that include the given arguments, regardless of order. Type must match.

```php
$mock = \Mockery::mock('MyClass');
$mock->shouldReceive('foo')
    ->withSomeOfArgs(1, 2);
```

--------------------------------

### Install Mockery via Composer require command

Source: https://docs.mockery.io/en/latest/_sources/getting_started/installation.rst.txt

Directly adds Mockery as a development dependency from the command line.

```bash
php composer.phar require --dev mockery/mockery
```

--------------------------------

### Spy usage example

Source: https://docs.mockery.io/en/latest/_sources/reference/spies.rst.txt

Shows the Arrange-Act-Assert style with a spy, where assertions are made after acting on the SUT.

```php
// arrange
$spy = \Mockery::spy('MyDependency');
$sut = new MyClass($spy);

// act
$sut->callFoo();

// assert
$spy->shouldHaveReceived()
    ->foo()
    ->with('bar');
```

--------------------------------

### Instance Mocking Example: new \MyNamespace\Foo

Source: https://docs.mockery.io/en/latest/reference/instance_mocking.html

Shows the statement that triggers instance mocking, replacing the real class with a mock object. The alias imports expectations from the original mock, which is never verified and should be ignored after setup. This works when autoloading is the primary class loading mechanism; a require statement can still include the real class and cause a fatal error.

```php
$obj = new \MyNamespace\Foo;

```

--------------------------------

### Service class with hard dependency

Source: https://docs.mockery.io/en/latest/cookbook/mocking_hard_dependencies.html

Example class that instantiates an external service using the 'new' keyword, which is a hard dependency that needs to be mocked.

```php
<?php
namespace App;
class Service
{
    function callExternalService($param)
    {
        $externalService = new Service\External($version = 5);
        $externalService->sendSomething($param);
        return $externalService->getSomething();
    }
}

```

--------------------------------

### Using namedMock() with a stub class for non-static fetch()

Source: https://docs.mockery.io/en/latest/cookbook/class_constants.html

Test setup for the non-static version. Creates a mock named Fetcher based on FetcherStub and passes it to MyClass::doFetching().

```php
class FetcherStub
{
    const SUCCESS = 0;
    const FAILURE = 1;
}

$mock = \Mockery::mock('Fetcher', 'FetcherStub')
$mock->shouldReceive('fetch')
    ->andReturn(0);

$myClass = new MyClass();
$myClass->doFetching($mock);
```

--------------------------------

### Mock vs Spy example

Source: https://docs.mockery.io/en/latest/_sources/reference/creating_test_doubles.rst.txt

Illustrates the difference between a mock and a spy. A mock requires setting expectations before the call, while a spy verifies calls after the fact. The return value of a spy method call is always null.

```php
$mock = \Mockery::mock('MyClass');
$spy = \Mockery::spy('MyClass');

$mock->shouldReceive('foo')->andReturn(42);

$mockResult = $mock->foo();
$spyResult = $spy->foo();

$spy->shouldHaveReceived()->foo();

var_dump($mockResult); // int(42)
var_dump($spyResult); // null
```

--------------------------------

### hasKey() matcher example

Source: https://docs.mockery.io/en/latest/_sources/reference/argument_validation.rst.txt

Matches any argument that is an array containing the given key name.

```php
$mock = \Mockery::mock('MyClass');
$mock->shouldReceive('foo')
    ->with(\Mockery::hasKey(key));
```

--------------------------------

### Closure argument matching example with even numbers

Source: https://docs.mockery.io/en/latest/_sources/reference/expectations.rst.txt

This example shows a closure that matches even arguments. Calls with even numbers match, odd numbers throw NoMatchingExpectationException.

```php
$mock = \Mockery::mock('MyClass');

$mock->shouldReceive('foo')->withArgs(function ($arg) {
    if ($arg % 2 == 0) {
        return true;
    }
    return false;
});

$mock->foo(4); // matches the expectation
$mock->foo(3); // throws a NoMatchingExpectationException
```

--------------------------------

### Instance Mocking: new statement example

Source: https://docs.mockery.io/en/latest/_sources/reference/instance_mocking.rst.txt

Shows a typical instantiation statement that instance mocking will intercept, replacing the real class with a mock object.

```php
$obj = new \MyNamespace\Foo;
```

--------------------------------

### Set up ordered database query expectations with Mockery

Source: https://docs.mockery.io/en/latest/_sources/getting_started/quick_reference.rst.txt

Use this snippet to define a sequence of expected method calls on a mock object. The 'ordered' method enforces call order, and the 'queries' group allows multiple calls to be ordered together. The example shows how to use 'with' to match arguments and 'andReturn' to specify return values.

```php
class DbTest extends MockeryTestCase
{
    public function testOrderedQueries()
    {
        $db = \Mockery::mock('db');
        $db->shouldReceive('startup')->once()->ordered();
        $db->shouldReceive('query')->with('CPWR')->andReturn(12.3)->once()->ordered('queries');
        $db->shouldReceive('query')->with('MSFT')->andReturn(10.0)->once()->ordered('queries');
        $db->shouldReceive('query')->with(\Mockery::pattern("/^....$/"))->andReturn(3.3)->atLeast()->once()->ordered('queries');
        $db->shouldReceive('finish')->once()->ordered();

        // ... test code here using the mock
    }
}
```

--------------------------------

### Example of BigParentClass and ChildClass

Source: https://docs.mockery.io/en/latest/_sources/cookbook/big_parent_class.rst.txt

Shows a legacy code structure where ChildClass extends BigParentClass and calls its doesEverything() method. This is the target for testing.

```php
class BigParentClass
{
    public function doesEverything()
    {
        // sets up database connections
        // writes to log files
    }
}

class ChildClass extends BigParentClass
{
    public function doesOneThing()
    {
        // but calls on BigParentClass methods
        $result = $this->doesEverything();
        // does something with $result
        return $result;
    }
}
```

--------------------------------

### Fetcher and MyClass classes with class constants

Source: https://docs.mockery.io/en/latest/cookbook/class_constants.html

Example classes used to illustrate the problem. Fetcher defines constants SUCCESS and FAILURE and a static fetch() method. MyClass calls Fetcher::fetch() and compares the result to Fetcher::SUCCESS.

```php
class Fetcher
{
    const SUCCESS = 0;
    const FAILURE = 1;

    public static function fetch()
    {
        // Fetcher gets something for us from somewhere...
        return self::SUCCESS;
    }
}

class MyClass
{
    public function doFetching()
    {
        $response = Fetcher::fetch();

        if ($response == Fetcher::SUCCESS) {
            echo "Thanks!" . PHP_EOL;
        } else {
            echo "Try again!" . PHP_EOL;
        }
    }
}
```

--------------------------------

### Using Mockery::anyOf() matcher

Source: https://docs.mockery.io/en/latest/_sources/reference/argument_validation.rst.txt

Matches any argument that equals any one of the given parameters. The example shows \Mockery::anyOf(1, 2) and its Hamcrest equivalent anyOf(1,2).

```php
$mock = \Mockery::mock('MyClass');
$mock->shouldReceive('foo')
    ->with(\Mockery::anyOf(1, 2));

// Hamcrest equivalent
$mock->shouldReceive('foo')
    ->with(anyOf(1,2));
```

--------------------------------

### Example of a Demeter chain method call

Source: https://docs.mockery.io/en/latest/reference/demeter_chains.html

Shows a typical fluent interface chain where multiple methods are called in sequence on an object. This is the pattern that Mockery's demeter chain mocking is designed to handle.

```php
$object->foo()->bar()->zebra()->alpha()->selfDestruct();
```

--------------------------------

### PHP class Post with publishPost method

Source: https://docs.mockery.io/en/latest/_sources/cookbook/mockery_on.rst.txt

Defines a Post service class with a publishPost method that saves an array with post_id, published, and published_at keys. This is the code under test that will be mocked in the test example.

```php
<?php
namespace Service;
class Post
{
    public function __construct($model)
    {
        $this->model = $model;
    }

    public function publishPost($id)
    {
        $saveData = [
            'post_id' => $id,
            'published' => 1,
            'published_at' => gmdate('Y-m-d H:i:s'),
        ];
        $this->model->save($saveData);
    }
}
```

--------------------------------

### Runtime partial test double with makePartial

Source: https://docs.mockery.io/en/latest/_sources/reference/creating_test_doubles.rst.txt

Creates a runtime partial test double using makePartial(). Methods not explicitly allowed or expected will behave as on a normal instance. The example shows that foo() returns 123 initially, then after setting an expectation, bar() returns 456.

```php
class Foo {
    function foo() { return 123; }
    function bar() { return $this->foo(); }
}

$foo = mock(Foo::class)->makePartial();
$foo->foo(); // int(123);
```

```php
$foo->shouldReceive('foo')->andReturn(456);
$foo->bar(); // int(456)
```

--------------------------------

### Mark expectation as default with byDefault()

Source: https://docs.mockery.io/en/latest/_sources/reference/expectations.rst.txt

Marks an expectation as a default. Default expectations are applied unless a non-default expectation is created. Later expectations immediately replace the previously defined default. Useful for setting up default mocks in unit test setup() and tweaking them later.

```php
byDefault()
```

--------------------------------

### hasValue() matcher example

Source: https://docs.mockery.io/en/latest/_sources/reference/argument_validation.rst.txt

Matches any argument that is an array containing the given value.

```php
$mock = \Mockery::mock('MyClass');
$mock->shouldReceive('foo')
    ->with(\Mockery::hasValue(value));
```

--------------------------------

### any() matcher and Hamcrest anything()

Source: https://docs.mockery.io/en/latest/reference/argument_validation.html

Shows how to match any argument in a position using `\Mockery::any()` and its Hamcrest equivalent `anything()`. Any value passed is accepted.

```php
$mock = \Mockery::mock('MyClass');
$mock->shouldReceive("foo")
    ->with(\Mockery::any());

// Hamcrest equivalent
$mock->shouldReceive("foo")
    ->with(anything())

```

--------------------------------

### allows() with array

Source: https://docs.mockery.io/en/latest/reference/alternative_should_receive_syntax.html

Sets up method stubs with predefined return values using the allows() method with an array of method names and return values. This is equivalent to using shouldReceive() with an array.

```APIDOC
## allows() with array

### Description
Sets up method stubs with predefined return values using the allows() method with an array of method names and return values. This is equivalent to using shouldReceive() with an array.

### Method
allows()

### Parameters
- **array** (array) - Required - An associative array mapping method names to return values.

### Request Example
```php
$mock = \Mockery::mock('MyClass');
$mock->allows([
    'name_of_method_1' => 'return value',
    'name_of_method_2' => 'return value',
]);
```

### Response
No return value.
```

--------------------------------

### contains() matcher example

Source: https://docs.mockery.io/en/latest/_sources/reference/argument_validation.rst.txt

Matches any argument that is an array containing the listed values. The naming of keys is ignored.

```php
$mock = \Mockery::mock('MyClass');
$mock->shouldReceive('foo')
    ->with(\Mockery::contains(value1, value2));
```

--------------------------------

### Mock object with ordered queries and patterns

Source: https://docs.mockery.io/en/latest/getting_started/quick_reference.html

Create a mock object where queries occur in a specific order with pattern matching for arguments.

```php
use \Mockery\Adapter\Phpunit\MockeryTestCase;

class DbTest extends MockeryTestCase
{
    public function testOrderedQueries()
    {
        $db = \Mockery::mock('db');
        $db->shouldReceive('startup')->once()->ordered();
        $db->shouldReceive('query')->with('CPWR')->andReturn(12.3)->once()->ordered('queries');
        $db->shouldReceive('query')->with('MSFT')->andReturn(10.0)->once()->ordered('queries');
        $db->shouldReceive('query')->with(\Mockery::pattern("/^....$/"))->andReturn(3.3)->atLeast()->once()->ordered('queries');
        $db->shouldReceive('finish')->once()->ordered();

        // ... test code here using the mock
    }
}
```

--------------------------------

### Enable reflection cache

Source: https://docs.mockery.io/en/latest/_sources/mockery/configuration.rst.txt

Use \Mockery::getConfiguration()->enableReflectionCache() to turn reflection caching back on after disabling it.

```php
\Mockery::getConfiguration()->enableReflectionCache();
```

--------------------------------

### shouldReceive

Source: https://docs.mockery.io/en/latest/_sources/reference/expectations.rst.txt

Declares that a mock object should receive a call to the specified method(s). This is the starting point for all expectations and constraints.

```APIDOC
## shouldReceive

### Description
Declares that a mock object should receive a call to the specified method(s). This is the starting point for all expectations and constraints.

### Method
shouldReceive

### Parameters
- **methodNames** (string|array) - Required - The name(s) of the method(s) expected to be called.
- **returnValues** (array) - Optional - An associative array mapping method names to return values.

### Request Example
```php
$mock = \Mockery::mock('MyClass');
$mock->shouldReceive('name_of_method');
```

```php
$mock = \Mockery::mock('MyClass');
$mock->shouldReceive('name_of_method_1', 'name_of_method_2');
```

```php
$mock = \Mockery::mock('MyClass');
$mock->shouldReceive([
    'name_of_method_1' => 'return value 1',
    'name_of_method_2' => 'return value 2',
]);
```

### Response
No return value specified.
```

--------------------------------

### allows() with method call

Source: https://docs.mockery.io/en/latest/reference/alternative_should_receive_syntax.html

Sets up a method stub with a predefined return value and argument matching using the allows() method with a method call. This is equivalent to using shouldReceive() with with() and andReturn().

```APIDOC
## allows() with method call

### Description
Sets up a method stub with a predefined return value and argument matching using the allows() method with a method call. This is equivalent to using shouldReceive() with with() and andReturn().

### Method
allows()

### Parameters
- **method** (string) - Required - The name of the method to stub.
- **arguments** (mixed) - Required - The arguments to match for the method call.
- **return value** (mixed) - Required - The value to return when the method is called.

### Request Example
```php
$mock = \Mockery::mock('MyClass');
$mock->allows()
    ->name_of_method_1($arg1)
    ->andReturn('return value');
```

### Response
No return value.
```

--------------------------------

### getMock()

Source: https://docs.mockery.io/en/latest/_sources/reference/expectations.rst.txt

Returns the current mock object from an expectation chain. Useful where we prefer to keep mock setups as a single statement.

```APIDOC
## getMock()

### Description
Returns the current mock object from an expectation chain. Useful where we prefer to keep mock setups as a single statement.

### Method
getMock()

### Usage Example
```php
$mock = \Mockery::mock('foo')->shouldReceive('foo')->andReturn(1)->getMock();
```

### Returns
- The current mock object.
```

--------------------------------

### Class loading initiator diagram

Source: https://docs.mockery.io/en/latest/cookbook/mocking_class_within_class.html

Diagram showing class loading initiators in a dependency tree. Each initiator (A, B, C) loads other classes, preventing mocking for those loaded classes.

```text
A        // main loading initiator
|- B     // another loading initiator
|  |-E
|  +-G
|
|- C     // another loading initiator
|  +-F
|
+- D

```

--------------------------------

### Create a spy with \Mockery::spy()

Source: https://docs.mockery.io/en/latest/reference/creating_test_doubles.html

Creates a spy for a class. The spy returns null for all method calls and cannot have return values set.

```php
$spy = \Mockery::spy('MyClass');

```

--------------------------------

### Return mock object with getMock()

Source: https://docs.mockery.io/en/latest/_sources/reference/expectations.rst.txt

Returns the current mock object from an expectation chain. Useful for keeping mock setups as a single statement.

```php
$mock = \Mockery::mock('foo')->shouldReceive('foo')->andReturn(1)->getMock();
```

--------------------------------

### allows() with array of method-return pairs

Source: https://docs.mockery.io/en/latest/_sources/reference/alternative_should_receive_syntax.rst.txt

Creates a mock and stubs multiple methods with predefined return values using allows() with an array. This is equivalent to shouldReceive() with the same array, and indicates that arguments are not important.

```php
$mock = \Mockery::mock('MyClass');
$mock->allows([
    'name_of_method_1' => 'return value',
    'name_of_method_2' => 'return value',
]);
```

```php
$mock = \Mockery::mock('MyClass');
$mock->shouldReceive([
    'name_of_method_1' => 'return value',
    'name_of_method_2' => 'return value',
]);
```

--------------------------------

### Using Mockery::not() matcher

Source: https://docs.mockery.io/en/latest/_sources/reference/argument_validation.rst.txt

Matches any argument that is not equal or identical to the given parameter. The example shows \Mockery::not(2) and its Hamcrest equivalent not(2).

```php
$mock = \Mockery::mock('MyClass');
$mock->shouldReceive('foo')
    ->with(\Mockery::not(2));

// Hamcrest equivalent
$mock->shouldReceive('foo')
    ->with(not(2));
```

--------------------------------

### Using Mockery::notAnyOf() matcher

Source: https://docs.mockery.io/en/latest/_sources/reference/argument_validation.rst.txt

Matches any argument that is not equal or identical to any of the given parameters. The example uses \Mockery::notAnyOf(1, 2). There is no Hamcrest version of notAnyOf().

```php
$mock = \Mockery::mock('MyClass');
$mock->shouldReceive('foo')
    ->with(\Mockery::notAnyOf(1, 2));
```

--------------------------------

### Declare a single method call expectation with shouldReceive

Source: https://docs.mockery.io/en/latest/_sources/reference/expectations.rst.txt

Use shouldReceive to tell a mock object to expect a call to a specific method. This is the starting point for all other expectations and constraints.

```php
$mock = \Mockery::mock('MyClass');
$mock->shouldReceive('name_of_method');
```

--------------------------------

### Create a mock based on a class and multiple interfaces

Source: https://docs.mockery.io/en/latest/_sources/reference/creating_test_doubles.rst.txt

Creates a stub or mock that is of type 'MyClass' and implements 'MyInterface' and 'OtherInterface'. The class name does not need to be first, but it is a friendly convention.

```php
$mock = \Mockery::mock('MyClass, MyInterface, OtherInterface');
```

--------------------------------

### Set minimum call count with atLeast()->times(3)

Source: https://docs.mockery.io/en/latest/_sources/reference/expectations.rst.txt

Use atLeast() to set a minimum number of times a method should be called. The example requires at least three calls.

```php
$mock = \Mockery::mock('MyClass');
$mock->shouldReceive('name_of_method')
    ->atLeast()
    ->times(3);
```

--------------------------------

### Create a mock based on an interface

Source: https://docs.mockery.io/en/latest/_sources/reference/creating_test_doubles.rst.txt

Creates a stub or mock that implements the 'MyInterface' interface.

```php
$mock = \Mockery::mock('MyInterface');
```

--------------------------------

### Original Point and Rectangle classes with new Point() calls

Source: https://docs.mockery.io/en/latest/_sources/cookbook/mocking_class_within_class.rst.txt

Shows the initial App\Point and App\Rectangle classes. Rectangle::create() instantiates Point objects directly with 'new Point()' and calls setPoint() on each, then passes them to draw(). This structure prevents mocking Point because the class is autoloaded.

```php
// Point.php
<?php
namespace App;

class Point {
    public function setPoint($x, $y) {
        echo "Point (" . $x . ", " . $y . ")" . PHP_EOL;
    }
}

// Rectangle.php
<?php
namespace App;
use App\Point;

class Rectangle {
    public function create($x1, $y1, $x2, $y2) {
        $a = new Point();
        $a->setPoint($x1, $y1);

        $b = new Point();
        $b->setPoint($x2, $y1);

        $c = new Point();
        $c->setPoint($x2, $y2);

        $d = new Point();
        $d->setPoint($x1, $y2);

        $this->draw([$a, $b, $c, $d]);
    }

    public function draw($points) {
        echo "Do something with the points";
    }
}
```

--------------------------------

### Using Mockery::ducktype() matcher

Source: https://docs.mockery.io/en/latest/_sources/reference/argument_validation.rst.txt

Matches any argument that is an object containing the specified list of methods. The example uses \Mockery::ducktype('foo', 'bar'). There is no Hamcrest version of ducktype().

```php
$mock = \Mockery::mock('MyClass');
$mock->shouldReceive('foo')
    ->with(\Mockery::ducktype('foo', 'bar'));
```

--------------------------------

### Using namedMock() with a stub class for static fetch()

Source: https://docs.mockery.io/en/latest/cookbook/class_constants.html

Creates a stub class FetcherStub that defines the constants, then uses namedMock() to create a mock named Fetcher based on the stub. This avoids the undefined constant error.

```php
class FetcherStub
{
    const SUCCESS = 0;
    const FAILURE = 1;
}

\Mockery::namedMock('Fetcher', 'FetcherStub')
    ->shouldReceive('fetch')
    ->andReturn(0);

$myClass = new MyClass();
$myClass->doFetching();
```

--------------------------------

### Using Mockery::pattern() for regex matching

Source: https://docs.mockery.io/en/latest/_sources/reference/argument_validation.rst.txt

Matches an argument against a regular expression using \Mockery::pattern(). The example shows a pattern '/^foo/' and its Hamcrest equivalent using matchesPattern().

```php
$mock = \Mockery::mock('MyClass');
$mock->shouldReceive('foo')
    ->with(\Mockery::pattern('/^foo/'));

// Hamcrest equivalent
$mock->shouldReceive('foo')
    ->with(matchesPattern('/^foo/'));
```

--------------------------------

### Basic with() matcher for integer argument

Source: https://docs.mockery.io/en/latest/_sources/reference/argument_validation.rst.txt

Sets up an expectation that the foo method is called with the integer 1. Mockery first tries strict === comparison, then falls back to == for primitives.

```php
$mock = \Mockery::mock('MyClass');
$mock->shouldReceive('foo')
    ->with(1):
```

--------------------------------

### PHP class method with pass-by-reference parameter

Source: https://docs.mockery.io/en/latest/_sources/reference/pass_by_reference_behaviours.rst.txt

Shows a PHP class method that accepts a parameter by reference and modifies it. The example demonstrates that changes to the parameter are reflected in the original variable.

```php
class Foo
{

    public function bar(&$a)
    {
        $a++;
    }

}

$baz = 1;
$foo = new Foo;
$foo->bar($baz);

echo $baz; // will echo the integer 2
```

--------------------------------

### expects() with method call

Source: https://docs.mockery.io/en/latest/reference/alternative_should_receive_syntax.html

Sets up an expectation that a method should be called exactly once with the given arguments, using the expects() method. This is equivalent to using shouldReceive() with once(), with(), and andReturn().

```APIDOC
## expects() with method call

### Description
Sets up an expectation that a method should be called exactly once with the given arguments, using the expects() method. This is equivalent to using shouldReceive() with once(), with(), and andReturn().

### Method
expects()

### Parameters
- **method** (string) - Required - The name of the method to expect.
- **arguments** (mixed) - Required - The arguments to match for the method call.
- **return value** (mixed) - Required - The value to return when the method is called.

### Request Example
```php
$mock = \Mockery::mock('MyClass');
$mock->expects()
    ->name_of_method_1($arg1)
    ->andReturn('return value');
```

### Response
No return value.
```

--------------------------------

### Mock with multiple query calls and a single update call

Source: https://docs.mockery.io/en/latest/_sources/getting_started/quick_reference.rst.txt

Create a mock that expects multiple query calls returning 1, 2, 3, and a single update call with argument 5 returning NULL.

```php
use \Mockery\Adapter\Phpunit\MockeryTestCase;

class DbTest extends MockeryTestCase
{
    public function testDbAdapter()
    {
        $mock = \Mockery::mock('db');
        $mock->shouldReceive('query')->andReturn(1, 2, 3);
        $mock->shouldReceive('update')->with(5)->andReturn(NULL)->once();

        // ... test code here using the mock
    }
}
```

--------------------------------

### Multiple return values with andReturn() and call examples

Source: https://docs.mockery.io/en/latest/_sources/reference/expectations.rst.txt

Shows the behavior of multiple return values: the first three calls return 1, 2, and 3, and any further calls return 3.

```php
$mock = \Mockery::mock('MyClass');

$mock->shouldReceive('foo')->andReturn(1, 2, 3);

$mock->foo(); // int(1)
$mock->foo(); // int(2)
$mock->foo(); // int(3)
$mock->foo(); // int(3)
```

--------------------------------

### Using Mockery::subset() matcher

Source: https://docs.mockery.io/en/latest/_sources/reference/argument_validation.rst.txt

Matches any argument that is an array containing the given array subset. The example uses \Mockery::subset(array(0 => 'foo')). It enforces both key naming and values.

```php
$mock = \Mockery::mock('MyClass');
$mock->shouldReceive('foo')
    ->with(\Mockery::subset(array(0 => 'foo')));
```

--------------------------------

### Basic test with overload mock

Source: https://docs.mockery.io/en/latest/_sources/cookbook/mocking_hard_dependencies.rst.txt

Uses m::mock('overload:App\Service\External') to mock the hard dependency. Sets expectations for sendSomething and getSomething, then verifies the result. Requires autoloading to avoid class already exists errors.

```php
<?php
namespace AppTest;
use Mockery as m;
class ServiceTest extends \PHPUnit_Framework_TestCase
{
    public function testCallingExternalService()
    {
        $param = 'Testing';

        $externalMock = m::mock('overload:App\Service\External');
        $externalMock->shouldReceive('sendSomething')
            ->once()
            ->with($param);
        $externalMock->shouldReceive('getSomething')
            ->once()
            ->andReturn('Tested!');

        $service = new \App\Service();

        $result = $service->callExternalService($param);

        $this->assertSame('Tested!', $result);
    }
}
```

--------------------------------

### Register Mockery autoloader in Bootstrap.php

Source: https://docs.mockery.io/en/latest/_sources/reference/phpunit_integration.rst.txt

Add this to your test suite's Bootstrap.php or TestHelper.php to use Mockery's autoloader, avoiding require_once() calls in tests. Ensure Mockery is on your include_path.

```php
require_once 'Mockery/Loader.php';
require_once 'Hamcrest/Hamcrest.php';

$loader = new \Mockery\Loader;
$loader->register();
```
Tokens:
Raw