Compartir a través de

Pruebas unitarias de bibliotecas de F# en .NET Core mediante dotnet test y xUnit

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. Si prefiere seguir el tutorial con una solución precompilada, vea o descargue el código de ejemplo antes de comenzar. Para obtener instrucciones de descarga, consulte Ejemplos y tutoriales.

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.

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 dotnet new sln para crear una nueva solución. Esto facilita la administración de la biblioteca de clases y el proyecto de prueba unitaria. Dentro del directorio de la solución, cree un directorio MathService . A continuación se muestra la estructura de directorios y archivos:

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

Convierta MathService en el directorio actual y ejecute dotnet new classlib -lang "F#" para crear el proyecto de origen. Creará una implementación de errores del servicio de matemáticas:

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

Cambie de nuevo al directorio unit-testing-with-fsharp. Ejecute dotnet sln add .\MathService\MathService.fsproj para agregar el proyecto de biblioteca de clases a la solución.

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.sln
    /MathService
        Source Files
        MathService.fsproj
    /MathService.Tests

Convierta el directorio MathService.Tests en el directorio actual y cree un nuevo proyecto mediante dotnet new xunit -lang "F#". Esto crea un proyecto de prueba que usa xUnit como biblioteca de pruebas. La plantilla generada configura el ejecutor de pruebas en MathServiceTests.fsproj:

<ItemGroup>
  <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.3.0-preview-20170628-02" />
  <PackageReference Include="xunit" Version="2.2.0" />
  <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
</ItemGroup>

El proyecto de prueba requiere otros paquetes para crear y ejecutar pruebas unitarias. dotnet new en el paso anterior se agregó xUnit y el ejecutor xUnit. Ahora, agregue la biblioteca de clases MathService como otra dependencia al proyecto. Use el comando dotnet reference add:

dotnet reference add ../MathService/MathService.fsproj

Puede ver todo el archivo en el repositorio de ejemplos de en GitHub.

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

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

Ejecute dotnet sln add .\MathService.Tests\MathService.Tests.fsproj en el directorio unit-testing-with-fsharp .

Creación de la primera prueba

Escriba una prueba que falla, hágala pasar, y luego repita el proceso. Abra Tests.fs y agregue el código siguiente:

[<Fact>]
let ``My test`` () =
    Assert.True(true)

[<Fact>]
let ``Fail every time`` () = Assert.True(false)

El [<Fact>] atributo denota un método de prueba que ejecuta el ejecutor de pruebas. En unit-testing-with-fsharp, ejecute dotnet test para compilar las pruebas y la biblioteca de clases y, a continuación, ejecute las pruebas. El ejecutor de pruebas xUnit contiene el punto de entrada del programa para ejecutar las pruebas. dotnet test inicia el ejecutor de pruebas mediante el proyecto de prueba unitaria que ha creado.

Estas dos pruebas muestran las pruebas superadas y con errores más básicas. My test indica que se supera y Fail every time 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. Lograr que cada prueba pase significa crear la funcionalidad necesaria para el método.

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

[<Fact>]
let ``Sequence of Evens returns empty collection`` () =
    let expected = Seq.empty<int>
    let actual = MyMath.squaresOfOdds [2; 4; 6; 8; 10]
    Assert.Equal<Collections.Generic.IEnumerable<int>>(expected, actual)

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 MathService clase que funciona:

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, ejecuta esta única prueba. Pasa.

Finalización de 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:

[<Fact>]
let ``Sequences of Ones and Evens returns Ones`` () =
    let expected = [1; 1; 1; 1]
    let actual = MyMath.squaresOfOdds [2; 1; 4; 1; 6; 1; 8; 1; 10]
    Assert.Equal<Collections.Generic.IEnumerable<int>>(expected, actual)

La ejecución de dotnet test ejecuta las pruebas y muestra que se produce un error en la nueva prueba. Ahora, actualice el squaresOfOdds método para controlar esta nueva prueba. Filtras todos los números pares de la secuencia para que esta prueba pase. 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:

[<Fact>]
let ``SquaresOfOdds works`` () =
    let expected = [1; 9; 25; 49; 81]
    let actual = MyMath.squaresOfOdds [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
    Assert.Equal(expected, actual)

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