ASP.NET Core 中文文件第四章 MVC（4.5）測試控制器邏輯

阿新 • • 發佈：2019-01-18

ASP.NET MVC 應用程式的控制器應當小巧並專注於使用者介面。涉及了非 UI 事務的大控制器更難於測試和維護。

章節:

為什麼要測試控制器

控制器是所有 ASP.NET Core MVC 應用程式的核心部分。因此，你應當確保它們的行為符合應用的預期。自動化測試可以為你提供這樣的保障並能夠在進入生產環境之前將錯誤檢測出來。重要的一點是，避免將非必要的職責加入你的控制器並且確保測試只關注在控制器的職責上。

控制器的邏輯應當最小化並且不要去關心業務邏輯或基礎事務（如，資料訪問）。要測試控制器的邏輯，而不是框架。根據有效或無效的輸入去測試控制器的行為如何。根據其執行業務操作的返回值去測試控制器的響應。

典型的控制器職責：

驗證 ModelState.IsValid
如果 ModelState 無效則返回一個錯誤響應
從持久層獲取一個業務實體
在業務實體上執行一個操作
將業務實體儲存到持久層
返回一個合適的 IActionResult

單元測試

單元測試包括對應用中獨立於基礎結構和依賴項之外的某一部分的測試。對控制器邏輯進行單元測試的時候，只測試一個操作的內容，而不測試其依賴項或框架本身的行為。就是說對你的控制器操作進行測試時，要確保只聚焦於操作本身的行為。控制器單元測試避開諸如過濾器，路由，or 模型繫結這些內容。由於只專注於測試某一項內容，單元測試通常編寫簡單而執行快捷。一組編寫良好的單元測試可以無需過多開銷地頻繁執行。然而，單元測試並不檢測元件之間互動的問題，那是

整合測試的目的。

如果你在編寫自定義的過濾器，路由，諸如此類，你應該對它們進行單元測試，但不是作為某個控制器操作測試的一部分。它們應該單獨進行測試。

為演示單元測試，請檢視下面的控制器。它顯示一個頭腦風暴討論會的列表，並且可以用 POST 請求建立新的頭腦風暴討論會：

using System;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using TestingControllersSample.Core.Interfaces;
using TestingControllersSample.Core.Model;
using TestingControllersSample.ViewModels;

namespace TestingControllersSample.Controllers
{
    public class HomeController : Controller                                   // 手動高亮
    {
        private readonly IBrainstormSessionRepository _sessionRepository;

        public HomeController(IBrainstormSessionRepository sessionRepository) // 手動高亮
        {
            _sessionRepository = sessionRepository;
        }

        public async Task<IActionResult> Index()                              // 手動高亮
        {
            var sessionList = await _sessionRepository.ListAsync();

            var model = sessionList.Select(session => new StormSessionViewModel()
            {
                Id = session.Id,
                DateCreated = session.DateCreated,
                Name = session.Name,
                IdeaCount = session.Ideas.Count
            });

            return View(model);
        }

        public class NewSessionModel
        {
            [Required]
            public string SessionName { get; set; }
        }

        [HttpPost]                                                     // 手動高亮
        public async Task<IActionResult> Index(NewSessionModel model)  // 手動高亮
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            await _sessionRepository.AddAsync(new BrainstormSession()
            {
                DateCreated = DateTimeOffset.Now,
                Name = model.SessionName
            });

            return RedirectToAction("Index");
        }
    }
}

這個控制器遵循顯式依賴原則，期望依賴注入為其提供一個 IBrainstormSessionRepository 的例項。這樣就非常容易用一個 Mock 物件框架來進行測試，比如 Moq 。HTTP GET Index 方法沒有迴圈或分支，只是呼叫了一個方法。要測試這個 Index 方法，我們需要驗證是否返回了一個 ViewResult ，其中包含一個來自儲存庫的 List 方法的 ViewModel 。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Moq;
using TestingControllersSample.Controllers;
using TestingControllersSample.Core.Interfaces;
using TestingControllersSample.Core.Model;
using TestingControllersSample.ViewModels;
using Xunit;

