Merge pull request #89 from fossa-app/split-client-result-helpers

Add ergonomic helpers for client results

Author: tiksn

src/Bridge/Models/Helpers/ClientResultHelpers.fs

@@ -9,19 +9,49 @@ module ClientResultHelpers =
     let problem<'T when 'T: not struct and 'T: not null> (problem: ProblemDetailsModel) : ClientResult<'T> =
         ClientResult.Failure problem
 
-    let matchClientResult<'T, 'TResult when 'T: not struct and 'T: not null>
+    let mapClientResult<'T, 'U when 'T: not struct and 'T: not null and 'U: not struct and 'U: not null>
+        (result: ClientResult<'T>)
+        (mapSuccess: 'T -> 'U)
+        : ClientResult<'U> =
+        match result with
+        | ClientResult.Success value -> ClientResult.Success(mapSuccess value)
+        | ClientResult.Failure problem -> ClientResult.Failure problem
+
+    let foldClientResult<'T, 'TResult when 'T: not struct and 'T: not null>
         (result: ClientResult<'T>)
         (onSuccess: 'T -> 'TResult)
         (onFailure: ProblemDetailsModel -> 'TResult)
         : 'TResult =
-        result.Match(onSuccess, onFailure)
+        match result with
+        | ClientResult.Success value -> onSuccess value
+        | ClientResult.Failure problem -> onFailure problem
 
-    let matchClientUnitResult<'TResult>
+    let foldClientUnitResult<'TResult>
         (result: ClientUnitResult)
         (onSuccess: unit -> 'TResult)
         (onFailure: ProblemDetailsModel -> 'TResult)
         : 'TResult =
-        result.Match(onSuccess, onFailure)
+        match result with
+        | ClientUnitResult.Success -> onSuccess ()
+        | ClientUnitResult.Failure problem -> onFailure problem
+
+    let handleClientResult<'T when 'T: not struct and 'T: not null>
+        (result: ClientResult<'T>)
+        (onSuccess: 'T -> unit)
+        (onFailure: ProblemDetailsModel -> unit)
+        : unit =
+        match result with
+        | ClientResult.Success value -> onSuccess value
+        | ClientResult.Failure problem -> onFailure problem
+
+    let handleClientUnitResult
+        (result: ClientUnitResult)
+        (onSuccess: unit -> unit)
+        (onFailure: ProblemDetailsModel -> unit)
+        : unit =
+        match result with
+        | ClientUnitResult.Success -> onSuccess ()
+        | ClientUnitResult.Failure problem -> onFailure problem
 
     let isClientSuccess (result: IClientResult) : bool = result.IsSuccess
 

tests/Bridge.Tests/ClientResultTests.fs

@@ -39,9 +39,23 @@ let tests =
           <| fun _ ->
               let result = ClientResultHelpers.success "bridge"
 
-              let matched = ClientResultHelpers.matchClientResult result id (fun _ -> "problem")
+              let mapped =
+                  ClientResultHelpers.mapClientResult result (fun value -> value + "-mapped")
 
-              Expect.equal matched "bridge" "Match should return success value"
+              let folded = ClientResultHelpers.foldClientResult result id (fun _ -> "problem")
+              let mutable successHandled = false
+              let mutable failureHandled = false
+
+              ClientResultHelpers.handleClientResult result (fun value -> successHandled <- value = "bridge") (fun _ ->
+                  failureHandled <- true)
+
+              match mapped with
+              | ClientResult.Success value -> Expect.equal value "bridge-mapped" "Map should transform success value"
+              | ClientResult.Failure _ -> failtest "Expected mapped success"
+
+              Expect.equal folded "bridge" "Fold should return success projection"
+              Expect.isTrue successHandled "Handle should invoke success callback"
+              Expect.isFalse failureHandled "Handle should not invoke failure callback"
               Expect.isTrue (ClientResultHelpers.isClientSuccess result) "Result should be success"
               Expect.isFalse (ClientResultHelpers.isClientFailure result) "Result should not be failure"
               Expect.equal (ClientResultHelpers.getClientValue result) (Some "bridge") "Value should be available"
@@ -51,11 +65,30 @@ let tests =
           testCase "ergonomic helpers expose failure result"
           <| fun _ ->
               let result: ClientResult<string> = ClientResultHelpers.problem problem
+              let mutable mapCalled = false
+
+              let mapped =
+                  ClientResultHelpers.mapClientResult result (fun value ->
+                      mapCalled <- true
+                      value + "-mapped")
+
+              let folded =
+                  ClientResultHelpers.foldClientResult result id (fun actual -> string actual.title)
+
+              let mutable successHandled = false
+              let mutable failureHandled = false
+
+              ClientResultHelpers.handleClientResult result (fun _ -> successHandled <- true) (fun actual ->
+                  failureHandled <- actual = problem)
 
-              let matched =
-                  ClientResultHelpers.matchClientResult result id (fun actual -> string actual.title)
+              match mapped with
+              | ClientResult.Success _ -> failtest "Expected mapped failure"
+              | ClientResult.Failure actual -> Expect.equal actual problem "Map should preserve problem"
 
-              Expect.equal matched (string problem.title) "Match should return problem projection"
+              Expect.isFalse mapCalled "Map should not invoke success mapper for failure"
+              Expect.equal folded (string problem.title) "Fold should return problem projection"
+              Expect.isFalse successHandled "Handle should not invoke success callback"
+              Expect.isTrue failureHandled "Handle should invoke failure callback"
               Expect.isFalse (ClientResultHelpers.isClientSuccess result) "Result should not be success"
               Expect.isTrue (ClientResultHelpers.isClientFailure result) "Result should be failure"
               Expect.equal (ClientResultHelpers.getClientValue result) None "Value should not be available"

tests/Bridge.Tests/ClientUnitResultTests.fs

@@ -39,10 +39,18 @@ let tests =
           <| fun _ ->
               let result = ClientUnitResultHelpers.success
 
-              let matched =
-                  ClientResultHelpers.matchClientUnitResult result (fun () -> "ok") (fun _ -> "problem")
+              let folded =
+                  ClientResultHelpers.foldClientUnitResult result (fun () -> "ok") (fun _ -> "problem")
 
-              Expect.equal matched "ok" "Match should return success projection"
+              let mutable successHandled = false
+              let mutable failureHandled = false
+
+              ClientResultHelpers.handleClientUnitResult result (fun () -> successHandled <- true) (fun _ ->
+                  failureHandled <- true)
+
+              Expect.equal folded "ok" "Fold should return success projection"
+              Expect.isTrue successHandled "Handle should invoke success callback"
+              Expect.isFalse failureHandled "Handle should not invoke failure callback"
               Expect.isTrue (ClientResultHelpers.isClientSuccess result) "Result should be success"
               Expect.isFalse (ClientResultHelpers.isClientFailure result) "Result should not be failure"
               Expect.equal (ClientResultHelpers.getClientProblem result) None "Problem should not be available"
@@ -52,10 +60,18 @@ let tests =
           <| fun _ ->
               let result = ClientUnitResultHelpers.problem problem
 
-              let matched =
-                  ClientResultHelpers.matchClientUnitResult result (fun () -> "ok") (fun actual -> string actual.title)
+              let folded =
+                  ClientResultHelpers.foldClientUnitResult result (fun () -> "ok") (fun actual -> string actual.title)
+
+              let mutable successHandled = false
+              let mutable failureHandled = false
+
+              ClientResultHelpers.handleClientUnitResult result (fun () -> successHandled <- true) (fun actual ->
+                  failureHandled <- actual = problem)
 
-              Expect.equal matched (string problem.title) "Match should return problem projection"
+              Expect.equal folded (string problem.title) "Fold should return problem projection"
+              Expect.isFalse successHandled "Handle should not invoke success callback"
+              Expect.isTrue failureHandled "Handle should invoke failure callback"
               Expect.isFalse (ClientResultHelpers.isClientSuccess result) "Result should not be success"
               Expect.isTrue (ClientResultHelpers.isClientFailure result) "Result should be failure"
               Expect.equal (ClientResultHelpers.getClientProblem result) (Some problem) "Problem should be available"