C#单元MOCK测试Moq常用方法示例 – 三郎君的日常
三郎君的日常

面试 · 2023年6月9日 0

C#单元MOCK测试Moq常用方法示例

Moq常用方法示例

学习之前

您好！我是Sanro，很幸运在测试学习之路上遇到新的伙伴！本片文章已经同步到个人技术博客：C#单元MOCK测试Moq常用方法示例 。如果有疑问和需求你可以联系我详细探讨。

学习步骤

学习 Moq 测试需要理解单元测试和模拟对象的概念。以下是一些建议的步骤和资源，帮助你开始学习 Moq 测试：

  1. 了解单元测试：单元测试是一种软件测试方法，用于验证代码中的各个单元（如方法、函数、类）是否按预期工作。学习单元测试的基本概念、原则和实践方法是学习 Moq 测试的前提。
  2. 理解模拟对象：在测试中，为了隔离被测试对象的依赖，我们使用模拟对象（Mock Object）来替代真实的依赖对象。模拟对象具有预定义的行为和验证能力，用于模拟被测试对象的依赖关系。学习模拟对象的概念和使用方法是学习 Moq 测试的核心。
  3. 掌握 Moq：Moq 是一个流行的 .NET 模拟框架，它简化了创建和管理模拟对象的过程。了解 Moq 的基本语法、API 和用法是学习 Moq 测试的关键。可以阅读 Moq 的官方文档和教程，其中包含了详细的使用示例和说明。官方地址：Docment/moq)
  4. 定义测试场景：在学习 Moq 测试时，选择一个合适的示例项目或代码片段作为练习对象。确定要测试的方法、类或功能，并考虑需要模拟的依赖关系。设计测试场景和预期结果，以便使用 Moq 创建适当的模拟对象。
  5. 编写测试用例：使用 Moq 创建模拟对象，并编写测试用例来验证被测试对象的行为。使用 Moq 的 API 设置模拟对象的行为和预期，然后调用被测试对象并断言预期结果。
  6. 运行和分析测试：使用适当的测试运行器（如 NUnit、xUnit 等）运行测试用例，并观察测试结果。分析测试结果，确保被测试对象按预期工作，并查看测试覆盖率和其他指标。
  7. 深入学习和实践：随着对 Moq 测试的基本理解和实践，逐渐深入学习更高级的 Moq 功能和技术，如设置模拟对象的回调、参数匹配、验证模拟对象的调用等。参考 Moq 的高级文档和示例，探索更多的测试场景和用例。 相关社区

除了上述步骤，还可以参考一些优秀的教程、博客和书籍，如《The Art of Unit Testing with Examples in .NET》、Moq 官方文档和社区论坛等，这些资源可以帮助你更全面地理解和应用 Moq 测试。Moq 的社区讨论和支持主要集中在以下几个地方：

  1. Moq GitHub 仓库：GitHub/moq在 GitHub 仓库的 “Issues” 部分，你可以查看已有的问题和讨论，或者创建新的问题来寻求帮助和讨论。
  2. Moq 的 Gitter 聊天室：Gitter/moq在 Gitter 聊天室中，你可以与其他 Moq 用户和贡献者进行实时的交流和讨论。
  3. Stack Overflow 上的 “moq”板块：Stack Overflow/moqStack Overflow 是一个常用的问答网站，你可以在这个标签下找到与 Moq 相关的问题和答案。

通过参与这些社区讨论和寻求帮助，你可以与其他 Moq 用户分享经验、解决问题，并获取更多关于 Moq 的使用技巧和最佳实践。

此外在国内，有一些专注于测试技术的社区和平台，提供了丰富的测试相关内容和交流机会。以下是一些国内的测试技术社区：

  1. TesterHome：https://testerhome.com/TesterHome 是国内领先的测试技术社区，聚集了大量的测试从业者和爱好者。在 TesterHome 上，你可以找到各类测试技术的文章、教程、工具和讨论，并与其他测试人员交流经验和解决问题。
  2. TestingBar：https://testingbar.com/TestingBar 是一个专注于测试技术的社区，提供了测试技术文章、培训课程、测试工具和招聘信息等资源。在 TestingBar 上，你可以与其他测试人员分享经验、学习新的测试技术，并参与社区的活动和讨论。
  3. Bugly 测试社区：https://tester.bugly.qq.com/Bugly 测试社区是由腾讯 Bugly 所创建的测试技术社区，聚焦于移动应用测试。社区中有丰富的测试资源、案例分享和技术讨论，你可以在这里学习移动应用测试的最佳实践和技巧。

