« Voltar
em ASP.NET Web API OWIN

Hosteando uma ASP.NET Web API dentro de uma Console Application usando OWIN.

O ASP.NET Web API atualmente é a forma mais simples de se desenvolver um web service REST com ASP.NET.

Mas e se eu quiser escrever testes para a minha API, como faço?
Quando criamos um projeto do tipo web application no Visual Studio, temos a opção de criar um projeto só para testes:
Ao selecionarmos essa configuração, um projeto adicional é criado em nossa solução:
Nesse projeto, escreveremos testes unitários para nossa API. Algo como:

    [TestClass]
    public class UnitTest1
    {
        [TestMethod]
        public void TestaQueOMetodoDevolveUmPost()
        {
            PostController controller = new PostController();
            HttpResponseMessage resposta = controller.Get(1);

            //testa se a resposta está ok
        }
    }

Nesse caso, estamos instanciando o controller e testando se a resposta dos métodos estão de acordo com o que esperamos. Isso é ok quando queremos fazer testes de unidade, mas e se quisermos fazer algo um pouco diferente: testar as requisições mesmo, e não os métodos. Ou seja: subir o servidor e simular uma requisição para o mesmo. Usando código C#.
Até um tempo atrás, se quisesse testar as requisições a solução seria: executar a aplicação Web API e com a aplicação rodando no Visual Studio, rodar os testes ou testar usando Fiddler ou algum outro tipo de ferramenta.

Introduzindo o OWIN

OWIN é uma interface criada para desacoplar as aplicações web do servidor. Sendo assim, podemos rodá-las fora do IIS, de forma independente.

Vamos aprender como fazer isso!

Vamos fazer uma API bem simples que supostamente devolve a lista de posts de um suposto blog. Pra esse exemplo estou usando o Visual Studio 2013 Community
Vamos criar uma aplicação do tipo ConsoleApplication e vamos chamá-la de BlogAPI:
Precisamos agora adicionar as referências para o OWIN e Web API:
1- vá ao menu Tools;
2- clique em Library Package Manager;
3- em seguida Package Manager Console.

Na janela Package Manager Console, digite:
Install-Package Microsoft.AspNet.WebApi.OwinSelfHost

E dê enter. Pode demorar um pouquinho pra instalar tudo.

Em seguida, vamos configurar a aplicação pra que consigamos "hospedar" a web API dentro da aplicação. Adicione ao projeto uma classe chamada Startup:
Coloque dentro da classe o seguinte código(importando namespaces Owin e System.Web.Http:

namespace BlogAPI  
{
    public class Startup
    {
        public void Configuration(IAppBuilder appBuilder)
        {
            // Configura a Web API pra self-host. 
            HttpConfiguration config = new HttpConfiguration();
            config.MapHttpAttributeRoutes();
            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );
            appBuilder.UseWebApi(config);
        } 
    }
}

Nesse código, configuramos a Web API e definimos uma rota padrão para nossa aplicação. A configuração de rotas na Web API funciona da mesma forma que no ASP.NET MVC. Se ficar com dúvidas, dê uma olhada em como as rotas funcionam.

Agora vamos adicionar um controler Web API!
Somente para seguir a convenção, crie uma pasta chamada Controllers dentro do projeto:
Adicione dentro dessa pasta uma classe chamada PostController:
Transforme essa classe em um Web API Controller fazendo-a herdar de ApiController(terá que importar o namespace System.Web.Http):

namespace BlogAPI.Controllers  
{
    public class PostController : ApiController
    {

    }
}

Agora, vamos criar os métodos da nossa API!
Como essa API é só para testarmos, retornaremos valores fixos e estamos supondo que os posts serão somente strings. Se fosse um projeto de verdade, provavelmente teríamos uma classe que representaria o Post. Nosso controller fica assim:

namespace BlogAPI.Controllers  
{
    public class PostController : ApiController
    {
        [HttpGet]
        [Route("api/posts")]
        public HttpResponseMessage Get()
        {
            IList<string> posts = new List<string>()
            {
                "Conteudo do post 1",
                "Conteudo do post 2"
            };

            return Request.CreateResponse(HttpStatusCode.OK, posts);
        }

        [HttpGet]
        [Route("api/posts/{1}")]
        public HttpResponseMessage Get(int id)
        {
            string post = "Conteudo do post";
            return Request.CreateResponse(HttpStatusCode.OK, post);
        }
    }
}

Agora, na classe Program(que é o ponto de entrada da nossa aplicação) vamos modificar o método Main para inicializar nosso host OWIN da seguinte forma(temos que importar o namespace Microsoft.Owin.Hosting:

namespace BlogAPI  
{
    class Program
    {
        static void Main(string[] args)
        {
            string enderecoBase = "http://localhost:9000/";

            using (WebApp.Start<Startup>(url: enderecoBase))
            {

            }
        }
    }
}

Pronto!
Agora, dentro desse using podemos fazer requisições e tratar respostas usando a classe HttpClient. Vamos fazer uma requisição para o método Get do nosso PostController:

namespace BlogAPI  
{
    class Program
    {
        static void Main(string[] args)
        {
            string enderecoBase = "http://localhost:9000/";

            using (WebApp.Start<Startup>(url: enderecoBase))
            {
                HttpClient client = new HttpClient();

                var reposta = client.GetAsync(enderecoBase + "api/posts").Result;

                Console.WriteLine(reposta);
                Console.WriteLine(reposta.Content.ReadAsStringAsync().Result);

                Console.ReadLine();
            }
        }
    }
}

Quando rodamos a aplicação, imprimimos o resultado de nossa requisição no Console:
Podemos testar o outro método:

namespace BlogAPI  
{
    class Program
    {
        static void Main(string[] args)
        {
            string enderecoBase = "http://localhost:9000/";

            using (WebApp.Start<Startup>(url: enderecoBase))
            {
                HttpClient client = new HttpClient();

                var reposta = client.GetAsync(enderecoBase + "api/posts/1").Result;

                Console.WriteLine(reposta);
                Console.WriteLine(reposta.Content.ReadAsStringAsync().Result);

                Console.ReadLine();
            }
        }
    }
}

Legal, não?

Tenha em mente que essa não é a forma correta de escrever testes para a sua aplicação.

Esse tipo de aplicação é útil em protótipos, quando você quer testar a sua API sem ter que depender de um servidor.

E ai, que achou? Ficou alguma dúvida, alguma sugestão?
Quer saber mais sobre WEB Api? Sobre OWIN? Sobre qualquer outra coisa relacionada à .NET?

Deixa seu comentário aí (:

comments powered by Disqus