¡Yeehaw, compañero desarrollador! Hay un nuevo sheriff en Testing Town, y su nombre es TUnit. Este recién llegado promete poner orden en el salvaje oeste de las pruebas unitarias en .NET 8. ¿Estás listo para un duelo de frameworks? ¡Desenfunda tu teclado y prepárate!

TLDR (Resumen)

  • TUnit es un nuevo framework de pruebas unitarias para .NET 8
  • Se basa en NUnit y XUnit, pero está optimizado para .NET 8
  • Ofrece una sintaxis fluida y expresiva para las aserciones
  • Ejecuta pruebas en paralelo por defecto
  • Es más rápido que NUnit y XUnit
  • Proporciona mensajes de error claros y fáciles de entender
  • Permite pruebas orientadas a datos con el atributo Arguments
  • Está disponible como paquete NuGet y es compatible con Visual Studio, Rider y VS Code
  • Visita TUnit para saber más

¿Quién es este forastero llamado TUnit?

TUnit no es un forastero en Testing Town. Se basa en lo mejor de NUnit y XUnit pero renuncia a los problemas que pueden dar las compatibilidades con versiones antiguas de .NET. Solo está disponible a partir de la versión 8 ya que está creado sobre la nueva plataforma de testing de Microsoft (Microsoft.Testing.Platform) y eso hace que tus pruebas se ejecuten más rápido que el mejor corcel que hayas visto jamás.

Pruebas unitarias, de integración, de aceptación... nada hace temblar a nuestro sheriff.

Puedes encontrarlo tanto para las últimas versiones de Visual Studio como en Rider o VS Code como paquete NuGet: Tunit nuget

TUnit en acción: Limpiando las calles de Testing Town

Pero basta de palabrería. Ha llegado la hora de ver cómo es y de qué es capaz TUnit.

Esta es una prueba unitaria sencilla donde nuestro sheriff capturará a Billy el Niño y obtendrá 10.000$ de recompensa por ello.

using TUnit.Assertions;
using TUnit.Assertions.Extensions;
using TUnit.Core;

public class SheriffTests
{
    [Test]
    public async Task CapturarBandido_BandidoConocido_DeberiaAumentarRecompensa()
    {
        // Arrange
        var sheriff = new Sheriff("Wyatt Earp");
        var bandido = new Bandido("Billy the Kid", recompensa: 10000);

        // Act
        var result = sheriff.CapturarBandido(bandido);

        // Assert
        await Assert.That(result.Recompensa).IsEqualTo(10000);
    }        
}
  • Si te fijas, TUnit sigue usando el patrón AAA (Arrange, Act y Assert) que usamos en el resto de frameworks de testing.
  • Los Assert usan una sintaxis fluida para que sea mucho más claro y legible qué están validando.

  • Y aunque aquí solo tenemos una prueba, las pruebas se lanzan por defecto siempre en paralelo. Si alguna de tus pruebas no debe ser lanzada de forma paralela necesitas añadir el atributo [NotInParallel] en ella.

    [Test, NotInParallel] public async Task CapturarBandido_BandidoConocido_DeberiaAumentarRecompensa()

Las armas del nuevo sheriff: Assertions de TUnit

Todo buen sheriff necesita un arsenal, y TUnit no se queda corto. En el ejemplo anterior ya has conocido a That y a IsEqualTo pero aquí tenemos a unos cuantos más:

  • IsNullOrEmpty()
  • IsNullOrWhitespace()
  • IsNotNull()
  • IsPositive()
  • ThrowsException()

Hay muchos más e incluso si no encuentras el que necesitas puedes crear tus propios Assert heredando de la clase AssertCondition<TActual, TExpected> donde TActual es el objeto a ser validado y TExpected el valor esperado.

Sobreescribe el método Passes con la validación que necesitas realizar: private protected override bool Passes(TActual? actualValue, Exception? exception)

Y el método GetFailureMessage para mostrar el mensaje de error que necesitas protected internal override string GetFailureMessage()

Otro punto interesante es que puedes crear validaciones más complejas o completas con las propiedades And y Or

