fsharp-testing

F#-Testmuster

Umfassende Testmuster für F#-Anwendungen mit xUnit, FsUnit, Unquote, FsCheck und modernen .NET-Testpraktiken.

Wann aktivieren

• Schreiben neuer Tests für F#-Code
• Überprüfen der Testqualität und -abdeckung
• Einrichten der Testinfrastruktur für F#-Projekte
• Debuggen von flaky oder langsamen Tests

Testframework-Stack

Tool	Zweck
xUnit	Testframework (Standard im .NET-Ökosystem)
FsUnit.xUnit	F#-freundliche Assert-Syntax für xUnit
Unquote	Assert-Bibliothek mit F#-Quotationen für klare Fehlermeldungen
FsCheck.xUnit	Eigenschaftsbasierte Tests integriert mit xUnit
NSubstitute	Mocken von .NET-Abhängigkeiten
Testcontainers	Reale Infrastruktur in Integrationstests
WebApplicationFactory	ASP.NET Core-Integrationstests

Komponententests mit xUnit + FsUnit

Grundlegende Teststruktur

module OrderServiceTests

open Xunit
open FsUnit.Xunit

[<Fact>]
let ``create setzt Status auf Pending`` () =
    let order = Order.create "cust-1" [ validItem ]
    order.Status |> should equal Pending

[<Fact>]
let ``confirm ändert Status auf Confirmed`` () =
    let order = Order.create "cust-1" [ validItem ]
    let confirmed = Order.confirm order
    confirmed.Status |> should be (ofCase <@ Confirmed @>)

Assertions mit Unquote

Unquote verwendet F#-Quotationen, sodass Fehlermeldungen den gesamten fehlgeschlagenen Ausdruck anzeigen, nicht nur "expected X got Y".

module OrderValidationTests

open Xunit
open Swensen.Unquote

[<Fact>]
let ``PlaceOrder gibt Erfolg zurück, wenn die Anfrage gültig ist`` () =
    let request = { CustomerId = "cust-123"; Items = [ validItem ] }
    let result = OrderService.placeOrder request
    test <@ Result.isOk result @>

[<Fact>]
let ``Bestellsumme summiert Artikelpreise`` () =
    let items = [ { Sku = "A"; Quantity = 2; Price = 10m }
                  { Sku = "B"; Quantity = 1; Price = 5m } ]
    let total = Order.calculateTotal items
    test <@ total = 25m @>

[<Fact>]
let ``validierte E-Mail lehnt leere Eingabe ab`` () =
    let result = ValidatedEmail.create ""
    test <@ Result.isError result @>

Async-Tests

[<Fact>]
let ``PlaceOrder gibt Erfolg zurück, wenn die Anfrage gültig ist`` () = task {
    let deps = createTestDeps ()
    let request = { CustomerId = "cust-123"; Items = [ validItem ] }

    let! result = OrderService.placeOrder deps request

    test <@ Result.isOk result @>
}

[<Fact>]
let ``PlaceOrder gibt Fehler zurück, wenn Artikel leer sind`` () = task {
    let deps = createTestDeps ()
    let request = { CustomerId = "cust-123"; Items = [] }

    let! result = OrderService.placeOrder deps request

    test <@ Result.isError result @>
}

Parametrisierte Tests mit Theory

[<Theory>]
[<InlineData("")>]
[<InlineData("   ")>]
let ``PlaceOrder lehnt leere Kunden-ID ab`` (customerId: string) =
    let request = { CustomerId = customerId; Items = [ validItem ] }
    let result = OrderService.placeOrder request
    result |> should be (ofCase <@ Error @>)

[<Theory>]
[<InlineData("", false)>]
[<InlineData("a", false)>]
[<InlineData("[email protected]", true)>]
[<InlineData("[email protected]", true)>]
let ``IsValidEmail gibt erwartetes Ergebnis zurück`` (email: string, expected: bool) =
    test <@ EmailValidator.isValid email = expected @>

Eigenschaftsbasierte Tests mit FsCheck

Mit FsCheck.xUnit

open FsCheck
open FsCheck.Xunit

[<Property>]
let ``Bestellsumme ist immer nicht-negativ`` (items: NonEmptyList<PositiveInt * decimal>) =
    let orderItems =
        items.Get
        |> List.map (fun (qty, price) ->
            { Sku = "SKU"; Quantity = qty.Get; Price = abs price })
    let total = Order.calculateTotal orderItems
    total >= 0m

