单元测试等

专题/后端/测试/01测试开始篇.md

@@ -0,0 +1,430 @@
+# .NET中的测试
+
+测试类型
+
+- 单元测试(`Unit tests`)：测试单个组件或方法，与数据库、文件、外界交互无关
+- 集成测试(Integration tests)：测试多个组件或方法，与数据库、文件、外界交互有关
+- 压力测试(Load tests)：测试系统对压力的承受程度，比如并发用户、并发请求等
+
+
+
+测试框架
+
+- `xUnit`：来自`NUnit v2`的作者，包括了最新的测试技术和思想。属于`.NET基金会`下的项目。
+- `NUnit`：从`JUnit`演变而来，最新的版本增加了很多新功能。属于`.NET基金会`下的项目。
+- `MSTest`：微软的测试框架，支持在`.NET CLI`和`Visual Studio`中的扩展
+
+
+
+`.NET CLI`
+
+`.NET CLI`集成了`IDE`下的大部分功能，通过使用`dotnet test`命令运行。可以被用到持续集成交付管道中，也可以被用在测试自动化任务中。
+
+
+
+`IDE`
+
+相比`.NET CLI`有更多的功能，比如`Live Unit Testing`是`IDE`独有的测试功能。
+
+
+
+# 单元测试的最佳实践
+
+为什么需要单元测试
+
+- 相比功能测试更少的时间：功能测试需要一个懂领域知识的人，测试时间较长。单元测试不需要对被测试系统有太多了解，在极短的时间内完成测试。
+- 能更好地应对变化：只要有代码的更改，无论是新功能，还是老功能，跑一遍单元测试就可以做到
+- 测试的文档化：单元测试本身说明了给定输入下的输出
+- 反向促使代码解耦：耦合性很强的代码很难测试
+
+
+
+好单元测试的特点
+
+- 快：毫秒级
+- 隔离的：不依赖于任何文件或数据库，可以单独跑通
+- 可重复的：如果在测试测时候没有改变条件，测试结果是一样的
+- 自检的：在没有人员介入的情况下判定测试成功或失败
+- 用时较少的：用时比写代码更少，如果发现写测试的时间较多，说明哪个地方有问题
+
+
+
+测试覆盖率`Code coverage`
+
+测试覆盖率不见得越大越好，只是表明有多少代码被测试了，需要在实际项目中把握测试覆盖率的度。
+
+
+
+## 理解`Fake`, `Mock`, `Stub`
+
+- `Fake`：不确定是`Mock`还是`Stub`的时候用`Fake`
+- `Mock`：直接影响到测试结果就用`Mock`
+- `Stub`： 只是某个依赖的替代，不直接影响到测试结果
+
+
+
+不好的
+
+```
+var mockOrder = new MockOrder();
+var purchase = new Purchase(mockOrder);
+purchase.ValidateOrders();
+Assert.True(purchase.CanBeShipped);//测试结果与MockOrder没有直接关系
+```
+
+好的
+
+```
+var stubOrder = new FakeOrder();//使用Fake可以转换成Mock或Stub
+var purchase = new Purchase(stubOrder);
+purchase.ValdiateOrders();
+Assert.True(purchase.CanBeShipped);//测试结果与stubOrder没有关系
+```
+
+好的
+
+```
+var mockOrder = new FakeOrder();//使用Fake可以转换成Mock或Stub
+var purchase = new Purchase(mockOrder);
+purchase.ValidateOrders();
+Assert.True(mockOrder.Valdiated);//测试结果与mockOrder有直接关系
+```
+
+> 命名。好的命名说明了测试意图。通常是：`被测方法名称_场景或条件_期待结果`
+
+不好的
+
+```
+[Fact]
+public void Test_Single(){}
+```
+
+好的
+
+```
+[Fact]
+public void Add_SingleNumber_ReturnsSameNumber(){}
+```
+
+## 遵循`AAA`原则
+
+不好的
+
+```
+[Fact]
+public void Add_EmptyString_ReturnsZero()
+{
+	//Arrange
+	var stringCalculator = new StringCalculator();
+	
+	//Assert
+	Assert.Equal(0, stringCalculator.Add(""));
+}
+```
+
+好的
+
+```
+[Fact]
+public void Add_EmptyString_ReturnsZero()
+{
+	//Arrange
+	var stringCalculator = new StringCalculator();
+	
+	//Act
+	var actual = stringCalculator.Add("");
+	
+	//Assert
+	Assert.Equal(0, actual);
+}
+```
+
+## 保持输入简单原则
+
+不好的
+
+```
+[Fact]
+public void Add_SingleNumber_ReturnsSameNumber()
+{
+    var stringCalculator = new StringCalculator();
+
+    var actual = stringCalculator.Add("42");
+
+    Assert.Equal(42, actual);
+}
+```
+
+好的
+
+```
+[Fact]
+public void Add_SingleNumber_ReturnsSameNumber()
+{
+    var stringCalculator = new StringCalculator();
+
+    var actual = stringCalculator.Add("0");
+
+    Assert.Equal(0, actual);
+}
+```
+
+## 避免使用系统保留字
+
+不好的
+
+```
+[Fact]
+public void Add_BigNumber_ThrowsException()
+{
+    var stringCalculator = new StringCalculator();
+
+    Action actual = () => stringCalculator.Add("1001");
+
+    Assert.Throws<OverflowException>(actual);
+}
+```
+
+好的
+
+```
+[Fact]
+void Add_MaximumSumResult_ThrowsOverflowException()
+{
+    var stringCalculator = new StringCalculator();
+    const string MAXIMUM_RESULT = "1001";//赋值给常量
+
+    Action actual = () => stringCalculator.Add(MAXIMUM_RESULT);
+
+    Assert.Throws<OverflowException>(actual);
+}
+```
+
+## 避免逻辑
+
+不好的
+
+```
+[Fact]
+public void Add_MultipleNumbers_ReturnsCorrectResults()
+{
+    var stringCalculator = new StringCalculator();
+    var expected = 0;
+    var testCases = new[]
+    {
+        "0,0,0",
+        "0,1,2",
+        "1,2,3"
+    };
+
+    foreach (var test in testCases)
+    {
+        Assert.Equal(expected, stringCalculator.Add(test));
+        expected += 3;
+    }
+}
+```
+
+好的
+
+```
+[Theory]
+[InlineData("0,0,0", 0)]
+[InlineData("0,1,2", 3)]
+[InlineData("1,2,3", 6)]
+public void Add_MultipleNumbers_ReturnsSumOfNumbers(string input, int expected)
+{
+    var stringCalculator = new StringCalculator();
+
+    var actual = stringCalculator.Add(input);
+
+    Assert.Equal(expected, actual);
+}
+```
+
+## 帮助方法替代`setup`和`teadown`
+
+不好的
+
+```
+private readonly StringCalculator stringCalculator;
+public StringCalculatorTests()
+{
+    stringCalculator = new StringCalculator();
+}
+```
+
+```
+[Fact]
+public void Add_TwoNumbers_ReturnsSumOfNumbers()
+{
+    var result = stringCalculator.Add("0,1");
+
+    Assert.Equal(1, result);
+}
+```
+
+好的
+
+```
+[Fact]
+public void Add_TwoNumbers_ReturnsSumOfNumbers()
+{
+    var stringCalculator = CreateDefaultStringCalculator();
+
+    var actual = stringCalculator.Add("0,1");
+
+    Assert.Equal(1, actual);
+}
+
+private StringCalculator CreateDefaultStringCalculator()
+{
+    return new StringCalculator();
+}
+```
+
+## 避免一个测试方法中出现多个推断
+
+不好的
+
+```
+[Fact]
+public void Add_EdgeCases_ThrowsArgumentExceptions()
+{
+    Assert.Throws<ArgumentException>(() => stringCalculator.Add(null));
+    Assert.Throws<ArgumentException>(() => stringCalculator.Add("a"));
+}
+```
+
+好的
+
+```
+[Theory]
+[InlineData(null)]
+[InlineData("a")]
+public void Add_InputNullOrAlphabetic_ThrowsArgumentException(string input)
+{
+    var stringCalculator = new StringCalculator();
+
+    Action actual = () => stringCalculator.Add(input);
+
+    Assert.Throws<ArgumentException>(actual);
+}
+```
+
+## 测试公共方法而不是私有方法
+
+```
+public string ParseLogLine(string input)
+{
+    var sanitizedInput = TrimInput(input);
+    return sanitizedInput;
+}
+
+private string TrimInput(string input)
+{
+    return input.Trim();
+}
+
+[Fact]
+public void ParseLogLine_StartsAndEndsWithSpace_ReturnsTrimmedResult()
+{
+    var parser = new Parser();
+
+    var result = parser.ParseLogLine(" a ");
+
+    Assert.Equals("a", result);
+}
+```
+
+## 使用接口获取静态值
+
+有一个和日期相关的方法
+
+```
+public int GetDiscountedPrice(int price)
+{
+    if (DateTime.Now.DayOfWeek == DayOfWeek.Tuesday)
+    {
+        return price / 2;
+    }
+    else
+    {
+        return price;
+    }
+}
+```
+
+不好的
+
+```
+public void GetDiscountedPrice_NotTuesday_ReturnsFullPrice()
+{
+    var priceCalculator = new PriceCalculator();
+
+    var actual = priceCalculator.GetDiscountedPrice(2);
+
+    Assert.Equals(2, actual)
+}
+
+public void GetDiscountedPrice_OnTuesday_ReturnsHalfPrice()
+{
+    var priceCalculator = new PriceCalculator();
+
+    var actual = priceCalculator.GetDiscountedPrice(2);
+
+    Assert.Equals(1, actual);
+}
+```
+
+不管哪一天，总一个通不过。
+
+好的。提炼出一个获取日期的接口。
+
+```
+public interface IDateTimeProvider
+{
+    DayOfWeek DayOfWeek();
+}
+```
+
+```
+public int GetDiscountedPrice(int price, IDateTimeProvider dateTimeProvider)
+{
+    if (dateTimeProvider.DayOfWeek() == DayOfWeek.Tuesday)
+    {
+        return price / 2;
+    }
+    else
+    {
+        return price;
+    }
+}
+```
+
+```
+public void GetDiscountedPrice_NotTuesday_ReturnsFullPrice()
+{
+    var priceCalculator = new PriceCalculator();
+    var dateTimeProviderStub = new Mock<IDateTimeProvider>();//模拟接口
+    dateTimeProviderStub.Setup(dtp => dtp.DayOfWeek()).Returns(DayOfWeek.Monday);//模拟接口实现
+
+    var actual = priceCalculator.GetDiscountedPrice(2, dateTimeProviderStub);
+
+    Assert.Equals(2, actual);
+}
+
+public void GetDiscountedPrice_OnTuesday_ReturnsHalfPrice()
+{
+    var priceCalculator = new PriceCalculator();
+    var dateTimeProviderStub = new Mock<IDateTimeProvider>();
+    dateTimeProviderStub.Setup(dtp => dtp.DayOfWeek()).Returns(DayOfWeek.Tuesday);
+
+    var actual = priceCalculator.GetDiscountedPrice(2, dateTimeProviderStub);
+
+    Assert.Equals(1, actual);
+}
+```
+
+
+

