如何在Lumen中对路由控制器的方法调用进行Mock测试？

Hey there! Let's break down how to mock that private method (and its underlying third-party service call) in your Lumen controller during testing. Since private methods aren't directly accessible, we've got two solid approaches—one that's clean and test-friendly (highly recommended) and another that works if you can't refactor right now.

Approach 1: Refactor for Dependency Injection (Recommended) #

The best practice here is to extract that third-party service logic into a separate interface and implementation. This way, you can inject the dependency into your controller and mock it easily without messing with private methods. Here's how to do it step by step:

1. Create an Interface for the Third-Party Service
   This defines the contract for your service, making it easy to swap implementations (including mocks) later:

<?php

namespace App\Services;

interface ThirdPartyServiceInterface
{
    public function fetchData($data);
}

2. Implement the Interface
   Move your existing third-party service code into this class:

<?php

namespace App\Services;

class ThirdPartyService implements ThirdPartyServiceInterface
{
    public function fetchData($data)
    {
        // Your original third-party service logic from private_method goes here
        return $some_value;
    }
}

3. Update Your Controller to Use Dependency Injection
   Modify your controller to accept the interface via constructor injection, then replace the private method call with the service:

<?php

use App\Services\ThirdPartyServiceInterface;
use Illuminate\Http\Request;

class MyController
{
    private $thirdPartyService;

    // Inject the service interface
    public function __construct(ThirdPartyServiceInterface $thirdPartyService)
    {
        $this->thirdPartyService = $thirdPartyService;
    }

    public function route_method(Request $request)
    {
        // some code
        $success = $this->thirdPartyService->fetchData($request->get('get_variable'));
        // some code
        return \response()->json(['results' => $success]);
    }

    // You can remove the private_method now, or refactor any extra logic into the service class
}

4. Bind the Interface in Lumen
   Tell Lumen which implementation to use for the interface. Add this to your bootstrap/app.php (or a custom service provider):

$this->app->bind(ThirdPartyServiceInterface::class, ThirdPartyService::class);

5. Write the Test with Mockery
   Now you can easily mock the service interface in your test:

<?php

use App\Services\ThirdPartyServiceInterface;
use Illuminate\Http\Request;
use Tests\TestCase;

class MyControllerTest extends TestCase
{
    public function test_route_method_returns_correct_json()
    {
        // Mock the third-party service
        $mockService = $this->mock(ThirdPartyServiceInterface::class, function ($mock) {
            $mock->shouldReceive('fetchData')
                 ->with('test_get_value') // Match the input you expect from the request
                 ->andReturn(true); // Set the mock's return value
        });

        // Create a mock request with your test parameter
        $request = Request::create('/your-route-path', 'GET', ['get_variable' => 'test_get_value']);

        // Call the controller method
        $response = $this->app->make(MyController::class)->route_method($request);

        // Assert the response is as expected
        $this->assertEquals(200, $response->getStatusCode());
        $this->assertEquals(['results' => true], json_decode($response->getContent(), true));
    }
}

Approach 2: Mock the Private Method Directly (If Refactoring Isn't an Option) #

If you can't refactor your code right now, you can use Mockery's partial mocking to stub the private method. Here's how:

<?php

use Illuminate\Http\Request;
use Tests\TestCase;

class MyControllerTest extends TestCase
{
    public function test_route_method_with_mocked_private_method()
    {
        // Create a partial mock of the controller—this lets us stub specific methods
        $controller = $this->partialMock(MyController::class, function ($mock) {
            $mock->shouldReceive('private_method')
                 ->with('test_get_value')
                 ->andReturn(true); // Mock the private method's return value
        });

        // Create a mock request
        $request = Request::create('/your-route-path', 'GET', ['get_variable' => 'test_get_value']);

        // Execute the controller method
        $response = $controller->route_method($request);

        // Verify the response
        $this->assertEquals(200, $response->getStatusCode());
        $this->assertEquals(['results' => true], json_decode($response->getContent(), true));
    }
}

Bonus: Testing the Private Method Directly #

If you want to test the private method's logic itself (not just mock it), you can use PHP reflection to make it accessible:

public function test_private_method_logic()
{
    $controller = new MyController();
    $reflection = new \ReflectionMethod($controller, 'private_method');
    $reflection->setAccessible(true);
    
    // Call the private method with test data
    $result = $reflection->invoke($controller, 'test_input_data');
    
    // Assert the result matches your expectation
    $this->assertEquals('expected_result', $result);
}

Key Takeaways #

• Always go with Approach 1 if possible—dependency injection makes your code more flexible, maintainable, and easier to test. Tying third-party calls directly to private methods creates tight coupling that's hard to work with long-term.
• Lumen includes Mockery by default for testing, so the mock() and partialMock() helpers are ready to use in your test cases.
• If you don't have Mockery installed, run composer require --dev mockery/mockery to add it.

内容的提问来源于stack exchange，提问作者MMSs