To mock dependencies effectively in Laravel, use dependency injection for services, shouldReceive() for facades, and Mockery for complex cases. 1. For injected services, use $this->instance() to replace the real class with a mock. 2. For facades like Mail or Cache, use shouldReceive() to define expected calls and return values. 3. For advanced scenarios, use Mockery to create flexible mocks and ensure cleanup with Mockery::close() or the MockeryPHPUnitIntegration trait. Avoid over-mocking to keep tests maintainable and focused on behavior rather than implementation details.

When you're writing tests in Laravel, mocking dependencies is a common practice to isolate the code under test and avoid hitting real services like databases or external APIs. The key is to replace those dependencies with test doubles that simulate their behavior without the overhead.

Here’s how to do it effectively in different scenarios.

Mocking Services Using Dependency Injection

Laravel makes it easy to mock injected dependencies in classes like controllers, jobs, or custom services. When testing, you can override the binding in the service container or use PHPUnit's mocking features directly.

For example, if your controller depends on a PaymentService, you can mock it like this:

use App\Services\PaymentService;
use Illuminate\Foundation\Testing\RefreshDatabase;

public function test_payment_is_processed()
{
    $mock = $this->createMock(PaymentService::class);

    $mock->method('charge')->willReturn(true);

    $this->instance(PaymentService::class, $mock);

    $response = $this->post('/process-payment', ['amount' => 100]);

    $response->assertStatus(200);
}

This replaces the actual PaymentService in the container with your mock during the test. It avoids real network calls or side effects.

Tip: Use $this->instance() when you want to swap out a concrete class in the container. If you’re using interfaces with bindings, bind the interface to the mock instead.

Mocking Facades

Many Laravel components are accessed via facades — like Cache, Mail, or Event. These are easy to mock thanks to Laravel’s built-in helpers.

To mock a facade, use the shouldReceive() method:

Mail::shouldReceive('to->send')->once();

This tells Laravel to expect one call to Mail::to()->send(), and it won’t actually send any emails.

You can also specify return values or throw exceptions:

Cache::shouldReceive('get')->with('key')->andReturn('value');

This way, you control what the facade returns without touching the real cache backend.

Using Mockery for Complex Scenarios

Sometimes you need more flexibility than basic mocks offer. That’s where Mockery, which comes bundled with Laravel, shines.

You can create a mock object directly and define expectations:

$mock = \Mockery::mock('App\Services\NotificationService');

$mock->shouldReceive('send')->once()->with('hello')->andReturn(true);

$this->app->instance('App\Services\NotificationService', $mock);

This is especially useful when dealing with complex method calls or multiple expected interactions.

One thing to remember: always add \Mockery::close(); in your tearDown() method or use the Mockery\Adapter\Phpunit\MockeryPHPUnitIntegration trait to ensure clean state between tests.

Don't Over-Mock

While mocking helps keep tests fast and isolated, overdoing it can make tests brittle or too tightly coupled to implementation details.

Only mock what you need to control — like external APIs or slow operations. For internal logic, prefer using real instances unless they introduce unwanted side effects.

If you find yourself mocking every method of a class, ask:

• Could I refactor this class to be simpler?
• Am I testing behavior or just verifying mocks?

Sometimes, using a real instance with an in-memory database or fake filesystem is cleaner and easier to maintain.

Basically, Laravel gives you several solid options to mock dependencies depending on your needs: use dependency injection for service mocking, shouldReceive() for facades, and Mockery for advanced cases. Just don’t get carried away — keep your tests readable and meaningful.

The above is the detailed content of How do I mock dependencies in Laravel tests?. For more information, please follow other related articles on the PHP Chinese website!