Improve test coverage and reorganize file structure and the like

src/FSharpy.TaskSeq.Test/FSharpy.TaskSeq.Test.fsproj

@@ -9,6 +9,11 @@
 
   <ItemGroup>
     <Compile Include="TestUtils.fs" />
+    <Compile Include="TaskSeq.ToXXX.Tests.fs" />
+    <Compile Include="TaskSeq.OfXXX.Tests.fs" />
+    <Compile Include="TaskSeq.Iter.Tests.fs" />
+    <Compile Include="TaskSeq.Map.Tests.fs" />
+    <Compile Include="TaskSeq.Collect.Tests.fs" />
     <Compile Include="TaskSeq.Tests.fs" />
     <Compile Include="TaskSeq.PocTests.fs" />
     <Compile Include="Program.fs" />

src/FSharpy.TaskSeq.Test/TaskSeq.Collect.Tests.fs

@@ -0,0 +1,65 @@
+module FSharpy.TaskSeq.Tests.Collect
+
+open Xunit
+open FsUnit.Xunit
+open FsToolkit.ErrorHandling
+
+open FSharpy
+
+[<Fact>]
+let ``TaskSeq-collect operates in correct order`` () = task {
+    let! sq =
+        createDummyTaskSeq 10
+        |> TaskSeq.collect (fun item -> taskSeq {
+            yield char (item + 64)
+            yield char (item + 65)
+        })
+        |> TaskSeq.toSeqCachedAsync
+
+    sq
+    |> Seq.map string
+    |> String.concat ""
+    |> should equal "ABBCCDDEEFFGGHHIIJJK"
+}
+
+[<Fact>]
+let ``TaskSeq-collectSeq operates in correct order`` () = task {
+    let! sq =
+        createDummyTaskSeq 10
+        |> TaskSeq.collectSeq (fun item -> seq {
+            yield char (item + 64)
+            yield char (item + 65)
+        })
+        |> TaskSeq.toSeqCachedAsync
+
+    sq
+    |> Seq.map string
+    |> String.concat ""
+    |> should equal "ABBCCDDEEFFGGHHIIJJK"
+}
+
+[<Fact>]
+let ``TaskSeq-collect with empty task sequences`` () = task {
+    let! sq =
+        createDummyTaskSeq 10
+        |> TaskSeq.collect (fun _ -> TaskSeq.ofSeq Seq.empty)
+        |> TaskSeq.toSeqCachedAsync
+
+    Seq.isEmpty sq |> should be True
+}
+
+[<Fact>]
+let ``TaskSeq-collectSeq with empty sequences`` () = task {
+    let! sq =
+        createDummyTaskSeq 10
+        |> TaskSeq.collectSeq (fun _ -> Seq.empty<int>)
+        |> TaskSeq.toSeqCachedAsync
+
+    Seq.isEmpty sq |> should be True
+}
+
+[<Fact>]
+let ``TaskSeq-empty is empty`` () = task {
+    let! sq = TaskSeq.empty<string> |> TaskSeq.toSeqCachedAsync
+    Seq.isEmpty sq |> should be True
+}

src/FSharpy.TaskSeq.Test/TaskSeq.Iter.Tests.fs

@@ -0,0 +1,48 @@
+module FSharpy.TaskSeq.Tests.Iter
+
+open Xunit
+open FsUnit.Xunit
+open FsToolkit.ErrorHandling
+
+open FSharpy
+
+
+[<Fact>]
+let ``TaskSeq-iteri should go over all items`` () = task {
+    let tq = createDummyTaskSeq 10
+    let mutable sum = 0
+    do! tq |> TaskSeq.iteri (fun i _ -> sum <- sum + i)
+    sum |> should equal 45 // index starts at 0
+}
+
+[<Fact>]
+let ``TaskSeq-iter should go over all items`` () = task {
+    let tq = createDummyTaskSeq 10
+    let mutable sum = 0
+    do! tq |> TaskSeq.iter (fun item -> sum <- sum + item)
+    sum |> should equal 55 // task-dummies started at 1
+}
+
+[<Fact>]
+let ``TaskSeq-iteriAsync should go over all items`` () = task {
+    let tq = createDummyTaskSeq 10
+    let mutable sum = 0
+
+    do!
+        tq
+        |> TaskSeq.iteriAsync (fun i _ -> task { sum <- sum + i })
+
+    sum |> should equal 45 // index starts at 0
+}
+
+[<Fact>]
+let ``TaskSeq-iterAsync should go over all items`` () = task {
+    let tq = createDummyTaskSeq 10
+    let mutable sum = 0
+
+    do!
+        tq
+        |> TaskSeq.iterAsync (fun item -> task { sum <- sum + item })
+
+    sum |> should equal 55 // task-dummies started at 1
+}

