Finish the test.

Author: ilonatommy

src/Components/Components/test/NavigationManagerTest.cs

@@ -8,6 +8,8 @@
 using Microsoft.AspNetCore.Components.Routing;
 using Microsoft.AspNetCore.InternalTesting;
 
+#nullable enable
+
 namespace Microsoft.AspNetCore.Components;
 
 public class NavigationManagerTest
@@ -893,32 +895,30 @@ public void OnNavigateToCallback_WhenThrows_ShouldBeHandledGracefully()
         // Arrange
         var baseUri = "scheme://host/";
         var uri = "scheme://host/test";
-        var testNavManager = new TestNavigationManagerWithCallback();
-        var exceptionThrown = false;
+        var testNavManager = new TestNavigationManagerWithExceptionHandling(baseUri);
         var expectedException = new InvalidOperationException("Test exception from OnNavigateTo");
 
-        // Configure the onNavigateTo callback to throw an exception
-        testNavManager.ConfigureOnNavigateToCallback(throwingUri =>
-        {
-            exceptionThrown = true;
-            throw expectedException;
-        });
+        // First test: Initialize with a callback that throws exceptions
+        testNavManager.Initialize(baseUri, uri, uri => testNavManager.GetErrorHandledTask(ThrowingMethod(uri)));
 
-        // Act
-        // Initialize the navigation manager with the callback
-        testNavManager.Initialize(baseUri, uri, testNavManager.GetOnNavigateToCallback());
+        // Act & Assert
+        // Verify that the wrapped callback handles the exception gracefully
+        var wrappedException = testNavManager.TriggerOnNavigateToCallback(uri);
 
-        // Assert
-        Assert.True(testNavManager.IsInitialized);
+         // Should be null because the exception was handled gracefully
+        Assert.Null(wrappedException);
 
-        // When navigation is triggered, the exception should be handled gracefully
-        var thrownException = testNavManager.TriggerOnNavigateToCallback(uri);
+        // Verify that the exception was logged
+        Assert.Single(testNavManager.HandledExceptions);
+        Assert.Same(expectedException, testNavManager.HandledExceptions[0]);
 
-        // Assert
-        Assert.True(exceptionThrown, "The OnNavigateTo callback should have been called and thrown an exception.");
-        Assert.Same(expectedException, thrownException);
+        async Task ThrowingMethod(string param)
+        {
+            await Task.Yield();
+            throw expectedException;
+        }
     }
- 
+
     private class TestNavigationManager : NavigationManager
     {
         public TestNavigationManager()
@@ -965,40 +965,27 @@ protected override void HandleLocationChangingHandlerException(Exception ex, Loc
         }
     }
 
-    private class TestNavigationManagerWithCallback : TestNavigationManager, IHostEnvironmentNavigationManager
+    private class TestNavigationManagerWithExceptionHandling : TestNavigationManager, IHostEnvironmentNavigationManager
     {
         private Func<string, Task> _onNavigateToCallback;
 
-        public TestNavigationManagerWithCallback()
+        public List<Exception> HandledExceptions { get; } = new();
+
+        public TestNavigationManagerWithExceptionHandling(string baseUri = null, string uri = null)
+            : base(baseUri, uri)
         {
         }
 
         public void Initialize(string baseUri, string uri, Func<string, Task> onNavigateTo)
         {
             _onNavigateToCallback = onNavigateTo;
-            base.Initialize(baseUri, uri);
-        }
-
-        public void ConfigureOnNavigateToCallback(Func<string, Task> callback)
-        {
-            _onNavigateToCallback = callback;
-        }
-
-        public Func<string, Task> GetOnNavigateToCallback()
-        {
-            return _onNavigateToCallback;
         }
 
-        public Exception TriggerOnNavigateToCallback(string uri)
+        public Exception? TriggerOnNavigateToCallback(string uri)
         {
-            if (_onNavigateToCallback == null)
-            {
-                return null;
-            }
-
             try
             {
-                // Simulate the fire-and-forget pattern used in RemoteNavigationManager
+                // Simulate the fire-and-forget pattern of RemoteNavigationManager
                 _ = _onNavigateToCallback(uri);
                 return null;
             }
@@ -1008,19 +995,25 @@ public Exception TriggerOnNavigateToCallback(string uri)
             }
         }
 
-        public bool IsInitialized 
+        protected override void NavigateToCore(string uri, bool forceLoad)
         {
-            get
+            // Simulate the behavior where NavigateToCore calls the onNavigateTo callback
+            // in a fire-and-forget manner when JSRuntime is not available
+            if (_onNavigateToCallback is not null)
             {
-                try
-                {
-                    _ = BaseUri; // This will throw if not initialized
-                    return true;
-                }
-                catch (InvalidOperationException)
-                {
-                    return false;
-                }
+                _ = _onNavigateToCallback(uri);
+            }
+        }
+
+        public async Task GetErrorHandledTask(Task taskToHandle)
+        {
+            try
+            {
+                await taskToHandle;
+            }
+            catch (Exception ex)
+            {
+                HandledExceptions.Add(ex);
             }
         }
     }