发布于 由admin

C++中的Mocking与Stubbing框架：实现单元测试中的依赖隔离与行为验证

C++中的Mocking与Stubbing框架：实现单元测试中的依赖隔离与行为验证

大家好，今天我们要深入探讨C++中单元测试的核心技术：Mocking和Stubbing，以及如何利用它们来实现依赖隔离和行为验证。单元测试的目的是隔离被测单元，对其行为进行独立验证。但现实中，代码往往依赖于其他模块、外部服务或者复杂的系统状态。直接测试这些依赖关系不仅困难，而且会使单元测试变得脆弱，失去其应有的价值。这就是Mocking和Stubbing发挥作用的地方。

什么是Mocking和Stubbing？

简单来说，Mocking和Stubbing都是用可控制的替身对象来替换真实依赖项的技术。它们的主要区别在于关注点不同：

  • Stubbing (打桩): 用于提供预定义的返回值，模拟依赖项的特定状态。它的目的是控制依赖项的输出，以便在被测单元中使用。Stubbing关注的是“状态验证”。

  • Mocking (模拟): 用于验证被测单元与依赖项之间的交互。它允许我们设置期望，验证依赖项的特定方法是否被调用，以及调用的次数和参数。Mocking关注的是“行为验证”。

可以这样理解， Stubbing 是为了让被测单元能正常运行，Mocking 是为了验证被测单元的行为是否符合预期。

为什么需要Mocking和Stubbing？

  • 依赖隔离： 消除对外部系统、数据库、文件系统或第三方库的依赖，使单元测试更快速、更可靠。
  • 可预测性： 控制依赖项的行为，确保测试在不同环境中都能得到一致的结果。
  • 并行测试： 允许并行运行测试，提高测试效率。
  • 测试驱动开发 (TDD)： 在开发代码之前编写测试，Mocking和Stubbing是TDD的关键技术。
  • 行为验证： 验证被测单元是否以正确的方式与依赖项交互。

C++ Mocking和Stubbing框架：Google Mock

在C++生态系统中，Google Mock (简称gMock) 是一个流行的Mocking框架。它与Google Test (gTest) 集成紧密，提供了强大的功能和灵活的API。

gMock基础概念

  • Mock Classes (模拟类): 手动或使用gMock宏生成的类，用于替换真实依赖项。Mock类继承自真实类的接口，并重写需要模拟的方法。
  • Actions (动作): 定义Mock方法在被调用时执行的操作，例如返回预定义的值、抛出异常或执行自定义代码。
  • Matchers (匹配器): 用于验证Mock方法的参数是否符合预期。gMock提供了丰富的内置匹配器，也可以自定义匹配器。
  • Expectations (期望): 定义Mock方法被调用的方式、次数和参数。gMock使用期望来验证被测单元的行为。

gMock代码示例

为了演示gMock的使用，我们假设有一个简单的场景：一个 OrderService 类依赖于一个 PaymentGateway 接口来处理支付。

首先，定义 PaymentGateway 接口：

// payment_gateway.h
#ifndef PAYMENT_GATEWAY_H
#define PAYMENT_GATEWAY_H

#include <string>

class PaymentGateway {
public:
  virtual ~PaymentGateway() {}
  virtual bool processPayment(const std::string& creditCardNumber, double amount) = 0;
};

#endif

接下来，定义 OrderService 类：

// order_service.h
#ifndef ORDER_SERVICE_H
#define ORDER_SERVICE_H

#include "payment_gateway.h"
#include <string>

class OrderService {
public:
  OrderService(PaymentGateway* paymentGateway) : paymentGateway_(paymentGateway) {}

  bool processOrder(const std::string& creditCardNumber, double orderTotal) {
    if (orderTotal <= 0) {
      return false; // Invalid order total
    }
    return paymentGateway_->processPayment(creditCardNumber, orderTotal);
  }

private:
  PaymentGateway* paymentGateway_;
};

#endif

现在，我们可以使用gMock来为 PaymentGateway 创建一个Mock类，并编写单元测试来验证 OrderService 的行为。

// order_service_test.cc
#include "gtest/gtest.h"
#include "gmock/gmock.h"
#include "order_service.h"
#include "payment_gateway.h"

using ::testing::Return;
using ::testing::_; // Wildcard matcher: matches any argument
using ::testing::DoubleEq;

// 创建PaymentGateway的Mock类
class MockPaymentGateway : public PaymentGateway {
public:
  MOCK_METHOD(bool, processPayment, (const std::string&, double), (override));
};

TEST(OrderServiceTest, ProcessOrder_ValidOrder_PaymentSuccess) {
  // Arrange
  MockPaymentGateway mockPaymentGateway;
  OrderService orderService(&mockPaymentGateway);
  std::string creditCardNumber = "1234-5678-9012-3456";
  double orderTotal = 100.0;

  // 设置期望：processPayment方法应该被调用一次，参数分别为creditCardNumber和orderTotal，并且返回true
  EXPECT_CALL(mockPaymentGateway, processPayment(creditCardNumber, DoubleEq(orderTotal)))
      .Times(1)
      .WillOnce(Return(true));

  // Act
  bool result = orderService.processOrder(creditCardNumber, orderTotal);

  // Assert
  ASSERT_TRUE(result);
}

