Introduction to Mockery

Mockery is a powerful and flexible PHP mock object framework. It offers useful APIs to simplify the process of mocking and stubbing objects, which are crucial for effective unit and integration testing. In this blog post, we’ll explore several Mockery APIs along with code snippets to illustrate their usage. We’ll also provide an example application that demonstrates the practical application of these APIs.

Basic Usage of Mockery

  
    use Mockery as m;

    // Create a mock object
    $mock = m::mock('MyClass');

    // Set an expectation
    $mock->shouldReceive('myMethod')->once()->andReturn('mocked result');

    // Use the mock object
    $result = $mock->myMethod();
    echo $result;  // outputs 'mocked result'
  

Mocking Methods with Parameters

  
    $mock = m::mock('MyClass');

    // Expect method call with specific parameters
    $mock->shouldReceive('calculate')
         ->with(10, 5)
         ->andReturn(15);

    $result = $mock->calculate(10, 5);
    echo $result;  // outputs 15
  

Mocking Static Methods

  
    m::mock('alias:MyStaticClass')
        ->shouldReceive('staticMethod')
        ->andReturn('static result');

    $result = MyStaticClass::staticMethod();
    echo $result;  // outputs 'static result'
  

Creating Partial Mocks

  
    $partialMock = m::mock('MyClass[partialMethod]');
    $partialMock->shouldReceive('partialMethod')->andReturn('partial result');

    echo $partialMock->partialMethod();  // outputs 'partial result'
    echo $partialMock->nonMockedMethod();  // calls the actual method
  

Verification of Calls

  
    $mock = m::mock('MyClass');
    $mock->shouldReceive('process')->once();

    $mock->process();  // this will pass verification

    m::close();  // verifies that all expectations were met
  

Example Application

Let’s create a simple application to demonstrate how to use Mockery’s API effectively.

  
    // src/MyService.php
    class MyService {
        public function fetchData($id) {
            return "Data for id " . $id;
        }

        public function processData($data) {
            // process data
        }
    }

    // tests/MyServiceTest.php
    use Mockery as m;
    use PHPUnit\Framework\TestCase;

    class MyServiceTest extends TestCase {
        public function tearDown(): void {
            m::close();
        }

        public function testProcessData() {
            $mockService = m::mock('MyService');
            $mockService->shouldReceive('fetchData')
                        ->with(123)
                        ->andReturn('mock data');

            $mockService->shouldReceive('processData')
                        ->with('mock data')
                        ->once();

            $data = $mockService->fetchData(123);
            $mockService->processData($data);
        }
    }
  

In this example, we tested MyService by mocking its methods fetchData and processData. This ensures that our test cases cover the intended functionality without relying on the actual implementations.

Conclusion

Mockery is an essential tool for PHP developers aimed at writing robust unit and integration tests with ease. Its extensive API allows for detailed and flexible creation of mock objects. With these examples, you should be well-equipped to start using Mockery in your projects.

Hash: fd8b4e62d16c4808959229f59f32f68f6cf68fac8aea938df628f56b8a9464b9