Fsharp Testing
F# testing patterns with xUnit, FsUnit, Unquote, FsCheck property-based testing, integration tests, and test organization best practices. Use when writing F# tests with xUnit, FsUnit, Unquote, or FsCheck.
Get the complete skill folder, including its scripts and reference files.
·
When to use this skill
Use Fsharp Testing when an AI agent needs a reusable SKILL.md workflow for this job: F# testing patterns with xUnit, FsUnit, Unquote, FsCheck property-based testing, integration tests, and test organization best practices. Use when writing F# tests with xUnit, FsUnit, Unquote, or FsCheck.
When not to use it
Skip Fsharp Testing when the task is outside the coding category, or when a more specific skill in this directory already covers the same workflow with clearer triggers.
How to install
Where will you use it?
mkdir -p ~/.claude/skills/fsharp-testing # Save SKILL.md to ~/.claude/skills/fsharp-testing/SKILL.md
- Claude Code personal install: place the skill and its bundled files at ~/.claude/skills/fsharp-testing/SKILL.md. For a shared project, commit the folder at .claude/skills/fsharp-testing/ instead.
- Current Claude Code detects SKILL.md changes in watched directories during the session. If you just created a top-level skills directory, run /reload-skills. Check that the skill is listed before testing its trigger.
- For Claude chat or Cowork in the Desktop app, manage uploaded skills in Customize > Skills; copying files into a local Claude Code folder is not a Desktop install. Other agents may use different install locations.
Full install guide for Claude, Cursor, and Codex →
Try a starter prompt
After installing the skill, paste this starter prompt into your agent to verify it triggers on a small task.
Use the Fsharp Testing skill for this task: Use Fsharp Testing when this documented workflow matches the task. Confirm any required inputs or files before making changes.
What supports this recommendation?
71/100 provisional content score. This measures documentation, practical detail and source signals. It is not a measured task success rate or a security certification.
- Documentation
- 77/100
- Practical detail
- 68/100
- Source evidence
- 63/100
- Source signals
- 72/100
Model compatibility evidence
- claudeuntested
No model-specific signal or recorded compatibility test was found.
- chatgptuntested
No model-specific signal or recorded compatibility test was found.
- geminiuntested
No model-specific signal or recorded compatibility test was found.
- copilotuntested
No model-specific signal or recorded compatibility test was found.
- llamauntested
No model-specific signal or recorded compatibility test was found.
- perplexityuntested
No model-specific signal or recorded compatibility test was found.
- mistraluntested
No model-specific signal or recorded compatibility test was found.
- grokuntested
No model-specific signal or recorded compatibility test was found.
Inferred compatibility is based on content signals. Check the app, its available tools and setup requirements before running a skill.
What this skill does
# F# Testing Patterns
Comprehensive testing patterns for F# applications using xUnit, FsUnit, Unquote, FsCheck, and modern .NET testing practices.
## When to Activate
- Writing new tests for F# code - Reviewing test quality and coverage - Setting up test infrastructure for F# projects - Debugging flaky or slow tests
## Test Framework Stack
| Tool | Purpose | |---|---| | **xUnit** | Test framework (standard .NET ecosystem choice) | | **FsUnit.xUnit** | F#-friendly assertion syntax for xUnit | | **Unquote** | Assertion library using F# quotations for clear failure messages | | **FsCheck.xUnit** | Property-based testing integrated with xUnit | | **NSubstitute** | Mocking .NET dependencies | | **Testcontainers** | Real infrastructure in integration tests | | **WebApplicationFactory** | ASP.NET Core integration tests |
## Unit Tests with xUnit + FsUnit
### Basic Test Structure
```fsharp 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 @>) ```
### Assertions with Unquote
Unquote uses F# quotations so failure messages show the full expression that failed, not just "expected X got Y".
```fsharp 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 @> ```
### Async Tests
```fsharp [<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 @> } ```
### Parameterized Tests with Theory
```fsharp [<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("[email protected]", true)>] [<InlineData("[email protected]", true)>] let ``IsValidEmail returns expected result`` (email: string, expected: bool) = test <@ EmailValidator.isValid email = expected @> ```
## Property-Based Testing with FsCheck
### Using FsCheck.xUnit
```fsharp 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 ```
### Custom Generators
```fsharp 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 ```
## Mocking Dependencies
### Function Stubs (Preferred)
```fsharp 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 for .NET Interfaces
```fsharp 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 Integration Tests
```fsharp 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 @> } ```
## Test Organization
``` tests/ MyApp.Tests/ Unit/ OrderServiceTests.fs PaymentServiceTests.fs Integration/ OrderApiTests.fs OrderRepositoryTests.fs Properties/ OrderPropertyTests.fs Helpers/ TestData.fs TestDeps.fs ```
## Common Anti-Patterns
| Anti-Pattern | Fix | |---|---| | Testing implementation details | Test behavior and outcomes | | Mutable shared test state | Fresh state per test | | `Thread.Sleep` in async tests | Use `Task.Delay` with timeout, or polling helpers | | Asserting on `sprintf` output | Assert on typed values and pattern matches | | Ignoring `CancellationToken` | Always pass and verify cancellation | | Skipping property-based tests | Use FsCheck for any function with clear invariants |
## Related Skills
- `dotnet-patterns` - Idiomatic .NET patterns, dependency injection, and architecture - `csharp-testing` - C# testing patterns (shared infrastructure like WebApplicationFactory and Testcontainers applies to F# too)
## Running Tests
```bash # 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/ ```
Intended uses
- Use Fsharp Testing when this documented workflow matches the task.
Implementation notes
- Review the source instructions and adapt inputs before running the workflow.
Try it, then tell us how it went
A copied prompt does not tell us whether the task worked. Report your result after checking the output. We collect your tool and outcome, never your files or prompt.