编写单元测试时，一个关键的挑战是确保您的测试专注于被测代码，而不受外部系统或依赖项的干扰。这就是 mock 对象 在 PHPUnit 中发挥作用的地方。它们允许您以受控方式模拟真实对象的行为，使您的测试更可靠且更易于维护。在本文中，我们将探讨什么是模拟对象、它们为何有用以及如何在 PHPUnit 中有效地使用它们。

什么是模拟对象？

模拟对象是单元测试中使用的真实对象的模拟版本。它们允许您：

• 隔离被测代码：模拟对象模拟依赖关系的行为，确保测试结果不受这些依赖关系的实际实现的影响。
• 控制依赖行为：您可以指定调用某些方法时模拟应如何表现，使您能够测试不同的场景。
• 验证交互：模拟跟踪方法调用及其参数，确保被测代码与其依赖项正确交互。

为什么使用模拟对象？

模拟在以下场景中特别有用：

• 复杂的依赖关系：如果您的代码依赖于数据库、API 或第三方服务等外部系统，则模拟对象可以通过消除与这些系统交互的需要来简化测试。
• 交互测试：模拟允许您验证是否使用正确的参数调用了特定方法，确保您的代码按预期运行。
• 更快的测试执行：数据库查询或 API 请求等实际操作可能会减慢测试速度。模拟这些依赖项可确保更快的测试执行。

存根与模拟：有什么区别？

使用模拟对象时，您会遇到两个术语：stubbing 和 mocking:

• Stubbing：指在模拟对象上定义方法的行为，例如指示方法返回特定值。
• Mocking：涉及设置对如何调用方法的期望，例如，验证方法调用的数量及其参数。

如何在 PHPUnit 中创建和使用模拟对象

PHPUnit 通过 createMock() 方法可以轻松创建和使用模拟对象。下面是一些示例，演示了如何有效地使用模拟对象。

示例 1：基本模拟对象用法

在此示例中，我们为类依赖项创建一个模拟对象并指定其行为。

use PHPUnit\Framework\TestCase;

class MyTest extends TestCase
{
    public function testMockExample()
    {
        // Create a mock for the SomeClass dependency
        $mock = $this->createMock(SomeClass::class);

        // Specify that when the someMethod method is called, it returns 'mocked value'
        $mock->method('someMethod')
             ->willReturn('mocked value');

        // Pass the mock object to the class under test
        $unitUnderTest = new ClassUnderTest($mock);

        // Perform the action and assert that the result matches the expected value
        $result = $unitUnderTest->performAction();
        $this->assertEquals('expected result', $result);
    }
}

解释：

• createMock(SomeClass::class) 为 SomeClass 创建一个模拟对象。
• method('someMethod')->willReturn('mocked value') 定义模拟的行为。
• 模拟对象被传递给正在测试的类，确保不使用真正的 SomeClass 实现。

示例 2：验证方法调用

有时，您需要验证是否使用正确的参数调用了方法。具体方法如下：

public function testMethodCallVerification()
{
    // Create a mock object
    $mock = $this->createMock(SomeClass::class);

    // Expect the someMethod to be called once with 'expected argument'
    $mock->expects($this->once())
         ->method('someMethod')
         ->with($this->equalTo('expected argument'))
         ->willReturn('mocked value');

    // Pass the mock to the class under test
    $unitUnderTest = new ClassUnderTest($mock);

    // Perform an action that calls the mock's method
    $unitUnderTest->performAction();
}

要点：

• Expects($this->once()) 确保 someMethod 被调用一次。
• with($this->equalTo('expected argument')) 验证是否使用正确的参数调用该方法。

示例：使用 PaymentProcessor 进行测试

为了演示模拟对象的实际应用，我们以依赖于外部 PaymentGateway 接口的 PaymentProcessor 类为例。我们想要测试 PaymentProcessor 的 processPayment 方法，而不依赖于 PaymentGateway 的实际实现。

这是 PaymentProcessor 类：