namespace TestingControllersSample.Tests.UnitTests
{
    public class HomeControllerTests
    {
        [Fact]                                                                       // 手動高亮
        public async Task Index_ReturnsAViewResult_WithAListOfBrainstormSessions()   // 手動高亮
        {
            // Arrange
            var mockRepo = new Mock<IBrainstormSessionRepository>();
            mockRepo.Setup(repo => repo.ListAsync()).Returns(Task.FromResult(GetTestSessions()));
            var controller = new HomeController(mockRepo.Object);

            // Act
            var result = await controller.Index();

            // Assert
            var viewResult = Assert.IsType<ViewResult>(result);
            var model = Assert.IsAssignableFrom<IEnumerable<StormSessionViewModel>>(
                viewResult.ViewData.Model);
            Assert.Equal(2, model.Count());
        }

        [Fact]
        public async Task IndexPost_ReturnsBadRequestResult_WhenModelStateIsInvalid()
        {
            // Arrange
            var mockRepo = new Mock<IBrainstormSessionRepository>();
            mockRepo.Setup(repo => repo.ListAsync()).Returns(Task.FromResult(GetTestSessions()));
            var controller = new HomeController(mockRepo.Object);
            controller.ModelState.AddModelError("SessionName", "Required");
            var newSession = new HomeController.NewSessionModel();

            // Act
            var result = await controller.Index(newSession);

            // Assert
            var badRequestResult = Assert.IsType<BadRequestObjectResult>(result);
            Assert.IsType<SerializableError>(badRequestResult.Value);
        }
        [Fact]
        public async Task IndexPost_ReturnsARedirectAndAddsSession_WhenModelStateIsValid()
        {
            // Arrange
            var mockRepo = new Mock<IBrainstormSessionRepository>();
            mockRepo.Setup(repo => repo.AddAsync(It.IsAny<BrainstormSession>()))
                .Returns(Task.CompletedTask)
                .Verifiable();
            var controller = new HomeController(mockRepo.Object);
            var newSession = new HomeController.NewSessionModel()
            {
                SessionName = "Test Name"
            };

            // Act
            var result = await controller.Index(newSession);

            // Assert
            var redirectToActionResult = Assert.IsType<RedirectToActionResult>(result);
            Assert.Null(redirectToActionResult.ControllerName);
            Assert.Equal("Index", redirectToActionResult.ActionName);
            mockRepo.Verify();
        }
        
        private List<BrainstormSession> GetTestSessions()
        {
            var sessions = new List<BrainstormSession>();
            sessions.Add(new BrainstormSession()
            {
                DateCreated = new DateTime(2016, 7, 2),
                Id = 1,
                Name = "Test One"
            });
            sessions.Add(new BrainstormSession()
            {
                DateCreated = new DateTime(2016, 7, 1),
                Id = 2,
                Name = "Test Two"
            });
            return sessions;
        }
    }
}

HTTP POST Index 方法（下面所示）應當驗證：

當 ModelState.IsValid 為 false 時，操作方法返回一個包含適當資料的 ViewResult。
當 ModelState.IsValid 為 true 時，儲存庫的 Add 方法被呼叫，然後返回一個包含正確變數內容的 RedirectToActionResult 。

    [Fact]
    public async Task IndexPost_ReturnsBadRequestResult_WhenModelStateIsInvalid()
    {
        // Arrange
        var mockRepo = new Mock<IBrainstormSessionRepository>();
        mockRepo.Setup(repo => repo.ListAsync()).Returns(Task.FromResult(GetTestSessions()));
        var controller = new HomeController(mockRepo.Object);
        controller.ModelState.AddModelError("SessionName", "Required");         // 手動高亮
        var newSession = new HomeController.NewSessionModel();

        // Act
        var result = await controller.Index(newSession);

        // Assert
        var badRequestResult = Assert.IsType<BadRequestObjectResult>(result);   // 手動高亮
        Assert.IsType<SerializableError>(badRequestResult.Value);               // 手動高亮
    }

    [Fact]
    public async Task IndexPost_ReturnsARedirectAndAddsSession_WhenModelStateIsValid()
    {
        // Arrange
        var mockRepo = new Mock<IBrainstormSessionRepository>();
        mockRepo.Setup(repo => repo.AddAsync(It.IsAny<BrainstormSession>()))
            .Returns(Task.CompletedTask)
            .Verifiable();
        var controller = new HomeController(mockRepo.Object);
        var newSession = new HomeController.NewSessionModel()
        {
            SessionName = "Test Name"
        };

        // Act
        var result = await controller.Index(newSession);

        // Assert
        var redirectToActionResult = Assert.IsType<RedirectToActionResult>(result); // 手動高亮
        Assert.Null(redirectToActionResult.ControllerName);                         // 手動高亮
        Assert.Equal("Index", redirectToActionResult.ActionName);                   // 手動高亮
        mockRepo.Verify();
    }

