Pruebas unitarias de bibliotecas de F# 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-with-fsharp 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 MathService . En el esquema siguiente se muestra la estructura de directorios y archivos hasta ahora:

/unit-testing-with-fsharp
    unit-testing-with-fsharp.slnx
    /MathService

Convierta MathService en el directorio actual y ejecute el siguiente comando para crear el proyecto de origen:

dotnet new classlib -lang "F#"

Reemplace el contenido de Library.fs por una implementación con error del servicio matemático:

namespace MathService

module MyMath =
    let squaresOfOdds (xs: int seq) : int seq = raise (System.NotImplementedException("You haven't written a test yet!"))

Cambie de nuevo al directorio unit-testing-with-fsharp. Ejecute el siguiente comando para agregar el proyecto de biblioteca de clases a la solución:

dotnet sln add ./MathService/MathService.fsproj

Creación del proyecto de prueba

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

/unit-testing-with-fsharp
    unit-testing-with-fsharp.slnx
    /MathService
        Source Files
        MathService.fsproj
    /MathService.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

Convierta el directorio MathService.Tests en el directorio actual y cree un nuevo proyecto con el comando siguiente:

dotnet new TUnit -lang "F#"

Note

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

Este comando crea un proyecto de prueba que usa TUnit como marco de pruebas. El archivo MathService.Tests.fsproj 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, y el TUnit.Assertions.FSharp paquete, que agrega asistentes de F# para aserciones.

La plantilla también agrega pruebas de ejemplo. En este tutorial, se reemplazan por sus propias pruebas en Tests.fs. Elimine el directorio Data y los archivos GlobalSetup.fs, Tests2.fs y Tests3.fs . Los proyectos de F# enumeran sus archivos de origen explícitamente, por lo que también debe reemplazar el ItemGroup que contiene los elementos Compile de MathService.Tests.fsproj por lo siguiente:

<ItemGroup>
  <Compile Include="Tests.fs" />
</ItemGroup>

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

dotnet reference add ../MathService/MathService.fsproj

En el esquema siguiente se muestra el diseño final de la solución:

/unit-testing-with-fsharp
    unit-testing-with-fsharp.slnx
    /MathService
        Source Files
        MathService.fsproj
    /MathService.Tests
        Test Source Files
        MathService.Tests.fsproj

Ejecute el siguiente comando en el directorio unit-testing-with-fsharp :

dotnet sln add ./MathService.Tests/MathService.Tests.fsproj

Configurar el modo MTP de dotnet test

Dado que TUnit no admite VSTest, dotnet test debe ejecutarse en su modo MTP. En el directorio unit-testing-with-fsharp , 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. Reemplace el contenido de Tests.fs por el código siguiente:

namespace MathService.Tests

open TUnit.Core
open TUnit.Assertions
open TUnit.Assertions.Extensions
open TUnit.Assertions.FSharp.TaskAssert
open MathService

type TestClass () =

    [<Test>]
    member this.TestMethodPassing() = taskAssert {
        do! Assert.That(true).IsTrue()
    }

    [<Test>]
    member this.FailEveryTime() = taskAssert {
        do! Assert.That(false).IsTrue()
    }

El [<Test>] atributo denota un método de prueba que ejecuta el ejecutor de pruebas. TUnit detecta métodos de prueba que son miembros de una clase; no detecta funciones declaradas con let en un módulo. Las aserciones de TUnit son asincrónicas. La taskAssert expresión de cálculo de TUnit.Assertions.FSharp ejecuta una prueba como una tarea y le permite esperar cada aserción con do!.

En el directorio unit-testing-with-fsharp , 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 mediante el proyecto de prueba unitaria que ha creado.

Estas dos pruebas muestran las pruebas superadas y con errores más básicas. TestMethodPassing indica que se supera y FailEveryTime indica que no. Ahora, cree una prueba para el squaresOfOdds método . El squaresOfOdds método devuelve una secuencia de los cuadrados de todos los valores enteros impares que forman parte de la secuencia de entrada. En lugar de intentar escribir todas esas funciones a la vez, puede crear pruebas iterativamente que validen la funcionalidad. Para que cada prueba pase, creas la funcionalidad necesaria para el método.

La prueba más sencilla que puede escribir es llamar a squaresOfOdds con todos los números pares, donde el resultado debe ser una secuencia vacía de enteros. Agregue la prueba siguiente al TestClass tipo :

[<Test>]
member this.TestEvenSequence() = taskAssert {
    let expected = Seq.empty<int>
    let actual = MyMath.squaresOfOdds [2; 4; 6; 8; 10]
    do! Assert.That<int>(actual).IsEquivalentTo(expected)
}

F# es más estricto que C# cuando resuelve sobrecargas de método, por lo que la prueba pasa el tipo de elemento a Assert.That<int> para seleccionar las aserciones de una secuencia de enteros. IsEquivalentTo comprueba que ambas secuencias contienen los mismos elementos.

Al ejecutar la prueba, verá que se produce un error en la prueba. Esto se debe a que aún no ha creado la implementación. Haga que esta prueba pase escribiendo el código más sencillo que funcione en el archivo Library.fs del proyecto MathService:

let squaresOfOdds xs =
    Seq.empty<int>

En el directorio unit-testing-with-fsharp, vuelva a ejecutar dotnet test. El comando dotnet test ejecuta una compilación para el proyecto de MathService y, a continuación, para el proyecto de MathService.Tests. Después de compilar ambos proyectos, las pruebas se ejecutan. Ahora se superan dos pruebas.

Completar los requisitos

Ahora que la prueba se ha superado, es el momento de escribir más. El siguiente caso sencillo funciona con una secuencia cuyo único número impar es 1. El número 1 es más fácil porque el cuadrado de 1 es 1. Esta es la siguiente prueba:

[<Test>]
member public this.TestOnesAndEvens() = taskAssert {
    let expected = [1; 1; 1; 1]
    let actual = MyMath.squaresOfOdds [2; 1; 4; 1; 6; 1; 8; 1; 10]
    do! Assert.That<int>(actual).IsEquivalentTo(expected)
}

La ejecución de dotnet test falla en la nueva prueba. Debe actualizar el squaresOfOdds método para controlar esta nueva prueba. Debe filtrar todos los números pares de la secuencia para pasar esta prueba. Para ello, escriba una función de filtro pequeña y use Seq.filter:

let private isOdd x = x % 2 <> 0

let squaresOfOdds xs =
    xs
    |> Seq.filter isOdd

Queda un paso más por hacer: cuadrar cada uno de los números impares. Comience escribiendo una prueba nueva:

[<Test>]
member public this.TestSquaresOfOdds() = taskAssert {
    let expected = [1; 9; 25; 49; 81]
    let actual = MyMath.squaresOfOdds [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
    do! Assert.That<int>(actual).IsEquivalentTo(expected)
}

Puede corregir la prueba si canaliza la secuencia filtrada a través de una operación de asignación para calcular el cuadrado de cada número impar:

let private square x = x * x
let private isOdd x = x % 2 <> 0

let squaresOfOdds xs =
    xs
    |> Seq.filter isOdd
    |> Seq.map square

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