WriteBetterTests.FsCheckSpy 1.0.0

WriteBetterTests.FsCheckSpy

FsCheckSpy adds spies to your FsCheck tests.

• F# Site → docs/fsharp/index.html
• C# Site → docs/csharp/index.html

API docs:

• F# API → docs/fsharp/reference/index.html
• C# API → docs/csharp/api/index.html

Installation

dotnet add package WriteBetterTests.FsCheckSpy

Quickstart

Create a spy. Run the property. Read the log.

• F#

open FsCheck
open FsCheck.FSharp
open FsCheckSpy
open Swensen.Unquote

type Calculator = { add: int -> int -> int }
  with
    static member Create (add) = { add = add }

type CalculatorLog = { add: CallLog<(int * int), int> }
  with
    static member Create (add) = { add = add }

let arbCalculator () =
  Spy.fn<(int * int), int>()
    .MapFn(fun fn -> fun x -> fun y -> fn(x, y))
    .Arbitrary(CalculatorLog.Create, Calculator.Create).Arb

[<Property>]
let prop_Calculator () =
  Prop.forAll (Arb.fromGen(Gen.zip3 (arbCalculator().Generator) (Gen.choose((1, 100))) (Gen.choose(1, 100)))) <| fun ((log, calc), x, y) ->
    // Use the calculator - we don't know what it returns
    let result = calc.add x y
    // But we can verify it was called correctly
    <@ log.add[0].Args = (x, y) @> |> ignore
    // And we can verify the result
    <@ log.add[0].Result = result @> |> ignore

• C#

using FsCheck;
using FsCheckSpy;

public readonly record struct Calculator(Func<int, int, int> Add)
{
  public static Calculator Create(Func<int, int, int> args) => new(args);
}

public readonly record struct CalculatorLogs(CallLog<(int, int), int> Add)
{
  public static CalculatorLogs Create(CallLog<(int, int), int> args) => new(args);
}

var arb = Spy.Fn<(int, int), int>()
  .InvokeMapFn<Func<int, int, int>>(f => (int x, int y) => f((x, y)))
  .ToArbitrary(CalculatorLogs.Create, Calculator.Create)
  .Arb;

Prop.ForAll(Arb.From(arb), pair =>
{
  var (logs, calc) = pair;
  var x = 3; var y = 5;
  var result = calc.Add(x, y);
  return logs.Add[0].Args == (x, y)
      && logs.Add[0].Result == result;
}).QuickCheckThrowOnFailure();

Anatomy of a Spy

• You get two things: a log and a function (your dependency).
• Each call to the function adds one entry to the log with Args and Result.
• Async logs store success or error: Result<'T, exn> (F#) or SpyResult<T,E> (C#).
• Spies can be composed to build concrete types that match your program dependencies.

Learn more

• F# Guide → docs/fsharp.md
• C# Guide → docs/csharp.md

License

MIT