Testes unitários de bibliotecas F# usando dotnet test e TUnit

Este tutorial leva você através de uma experiência interativa criando uma solução de exemplo passo a passo para aprender conceitos de teste de unidade.

Este artigo é sobre como testar um projeto .NET Core. Se você estiver testando um projeto ASP.NET Core, consulte Testes de integração no ASP.NET Core.

Prerequisites

  • .NET 10 SDK ou versões posteriores.
  • Um editor de texto ou editor de código da sua preferência.

O TUnit é totalmente construído em Microsoft.Testing.Platform (MTP) e não suporta VSTest. Este tutorial utiliza o modo MTP de dotnet test, que requer o SDK .NET 10.

Criar o projeto de origem

Abra uma janela de terminal. Crie um diretório chamado unit-testing-with-fsharp para armazenar a solução. Dentro desse novo diretório, execute o seguinte comando para criar um novo arquivo de solução para a biblioteca de classes e o projeto de teste:

dotnet new sln

Em seguida, crie um diretório MathService . O seguinte esboço apresenta o diretório e a estrutura de ficheiros até agora:

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

Torne MathService o diretório atual e execute o seguinte comando para criar o projeto de origem:

dotnet new classlib -lang "F#"

Substitua o conteúdo do Library.fs por uma implementação com falha do serviço matemático:

namespace MathService

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

Volte para o diretório unit-testing-with-fsharp. Execute o seguinte comando para adicionar o projeto de biblioteca de classes à solução:

dotnet sln add ./MathService/MathService.fsproj

Criar o projeto de teste

Em seguida, crie o diretório MathService.Tests. O esquema a seguir mostra a estrutura de diretórios:

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

Os modelos de projeto TUnit não estão incluídos no SDK .NET. Instale-os com o seguinte comando:

dotnet new install TUnit.Templates

Faça do diretório MathService.Tests o diretório atual e crie um novo projeto usando o seguinte comando:

dotnet new TUnit -lang "F#"

Note

Os nomes curtos do modelo são sensíveis a maiúsculas e minúsculas. Use TUnit, não tunit.

Este comando cria um projeto de teste que utiliza o TUnit como framework de teste. O ficheiro gerado MathService.Tests.fsproj é um projeto executável que faz referência ao pacote TUnit, incluindo o framework de teste, a biblioteca de asserções, o executor de testes MTP, e o pacote TUnit.Assertions.FSharp, que adiciona ajudantes em F# para as asserções.

O modelo também adiciona testes de exemplo. Este tutorial substitui-os pelos seus próprios testes no Tests.fs. Apague o diretório Data e os ficheiros GlobalSetup.fs, Tests2.fs e Tests3.fs . Os projetos F# listam explicitamente os seus ficheiros fonte, por isso substitua também o ItemGroup que contém os itens Compile em MathService.Tests.fsproj pelos seguintes:

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

Agora, adicione a biblioteca de classes MathService como outra dependência ao projeto. Utilize o comando dotnet reference add:

dotnet reference add ../MathService/MathService.fsproj

O esquema a seguir mostra o layout final da solução.

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

Execute o seguinte comando no diretório unit-testing-with-fsharp :

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

Configurar o modo MTP do dotnet test

Como o TUnit não suporta VSTest, dotnet test tem de correr no seu modo MTP. No diretório unit-testing-with-fsharp , crie um ficheiro global.json com o seguinte conteúdo:

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

Para mais informações, veja o modo MTP do dotnet test.

Criar o primeiro teste

Escreve um teste que falha, faz com que passe, depois repete o processo. Substitua o conteúdo do Tests.fs pelo seguinte código:

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()
    }

O atributo [<Test>] indica um método de teste que é executado pelo executor de teste. O TUnit descobre métodos de teste que são membros de uma classe; não descobre funções que são declaradas com let num módulo. As asserções TUnit são assíncronas. A taskAssert expressão de computação de TUnit.Assertions.FSharp executa um teste como tarefa e permite-lhe aguardar cada asserção com do!.

A partir do diretório unit-testing-with-fsharp, execute dotnet test para criar os testes e a biblioteca de classes e, em seguida, execute os testes. O projeto de teste TUnit contém o ponto de entrada do programa para executar os seus testes. dotnet test Inicia a aplicação de teste usando o projeto de teste unitário que criaste.

Estes dois testes mostram os testes mais básicos de aprovação e reprovação. TestMethodPassing passa e FailEveryTime falha. Agora, crie um teste para o método squaresOfOdds. O squaresOfOdds método retorna uma sequência dos quadrados de todos os valores inteiros ímpares que fazem parte da sequência de entrada. Em vez de tentar escrever todas essas funções de uma só vez, você pode criar iterativamente testes que validam a funcionalidade. Para que cada teste passe, cria a funcionalidade necessária para o método.

O teste mais simples que pode escrever é chamar squaresOfOdds com todos os números pares, devendo resultar numa sequência vazia de inteiros. Adicione o seguinte teste ao tipo TestClass:

[<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# é mais rigoroso do que C# quando resolve sobrecargas de métodos, pelo que o teste passa o tipo de item para Assert.That<int> selecionar as asserções para uma sequência de inteiros. IsEquivalentTo verifica se ambas as sequências contêm os mesmos itens.

Quando você executa o teste, você vê que o teste falha. Isso porque você ainda não criou a implementação. Faça este teste passar escrevendo o código mais simples no ficheiro Library.fs do seu projeto MathService que funcione:

let squaresOfOdds xs =
    Seq.empty<int>

No diretório unit-testing-with-fsharp, execute dotnet test novamente. O comando dotnet test executa uma compilação para o projeto MathService e, em seguida, para o projeto MathService.Tests. Depois de construir ambos os projetos, ele executa seus testes. Dois testes passam agora.

Preencha os requisitos

Agora que você fez um teste aprovado, é hora de escrever mais. O próximo caso simples funciona com uma sequência cujo único número ímpar é 1. O número 1 é mais fácil porque o quadrado de 1 é 1. Este é o próximo teste:

[<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)
}

A execução dotnet test falha no(s) novo(s) teste(s). Você deve atualizar o método squaresOfOdds para manipular esse novo teste. Você deve filtrar todos os números pares fora da sequência para fazer este teste passar. Você pode fazer isso escrevendo uma pequena função de filtro e usando Seq.filter:

let private isOdd x = x % 2 <> 0

let squaresOfOdds xs =
    xs
    |> Seq.filter isOdd

Há mais um passo a percorrer: quadrar cada um dos números ímpares. Comece por escrever um novo teste:

[<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)
}

Você pode corrigir o teste canalizando a sequência filtrada através de uma operação de mapa para calcular o quadrado de cada número ímpar:

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

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

Você criou uma pequena biblioteca e um conjunto de testes unitários para essa biblioteca. Você estruturou a solução para que a adição de novos pacotes e testes faça parte do fluxo de trabalho normal. Você concentrou a maior parte do seu tempo e esforço na resolução dos objetivos do aplicativo.

Ver também