IT评测·应用市场-qidao123.com技术社区

标题: 掌握 xUnit 单位测试中的 Mock 与 Stub 实战 [打印本页]
作者: 农民    时间: 2024-5-17 02:45
标题: 掌握 xUnit 单位测试中的 Mock 与 Stub 实战
引言

上一章节介绍了 TDD 的三大法则，本日我们讲一下在单位测试中模仿对象的使用。
Fake

Fake - Fake 是一个通用术语，可用于描述 stub或 mock 对象。 它是 stub 照旧 mock 取决于使用它的上下文。 也就是说，Fake 可以是 stub 或 mock
Mock - Mock 对象是系统中的 fake 对象，用于确定单位测试是否通过。 Mock 起初为 Fake，直到对其断言。
Stub - Stub 是系统中现有依赖项的可控制替代项。 通过使用 Stub，可以在无需使用依赖项的情况下直接测试代码。
参考 单位测试最佳做法 让我们使用相同的术语
区别点：

总结：

在某些情况下两者可能看起来相似，但在测试的目的和用途上照旧存在一些区别。在编写单位测试时，根据测试场景和需求选择合适的 stub 或 mock对象可以帮助提高测试的准确性和可靠性。
创建实战项目

创建一个 WebApi 的 Controller 项目，和一个EFCore仓储类库作为我们后续章节的演示项目
  1. dotNetParadise-Xunit
  2. │
  3. ├── src
  4. │   ├── Sample.Api
  5. │   └── Sample.Repository
复制代码
Sample.Repository 是一个简单 EFCore 的仓储模式实现，Sample.Api 对外提供 RestFul 的 Api 接口
Sample.Repository 实现

  1. PM> NuGet\Install-Package Microsoft.EntityFrameworkCore.InMemory -Version 8.0.3
复制代码
  1. PM> Microsoft.EntityFrameworkCore.Relational -Version 8.0.3
复制代码
  1. public class Staff
  2. {
  3.     public int Id { get; set; }
  4.     public string Name { get; set; }
  5.     public string Email { get; set; }
  6.     public int? Age { get; set; }
  7.     public List<string>? Addresses { get; set; }
  9.     public DateTimeOffset? Created { get; set; }
  10. }
复制代码
  1. public class SampleDbContext(DbContextOptions<SampleDbContext> options) : DbContext(options)
  2. {
  3.     public DbSet<Staff> Staff { get; set; }
  5.     protected override void OnModelCreating(ModelBuilder builder)
  6.     {
  7.         base.OnModelCreating(builder);
  8.     }
  9. }
复制代码
  1. public interface IStaffRepository
  2. {
  3.     /// <summary>
  4.     /// 获取 Staff 实体的 DbSet
  5.     /// </summary>
  6.     DbSet<Staff> dbSet { get; }
  8.     /// <summary>
  9.     /// 添加新的 Staff 实体
  10.     /// </summary>
  11.     /// <param name="staff"></param>
  12.     Task AddStaffAsync(Staff staff, CancellationToken cancellationToken = default);
  14.     /// <summary>
  15.     /// 根据 Id 删除 Staff 实体
  16.     /// </summary>
  17.     /// <param name="id"></param>
  18.      Task DeleteStaffAsync(int id, CancellationToken cancellationToken = default);
  20.     /// <summary>
  21.     /// 更新 Staff 实体
  22.     /// </summary>
  23.     /// <param name="staff"></param>
  24.     Task UpdateStaffAsync(Staff staff, CancellationToken cancellationToken = default);
  26.     /// <summary>
  27.     /// 根据 Id 获取单个 Staff 实体
  28.     /// </summary>
  29.     /// <param name="id"></param>
  30.     /// <returns></returns>
  31.     Task<Staff?> GetStaffByIdAsync(int id, CancellationToken cancellationToken = default);
  33.     /// <summary>
  34.     /// 获取所有 Staff 实体
  35.     /// </summary>
  36.     /// <returns></returns>
  37.     Task<List<Staff>> GetAllStaffAsync(CancellationToken cancellationToken = default);
  39.     /// <summary>
  40.     /// 批量更新 Staff 实体
  41.     /// </summary>
  42.     /// <param name="staffList"></param>
  43.     Task BatchAddStaffAsync(List<Staff> staffList, CancellationToken cancellationToken = default);
  45. }
