Test with mocking

Certainly! Mocking is a powerful technique in unit testing that allows you to isolate the code you are testing from its dependencies. This can be particularly useful for several reasons:

1. Isolation: By mocking dependencies, you can ensure that your tests are focused solely on the functionality of the unit under test, without being affected by the behavior of its dependencies.

2. Control: Mocks allow you to precisely control the behavior of dependencies. You can specify exactly what methods should return, how many times they should be called, and with what arguments.

3. Performance: Mocking can make your tests run faster because you are not invoking the actual implementations of dependencies, which might involve time-consuming operations like database access or network calls.

4. Reliability: Tests that rely on external systems can be flaky due to network issues, database state, etc. Mocking removes these variables, making your tests more reliable.

Let's break down your example to illustrate these points.

Without Mocking

$data = 'data';
$something = 'other data';

$returnedValue = (new Service)->process($data);

$this->assertSame($returnedValue, $something);

In this case, you are testing the Service class's process method directly. This means that the test is dependent on the actual implementation of the process method. If process interacts with a database, makes an API call, or has any other side effects, those will be executed during the test.

With Mocking

$data = 'data';
$something = 'other data';

$mock = $this->mock(Service::class, function (MockInterface $mock) use ($data, $something) {
    $mock->shouldReceive('process')->once()->with($data)->andReturn($something);
});

Here, you are creating a mock of the Service class. You specify that the process method should be called once with $data as the argument and that it should return $something. This way, you are not invoking the actual process method, but rather a controlled version of it.

Why Mocking is Useful

1. Isolation: The test is isolated from the actual implementation of Service::process. This means you can test the behavior of the code that uses Service without worrying about the actual implementation of Service.

2. Control: You have full control over what Service::process returns. This is useful if process has complex logic or side effects that you don't want to execute during the test.

3. Performance: The test will run faster because it doesn't execute the actual process method, which might involve time-consuming operations.

4. Reliability: The test is more reliable because it doesn't depend on external systems or the state of the database.

Example Scenario

Imagine you have a class OrderProcessor that uses Service to process orders. You want to test OrderProcessor without worrying about the implementation of Service.

class OrderProcessor
{
    protected $service;

    public function __construct(Service $service)
    {
        $this->service = $service;
    }

    public function processOrder($order)
    {
        $data = $order->getData();
        return $this->service->process($data);
    }
}

You can write a test for OrderProcessor using a mock for Service:

public function testProcessOrder()
{
    $data = 'data';
    $something = 'other data';

    $mockService = $this->mock(Service::class, function (MockInterface $mock) use ($data, $something) {
        $mock->shouldReceive('process')->once()->with($data)->andReturn($something);
    });

    $order = $this->createMock(Order::class);
    $order->method('getData')->willReturn($data);

    $orderProcessor = new OrderProcessor($mockService);
    $result = $orderProcessor->processOrder($order);

    $this->assertSame($result, $something);
}

In this test, you are focusing on the behavior of OrderProcessor without worrying about the actual implementation of Service. This makes your test more focused, faster, and more reliable.

I hope this helps you understand the usefulness of mocking in unit tests!