Updated AsyncValidation due to discovery in CancellableTaskValidation tests

Author: 1eyewonder

src/FsToolkit.ErrorHandling.IcedTasks/CancellableTaskValidationCE.fs

@@ -812,7 +812,7 @@ module CancellableTaskValidationCE =
                 this.ReturnFrom(Async.AwaitCancellableTaskValidation t)
 
 
-        type FsToolkit.ErrorHandling.AsyncResultCE.AsyncResultBuilder with
+        type FsToolkit.ErrorHandling.AsyncValidationCE.AsyncValidationBuilder with
 
             member inline this.Source
                 ([<InlineIfLambda>] t: CancellableTaskValidation<'T, 'Error>)

src/FsToolkit.ErrorHandling/AsyncValidationCE.fs

@@ -139,26 +139,54 @@ module AsyncValidationCE =
     let asyncValidation = AsyncValidationBuilder()
 
 [<AutoOpen>]
-module AsyncValidationCEExtensions =
+module HighPriority =
 
     // Having members as extensions gives them lower priority in
     // overload resolution and allows skipping more type annotations.
     type AsyncValidationBuilder with
 
         /// <summary>
-        /// Needed to allow `for..in` and `for..do` functionality
+        /// Method lets us transform data types into our internal representation.
         /// </summary>
