Unit-Tests für F#-Bibliotheken mit dotnet test und TUnit

Dieses Tutorial führt Sie interaktiv Schritt für Schritt durch das Erstellen einer Beispielprojektmappe, um die Konzepte von Komponententests zu erlernen.

In diesem Artikel wird ein .NET Core-Projekt getestet. Wenn Sie ein ASP.NET Core-Projekt testen, finden Sie weitere Informationen unter Integrationstests in ASP.NET Core.

Prerequisites

  • .NET 10 SDK oder höhere Versionen.
  • Ein Text-Editor oder Code-Editor Ihrer Wahl.

TUnit basiert vollständig auf Microsoft. Testing.Platform (MTP) und unterstützt VSTest nicht. In diesem Lernprogramm wird der MTP-Modus verwendet, der dotnet testdas .NET 10 SDK erfordert.

Erstellen des Quellprojekts

Öffnen eines Shell-Fensters. Erstellen Sie ein Verzeichnis namens Unit-testing-with-fsharp , um die Lösung zu speichern. Führen Sie in diesem neuen Verzeichnis den folgenden Befehl aus, um eine neue Lösungsdatei für die Klassenbibliothek und das Testprojekt zu erstellen:

dotnet new sln

Erstellen Sie als Nächstes ein MathService-Verzeichnis . Die folgende Gliederung zeigt bisher die Verzeichnis- und Dateistruktur:

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

Machen Sie MathService zum aktuellen Verzeichnis, und führen Sie den folgenden Befehl aus, um das Quellprojekt zu erstellen:

dotnet new classlib -lang "F#"

Ersetzen Sie den Inhalt von Library.fs durch eine fehlerhafte Implementierung des mathematischen Diensts:

namespace MathService

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

Ändern Sie das Verzeichnis wieder in das Verzeichnis unit-testing-with-fsharp. Führen Sie den folgenden Befehl aus, um das Klassenbibliotheksprojekt zur Projektmappe hinzuzufügen:

dotnet sln add ./MathService/MathService.fsproj

Erstellen des Testprojekts

Erstellen Sie als Nächstes das Verzeichnis MathService.Tests . Die folgende Gliederung zeigt die Verzeichnisstruktur:

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

Die TUnit-Projektvorlagen sind nicht im .NET SDK enthalten. Installieren Sie sie mit dem folgenden Befehl:

dotnet new install TUnit.Templates

Erstellen Sie das Verzeichnis MathService.Tests als aktuelles Verzeichnis, und erstellen Sie ein neues Projekt mit dem folgenden Befehl:

dotnet new TUnit -lang "F#"

Note

Bei Kurznamen von Vorlagen wird die Groß-/Kleinschreibung beachtet. Verwenden Sie TUnit, nicht tunit.

Mit diesem Befehl wird ein Testprojekt erstellt, das TUnit als Testframework verwendet. Die generierte Datei MathService.Tests.fsproj ist ein ausführbares Projekt, das auf das TUnit Paket verweist, das das Testframework, die Assertionsbibliothek und den MTP-Testläufer enthält, und das TUnit.Assertions.FSharp Paket, das F#-Hilfsprogramme für Assertionen hinzufügt.

Die Vorlage fügt außerdem Beispieltests hinzu. Dieses Lernprogramm ersetzt sie durch eigene Tests in Tests.fs. Löschen Sie das Data-Verzeichnis und die Dateien GlobalSetup.fs, Tests2.fs und Tests3.fs. F#-Projekte listen ihre Quelldateien explizit auf. Ersetzen Sie daher auch das ItemGroup, das die Compile-Elemente enthält, in MathService.Tests.fsproj durch Folgendes:

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

Fügen Sie nun die MathService Klassenbibliothek als weitere Abhängigkeit zum Projekt hinzu. Verwenden Sie den Befehl dotnet reference add:

dotnet reference add ../MathService/MathService.fsproj

Die folgende Gliederung zeigt das endgültige Lösungslayout:

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

Führen Sie den folgenden Befehl im Verzeichnis "unit-testing-with-fsharp " aus:

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

MTP-Modus von dotnet test konfigurieren

Da TUnit VSTest nicht unterstützt, muss dotnet test im MTP-Modus ausgeführt werden. Erstellen Sie im Verzeichnis "unit-testing-with-fsharp" eine global.json-Datei mit folgendem Inhalt:

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

Weitere Informationen finden Sie im MTP-Modus des Dotnet-Tests.

Erstellen des ersten Tests

Du schreibst einen fehlgeschlagenen Test, machst ihn erfolgreich und wiederholst dann den Vorgang. Ersetzen Sie den Inhalt von Tests.fs durch den folgenden Code:

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