第一個測試確定當 ModelState 無效時，返回一個與 GET 請求一樣的 ViewResult 。注意，測試不會嘗試傳遞一個無效模型進去。那樣是沒有作用的，因為模型繫結並沒有執行 - 我們只是直接呼叫了操作方法。然而，我們並不想去測試模型繫結 —— 我們只是在測試操作方法裡的程式碼行為。最簡單的方法就是在 ModelState 中新增一個錯誤。

第二個測試驗證當 ModelState 有效時，新的 BrainstormSession 被新增（通過儲存庫），並且該方法返回一個帶有預期屬性值的 RedirectToActionResult 。未被執行到的 mock 呼叫通常就被忽略了，但是在設定過程的最後呼叫 Verifiable 則允許其在測試中被驗證。這是通過呼叫 mockRepo.Verify 實現的。

這個例子中所採用的 Moq 庫能夠簡單地混合可驗證的，“嚴格的”及帶有不可驗證mock（也稱為 “寬鬆的” mock 或 stub）的mock。瞭解更多關於使用 Moq 自定義 Mock 行為。

應用程式裡的另外一個控制器顯示指定頭腦風暴討論會的相關資訊。它包含一些處理無效 id 值的邏輯：

using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using TestingControllersSample.Core.Interfaces;
using TestingControllersSample.ViewModels;

namespace TestingControllersSample.Controllers
{
    public class SessionController : Controller
    {
        private readonly IBrainstormSessionRepository _sessionRepository;

        public SessionController(IBrainstormSessionRepository sessionRepository)
        {
            _sessionRepository = sessionRepository;
        }

        public async Task<IActionResult> Index(int? id)
        {
            if （!id.HasValue）                              // 手動高亮
            {                                                // 手動高亮
                return RedirectToAction("Index", "Home");    // 手動高亮
            }                                                // 手動高亮

            var session = await _sessionRepository.GetByIdAsync(id.Value);
            if (session == null)                        // 手動高亮
            {                                           // 手動高亮
                return Content("Session not found.");   // 手動高亮
            }                                           // 手動高亮

            var viewModel = new StormSessionViewModel()
            {
                DateCreated = session.DateCreated,
                Name = session.Name,
                Id = session.Id
            };

            return View(viewModel);
        }
    }
}

這個控制器操作有三種情況要測試，每條 return 語句一種：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Moq;
using TestingControllersSample.Controllers;
using TestingControllersSample.Core.Interfaces;
using TestingControllersSample.Core.Model;
using TestingControllersSample.ViewModels;
using Xunit;

namespace TestingControllersSample.Tests.UnitTests
{
    public class SessionControllerTests
    {
        [Fact]
        public async Task IndexReturnsARedirectToIndexHomeWhenIdIsNull()
        {
            // Arrange
            var controller = new SessionController(sessionRepository: null);

            // Act
            var result = await controller.Index(id: null);

            // Arrange
            var redirectToActionResult = Assert.IsType<RedirectToActionResult>(result); // 手動高亮
            Assert.Equal("Home", redirectToActionResult.ControllerName);                // 手動高亮
            Assert.Equal("Index", redirectToActionResult.ActionName);                   // 手動高亮
        }
        [Fact]
        public async Task IndexReturnsContentWithSessionNotFoundWhenSessionNotFound()
        {
            // Arrange
            int testSessionId = 1;
            var mockRepo = new Mock<IBrainstormSessionRepository>();
            mockRepo.Setup(repo => repo.GetByIdAsync(testSessionId))
                .Returns(Task.FromResult((BrainstormSession)null));
            var controller = new SessionController(mockRepo.Object);

            // Act
            var result = await controller.Index(testSessionId);

            // Assert
            var contentResult = Assert.IsType<ContentResult>(result);   // 手動高亮
            Assert.Equal("Session not found.", contentResult.Content);  // 手動高亮
        }