[Test]
public async Task MyTest()
{
    var result = 1 + 2;

    await Assert.That(result)
        .IsNotNull()
        .And.IsPositive()
        .And.IsEqualTo(3);
}

¡Que me aspen si esto no merece un buen trago de zarzaparrilla!

El gran duelo: TUnit vs NUnit vs xUnit

Característica TUnit NUnit xUnit
Sintaxis Fluida y expresiva Tradicional Moderna pero menos expresiva
Velocidad 🚀🚀🚀 🚀🚀 🚀🚀
Curva de aprendizaje Suave como un whisky añejo Familiar como un viejo revólver Algo complicada al principio
Integración .NET 8 Perfecta como un traje a medida Buena Buena
Mensajes de error Claros como el agua del río A veces crípticos Mejores que NUnit
Comunidad Pequeña pero creciendo Grande y establecida Grande y activa
Plugins Pocos pero potentes Abundantes Moderados

¿Por qué TUnit es el nuevo sheriff que necesitamos?

  1. Sintaxis que enamora: Escribir tests con TUnit es tan satisfactorio como ganar un duelo al mediodía. Simple, sencillo y usando sintaxis fluida.

    [Test] public void Banco_RetirarDinero_DeberiaReducirSaldo() { var cuenta = new CuentaBancaria(saldoInicial: 100); cuenta.RetirarDinero(50); cuenta.Saldo.That().IsEqual(50); }

  2. Velocidad de vaquero: Tus tests correrán más rápido que un ladrón de bancos perseguido por la ley.

Method Mean Error StdDev
TUnit_AOT 239.1 ms 17.49 ms 51.58 ms
TUnit 598.0 ms 22.00 ms 64.88 ms
NUnit 14,188.5 ms 282.69 ms 495.11 ms
xUnit 14,397.4 ms 285.65 ms 684.40 ms
MSTest 14,396.9 ms 285.20 ms 370.85 ms

  1. Mensajes de error que hablan tu idioma: Nada de jeroglíficos. TUnit te dice qué pasó con la claridad de un predicador de domingo.

  2. Pruebas orientadas a datos: Repite tus pruebas tantas veces como quieras con un set de datos distintos sin volverte loco usando el atributo Arguments.

    [Test] [Arguments(1, 1, 2)] [Arguments(1, 2, 3)] [Arguments(2, 2, 4)] [Arguments(4, 3, 7)] [Arguments(5, 5, 10)] public async Task MyTest(int value1, int value2, int expectedResult) { var result = value1 + value2; await Assert.That(result).IsEqualTo(expectedResult); }

Conclusión: ¿Estás listo para unirte a la nueva ley en Testing Town?

TUnit no es solo otro framework de testing, es una revolución en el salvaje oeste del desarrollo. Es rápido, intuitivo y más divertido que un rodeo en sábado por la noche.

NUnit y xUnit son como esos viejos alguaciles que han mantenido la paz durante años. Respetables, confiables, pero quizás un poco cansados. TUnit es el nuevo sheriff en la ciudad, trayendo ideas frescas y una actitud que hace que probar tu código sea más emocionante que un tiroteo al atardecer. Es cierto que es nuevo en la ciudad y necesitará un tiempo para ver si se asienta y se gana el respeto que merece.

Así que, ¿qué dices, vaquero? ¿Estás listo para colgar tu vieja placa de NUnit o xUnit y unirte a la nueva ley en Testing Town? TUnit te está esperando, y juntos, harán que los bugs tiemblen de miedo al oír sus pasos.

¿Y tú? ¿Te atreves a desenfundar TUnit en tu próximo proyecto? ¿O seguirás aferrado a tu viejo confiable como un vaquero a su caballo favorito?

Recuerda: en Testing Town, la única ley es la calidad del código. Y con TUnit como tu ayudante, esa ley se cumplirá... ¡a rajatabla!

Si quieres saber más sobre él revisa su página: TUnit o si te ves con ánimo de ser ayudante del sheriff prueba a hacer tus aportaciones al repositorio de Git del proyecto Repositorio