[feat]: Added tests and utility functions for Optimistic helper type based on PR feedback.

what changed?: added tests for Optimistic helper type; Also added utility functions for Optimistic helper type
why?: from pr feedback
effect?: better tested library

Author: aplikethewatch

src/SAFE.Client/SAFE.fs

@@ -208,3 +208,45 @@ type Optimistic<'T> = {
             Value = this.Prev
             Prev = None
         }
+
+    /// Maps the underlying optimistic value, when it exists, into another shape.
+    member this.Map (f: 'T -> 'U) =
+        {
+            Value = Option.map f this.Value
+            Prev = Option.map f this.Prev
+        }
+        
+    /// Binds both current and previous values using the provided function
+    member this.Bind (f: 'T -> Optimistic<'U>) =
+        match this.Value with
+        | Some v -> f v  // Just use the result directly
+        | None -> { Value = None; Prev = None }
+        
+    /// Returns the current value as an option
+    member this.AsOption = this.Value
+
+/// Module containing functions for working with Optimistic type
+module Optimistic =
+    /// Creates a new Optimistic value with no history
+    let create value = { Value = Some value; Prev = None }
+    
+    /// Creates an empty Optimistic value
+    let empty = { Value = None; Prev = None }
+    
+    /// Updates the current value, shifting existing value to previous
+    let update value (optimistic: Optimistic<'T>) = optimistic.Update value
+    
+    /// Rolls back to the previous value
+    let rollback (optimistic: Optimistic<'T>) = optimistic.Rollback()
+    
+    /// Maps both current and previous values
+    let map f (optimistic: Optimistic<'T>) = optimistic.Map f
+    
+    /// Binds both current and previous values
+    let bind f (optimistic: Optimistic<'T>) = optimistic.Bind f
+    
+    /// Returns the current value as an option
+    let asOption (optimistic: Optimistic<'T>) = optimistic.AsOption
+    
+    /// Returns the previous value as an option
+    let asPrevOption optimistic = optimistic.Prev

test/SAFE.Client.Tests/Program.fs

@@ -125,5 +125,72 @@ let remoteData =
             | RemoteDataCase.Loaded -> Loading (Some true))
     ]
 
+let optimistic =
+    testList "Optimistic" [
+        testList "create" [
+            testCase "creates new value with no history" <| fun _ ->
+                let opt = Optimistic.create 42
+                Expect.equal opt.Value (Some 42) "Current value should be set"
+                Expect.equal opt.Prev None "Previous value should be None"
+        ]
+        
+        testList "empty" [
+            testCase "creates empty optimistic value" <| fun _ ->
+                let opt = Optimistic.empty
+                Expect.equal opt.Value None "Current value should be None"
+                Expect.equal opt.Prev None "Previous value should be None"
+        ]
+        
+        testList "update" [
+            testCase "updates value and shifts previous" <| fun _ ->
+                let opt = Optimistic.create 42
+                let updated = opt.Update 84
+                Expect.equal updated.Value (Some 84) "Current value should be updated"
+                Expect.equal updated.Prev (Some 42) "Previous value should be old current"
+        ]
+        
+        testList "rollback" [
+            testCase "rolls back to previous value" <| fun _ ->
+                let opt = Optimistic.create 42 |> Optimistic.update 84
+                let rolled = opt.Rollback()
+                Expect.equal rolled.Value (Some 42) "Current value should be previous"
+                Expect.equal rolled.Prev None "Previous value should be cleared"
+        ]
+        
+        testList "map" [
+            testCase "maps both values" <| fun _ ->
+                let opt = { Value = Some 42; Prev = Some 21 }
+                let mapped = opt.Map string
+                Expect.equal mapped.Value (Some "42") "Current value should be mapped"
+                Expect.equal mapped.Prev (Some "21") "Previous value should be mapped"
+        ]
+        
+        testList "bind" [
+            testCase "binds value with history" <| fun _ ->
+                let opt = { Value = Some 42; Prev = Some 21 }
+                let bound = opt.Bind (fun x -> { Value = Some (string x); Prev = None})
+                Expect.equal bound.Value (Some "42") "Current value should be bound"
+                Expect.equal bound.Prev (None) "Previous value should be bound"
+        ]
+        
+        testList "asOption" [
+            testCase "returns current value as option" <| fun _ ->
+                let opt = Optimistic.create 42
+                Expect.equal (Optimistic.asOption opt) (Some 42) "Should return current value"
+        ]
+        
+        testList "asPrevOption" [
+            testCase "returns previous value as option" <| fun _ ->
+                let opt = Optimistic.create 42 |> Optimistic.update 84
+                Expect.equal (Optimistic.asPrevOption opt) (Some 42) "Should return previous value"
+        ]
+    ]
+
+let allTests = 
+    testList "All Tests" [
+        remoteData
+        optimistic
+    ]
+
 [<EntryPoint>]
-let main _ = Mocha.runTests remoteData
+let main _ = Mocha.runTests allTests