这些测试技术社区提供了丰富的测试资源、讨论和交流机会，你可以在其中获取到测试领域的最新动态、技术分享和实践经验。此外，还有一些测试专题公众号、测试微信群等社交媒体平台也提供了测试相关的内容和交流渠道，你可以根据自己的兴趣和需求进行搜索和参与。

Moq 是一个用于创建和管理模拟对象的 .NET 开发工具。它提供了丰富的方法和功能来设置模拟对象的行为、验证方法调用等。以下是一些常用的 Moq 方法和示例代码：

1.Setup方法：用于设置模拟对象的成员行为。

// 设置方法的返回值

mockObject.Setup(m => m.MethodName()).Returns("mocked result");

// 设置方法的行为

mockObject.Setup(m => m.MethodName()).Callback(() => /* 操作 */);

// 设置属性的返回值

mockObject.SetupGet(m => m.PropertyName).Returns("mocked value");

// 设置属性的行为

mockObject.SetupSet(m => m.PropertyName = It.IsAny<string>()).Callback<string>(value => /* 操作 */);

2.Returns 方法：用于指定模拟对象方法的返回值。

// 返回固定的值
mockObject.Setup(m => m.MethodName()).Returns("mocked result");

// 返回由委托方法生成的值
mockObject.Setup(m => m.MethodName()).Returns(() => /* 生成值的逻辑 */);

// 返回由输入参数决定的值
mockObject.Setup(m => m.MethodName(It.IsAny<string>())).Returns((string input) => /* 根据输入参数生成值的逻辑 */);

3.Callback 方法：用于在模拟对象方法被调用时执行自定义操作。

mockObject.Setup(m => m.MethodName()).Callback(() => /* 自定义操作 */);

4.Verify 方法：用于验证模拟对象的方法调用是否符合预期。

// 验证方法被调用一次
mockObject.Verify(m => m.MethodName(), Times.Once);

// 验证方法被调用特定次数
mockObject.Verify(m => m.MethodName(), Times.Exactly(3));

// 验证方法被调用时传入了特定参数
mockObject.Verify(m => m.MethodName("expected parameter"), Times.Once);

// 验证方法未被调用
mockObject.Verify(m => m.MethodName(), Times.Never);

5.It.IsAny<T>：用于表示任意类型的参数匹配。

mockObject.Setup(m => m.MethodName(It.IsAny<string>())).Returns("mocked result");

mockObject.Verify(m => m.MethodName(It.IsAny<int>()), Times.Once);

这些方法只是 Moq 框架中的一小部分，用于模拟对象的设置和验证。你可以根据需要深入学习 Moq 的更多功能和用法，以满足你的测试需求。当使用 Moq 进行测试时，还有一些其他常用的方法和模式可以帮助你创建和配置模拟对象。以下是一些示例：

6.参数匹配：

// 匹配特定参数值
mockObject.Setup(m => m.MethodName("expected parameter")).Returns("mocked result");

// 匹配任意参数
mockObject.Setup(m => m.MethodName(It.IsAny<string>())).Returns("mocked result");

// 自定义参数匹配逻辑
mockObject.Setup(m => m.MethodName(It.Is<int>(x => x % 2 == 0))).Returns("even");
mockObject.Setup(m => m.MethodName(It.IsInRange(1, 10, Range.Inclusive))).Returns("within range");

7.异步方法支持：

// 设置异步方法的返回值
mockObject.Setup(m => m.MethodNameAsync()).ReturnsAsync("mocked result");

// 模拟异步方法的延迟
mockObject.Setup(m => m.MethodNameAsync()).Returns(async () =>
{
    await Task.Delay(1000);
    return "mocked result";
});

8.回调函数的参数捕获：

string capturedArgument = null;
mockObject.Setup(m => m.MethodName(It.IsAny<string>())).Callback<string>(arg => capturedArgument = arg);

// 在回调函数中使用捕获的参数
mockObject.Setup(m => m.AnotherMethod(capturedArgument)).Returns("mocked result");

9.部分模拟对象

// 创建一个真实对象的部分模拟
var realObject = new RealObject();
var mockObject = Mock.Get(realObject);

// 仅对部分方法进行模拟
mockObject.Setup(m => m.MethodName()).Returns("mocked result");

这些示例展示了更多 Moq 的用法，包括参数匹配、异步方法支持、回调函数参数捕获和部分模拟对象等。通过使用这些方法和模式，你可以更灵活地配置和操作模拟对象，以满足你的具体测试需求。请根据你的项目和测试场景选择适当的方法。当使用 Moq 进行测试时，还有一些其他常用的方法和模式可以帮助你创建和配置模拟对象。以下是进一步的示例：