复制代码
  1. public class StaffRepository : IStaffRepository
  2. {
  3.     private readonly SampleDbContext _dbContext;
  4.     public DbSet<Staff> dbSet => _dbContext.Set<Staff>();
  5.     public StaffRepository(SampleDbContext dbContext)
  6.     {
  7.         dbContext.Database.EnsureCreated();
  8.         _dbContext = dbContext;
  9.     }
  10.     public async Task AddStaffAsync(Staff staff, CancellationToken cancellationToken = default)
  11.     {
  12.         await dbSet.AddAsync(staff, cancellationToken);
  13.         await _dbContext.SaveChangesAsync(cancellationToken);
  14.     }
  16.     public async Task DeleteStaffAsync(int id, CancellationToken cancellationToken = default)
  17.     {
  18.         //await dbSet.AsQueryable().Where(_ => _.Id == id).ExecuteDeleteAsync(cancellationToken);
  19.         var staff = await GetStaffByIdAsync(id, cancellationToken);
  20.         if (staff is not null)
  21.         {
  22.             dbSet.Remove(staff);
  23.             await _dbContext.SaveChangesAsync(cancellationToken);
  24.         }
  25.     }
  27.     public async Task UpdateStaffAsync(Staff staff, CancellationToken cancellationToken = default)
  28.     {
  29.         dbSet.Update(staff);
  30.         _dbContext.Entry(staff).State = EntityState.Modified;
  31.         await _dbContext.SaveChangesAsync(cancellationToken);
  32.     }
  34.     public async Task<Staff?> GetStaffByIdAsync(int id, CancellationToken cancellationToken = default)
  35.     {
  36.         return await dbSet.AsQueryable().Where(_ => _.Id == id).FirstOrDefaultAsync(cancellationToken);
  37.     }
  39.     public async Task<List<Staff>> GetAllStaffAsync(CancellationToken cancellationToken = default)
  40.     {
  41.         return await dbSet.ToListAsync(cancellationToken);
  42.     }
  44.     public async Task BatchAddStaffAsync(List<Staff> staffList, CancellationToken cancellationToken = default)
  45.     {
  46.         await dbSet.AddRangeAsync(staffList, cancellationToken);
  47.         await _dbContext.SaveChangesAsync(cancellationToken);
  48.     }
  49. }
复制代码
  1. public static class ServiceCollectionExtensions
  2. {
  3.     public static IServiceCollection AddEFCoreInMemoryAndRepository(this IServiceCollection services)
  4.     {
  5.         services.AddScoped<IStaffRepository, StaffRepository>();
  6.         services.AddDbContext<SampleDbContext>(options => options.UseInMemoryDatabase("sample").EnableSensitiveDataLogging(), ServiceLifetime.Scoped);
  7.         return services;
  8.     }
  9. }
复制代码
到现在为止 仓储层的简单实现已经完成了，接下来完成 WebApi 层
Sample.Api

将 Sample.Api 添加项目引用Sample.Repository
program 依赖注入
  1. builder.Services.AddEFCoreInMemoryAndRepository();
