测试驱动 ASP.NET MVC4

其他模板很适合于试验或创建概念证明，但它们通常会包含许多会让人分神且在真正的企业应用程序中不必要的干扰内容。

对于 ASP.NET MVC 应用程序开发，我建议使用在图 1 和图 2 中阐释的方法，其中包含以下项目：

  • 该层只能访问 Controllers、Service、Domain 和 Shared 项目。
  • 该层与 Service、Domain 和 Shared 项目通信。
  • 该层与 DataAccess、Domain 和 Shared 项目通信。
  • 该层与 Domain 和 Shared 项目通信。
  • Domain 项目包含应用程序使用的域项目，并且禁止与任何项目通信。
  • 图 1 各层之间的交互

测试驱动 ASP.NET MVC4
图 2 解决方案结构示例

结果就是您的 Web 项目仅包含真正与 UI 相关的代码。

在单个解决方案文件夹中定位您的所有测试项目和测试将会显著减少默认解决方案资源管理器视图中的干扰内容，从而允许您轻松地定位您的测试。

若要按测试类型对测试进行分组，请在 Tests 解决方案文件夹内为您计划编写的每种测试类型都创建一个文件夹。

图 3 显示了一个 Tests 解决方案文件夹的示例，其中包含多个测试类型文件夹。

测试驱动 ASP.NET MVC4
图 3 Tests 解决方案文件夹示例

图 4 显示具有测试项目的解决方案资源管理器。

测试驱动 ASP.NET MVC4
图 4 解决方案资源管理器中的测试项目

介绍针对您的体系结构的依赖关系注入

但在您可以利用 Test Double 所提供的灵活性之前，必须对您的代码进行设计，以便处理依赖关系的注入。

使用类并不知道其任何依赖关系的实际具体实现，仅知道支持依赖关系的接口；具体实现由使用类或依赖关系注入框架提供。

通过松散耦合，您在撰写单元测试时可以轻松地替换您的依赖关系的 Test Double 实现。

有三种主要方法可用于实现依赖关系注入：

  • 属性注入
  • 构造函数注入
  • 使用依赖关系注入框架/控制容器反转（自此以后称作 DI/IoC 框架）

此方法简单明了并且不需要工具。

图 5 属性注入

  1.           // Employee Service
  2. public class EmployeeService : IEmployeeService {
  3.   private ILoggingService _loggingService;
  4.   public EmployeeService() {}
  5.   public ILoggingService LoggingService { get; set; }
  6.   public decimal CalculateSalary(long employeeId) {
  7.     EnsureDependenciesSatisfied();
  8.     _loggingService.LogDebug(string.Format(
  9.       "Calculating Salary For Employee: {0}", employeeId));
  10.     decimal output = 0;
  11.     /*
  12.     * Complex logic that needs to be performed
  13.     * in order to determine the employee's salary
  14.     */
  15.     return output;
  16.   }
  17.   private void EnsureDependenciesSatisfied() {
  18.     if (_loggingService == null)
  19.       throw new InvalidOperationException(
  20.         "Logging Service dependency must be satisfied!");
  21.     }
  22.   }
  23. }
  24. // Employee Controller (Consumer of Employee Service)
  25. public class EmployeeController : Controller {
  26.   public ActionResult DisplaySalary(long id) {
  27.     EmployeeService employeeService = new EmployeeService();
  28.     employeeService.LoggingService = new LoggingService();
  29.     decimal salary = employeeService.CalculateSalary(id);
  30.     return View(salary);
  31.   }
  32. }
  33.         

最后，随着您的对象的依赖关系数目的增加，实例化对象所需的代码量也将增加。

此方法也简单明了，但与属性注入不同，您可以确保始终设置该类的依赖关系。

图 6 构造函数注入

  1.           // Employee Service
  2. public class EmployeeService : IEmployeeService {
  3.   private ILoggingService _loggingService;
  4.   public EmployeeService(ILoggingService loggingService) {
  5.     _loggingService = loggingService;
  6.   }
  7.   public decimal CalculateSalary(long employeeId) {
  8.     _loggingService.LogDebug(string.Format(
  9.       "Calculating Salary For Employee: {0}", employeeId));
  10.     decimal output = 0;
  11.     /*
  12.     * Complex logic that needs to be performed
  13.     * in order to determine the employee's salary
  14.     */
  15.     return output;
  16.   }
  17. }
  18. // Consumer of Employee Service
  19. public class EmployeeController : Controller {
  20.   public ActionResult DisplaySalary(long employeeId) {
  21.     EmployeeService employeeService =
  22.       new EmployeeService(new LoggingService());
  23.     decimal salary = employeeService.CalculateSalary(employeeId);
  24.     return View(salary);
  25.   }
  26. }
  27.         

