Este artículo es un complemento para el tutorial sobre Test-Driven Development (TDD) en .NET. A continuación, te guiaré paso a paso para la configuración del proyecto de pruebas, de esta forma, nos aseguraremos que puedas seguir el tutorial sin contratiempos y centrarte en aprender TDD de manera efectiva.

Para comenzar nuestro proyecto y asegurarnos de avanzar correctamente, te invito a realizar micro commits por cada pequeño paso que demos. Sin más que agregar, ¡comencemos!

En el proyecto de ejemplo, utilizo .NET 8, pero este proceso también es aplicable a .NET 6 o .NET 7. Las características iniciales del proyecto incluyen .NET 8, C#, xUnit, y los paquetes NuGet FluentAssertions y NSubstitute.

Puedes crear el proyecto desde tu IDE favorito o desde la interfaz de línea de comandos. Los siguientes comandos te permitirán configurar el proyecto paso a paso en la terminal. Utiliza los checkboxes para llevar un seguimiento de tu progreso:

• Crea un proyecto de pruebas unitarias con xUnit:

  dotnet new xunit -f net8.0 -n Loan.Domain.Tests -o tests/Loan.Domain.Tests

  Este comando establece un nuevo proyecto de pruebas unitarias que usará xUnit, configurado para .NET 8 y lo ubicará en el directorio tests/Loan.Domain.Tests

• Genera un proyecto de tipo Class Library:

  dotnet new classlib -f net8.0 -n Loan.Domain -o source/Loan.Domain

  Aquí estamos creando una classlib de .NET 8, que se ubicará en source/Loan.Domain, donde desarrollaremos la lógica negocios para nuestra aplicación.

• Inicia una nueva solución de proyecto para .NET:

  dotnet new sln -n Loan

  Este comando crea un archivo de solución .sln con nombre Loan para agrupar y manejar todos los proyectos relacionados con la aplicación.

• Añade el proyecto de pruebas a la solución:

  dotnet sln add ./tests/Loan.Domain.Tests/Loan.Domain.Tests.csproj

  Esto incluye el proyecto de pruebas unitarias en la solución, lo que nos permite gestionar todas las dependencias y compilaciones desde un único punto.

• Incorpora el proyecto de consola a la solución:

  dotnet sln add ./source/Loan.Domain/Loan.Domain.csproj

  Al igual que el proyecto de pruebas, añadimos el proyecto de consola a la solución para facilitar la administración y el desarrollo simultáneos.

Si prefieres ejecutar todo en una sola instrucción para ahorrar tiempo, puedes utilizar la siguiente secuencia de comandos:

dotnet new xunit -f net8.0 -n Loan.Domain.Tests -o tests/Loan.Domain.Tests && \
dotnet new classlib -f net8.0 -n Loan.Domain -o source/Loan.Domain && \
dotnet new sln -n Loan && \
dotnet sln add ./tests/Loan.Domain.Tests/Loan.Domain.Tests.csproj && \
dotnet sln add ./source/Loan.Domain/Loan.Domain.csproj

Esta secuencia concatenará todos los comandos anteriores en una sola línea, ejecutándolos uno tras otro, siempre y cuando cada comando se ejecute sin errores.

Como mencionamos antes, vamos a mantener la práctica de realizar micro commits. En particular, me gusta mucho utilizar gitmoji para los commits, considero que ofrecen mucha información y adicionalmente se ven muy bonitos 😊. Puedes ver los más populares visitando este enlace: gitmoji.dev

Sigamos adelante añadiendo nuestro archivo .gitignore, utilizando el template estándar de dotnet, y activemos nuestro repositorio GIT. Puedes hacerlo desde la línea de comandos utilizando los siguientes comandos:

• Agrega el archivo.gitignore con la plantilla de .NET:

  dotnet new gitignore

  Este comando genera un archivo .gitignore óptimo para proyectos .NET, excluyendo archivos innecesarios del control de versiones.

• Inicializa tu repositorio Git:

  git init

  Con esto creamos un nuevo repositorio Git local en nuestro proyecto.

• Prepara los archivos para el commit:

  git add .

  Este comando incluye todos los archivos del directorio actual en el área de preparación de Git.

• Realiza el commit inicial con gitmoji:

  git commit -m "🎉 Initial project setup."

  Aquí efectuamos nuestro primer commit, utilizando el gitmoji 🎉 para simbolizar el comienzo entusiasta de nuestro proyecto.

O si prefieres puedes ejecutar todo en una sola instrucción:

dotnet new gitignore && \
git init && \
git add . && \
git commit -m "🎉 Initial project setup."

Es hora de agregar algunas herramientas esenciales para el testing. En TDD, las afirmaciones son cruciales y para eso, vamos a utilizar FluentAssertions, una biblioteca que nos permite escribir pruebas de una manera más natural y legible. También integraremos NSubstitute, un framework de mocking que facilita la creación de objetos falsos para nuestras pruebas.

Vamos a añadir estas herramientas a nuestro proyecto de pruebas y a la par seguiremos poniendo en práctica nuestros micro commits con los siguientes comandos:

• Incluir FluentAssertions en el proyecto de pruebas:

  dotnet add ./tests/TDD.Tests/TDD.Tests.csproj package FluentAssertions -v 6.12.0

  Este comando agrega la versión 6.12.0 de FluentAssertions como dependencia en nuestro proyecto de pruebas, permitiéndonos utilizar sus potentes capacidades de assertions.

• Añadir NSubstitute al proyecto de pruebas:

  dotnet add ./tests/TDD.Tests/TDD.Tests.csproj package NSubstitute -v 5.1.0

  Al ejecutar este comando, incorporamos la versión 5.1.0 de NSubstitute a nuestro proyecto de pruebas, dándonos acceso a herramientas de mocking eficientes y fáciles de usar.

• Ejecutamos un commit con la incorporación de nuestros Nugets:

git commit -m "📦️ Add packages FluentAssertions and NSubstitute" -m "- FluentAssertions package for enhanced assertion capabilities." -m "- NSubstitute for mocking dependencies in unit tests."

Para simplificar el proceso y ejecutar todos los comandos consecutivamente, puedes utilizar la siguiente instrucción combinada en tu terminal:

dotnet add ./tests/TDD.Tests/TDD.Tests.csproj package FluentAssertions -v 6.12.0 && \
dotnet add ./tests/TDD.Tests/TDD.Tests.csproj package NSubstitute -v 5.1.0 && \
git commit -am "📦️ Add packages FluentAssertions and NSubstitute" -m "- FluentAssertions package for enhanced assertion capabilities." -m "- NSubstitute for mocking dependencies in unit tests."

Conclusión

Hemos dedicado tiempo y esfuerzo a preparar nuestro entorno para TDD, una inversión que no debe subestimarse. La configuración cuidadosa es crucial, ya que nos permite implementar TDD de manera efectiva en proyectos de software.