¿Cómo mejorar la calidad de tus APIs mediante pruebas unitarias eficaces?

En el desarrollo de software, las pruebas unitarias juegan un papel fundamental en la construcción de aplicaciones robustas y de alta calidad. Sin embargo, para que estas pruebas sean verdaderamente útiles, deben ser ejecutadas de manera eficiente, con un enfoque claro hacia la detección temprana de errores y la garantía de que los módulos individuales del sistema se comportan como se espera. A lo largo de este capítulo, exploraremos cómo llevar a cabo pruebas unitarias de manera eficiente y cómo elegir las herramientas adecuadas para maximizar su efectividad.

El siguiente paso en el proceso de pruebas unitarias es la planificación y ejecución de las pruebas sobre la unidad de trabajo, también conocida como SUT (System Under Test). Para garantizar que las pruebas sean efectivas, se debe contar con un enfoque sistemático que implique la escritura de pruebas para cada caso de uso relevante del sistema. Comenzar con pruebas simples y luego expandirlas a escenarios más complejos es una buena práctica que ayuda a cubrir una amplia gama de comportamientos posibles sin perderse en detalles innecesarios desde el principio. La ejecución de las pruebas debe hacerse de manera continua para asegurar que cualquier cambio en el código no rompa funcionalidades previamente implementadas.

En el proceso de escritura de pruebas unitarias, un aspecto crítico es la capacidad de aislar las unidades individuales que se están probando. Para lograrlo, es común utilizar técnicas como el mocking o el uso de dependencias falsas. Estas prácticas permiten simular el comportamiento de componentes externos sin tener que depender de su implementación real, lo que ayuda a reducir el tiempo necesario para ejecutar las pruebas y mejora su fiabilidad. Además, el uso de frameworks como Moq o NSubstitute facilita enormemente este proceso al proporcionar una manera sencilla de crear objetos simulados con comportamientos predefinidos.

Es importante no subestimar la importancia de la organización de las pruebas unitarias. Una buena organización permite que las pruebas sean más fáciles de mantener, comprender y actualizar a medida que el código evoluciona. Las pruebas deben estar claramente estructuradas y agrupadas según el módulo o funcionalidad que se esté probando. Asimismo, cada prueba debe ser independiente, de modo que su ejecución no dependa de otras pruebas previas. Este principio es esencial para asegurar que las pruebas sean predecibles y no introduzcan errores adicionales en el sistema.

Otro factor a considerar en el desarrollo de pruebas unitarias es la cobertura de pruebas. Aunque alcanzar una cobertura del 100% puede ser una meta atractiva, en la práctica no siempre es necesario ni eficiente. En lugar de enfocarse únicamente en la cobertura total, los desarrolladores deben asegurarse de que las pruebas cubren las rutas de ejecución más críticas y los casos de borde. Esto garantiza que el sistema sea probado en sus puntos más vulnerables sin necesidad de realizar pruebas redundantes o innecesarias.

Finalmente, es importante que las pruebas unitarias no sean vistas como una tarea aislada, sino como una parte integral del ciclo de vida del desarrollo del software. Integrar las pruebas unitarias dentro de un proceso de integración continua (CI) y entrega continua (CD) permite detectar errores en las etapas más tempranas del ciclo de desarrollo. Esto, a su vez, acelera el proceso de desarrollo al evitar que los errores se acumulen en fases posteriores, lo que puede resultar en costosos refactoreos o incluso en fallos catastróficos en producción.

Es fundamental que el equipo de desarrollo mantenga una mentalidad de mejora continua cuando se trata de pruebas unitarias. Las pruebas no solo sirven para verificar que el sistema funciona correctamente, sino también para proporcionar una base sólida sobre la cual se puede evolucionar el software de manera controlada. Los errores encontrados durante las pruebas unitarias deben ser analizados no solo para corregir los fallos inmediatos, sino para entender mejor la arquitectura del sistema y mejorar los procesos de desarrollo a largo plazo.

Además de la implementación técnica de las pruebas unitarias, es importante considerar la comunicación con los stakeholders del proyecto, como los responsables de calidad o los gestores de producto. Asegurarse de que todos comprendan la importancia de las pruebas unitarias y cómo contribuyen a la estabilidad y fiabilidad del sistema es un paso clave para fomentar una cultura de calidad dentro del equipo de desarrollo. La colaboración entre todos los involucrados en el proceso de creación del software contribuye al éxito a largo plazo del proyecto.

Para profundizar aún más en la calidad de las pruebas unitarias, es recomendable complementar esta práctica con pruebas de integración y pruebas funcionales. Las pruebas unitarias por sí solas no son suficientes para garantizar la fiabilidad del sistema, ya que no cubren interacciones complejas entre componentes. Por lo tanto, deben ser vistas como una parte de un enfoque integral de pruebas que aborde diferentes niveles del sistema y sus interacciones.

¿Cómo Acceder a Datos de Manera Segura y Eficiente Usando HTTP y Refit?