专题/后端/测试/02使用xUnit进行TDD测试驱动开发.md

@@ -0,0 +1,83 @@
+使用`TDD`方式。
+
+```
+    public class MyPrimeService
+    {
+        public bool IsPrime(int num)
+        {
+            throw new NotImplementedException("not implemented");
+        }
+    }
+```
+
+单元测试
+
+```
+        [Fact]
+        public void IsPrime_InputIs1_ReturnFalse()
+        {
+            //Arrange
+            var primeService = new MyPrimeService();
+
+            //Act
+            bool result = primeService.IsPrime(1);
+
+            //Assert
+            Assert.False(result, "1 should not be prime");
+        }
+```
+
+修改代码让单元测试通过。
+
+```
+        public bool IsPrime(int num)
+        {
+            if(num==1)
+            {
+                return false;
+            }
+            throw new NotImplementedException("not implemented");
+        }
+```
+
+目前单元测试输入条件有限，输入更多条件。
+
+```
+        [Theory]
+        [InlineData(-1)]
+        [InlineData(0)]
+        [InlineData(1)]
+        public void IsPrime_ValueLessThanTwo_ReturnFalse(int value)
+        {
+            //Arrange
+            var primeService = new PrimeService.MyPrimeService();
+
+            //Act
+            var restul = primeService.IsPrime(value);
+
+            //Assert
+            Assert.False(restul, $"{value} should not be prime");
+        }
+```
+
+有两个不通过
+
+```
+失败!  - Failed:     2, Passed:     1, Skipped:     0, Total:     3, Duration: 4 ms
+```
+
+其实所有都不应该通过。修改代码：
+
+```
+        public bool IsPrime(int num)
+        {
+            if(num < 2)
+            {
+                return false;
+            }
+            throw new NotImplementedException("not implemented");
+        }
+```
+
+
+

