specification pattern

专题/后端/2020.2.13领域驱动实战.md → 专题/后端/DDD/2020.2.13领域驱动实战.md

 ---
+
 typora-root-url: ./
 ---
 

专题/后端/DDD/2、替代throw的组件.md

+往往在架构中`throw`随处可见。
+
+```
+throw new ArgumentException($"Input {parameterName} was not in required format", parameterName);
+```
+
+`Ardalis.GuardClauses`用来解决这个问题。
+
+```
+<ItemGroup>
+	<PackageReference Include="Ardalis.GuardClauses" Version="3.0.1" />
+</ItemGroup>
+```
+
+用法
+
+```
+    public class Order
+    {
+        private string _name;
+        private int _quantity;
+        private long _max;
+        private decimal _unitPrice;
+        private DateTime _dateCreated;
+
+        public Order(string name, int quantity, long max, decimal unitPrice, DateTime dateCreated)
+        {
+            _name = Guard.Against.NullOrWhiteSpace(name, nameof(name));
+            _quantity = Guard.Against.NegativeOrZero(quantity, nameof(quantity));
+            _max = Guard.Against.Zero(max, nameof(max));
+            _unitPrice = Guard.Against.Negative(unitPrice, nameof(unitPrice));
+            _dateCreated = Guard.Against.OutOfSQLDateRange(dateCreated, nameof(dateCreated));
+        }
+    }
+```
+
+通过`IGuardClause`实现扩展
+
+```
+namespace Ardalis.GuardClauses
+{
+    public static class Extensions
+    {
+        public static string Foo(this IGuardClause guardClause, string input, string parameterName)
+        {
+            if(input?.ToLower() == "foo")
+            {
+                throw new ArgumentException("Should not have been foo", parameterName);
+            }
+            return input;
+        }
+    }
+}
+```
+
+于是
+
+```
+_name = Guard.Against.Foo(name, nameof(name));
+```
+

专题/后端/DDD/3、Specification Patter规格模式.md