El acceso a datos a través de HTTP se maneja comúnmente mediante la clase HttpClient en .NET. A través de esta clase, se pueden realizar solicitudes de tipo GET, POST, PUT, DELETE, entre otras, a APIs externas. Sin embargo, aunque HttpClient es muy útil, su uso incorrecto puede afectar seriamente el rendimiento de la aplicación, sobre todo si no se gestionan adecuadamente las instancias de HttpMessageHandler, que es la clase responsable de manejar las solicitudes HTTP.

Por ejemplo, crear una nueva instancia de HttpClient para cada solicitud puede llevar a un agotamiento de los sockets disponibles, lo que resulta en fallos de red y ralentización en las respuestas de la API. Para evitar este problema, .NET ofrece una interfaz llamada IHttpClientFactory, que gestiona la reutilización de instancias de HttpClient y, por ende, optimiza el consumo de recursos.

En la siguiente sección, se verá cómo utilizar IHttpClientFactory de manera eficiente y cómo esta práctica puede combinarse con la biblioteca Refit para facilitar aún más el trabajo con servicios HTTP.

Implementación de IHttpClientFactory

La interfaz IHttpClientFactory fue introducida en .NET Core 1 y ha sido parte integral de .NET desde entonces. Su propósito es centralizar la creación y configuración de instancias de HttpClient, lo que permite un control más preciso sobre los recursos de red utilizados por una aplicación.

Para empezar a usar IHttpClientFactory, es necesario instalar el paquete Microsoft.Extensions.Http. Después, se debe agregar la configuración correspondiente en el archivo Program.cs para registrar la fábrica de clientes HTTP en el contenedor de dependencias. A partir de ahí, se pueden crear instancias de HttpClient de manera más controlada, lo que optimiza las conexiones de red y mejora el rendimiento global.

csharp
Copy code
namespace Domain.Repositories
{
    public interface IMediaRepository
    {

        Task<(byte[] Content, string MimeType)> GetCountryFlagContent(string countryShortName);

    }
}

A continuación, se muestra la implementación de la clase MediaRepository:

csharp
Copy code
using Domain.Repositories;
namespace Infrastructure.Http.Repositories
{

    public class MediaRepository : IMediaRepository

    {
        private readonly IHttpClientFactory _httpClientFactory;
        public MediaRepository(IHttpClientFactory httpClientFactory)
        {
            _httpClientFactory = httpClientFactory;
        }
        public async Task<(byte[] Content, string MimeType)> GetCountryFlagContent(string countryShortName)
        {
            byte[] fileBytes;
            using HttpClient client = _httpClientFactory.CreateClient();

            fileBytes = await client.GetByteArrayAsync($"https://anthonygiretti.blob.core.windows.net/countryflags/{countryShortName}.png");

            return (fileBytes, "image/png");
        }
    }
}

Uso de Refit para Optimizar las Solicitudes HTTP

A pesar de las mejoras que IHttpClientFactory aporta, el trabajo con solicitudes HTTP puede ser aún más eficiente utilizando bibliotecas como Refit. Refit permite crear clientes HTTP tipados de manera dinámica, lo que reduce la necesidad de escribir código repetitivo y mejora la claridad del código. Con Refit, solo es necesario definir interfaces con los métodos correspondientes y las rutas de las API que se desean consumir.

Para integrar Refit, primero debemos instalar el paquete Refit. Luego, se declara una interfaz que define los métodos de acceso a la API utilizando atributos específicos de HTTP, como [Get] o [Post]. A continuación, mostramos cómo se puede modificar la interfaz IMediaRepository utilizando Refit para acceder a las banderas de los países:

csharp
Copy code
using Refit;

namespace Domain.Repositories
{
    public interface IMediaRepository
    {
        [Get("/countryflags/{countryShortName}.png")]
        Task<byte[]> GetCountryFlagContent(string countryShortName);
    }
}

En este caso, la URL base del servicio se configura por separado, y solo es necesario indicar la ruta y el verbo HTTP en el atributo [Get]. Refit se encarga del resto, incluyendo la creación del cliente HTTP tipado y la ejecución de la solicitud.

Aspectos Adicionales a Tener en Cuenta

El uso de IHttpClientFactory y Refit es solo una parte de la optimización del acceso a los datos. A pesar de estas herramientas, es fundamental comprender la importancia de la gestión de excepciones y la implementación de estrategias de reintento en las solicitudes HTTP, ya que las redes pueden ser inestables. Las aplicaciones deben ser resilientes ante fallos temporales de red o servidores no disponibles. Una estrategia común es usar Polly, una biblioteca para manejar la resiliencia y los reintentos, integrándola con IHttpClientFactory.

También es importante destacar que el uso de IHttpClientFactory y Refit permite una mayor flexibilidad y escalabilidad en las aplicaciones, especialmente cuando se interactúa con múltiples servicios externos. Mantener la simplicidad del código y evitar la repetición de configuraciones es clave para el mantenimiento a largo plazo de sistemas complejos.