Skip to main content
Agent skill

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 started

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?

Install scope
Claude Code folder setup
mkdir -p ~/.claude/skills/fsharp-testing
# Save SKILL.md to ~/.claude/skills/fsharp-testing/SKILL.md
  1. 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.
  2. 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.
  3. 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.

Starter prompt
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.