TEST(OrderServiceTest, ProcessOrder_InvalidOrder_PaymentNotProcessed) {
  // Arrange
  MockPaymentGateway mockPaymentGateway;
  OrderService orderService(&mockPaymentGateway);
  std::string creditCardNumber = "1234-5678-9012-3456";
  double orderTotal = 0.0;

  // 设置期望：processPayment方法不应该被调用
  EXPECT_CALL(mockPaymentGateway, processPayment(_, _))
      .Times(0);

  // Act
  bool result = orderService.processOrder(creditCardNumber, orderTotal);

  // Assert
  ASSERT_FALSE(result);
}

TEST(OrderServiceTest, ProcessOrder_ValidOrder_PaymentFailure) {
  // Arrange
  MockPaymentGateway mockPaymentGateway;
  OrderService orderService(&mockPaymentGateway);
  std::string creditCardNumber = "1234-5678-9012-3456";
  double orderTotal = 100.0;

  // 设置期望：processPayment方法应该被调用一次，参数分别为creditCardNumber和orderTotal，并且返回false
  EXPECT_CALL(mockPaymentGateway, processPayment(creditCardNumber, DoubleEq(orderTotal)))
      .Times(1)
      .WillOnce(Return(false));

  // Act
  bool result = orderService.processOrder(creditCardNumber, orderTotal);

  // Assert
  ASSERT_FALSE(result);
}

代码解释

  • MockPaymentGateway 是 PaymentGateway 的Mock类，使用 MOCK_METHOD 宏自动生成 processPayment 方法的Mock版本。
  • EXPECT_CALL 用于设置期望，指定 processPayment 方法应该如何被调用。
    • Times(1) 表示该方法应该被调用一次。
    • WillOnce(Return(true)) 表示该方法被调用时应该返回 true。
    • DoubleEq(orderTotal) 是一个匹配器，用于验证 amount 参数是否等于 orderTotal。
    • _ 是一个通配符匹配器，可以匹配任何参数值。
  • ASSERT_TRUE 和 ASSERT_FALSE 用于验证 OrderService 的返回值是否符合预期。

gMock高级特性

  • Matchers (匹配器): gMock提供了大量的内置匹配器，例如 Eq (等于), Ne (不等于), Gt (大于), Lt (小于), Ge (大于等于), Le (小于等于), StrEq (字符串相等), StartsWith (以指定字符串开头), Contains (包含指定字符串) 等。 也可以自定义匹配器来满足特定的需求。
// 自定义匹配器示例
MATCHER(IsPositive, "") { return arg > 0; }

TEST(OrderServiceTest, ProcessOrder_InvalidAmount_CustomMatcher) {
  MockPaymentGateway mockPaymentGateway;
  OrderService orderService(&mockPaymentGateway);

  EXPECT_CALL(mockPaymentGateway, processPayment(_, IsPositive()))
      .Times(0);

  orderService.processOrder("1234-5678-9012-3456", -10.0); // 负数金额
}
  • Actions (动作): 除了 Return 之外，gMock还提供了其他Action，例如 Throw (抛出异常), Invoke (调用自定义函数), Assign (赋值给变量) 等。
// 抛出异常示例
class MyException : public std::exception {};

TEST(OrderServiceTest, ProcessOrder_PaymentGatewayThrowsException) {
  MockPaymentGateway mockPaymentGateway;
  OrderService orderService(&mockPaymentGateway);

  EXPECT_CALL(mockPaymentGateway, processPayment(_, _))
      .WillOnce(Throw(MyException()));

  try {
    orderService.processOrder("1234-5678-9012-3456", 100.0);
    FAIL() << "Expected MyException to be thrown";
  } catch (const MyException&) {
    // 期望抛出异常
  }
}

// 调用自定义函数示例
int global_counter = 0;
void increment_counter(const std::string& card, double amount) {
  global_counter++;
}

TEST(OrderServiceTest, ProcessOrder_PaymentGatewayInvokesFunction) {
  MockPaymentGateway mockPaymentGateway;
  OrderService orderService(&mockPaymentGateway);
  global_counter = 0;

  EXPECT_CALL(mockPaymentGateway, processPayment(_, _))
      .WillOnce(Invoke(increment_counter));

  orderService.processOrder("1234-5678-9012-3456", 100.0);

  ASSERT_EQ(global_counter, 1);
}
  • Cardinality (基数): 除了 Times 之外，还可以使用 AtLeast, AtMost, Between 等来指定方法被调用的次数范围。
// 方法至少被调用一次
EXPECT_CALL(mockPaymentGateway, processPayment(_, _))
    .AtLeast(1);

// 方法最多被调用三次
EXPECT_CALL(mockPaymentGateway, processPayment(_, _))
    .AtMost(3);

