Teste de unidade de bibliotecas F# usando dotnet test e TUnit

Este tutorial guia você por uma experiência interativa de construção de uma solução de exemplo passo a passo para aprender conceitos de teste de unidade.

Este artigo é sobre como testar um projeto do .NET Core. Se você estiver testando um projeto do 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 de sua escolha.

O TUnit é criado inteiramente em Microsoft.Testing.Platform (MTP) e não dá suporte ao VSTest. Este tutorial usa o modo MTP dedotnet test, que requer o SDK .NET 10.

Criar o projeto de origem

Abra uma janela do shell. Crie um diretório chamado unit-testing-with-fsharp para manter 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 . A estrutura de diretório e arquivos até agora é a seguinte:

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

Torne o 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 de matemática:

namespace MathService

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

Altere o diretório de volta 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 seguinte esquema mostra a estrutura do diretório:

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

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

dotnet new install TUnit.Templates

Torne o diretório MathService.Tests o diretório atual e crie um novo projeto usando o seguinte comando:

dotnet new TUnit -lang "F#"

Note

Nomes curtos de modelo diferenciam maiúsculas de minúsculas. Use TUnit, não tunit.

Esse comando cria um projeto de teste que usa o TUnit como o framework de teste. O arquivo MathService.Tests.fsproj gerado é um projeto executável que faz referência ao pacote TUnit, que inclui o framework de teste, a biblioteca de asserções e o executor de testes MTP, e ao pacote TUnit.Assertions.FSharp, que adiciona auxiliares de F# para asserções.

O modelo também adiciona testes de exemplo. Este tutorial os substitui por seus próprios testes em Tests.fs. Exclua o diretório Data e os arquivos GlobalSetup.fs, Tests2.fs e Tests3.fs. Os projetos F# listam explicitamente seus arquivos de origem, portanto, substitua também o ItemGroup que contém os Compile itens em MathService.Tests.fsproj com o seguinte:

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

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

dotnet reference add ../MathService/MathService.fsproj

O esboço a seguir mostra o esquema 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 dá suporte ao VSTest, dotnet test deve ser executado em seu modo MTP. No diretório unit-testing-with-fsharp , crie um arquivo global.json com o seguinte conteúdo:

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

Para obter mais informações, consulte modo MTP do dotnet test.

Criar o primeiro teste

Você escreve um teste com falha, faz com que ele passe e repita o processo. Substitua o conteúdo de 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 [<Test>] atributo indica um método de teste executado pelo executor de teste. O TUnit descobre métodos de teste que são membros de uma classe; ele não descobre funções declaradas com let em um módulo. As asserções do TUnit são assíncronas. A taskAssert expressão de computação de TUnit.Assertions.FSharp executa um teste como uma tarefa e permite aguardar cada asserção com do!.

No 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 do TUnit contém o ponto de entrada do programa para executar seus testes. dotnet test inicia o aplicativo de teste usando o projeto de teste de unidade que você criou.

Esses dois testes mostram testes com aprovação e falha mais básicos. TestMethodPassing passa e FailEveryTime falha. Agora, crie um teste para o squaresOfOdds método. 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 gravar todas essas funções de uma só vez, você pode criar testes iterativamente que validem a funcionalidade. Para que cada teste seja aprovado, crie a funcionalidade necessária para o método.

O teste mais simples que você pode escrever é chamar squaresOfOdds com todos os números pares, em que o resultado deve ser uma sequência vazia de inteiros. Adicione o seguinte teste ao 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# é mais estrito que C# quando resolve sobrecargas de método, portanto, o teste passa o tipo de item para Assert.That<int> para selecionar as asserções para uma sequência de inteiros. IsEquivalentTo verifica se ambas as sequências contêm os mesmos itens.

Ao executar o teste, você verá que o teste falha. Isso ocorre porque você ainda não criou a implementação. Faça esse teste passar escrevendo o código mais simples no arquivo Library.fs em seu projeto MathService que funciona:

let squaresOfOdds xs =
    Seq.empty<int>

No diretório unit-testing-with-fsharp , execute dotnet test novamente. O comando dotnet test executa um build para o projeto MathService e, em seguida, para o projeto MathService.Tests. Depois de compilar os dois projetos, ele executa os seus testes. Agora, dois testes são aprovados.

Cumprir 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 de dotnet test falha no novo teste. Você deve atualizar o squaresOfOdds método para lidar com esse novo teste. Você deve filtrar todos os números par da sequência para fazer esse teste passar. Você pode fazer isso escrevendo uma função de filtro pequena e usando Seq.filter:

let private isOdd x = x % 2 <> 0

let squaresOfOdds xs =
    xs
    |> Seq.filter isOdd

Há mais um passo a percorrer: acertar cada um dos números ímpares. Comece escrevendo 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 redirecionando a sequência filtrada por meio 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 das metas do aplicativo.

Consulte também

  • Última atualização em