feat: enhance test suite with async support and improved structure

Author: dlidstrom

Readme.md

@@ -51,31 +51,36 @@ open Sprout
 
 let suite = describe "A test suite" {
   Info "Top level info message"
+
+  // variables may be used to store state across tests
+  let mutable b = false
+  beforeEach { b <- true }
   it "should pass" {
     info "This test passes"
+
+    // simple assertions included out-of-the-box
+    b |> shouldBeTrue
   }
 
   it "should fail" {
     info "This test fails"
     failwith "Intentional failure"
   }
 
+  // use pending to mark tests that are not yet implemented
   pending "This is a pending test"
 
-  describe "Nested suite" {
-    Debug "Use beforeEach and afterEach for setup and teardown"
-    beforeEach {
-      debug "Before each test"
-    }
+  describe "Async works too" {
+    Debug "Async test example"
 
-    afterEach {
-      debug "After each test"
-    }
-    it "should also pass" {
-      info "Nested test passes"
+    // asynchronous flows are supported
+    it "should run asynchronously" {
+      do! Async.Sleep 1000
+      info "Async test completed"
     }
   }
 
+  // use nested suites to organize tests
   describe "Arithmetic" {
     describe "Addition" {
       it "should add two numbers correctly" {
@@ -90,24 +95,30 @@ let suite = describe "A test suite" {
         result |> shouldEqual 9
       }
     }
-  }
 
-  describe "Comparisons" {
-    debug "Testing comparisons"
-    it "should compare numbers correctly" {
-      5 > 3 |> shouldBeTrue
+    describe "Comparisons" {
+      debug "Testing comparisons"
+      it "should compare numbers correctly" {
+        5 > 3 |> shouldBeTrue
+      }
     }
-  }
 
-  describe "Parameterized Tests" {
-    info "Simply embed test cases and loop over them"
-    let numbers = [1; 2; 3; 4; 5]
-    for n in numbers do
-      it $"should handle number {n}" {
-        n > 0 |> shouldBeTrue
-      }
+    // parameterized tests are supported using regular F# loops
+    // type-safe as expected without any special syntax
+    describe "Parameterized Tests" {
+      info "Simply embed test cases and loop over them"
+      let numbers = [1; 2; 3; 4; 5]
+      for n in numbers do
+        it $"should handle number {n}" {
+          n > 0 |> shouldBeTrue
+        }
+    }
   }
 }
+
+// Run the test suite asynchronously
+runTestSuite
+|> Async.RunSynchronously
 ```
 
 Output:

Sprout.fs

@@ -72,37 +72,30 @@ type ITestReporter =
   abstract Debug : message:string * path:Path -> unit
   abstract End : TestResult [] -> unit
 
-type SimpleAsyncBuilder() =
+module Builders =
+  type EachBuilder(factory: (unit -> Async<unit>) -> EachFunction) =
     member _.Zero() = async { return () }
+    member _.Return x = async { return x }
+    member _.ReturnFrom(x: Async<unit>) = x
     member _.Delay(f: unit -> Async<unit>) = async.Delay f
-    member _.Run(f: Async<unit>) = f
-    member _.Bind(m: Async<unit>, f: unit -> Async<unit>) = async.Bind(m, f)
-
-let simpleAsync = SimpleAsyncBuilder()
-
-let computation =
-    simpleAsync {
-        do! async { printfn "First" }
-        do! async { printfn "Second" }
-        printfn "Done"
+    member _.Combine(a: Async<unit>, b: Async<unit>) = async {
+      do! a
+      do! b
     }
-
-// To run:
-Async.RunSynchronously computation
-module Builders =
-  type EachBuilder(factory: (unit -> Async<unit>) -> EachFunction) =
-    member _.Zero() = ()
-    member _.Delay(f: unit -> unit) = fun() -> async { return f() }
-    member _.Delay(f: unit -> Async<unit>) = f
-    member _.Run(f: (unit -> Async<unit>)) = factory f
-    member _.Run (f: unit -> unit) = factory <| fun() -> async { return f() }
+    member _.Bind(m: Async<'T>, f: 'T -> Async<unit>) = async.Bind(m, f)
+    member _.Run(f: Async<unit>) = factory (fun() -> f)
 
   type ItBuilder(name: string) =
-    member _.Zero() = ()
-    member _.Delay(f: unit -> unit) = fun() -> async { return f() }
-    member _.Delay(f: unit -> Async<unit>) = f
-    member _.Run (f: unit -> Async<unit>) = It.Active name f
-    member _.Run (f: unit -> unit) = It.Active name (fun() -> async { return f() })
+    member _.Zero() = async { return () }
+    member _.Return x = async { return x }
+    member _.ReturnFrom(x: Async<unit>) = x
+    member _.Delay(f: unit -> Async<unit>) = async.Delay f
+    member _.Combine(a: Async<unit>, b: Async<unit>) = async {
+      do! a
+      do! b
+    }
+    member _.Bind(m: Async<'T>, f: 'T -> Async<unit>) = async.Bind(m, f)
+    member _.Run(f: Async<unit>) = It.Active name (fun () -> f)
 
   type DescribeBuilder(name) =
     member _.Zero() = Describe.New name
@@ -139,31 +132,6 @@ let pending name = It.Pending name
 
 let describe name = Builders.DescribeBuilder name
 
-let asyncSuite = describe "Async Tests" {
-  beforeEach {
-    let! x = async {
-      debug "Before each async test"
-      return 42
-    }
-    do! Async.Sleep 100
-  }
-
-  it "should run an async test" {
-    do! Async.Sleep 100
-    let! x = async {
-      debug "Before each async test"
-      return 42
-    }
-    printfn "Async test completed with value: %d" x
-  }
-
-  it "should handle async failure" {
-    do! Async.Sleep 100
-    failwith "Intentional async failure"
-  }
-}
-
-
 module Reporters =
   open System.Diagnostics
 

Tests.fsx

@@ -83,8 +83,12 @@ let asyncSuite = describe "Async Tests" {
   }
 }
 
-runTestSuite suite
-runTestSuiteWithContext
-  { TestContext.New with Reporter = Reporters.TapReporter() }
-  suite
-runTestSuite asyncSuite
+[
+  runTestSuite suite
+  runTestSuiteWithContext
+    { TestContext.New with Reporter = Reporters.TapReporter() }
+    suite
+  runTestSuite asyncSuite
+]
+|> Async.Sequential
+|> Async.RunSynchronously

expected.log

@@ -1,13 +1,3 @@
-Running 1 tests...
-Main Suite
-  Suite 1
-  Suite 2
-  Before each test in Suite 2
-  This test passes in Suite 2
-    ✅ passed: should pass in Suite 2
-All tests passed!
-Summary: 1 passed, 0 failed, 0 pending
-Total time: 00:00:00.0042054
 Running 7 tests...
 A larger test suite
 Top level info message
@@ -44,7 +34,7 @@ There were 2 test failures:
 - A larger test suite / should fail - Intentional failure
 - A larger test suite / Arithmetic / Faulty Addition / should fail when adding incorrect numbers - Expected 5 but got 4
 Summary: 4 passed, 2 failed, 1 pending
-Total time: 00:00:00.0034252
+Total time: 00:00:00.0124887
 TAP version 14
 1..7
 ok should pass
@@ -63,3 +53,13 @@ not ok should fail when adding incorrect numbers
   severity: fail
   ...
 
+Running 2 tests...
+Async Tests
+Before each async test
+  ✅ passed: should run an async test
+Before each async test
+  ❌ failed: should handle async failure - Intentional async failure
+There were 1 test failures:
+- Async Tests / should handle async failure - Intentional async failure
+Summary: 1 passed, 1 failed, 0 pending
+Total time: 00:00:00.4115251

out.png

@@ -4,31 +4,36 @@ open Sprout
 
 let suite = describe "A test suite" {
   Info "Top level info message"
+
+  // variables may be used to store state across tests
+  let mutable b = false
+  beforeEach { b <- true }
   it "should pass" {
     info "This test passes"
+
+    // simple assertions included out-of-the-box
+    b |> shouldBeTrue
   }
 
   it "should fail" {
     info "This test fails"
     failwith "Intentional failure"
   }
 
+  // use pending to mark tests that are not yet implemented
   pending "This is a pending test"
 
-  describe "Nested suite" {
-    Debug "Use beforeEach and afterEach for setup and teardown"
-    beforeEach {
-      debug "Before each test"
-    }
+  describe "Async works too" {
+    Debug "Async test example"
 
-    afterEach {
-      debug "After each test"
-    }
-    it "should also pass" {
-      info "Nested test passes"
+    // asynchronous flows are supported
+    it "should run asynchronously" {
+      do! Async.Sleep 1000
+      info "Async test completed"
     }
   }
 
+  // use nested suites to organize tests
   describe "Arithmetic" {
     describe "Addition" {
       it "should add two numbers correctly" {
@@ -43,23 +48,28 @@ let suite = describe "A test suite" {
         result |> shouldEqual 9
       }
     }
-  }
 
-  describe "Comparisons" {
-    debug "Testing comparisons"
-    it "should compare numbers correctly" {
-      5 > 3 |> shouldBeTrue
+    describe "Comparisons" {
+      debug "Testing comparisons"
+      it "should compare numbers correctly" {
+        5 > 3 |> shouldBeTrue
+      }
     }
-  }
 
-  describe "Parameterized Tests" {
-    info "Simply embed test cases and loop over them"
-    let numbers = [1; 2; 3; 4; 5]
-    for n in numbers do
-      it $"should handle number {n}" {
-        n > 0 |> shouldBeTrue
-      }
+    // parameterized tests are supported using regular F# loops
+    // type-safe as expected without any special syntax
+    describe "Parameterized Tests" {
+      info "Simply embed test cases and loop over them"
+      let numbers = [1; 2; 3; 4; 5]
+      for n in numbers do
+        it $"should handle number {n}" {
+          n > 0 |> shouldBeTrue
+        }
+    }
   }
 }
 
-runTestSuiteWithContext suite { TestContext.Empty with Reporter = Reporters.ConsoleReporter("v", "x", "?") :> ITestReporter }
+runTestSuiteWithContext
+  { TestContext.New with Reporter = Reporters.ConsoleReporter("v", "x", "?", "  ") :> ITestReporter }
+  suite
+|> Async.RunSynchronously