       [Fact]
        public async Task IndexReturnsViewResultWithStormSessionViewModel()
        {
            // Arrange
            int testSessionId = 1;
            var mockRepo = new Mock<IBrainstormSessionRepository>();
            mockRepo.Setup(repo => repo.GetByIdAsync(testSessionId))
                .Returns(Task.FromResult(GetTestSessions().FirstOrDefault(s => s.Id == testSessionId)));
            var controller = new SessionController(mockRepo.Object);

            // Act
            var result = await controller.Index(testSessionId);

            // Assert
            var viewResult = Assert.IsType<ViewResult>(result); // 手動高亮
            var model = Assert.IsType<StormSessionViewModel>(viewResult.ViewData.Model);    // 手動高亮
            Assert.Equal("Test One", model.Name);   // 手動高亮
            Assert.Equal(2, model.DateCreated.Day); // 手動高亮
            Assert.Equal(testSessionId, model.Id);  // 手動高亮
        }

      private List<BrainstormSession> GetTestSessions()
        {
            var sessions = new List<BrainstormSession>();
            sessions.Add(new BrainstormSession()
            {
                DateCreated = new DateTime(2016, 7, 2),
                Id = 1,
                Name = "Test One"
            });
            sessions.Add(new BrainstormSession()
            {
                DateCreated = new DateTime(2016, 7, 1),
                Id = 2,
                Name = "Test Two"
            });
            return sessions;
        }
    }
}

這個應用程式以 Web API （一個頭腦風暴討論會的意見列表以及一個給討論會新增新意見的方法）的形式公開功能：

using System;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using TestingControllersSample.ClientModels;
using TestingControllersSample.Core.Interfaces;
using TestingControllersSample.Core.Model;

namespace TestingControllersSample.Api
{
    [Route("api/ideas")]
    public class IdeasController : Controller
    {
        private readonly IBrainstormSessionRepository _sessionRepository;

        public IdeasController(IBrainstormSessionRepository sessionRepository)
        {
            _sessionRepository = sessionRepository;
        }

        [HttpGet("forsession/{sessionId}")]                         // 手動高亮
        public async Task<IActionResult> ForSession(int sessionId)  // 手動高亮
        {
            var session = await _sessionRepository.GetByIdAsync(sessionId);
            if (session == null)
            {
                return NotFound(sessionId); // 手動高亮
            }

            var result = session.Ideas.Select(idea => new IdeaDTO()// 手動高亮
            {                                                      // 手動高亮
                Id = idea.Id,                                      // 手動高亮
                Name = idea.Name,                                  // 手動高亮
                Description = idea.Description,                    // 手動高亮
                DateCreated = idea.DateCreated                     // 手動高亮
            }).ToList();                                           // 手動高亮
            
            return Ok(result);
        }

        [HttpPost("create")]                                                    // 手動高亮
        public async Task<IActionResult> Create([FromBody]NewIdeaModel model)   // 手動高亮
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);                                  // 手動高亮
            }

            var session = await _sessionRepository.GetByIdAsync(model.SessionId);
            if (session == null)
            {
                return NotFound(model.SessionId);                               // 手動高亮
            }

            var idea = new Idea()
            {
                DateCreated = DateTimeOffset.Now,
                Description = model.Description,
                Name = model.Name
            };
            session.AddIdea(idea);

            await _sessionRepository.UpdateAsync(session);

            return Ok(session);                                                 // 手動高亮
        }
    }
}

ForSession 方法返回一個 IdeaDTO 型別的列表，該型別有著符合 JavaScript 慣例的駝峰命名法的屬性名。從而避免直接通過 API 呼叫返回你業務領域的實體，因為通常它們都包含了 API 客戶端並不需要的更多資料，而且它們將你的應用程式的內部領域模型與外部公開的 API 不必要地耦合起來。可以手動將業務領域實體與你想要返回的型別連線對映起來（使用這裡展示的 LINQ Select），或者使用諸如 AutoMapper的類庫。

Create 和 ForSession API 方法的單元測試：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Moq;
using TestingControllersSample.Api;
using TestingControllersSample.ClientModels;
using TestingControllersSample.Core.Interfaces;
using TestingControllersSample.Core.Model;
using Xunit;

