Pruebas unitarias de bibliotecas de Visual Basic .NET mediante dotnet test y TUnit

Este tutorial le lleva a través de una experiencia interactiva que crea una solución de ejemplo paso a paso para aprender conceptos de pruebas unitarias.

En este artículo se trata de probar un proyecto de .NET Core. Si vas a probar un proyecto de ASP.NET Core, consulta Pruebas de integración en ASP.NET Core.

Prerequisites

  • .NET 10 SDK o versiones posteriores.
  • El editor de texto o de código que elija.

TUnit se basa completamente en Microsoft. Testing.Platform (MTP) y no admite VSTest. En este tutorial se usa el modo MTP de dotnet test, que requiere el SDK de .NET 10.

Creación del proyecto de origen

Abra una ventana de terminal. Cree un directorio denominado unit-testing-vb-tunit para contener la solución. Dentro de este nuevo directorio, ejecute el siguiente comando para crear un nuevo archivo de solución para la biblioteca de clases y el proyecto de prueba:

dotnet new sln

A continuación, cree un directorio PrimeService. En el esquema siguiente se muestra la estructura de archivos hasta ahora:

/unit-testing-vb-tunit
    unit-testing-vb-tunit.slnx
    /PrimeService

Haga de PrimeService como el directorio actual y ejecute el siguiente comando para crear el proyecto fuente:

dotnet new classlib -lang VB

Cambie el nombre de Class1.vb a PrimeService.vb. Crea una implementación fallida de la clase PrimeService.

Namespace Prime.Services
    Public Class PrimeService
        Public Function IsPrime(candidate As Integer) As Boolean
            Throw New NotImplementedException("Please create a test first.")
        End Function
    End Class
End Namespace

Vuelva a cambiar el directorio al directorio unit-testing-vb-tunit . Ejecute el siguiente comando para agregar el proyecto de biblioteca de clases a la solución:

dotnet sln add ./PrimeService/PrimeService.vbproj

Creación del proyecto de prueba

A continuación, cree el directorio PrimeService.Tests. En el esquema siguiente se muestra la estructura de directorios:

/unit-testing-vb-tunit
    unit-testing-vb-tunit.slnx
    /PrimeService
        Source Files
        PrimeService.vbproj
    /PrimeService.Tests

Las plantillas de proyecto de TUnit no se incluyen en el SDK de .NET. Instálelos con el siguiente comando:

dotnet new install TUnit.Templates

Establezca el directorio PrimeService.Tests como el directorio actual y cree un nuevo proyecto con el siguiente comando:

dotnet new TUnit -lang VB

Note

Los nombres cortos de plantilla distinguen mayúsculas de minúsculas. Usa TUnit, no tunit.

El comando dotnet new crea un proyecto de prueba que usa TUnit como biblioteca de pruebas. El archivo PrimeService.Tests.vbproj generado es un proyecto ejecutable que hace referencia al TUnit paquete, que incluye el marco de pruebas, la biblioteca de aserciones y el ejecutor de pruebas de MTP, por lo que el proyecto no necesita ningún otro paquete de prueba.

La plantilla también agrega pruebas de ejemplo. Elimine todos los archivos .vb y el directorio Data del directorio PrimeService.Tests , ya que este tutorial los reemplaza por sus propias pruebas.

Ahora, agregue la biblioteca de clases PrimeService como otra dependencia al proyecto. Use el comando dotnet reference add:

dotnet reference add ../PrimeService/PrimeService.vbproj

Tiene el siguiente diseño de solución final:

/unit-testing-vb-tunit
    unit-testing-vb-tunit.slnx
    /PrimeService
        Source Files
        PrimeService.vbproj
    /PrimeService.Tests
        Test Source Files
        PrimeService.Tests.vbproj

Ejecute el siguiente comando en el directorio unit-testing-vb-tunit :

dotnet sln add ./PrimeService.Tests/PrimeService.Tests.vbproj

Configuración del modo MTP de dotnet test

Dado que TUnit no admite VSTest, dotnet test debe ejecutarse en su modo MTP. En el directorio unit-testing-vb-tunit , cree un archivo global.json con el siguiente contenido:

