fsharp-testing

Modèles de Test F#

Modèles de test complets pour les applications F# utilisant xUnit, FsUnit, Unquote, FsCheck et les pratiques de test modernes .NET.

Quand Activer

• Écrire de nouveaux tests pour du code F#
• Réviser la qualité et la couverture des tests
• Mettre en place l'infrastructure de test pour des projets F#
• Déboguer des tests instables ou lents

Pile du Framework de Test

Outil	Objectif
xUnit	Framework de test (choix standard de l'écosystème .NET)
FsUnit.xUnit	Syntaxe d'assertion adaptée à F# pour xUnit
Unquote	Bibliothèque d'assertions utilisant les citations F# pour des messages d'échec clairs
FsCheck.xUnit	Tests basés sur les propriétés intégrés à xUnit
NSubstitute	Mock des dépendances .NET
Testcontainers	Infrastructure réelle dans les tests d'intégration
WebApplicationFactory	Tests d'intégration ASP.NET Core

Tests Unitaires avec xUnit + FsUnit

Structure de Test Basique

module OrderServiceTests

open Xunit
open FsUnit.Xunit

[<Fact>]
let ``create définit le statut sur EnAttente`` () =
    let order = Order.create "client-1" [ articleValide ]
    order.Status |> should equal EnAttente

[<Fact>]
let ``confirm change le statut sur Confirmé`` () =
    let order = Order.create "client-1" [ articleValide ]
    let confirmed = Order.confirm order
    confirmed.Status |> should be (ofCase <@ Confirmé @>)

Assertions avec Unquote

Unquote utilise les citations F# pour que les messages d'échec affichent l'expression complète qui a échoué, et pas seulement "attendu X reçu Y".

module OrderValidationTests

open Xunit
open Swensen.Unquote

[<Fact>]
let ``PlaceOrder retourne un succès quand la requête est valide`` () =
    let request = { CustomerId = "client-123"; Items = [ articleValide ] }
    let result = OrderService.placeOrder request
    test <@ Result.isOk result @>

[<Fact>]
let ``le total de la commande additionne les prix des articles`` () =
    let items = [ { Sku = "A"; Quantité = 2; Prix = 10m }
                  { Sku = "B"; Quantité = 1; Prix = 5m } ]
    let total = Order.calculateTotal items
    test <@ total = 25m @>

[<Fact>]
let ``l'email validé rejette une entrée vide`` () =
    let result = ValidatedEmail.create ""
    test <@ Result.isError result @>

Tests Asynchrones

[<Fact>]
let ``PlaceOrder retourne un succès quand la requête est valide`` () = task {
    let deps = createTestDeps ()
    let request = { CustomerId = "client-123"; Items = [ articleValide ] }

    let! result = OrderService.placeOrder deps request

    test <@ Result.isOk result @>
}

[<Fact>]
let ``PlaceOrder retourne une erreur quand les articles sont vides`` () = task {
    let deps = createTestDeps ()
    let request = { CustomerId = "client-123"; Items = [] }

    let! result = OrderService.placeOrder deps request

    test <@ Result.isError result @>
}

Tests Paramétrés avec Theory

[<Theory>]
[<InlineData("")>]
[<InlineData("   ")>]
let ``PlaceOrder rejette un ID client vide`` (customerId: string) =
    let request = { CustomerId = customerId; Items = [ articleValide ] }
    let result = OrderService.placeOrder request
    result |> should be (ofCase <@ Erreur @>)

[<Theory>]
[<InlineData("", false)>]
[<InlineData("a", false)>]
[<InlineData("[email protected]", true)>]
[<InlineData("[email protected]", true)>]
let ``IsValidEmail retourne le résultat attendu`` (email: string, expected: bool) =
    test <@ EmailValidator.isValid email = expected @>

Tests Basés sur les Propriétés avec FsCheck

Utilisation de FsCheck.xUnit

open FsCheck
open FsCheck.Xunit

[<Property>]
let ``le total de la commande est toujours non négatif`` (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 ``la sérialisation fait un aller-retour`` (order: Order) =
    let json = JsonSerializer.Serialize order
    let deserialized = JsonSerializer.Deserialize<Order> json
    deserialized = order

Générateurs Personnalisés

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

[<Property(Arbitrary = [| typeof<OrderGenerators> |])>]
let ``les emails valides passent la validation`` (email: string) =
    EmailValidator.isValid email

Mock des Dépendances

Stubs de Fonctions (Préféré)

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 enregistre la commande confirmée`` () = task {
    let mutable saved = []
    let deps =
        { createTestDeps () with
            SaveOrder = fun order -> task { saved <- order :: saved } }

    let! _ = OrderService.placeOrder deps requêteValide

    test <@ saved.Length = 1 @>
}

NSubstitute pour les Interfaces .NET

open NSubstitute

[<Fact>]
let ``appelle le dépôt avec le bon ID`` () = 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>())
}

Tests d'Intégration ASP.NET Core

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 retourne 404 quand non trouvé`` () = task {
        let! response = client.GetAsync($"/api/orders/{Guid.NewGuid()}")
        test <@ response.StatusCode = HttpStatusCode.NotFound @>
    }

Organisation des Tests

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

Anti-Modèles Courants

Anti-Modèle	Correction
Tester les détails d'implémentation	Tester le comportement et les résultats
État de test partagé mutable	État frais par test
Thread.Sleep dans les tests asynchrones	Utiliser Task.Delay avec délai d'attente, ou des helpers de sondage
Affirmer sur la sortie de sprintf	Affirmer sur des valeurs typées et des filtres par motif
Ignorer CancellationToken	Toujours passer et vérifier l'annulation
Ignorer les tests basés sur les propriétés	Utiliser FsCheck pour toute fonction avec des invariants clairs

Compétences Associées

• dotnet-patterns - Modèles .NET idiomatiques, injection de dépendances et architecture
• csharp-testing - Modèles de test C# (l'infrastructure partagée comme WebApplicationFactory et Testcontainers s'applique aussi à F#)

Exécution des Tests

# Lancer tous les tests
dotnet test

# Lancer avec couverture
dotnet test --collect:"XPlat Code Coverage"

# Lancer un projet spécifique
dotnet test tests/MyApp.Tests/

# Filtrer par nom de test
dotnet test --filter "FullyQualifiedName~OrderService"

# Mode watch pendant le développement
dotnet watch test --project tests/MyApp.Tests/