10.抛出异常：

// 设置方法在调用时抛出异常
mockObject.Setup(m => m.MethodName()).Throws<Exception>();

// 自定义异常类型和消息
mockObject.Setup(m => m.MethodName()).Throws(new CustomException("Exception message"));

11.序列化返回值：

// 设置方法返回序列化的对象
mockObject.Setup(m => m.MethodName()).ReturnsSerialized("serialized object");

// 使用自定义序列化器
mockObject.Setup(m => m.MethodName()).ReturnsSerializedWith(serializer, "serialized object");

12.调用真实对象：

// 创建一个真实对象的模拟包装
var realObject = new RealObject();
var mockObject = Mock.Get(realObject);

// 对真实对象的方法进行模拟和验证
mockObject.Setup(m => m.MethodName()).Returns("mocked result");
mockObject.Verify(m => m.MethodName(), Times.Once);

13.对事件进行模拟：

// 创建模拟事件的委托
var eventHandler = new EventHandler();
mockObject.Object.EventName += eventHandler;

// 触发模拟事件
mockObject.Raise(m => m.EventName += null, EventArgs.Empty);

// 验证事件是否被触发
mockObject.Verify(m => m.EventName += eventHandler, Times.Once);

这些示例展示了更多 Moq 的用法，包括抛出异常、序列化返回值、调用真实对象以及对事件进行模拟和验证。通过使用这些方法，你可以在测试中更精确地控制模拟对象的行为，并进行相应的断言和验证。根据你的具体测试需求，选择适当的方法来设置和操作模拟对象。当使用 Moq 进行测试时，还有一些其他常用的方法和模式可以帮助你创建和配置模拟对象。以下是进一步的示例：

14.顺序验证：

// 设置模拟对象方法的顺序
var mockObject = new Mock<IMyInterface>(MockBehavior.Strict);
mockObject.Setup(m => m.Method1()).Returns(1).Verifiable();
mockObject.Setup(m => m.Method2()).Returns(2).Verifiable();

// 调用模拟对象方法
var result1 = mockObject.Object.Method1();
var result2 = mockObject.Object.Method2();

// 验证方法的顺序
mockObject.Verify();

// 验证方法的顺序（使用自定义顺序）
mockObject.Verify(m => m.Method1(), Times.AtMostOnce());
mockObject.Verify(m => m.Method2(), Times.Once());

15.设置属性的行为：

// 设置属性的 getter 行为
mockObject.SetupGet(m => m.MyProperty).Returns("mocked value");

// 设置属性的 setter 行为
mockObject.SetupSet(m => m.MyProperty = It.IsAny<string>()).Callback<string>(value => /* 自定义操作 */);

16.模拟接口的默认实现：

// 创建接口的默认实现
var defaultImplementation = new DefaultImplementation();

// 创建模拟对象并设置默认实现
var mockObject = new Mock<IMyInterface>(MockBehavior.Default) { DefaultValue = DefaultValue.Mock };
mockObject.Setup(m => m.Method()).Returns("mocked result");

// 设置模拟对象的默认实现
mockObject.As<IMyInterface>().DefaultImplemented();

// 调用默认实现的方法
var result = mockObject.Object.Method();

// 验证调用的方法是否为默认实现
Assert.Equal("default implementation", result);

17.配置模拟对象的回调函数

// 设置模拟对象方法的回调函数
mockObject.Setup(m => m.Method()).Callback(() => /* 自定义操作 */);

// 设置模拟对象方法的回调函数，并修改输入参数
mockObject.Setup(m => m.Method(It.IsAny<string>())).Callback<string>(input => /* 修改输入参数的操作 */);

// 设置模拟对象方法的回调函数，并返回特定的值
mockObject.Setup(m => m.Method()).Callback(() => /* 自定义操作 */).Returns("mocked result");

18.设置方法的回调函数并返回结果：

// 设置方法的回调函数，并返回特定的结果
mockObject.Setup(m => m.MethodName()).Callback(() => /* 自定义操作 */).Returns("mocked result");

// 设置方法的回调函数，并根据输入参数返回不同的结果
mockObject.Setup(m => m.MethodName(It.IsAny<int>())).Callback<int>(input => /* 自定义操作 */).Returns((int input) => /* 返回特定的结果 */);

19.配置方法的抛出异常：

// 设置方法在调用时抛出异常
mockObject.Setup(m => m.MethodName()).Throws<Exception>();

// 自定义异常类型和消息
mockObject.Setup(m => m.MethodName()).Throws(new CustomException("Exception message"));

20.验证方法的调用次数和顺序：