namespace TestingControllersSample.Tests.UnitTests
{
    public class ApiIdeasControllerTests
    {
        [Fact]
        public async Task Create_ReturnsBadRequest_GivenInvalidModel()  // 手動高亮
        {
            // Arrange & Act
            var mockRepo = new Mock<IBrainstormSessionRepository>();
            var controller = new IdeasController(mockRepo.Object);
            controller.ModelState.AddModelError("error","some error");  // 手動高亮

            // Act
            var result = await controller.Create(model: null);

            // Assert
            Assert.IsType<BadRequestObjectResult>(result);              // 手動高亮
        }
       [Fact]
        public async Task Create_ReturnsHttpNotFound_ForInvalidSession()// 手動高亮
        {
            // Arrange
            int testSessionId = 123;
            var mockRepo = new Mock<IBrainstormSessionRepository>();
            mockRepo.Setup(repo => repo.GetByIdAsync(testSessionId))    // 手動高亮
                .Returns(Task.FromResult((BrainstormSession)null));     // 手動高亮 
            var controller = new IdeasController(mockRepo.Object);

            // Act
            var result = await controller.Create(new NewIdeaModel());   // 手動高亮

            // Assert
            Assert.IsType<NotFoundObjectResult>(result);
        }
        
        [Fact]
        public async Task Create_ReturnsNewlyCreatedIdeaForSession()    // 手動高亮
        {
            // Arrange
            int testSessionId = 123;
            string testName = "test name";
            string testDescription = "test description";
            var testSession = GetTestSession();
            var mockRepo = new Mock<IBrainstormSessionRepository>();
            mockRepo.Setup(repo => repo.GetByIdAsync(testSessionId))    // 手動高亮
                .Returns(Task.FromResult(testSession));                 // 手動高亮
            var controller = new IdeasController(mockRepo.Object);

            var newIdea = new NewIdeaModel()
            {
                Description = testDescription,
                Name = testName,
                SessionId = testSessionId
            };
            mockRepo.Setup(repo => repo.UpdateAsync(testSession))       // 手動高亮
                .Returns(Task.CompletedTask)                            // 手動高亮
                .Verifiable();                                          // 手動高亮

            // Act
            var result = await controller.Create(newIdea);

            // Assert
            var okResult = Assert.IsType<OkObjectResult>(result);       // 手動高亮
            var returnSession = Assert.IsType<BrainstormSession>(okResult.Value);// 手動高亮
            mockRepo.Verify();                                          // 手動高亮
            Assert.Equal(2, returnSession.Ideas.Count());
            Assert.Equal(testName, returnSession.Ideas.LastOrDefault().Name);
            Assert.Equal(testDescription, returnSession.Ideas.LastOrDefault().Description);
        }

        [Fact]
        public async Task ForSession_ReturnsHttpNotFound_ForInvalidSession()
        {
            // Arrange
            int testSessionId = 123;
            var mockRepo = new Mock<IBrainstormSessionRepository>();
            mockRepo.Setup(repo => repo.GetByIdAsync(testSessionId))
                .Returns(Task.FromResult((BrainstormSession)null));
            var controller = new IdeasController(mockRepo.Object);

            // Act
            var result = await controller.ForSession(testSessionId);

            // Assert
            var notFoundObjectResult = Assert.IsType<NotFoundObjectResult>(result);
            Assert.Equal(testSessionId, notFoundObjectResult.Value);
        }

        [Fact]
        public async Task ForSession_ReturnsIdeasForSession()
        {
            // Arrange
            int testSessionId = 123;
            var mockRepo = new Mock<IBrainstormSessionRepository>();
            mockRepo.Setup(repo => repo.GetByIdAsync(testSessionId)).Returns(Task.FromResult(GetTestSession()));
            var controller = new IdeasController(mockRepo.Object);

            // Act
            var result = await controller.ForSession(testSessionId);

            // Assert
            var okResult = Assert.IsType<OkObjectResult>(result);
            var returnValue = Assert.IsType<List<IdeaDTO>>(okResult.Value);
            var idea = returnValue.FirstOrDefault();
            Assert.Equal("One", idea.Name);
        }
        
        private BrainstormSession GetTestSession()
        {
            var session = new BrainstormSession()
            {
                DateCreated = new DateTime(2016, 7, 2),
                Id = 1,
                Name = "Test One"
            };

            var idea = new Idea() { Name = "One" };
            session.AddIdea(idea);
            return session;
        }
    }
}

