Asp.Net Core怎么利用xUnit進行主機級別的網絡集成測試

這篇文章將為大家詳細講解有關Asp.Net Core怎么利用xUnit進行主機級別的網絡集成測試，小編覺得挺實用的，因此分享給大家做個參考，希望大家閱讀完這篇文章后可以有所收獲。

前言

在開發 Asp.Net Core 應用程序的過程中，我們常常需要對業務代碼編寫單元測試，這種方法既快速又有效，利用單元測試做代碼覆蓋測試，也是非常必要的事情；但是，但我們需要對系統進行集成測試的時候，需要啟動服務主機，利用瀏覽器或者Postman 等網絡工具對接口進行集成測試，這就非常的不方便，同時浪費了大量的時間在重復啟動應用程序上；今天要介紹就是如何在不啟動應用程序的情況下，對 Asp.Net Core WebApi 項目進行網絡集成測試。

一、建立項目

1.1 首先我們建立兩個項目，Asp.Net Core WebApi 和 xUnit 單元測試項目，如下

1.2 上圖的單元測試項目 Ron.XUnitTest 必須應用待測試的 WebApi 項目 Ron.TestDemo

1.3 接下來打開 Ron.XUnitTest 項目文件 .csproj，添加包引用

Microsoft.AspNetCore.App
Microsoft.AspNetCore.TestHost

1.4 為什么要引用這兩個包呢，因為我剛才創建的 WebApi 項目是引用 Microsoft.AspNetCore.App 的，至于 Microsoft.AspNetCore.TestHost，它是今天的主角，為了使用測試主機，必須對其進行引用，下面會詳細說明

二、編寫業務

2.1 創建一個接口，代碼如下

 [Route("api/[controller]")]
 [ApiController]
 public class ValuesController : ControllerBase
 {
 private IConfiguration configuration;
 public ValuesController(IConfiguration configuration)
 {
  this.configuration = configuration;
 }

 [HttpGet("{id}")]
 public ActionResult<int> Get(int id)
 {
  var result= id + this.configuration.GetValue<int>("max");

  return result;
 }
 }

2.1 接口代碼非常簡單，接受一個參數 id，然后和配置文件中獲取的值 max 相加，然后輸出結果給客戶端

三、編寫測試用例

3.1 為了能夠使用主機集成測試，我們需要使用類

Microsoft.AspNetCore.TestHost.TestServer

3.2 我們來看一下 TestServer 的源碼，代碼較長，你可以直接跳過此段，進入下一節 3.3

 public class TestServer : IServer
 {
 private IWebHost _hostInstance;
 private bool _disposed = false;
 private IHttpApplication<Context> _application;

 public TestServer(): this(new FeatureCollection())
 {
 }

 public TestServer(IFeatureCollection featureCollection)
 {
  Features = featureCollection ?? throw new ArgumentNullException(nameof(featureCollection));
 }

 public TestServer(IWebHostBuilder builder): this(builder, new FeatureCollection())
 {
 }
 
 public TestServer(IWebHostBuilder builder, IFeatureCollection featureCollection): this(featureCollection)
 {
  if (builder == null)
  {
  throw new ArgumentNullException(nameof(builder));
  }

  var host = builder.UseServer(this).Build();
  host.StartAsync().GetAwaiter().GetResult();
  _hostInstance = host;
 }

 public Uri BaseAddress { get; set; } = new Uri("http://localhost/");

 public IWebHost Host
 {
  get
  {
  return _hostInstance
   ?? throw new InvalidOperationException("The TestServer constructor was not called with a IWebHostBuilder so IWebHost is not available.");
  }
 }

 public IFeatureCollection Features { get; }

 private IHttpApplication<Context> Application
 {
  get => _application ?? throw new InvalidOperationException("The server has not been started or no web application was configured.");
 }

 public HttpMessageHandler CreateHandler()
 {
  var pathBase = BaseAddress == null ? PathString.Empty : PathString.FromUriComponent(BaseAddress);
  return new ClientHandler(pathBase, Application);
 }

 public HttpClient CreateClient()
 {
  return new HttpClient(CreateHandler()) { BaseAddress = BaseAddress };
 }

 public WebSocketClient CreateWebSocketClient()
 {
  var pathBase = BaseAddress == null ? PathString.Empty : PathString.FromUriComponent(BaseAddress);
  return new WebSocketClient(pathBase, Application);
 }

 public RequestBuilder CreateRequest(string path)
 {
  return new RequestBuilder(this, path);
 }

 public async Task<HttpContext> SendAsync(Action<HttpContext> configureContext, CancellationToken cancellationToken = default)
 {
  if (configureContext == null)
  {
  throw new ArgumentNullException(nameof(configureContext));
  }

  var builder = new HttpContextBuilder(Application);
  builder.Configure(context =>
  {
  var request = context.Request;
  request.Scheme = BaseAddress.Scheme;
  request.Host = HostString.FromUriComponent(BaseAddress);
  if (BaseAddress.IsDefaultPort)
  {
   request.Host = new HostString(request.Host.Host);
  }
  var pathBase = PathString.FromUriComponent(BaseAddress);
  if (pathBase.HasValue && pathBase.Value.EndsWith("/"))
  {
   pathBase = new PathString(pathBase.Value.Substring(0, pathBase.Value.Length - 1));
  }
  request.PathBase = pathBase;
  });
  builder.Configure(configureContext);
  return await builder.SendAsync(cancellationToken).ConfigureAwait(false);
 }

 public void Dispose()
 {
  if (!_disposed)
  {
  _disposed = true;
  _hostInstance.Dispose();
  }
 }

 Task IServer.StartAsync<TContext>(IHttpApplication<TContext> application, CancellationToken cancellationToken)
 {
  _application = new ApplicationWrapper<Context>((IHttpApplication<Context>)application, () =>
  {
  if (_disposed)
  {
   throw new ObjectDisposedException(GetType().FullName);
  }
  });

  return Task.CompletedTask;
 }

 Task IServer.StopAsync(CancellationToken cancellationToken)
 {
  return Task.CompletedTask;
 }

 private class ApplicationWrapper<TContext> : IHttpApplication<TContext>
 {
  private readonly IHttpApplication<TContext> _application;
  private readonly Action _preProcessRequestAsync;

  public ApplicationWrapper(IHttpApplication<TContext> application, Action preProcessRequestAsync)
  {
  _application = application;
  _preProcessRequestAsync = preProcessRequestAsync;
  }

  public TContext CreateContext(IFeatureCollection contextFeatures)
  {
  return _application.CreateContext(contextFeatures);
  }

  public void DisposeContext(TContext context, Exception exception)
  {
  _application.DisposeContext(context, exception);
  }

  public Task ProcessRequestAsync(TContext context)
  {
  _preProcessRequestAsync();
  return _application.ProcessRequestAsync(context);
  }
 }
 }