class PaymentProcessor
{
    private $gateway;

    public function __construct(PaymentGateway $gateway)
    {
        $this->gateway = $gateway;
    }

    public function processPayment(float $amount): bool
    {
        return $this->gateway->charge($amount);
    }
}

现在，我们可以为 PaymentGateway 创建一个模拟来测试 processPayment 方法，而无需与实际的支付网关交互。

使用模拟对象测试 PaymentProcessor

use PHPUnit\Framework\TestCase;

class PaymentProcessorTest extends TestCase
{
    public function testProcessPayment()
    {
        // Create a mock object for the PaymentGateway interface
        $gatewayMock = $this->createMock(PaymentGateway::class);

        // Define the expected behavior of the mock
        $gatewayMock->method('charge')
                    ->with(100.0)
                    ->willReturn(true);

        // Inject the mock into the PaymentProcessor
        $paymentProcessor = new PaymentProcessor($gatewayMock);

        // Assert that processPayment returns true
        $this->assertTrue($paymentProcessor->processPayment(100.0));
    }
}

测试细目：

• createMock(PaymentGateway::class) 创建一个模拟 PaymentGateway 接口的模拟对象。
• method('charge')->with(100.0)->willReturn(true) 指定当以 100.0 作为参数调用 charge 方法时，它应该返回 true。
• 模拟对象被传递给 PaymentProcessor 类，允许您在不依赖真实支付网关的情况下测试 processPayment。

验证交互

您还可以验证在处理付款时收费方法是否被调用一次：

public function testProcessPaymentCallsCharge()
{
    $gatewayMock = $this->createMock(PaymentGateway::class);

    // Expect the charge method to be called once with the argument 100.0
    $gatewayMock->expects($this->once())
                ->method('charge')
                ->with(100.0)
                ->willReturn(true);

    $paymentProcessor = new PaymentProcessor($gatewayMock);
    $paymentProcessor->processPayment(100.0);
}

在此示例中，expects($this->once()) 确保 charge 方法仅被调用一次。如果该方法未被调用，或者调用多次，测试将失败。

示例：使用存储库进行测试

假设您有一个 UserService 类，它依赖于 UserRepository 来获取用户数据。要单独测试 UserService，您可以模拟 UserRepository。

class UserService
{
    private $repository;

    public function __construct(UserRepository $repository)
    {
        $this->repository = $repository;
    }

    public function getUserName($id)
    {
        $user = $this->repository->find($id);
        return $user->name;
    }
}

为了测试这个类，我们可以模拟存储库：

use PHPUnit\Framework\TestCase;

class UserServiceTest extends TestCase
{
    public function testGetUserName()
    {
        // Create a mock for the UserRepository
        $mockRepo = $this->createMock(UserRepository::class);

        // Define that the find method should return a user object with a predefined name
        $mockRepo->method('find')
                 ->willReturn((object) ['name' => 'John Doe']);

        // Instantiate the UserService with the mock repository
        $service = new UserService($mockRepo);

        // Assert that the getUserName method returns 'John Doe'
        $this->assertEquals('John Doe', $service->getUserName(1));
    }
}

使用模拟的最佳实践

1. 仅在必要时使用 Mocks：Mocks 对于隔离代码很有用，但过度使用会使测试难以理解。仅模拟测试所需的依赖项。
2. 关注行为，而不是实现：模拟应该帮助测试代码的行为，而不是依赖项的具体实现细节。
3. 避免模拟太多依赖项：如果一个类需要许多模拟依赖项，则可能表明该类有太多职责。如果需要的话重构。
4. 谨慎验证交互：除非对测试至关重要，否则避免过度验证方法调用。

结论

Mock 对象是在 PHPUnit 中编写单元测试的宝贵工具。它们允许您将代码与外部依赖项隔离，确保您的测试更快、更可靠且更易于维护。模拟对象还有助于验证被测代码及其依赖项之间的交互，确保您的代码在各种场景中都能正确运行