如前所述，要測試這個方法在 ModelState 無效時的行為，可以將一個模型錯誤作為測試的一部分新增到控制器。不要在單元測試嘗試測試模型驗證或者模型繫結 —— 僅僅測試應對特定 ModelState 值的時候，你的操作方法的行為。

第二項測試需要儲存庫返回 null ，因此將模擬的儲存庫配置為返回 null 。沒有必要去建立一個測試資料庫（記憶體中的或其他的）並構建一條能返回這個結果的查詢 —— 就像展示的那樣，一行程式碼就可以了。.

最後一項測試驗證儲存庫的 Update 方法是否被呼叫。像我們之前做過的那樣，在呼叫 mock 時呼叫了 Verifiable ，然後模擬儲存庫的 Verify 方法被呼叫，用以確認可驗證的方法已被執行。確保 Update 儲存了資料並不是單元測試的職責；那是整合測試做的事。

整合測試

整合測試是為了確保你應用程式裡各獨立模組能夠正確地一起工作。通常，能進行單元測試的東西，都能進行整合測試，但反之則不行。不過，整合測試往往比單元測試慢得多。因此，最好儘量採用單元測試，在涉及到多方合作的情況下再進行整合測試。

儘管 mock 物件仍然有用，但在整合測試中很少用到它們。在單元測試中，mock 物件是一種有效的方式，根據測試目的去控制測試單元外的合作者應當有怎樣的行為。在整合測試中，則採用真實的合作者來確定整個子系統能夠正確地一起工作。

應用程式狀態

在執行整合測試的時候，一個重要的考慮因素就是如何設定你的應用程式的狀態。各個測試需要獨立地執行，所以每個測試都應該在已知狀態下隨應用程式啟動。如果你的應用沒有使用資料庫或者任何持久層，這可能不是個問題。然而，大多數真實的應用程式都會將它們的狀態持久化到某種資料儲存中，所以某個測試對其有任何改動都可能影響到其他測試，除非重置了資料儲存。使用內建的 TestServer ，它可以直接託管我們整合測試中的 ASP.NET Core 應用程式，但又無須對我們將使用的資料授權訪問。如果你正在使用真實的資料庫，一種方法是讓應用程式連線到測試資料庫，你的測試可以訪問它並且確保在每個測試執行之前會重置到一個已知的狀態。

在這個示例應用程式裡，我採用了 Entity Framework Core 的 InMemoryDatabase 支援，因此我可以直接把我的測試專案連線到它。實際上，我在應用程式的 Startup 類裡公開了一個 InitializeDatabase 方法，我可以在開發（ Development ）環境中啟動應用程式的時候呼叫這個方法。我的整合測試只要把環境設定為 Development ，就能自動從中受益。我不需要擔心重置資料庫，因為 InMemoryDatabase 會在應用程式每次重啟的時候重置。

The Startup class:

using System;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using TestingControllersSample.Core.Interfaces;
using TestingControllersSample.Core.Model;
using TestingControllersSample.Infrastructure;

namespace TestingControllersSample
{
    public class Startup
    {
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddDbContext<AppDbContext>(                        // 手動高亮
                optionsBuilder => optionsBuilder.UseInMemoryDatabase());// 手動高亮

            services.AddMvc();

            services.AddScoped<IBrainstormSessionRepository,
                EFStormSessionRepository>();
        }

        public void Configure(IApplicationBuilder app,
            IHostingEnvironment env,
            ILoggerFactory loggerFactory)
        {
            loggerFactory.AddConsole(LogLevel.Warning);

            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();

                var repository = app.ApplicationServices.GetService<IBrainstormSessionRepository>();// 手動高亮
                InitializeDatabaseAsync(repository).Wait();                                         // 手動高亮
            }

            app.UseStaticFiles();