+# 从一段代码说起
+
+通常在`Application`层的`IRequestHandler`中涉及到查询、排序、分页会有一大段代码。
+
+```
+public class SomeRequest : IRequest<DDResponseWrapper<SomeRequestDto>>
+{
+	//是否加载一对多关系
+	public bool LoadChildren {get;set;}
+	public bool IsPagingEnabled{get;set;}
+	public int Page{get;set;}
+	public int PageSize{get;set;}
+	...
+}
+
+public class SomeRequestDto
+{
+
+}
+
+public class SomeRequestHandler : IRequestHandler<SomeRequest, DDResponseWrapper<SomeRequestDto>>
+{
+	private readonly IBreakerRepo _breakerRepo;
+	
+	public SomeRequestHandler(IBreakerRepo breakerRepo)
+	{
+		_breakerRepo = breakerRepo;
+	}
+	
+	public asyn Task<DDResponseWrapper<SomeRequestDto>> Handle(SomeRequest request, CancellationTolen canellationTolen)
+	{
+		var breakers = _breakerRepo.GetAll();
+		
+		breakers = breakers.OrderBy(t=>t.Name);
+		
+		if(request.LoadChildren)
+		{
+			breakers = breakers.Include(t => t.BreakerData);
+		}
+		
+		if(request.IsPagingEnablled)
+		{
+			breakers = breakers.Skip(request.Page).Take(request.PageSize);
+		}
+		
+		if(!string.IsNullOrEmpty(request.Name))
+		{
+			breakers = breakers.Where(t=>t.Name.Contains(request.Name));
+		}
+		
+		......
+	}
+}
+```
+
+> 是否可以把这部分逻辑放到基础设施层、或者领域层呢？然后通过调用`var breakers =await  _breakerRepo.ListAsync(request)`替换以上逻辑？在`DDD`中，有一种`Specification Patter`模式特别适合这种场景，可以把相关逻辑封装在领域层，这样根据模块化，也更方便单元测试。
+
+```
+//在领域层定义Specification<T>
+public class CustomerSpec : Specification<Customer>
+{
+	public CustomerSpec(CustomerFilter filter)
+	{
+		...
+	}
+}
+
+//应用
+var spec = new CustomerSpec();
+var breakers = await _breakerRepo.ListAsync(spec);
+```
+
+`Ardalis.Specification`遵循了`Specification Pattern`，很好地解决了上述问题。
+
+```
+<PackageReference Include="Ardalis.Specification" Version="4.2.0" />
+<PackageReference Include="Ardalis.Specification.EntityFrameworkCore" Version="4.2.0" />
+```
+
+# 领域层
+
+一对多关系
+
+```
+    public class Customer : IAggregateRoot
+    {
+        public int Id { get; private set; }
+        public string Name { get; private set; }
+        public string Email { get; private set; }
+        public string Address { get; private set; }
+
+        public IEnumerable<Store> Stores => _stores.AsEnumerable();
+        private readonly List<Store> _stores = new List<Store>();
+
+        public Customer(string name, string email, string address)
+        {
+            Guard.Against.NullOrEmpty(name, nameof(name));
+            Guard.Against.NullOrEmpty(email, nameof(email));
+
+            this.Name = name;
+            this.Email = email;
+            this.Address = address;
+        }
+        ......
+    }
+    
+    public class Store
+    {
+        public int Id { get; private set; }
+        public string Name { get; private set; }
+        public string Address { get; private set; }
+
+        public int CustomerId { get; private set; }
+
+        public Store(string name, string address)
+        {
+            Guard.Against.NullOrEmpty(name, nameof(name));
+
+            this.Name = name;
+            this.Address = address;
+        }
+    }
+```
+
+查询条件
+
+```
+    public class BaseFilter
+    {
+        public bool LoadChildren { get; set; }
+        public bool IsPagingEnabled { get; set; }
+
+        public int Page { get; set; }
+        public int PageSize { get; set; }
+    }
+    
+    public class CustomerFilter : BaseFilter
+    {
+        public string Name { get; set; }
+        public string Email { get; set; }
+        public string Address { get; set; }
+    }
+```
+
+定义`Specification`相关
+
+```
+namespace Sample.Core.Specifications
+{
+    public class CustomerSpec : Specification<Customer>
+    {
+        public CustomerSpec(CustomerFilter filter)
+        {
+            Query.OrderBy(t => t.Name)
+                .ThenByDescending(t => t.Address);
+
+            if (filter.LoadChildren)
+                Query.Include(x => x.Stores);
+
+            if (filter.IsPagingEnabled)
+                Query.Skip(PaginationHelper.CalculateSkip(filter))
+                    .Take(PaginationHelper.CalculateTake(filter));
+
+            if (!string.IsNullOrEmpty(filter.Name))
+                Query.Where(t => t.Name == filter.Name);
+
+            if (!string.IsNullOrEmpty(filter.Email))
+                Query.Where(x => x.Email == filter.Email);
+
+            if (!string.IsNullOrEmpty(filter.Address))
+                Query.Search(x => x.Address, "%" + filter.Address + "%");
+        }
+    }
+}
+```
+
+实现`Ardalis.Specification`的一个接口
+
+```
+using Ardalis.Specification;
+
+namespace Sample.Core.Interfaces
+{
+    public interface IRepository<T> : IRepositoryBase<T> where T : class, IAggregateRoot
+    {
+    }
+}
+
+```
+
+# 基础设施层
+
+`IRepository`的实现
+
+```
+using Ardalis.Specification.EntityFrameworkCore;
+
+namespace Sample.Infra.Data
+{
+    public class MyRepository<T> : RepositoryBase<T>, IRepository<T> where T : class, IAggregateRoot
+    {
+        private readonly SampleDbContext dbContext;
+
+        public MyRepository(SampleDbContext dbContext) : base(dbContext)
+        {
+            this.dbContext = dbContext;
+        }
+
+        // Not required to implement anything. Add additional functionalities if required.
+    }
+}
+```
+
+注册
+
+```
+services.AddScoped(typeof(MyRepository<>));
+```
+
+# `Application`层或`UI`层调用
+
+```
+private readonly IRepository<Customer> customerRepository;
+var spec = new CustomerSpec();
+var customers = await customerRepository.ListAsync(spec);
+```
+
+
+
+源码位置：`F:\demos\CleanArchitecture\UseSpecification`