3.3 TestServer 類代碼量比較大，不過不要緊，我們只需要關注它的構造方法就可以了

 public TestServer(IWebHostBuilder builder)
  : this(builder, new FeatureCollection())
 {
 }

3.4 其構造方法接受一個 IWebHostBuilder 對象，只要我們傳入一個 WebHostBuilder 就可以創建一個測試主機了

3.5 創建測試主機和 HttpClient 客戶端，我們在測試類 ValuesUnitTest 編寫如下代碼

 public class ValuesUnitTest
 {
 private TestServer testServer;
 private HttpClient httpCLient;

 public ValuesUnitTest()
 {
  testServer = new TestServer(new WebHostBuilder().UseStartup<Ron.TestDemo.Startup>());
  httpCLient = testServer.CreateClient();
 }

 [Fact]
 public async void GetTest()
 {
  var data = await httpCLient.GetAsync("/api/values/100");
  var result = await data.Content.ReadAsStringAsync();

  Assert.Equal("300", result);
 }
 }

代碼解釋

這段代碼非常簡單，首先，我們聲明了一個 TestServer 和 HttpClient 對象，并在構造方法中初始化他們； TestServer 的初始化是由我們 new 了一個 Builder 對象，并指定其使用待測試項目 Ron.TestDemo 中的 Startup 類來啟動，這樣我們能可以直接使用待測試項目的路由和管道了，甚至我們無需指定測試站點，因為這些都會在 TestServer 自動配置一個 localhost 的主機地址

3.7 接下來就是創建了一個單元測試的方法，直接使用剛才初始化的 HttpClient 對象進行網絡請求，這個時候，我們只需要知道 Action 即可，同時傳遞參數 100，最后斷言服務器輸出值為："300"，回顧一下我們創建的待測試方法，其業務正是將客戶端傳入的 id 值和配置文件 max 值相加后輸出，而 max 值在這里被配置為 200

3.8 運行單元測試

3.9 測試通過，可以看到，測試達到了預期的結果，服務器正確返回了計算后的值

四、配置文件注意事項

4.1 在待測試項目中的配置文件 appsettings.json 并不會被測試主機所讀取，因為我們在上面創建測試主機的時候沒有調用方法

WebHost.CreateDefaultBuilder

4.2 我們只是創建了一個 WebHostBuilder 對象，非常輕量的主機配置，簡單來說就是無配置，如果對于 WebHost.CreateDefaultBuilder 不理解的同學，建議閱讀我的文章 asp.netcore 深入了解配置文件加載過程.

4.3 所以，為了能夠在單元測試中使用項目配置文件，我在 Ron.TestDemo 項目中的 Startup 類加入了下面的代碼

 public class Startup
 {
 public Startup(IConfiguration configuration, IHostingEnvironment env)
 {
  this.Configuration = new ConfigurationBuilder()
  .AddJsonFile("appsettings.json")
  .AddEnvironmentVariables()
  .SetBasePath(env.ContentRootPath)
  .Build();
 }

 public IConfiguration Configuration { get; }

 // This method gets called by the runtime. Use this method to add services to the container.
 public void ConfigureServices(IServiceCollection services)
 {
  services.AddSingleton<IConfiguration>(this.Configuration);
  services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
 }
 }

4.4 其目的就是手動讀取配置文件，重新初始化 IConfiguration 對象，并將 this.Configuration 對象加入依賴注入容器中

結語

• 本文從單元測試入手，針對常見的系統集成測試提供了另外一種便捷的測試方案，通過創建 TestServer 測試主機開始，利用主機創建 HttpCLient 對象進行網絡集成測試

• 減少重復啟動程序和測試工具，提高了測試效率

• 充分利用了 Visual Studio 的優勢，既可以做單元測試，還能利用這種測試方案進行快速代碼調試

• 最后，還了解如何通過 TestServer 主機加載待測試項目的配置文件對象 IConfiguration

關于“Asp.Net Core怎么利用xUnit進行主機級別的網絡集成測試”這篇文章就分享到這里了，希望以上內容可以對大家有一定的幫助，使各位可以學到更多知識，如果覺得文章不錯，請把它分享出去讓更多的人看到。