            app.UseMvcWithDefaultRoute();
        }

        public async Task InitializeDatabaseAsync(IBrainstormSessionRepository repo)    // 手動高亮
        {
            var sessionList = await repo.ListAsync();
            if (!sessionList.Any())
            {
                await repo.AddAsync(GetTestSession());
            }
        }

        public static BrainstormSession GetTestSession()                                // 手動高亮 
        {
            var session = new BrainstormSession()
            {
                Name = "Test Session 1",
                DateCreated = new DateTime(2016, 8, 1)
            };
            var idea = new Idea()
            {
                DateCreated = new DateTime(2016, 8, 1),
                Description = "Totally awesome idea",
                Name = "Awesome idea"
            };
            session.AddIdea(idea);
            return session;
        }
    }
}

在下面的整合測試中，你會看到 GetTestSession 方法被頻繁使用。

訪問檢視

每一個整合測試類都會配置 TestServer 來執行 ASP.NET Core 應用程式。預設情況下，TestServer 在其執行的目錄下承載 Web 應用程式 —— 在本例中，就是測試專案資料夾。因此，當你嘗試測試返回 ViewResult 的控制器操作的時候，你會看見這樣的錯誤：

   未找到檢視 “Index”。已搜尋以下位置：
  （位置列表）

要修正這個問題，你需要配置伺服器使其採用 Web 專案的 ApplicationBasePath 和 ApplicationName 。這在所示的整合測試類中呼叫 UseServices 完成的：

using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
using Xunit;

namespace TestingControllersSample.Tests.IntegrationTests
{
    public class HomeControllerTests : IClassFixture<TestFixture<TestingControllersSample.Startup>>
    {
        private readonly HttpClient _client;

        public HomeControllerTests(TestFixture<TestingControllersSample.Startup> fixture)
        {
            _client = fixture.Client;
        }

        [Fact]
        public async Task ReturnsInitialListOfBrainstormSessions()
        {
            // Arrange
            var testSession = Startup.GetTestSession();

            // Act
            var response = await _client.GetAsync("/");

            // Assert
            response.EnsureSuccessStatusCode();
            var responseString = await response.Content.ReadAsStringAsync();
            Assert.True(responseString.Contains(testSession.Name));
        }
        
        [Fact]
        public async Task PostAddsNewBrainstormSession()
        {
            // Arrange
            string testSessionName = Guid.NewGuid().ToString();
            var data = new Dictionary<string, string>();
            data.Add("SessionName", testSessionName);
            var content = new FormUrlEncodedContent(data);

            // Act
            var response = await _client.PostAsync("/", content);

            // Assert
            Assert.Equal(HttpStatusCode.Redirect, response.StatusCode);
            Assert.Equal("/", response.Headers.Location.ToString());
        }
    }
}

在上面的測試中，responseString 從檢視獲取真實渲染的 HTML ，可以用來檢查確認其中是否包含期望的結果。

API 方法

如果你的應用程式有公開的 Web API，採用自動化測試來確保它們按期望執行是個好主意。內建的 TestServer 便於測試 Web API。如果你的 API 方法使用了模型繫結，那麼你應該始終檢查 ModelState.IsValid ，另外確認你的模型驗證工作是否正常應當在整合測試裡進行。