// 验证方法被调用的次数
mockObject.Verify(m => m.MethodName(), Times.Once);

// 验证方法未被调用
mockObject.Verify(m => m.MethodName(), Times.Never);

// 验证方法调用的顺序
var verifier = new MockSequence();
mockObject.InSequence(verifier).Setup(m => m.Method1());
mockObject.InSequence(verifier).Setup(m => m.Method2());

21.模拟接口的默认实现：

// 创建接口的默认实现
var defaultImplementation = new DefaultImplementation();

// 创建模拟对象并设置默认实现
varmockObject = new Mock<IMyInterface>(MockBehavior.Default) { DefaultValue = DefaultValue.Mock };
mockObject.Setup(m => m.Method()).Returns("mocked result");

// 设置模拟对象的默认实现
mockObject.As<IMyInterface>().DefaultImplemented();

// 调用默认实现的方法
var result = mockObject.Object.Method();

// 验证调用的方法是否为默认实现
Assert.Equal("default implementation", result);
这些示例展示了更多 Moq 的用法，包括设置方法的回调函数并返回结果、配置方法的抛出异常、验证方法的调用次数和顺序以及模拟接口的默认实现。通过使用这些方法，你可以更加灵活地配置和操作模拟对象，以满足你的具体测试需求。根据你的项目和测试场景选择适当的方法。

#C#单元测试：Nunit+Moq示例

当使用 NUnit 和 Moq 进行单元测试时，以下是一个较为全面系统的示例，包括创建模拟对象、设置模拟对象的行为、执行测试代码和验证模拟对象的调用：

示例1： CalculatorTests

1.被测类:Calculator

// 使用 NuGet 安装 NUnit 和 Moq 包
// 要测试的类
public class Calculator
{
    private readonly ICalculatorService _calculatorService;

    public Calculator(ICalculatorService calculatorService)
    {
        _calculatorService = calculatorService;
    }

    public int Add(int a, int b)
    {
        return _calculatorService.Add(a, b);
    }
}

2.接口实现: ICalculatorService

// 接口和其实现
public interface ICalculatorService
{
    int Add(int a, int b);
}

public class CalculatorService : ICalculatorService
{
    public int Add(int a, int b)
    {
        return a + b;
    }
}

3.单元测试:s CalculatorTests

// 单元测试类
[TestFixture]
public class CalculatorTests
{
    [Test]
    public void Add_WithValidParameters_ReturnsSum()
    {
        // 创建模拟对象
        var calculatorServiceMock = new Mock<ICalculatorService>();

        // 设置模拟对象的行为
        calculatorServiceMock.Setup(m => m.Add(2, 3)).Returns(5);

        // 实例化要测试的类，并传入模拟对象
        var calculator = new Calculator(calculatorServiceMock.Object);

        // 执行测试代码
        int result = calculator.Add(2, 3);

        // 验证模拟对象的调用
        calculatorServiceMock.Verify(m => m.Add(2, 3), Times.Once);

        // 断言测试结果
        Assert.AreEqual(5, result);
    }
}

在这个示例中，我们有一个要测试的 Calculator 类，它依赖于一个 ICalculatorService 接口。我们使用 Moq 创建了 calculatorServiceMock 模拟对象，并设置了 Add 方法的行为。然后我们实例化了 Calculator 类，并将模拟对象传递给它。在执行测试代码后，我们使用 Verify 方法验证了模拟对象的调用，并使用断言来验证测试结果。

这个示例展示了一个完整的单元测试流程，涵盖了模拟对象的创建、行为设置、测试代码的执行和模拟对象调用的验证。你可以根据自己的项目需求和测试场景，进一步扩展和定制这个示例，以满足你的具体需求。

示例2：

1.被测类：UserManager

// 使用 NuGet 安装 NUnit 和 Moq 包

// 要测试的类
public class UserManager
{
    private readonly IUserRepository _userRepository;
    private readonly IEmailService _emailService;

    public UserManager(IUserRepository userRepository, IEmailService emailService)
    {
        _userRepository = userRepository;
        _emailService = emailService;
    }

    public bool RegisterUser(User user)
    {
        if (_userRepository.GetUserByEmail(user.Email) != null)
            return false;

        _userRepository.AddUser(user);
        _emailService.SendEmail(user.Email, "Welcome!", "Welcome to our platform!");

        return true;
    }
}

2.用户类实体: User

// 用户实体类
public class User
{
    public string Email { get; set; }
    public string Password { get; set; }
    // 其他属性...
}

3.用户仓储接口: IUserRepository

// 用户仓储接口
public interface IUserRepository
{
    User GetUserByEmail(string email);
    void AddUser(User user);
}

