Partilhar via

Teste de unidade de bibliotecas F# no .NET Core usando o teste dotnet e xUnit

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. Se preferir seguir o tutorial usando uma solução pré-construída, baixe ou visualize o código de exemplo antes de começar. Para obter instruções de download, consulte Exemplos e Tutoriais.

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.

Criando 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 dotnet new sln para criar uma nova solução. Isso facilita o gerenciamento da biblioteca de classes e do projeto de teste de unidade. Dentro do diretório da solução, crie um diretório MathService. O diretório e a estrutura de arquivos até agora são mostrados abaixo:

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

Torne MathService o diretório atual e execute dotnet new classlib -lang "F#" para criar o projeto de origem. Você criará uma implementação falhada do serviço de matemática.

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

Volte para o diretório unit-testing-with-fsharp. Execute dotnet sln add .\MathService\MathService.fsproj para adicionar o projeto de biblioteca de classes à solução.

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

Torne o diretório MathService.Tests o diretório atual e crie um novo projeto usando dotnet new xunit -lang "F#". Isso cria um projeto de teste que usa xUnit como a biblioteca de teste. O modelo gerado configura o executor de testes no projeto 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>

O projeto de teste requer outros pacotes para criar e executar testes de unidade. dotnet new na etapa anterior adicionou xUnit e o executor xUnit. 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

Você pode ver o arquivo inteiro no repositório de amostras no GitHub.

Você tem o seguinte layout de solução final:

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

Execute dotnet sln add .\MathService.Tests\MathService.Tests.fsproj no diretório dentro do diretório unit-testing-with-fsharp.

Criando o primeiro teste

Escreve um teste que falha, faz com que passe, depois repete o processo. Abra Tests.fs e adicione o seguinte código:

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

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

O atributo [<Fact>] indica um método de teste que é executado pelo executor de teste. A partir do unit-testing-with-fsharp, execute dotnet test para construir os testes e a biblioteca de classes e, em seguida, execute os testes. O executor de teste xUnit contém o ponto de entrada do programa para executar seus testes. dotnet test inicia o executor de teste usando o projeto de teste de unidade que você criou.

Estes dois testes mostram os testes mais básicos de aprovação e reprovação. My test passa e Fail every time 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. Fazer com que cada teste seja aprovado significa criar a funcionalidade necessária para o método.

O teste mais simples que podemos escrever é chamar squaresOfOdds com todos os números pares, onde o resultado deve ser uma sequência vazia de inteiros. Aqui está esse teste:

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

O seu teste falha. Você ainda não criou a implementação. Faça este teste passar escrevendo o código mais simples na classe 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 uma compilação para o projeto MathService e, em seguida, para o projeto MathService.Tests. Depois de compilar ambos os projetos, ele executa este teste único. Passa.

Preenchimento dos 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. Aqui está o próximo teste:

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

A execução de dotnet test realiza os testes e mostra que o novo teste falha. Agora, atualize o squaresOfOdds método para lidar com esse novo teste. Você filtra todos os números pares da sequência para fazer esse 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:

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

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