-        member inline _.Source(s: #seq<_>) : #seq<_> = s
+        member inline _.Source(s: Async<Result<'ok, 'error>>) : AsyncValidation<_, 'error> =
+            s
+            |> AsyncResult.mapError (fun e -> [ e ])
 
         /// <summary>
         /// Method lets us transform data types into our internal representation.
         /// </summary>
         member inline _.Source(s: Result<'ok, 'error>) : AsyncValidation<'ok, 'error> =
             AsyncValidation.ofResult s
 
+        /// <summary>
+        /// Method lets us transform data types into our internal representation.
+        /// </summary>
+        /// <returns></returns>
+        member inline _.Source(a: Async<'ok>) : AsyncValidation<'ok, 'error> =
+            async {
+                let! result = a
+                return! AsyncValidation.ok result
+            }
+
         /// <summary>
         /// Method lets us transform data types into our internal representation.
         /// </summary>
         /// <returns></returns>
         member inline _.Source(choice: Choice<'ok, 'error>) : AsyncValidation<'ok, 'error> =
             AsyncValidation.ofChoice choice
+
+        /// <summary>
+        /// Needed to allow `for..in` and `for..do` functionality
+        /// </summary>
+        member inline _.Source(s: #seq<_>) : #seq<_> = s
+
+[<AutoOpen>]
+module LowPriority =
+
+    type AsyncValidationBuilder with
+
+        /// <summary>
+        /// Method lets us transform data types into our internal representation.
+        /// </summary>
+        member inline _.Source(s: Validation<'ok, 'error>) : AsyncValidation<'ok, 'error> =
+            Async.retn s

tests/FsToolkit.ErrorHandling.IcedTasks.Tests/CancellableTaskValidationCE.fs

@@ -1088,7 +1088,39 @@ module CancellableTaskValidationCE =
                         Expect.equal actual expected "Should be Error"
                     }
 
-                testCaseTask "Fail Path Validation"
+                testCaseTask "Fail Path Error Validation"
+                <| fun () ->
+                    task {
+                        let expected =
+                            Error [
+                                "Error 1"
+                                "Error 2"
+                                "Error 3"
+                            ]
+
+                        let actual =
+                            cancellableTaskValidation {
+                                let! a = Ok 3
+                                and! b = Ok 2
+                                and! c = Error "Error 1"
+
+                                and! d =
+                                    Error [
+                                        "Error 2"
+                                        "Error 3"
+                                    ]
+
+                                return
+                                    a + b
+                                    - c
+                                    - d
+                            }
+
+                        let! actual = actual CancellationToken.None
+                        Expect.equal actual expected "Should be Error"
+                    }
+
+                testCaseTask "Fail Path Ok Validation"
                 <| fun () ->
                     task {
                         let expected = CancellableTaskValidation.error "TryParse failure"
@@ -1186,6 +1218,22 @@ module CancellableTaskValidationCE =
 
                     Expect.equal actual (Ok cts.Token) ""
 
+                testCase
+                    "CancellationToken flows from AsyncValidation<T> to CancellableTaskValidation<T>"
+                <| fun () ->
+                    let innerTask =
+                        cancellableTaskValidation {
+                            return! CancellableTaskValidation.getCancellationToken ()
+                        }
+
+                    let outerAsync = asyncValidation { return! innerTask }
+
+                    use cts = new CancellationTokenSource()
+
+                    let actual = Async.RunSynchronously(outerAsync, cancellationToken = cts.Token)
+
+                    Expect.equal actual (Ok cts.Token) ""
+
                 testCase "CancellationToken flows from CancellableTaskValidation<T> to Async<unit>"
                 <| fun () ->
                     let innerAsync = async { return! Async.CancellationToken }
@@ -1211,6 +1259,19 @@ module CancellableTaskValidationCE =
 
                     Expect.equal actual (Ok cts.Token) ""
 
+                testCase
+                    "CancellationToken flows from CancellableTaskValidation<T> to AsyncValidation<unit>"
+                <| fun () ->
+                    let innerAsync = asyncValidation { return! Async.CancellationToken }
+
+                    let outerTask = cancellableTaskValidation { return! innerAsync }
+
+                    use cts = new CancellationTokenSource()
+
+                    let actual = (outerTask cts.Token).GetAwaiter().GetResult()
+
+                    Expect.equal actual (Ok cts.Token) ""
+
                 testCase
                     "CancellationToken flows from CancellableTaskValidation<T> to CancellableTask<T>"
                 <| fun () ->

tests/FsToolkit.ErrorHandling.Tests/AsyncValidationCE.fs

@@ -57,14 +57,14 @@ let ``AsyncValidationCE return! Tests`` =
         testCaseAsync "Return Ok Validation"
         <| async {
             let innerData = "Foo"
-            let! data = AsyncValidation.ok innerData
+            let data = Validation.ok innerData
             let! actual = asyncValidation { return! data }
             Expect.equal actual (Result.Ok innerData) "Should be ok"
         }
         testCaseAsync "Return Error Validation"
         <| async {
             let innerData = "Foo"
-            let! expected = AsyncValidation.error innerData
+            let expected = Validation.error innerData
             let data = AsyncValidation.error innerData
             let! actual = asyncValidation { return! data }
             Expect.equal actual expected "Should be ok"
@@ -74,6 +74,18 @@ let ``AsyncValidationCE return! Tests`` =
 
 let ``AsyncValidationCE bind Tests`` =
     testList "AsyncValidationCE bind Tests" [
+        testCaseAsync "let! Async"
+        <| async {
+            let data = "Foo"
+
+            let! actual =
+                asyncValidation {
+                    let! f = async { return data }
+                    return f
+                }
+
+            Expect.equal actual (Ok data) "Should be ok"
+        }
         testCaseAsync "let! Ok result"
         <| async {
             let data = Result.Ok "Foo"
@@ -130,11 +142,10 @@ let ``AsyncValidationCE bind Tests`` =
         testCaseAsync "let! Ok Validation"
         <| async {
             let innerData = "Foo"
-            let! data = AsyncValidation.ok innerData
 
             let! actual =
                 asyncValidation {
-                    let! f = data
+                    let! f = validation { return innerData }
                     return f
                 }
 
@@ -143,12 +154,11 @@ let ``AsyncValidationCE bind Tests`` =
         testCaseAsync "let! Error Validation"
         <| async {
             let innerData = "Foo"
-            let data = AsyncValidation.error innerData
             let! expected = AsyncValidation.error innerData
 
             let! actual =
                 asyncValidation {
-                    let! f = data
+                    let! f = validation { return Error innerData }
                     return f
                 }