Fixes 4331 Handle null load state; add tests (#4349)

<!-- Please be sure to read our [Contribute
guide](https://www.reactiveui.net/contribute/index.html) before opening
a PR. -->

## What kind of change does this PR introduce?
<!-- Bug fix, feature, docs update, refactor, ci, ... -->
Fix
## What is the current behavior?
<!-- You can also link to an open issue here. Use "Closes #123" to
auto-close on merge. -->

Closes #4331

## What is the new behavior?
<!-- If this is a feature change -->

Do not assign a potentially-null loaded state directly to
AppState/AppStateValue.

Capture the result of ISuspensionDriver.LoadState into a local (object?
/ TAppState?) and assign item.AppState/item.AppStateValue to the loaded
value or fallback to CreateNewAppState/CreateNewAppStateTyped.

Add tests in SuspensionHostExtensionsTests and
SuspensionHostExtensionsAotTests that verify GetAppState creates and
stores a new app state when no persisted state exists.

Add ReturnNullOnLoad to TestSuspensionDriver to simulate drivers
returning null.

Change SuspensionHostTestExecutor to inherit from AppBuilderTestExecutor
and delegate ExecuteTest to the base implementation (and add the
required using).

These changes ensure null-returning drivers are handled safely and
covered by tests.

## What might this PR break?

## Checklist
- [x] I have read the [Contribute
guide](https://www.reactiveui.net/contribute/index.html)
- [x] Tests have been added or updated (for bug fixes / features)
- [ ] Docs have been added or updated (for bug fixes / features)
- [x] Changes target the `main` branch
- [x] PR title follows [Conventional
Commits](https://www.conventionalcommits.org/)

## Additional information

Author: ChrisPulman

src/ReactiveUI/Suspension/SuspensionHostExtensions.cs

@@ -284,16 +284,20 @@ private static IObservable<Unit> EnsureLoadAppState(this ISuspensionHost item, I
             return Observable.Return(Unit.Default);
         }
 
+        object? loadedState;
+
         try
         {
-            item.AppState = _suspensionDriver.LoadState().Wait();
+            loadedState = _suspensionDriver.LoadState().Wait();
         }
         catch (Exception ex)
         {
             item.Log().Warn(ex, "Failed to restore app state from storage, creating from scratch");
-            item.AppState = item.CreateNewAppState?.Invoke();
+            loadedState = null;
         }
 
+        item.AppState = loadedState ?? item.CreateNewAppState?.Invoke();
+
         return Observable.Return(Unit.Default);
     }
 
@@ -321,16 +325,20 @@ private static IObservable<Unit> EnsureLoadAppState<TAppState>(this ISuspensionH
             return Observable.Return(Unit.Default);
         }
 
+        TAppState? loadedState;
+
         try
         {
-            item.AppStateValue = _suspensionDriver.LoadState(typeInfo).Wait();
+            loadedState = _suspensionDriver.LoadState(typeInfo).Wait();
         }
         catch (Exception ex)
         {
             item.Log().Warn(ex, "Failed to restore app state from storage, creating from scratch");
-            item.AppStateValue = item.CreateNewAppStateTyped?.Invoke();
+            loadedState = null;
         }
 
+        item.AppStateValue = loadedState ?? item.CreateNewAppStateTyped?.Invoke();
+
         return Observable.Return(Unit.Default);
     }
 }

src/tests/ReactiveUI.Test.Utilities/SuspensionHost/SuspensionHostTestExecutor.cs

@@ -5,6 +5,8 @@
 
 using System.Reactive;
 
+using ReactiveUI.Tests.Utilities.AppBuilder;
+
 namespace ReactiveUI.Tests.Utilities.SuspensionHost;
 
 /// <summary>
@@ -17,21 +19,21 @@ namespace ReactiveUI.Tests.Utilities.SuspensionHost;
 /// - SuspensionHostExtensions.SuspensionDriver
 /// Tests using this executor should be marked with [NotInParallel] due to static state modifications.
 /// </remarks>
-public class SuspensionHostTestExecutor : ITestExecutor
+public class SuspensionHostTestExecutor : AppBuilderTestExecutor
 {
     private Func<IObservable<Unit>>? _previousEnsureLoadAppStateFunc;
     private ISuspensionDriver? _previousSuspensionDriver;
 
     /// <inheritdoc/>
-    public virtual async ValueTask ExecuteTest(TestContext context, Func<ValueTask> testAction)
+    public override async ValueTask ExecuteTest(TestContext context, Func<ValueTask> testAction)
     {
         ArgumentNullException.ThrowIfNull(testAction);
 
         SaveStaticState();
 
         try
         {
-            await testAction();
+            await base.ExecuteTest(context, testAction);
         }
         finally
         {

src/tests/ReactiveUI.Tests/Suspension/SuspensionHostExtensionsAotTests.cs

@@ -69,6 +69,36 @@ public async Task GetAppState_Typed_TriggersEnsureLoadAppState()
         await Assert.That(driver.LoadStateCallCount).IsEqualTo(1);
     }
 
+    [Test]
+    public async Task GetAppState_Typed_WhenNoPersistedState_CreatesAndStoresNewAppState()
+    {
+        var createdState = new TestAppState { Value = 99 };
+        var createNewAppStateCallCount = 0;
+        using var host = new SuspensionHost<TestAppState>
+        {
+            CreateNewAppStateTyped = () =>
+            {
+                createNewAppStateCallCount++;
+                return createdState;
+            },
+            IsLaunchingNew = Observable.Never<Unit>(),
+            IsResuming = Observable.Never<Unit>(),
+            ShouldPersistState = Observable.Never<IDisposable>(),
+            ShouldInvalidateState = Observable.Never<Unit>()
+        };
+
+        var driver = new TestSuspensionDriver<TestAppState>();
+
+        using var disposable = host.SetupDefaultSuspendResume(TestAppStateContext.Default.TestAppState, driver);
+
+        var state = host.GetAppState();
+
+        await Assert.That(state).IsSameReferenceAs(createdState);
+        await Assert.That(host.AppStateValue).IsSameReferenceAs(createdState);
+        await Assert.That(createNewAppStateCallCount).IsEqualTo(1);
+        await Assert.That(driver.LoadStateCallCount).IsEqualTo(1);
+    }
+
     [Test]
     public async Task ObserveAppState_Typed_EmitsCurrentValueImmediately()
     {

src/tests/ReactiveUI.Tests/SuspensionHostExtensionsTests.cs

@@ -124,6 +124,36 @@ public async Task EnsureLoadAppState_LoadStateThrows_CreatesNewAppState()
         await Assert.That(driver.LoadStateCallCount).IsEqualTo(1);
     }
 
+    [Test]
+    public async Task GetAppState_WhenNoPersistedState_CreatesAndStoresNewAppState()
+    {
+        var createdState = new DummyAppState();
+        var createNewAppStateCallCount = 0;
+        using var host = new SuspensionHost
+        {
+            CreateNewAppState = () =>
+            {
+                createNewAppStateCallCount++;
+                return createdState;
+            },
+            IsLaunchingNew = Observable.Never<Unit>(),
+            IsResuming = Observable.Never<Unit>(),
+            ShouldPersistState = Observable.Never<IDisposable>(),
+            ShouldInvalidateState = Observable.Never<Unit>()
+        };
+
+        var driver = new TestSuspensionDriver { ReturnNullOnLoad = true };
+
+        using var disposable = host.SetupDefaultSuspendResume(driver);
+
+        var state = host.GetAppState<DummyAppState>();
+
+        await Assert.That(state).IsSameReferenceAs(createdState);
+        await Assert.That(host.AppState).IsSameReferenceAs(createdState);
+        await Assert.That(createNewAppStateCallCount).IsEqualTo(1);
+        await Assert.That(driver.LoadStateCallCount).IsEqualTo(1);
+    }
+
     [Test]
     public async Task EnsureLoadAppState_WithExistingAppState_DoesNotLoad()
     {
@@ -475,6 +505,8 @@ private class TestSuspensionDriver : ISuspensionDriver
 
         public bool ShouldThrowOnLoad { get; set; }
 
+        public bool ReturnNullOnLoad { get; set; }
+
         public object? StateToLoad { get; set; }
 
         public IObservable<Unit> InvalidateState()
@@ -497,6 +529,11 @@ public IObservable<Unit> InvalidateState()
                     ImmediateScheduler.Instance);
             }
 
+            if (ReturnNullOnLoad)
+            {
+                return Observable.Return<object?>(null, ImmediateScheduler.Instance);
+            }
+
             return Observable.Return(StateToLoad ?? new DummyAppState(), ImmediateScheduler.Instance);
         }