// 方法被调用1到3次之间
EXPECT_CALL(mockPaymentGateway, processPayment(_, _))
    .Between(1, 3);
  • Sequences (序列): 可以定义方法调用的顺序。
::testing::Sequence s1;

EXPECT_CALL(mockPaymentGateway, processPayment("card1", _))
    .InSequence(s1)
    .WillOnce(Return(true));

EXPECT_CALL(mockPaymentGateway, processPayment("card2", _))
    .InSequence(s1)
    .WillOnce(Return(false));

Stubbing示例

虽然gMock主要用于Mocking，但它也可以用于Stubbing。 当我们仅仅需要控制依赖项的返回值，而不需要验证其行为时，可以使用 WillRepeatedly 来设置默认返回值。

TEST(OrderServiceTest, ProcessOrder_AlwaysReturnsTrue) {
  MockPaymentGateway mockPaymentGateway;
  OrderService orderService(&mockPaymentGateway);

  // 设置processPayment方法总是返回true
  ON_CALL(mockPaymentGateway, processPayment(_, _))
      .WillByDefault(Return(true));

  bool result1 = orderService.processOrder("card1", 100.0);
  bool result2 = orderService.processOrder("card2", 200.0);

  ASSERT_TRUE(result1);
  ASSERT_TRUE(result2);
}

ON_CALL 用于设置Stubbing， WillByDefault 指定默认的Action。

Mocking和Stubbing的最佳实践

  • 只Mock你拥有的类型： 避免Mock第三方库或系统API，因为它们的行为不受你的控制。应该封装这些依赖项，然后Mock你自己的封装层。
  • 保持Mock对象简单： Mock对象应该尽可能简单，只模拟被测单元实际使用的行为。
  • 避免过度Mocking： 过度Mocking会使测试变得脆弱，难以维护。只Mock必要的依赖项。
  • 使用清晰的命名： 为Mock类和测试用例使用清晰的命名，以便于理解和维护。
  • 优先使用Stubbing进行状态验证， 使用Mocking进行行为验证

与其他Mocking框架的比较

除了gMock，还有其他的C++ Mocking框架，例如：

框架 优点 缺点
Google Mock 强大的功能，灵活的API，与Google Test集成紧密， 广泛使用，文档丰富。 学习曲线较陡峭。
Trompeloeil 轻量级， header-only，编译速度快，支持C++14及更高版本。 功能相对较少，文档不如gMock完善。
FakeIt 易于使用，API简洁，支持C++11及更高版本，也提供 header-only 版本。 功能相对较少，性能可能不如gMock。

选择哪个框架取决于项目的具体需求和团队的偏好。gMock由于其功能丰富和广泛使用，通常是首选。

Mocking和Stubbing的局限性

  • 过度依赖Mocking： 过度依赖Mocking会导致测试与真实代码脱节，降低测试的价值。
  • 维护成本： 当依赖项发生变化时，需要更新Mock对象，增加维护成本。
  • 无法测试集成： Mocking只能测试单元级别的行为，无法测试不同模块之间的集成。

因此，Mocking和Stubbing应该作为单元测试的一部分，与其他测试类型（例如集成测试和端到端测试）结合使用，以确保代码的质量。

代码示例：使用Trompeloeil

// 使用Trompeloeil进行Mocking
#include "trompeloeil.hpp"
#include "payment_gateway.h"
#include "order_service.h"

using namespace trompeloeil;

struct MockPaymentGateway : public PaymentGateway {
  MAKE_MOCK2(processPayment, bool(const std::string&, double));
};

TEST(OrderServiceTestTrompeloeil, ProcessOrder_ValidOrder_PaymentSuccess) {
  MockPaymentGateway mockPaymentGateway;
  OrderService orderService(&mockPaymentGateway);

  std::string creditCardNumber = "1234-5678-9012-3456";
  double orderTotal = 100.0;

  REQUIRE_CALL(mockPaymentGateway, processPayment(creditCardNumber, orderTotal))
      .RETURN(true);

  bool result = orderService.processOrder(creditCardNumber, orderTotal);

  ASSERT_TRUE(result);
}

总结一下今天的内容

今天我们深入探讨了C++中的Mocking和Stubbing技术，学习了如何使用gMock框架来实现依赖隔离和行为验证。我们了解了Mocking和Stubbing的基本概念、目的和最佳实践，并通过代码示例演示了gMock的各种高级特性。掌握这些技术可以帮助我们编写更健壮、更可靠的单元测试，提高代码质量。

总结一下讲座要点

  • Mocking和Stubbing是单元测试中隔离依赖、验证行为的关键技术。
  • gMock是一个强大的C++ Mocking框架，提供了丰富的功能和灵活的API。
  • 正确使用Mocking和Stubbing可以提高测试效率、降低维护成本。
  • Mocking和Stubbing只是单元测试的一部分，需要与其他测试类型结合使用。

更多IT精英技术系列讲座，到智猿学院

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注