{
    "test": {
        "runner": "Microsoft.Testing.Platform"
    }
}

Para obtener más información, consulte el modo MTP de dotnet test.

Creación de la primera prueba

Escriba una prueba que falla, hágala pasar, y luego repita el proceso. En el directorio PrimeService.Tests , cree un archivo PrimeService_IsPrimeShould.vb con el código siguiente:

Imports TUnit.Assertions
Imports TUnit.Assertions.Extensions
Imports TUnit.Core

Namespace PrimeService.Tests
    Public Class PrimeService_IsPrimeShould
        Private ReadOnly _primeService As Prime.Services.PrimeService = New Prime.Services.PrimeService()

        <Test>
        Public Async Function IsPrime_InputIs1_ReturnFalse() As Task
            Dim result As Boolean = _primeService.IsPrime(1)

            Await Assert.That(result).IsFalse()
        End Function

    End Class
End Namespace

El atributo <Test> denota un método ejecutado por el ejecutor de pruebas. TUnit no necesita un atributo en la clase . Las aserciones de TUnit son asincrónicas, por lo que la prueba es una Async Function que devuelve una Task y espera a Assert.That.

Visual Basic coloca el código en cada proyecto en el espacio de nombres raíz del proyecto, por lo que la PrimeService clase está en el PrimeService.Prime.Services espacio de nombres. La prueba hace referencia a ella como Prime.Services.PrimeService porque, dentro de los espacios de nombres del proyecto de prueba, el nombre PrimeService hace referencia a un espacio de nombres en lugar de a la clase .

En el directorio unit-testing-vb-tunit , ejecute dotnet test para compilar las pruebas y la biblioteca de clases y, a continuación, ejecute las pruebas. El proyecto de prueba TUnit contiene el punto de entrada del programa para ejecutar las pruebas. dotnet test inicia la aplicación de prueba con el proyecto de prueba unitaria que ha creado.

Se produce un error en la prueba. Todavía no ha creado la implementación. Haga que esta prueba pase escribiendo el código más sencillo en la PrimeService clase que funciona:

Public Function IsPrime(candidate As Integer) As Boolean
    If candidate = 1 Then
        Return False
    End If
    Throw New NotImplementedException("Please create a test first.")
End Function

En el directorio unit-testing-vb-tunit, vuelva a ejecutar dotnet test. El comando dotnet test ejecuta una compilación para el proyecto de PrimeService y, a continuación, para el proyecto de PrimeService.Tests. Después de compilar ambos proyectos, ejecuta esta única prueba. Pasa.

Adición de más características

Ahora que la prueba se ha superado, es el momento de escribir más. Hay algunos otros casos simples para números primos: 0, -1. Puede agregar esos casos como nuevas pruebas con el atributo <Test>, pero eso se vuelve tedioso. TUnit proporciona el <Arguments> atributo para crear un conjunto de pruebas que ejecutan el mismo código, pero tienen argumentos de entrada diferentes.

En lugar de crear nuevas pruebas, aplique este atributo para crear una única prueba controlada por datos. Reemplace la IsPrime_InputIs1_ReturnFalse función por el código siguiente, que prueba varios valores inferiores a dos, el número primo más bajo:

<Test>
<Arguments(-1)>
<Arguments(0)>
<Arguments(1)>
Public Async Function IsPrime_ValuesLessThan2_ReturnFalse(value As Integer) As Task
    Dim result As Boolean = _primeService.IsPrime(value)

    Await Assert.That(result).IsFalse()
End Function

Ejecute dotnet testy dos de estas pruebas fallan. Para que se superen todas las pruebas, cambie la If cláusula al principio del método IsPrime en el archivo PrimeService.vb:

If candidate < 2 Then

Siga iterando agregando más pruebas y más código en la biblioteca principal.

Has creado una pequeña biblioteca y una suite de pruebas unitarias para esa biblioteca. Ha estructurado la solución para que la adición de nuevos paquetes y pruebas forme parte del flujo de trabajo normal. Ha concentrado la mayor parte de su tiempo y esfuerzo en resolver los objetivos de la aplicación.

Consulte también

  • Se actualizó por última vez el