Add tests for zip/zipError in AsyncResult/TaskResult/JobResult

Author: sep2

tests/FsToolkit.ErrorHandling.JobResult.Tests/JobResult.fs

@@ -482,6 +482,48 @@ let catchTests =
     testCase "catch returns unmapped error without exception" <| fun _ ->
       Expect.hasJobErrorValue "unmapped" (JobResult.catch f (toJob (Error "unmapped")))
   ]
+  
+
+[<Tests>]
+let zipTests =
+  testList "JobResult.zip tests" [
+    testCase "Ok, Ok" <| fun _ ->
+      let v = JobResult.zip (toJob (Ok 1)) (toJob (Ok 2))
+      Expect.hasJobValue (Ok(1, 2)) v
+      
+    testCase "Ok, Error" <| fun _ ->
+      let v = JobResult.zip (toJob (Ok 1)) (toJob (Error "Bad"))
+      Expect.hasJobValue (Error("Bad")) v
+      
+    testCase "Error, Ok" <| fun _ ->
+      let v = JobResult.zip (toJob (Error "Bad")) (toJob (Ok 1))
+      Expect.hasJobValue (Error("Bad")) v
+      
+    testCase "Error, Error" <| fun _ ->
+      let v = JobResult.zip (toJob (Error "Bad1")) (toJob (Error "Bad2"))
+      Expect.hasJobValue (Error("Bad1")) v
+  ]
+
+[<Tests>]
+let zipErrorTests =
+  testList "JobResult.zipError tests" [
+    testCase "Ok, Ok" <| fun _ ->
+      let v = JobResult.zipError (toJob (Ok 1)) (toJob (Ok 2))
+      Expect.hasJobValue (Ok(1)) v
+      
+    testCase "Ok, Error" <| fun _ ->
+      let v = JobResult.zipError (toJob (Ok 1)) (toJob (Error "Bad"))
+      Expect.hasJobValue (Ok 1) v
+      
+    testCase "Error, Ok" <| fun _ ->
+      let v = JobResult.zipError (toJob (Error "Bad")) (toJob (Ok 1))
+      Expect.hasJobValue (Ok 1) v
+      
+    testCase "Error, Error" <| fun _ ->
+      let v = JobResult.zipError (toJob (Error "Bad1")) (toJob (Error "Bad2"))
+      Expect.hasJobValue (Error("Bad1", "Bad2")) v
+  ]
+
 
 type CreatePostResult =
 | PostSuccess of NotifyNewPostRequest

tests/FsToolkit.ErrorHandling.TaskResult.Tests/TaskResult.fs

@@ -483,6 +483,46 @@ let catchTests =
       Expect.hasTaskErrorValue "unmapped" (TaskResult.catch f (toTask (Error "unmapped")))
   ]
 
+[<Tests>]
+let zipTests =
+  testList "TaskResult.zip tests" [
+    testCase "Ok, Ok" <| fun _ ->
+      let v = TaskResult.zip (toTask (Ok 1)) (toTask (Ok 2))
+      Expect.hasTaskValue (Ok(1, 2)) v
+      
+    testCase "Ok, Error" <| fun _ ->
+      let v = TaskResult.zip (toTask (Ok 1)) (toTask (Error "Bad"))
+      Expect.hasTaskValue (Error("Bad")) v
+      
+    testCase "Error, Ok" <| fun _ ->
+      let v = TaskResult.zip (toTask (Error "Bad")) (toTask (Ok 1))
+      Expect.hasTaskValue (Error("Bad")) v
+      
+    testCase "Error, Error" <| fun _ ->
+      let v = TaskResult.zip (toTask (Error "Bad1")) (toTask (Error "Bad2"))
+      Expect.hasTaskValue (Error("Bad1")) v
+  ]
+
+[<Tests>]
+let zipErrorTests =
+  testList "TaskResult.zipError tests" [
+    testCase "Ok, Ok" <| fun _ ->
+      let v = TaskResult.zipError (toTask (Ok 1)) (toTask (Ok 2))
+      Expect.hasTaskValue (Ok(1)) v
+      
+    testCase "Ok, Error" <| fun _ ->
+      let v = TaskResult.zipError (toTask (Ok 1)) (toTask (Error "Bad"))
+      Expect.hasTaskValue (Ok 1) v
+      
+    testCase "Error, Ok" <| fun _ ->
+      let v = TaskResult.zipError (toTask (Error "Bad")) (toTask (Ok 1))
+      Expect.hasTaskValue (Ok 1) v
+      
+    testCase "Error, Error" <| fun _ ->
+      let v = TaskResult.zipError (toTask (Error "Bad1")) (toTask (Error "Bad2"))
+      Expect.hasTaskValue (Error("Bad1", "Bad2")) v
+  ]
+
 type CreatePostResult =
 | PostSuccess of NotifyNewPostRequest
 | NotAllowedToPost

tests/FsToolkit.ErrorHandling.Tests/AsyncResult.fs

@@ -547,6 +547,49 @@ let asyncResultOperatorTests =
         |> Expect.hasAsyncOkValue (PostId newPostId)
     }
   ]
+  
+
+let zipTests = 
+  testList "AsyncResult.zip Tests" [
+    testCaseAsync "Ok, Ok" <| async {
+      let! v = AsyncResult.zip (toAsync (Ok 1)) (toAsync (Ok 2))
+      Expect.equal v (Ok(1, 2)) "Should be ok"
+    }
+    testCaseAsync "Ok, Error" <| async {
+      let! v = AsyncResult.zip (toAsync (Ok 1)) (toAsync (Error "Bad"))
+      Expect.equal v (Error("Bad")) "Should be Error"
+    }
+    testCaseAsync "Error, Ok" <| async {
+      let! v = AsyncResult.zip (toAsync (Error "Bad")) (toAsync (Ok 1))
+      Expect.equal v (Error("Bad")) "Should be Error"
+    }
+    testCaseAsync "Error, Error" <| async {
+      let! v = AsyncResult.zip (toAsync (Error "Bad1")) (toAsync (Error "Bad2"))
+      Expect.equal v (Error("Bad1")) "Should be Error"
+    }
+  ]
+
+
+let zipErrorTests = 
+  testList "AsyncResult.zipError Tests" [
+    testCaseAsync "Ok, Ok" <| async {
+      let! v = AsyncResult.zipError (toAsync (Ok 1)) (toAsync (Ok 2))
+      Expect.equal v (Ok(1)) "Should be ok"
+    }
+    testCaseAsync "Ok, Error" <| async {
+      let! v = AsyncResult.zipError (toAsync (Ok 1)) (toAsync (Error "Bad"))
+      Expect.equal v (Ok 1) "Should be ok"
+    }
+    testCaseAsync "Error, Ok" <| async {
+      let! v = AsyncResult.zipError (toAsync (Error "Bad")) (toAsync (Ok 1))
+      Expect.equal v (Ok 1) "Should be ok"
+    }
+    testCaseAsync "Error, Error" <| async {
+      let! v = AsyncResult.zipError (toAsync (Error "Bad1")) (toAsync (Error "Bad2"))
+      Expect.equal v (Error("Bad1", "Bad2")) "Should be Error"
+    }
+  ]
+
 
 let allTests = testList "Async Result tests" [
   mapTests
@@ -576,4 +619,6 @@ let allTests = testList "Async Result tests" [
   catchTests
   asyncResultCETests
   asyncResultOperatorTests
+  zipTests
+  zipErrorTests
 ]