[<Property>]
let ``Serialisierung roundtrips`` (order: Order) =
    let json = JsonSerializer.Serialize order
    let deserialized = JsonSerializer.Deserialize<Order> json
    deserialized = order

Benutzerdefinierte Generatoren

type OrderGenerators =
    static member ValidEmail () =
        gen {
            let! user = Gen.elements [ "alice"; "bob"; "carol" ]
            let! domain = Gen.elements [ "example.com"; "test.org" ]
            return $"{user}@{domain}"
        }
        |> Arb.fromGen

[<Property(Arbitrary = [| typeof<OrderGenerators> |])>]
let ``gültige E-Mails bestehen die Validierung`` (email: string) =
    EmailValidator.isValid email

Mocken von Abhängigkeiten

Funktions-Stubs (bevorzugt)

let createTestDeps () =
    let mutable savedOrders = []
    { FindOrder = fun id -> task { return Map.tryFind id testData }
      SaveOrder = fun order -> task { savedOrders <- order :: savedOrders }
      SendNotification = fun _ -> Task.CompletedTask }

[<Fact>]
let ``PlaceOrder speichert die bestätigte Bestellung`` () = task {
    let mutable saved = []
    let deps =
        { createTestDeps () with
            SaveOrder = fun order -> task { saved <- order :: saved } }

    let! _ = OrderService.placeOrder deps validRequest

    test <@ saved.Length = 1 @>
}

NSubstitute für .NET-Interfaces

open NSubstitute

[<Fact>]
let ``ruft Repository mit korrekter ID auf`` () = task {
    let repo = Substitute.For<IOrderRepository>()
    repo.FindByIdAsync(Arg.Any<Guid>(), Arg.Any<CancellationToken>())
        .Returns(Task.FromResult(Some testOrder))

    let service = OrderService(repo)
    let! _ = service.GetOrder(testOrder.Id, CancellationToken.None)

    do! repo.Received(1).FindByIdAsync(testOrder.Id, Arg.Any<CancellationToken>())
}

ASP.NET Core-Integrationstests

type OrderApiTests (factory: WebApplicationFactory<Program>) =
    interface IClassFixture<WebApplicationFactory<Program>>

    let client =
        factory.WithWebHostBuilder(fun builder ->
            builder.ConfigureServices(fun services ->
                services.RemoveAll<DbContextOptions<AppDbContext>>() |> ignore
                services.AddDbContext<AppDbContext>(fun options ->
                    options.UseInMemoryDatabase("TestDb") |> ignore) |> ignore))
            .CreateClient()

    [<Fact>]
    member _.``GET order gibt 404 zurück, wenn nicht gefunden`` () = task {
        let! response = client.GetAsync($"/api/orders/{Guid.NewGuid()}")
        test <@ response.StatusCode = HttpStatusCode.NotFound @>
    }

Testorganisation

tests/
  MyApp.Tests/
    Unit/
      OrderServiceTests.fs
      PaymentServiceTests.fs
    Integration/
      OrderApiTests.fs
      OrderRepositoryTests.fs
    Properties/
      OrderPropertyTests.fs
    Helpers/
      TestData.fs
      TestDeps.fs

Häufige Anti-Patterns

Anti-Pattern	Lösung
Testen von Implementierungsdetails	Verhalten und Ergebnisse testen
Veränderbarer gemeinsamer Testzustand	Neuen Zustand pro Test
Thread.Sleep in Async-Tests	Task.Delay mit Timeout oder Polling-Helfer verwenden
Assertion auf sprintf-Ausgabe	Auf typisierte Werte und Mustervergleiche asserten
Ignorieren von CancellationToken	Immer übergeben und Abbruch überprüfen
Überspringen eigenschaftsbasierter Tests	FsCheck für jede Funktion mit klaren Invarianten verwenden

Verwandte Skills

• dotnet-patterns - Idiomatische .NET-Muster, Dependency Injection und Architektur
• csharp-testing - C#-Testmuster (gemeinsame Infrastruktur wie WebApplicationFactory und Testcontainers gilt auch für F#)

Tests ausführen

# Alle Tests ausführen
dotnet test

# Mit Codeabdeckung ausführen
dotnet test --collect:"XPlat Code Coverage"

# Bestimmtes Projekt ausführen
dotnet test tests/MyApp.Tests/

# Nach Testnamen filtern
dotnet test --filter "FullyQualifiedName~OrderService"

# Watch-Modus während der Entwicklung
dotnet watch test --project tests/MyApp.Tests/