Updated unit tests

Author: 1eyewonder

tests/FsToolkit.ErrorHandling.Tests/AsyncValidationCE.fs

@@ -154,11 +154,11 @@ let ``AsyncValidationCE bind Tests`` =
         testCaseAsync "let! Error Validation"
         <| async {
             let innerData = "Foo"
-            let! expected = AsyncValidation.error innerData
+            let expected = Error [ innerData ]
 
             let! actual =
                 asyncValidation {
-                    let! f = validation { return Error innerData }
+                    let! f = validation { return! expected }
                     return f
                 }
 
@@ -173,8 +173,8 @@ let ``AsyncValidationCE bind Tests`` =
         testCaseAsync "do! Error result"
         <| async {
             let innerData = ()
-            let! expected = AsyncValidation.error innerData
             let data = Result.Error innerData
+            let! expected = AsyncValidation.error innerData
             let! actual = asyncValidation { do! data }
             Expect.equal actual expected "Should be error"
         }

tests/FsToolkit.ErrorHandling.Tests/Main.fs

@@ -4,14 +4,16 @@ module FsToolkit.ErrorHandling.Tests
 open Fable.Mocha
 #else
 open Expecto
-
-[<Tests>] //needed for `dotnet test` to work
 #endif
+
+//needed for `dotnet test` to work
+[<Tests>]
 let allTests =
     testList "All Tests" [
         ResultTests.allTests
         ResultCETests.allTests
         ResultOptionTests.allTests
+        ResultOptionCETests.allTests
         OptionTests.allTests
         OptionCETests.allTests
         AsyncOptionTests.allTests
@@ -22,6 +24,8 @@ let allTests =
         AsyncResultCETests.allTests
         AsyncResultOptionTests.allTests
         AsyncResultOptionCETests.allTests
+        AsyncValidationTests.allTests
+        AsyncValidationCETests.allTests
         ValidationTests.allTests
         ValidationCETests.allTests
         ValueOptionTests.allTests

tests/FsToolkit.ErrorHandling.Tests/ResultOption.fs

@@ -207,6 +207,86 @@ let resultOptionOperatorsTests =
             |> Expect.hasOkValue (Some validURL)
     ]
 
+let zipTests =
+    testList "zip tests" [
+        testCase "Ok Some, Ok Some"
+        <| fun () ->
+            let actual = ResultOption.zip (Ok(Some 1)) (Ok(Some 2))
+            Expect.equal actual (Ok(Some(1, 2))) "Should be ok some"
+        testCase "Ok None, Ok None"
+        <| fun () ->
+            let actual = ResultOption.zip (Ok None) (Ok None)
+            Expect.equal actual (Ok None) "Should be ok none"
+        testCase "Ok Some, Ok None"
+        <| fun () ->
+            let actual = ResultOption.zip (Ok(Some 1)) (Ok None)
+            Expect.equal actual (Ok None) "Should be ok none"
+        testCase "Ok None, Ok Some"
+        <| fun () ->
+            let actual = ResultOption.zip (Ok None) (Ok(Some 1))
+            Expect.equal actual (Ok None) "Should be ok none"
+        testCase "Ok Some, Error"
+        <| fun () ->
+            let actual = ResultOption.zip (Ok(Some 1)) (Error "Bad")
+            Expect.equal actual (Error "Bad") "Should be Error"
+        testCase "Error, Ok Some"
+        <| fun () ->
+            let actual = ResultOption.zip (Error "Bad") (Ok(Some 1))
+            Expect.equal actual (Error "Bad") "Should be Error"
+        testCase "Ok None, Error"
+        <| fun () ->
+            let actual = ResultOption.zip (Ok None) (Error "Bad")
+            Expect.equal actual (Error "Bad") "Should be Error"
+        testCase "Error, Ok None"
+        <| fun () ->
+            let actual = ResultOption.zip (Error "Bad") (Ok None)
+            Expect.equal actual (Error "Bad") "Should be Error"
+        testCase "Error, Error"
+        <| fun () ->
+            let actual = ResultOption.zip (Error "Bad1") (Error "Bad2")
+            Expect.equal actual (Error "Bad1") "Should be Error"
+    ]
+
+let zipErrorTests =
+    testList "zipError tests" [
+        testCase "Ok Some, Ok Some"
+        <| fun () ->
+            let actual = ResultOption.zipError (Ok(Some 1)) (Ok(Some 2))
+            Expect.equal actual (Ok(Some 1)) "Should be ok some"
+        testCase "Ok None, Ok None"
+        <| fun () ->
+            let actual = ResultOption.zipError (Ok None) (Ok None)
+            Expect.equal actual (Ok None) "Should be ok none"
+        testCase "Ok Some, Ok None"
+        <| fun () ->
+            let actual = ResultOption.zipError (Ok(Some 1)) (Ok None)
+            Expect.equal actual (Ok(Some 1)) "Should be ok some"
+        testCase "Ok None, Ok Some"
+        <| fun () ->
+            let actual = ResultOption.zipError (Ok None) (Ok(Some 1))
+            Expect.equal actual (Ok None) "Should be ok none"
+        testCase "Ok Some, Error"
+        <| fun () ->
+            let actual = ResultOption.zipError (Ok(Some 1)) (Error "Bad")
+            Expect.equal actual (Ok(Some 1)) "Should be ok some"
+        testCase "Error, Ok Some"
+        <| fun () ->
+            let actual = ResultOption.zipError (Error "Bad") (Ok(Some 1))
+            Expect.equal actual (Ok(Some 1)) "Should be ok some"
+        testCase "Ok None, Error"
+        <| fun () ->
+            let actual = ResultOption.zipError (Ok None) (Error "Bad")
+            Expect.equal actual (Ok None) "Should be ok none"
+        testCase "Error, Ok None"
+        <| fun () ->
+            let actual = ResultOption.zipError (Error "Bad") (Ok None)
+            Expect.equal actual (Ok None) "Should be ok none"
+        testCase "Error, Error"
+        <| fun () ->
+            let actual = ResultOption.zipError (Error "Bad1") (Error "Bad2")
+            Expect.equal actual (Error("Bad1", "Bad2")) "Should be Error tuple"
+    ]
+
 let allTests =
     testList "Result Option Tests" [
         map2Tests
@@ -217,4 +297,6 @@ let allTests =
         ignoreTests
         resultOptionCETests
         resultOptionOperatorsTests
+        zipTests
+        zipErrorTests
     ]

tests/FsToolkit.ErrorHandling.Tests/ResultOptionCE.fs

@@ -183,13 +183,7 @@ let ``ResultOptionCE bind Tests`` =
                 let data = ()
                 let actual = resultOption { do! None }
 
-                Expect.equal actual (Ok(Some data)) "Should be ok some"
-
-            testCase "Error result"
-            <| fun _ ->
-                let data = Error()
-                let actual = resultOption { do! data }
-                Expect.equal actual (data) "Should be ok"
+                Expect.equal actual (Ok None) "Should be ok none"
 
             testCase "Ok Choice"
             <| fun _ ->