复制代码
  1. [Route("api/[controller]")]
  2. [ApiController]
  3. public class StaffController(IStaffRepository staffRepository) : ControllerBase
  4. {
  5.     private readonly IStaffRepository _staffRepository = staffRepository;
  7.     [HttpPost]
  8.     public async Task<IResult> AddStaff([FromBody] Staff staff, CancellationToken cancellationToken = default)
  9.     {
  10.         await _staffRepository.AddStaffAsync(staff, cancellationToken);
  11.         return TypedResults.NoContent();
  12.     }
  14.     [HttpDelete("{id}")]
  15.     public async Task<IResult> DeleteStaff(int id, CancellationToken cancellationToken = default)
  16.     {
  17.         await _staffRepository.DeleteStaffAsync(id);
  18.         return TypedResults.NoContent();
  19.     }
  21.     [HttpPut("{id}")]
  22.     public async Task<Results<BadRequest<string>, NoContent, NotFound>> UpdateStaff(int id, [FromBody] Staff staff, CancellationToken cancellationToken = default)
  23.     {
  24.         if (id != staff.Id)
  25.         {
  26.             return TypedResults.BadRequest("Staff ID mismatch");
  27.         }
  28.         var originStaff = await _staffRepository.GetStaffByIdAsync(id, cancellationToken);
  29.         if (originStaff is null) return TypedResults.NotFound();
  30.         originStaff.Update(staff);
  31.         await _staffRepository.UpdateStaffAsync(originStaff, cancellationToken);
  32.         return TypedResults.NoContent();
  33.     }
  35.     [HttpGet("{id}")]
  36.     public async Task<Results<Ok<Staff>, NotFound>> GetStaffById(int id, CancellationToken cancellationToken = default)
  37.     {
  38.         var staff = await _staffRepository.GetStaffByIdAsync(id, cancellationToken);
  39.         if (staff == null)
  40.         {
  41.             return TypedResults.NotFound();
  42.         }
  43.         return TypedResults.Ok(staff);
  44.     }
  47.     [HttpGet]
  48.     public async Task<IResult> GetAllStaff(CancellationToken cancellationToken = default)
  49.     {
  50.         var staffList = await _staffRepository.GetAllStaffAsync(cancellationToken);
  51.         return TypedResults.Ok(staffList);
  52.     }
  55.     [HttpPost("BatchAdd")]
  56.     public async Task<IResult> BatchAddStaff([FromBody] List<Staff> staffList, CancellationToken cancellationToken = default)
  57.     {
  58.         await _staffRepository.BatchAddStaffAsync(staffList, cancellationToken);
  59.         return TypedResults.NoContent();
  60.     }
  62. }
复制代码
F5 项目跑一下

到这儿我们的项目已经创建完成了本系列背面的章节根本上都会以这个项目为基础展开辟展
控制器的单位测试