较大的应用程序通常具有过多的依赖关系，以致无法通过对象的构造函数提供它们。

为了在本文中演示 DI/IoC 框架，我将使用 StructureMap。

利用 StructureMap 让依赖关系注入更上一层楼

您可以使用程序包管理器控制台 (Install-Package StructureMap) 或 NuGet 程序包管理器 GUI（右键单击您的项目的引用文件夹，然后选择“管理 NuGet 程序包”）通过 NuGet 来安装该框架。

您可以通过以下两种方法中的一种在 Global.asax 的 Application_Start 方法中配置依赖关系。

第一种方法是手动指示 StructureMap，对于特定的抽象实现，它应该使用特定的具体实现：

  1.           ObjectFactory.Initialize(register => {
  2.   register.For<ILoggingService>().Use<LoggingService>();
  3.   register.For<IEmployeeService>().Use<EmployeeService>();
  4. });
  5.         

此外，因为您在 ASP.NET MVC 站点的 Application_Start 中注册依赖关系，因此，您的 Web 层必须直接知道绑定有依赖关系的应用程序的其他每个层。

通过此方法，StructureMap 将扫描您的程序集，并且在它遇到某一接口时，会查找关联的具体实现（基于一个概念，即依据惯例，名为 IFoo 的方法将映射到具体实现 Foo）：

  1.           ObjectFactory.Initialize(registry => registry.Scan(x => {
  2.   x.AssembliesFromApplicationBaseDirectory();
  3.   x.WithDefaultConventions();
  4. }));
  5.         

这是通过创建依赖关系解决程序并将其定位于 Shared 项目中来实现的（因为它将需要由具有依赖关系的所有应用程序层来访问）：

  1.           public static class Resolver {
  2.   public static T GetConcreteInstanceOf<T>() {
  3.     return ObjectFactory.GetInstance<T>();
  4.   }
  5. }
  6.         

该函数接受泛型参数 T，该参数表示为其查找具体实现的接口；并且返回 T，这是传入接口的实际实现。

但遗憾的是，它驻留在 System.Web.MVC DLL 中，而我不希望在应用程序体系结构的非 Web 层中具有对特定于 Web 技术的库的引用。

您需要完成的全部工作就是调用 Resolver 类的静态 GetConcreteInstanceOf 函数，并且将其传递给您在为其查找具体实现的接口，如图 7 中所示。

图 7 解析代码中的依赖关系

  1.           public class EmployeeService : IEmployeeService {
  2.   private ILoggingService _loggingService;
  3.   public EmployeeService() {
  4.     _loggingService = 
  5.       Resolver.GetConcreteInstanceOf<ILoggingService>();
  6.   }
  7.   public decimal CalculateSalary(long employeeId) {
  8.     _loggingService.LogDebug(string.Format(
  9.       "Calculating Salary For Employee: {0}", employeeId));
  10.     decimal output = 0;
  11.     /*
  12.     * Complex logic that needs to be performed
  13.     * in order to determine the employee's salary
  14.     */
  15.     return output;
  16.   }
  17. }
  18.         

它的具体情形是这样的：

  • （您将会在图 7 中发现 EmployeeService 和 CalculateSalary 函数。）
  • 有一个要求，即必须记录对 CalculateSalary 函数的所有调用。
  • 调用日志记录服务当前会引发一个异常。
  • 需要在针对日志记录服务的工作按计划开始前完成该任务。

在该项目中，我添加了一个 Fakes 文件夹，因为为了完成我的测试，我需要 ILoggingService 的虚设实现。

测试驱动 ASP.NET MVC4
图 8 用于共享测试代码和虚设的项目

通常，这意味着它具有 void 方法的空实现，并且函数实现包含返回硬编码值的返回语句，如下所示：

  1.           public class LoggingServiceFake : ILoggingService {
  2.   public void LogError(string message, Exception ex) {}
  3.   public void LogDebug(string message) {}
  4.   public bool IsOnline() {
  5.     return true;
  6.   }
  7. }
  8.         

开始时，我将在 TestDrivingMVC.Service.Test.Unit 单元测试项目中创建一个测试类，按照前面所述的命名约定，我将其命名为 EmployeeServiceTest，如图 9 中所示。