src/FSharpy.TaskSeq.Test/TaskSeq.Map.Tests.fs

@@ -0,0 +1,34 @@
+module FSharpy.TaskSeq.Tests.Map
+
+open Xunit
+open FsUnit.Xunit
+open FsToolkit.ErrorHandling
+
+open FSharpy
+
+
+[<Fact>]
+let ``TaskSeq-map maps in correct order`` () = task {
+    let! sq =
+        createDummyTaskSeq 10
+        |> TaskSeq.map (fun item -> char (item + 64))
+        |> TaskSeq.toSeqCachedAsync
+
+    sq
+    |> Seq.map string
+    |> String.concat ""
+    |> should equal "ABCDEFGHIJ"
+}
+
+[<Fact>]
+let ``TaskSeq-mapAsync maps in correct order`` () = task {
+    let! sq =
+        createDummyTaskSeq 10
+        |> TaskSeq.mapAsync (fun item -> task { return char (item + 64) })
+        |> TaskSeq.toSeqCachedAsync
+
+    sq
+    |> Seq.map string
+    |> String.concat ""
+    |> should equal "ABCDEFGHIJ"
+}

src/FSharpy.TaskSeq.Test/TaskSeq.OfXXX.Tests.fs

@@ -0,0 +1,57 @@
+module FSharpy.TaskSeq.Tests.``Conversion-From``
+
+open Xunit
+open FsUnit.Xunit
+open FsToolkit.ErrorHandling
+
+open FSharpy
+
+let validateSequence sq = task {
+    let! sq = TaskSeq.toArrayAsync sq
+    do sq |> Seq.toArray |> should equal [| 0..9 |]
+}
+
+[<Fact>]
+let ``TaskSeq-ofAsyncArray should succeed`` () =
+    Array.init 10 (fun x -> async { return x })
+    |> TaskSeq.ofAsyncArray
+    |> validateSequence
+
+[<Fact>]
+let ``TaskSeq-ofAsyncList should succeed`` () =
+    List.init 10 (fun x -> async { return x })
+    |> TaskSeq.ofAsyncList
+    |> validateSequence
+
+[<Fact>]
+let ``TaskSeq-ofAsyncSeq should succeed`` () =
+    Seq.init 10 (fun x -> async { return x })
+    |> TaskSeq.ofAsyncSeq
+    |> validateSequence
+
+[<Fact>]
+let ``TaskSeq-ofTaskArray should succeed`` () =
+    Array.init 10 (fun x -> task { return x })
+    |> TaskSeq.ofTaskArray
+    |> validateSequence
+
+[<Fact>]
+let ``TaskSeq-ofTaskList should succeed`` () =
+    List.init 10 (fun x -> task { return x })
+    |> TaskSeq.ofTaskList
+    |> validateSequence
+
+[<Fact>]
+let ``TaskSeq-ofTaskSeq should succeed`` () =
+    Seq.init 10 (fun x -> task { return x })
+    |> TaskSeq.ofTaskSeq
+    |> validateSequence
+
+[<Fact>]
+let ``TaskSeq-ofArray should succeed`` () = Array.init 10 id |> TaskSeq.ofArray |> validateSequence
+
+[<Fact>]
+let ``TaskSeq-ofList should succeed`` () = List.init 10 id |> TaskSeq.ofList |> validateSequence
+
+[<Fact>]
+let ``TaskSeq-ofSeq should succeed`` () = Seq.init 10 id |> TaskSeq.ofSeq |> validateSequence

src/FSharpy.TaskSeq.Test/TaskSeq.Tests.fs

@@ -1,143 +1,15 @@
-namespace FSharpy.TaskSeq.Tests
+module FSharpy.TaskSeq.Tests.``Utility functions``
 
 open Xunit
 open FsUnit.Xunit
 open FsToolkit.ErrorHandling
 
 open FSharpy
 
-module TaskSeqTests =
-    let createTaskSeq count =
-        /// Set of delayed tasks in the form of `unit -> Task<int>`
-        let tasks = DummyTaskFactory().CreateDelayedTasks count
 