[单位测试涉及通过基础结构和依赖项单独测试应用的一部门。 单位测试控制器逻辑时，仅测试单个操作的内容，不测试其依赖项或框架自身的行为。
本章节重要以控制器的单位测试来带大家了解一下Stup和Moq的核心区别。
创建一个新的测试项目，然后添加Sample.Api的项目引用

Stub 实战

Stub 是系统中现有依赖项的可控制替代项。通过使用 Stub，可以在测试代码时不必要使用真实依赖项。通常情况下，存根最初被视为 Fake
下面对 StaffController 使用 Stub 进行单位测试,
我们在dotNetParadise.FakeTest测试项目上新建一个IStaffRepository的实现，名字可以叫StubStaffRepository
  1. public class StubStaffRepository : IStaffRepository
  2. {
  3.     public DbSet<Staff> dbSet => default!;
  5.     public async Task AddStaffAsync(Staff staff, CancellationToken cancellationToken)
  6.     {
  7.         // 模拟添加员工操作
  8.         await Task.CompletedTask;
  9.     }
  11.     public async Task DeleteStaffAsync(int id)
  12.     {
  13.         // 模拟删除员工操作
  14.         await Task.CompletedTask;
  15.     }
  17.     public async Task UpdateStaffAsync(Staff staff, CancellationToken cancellationToken)
  18.     {
  19.         // 模拟更新员工操作
  20.         await Task.CompletedTask;
  21.     }
  23.     public async Task<Staff?> GetStaffByIdAsync(int id, CancellationToken cancellationToken)
  24.     {
  25.         // 模拟根据 ID 获取员工操作
  26.         return await Task.FromResult(new Staff { Id = id, Name = "Mock Staff" });
  27.     }
  29.     public async Task<List<Staff>> GetAllStaffAsync(CancellationToken cancellationToken)
  30.     {
  31.         // 模拟获取所有员工操作
  32.         return await Task.FromResult(new List<Staff> { new Staff { Id = 1, Name = "Mock Staff 1" }, new Staff { Id = 2, Name = "Mock Staff 2" } });
  33.     }
  35.     public async Task BatchAddStaffAsync(List<Staff> staffList, CancellationToken cancellationToken)
  36.     {
  37.         // 模拟批量添加员工操作
  38.         await Task.CompletedTask;
  39.     }
  41.     public async Task DeleteStaffAsync(int id, CancellationToken cancellationToken = default)
  42.     {
  43.         await Task.CompletedTask;
  44.     }
  45. }
复制代码
我们新创建了一个仓储的实现来替换StaffRepository作为新的依赖
下一步在单位测试项目测试我们的Controller方法
  1. public class TestStubStaffController
  2. {
  4.     [Fact]
  5.     public async Task AddStaff_WhenCalled_ReturnNoContent()
  6.     {
  7.         //Arrange
  8.         var staffController = new StaffController(new StubStaffRepository());
  9.         var staff = new Staff()
  10.         {
  11.             Age = 10,
  12.             Name = "Test",
  13.             Email = "Test@163.com",
  14.             Created = DateTimeOffset.Now,
  15.         };
  16.         //Act
  17.         var result = await staffController.AddStaff(staff);
  19.         //Assert
  20.         Assert.IsType<Results<NoContent, ProblemHttpResult>>(result);
  21.     }
  23.     [Fact]
  24.     public async Task GetStaffById_WhenCalled_ReturnOK()
  25.     {
  26.         //Arrange
  27.         var staffController = new StaffController(new StubStaffRepository());
  28.         var id = 1;
  29.         //Act
  30.         var result = await staffController.GetStaffById(id);
  32.         //Assert
  33.         Assert.IsType<Results<Ok<Staff>, NotFound>>(result);
  34.         var okResult = (Ok<Staff>)result.Result;
  35.         Assert.Equal(id, okResult.Value?.Id);
  36.     }
  38.       //先暂时省略后面测试方法....
  40. }
复制代码

用 Stub 来替代真实的依赖项，以便更好地控制测试情况和测试结果
Mock

在测试过程中，尤其是TDD的开发过程中，测试用例有限开发在这个时候，我们总是要去模仿对象的创建，这些对象可能是某个接口的实现也可能是详细的某个对象，这时候就必须去写接口的实现，这时候模仿对象Mock的用处就体现出来了，在社区中也有很多模仿对象的库如Moq,FakeItEasy等。
Moq 是一个简单、直观且强大的.NET 模仿库，用于在单位测试中模仿对象和行为。通过 Moq，您可以轻松地设置依赖项的行为，并验证代码的调用。
我们用上面的实例来演示一下Moq的核心用法
第一步 Nuget 包安装Moq
  1. PM> NuGet\Install-Package Moq -Version 4.20.70
复制代码
您可以使用 Moq 中的 Setup 方法来设置模仿对象（Mock 对象）中可重写方法的行为，结合 Returns（用于返回一个值）或 Throws（用于抛出异常）等方法来定义其行为。如许可以模仿对特定方法的调用，使其在测试中返回预期的值或抛出特定的异常。
创建TestMockStaffController测试类，接下来我们用Moq实现一下上面的例子
  1. public class TestMockStaffController
  2. {
  3.     private readonly ITestOutputHelper _testOutputHelper;
  4.     public TestMockStaffController(ITestOutputHelper testOutputHelper)
  5.     {
  6.         _testOutputHelper = testOutputHelper;
  7.     }
  8.     [Fact]
  9.     public async Task AddStaff_WhenCalled_ReturnNoContent()
  10.     {
  11.         //Arrange
  12.         var mock = new Mock<IStaffRepository>();
  14.         mock.Setup(_ => _.AddStaffAsync(It.IsAny<Staff>(), default));
  15.         var staffController = new StaffController(mock.Object);
  16.         var staff = new Staff()
  17.         {
  18.             Age = 10,
  19.             Name = "Test",
  20.             Email = "Test@163.com",
  21.             Created = DateTimeOffset.Now,
  22.         };
  23.         //Act
  24.         var result = await staffController.AddStaff(staff);
  26.         //Assert
  27.         Assert.IsType<Results<NoContent, ProblemHttpResult>>(result);
  28.     }
  30.     [Fact]
  31.     public async Task GetStaffById_WhenCalled_ReturnOK()
  32.     {
  33.         //Arrange
  34.         var mock = new Mock<IStaffRepository>();
  35.         var id = 1;
  36.         mock.Setup(_ => _.GetStaffByIdAsync(It.IsAny<int>(), default)).ReturnsAsync(() => new Staff()
  37.         {
  38.             Id = id,
  39.             Name = "张三",
  40.             Age = 18,
  41.             Email = "zhangsan@163.com",
  42.             Created = DateTimeOffset.Now
  43.         });
  45.         var staffController = new StaffController(mock.Object);
  47.         //Act
  48.         var result = await staffController.GetStaffById(id);
  50.         //Assert
  51.         Assert.IsType<Results<Ok<Staff>, NotFound>>(result);
  52.         var okResult = (Ok<Staff>)result.Result;
  53.         Assert.Equal(id, okResult.Value?.Id);
  54.         _testOutputHelper.WriteLine(okResult.Value?.Name);
  56.     }
  58.     //先暂时省略后面测试方法....
  59. }
复制代码
看一下运行测试

Moq 核心功能讲解

通过我们上面这个简单的 Demo 简单的了解了一下 Moq 的使用，接下来我们对 Moq 和核心功能深入了解一下
通过安装的Nuget包可以看到, Moq依赖了Castle.Core这个包，Moq正是使用了 Castle 来实现动态署理模仿对象的功能。
根本概念

异步方法

从我们上面的单位测试中看到我们使用了一个异步方法,使用返回值ReturnsAsync表示的
  1.   mock.Setup(_ => _.GetStaffByIdAsync(It.IsAny<int>(), default))
  2.        .ReturnsAsync(() => new Staff()
  3.         {
  4.             Id = id,
  5.             Name = "张三",
  6.             Age = 18,
  7.             Email = "zhangsan@163.com",
  8.             Created = DateTimeOffset.Now
  9.         });
复制代码
Moq有三种方式去设置异步方法的返回值分别是：
参数匹配

在我们单位测试实例中用到了参数匹配,mock.Setup(_ => _.GetStaffByIdAsync(It.IsAny<int>(), default)).，对就是这个It.IsAny()，此处的用意是匹配任意输入的 int范例的入参，接下来我们一起看下参数匹配的一些常用示例。




属性值


假如值设置为mock.Object.Name = "foo1";,
单位测试就会抛出异常
OutPut:
  1.  dotNetParadise.FakeTest.TestControllers.TestMockStaffController.Test_Moq_Demo
  2.  源: TestMockStaffController.cs 行 70
  3.  持续时间: 8.7 秒
  5. 消息: 
  6. Moq.MockException : Mock<IFoo:2>:
  7. This mock failed verification due to the following:
  9. IFoo foo => foo.Name = "foo":
  10. This setup was not matched.
  12. 堆栈跟踪: 
  13. Mock.Verify(Func`2 predicate, HashSet`1 verifiedMocks) 行 309
  14. Mock.Verify() 行 251
  15. TestMockStaffController.Test_Moq_Demo() 行 111
  16. --- End of stack trace from previous location ---
复制代码
  1.        //VerifySet直接验证属性的设置操作
  2.        {
  3.            // Arrange
  4.            mock = new Mock<IFoo>();
  5.            //Act
  6.            mock.Object.Name = "foo";
  7.            //Asset
  8.            mock.VerifySet(person => person.Name = "foo");
  9.        }
复制代码
  1. {
  2.     // Arrange
  3.      mock = new Mock<IFoo>();
  4.       // start "tracking" sets/gets to this property
  5.      mock.SetupProperty(f => f.Name);
  6.       // alternatively, provide a default value for the stubbed property
  7.      mock.SetupProperty(f => f.Name, "foo");
  8.       //Now you can do:
  9.      IFoo foo = mock.Object;
  10.      // Initial value was stored
  11.      //Asset
  12.      Assert.Equal("foo", foo.Name);
  13. }
复制代码
在Moq 中，您可以使用 SetupAllProperties 方法来一次性存根（Stub）Mock 对象的全部属性。这意味着全部属性都会开始跟踪其值，并可以提供默认值。以下是一个示例演示怎样使用 SetupAllProperties 方法：
  1. // 存根（Stub）Mock 对象的所有属性
  2. mock.SetupAllProperties();
复制代码
通过使用 SetupProperty 方法，可以更灵活地设置 Mock 对象的属性行为和默认值，以满足单位测试中的需求
处置处罚事件（Events）

在 Moq 4.13 及以后的版本中，你可以通过配置事件的 add 和 remove 访问器来模仿事件的行为。这允许你指定当事件处置处罚器被添加或移除时应该发生的逻辑。这通常用于验证事件是否被精确添加或移除，或者模仿事件触发时的行为。

创建要被测试的类：
  1. public class HasEvent
  2. {
  3.     public virtual event Action Event;
  5.     public void RaiseEvent() => this.Event?.Invoke();
  6. }
复制代码
  1.         {
  2.             var handled = false;
  3.             var mock = new Mock<HasEvent>();
  4.             //设置订阅行为
  5.             mock.SetupAdd(m => m.Event += It.IsAny<Action>()).CallBase();
  6.             // 订阅事件并设置事件处理逻辑
  7.             Action eventHandler = () => handled = true;
  8.             mock.Object.Event += eventHandler;
  9.             mock.Object.RaiseEvent();
  10.             Assert.True(handled);
  12.             // 重置标志为 false
  13.             handled = false;
  14.             //  移除事件处理程序
  15.             mock.SetupRemove(h => h.Event -= It.IsAny<Action>()).CallBase();
  16.             // 移除事件处理程序
  17.             mock.Object.Event -= eventHandler;
  18.             // 再次触发事件
  19.             mock.Object.RaiseEvent();
  21.             // Assert -  验证事件是否被正确处理
  22.             Assert.False(handled); // 第一次应该为 true，第二次应该为 false
  24.         }
复制代码
这段代码是一个针对 HasEvent 类的测试示例，使用 Moq 来设置事件的订阅和移除行为，并验证事件处置处罚步伐的添加和移除是否按预期工作。让我简单解释一下这段代码的流程：
通过这个测试示例，可以验证事件处置处罚步伐的添加和移除操作是否正常工作

  1.         {
  2.             // Arrange
  3.             var handled = false;
  4.             var mock = new Mock<HasEvent>();
  5.             //设置订阅行为
  6.             mock.Object.Event += () => handled = true;
  7.             //act
  8.             mock.Raise(m => m.Event += null);
  9.             // Assert - 验证事件是否被正确处理
  10.             Assert.True(handled);
  11.         }
复制代码
这个示例使用Raise方法手动触发 Mock 对象上的事件 Event，并验证事件处置处罚步伐的实行情况。通过设置事件的订阅行为，触发事件，以及断言验证事件处置处罚步伐的实行结果，测试了事件处置处罚步伐的逻辑是否按预期实行。这个过程帮助我们确认事件处置处罚步伐在事件触发时可以或许精确实行.
Callbacks

Callback方法用于在设置 Mock 对象的成员时指定回调操作。当特定操作被调用时，可以在 Callback 方法中实行自定义的逻辑
  1.     //Arrange
  2.     var mock = new Mock<IFoo>();
  3.     var calls = 0;
  4.     var callArgs = new List<string>();
  6.     mock.Setup(foo => foo.DoSomething("ping"))
  7.         .Callback(() => calls++)
  8.        .Returns(true);
  10.     // Act
  11.     mock.Object.DoSomething("ping");
  13.     // Assert
  14.     Assert.Equal(1, calls); // 验证 DoSomething 方法被调用一次
复制代码
在调用 DoSomething 方法是，回调操作自动被触发参数++
  1. //CallBack 捕获参数
  2. {
  3.      //Arrange
  4.      mock = new Mock<IFoo>();
  5.      mock.Setup(foo => foo.DoSomething(It.IsAny<string>()))
  6.          .Callback<string>(s => callArgs.Add(s))
  7.          .Returns(true);
  8.      //Act
  9.      mock.Object.DoSomething("a");
  10.      //Asset
  11.      // 验证参数是否被添加到 callArgs 列表中
  12.      Assert.Contains("a", callArgs);
  13. }
复制代码
使用 Moq 的 Callback 方法可以捕捉方法调用时的参数，允许我们在测试中访问和处置处罚这些参数。通过在 Setup 方法中指定 Callback 操作，我们可以捕捉方法调用时传入的参数，并在回调中实行自定义逻辑，比方将参数添加到列表中。这种方法可以帮助我们验证方法在不同参数下的行为，以及检查方法是否被精确调用和传递参数。总的来说，Callback 方法为我们提供了一种灵活的方式来处置处罚方法调用时的参数，帮助我们编写更全面的单位测试。

  1.         {
  2.             //Arrange
  3.             mock = new Mock<IFoo>();
  4.             mock.SetupProperty(foo => foo.Name);
  5.             mock.Setup(foo => foo.DoSomething(It.IsAny<string>()))
  6.                 .Callback((string s) => mock.Object.Name = s)
  7.                 .Returns(true);
  8.             //Act
  9.             mock.Object.DoSomething("a");
  10.             // Assert
  11.             Assert.Equal("a", mock.Object.Name);
  12.         }
复制代码
SetupProperty 方法的作用包括：
Verification

在 Moq 中，Verification 是指验证 Mock 对象上的方法是否被精确调用，以及调用时是否传入了预期的参数。通过 Verification，我们可以确保 Mock 对象的方法按预期进行了调用，从而验证代码的行为是否符合预期。
  1.         {
  2.             //Arrange
  3.             var mock = new Mock<IFoo>();
  4.             //Act
  5.             mock.Object.Add(1);
  6.             // Assert
  7.             mock.Verify(foo => foo.Add(1));
  8.         }
复制代码

  1.    {
  2.        var mock = new Mock<IFoo>();
  3.        mock.Verify(foo => foo.DoSomething("ping"), Times.Never());
  4.    }
复制代码
  1. mock.Verify(foo => foo.DoSomething("ping"), Times.AtLeastOnce());
复制代码
Verify指定 Times.AtLeastOnce() 验证方法至少被调用了一次。

  1.     {
  2.         var mock = new Mock<IFoo>();
  3.          mock.VerifyGet(foo => foo.Name);
  4.     }
复制代码
VerifyAdd 和 VerifyRemove 方法来验证事件的订阅和移除
  1. // Verify event accessors (requires Moq 4.13 or later):
  2. mock.VerifyAdd(foo => foo.FooEvent += It.IsAny<EventHandler>());
  3. mock.VerifyRemove(foo => foo.FooEvent -= It.IsAny<EventHandler>());
复制代码
VerifyNoOtherCalls 方法的作用是在使用 Moq 进行方法调用验证时，确保除了已经通过 Verify 方法验证过的方法调用外，没有其他未验证的方法被实行
  1. mock.VerifyNoOtherCalls();
复制代码
Customizing Mock Behavior

  1.     [Fact]
  2.     public void TestStrictMockBehavior_WithUnsetExpectation()
  3.     {
  4.         // Arrange
  5.         var mock = new Mock<IFoo>(MockBehavior.Strict);
  6.         //mock.Setup(_ => _.Add(It.IsAny<int>())).Returns(true);
  7.         // Act & Assert
  8.         Assert.Throws<MockException>(() => mock.Object.Add(3));
  9.     }
复制代码
假如mock.Setup这一行注释了，即未设置盼望值，则会抛出异常
  1. public interface IUser
  2. {
  3.     string GetName();
  4. }
  6. public class UserBase : IUser
  7. {
  8.     public virtual string GetName()
  9.     {
  10.         return "BaseName";
  11.     }
  13.     string IUser.GetName() => "Name";
  14. }
复制代码
测试
  1.     [Fact]
  2.     public void TestPartialMockWithCallBase()
  3.     {
  4.         // Arrange
  5.        var mock = new Mock<UserBase> { CallBase = true };
  6.         mock.As<IUser>().Setup(foo => foo.GetName()).Returns("MockName");
  7.         // Act
  8.         string result = mock.Object.GetName();//
  10.         // Assert
  11.         Assert.Equal("BaseName", result);
  13.         //Act
  14.         var valueOfSetupMethod = ((IUser)mock.Object).GetName();
  15.         //Assert
  16.         Assert.Equal("MockName", valueOfSetupMethod);
  17.     }
复制代码
<ul>第一个Act：调用模仿对象的 GetName() 方法，此时基类的实现被调用，返回值为 "BaseName"。
第二个Act
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 IT评测·应用市场-qidao123.com技术社区 (https://dis.qidao123.com/) Powered by Discuz! X3.4