4.邮件服务接口: IEmailService

// 邮件服务接口
public interface IEmailService
{
    void SendEmail(string email, string subject, string body);
}

5.单元测试类:s UserManagerTests

// 单元测试类
[TestFixture]
public class UserManagerTests
{
    // 模拟对象
    private Mock<IUserRepository> _userRepositoryMock;
    private Mock<IEmailService> _emailServiceMock;

    // 要测试的类
    private UserManager _userManager;

    [SetUp]
    public void SetUp()
    {
        // 创建模拟对象
        _userRepositoryMock = new Mock<IUserRepository>();
        _emailServiceMock = new Mock<IEmailService>();

        // 实例化要测试的类，并传入模拟对象
        _userManager = new UserManager(_userRepositoryMock.Object, _emailServiceMock.Object);
    }

    [TestCase("test@example.com", "password", true)]
    [TestCase("existing@example.com", "password", false)]
    public void RegisterUser_ValidUser_ReturnsSuccess(string email, string password, bool expectedResult)
    {
        // 设置模拟对象的行为
        _userRepositoryMock.Setup(m => m.GetUserByEmail(email))
                           .Returns(expectedResult ? null : new User { Email = email, Password = password });

        // 执行测试代码
        bool result = _userManager.RegisterUser(new User { Email = email, Password = password });

        // 验证模拟对象的调用
        _userRepositoryMock.Verify(m => m.GetUserByEmail(email), Times.Once);
        _userRepositoryMock.Verify(m => m.AddUser(It.IsAny<User>()), expectedResult ? Times.Once() : Times.Never);
        _emailServiceMock.Verify(m => m.SendEmail(email, "Welcome!", "Welcome to our platform!"), expectedResult ? Times.Once() : Times.Never);

        // 断言测试结果
        Assert.AreEqual(expectedResult, result);
    }
}

在这个示例中，我们有一个要测试的 UserManager 类，它依赖于一个 IUserRepository 接口和一个 IEmailService 接口。我们使用 Moq 创建了 _userRepositoryMock 和 _emailServiceMock 模拟对象，并设置了它们的行为。在 RegisterUser_ValidUser_ReturnsSuccess 测试方法中，我们使用多个 TestCase 来测试注册用户的不同情况。在每个测试案例中，我们设置模拟对象的行为，并验证它们的调用情况。最后，我们使用断言

首先，我们有一个 UserManager 类，它负责用户的注册操作。它依赖于 IUserRepository 接口和 IEmailService 接口来访问用户数据和发送电子邮件。

接下来，我们有一个 User 类，它表示用户实体，包含了一些属性，例如电子邮件和密码。

然后，我们定义了 IUserRepository 接口和 IEmailService 接口，分别定义了与用户数据和电子邮件服务相关的方法。

接下来，我们进入了单元测试部分。

我们使用 NUnit 和 Moq 进行单元测试，并使用 [TestFixture] 属性标记了我们的测试类 UserManagerTests。

在 SetUp 方法中，我们进行了测试准备工作。我们创建了 IUserRepository 和 IEmailService 的模拟对象，并将它们传递给要测试的 UserManager 类的实例。

接下来，我们定义了一个名为 RegisterUser_ValidUser_ReturnsSuccess 的测试方法，并使用 [TestCase] 属性定义了多个测试案例。每个测试案例都包含了用户的电子邮件和密码，以及预期的注册结果。

在每个测试案例中，我们使用 Moq 的 Setup 方法设置模拟对象的行为。我们设置了 IUserRepository 的 GetUserByEmail 方法返回一个用户实体或 null，以模拟不同的情况。我们还设置了 IUserRepository 的 AddUser 方法和 IEmailService 的 SendEmail 方法的行为。

然后，我们执行了要测试的代码，即调用 RegisterUser 方法，并传入相应的用户实体。最后，我们使用 Moq 的 Verify 方法来验证模拟对象的调用情况。

我们验证了 IUserRepository 的 GetUserByEmail 方法是否被调用了一次，AddUser 方法和 SendEmail 方法是否根据预期被调用了相应的次数。

最后，我们使用断言来验证测试结果，即注册操作的实际结果是否与预期结果一致。

通过这个示例，我们演示了如何使用 NUnit 和 Moq 进行单元测试，并展示了 Moq 的一些常用方法，如 Setup 和 Verify，以及如何使用 [TestCase] 属性定义多个测试案例来覆盖不同的情况。这个示例可以作为一个参考，帮助你理解如何编写更复杂的单元测试代码，测试实际项目中的各种场景。

您可能还喜欢...

发表评论