专题/后端/测试/03CleanArchitecture下的CleanTesting.md

@@ -0,0 +1,502 @@
+# 用到的组件
+
+
+
+本篇涉及的测试形式：
+
+- `Subcutaneous`测试：最接近`UI`层的测试，聚焦在输入和输出，非常适合逻辑和UI分离的场景，这样就避免进行UI测试，容易写也容易维护
+- `Integration`集成测试：
+- `Unit`单元测试：
+
+
+
+## `FluentAssertions`组件
+
+- 支持非常自然地规定自动测试的结果
+- 更好的可读性
+- 更好的测试失败说明
+- 避免调试
+- 更有生产力，更简单
+
+
+
+## `Moq`组件
+
+- 为`.NET`而来
+- 流行并且友好
+- 支持`Mock`类和接口
+- 强类型，这样可以避免和系统关键字冲突
+- 简单易用
+
+
+
+## `EF Core InMemory`组件
+
+- 内置数据库引擎
+- 内存数据库
+- 适用于测试场景
+- 轻量级无依赖
+
+
+
+## `Respawn`组件
+
+- 为集成测试准备的数据库智能清洗
+- 避免删除数据或回滚事务
+- 把数据库恢复到一个干净的某个节点
+- 忽略表和`Schema`，比如忽略`_EFMigrationsHistory`
+- 支持`SQL Server`, `Postgres`,`MySQL`
+
+
+
+# 界面
+
+## 列表
+
+![t1](F:\SourceCodes\DDWiki\专题\后端\测试\t1.png)
+
+## 删除和更新
+
+![t2](F:\SourceCodes\DDWiki\专题\后端\测试\t2.png)
+
+# 解决方案组件依赖
+
+- `.NET Core Template Package`
+- `ASP.NET Core 3.1`
+- `Entity Framework Core 3.1`
+- `ASP.NET Core Identity 3.1`
+- `Angular 9`
+
+# 文件结构
+
+- `Application`层
+- `Domain`层
+- `Infrastructure`层
+- `WebUI`层
+-  集成测试层
+
+
+
+# `WebUI`层
+
+`TodoListsController`
+
+```
+[Authorize]
+public class TodoListsController : ApiController
+{
+	[HttpGet]
+	public async Task<IActionResult<TodoVm>> Get()
+	{
+		return await Mediator.Send(new GetTodosQuery());
+	}
+	
+	[HttpGet("{id}")]
+	public async Task<FileResult> Get(int id)
+	{
+		var vm = await Mediator.Send(new ExportTodosQuery {ListId=id});
+		return File(vm.Content, vm.ContentType, vm.FileName);
+	}
+	
+	[HttpPost]
+	public async Task<IActionResult<int>> Create(CreateTodoListCommand command)
+	{
+		return await Mediator.Send(command);
+	}
+}
+
+
+```
+
+# `Application`层
+
+`GetTodosQuery.cs`
+
+```
+public class GetTodosQuery : IRequest<TodosVm>
+{
+
+}
+
+public class GetTodosQueryHandler : IRequestHandler<GetTodosQuery, TodosVm>
+{
+	private readonly IApplicationDbContext _context;
+	private readonly IMapper _mapper;
+	
+	public GetTodosQueryHandler(IApplicationDbContext context, IMapper mapper)
+	{
+		_context = context;
+		_mapper = mapper;
+	}
+	
+	public async Task<TodosVm> Handler(GetTodosQuery request, CancellationToken cancellationToken)
+	{
+		return new TodosVm{
+			PriorityLevels = Enum.GetValues(typeof(PriorityLevel))
+				.Cast<PriorityLevel>()
+				.Select(p => new PriorityLevelDto{Value=(int)p, Name=p.ToString()})
+				.ToList,
+			Lists = await _context.TodosLists
+				.ProjectTo<TodoListDto>(_mapper.ConfigurationProvider)
+				.OrdreBy(t => t.Title)
+				.ToListAsync(cacnellationToken);
+		};
+	}
+}
+```
+
+在`MediatR`的请求管道中做验证。
+
+```
+public class RequestValidationBehavior<TRequest, TResponse> : IPiplelineBehavior<TRequest, TResponse> where TRequest : IRequest<TResponse>
+{
+	private readonly IENumerable<IValidator<TRequest>> _validators;
+	
+	public RequestValidationBehavior(IEnumerable<IValidator<TRequest>> validators)
+	{
+		_validators = validators;
+	}
+	
+	public Task<TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate<TResponse> next)
+	{
+		if(_validators.Any())
+		{
+			var context = new ValidationContext(request);
+			
+			var failures = _validators
+				.Select(v => v.Validate(context))
+				.SelectMany(result => result.Errors)
+				.Whre(f => f != null)
+				.ToList();
+				
+			if(failures.Count != 0)
+			{
+				throw new ValidationException(failures);
+			}
+		}
+		return next();
+	}
+}
+```
+
+在`MediatR`的请求管道中处理异常。
+
+```
+public class UnhandledExceptionBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
+{
+	private readonly ILogger<TRequest> _logger;
+	
+	public UnhandledExceptionBehaviour(ILogger<TRequest> logger)
+	{
+		_logger = logger;
+	}
+	
+	public async Task<TResponse> Handle(TRequest request, CancellationTOken canellationToken, RequestHandlerDelegate<TResponse> next)
+	{
+		try	
+		{
+			return await next();
+		}
+		catch(Exception ex)
+		{
+			var requestName = typeof(TRequest).Name;
+			_logger.LogError();
+			throw;
+		}
+	}
+}
+```
+
+# 集成测试层
+
+引用`WebUI`层
+
+```
+dotnet add package FluentAssertions
+dotnet add package Moq
+dotnet add package Respawn
+```
+
+`GetTodosTests.cs`
+
+```
+
+using static Testing;
+public class GetTodosTests : TestBase //每次运行测试让数据库回到干净的状态
+{
+	[Test]
+	public async Task ShouldReturnAllListsAndAssociatedItems()
+	{
+		//Arrange
+		await AddAsync(new TodoList{
+			Title = "",
+			Items = {
+				new TodoItem {Title="",Done=true},
+				new TodoItem {Title="",Done=true},
+				new TodoItem {Title="",Done=true},
+				new TodoItem {Title=""},
+				new TodoItem {Title=""},
+				new TodoItem {Title=""}
+			}
+		});
+		var query = new GetTodosQuery();
+		
+		//Act
+		TodosVm result = await SendAsync(query);
+		
+		//Assert
+		result.Should().NotBeNull();
+		result.List.Should().HaveCount(1);
+		result.Lists.First().Items.Should().HaveCount();
+	}
+}
+```
+
+`CreateTodoListTests.cs`
+
+```
+
+using static Testing;
+public class CreateTodListTests : TestBase//每次运行测试让数据库回到干净的状态
+{
+	[Test]
+	public void ShouldRequredMinimumFileds()
+	{
+		var command = new CrateTodoListCommand();
+		FluenActions.Invoking(()=> SendAsync(command))
+			.Should().Throw<ValidaitonException>();
+	}
+	
+	[Test]
+	public async Task ShouldRequiredUniqueTitle()
+	{
+		await SendAsync(new CreateTodoListCommand{
+			Title = ""
+		});
+		
+		var command = new CreateTodoListCommand
+		{
+			Title = ""
+		};
+		
+		
+		FluenActions.Invoking(() => SendAsync(comamnd))
+			.Should().Throw<ValidationException>();
+	}
+	
+	[Test]
+	public async Task ShouldCreateTodoList()
+	{
+	
+		var useId = await RunAsDefaultUserAsync();
+		var command = new CreateTodoListCommand
+		{
+			Title = ""
+		};
+		
+		var listeId = await SendAsync(command);
+		
+		var list = await FindAsync<TodoList>(listId);
+		
+		list.Should().NotBuNull();
+		list.Title.Should().Be(command.Title);
+		list.Created.Should().BeCloseTo(DateTime.Now, 10000);
+		list.CreatedBy.Should().Be(userId);
+	}
+}
+```
+
+`UpdateDotListTests.cs`
+
+```
+using static Testing;
+public class UpdateTodoListTests : TestBase
+{
+	[Test]
+	public void ShouldRequireValidTodoListId()
+	{
+		var command = new UpdateTodoListCommand
+		{
+			Id = 99,
+			Title = "New Title"
+		};
+		
+		FluenActions.Invoking(() => SendAsync(command)).Should().Throw<NotFoundException>();
+	}
+	
+	[Test]
+	public async Task ShouldRequireUniqueTitle()
+	{
+		var listId = await SendAsync(new CreateTodoListCommand{Title=""});
+		
+		await SendAsync(new CreateTodoListCommand={Title=""});
+		var command = new UpdateTodoListCommand
+		{
+			Id = listId,
+			Title = ""
+		};
+		
+		FluentActions.Invoking(()=>
+			SendAsync(command)).Should().Throw<ValidationException>().Where(ex => ex.Errors.ContainsKey("Title"))
+			.And.Erros["Title"].Should().Contain("The specified title is already exists.");
+	}
+	
+	[Test]
+	public async Task ShouldUpdateTodoList()
+	{
+		var userId = await RunAsDefaultUserAsync();
+		var listId = await SendAsync(new CreateTodoListCommand{
+			Title = ""
+		});
+		
+		var command = new UpdateTodoListCommand
+		{
+			Id = listId,
+			Title= ""
+		};
+		await SendAsync(command);
+		var list =await FindAsync<TodoList>(listId);
+		
+		list.Title.Should().Be(command.Title);
+		list.LastModifiedBy.Should().NotBeNull();
+		list.LastModifiedBy.Should().Be(userId);
+		list.LastModified.Should().NotBeNull();
+		list.LstModified.Should().BeCloaseTo(DateTime.Now, 1000);
+	}
+}
+```
+
+`Testing.cs`
+
+```
+[SetUpFixture]
+public class Testing
+{
+
+	private static IConfiguration _configuration;//配置
+	private static IServiceScopeFactory _scopeFactory;//域
+	private static Checkpoint _checkpoint;//Respawn
+	private static string _currentUserId;
+
+	[OneTimeSetUp]
+	public void RunBeforeAnyTests()
+	{
+		var buidler = new ConfigurationBuilder()
+			.SetBasePath(Directory.GetCurrentDirectory)
+			.AddJsonFile("appsettings.json", true, true)
+			.AddEnvironmentVariables();
+			
+		_configuration = builder.Build();
+		
+		var services = new ServiceCollection();//看作是容器
+		var startup = new Startup(_configuration);//Startup.cs需要IConfiguration
+		
+		//ServiceCollection需要宿主
+		services.AddSignleton(Mock.Of<IWebHostEnvironment>(w =>
+			w.ApplcationName == "CleanTesting.WebUI" &&
+			w.EnvirnmentName == "Development"));
+		
+		startup.ConfigureServices(services);
+		
+		//Replace service registration for ICurrentUserService
+		//Remove existing registration
+		var currentUserServiceDescriptor = services.FirstOrDefault(d => d.ServiceType == typeof(ICurrentUserService));
+		service.Remove(currentUserServiceDescriptor);
+		
+		//Register testing version
+		services.AddTransient(provider => 
+			Mock.Of<ICurrentUserService>(s => s.UserId == _currentUserId));
+		
+		_scopeFactory = services.BuilderServiceProvider().GetService<IServiceScopeFactory>();
+		
+		_checkpoint = new Checkpoint{
+			TablesToIgnore  = new [] {"__EFMigrationsHistory"}
+		};
+	}
+	
+	public static async Task<string> RunAsDefaultUserAsync()
+	{
+		return await RundAsUserAsync("","");
+		_currentUserId = null;
+	}
+	
+	public static async Task<string> RunAsUserAsync(string userName, string password)
+	{
+		using var scope = _scopeFactory.CreateScope();
+		var userManager = scope.ServiceProvider.GetService<UserManager<ApplicaitonUser>>();
+		
+		var user = new ApplicationUser{UserName=userName, Email = userName};
+		var result = await  userManager.CreateAsync(user, password);
+		_currentUserId = user.Id;
+		return _currentUserId;
+	}
+	
+	public static async Task ResetState()
+	{
+		await _checkpoint.Reset(_configuration.GetConnectionString("DefaultConnection"));
+	}
+	
+	public static async Task AddAsync<TEntity>(TEntity entity) where TEntity : class
+	{
+		using var scope = _scopeFactory.CreateScope();
+		var context = scope.ServiceProvider.GetService<ApplicationDbContext>();
+		context.Add(entity);
+		await context.SaveChangesAsync();
+	}
+	
+	public static async Task<TResponse> SendAsync<TResponse>(IRequest<TResponse> request)
+	{
+		using var scope = _scopeFacotry.CreateScope();
+		var mediator = scope.ServiceProvider.GetService<IMediator>();
+		return await mediator.Send(request);
+	}
+	
+	public static async Task<TEntity> FindAsync<TEntity>(int id)
+	{
+		using var scope = _scopeFactory.CreateScope();
+		var context = scope.ServiceProvider.GetService<ApplicationContext>();
+		return await context.FindAsync<TEntity>(id);
+	}
+}
+```
+
+`appSetting.json`
+
+```
+{
+	"UseInMemoryDatabase":false,
+	"ConnectionStrings":{
+		"DefaultConnection" : "Server=(localdb)\\mssqllocaldb;Database=CleanTestingDb;Truested_Connection=True;MultipleActiveRestultSet"
+	},
+	"IdentityServer":{
+		"Clients":{
+			"CleanTesting.WebUI": {
+				"Profile": "IdentityServerSPA"
+			}
+		},
+		"Key":{
+			"Type" : "Development"
+		}
+	}
+}
+```
+
+`TestBase.cs`
+
+```
+using static Testing;
+public calss TestBase
+{
+	[SetUp]
+	public async Task SetUp()
+	{
+		await ResetState();
+	}
+}
+```
+
+# 资源
+
+- `Clean Testing Sample Code`: `https://github.com/jasontaylordev/cleantesting`
+- `Rules to Better Unit Tests`: `https://rules.ssw.com.au/rules-to-better-unit-tests`(翻墙)
+- `Fixie Demo`: `https://github.com/fixie/fixie.demo`