-        taskSeq {
-            for task in tasks do
-                // cannot use `yield!` here, as `taskSeq` expects it to return a seq
-                let! x = task ()
-                yield x
-        }
-
-    [<Fact>]
-    let ``TaskSeq-iteri should go over all items`` () = task {
-        let tq = createTaskSeq 10
-        let mutable sum = 0
-        do! tq |> TaskSeq.iteri (fun i _ -> sum <- sum + i)
-        sum |> should equal 45 // index starts at 0
-    }
-
-    [<Fact>]
-    let ``TaskSeq-iter should go over all items`` () = task {
-        let tq = createTaskSeq 10
-        let mutable sum = 0
-        do! tq |> TaskSeq.iter (fun item -> sum <- sum + item)
-        sum |> should equal 55 // task-dummies started at 1
-    }
-
-    [<Fact>]
-    let ``TaskSeq-iteriAsync should go over all items`` () = task {
-        let tq = createTaskSeq 10
-        let mutable sum = 0
-
-        do!
-            tq
-            |> TaskSeq.iteriAsync (fun i _ -> task { sum <- sum + i })
-
-        sum |> should equal 45 // index starts at 0
-    }
-
-    [<Fact>]
-    let ``TaskSeq-iterAsync should go over all items`` () = task {
-        let tq = createTaskSeq 10
-        let mutable sum = 0
-
-        do!
-            tq
-            |> TaskSeq.iterAsync (fun item -> task { sum <- sum + item })
-
-        sum |> should equal 55 // task-dummies started at 1
-    }
-
-    [<Fact>]
-    let ``TaskSeq-map maps in correct order`` () = task {
-        let! sq =
-            createTaskSeq 10
-            |> TaskSeq.map (fun item -> char (item + 64))
-            |> TaskSeq.toSeqCachedAsync
-
-        sq
-        |> Seq.map string
-        |> String.concat ""
-        |> should equal "ABCDEFGHIJ"
-    }
-
-    [<Fact>]
-    let ``TaskSeq-mapAsync maps in correct order`` () = task {
-        let! sq =
-            createTaskSeq 10
-            |> TaskSeq.mapAsync (fun item -> task { return char (item + 64) })
-            |> TaskSeq.toSeqCachedAsync
-
-        sq
-        |> Seq.map string
-        |> String.concat ""
-        |> should equal "ABCDEFGHIJ"
-    }
-
-    [<Fact>]
-    let ``TaskSeq-collect operates in correct order`` () = task {
-        let! sq =
-            createTaskSeq 10
-            |> TaskSeq.collect (fun item -> taskSeq {
-                yield char (item + 64)
-                yield char (item + 65)
-            })
-            |> TaskSeq.toSeqCachedAsync
-
-        sq
-        |> Seq.map string
-        |> String.concat ""
-        |> should equal "ABBCCDDEEFFGGHHIIJJK"
-    }
-
-    [<Fact>]
-    let ``TaskSeq-collectSeq operates in correct order`` () = task {
-        let! sq =
-            createTaskSeq 10
-            |> TaskSeq.collectSeq (fun item -> seq {
-                yield char (item + 64)
-                yield char (item + 65)
-            })
-            |> TaskSeq.toSeqCachedAsync
-
-        sq
-        |> Seq.map string
-        |> String.concat ""
-        |> should equal "ABBCCDDEEFFGGHHIIJJK"
-    }
-
-    [<Fact>]
-    let ``TaskSeq-collect with empty task sequences`` () = task {
-        let! sq =
-            createTaskSeq 10
-            |> TaskSeq.collect (fun _ -> TaskSeq.ofSeq Seq.empty)
-            |> TaskSeq.toSeqCachedAsync
-
-        Seq.isEmpty sq |> should be True
-    }
-
-    [<Fact>]
-    let ``TaskSeq-collectSeq with empty sequences`` () = task {
-        let! sq =
-            createTaskSeq 10
-            |> TaskSeq.collectSeq (fun _ -> Seq.empty<int>)
-            |> TaskSeq.toSeqCachedAsync
-
-        Seq.isEmpty sq |> should be True
-    }
-
-    [<Fact>]
-    let ``TaskSeq-empty is empty`` () = task {
-        let! sq = TaskSeq.empty<string> |> TaskSeq.toSeqCachedAsync
-        Seq.isEmpty sq |> should be True
-    }
+[<Fact>]
+let ``TaskSeq-empty is empty`` () = task {
+    let! sq = TaskSeq.empty<string> |> TaskSeq.toSeqCachedAsync
+    Seq.isEmpty sq |> should be True
+    Seq.length sq |> should equal 0
+}