模拟业务层以集成测试 Web API

Question

我想在我的 Web API 上进行集成测试，而不依赖于我的业务层接口。

当这个动作运行时：

1) 我想模拟 _service 对象并验证它是否被调用

2) 我想断言返回了正确的 StatusCode

2 号没问题，但是当我不手动控制/启动 api 控制器的创建时，如何模拟 _service 对象（ISchoolyearService），因为这是在单元测试控制器中完成的任务。但我不想对我的 API 进行单元测试！

 [RoutePrefix("api/schoolyears")]
    public class SchoolyearController : ApiController
    {
        private readonly ISchoolyearService _service;
        public SchoolyearController(ISchoolyearService service)
        {
            _service = service;
        }



 [Route("")]
    [HttpPost]
    public HttpResponseMessage Post([FromBody]SchoolyearCreateRequest request)
    {
        _service.CreateSchoolyear(request);
        return Request.CreateResponse(HttpStatusCode.Created);
    }

Answer 1

以下是一个粗略的示例，说明如何进行内存集成测试。这里我使用Unity.WebApi.UnityDependencyResolver 来注入模拟依赖项。您可以类似地使用任何其他 IoC 容器。

using Microsoft.Practices.Unity;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http;
using Unity.WebApi;

namespace WebApplication251.Tests.Controllers
{
    [TestClass]
    public class PeopleControllerTest
    {
        string baseAddress = "http://dummyhost/";

        [TestMethod]
        public void PostTest()
        {
            HttpConfiguration config = new HttpConfiguration();

            // use the configuration that the web application has defined
            WebApiConfig.Register(config);

            //override the dependencies with mock ones
            RegisterMockDependencies(config);

            HttpServer server = new HttpServer(config);

            //create a client with a handler which makes sure to exercise the formatters
            HttpClient client = new HttpClient(new InMemoryHttpContentSerializationHandler(server));

            SchoolyearCreateRequest req = new SchoolyearCreateRequest();

            using (HttpResponseMessage response = client.PostAsJsonAsync<SchoolyearCreateRequest>(baseAddress + "api/schoolyears", req).Result)
            {
                Assert.IsNotNull(response.Content);
                Assert.IsNotNull(response.Content.Headers.ContentType);
                Assert.AreEqual<string>("application/json; charset=utf-8", response.Content.Headers.ContentType.ToString());

                SchoolyearCreateRequest recSCR = response.Content.ReadAsAsync<SchoolyearCreateRequest>().Result;

                //todo: verify data
            }
        }

        private void RegisterMockDependencies(HttpConfiguration config)
        {
            var unity = new UnityContainer();

            unity.RegisterType<ISchoolyearService, MockSchoolyearService>();

            config.DependencyResolver = new UnityDependencyResolver(unity);
        }
    }

    [RoutePrefix("api/schoolyears")]
    public class SchoolyearController : ApiController
    {
        private readonly ISchoolyearService _service;
        public SchoolyearController(ISchoolyearService service)
        {
            _service = service;
        }

        [Route]
        [HttpPost]
        public HttpResponseMessage Post([FromBody]SchoolyearCreateRequest request)
        {
            _service.CreateSchoolyear(request);
            return Request.CreateResponse(HttpStatusCode.Created);
        }
    }

    public class InMemoryHttpContentSerializationHandler : DelegatingHandler
    {
        public InMemoryHttpContentSerializationHandler(HttpMessageHandler innerHandler)
            : base(innerHandler)
        {
        }

        protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            request.Content = await ConvertToStreamContentAsync(request.Content);

            HttpResponseMessage response = await base.SendAsync(request, cancellationToken);

            response.Content = await ConvertToStreamContentAsync(response.Content);

            return response;
        }

        private async Task<StreamContent> ConvertToStreamContentAsync(HttpContent originalContent)
        {
            if (originalContent == null)
            {
                return null;
            }

            StreamContent streamContent = originalContent as StreamContent;

            if (streamContent != null)
            {
                return streamContent;
            }

            MemoryStream ms = new MemoryStream();

            await originalContent.CopyToAsync(ms);

            // Reset the stream position back to 0 as in the previous CopyToAsync() call,
            // a formatter for example, could have made the position to be at the end
            ms.Position = 0;

            streamContent = new StreamContent(ms);

            // copy headers from the original content
            foreach (KeyValuePair<string, IEnumerable<string>> header in originalContent.Headers)
            {
                streamContent.Headers.TryAddWithoutValidation(header.Key, header.Value);
            }

            return streamContent;
        }
    }
}