Das [<Test>] Attribut zeigt eine Testmethode an, die vom Testläufer ausgeführt wird. TUnit ermittelt Testmethoden, die Member einer Klasse sind; es werden keine Funktionen gefunden, die mit let in einem Modul deklariert sind. TUnit-Assertionen sind asynchron. Der taskAssert Berechnungsausdruck aus TUnit.Assertions.FSharp führt einen Test als Aufgabe aus und ermöglicht es Ihnen, mit do! auf jede Assertion zu warten.

Wechseln Sie in das Verzeichnis "unit-testing-with-fsharp", führen Sie dotnet test aus, um die Tests und die Klassenbibliothek zu erstellen, und führen Sie dann die Tests aus. Das TUnit-Testprojekt enthält den Programmeinstieg, um Ihre Tests auszuführen. Mit dotnet test wird die Testanwendung mithilfe des erstellten Komponententestprojekts gestartet.

Diese zwei Tests geben jeweils den grundlegendsten bestandenen und fehlerhaften Test an. TestMethodPassing bestanden und FailEveryTime nicht bestanden. Erstellen Sie nun einen Test für die squaresOfOdds Methode. Die squaresOfOdds Methode gibt eine Sequenz der Quadrate aller ungeraden ganzzahligen Werte zurück, die Teil der Eingabesequenz sind. Anstatt alle diese Funktionen gleichzeitig zu schreiben, können Sie iterativ Tests erstellen, die die Funktionalität überprüfen. Um jeden Test erfolgreich bestehen zu lassen, erstellen Sie die erforderliche Funktionalität für die Methode.

Der einfachste Test, den Sie schreiben können, besteht darin, mit allen geraden Zahlen aufzurufen squaresOfOdds , wobei das Ergebnis eine leere Sequenz von ganzzahligen Zahlen sein soll. Fügen Sie dem TestClass Typ den folgenden Test hinzu:

[<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# ist strenger als C#, wenn Methodenüberladungen aufgelöst werden, sodass der Test den Elementtyp an Assert.That<int> übergibt, damit Assert.That<int> die Assertionen für eine Folge ganzer Zahlen auswählt. IsEquivalentTo überprüft, ob beide Sequenzen dieselben Elemente enthalten.

Wenn Sie den Test ausführen, sehen Sie, dass der Test fehlschlägt. Das liegt daran, dass Sie die Implementierung noch nicht erstellt haben. Bringen Sie diesen Test zum Bestehen, indem Sie den einfachsten Code, der funktioniert, in der Datei Library.fs in Ihrem MathService-Projekt schreiben:

let squaresOfOdds xs =
    Seq.empty<int>

Führen Sie im Verzeichnis unit-testing-with-fsharp erneut dotnet test aus. Der Befehl dotnet test führt einen Build für das MathService Projekt und dann für das MathService.Tests Projekt aus. Nachdem beide Projekte erstellt wurden, führt es Ihre Tests aus. Jetzt sind zwei Tests bestanden.

Erfüllen Sie die Anforderungen

Nachdem Sie nun einen Test bestanden haben, ist es an der Zeit, mehr zu schreiben. Der nächste einfache Fall funktioniert mit einer Sequenz, deren einzige ungerade Zahl ist 1. Die Zahl 1 ist einfacher, da das Quadrat von 1 1 ist. Dies ist der nächste 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)
}

Die dotnet test Ausführung schlägt den neuen Test fehl. Sie müssen die squaresOfOdds Methode aktualisieren, um diesen neuen Test zu behandeln. Sie müssen alle geraden Zahlen aus der Sequenz filtern, um diesen Testdurchlauf durchzuführen. Dazu können Sie eine kleine Filterfunktion schreiben und folgendes verwenden Seq.filter:

let private isOdd x = x % 2 <> 0

let squaresOfOdds xs =
    xs
    |> Seq.filter isOdd

Es gibt einen weiteren Schritt: Quadratieren Sie jede der ungeraden Zahlen. Beginnen Sie mit dem Schreiben eines neuen Tests:

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

Sie können den Test beheben, indem Sie für die gefilterte Sequenz einen Zuordnungsvorgang durchführen, um das Quadrat von jeder ungerade Zahl zu berechnen:

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

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

Sie haben eine kleine Bibliothek und eine Reihe von Unittests für diese Bibliothek erstellt. Sie haben die Lösung so strukturiert, dass das Hinzufügen neuer Pakete und Tests Teil des normalen Workflows ist. Sie konzentrierten sich größtenteils auf die Lösung der Ziele der Anwendung.

Siehe auch

  • Zuletzt aktualisiert um