F# 测试模式¶

使用 xUnit、FsUnit、Unquote、FsCheck 以及现代 .NET 测试实践，为 F# 应用程序提供全面的测试模式。

何时激活¶

为 F# 代码编写新测试
审查测试质量和覆盖率
为 F# 项目搭建测试基础设施
调试不稳定或运行缓慢的测试

测试框架技术栈¶

工具	用途
xUnit	测试框架（.NET 生态系统的标准选择）
FsUnit.xUnit	面向 xUnit 的 F# 友好断言语法
Unquote	使用 F# 引用（quotations）的断言库，可提供清晰的失败消息
FsCheck.xUnit	与 xUnit 集成的基于属性的测试
NSubstitute	模拟 .NET 依赖
Testcontainers	集成测试中的真实基础设施
WebApplicationFactory	ASP.NET Core 集成测试

使用 xUnit + FsUnit 编写单元测试¶

基本测试结构¶

module OrderServiceTests

open Xunit
open FsUnit.Xunit

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

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

使用 Unquote 进行断言¶

Unquote 使用 F# 引用（quotations），因此失败消息会显示失败的完整表达式，而不仅仅是“预期 X，实际 Y”。

module OrderValidationTests

open Xunit
open Swensen.Unquote

[<Fact>]
let ``PlaceOrder returns success when request is valid`` () =
    let request = { CustomerId = "cust-123"; Items = [ validItem ] }
    let result = OrderService.placeOrder request
    test <@ Result.isOk result @>

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

[<Fact>]
let ``validated email rejects empty input`` () =
    let result = ValidatedEmail.create ""
    test <@ Result.isError result @>

异步测试¶

[<Fact>]
let ``PlaceOrder returns success when request is valid`` () = task {
    let deps = createTestDeps ()
    let request = { CustomerId = "cust-123"; Items = [ validItem ] }

    let! result = OrderService.placeOrder deps request

    test <@ Result.isOk result @>
}

[<Fact>]
let ``PlaceOrder returns error when items are empty`` () = task {
    let deps = createTestDeps ()
    let request = { CustomerId = "cust-123"; Items = [] }

    let! result = OrderService.placeOrder deps request

    test <@ Result.isError result @>
}

使用 Theory 进行参数化测试¶

[<Theory>]
[<InlineData("")>]
[<InlineData("   ")>]
let ``PlaceOrder rejects empty customer ID`` (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("user@example.com", true)>]
[<InlineData("user+tag@example.co.uk", true)>]
let ``IsValidEmail returns expected result`` (email: string, expected: bool) =
    test <@ EmailValidator.isValid email = expected @>

使用 FsCheck 进行基于属性的测试¶

使用 FsCheck.xUnit¶

open FsCheck
open FsCheck.Xunit

[<Property>]
let ``order total is always non-negative`` (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 ``serialization roundtrips`` (order: Order) =
    let json = JsonSerializer.Serialize order
    let deserialized = JsonSerializer.Deserialize<Order> json
    deserialized = order

自定义生成器¶

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 ``valid emails pass validation`` (email: string) =
    EmailValidator.isValid email

模拟依赖¶

函数桩（首选）¶

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 saves the confirmed order`` () = 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 模拟 .NET 接口¶

open NSubstitute

[<Fact>]
let ``calls repository with correct 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>())
}

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 returns 404 when not found`` () = task {
        let! response = client.GetAsync($"/api/orders/{Guid.NewGuid()}")
        test <@ response.StatusCode = HttpStatusCode.NotFound @>
    }

测试组织¶

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

常见反模式¶

反模式	修复方案
测试实现细节	测试行为与结果
可变的共享测试状态	每个测试使用全新状态
异步测试中的 `Thread.Sleep`	使用带超时的 `Task.Delay`，或使用轮询辅助工具
对 `sprintf` 输出进行断言	对类型化值和模式匹配进行断言
忽略 `CancellationToken`	始终传递并验证取消
跳过基于属性的测试	对任何具有明确不变量的函数使用 FsCheck

dotnet-patterns - 惯用的 .NET 模式、依赖注入和架构
csharp-testing - C# 测试模式（共享基础设施如 WebApplicationFactory 和 Testcontainers 同样适用于 F#）

运行测试¶

# Run all tests
dotnet test

# Run with coverage
dotnet test --collect:"XPlat Code Coverage"

# Run specific project
dotnet test tests/MyApp.Tests/

# Filter by test name
dotnet test --filter "FullyQualifiedName~OrderService"

# Watch mode during development
dotnet watch test --project tests/MyApp.Tests/

本页原文 Markdown：在 AtomGit 查看·内容源自开源项目 ev/ECC

F# 测试模式¶

何时激活¶

测试框架技术栈¶

使用 xUnit + FsUnit 编写单元测试¶

基本测试结构¶

使用 Unquote 进行断言¶

异步测试¶

使用 Theory 进行参数化测试¶

使用 FsCheck 进行基于属性的测试¶

使用 FsCheck.xUnit¶

自定义生成器¶

模拟依赖¶

函数桩（首选）¶

使用 NSubstitute 模拟 .NET 接口¶

ASP.NET Core 集成测试¶

测试组织¶

常见反模式¶

相关技能¶

运行测试¶