下面一組測試針對上文所示的 ideasController裡的 Create 方法：

        [Fact]
        public async Task CreatePostReturnsBadRequestForMissingNameValue()
        {
            // Arrange
            var newIdea = new NewIdeaDto("", "Description", 1);

            // Act
            var response = await _client.PostAsJsonAsync("/api/ideas/create", newIdea);

            // Assert
            Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
        }

        [Fact]
        public async Task CreatePostReturnsBadRequestForMissingDescriptionValue()
        {
            // Arrange
            var newIdea = new NewIdeaDto("Name", "", 1);

            // Act
            var response = await _client.PostAsJsonAsync("/api/ideas/create", newIdea);

            // Assert
            Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
        }

        [Fact]
        public async Task CreatePostReturnsBadRequestForSessionIdValueTooSmall()
        {
            // Arrange
            var newIdea = new NewIdeaDto("Name", "Description", 0);

            // Act
            var response = await _client.PostAsJsonAsync("/api/ideas/create", newIdea);

            // Assert
            Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
        }

        [Fact]
        public async Task CreatePostReturnsBadRequestForSessionIdValueTooLarge()
        {
            // Arrange
            var newIdea = new NewIdeaDto("Name", "Description", 1000001);

            // Act
            var response = await _client.PostAsJsonAsync("/api/ideas/create", newIdea);

            // Assert
            Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
        }

        [Fact]
        public async Task CreatePostReturnsNotFoundForInvalidSession()
        {
            // Arrange
            var newIdea = new NewIdeaDto("Name", "Description", 123);

            // Act
            var response = await _client.PostAsJsonAsync("/api/ideas/create", newIdea);

            // Assert
            Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
        }

        [Fact]
        public async Task CreatePostReturnsCreatedIdeaWithCorrectInputs()
        {
            // Arrange
            var testIdeaName = Guid.NewGuid().ToString();
            var newIdea = new NewIdeaDto(testIdeaName, "Description", 1);

            // Act
            var response = await _client.PostAsJsonAsync("/api/ideas/create", newIdea);

            // Assert
            response.EnsureSuccessStatusCode();
            var returnedSession = await response.Content.ReadAsJsonAsync<BrainstormSession>();
            Assert.Equal(2, returnedSession.Ideas.Count);
            Assert.True(returnedSession.Ideas.Any(i => i.Name == testIdeaName));
        }

        [Fact]
        public async Task ForSessionReturnsNotFoundForBadSessionId()
        {
            // Arrange & Act
            var response = await _client.GetAsync("/api/ideas/forsession/500");

            // Assert
            Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
        }

        public async Task ForSessionReturnsIdeasForValidSessionId()
        {
            // Arrange
            var testSession = Startup.GetTestSession();

            // Act
            var response = await _client.GetAsync("/api/ideas/forsession/1");

            // Assert
            response.EnsureSuccessStatusCode();
            var ideaList = JsonConvert.DeserializeObject<List<IdeaDTO>>(
                await response.Content.ReadAsStringAsync());
            var firstIdea = ideaList.First();
            Assert.Equal(testSession.Ideas.First().Name, firstIdea.Name);
        }
    }

不同於對返回 HTML 檢視的操作的整合測試，有返回值的 Web API 方法通常能夠反序列化為強型別物件，就像上面所示的最後一個測試。在此例中，該測試將返回值反序列化為一個 BrainstormSession 例項，然後再確認意見是否被正確新增到了意見集合裡。

你可以在sample project這篇文章裡找到更多的整合測試示例。

返回目錄

ASP.NET Core 中文文件第四章 MVC（4.5）測試控制器邏輯

為什麼要測試控制器

單元測試

整合測試

應用程式狀態

訪問檢視

API 方法

ASP.NET Core 中文文件第四章 MVC（4.5）測試控制器邏輯

ASP.NET Core 中文文件第四章 MVC（4.6）Areas（區域）

ASP.NET Core 中文文件第四章 MVC（4.2）控制器操作的路由

ASP.NET Core 中文文件第四章 MVC（4.1）Controllers, Actions 和 Action Results

ASP.NET Core 中文文件第四章 MVC（4.3）過濾器

ASP.NET Core 中文文件第四章 MVC（2.3）格式化響應資料

ASP.NET Core 中文文件第四章 MVC（4.4）依賴注入和控制器

ASP.NET Core 中文文件第四章 MVC（3.8）檢視中的依賴注入

ASP.NET Core 中文文件第四章 MVC（3.7 ）區域性檢視（partial）

ASP.NET Core 中文文件第四章 MVC（3.9）檢視元件

ASP.NET Core 中文文件第四章 MVC（01）ASP.NET Core MVC 概覽

ASP.NET Core 中文文件第三章原理（4）路由

ASP.NET Core 中文文件第三章原理（2）中介軟體

ASP.NET Core 中文文件第三章原理（6）全球化與本地化

ASP.NET Core 中文文件第三章原理（11）在多個環境中工作

ASP.NET Core 中文文件第三章原理（13）管理應用程式狀態

ASP.NET Core 中文文件第三章原理（1）應用程式啟動

ASP.NET Core 中文文件第三章原理（16）.NET開放Web介面（OWIN）

ASP.NET Core 中文文件第三章原理（17）為你的伺服器選擇合適版本的.NET框架

ASP.NET Core 中文文件第五章測試（5.2）整合測試

ASP.NET Core 中文文件 第四章 MVC（4.5）測試控制器邏輯

為什麼要測試控制器

單元測試

整合測試

應用程式狀態

訪問檢視

API 方法

相關推薦

ASP.NET Core 中文文件第四章 MVC（4.5）測試控制器邏輯