controlador WebAPI Prueba Url.Link

Question

Tengo el siguiente acción del controlador

public void Post(Dto model) 
{ 
    using (var message = new MailMessage()) 
    { 
     var link = Url.Link("ConfirmAccount", new { model.Id }); 

     message.To.Add(model.ToAddress); 
     message.IsBodyHtml = true; 
     message.Body = string.Format(@"<p>Click <a href=""{0}"">here</a> to complete your registration.<p><p>You may also copy and paste this link into your browser.</p><p>{0}</p>", link); 

     MailClient.Send(message); 
    } 
} 

Para probar esto necesito para configurar el controlador de contexto

var httpConfiguration = new HttpConfiguration(new HttpRouteCollection { { "ConfirmAccount", new HttpRoute() } }); 
var httpRouteData = new HttpRouteData(httpConfiguration.Routes.First()); 
var httpRequestMessage = new HttpRequestMessage(HttpMethod.Post, "http://localhost"); 
sut = new TheController 
{ 
    ControllerContext = new HttpControllerContext(httpConfiguration, httpRouteData, httpRequestMessage), 
    MailClient = new SmtpClient { PickupDirectoryLocation = location } 
}; 

Esto parece como un montón de configuración para probar la creación de un enlace. ¿Hay una manera más limpia de hacer esto? He leído acerca de los servidores en memoria, pero parece que se aplica más al httpclient que al controlador directamente.

Answer 1

Me encuentro con la misma estupidez. Todas las referencias que puedo encontrar le piden que se burle de la Solicitud/Controlador, que es (como usted señaló) un montón de trabajo.

referencias específicas:

• http://aspnetwebstack.codeplex.com/discussions/358709/
• http://www.peterprovost.org/blog/2012/06/16/unit-testing-asp-dot-net-web-api/#testing-the-harder-stuff-postproduct
• ASP.NET MVC Controller Unit Testing - Problem with UrlHelper Extension
• ASP.NET MVC: Unit testing controllers that use UrlHelper
• el resto de internet

No he intentado probar los frameworks de Mocking, así que tengo una clase de ayuda para "construir" mi controlador. Así que en lugar de

sut = new TheController { ... } 

utilizo algo como:

// actually rolled together to `sut = MyTestSetup.GetController(method, url)` 
sut = new TheController()... 
MyTestSetup.FakeRequest(sut, HttpMethod.Whatever, "~/the/expected/url"); 

Como referencia, el método es básicamente:

public void FakeRequest(ApiController controller, HttpMethod method = null, string requestUrl = null, string controllerName = null) { 
    HttpConfiguration config = new HttpConfiguration(); 
    // rebuild the expected request 
    var request = new HttpRequestMessage(null == method ? this.requestMethod : method, string.IsNullOrWhiteSpace(requestUrl) ? this.requestUrl : requestUrl); 
    //var route = System.Web.Routing.RouteTable.Routes["DefaultApi"]; 
    var route = config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}"); 

    // TODO: get from application? maybe like https://stackoverflow.com/a/5943810/1037948 
    var routeData = new HttpRouteData(route, new HttpRouteValueDictionary { { "controller", string.IsNullOrWhiteSpace(controllerName) ? this.requestController : controllerName } }); 

    controller.ControllerContext = new HttpControllerContext(config, routeData, request); 

    // attach fake request 
    controller.Request = request; 
    controller.Request.Properties[/* "MS_HttpConfiguration" */ HttpPropertyKeys.HttpConfigurationKey] = config; 
} 

Answer 2

A continuación se muestra el código mínimo absoluto requerido para probar UrlHelper sin ningún tipo de la biblioteca burlona. Lo que me arrojó (y me llevó algo de tiempo rastrear) fue que debes establecer el IHttpRouteData de la solicitud. Si no lo hace, la instancia IHttpRoute no generará una ruta virtual que dé como resultado una URL vacía.

public class FooController : ApiController 
    { 
     public string Get() 
     { 
      return Url.Link(RouteNames.DefaultRoute, new { controller = "foo", id = "10" }); 
     } 
    } 

    [TestFixture] 
    public class FooControllerTests 
    { 
     FooController controller; 

     [SetUp] 
     public void SetUp() 
     { 
      var config = new HttpConfiguration(); 

      config.Routes.MapHttpRoute(
       name: "Default", 
       routeTemplate: "api/{controller}/{id}", 
       defaults: new { id = RouteParameter.Optional }); 

      var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost"); 
      request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config; 
      request.Properties[HttpPropertyKeys.HttpRouteDataKey] = new HttpRouteData(new HttpRoute()); 

      controller = new FooController 
      { 
       Request = request 
      }; 
     } 

     [Test] 
     public void Get_returns_link() 
     { 
      Assert.That(controller.Get(), Is.EqualTo("http://localhost/api/foo/10")); 
     } 
    } 

Answer 3

Comencé a utilizar este enfoque con Web API 2.0.

Si está utilizando una biblioteca de burlas (y realmente debería hacer pruebas en unidades del mundo real), puede burlarse directamente del objeto UrlHelper ya que todos los métodos que contiene son virtual.

var mock = new Mock<UrlHelper>(); 
mock.Setup(m => m.Link(It.IsAny<string>(), It.IsAny<object>())).Returns("test url"); 

var controller = new FooController { 
    Url = mock.Object 
}; 

Esta es una solución mucho más limpia que la respuesta de Ben Foster, al igual que con ese enfoque, es necesario agregar rutas a la configuración para cada nombre que está utilizando. Eso podría cambiar fácilmente o ser una cantidad ridículamente grande de rutas para configurar.