图 9 EmployeeServiceTest 测试类

  1.           [TestClass]
  2. public class EmployeeServiceTest {
  3.   private ILoggingService _loggingServiceFake;
  4.   private IEmployeeService _employeeService;
  5.   [TestInitialize]
  6.   public void TestSetup() {
  7.     _loggingServiceFake = new LoggingServiceFake();
  8.     ObjectFactory.Initialize(x => 
  9.       x.For<ILoggingService>().Use(_loggingServiceFake));
  10.     _employeeService = new EmployeeService();
  11.   }
  12.   [TestMethod]
  13.   public void CalculateSalary_ShouldReturn_Decimal() {
  14.     // Arrange
  15.     long employeeId = 12345;
  16.     // Act
  17.     var result = 
  18.       _employeeService.CalculateSalary(employeeId);
  19.     // Assert
  20.     result.ShouldBeType<decimal>();
  21.   }
  22. }
  23.         

您要特别注意的代码行是：

  1.           ObjectFactory.Initialize(x =>
  2.     x.For<ILoggingService>().Use(
  3.     _loggingService));
  4.         

我将此代码放置于用 TestInitialize 标记的方法中，这指示单元测试框架在测试类中运行每个测试前都执行该方法。

这样做使我能够在不受到日志记录服务状态的影响下完成编码和单元测试，并且编写不依赖于任何依赖关系的真正的单元测试代码。

通过创建从 DefaultControllerFactory 继承的类（参见图 10），您可以控制创建控制器的方式。

图 10 自定义控制器工厂

  1.           public class ControllerFactory : DefaultControllerFactory {
  2.   private const string ControllerNotFound = 
  3.   "The controller for path '{0}' could not be found or it does not implement IController.";
  4.   private const string NotAController = "Type requested is not a controller: {0}";
  5.   private const string UnableToResolveController = 
  6.     "Unable to resolve controller: {0}";
  7.   public ControllerFactory() {
  8.     Container = ObjectFactory.Container;
  9.   }
  10.   public IContainer Container { get; set; }
  11.   protected override IController GetControllerInstance(
  12.     RequestContext context, Type controllerType) {
  13.     IController controller;
  14.     if (controllerType == null)
  15.       throw new HttpException(404, String.Format(ControllerNotFound,
  16.       context.HttpContext.Request.Path));
  17.     if (!typeof (IController).IsAssignableFrom(controllerType))
  18.       throw new ArgumentException(string.Format(NotAController,
  19.       controllerType.Name), "controllerType");
  20.     try {
  21.       controller = Container.GetInstance(controllerType) 
  22.         as IController;
  23.     }
  24.     catch (Exception ex) {
  25.       throw new InvalidOperationException(
  26.       String.Format(UnableToResolveController, 
  27.         controllerType.Name), ex);
  28.     }
  29.     return controller;
  30.   }
  31. }
  32.         

在这个新的控制器工厂中，我具有一个公共的 StructureMap 容器属性，它基于 StructureMap ObjectFactory 获取集（在图 10 的 Global.asax 中配置）。

因为我在最初配置 StructureMap 时使用了 StructureMap 自动注册和扫描功能，所以无需执行任何其他操作。

当您为控制器声明参数化的构造函数时，将在新的控制器工厂中解析控制器时自动解析依赖关系。

这意味着您无需手动添加代码来解析控制器的依赖关系 — 但您仍可以按照前述内容来使用虚设。

图 11 解析控制器

  1.           public class HomeController : Controller {
  2.   private readonly IEmployeeService _employeeService;
  3.   public HomeController(IEmployeeService employeeService) {
  4.     _employeeService = employeeService;
  5.   }
  6.   public ActionResult Index() {
  7.     return View();
  8.   }
  9.   public ActionResult DisplaySalary(long id) {
  10.     decimal salary = _employeeService.CalculateSalary(id);
  11.     return View(salary);
  12.   }
  13. }
  14.         

通过在您的 ASP.NET MVC 应用程序中使用这些实践和技术，整个 TDD 过程将更加轻松和简明。

相关文章：

  • 2021-05-13
  • 2021-10-05
  • 2021-11-30
  • 2021-11-28
  • 2021-06-27
猜你喜欢
  • 2022-02-18
  • 2022-12-23
  • 2021-12-07
  • 2021-12-14
  • 2022-12-23
  • 2022-12-23
  • 2021-11-18
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode