Testování jednotek knihoven F# pomocí dotnet test a TUnit

Tento kurz vás provede interaktivním prostředím a podrobným sestavením ukázkového řešení, kde se seznámíte s koncepty testování jednotek.

Tento článek se týká testování projektu .NET Core. Pokud testujete projekt ASP.NET Core, přečtěte si téma Integrační testy v ASP.NET Core.

Prerequisites

  • .NET 10 SDK nebo novější verze.
  • Textový editor nebo editor kódu podle vašeho výběru.

TUnit je postaven zcela na Microsoft.Testing.Platform (MTP) a nepodporuje VSTest. Tento kurz používá režim MTP dotnet test, který vyžaduje .NET 10 SDK.

Vytvoření zdrojového projektu

Otevřete okno příkazového řádku. Vytvořte adresář s názvem unit-testing-with-fsharp pro uložení řešení. V tomto novém adresáři spusťte následující příkaz, který vytvoří nový soubor řešení pro knihovnu tříd a testovací projekt:

dotnet new sln

Dále vytvořte adresář MathService . Následující osnova ukazuje zatím strukturu adresářů a souborů:

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

Nastavte MathService jako aktuální adresář a spuštěním následujícího příkazu vytvořte zdrojový projekt:

dotnet new classlib -lang "F#"

Obsah knihovny Library.fs nahraďte neúspěšnou implementací matematické služby:

namespace MathService

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

Změňte adresář zpět na adresář unit-testing-with-fsharp . Spuštěním následujícího příkazu přidejte do řešení projekt knihovny tříd:

dotnet sln add ./MathService/MathService.fsproj

Vytvoření testovacího projektu

Dále vytvořte adresář MathService.Tests . Následující osnova ukazuje adresářovou strukturu:

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

Šablony projektů TUnit nejsou součástí sady .NET SDK. Nainstalujte je pomocí následujícího příkazu:

dotnet new install TUnit.Templates

Vytvořte adresář MathService.Tests jako aktuální adresář a vytvořte nový projekt pomocí následujícího příkazu:

dotnet new TUnit -lang "F#"

Note

V krátkých názvech šablon se rozlišují malá a velká písmena. Použít TUnit, ne tunit.

Tento příkaz vytvoří testovací projekt, který používá TUnit jako testovací framework. Vygenerovaný soubor MathService.Tests.fsproj je spustitelný projekt, který odkazuje na balíček TUnit, který obsahuje testovací rozhraní, knihovnu kontrolních výrazů a spouštěč testů MTP, a na balíček TUnit.Assertions.FSharp, který přidává pomocné rutiny jazyka F# pro kontrolní výrazy.

Šablona také přidá ukázkové testy. Tento kurz je nahradí vlastními testy v Tests.fs. Odstraňte adresář Data a soubory GlobalSetup.fs, Tests2.fs a Tests3.fs. Projekty F# vypisují zdrojové soubory explicitně, proto také nahraďte ItemGroup, který obsahuje položky Compile, v souboru MathService.Tests.fsproj následujícím kódem:

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

Teď do projektu přidejte knihovnu tříd MathService jako jinou závislost. Použijte příkaz dotnet reference add:

dotnet reference add ../MathService/MathService.fsproj

Následující osnova ukazuje konečné rozložení řešení:

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

V adresáři unit-testing-with-fsharp spusťte následující příkaz:

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

Nakonfigurujte režim MTP pro dotnet test

Vzhledem k tomu, že TUnit nepodporuje VSTest, dotnet test musí běžet v režimu MTP. V adresáři unit-testing-with-fsharp vytvořte soubor global.json s následujícím obsahem:

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

Další informace najdete v části režim MTP dotnet test.

Vytvoření prvního testu

Napíšete jeden neúspěšný test, uděláte ho úspěšným, a pak tento proces zopakujete. Obsah Tests.fs nahraďte následujícím kódem:

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

Atribut [<Test>] označuje testovací metodu, kterou spouští spouštěč testů. TUnit zjišťuje testovací metody, které jsou členy třídy; nezjišťuje funkce, které jsou deklarovány pomocí let v modulu. Aserce TUnit jsou asynchronní. Výpočetní taskAssert výraz z TUnit.Assertions.FSharp spouští test jako úlohu a umožňuje čekat na každou aserci pomocí do!.

Z adresáře unit-testing-with-fsharp spusťte dotnet test pro sestavení testů a knihovny tříd a poté testy spusťte. Projekt testu TUnit obsahuje vstupní bod programu pro spuštění testů. dotnet test spustí testovací aplikaci pomocí projektu testování jednotek, který jste vytvořili.

Tyto dva testy ukazují ty nejzákladnější testy, které prošly a neprošly. TestMethodPassing projde a FailEveryTime selže. Teď vytvořte test pro metodu squaresOfOdds . Metoda squaresOfOdds vrátí sekvenci čtverců všech lichých celočíselných hodnot, které jsou součástí vstupní sekvence. Místo toho, abyste se pokusili najednou napsat všechny tyto funkce, můžete iterativním způsobem vytvořit testy, které funkci ověřují. K úspěšnému provedení každého testu vytvoříte pro metodu potřebnou funkčnost.

Nejjednodušším testem, který můžete napsat, je volat squaresOfOdds se všemi sudými čísly, kde by výsledek měl být prázdná posloupnost celých čísel. Do TestClass typu přidejte následující test:

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

Jazyk F# je při řešení přetížení metody přísnější než jazyk C#, takže test předá typ položky do Assert.That<int> pro výběr asercí pro posloupnost celých čísel. IsEquivalentTo kontroluje, zda obě sekvence obsahují stejné položky.

Když test spustíte, uvidíte, že váš test selže. Je to proto, že jste ještě nevytvořili implementaci. Nechte tento test projít tím, že napíšete nejjednodušší kód, který funguje, do souboru Library.fs v projektu MathService:

let squaresOfOdds xs =
    Seq.empty<int>

V adresáři unit-testing-with-fsharp spusťte dotnet test znovu. Příkaz dotnet test spustí sestavení projektu MathService a poté projektu MathService.Tests. Po sestavení obou projektů spustí testy. Nyní prošly dva testy.

Splnění požadavků

Nyní, když jste úspěšně prošli jedním testem, je čas napsat více testů. Další jednoduchý případ funguje se sekvencí, jejíž jediné liché číslo je 1. Číslo 1 je jednodušší, protože čtverec 1 je 1. Tady je další test:

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

Spuštění dotnet test selže při novém testu. Chcete-li tento nový test zpracovat, je nutné aktualizovat metodu squaresOfOdds . Aby test prošel, musíte odebrat všechna sudá čísla ze sekvence. Můžete to udělat tak, že napíšete malou funkci filtru a použijete Seq.filter:

let private isOdd x = x % 2 <> 0

let squaresOfOdds xs =
    xs
    |> Seq.filter isOdd

Existuje ještě jeden krok: umocněte každé z lichých čísel. Začněte napsáním nového testu:

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

Test můžete opravit propojením filtrované sekvence pomocí operace mapování pro výpočet čtverce každého lichého čísla:

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

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

Vytvořili jste malou knihovnu a sadu jednotkových testů pro tuto knihovnu. Řešení jste strukturují tak, aby přidání nových balíčků a testů bylo součástí normálního pracovního postupu. Většinu času a úsilí jste se zaměřili na řešení cílů aplikace.

Viz také

  • Poslední aktualizace v