专题/后端/测试/04单元测试基本面.md

+# 为什么测试这么重要
+
+`人非圣贤孰能无过`，归根结底，代码是人写的，`Bug`终究是无法避免的。测试的目的是为了尽早发现问题，尽量减少`Bug`数量。
+
+# 测试类型
+
+## `Smoke test`
+
+- 程序员自己测试
+
+## `Unit Tests`
+
+- 通常由程序员做
+- 快，几毫秒
+- 独立
+- 一次测试一种行为
+- 不依赖于外界，比如使用`Moq`和`nSubstitute`
+
+## `Integration Tests`
+
+- 通常由程序员做
+- 相对较慢
+- 依赖于外部实现，比如依赖数据库、外部服务
+
+## `Functional Tests`
+
+- 从用户的角度测试功能，可能是内测人员
+- 可以手动测试，也有自动测试框架
+
+## `Subcutaneous Tests`
+
+- 最接近`UI`下的测试
+- 通常由程序员做
+- 适合逻辑在后端业务层，比如前后端分离的后端业务层
+
+## `Load Tests`
+
+- 通常由程序员做
+- 模拟程序的负载
+- 通常查看各项性能指标
+
+`Stress Tests`
+
+- 通常由程序员做
+- 通常查看`CPU`,`Network`,`Memory`指标
+
+![t3](F:\SourceCodes\DDWiki\专题\后端\测试\t3.png)
+
+# 单元测试的要和不要
+
+要
+
+- 要间接测试私有方法
+- 要符合条件/不符合条件的输入
+- 容易出问题的代码要单元测试，比如包含正则表达式
+- 很难被捕捉的异常要单元测试，比如路由、算法
+
+不要
+
+- 不要100%的覆盖率，没太必要
+- 不要给依赖组件的运行时错误进行单元测试
+- 不要在数据库架构、外部服务方面进行单元测试
+- 性能测试不通过单元测试
+- 代码生成器生成的代码不需要单元测试
+- 如果测试代码远大于被测试代码不需要单元测试
+
+# 一定要让测试不通过
+
+不好的
+
+```
+[Test]
+public void ShouldAddTwoNumbers()
+{
+   var calculator = new Calculator();
+   var result = calculator.Sum(10, 11);
+   Assert.Equal(21, result);
+}
+
+// The method to test in class Calculator ...
+public int Sum(int x, int y)
+{
+   throw new NotImplementedException();
+}
+```
+
+
+
+好的
+
+```
+[Test]
+public void ShouldAddTwoNumbers()
+{
+   var calculator = new Calculator();
+   var result = calculator.Sum(10, 11);
+   Assert.Equal(21, result);
+}
+
+// The method to test in class Calculator ...
+public int Sum(int x, int y)
+{
+   return 0;//返回一个值让不通过
+}
+```
+
+# 通过单元测试消除`Bug`
+
+如果通过单元测试发现一个`Bug`, 即单元测试显示红灯。重构代买，单元测试通过，显示绿色。于是，单元测试起到了帮助代码重构的作用。
+
+
+
+# 流行的测试框架
+
+- `NUnit`: 是`.NET`开源的、被认可的测试框架，有`UI`
+- `XUnit`: 来之`NUnit`作者，最新的，鼓励`TDD`的开发方式，甚至`.NET Core`团队也在使用
+- `MSTest`: 微软的测试框架，无法在`build server`跑`CI/CD`
+
+# 持续集成服务器
+
+监控源代码，一旦有变化，检查、构建、自动测试、发送报告等。
+
+# 测试项目的文件结构
+
+![t4](F:\SourceCodes\DDWiki\专题\后端\测试\t4.png)
+
+# 命名
+
+- `MethodName_StateUnderTest_ExpectedBehavior`
+
+```
+isAdult_AgeLessThan18_False
+withdrawMoney_InvalidAccount_ExceptionThrown
+admitStudent_MissingMandatoryFields_FailToAdmit
+```
+
+- `MethodName_ExpectedBehavior_StateUnderTest`
+- `test[Feature being tested]`
+
+```
+testIsNotAnAdultIfAgeLessThan18
+testFailToWithdrawMoneyIfAccountIsInvalid
+```
+
+- `Feature to be tested`
+
+```
+IsNotAnAdultIfAgeLessThan18
+FailToWithdrawMoneyIfAccountIsInvalid
+```
+
+- `Should_ExpectedBehaviour_When_StateUnderTest`
+
+```
+Should_ThrowException_When_AgeLessThan18
+Should_FailToWithdrawMoney_ForInvalidAccount
+```
+
+- `When_StateUnderTest_Expect_ExpectedBehavior`
+
+```
+When_AgeLessThan18_Expect_isAdultAsFalse
+When_InvalidAccount_Expect_WithdrawMoneyToFail
+```
+
+- `Given_Preconditions_When_StateUnderTest_Then_ExpectedBehavior`
+
+```
+Given_UserIsAuthenticated_When_InvalidAccountNumberIsUsedToWithdrawMoney_Then_TransactionsWillFail
+```
+
+# `AAA`
+
+```
+[TestMethod]
+public void TestRegisterPost_ValidUser_ReturnsRedirect()
+{
+   // Arrange
+   AccountController controller = GetAccountController();
+   RegisterModel model = new RegisterModel()
+   {
+      UserName = "someUser",
+      Email = "goodEmail",
+      Password = "goodPassword",
+      ConfirmPassword = "goodPassword"
+   };
+   // Act
+   ActionResult result = controller.Register(model);
+   // Assert
+   RedirectToRouteResult redirectResult = (RedirectToRouteResult)result;
+   Assert.AreEqual("Home", redirectResult.RouteValues["controller"]);
+   Assert.AreEqual("Index", redirectResult.RouteValues["action"]);
+}
+```
+
+# 数据量很大很难测试时用单元测试
+
+被测代码,数量越大越难测，很有必要使用单元测试。
+
+```
+public decimal CalculateTotal(List<myitem> items)
+{
+	decimal total = 0.0m;
+	foreach(MyItem i in items)
+	{
+	 	total += i.UnitPrice * (i - i.Discount);
+	}
+	return total;
+}
+```
+
+# 保持被测方法不要过于复杂
+
+# `Test Explorer`的使用
+
+![t5](F:\SourceCodes\DDWiki\专题\后端\测试\t5.png)
+
+![t6](F:\SourceCodes\DDWiki\专题\后端\测试\t6.png)
+
+
+
+# 对被测代码复杂逻辑的封装
+
+不好
+
+```
+while ((ActiveThreads > 0 || AssociationsQueued > 0) && (IsRegistered || report.TotalTargets <= 1000 )
+&& (maxNumPagesToScan == -1 || report.TotalTargets < maxNumPagesToScan) && (!CancelScan))
+```
+
+好的
+
+```
+while (!HasFinishedInitializing (ActiveThreads, AssociationsQueued, IsRegistered,
+report.TotalTargets, maxNumPagesToScan, CancelScan))
+```
+
+# 使用`Selenium`进行`Web`测试
+