Add circuit host tests

Author: javiercn

src/Components/Server/src/Circuits/CircuitHost.cs

@@ -760,7 +760,7 @@ private async Task TryNotifyClientErrorAsync(IClientProxy client, string error,
 
     internal Task UpdateRootComponents(
         RootComponentOperationBatch operationBatch,
-        ProtectedPrerenderComponentApplicationStore store,
+        IClearableStore store,
         bool isRestore,
         CancellationToken cancellation)
     {
@@ -858,7 +858,7 @@ internal Task UpdateRootComponents(
                     // At this point all components have successfully produced an initial render and we can clear the contents of the component
                     // application state store. This ensures the memory that was not used during the initial render of these components gets
                     // reclaimed since no-one else is holding on to it any longer.
-                    store.ExistingState.Clear();
+                    store.Clear();
                 }
             }
         });

src/Components/Server/test/Circuits/CircuitHostTest.cs

@@ -693,6 +693,90 @@ public async Task UpdateRootComponents_CanRemoveExistingRootComponent()
             ((TestRemoteRenderer)circuitHost.Renderer).GetTestComponentState(0));
     }
 
+    [Fact]
+    public async Task UpdateRootComponents_ValidatesOperationSequencingDuringValueUpdateRestore()
+    {
+        // Arrange
+        var testRenderer = GetRemoteRenderer();
+        var circuitHost = TestCircuitHost.Create(
+            remoteRenderer: testRenderer);
+
+        // Set up initial components for subsequent operations
+        await AddComponentAsync<DynamicallyAddedComponent>(circuitHost, 0, new Dictionary<string, object>
+        {
+            [nameof(DynamicallyAddedComponent.Message)] = "Component 0"
+        });
+        await AddComponentAsync<DynamicallyAddedComponent>(circuitHost, 1, new Dictionary<string, object>
+        {
+            [nameof(DynamicallyAddedComponent.Message)] = "Component 1"
+        });
+
+        Assert.Equal(2, testRenderer.GetOrCreateWebRootComponentManager().GetRootComponents().Count());
+        var store = new TestComponentApplicationStore(
+            new Dictionary<string, byte[]> { ["test"] = [1, 2, 3] });
+
+        var operations = new RootComponentOperation[]
+        {
+            new()
+            {
+                Type = RootComponentOperationType.Add,
+                SsrComponentId = 2,
+                Marker = CreateMarker(typeof(DynamicallyAddedComponent), "2", new Dictionary<string, object>
+                {
+                    [nameof(DynamicallyAddedComponent.Message)] = "New Component 2"
+                }),
+                Descriptor = new(
+                    componentType: typeof(DynamicallyAddedComponent),
+                    parameters: CreateWebRootComponentParameters(new Dictionary<string, object>
+                    {
+                        [nameof(DynamicallyAddedComponent.Message)] = "New Component 2"
+                    })),
+            },
+
+            new()
+            {
+                Type = RootComponentOperationType.Remove,
+                SsrComponentId = 0,
+            },
+
+            new()
+            {
+                Type = RootComponentOperationType.Update,
+                SsrComponentId = 1,
+                Marker = CreateMarker(typeof(DynamicallyAddedComponent), "1", new Dictionary<string, object>
+                {
+                    [nameof(DynamicallyAddedComponent.Message)] = "Replaced Component 1"
+                }),
+                Descriptor = new(
+                    componentType: typeof(DynamicallyAddedComponent),
+                    parameters: CreateWebRootComponentParameters(new Dictionary<string, object>
+                    {
+                        [nameof(DynamicallyAddedComponent.Message)] = "Replaced Component 1"
+                    })),
+            },
+        };
+
+        var batch = new RootComponentOperationBatch
+        {
+            BatchId = 1,
+            Operations = operations
+        };
+
+        var updateTask = circuitHost.UpdateRootComponents(batch, store, false, CancellationToken.None);
+        Assert.Equal(2, testRenderer.GetOrCreateWebRootComponentManager().GetRootComponents().Count());
+        Assert.Equal("Default message", Assert.IsType<DynamicallyAddedComponent>(testRenderer.GetTestComponentState(3).Component).Message);
+        Assert.Equal("Default message", Assert.IsType<DynamicallyAddedComponent>(testRenderer.GetTestComponentState(2).Component).Message);
+        store.Continue();
+        await updateTask;
+
+        // Enqueue a callback to indirectly await for the remaining operations to complete.
+        await testRenderer.Dispatcher.InvokeAsync(() => { });
+        Assert.Equal("Replaced Component 1", Assert.IsType<DynamicallyAddedComponent>(testRenderer.GetTestComponentState(3).Component).Message);
+        Assert.Equal("New Component 2", Assert.IsType<DynamicallyAddedComponent>(testRenderer.GetTestComponentState(2).Component).Message);
+
+        Assert.Equal(2, testRenderer.GetOrCreateWebRootComponentManager().GetRootComponents().Count());
+    }
+
     private async Task AddComponentAsync<TComponent>(CircuitHost circuitHost, int ssrComponentId, Dictionary<string, object> parameters = null, string componentKey = "")
         where TComponent : IComponent
     {
@@ -823,7 +907,7 @@ public TestRemoteRenderer(IServiceProvider serviceProvider, ISingleClientProxy c
                   NullLogger.Instance,
                   CreateJSRuntime(new CircuitOptions()),
                   new CircuitJSComponentInterop(new CircuitOptions()))
-        {
+        {            
         }
 
         public ComponentState GetTestComponentState(int id)
@@ -1051,4 +1135,20 @@ public void TriggerRender()
             Assert.True(task.IsCompletedSuccessfully);
         }
     }
+
+    private class TestComponentApplicationStore(Dictionary<string, byte[]> dictionary) : IPersistentComponentStateStore, IClearableStore
+    {
+        private readonly TaskCompletionSource _tcs = new();
+
+        public void Clear() => dictionary.Clear();
+
+        public async Task<IDictionary<string, byte[]>> GetPersistedStateAsync()
+        {
+            await _tcs.Task;
+            return dictionary;
+        }
+
+        public Task PersistStateAsync(IReadOnlyDictionary<string, byte[]> state) => throw new NotImplementedException();
+        internal void Continue() => _tcs.SetResult();
+    }
 }

src/Components/Server/test/Circuits/TestCircuitHost.cs

@@ -30,26 +30,29 @@ public static CircuitHost Create(
         CircuitHandler[] handlers = null,
         CircuitClientProxy clientProxy = null)
     {
-        serviceScope = serviceScope ?? new AsyncServiceScope(Mock.Of<IServiceScope>());
         clientProxy = clientProxy ?? new CircuitClientProxy(Mock.Of<ISingleClientProxy>(), Guid.NewGuid().ToString());
         var jsRuntime = new RemoteJSRuntime(Options.Create(new CircuitOptions()), Options.Create(new HubOptions<ComponentHub>()), Mock.Of<ILogger<RemoteJSRuntime>>());
         var navigationManager = new RemoteNavigationManager(Mock.Of<ILogger<RemoteNavigationManager>>());
         var componentsActivitySource = new ComponentsActivitySource();
         var circuitActivitySource = new CircuitActivitySource();
-        var serviceProvider = new Mock<IServiceProvider>();
-        serviceProvider
-            .Setup(services => services.GetService(typeof(IJSRuntime)))
-            .Returns(jsRuntime);
-        serviceProvider
-            .Setup(services => services.GetService(typeof(ComponentsActivitySource)))
-            .Returns(componentsActivitySource);
+        var persistenceManager = new ComponentStatePersistenceManager(
+            NullLogger<ComponentStatePersistenceManager>.Instance,
+            new ServiceCollection().BuildServiceProvider());
+        var serviceProvider = new ServiceCollection()
+            .AddSingleton<IJSRuntime>(jsRuntime)
+            .AddSingleton(componentsActivitySource)
+            .AddSingleton(persistenceManager)
+            .AddSingleton(circuitActivitySource)
+            .BuildServiceProvider();
+        serviceScope ??= serviceProvider.CreateAsyncScope();
+
         var serverComponentDeserializer = Mock.Of<IServerComponentDeserializer>();
         var circuitMetrics = new CircuitMetrics(new TestMeterFactory());
 
         if (remoteRenderer == null)
         {
             remoteRenderer = new RemoteRenderer(
-                serviceProvider.Object,
+                serviceProvider,
                 NullLoggerFactory.Instance,
                 new CircuitOptions(),
                 clientProxy,

src/Shared/Components/ProtectedPrerenderComponentApplicationStore.cs

@@ -6,7 +6,7 @@
 
 namespace Microsoft.AspNetCore.Components;
 
-internal sealed class ProtectedPrerenderComponentApplicationStore : PrerenderComponentApplicationStore
+internal sealed class ProtectedPrerenderComponentApplicationStore : PrerenderComponentApplicationStore, IClearableStore
 {
     private IDataProtector _protector = default!; // Assigned in all constructor paths
 
@@ -39,4 +39,14 @@ private void CreateProtector(IDataProtectionProvider dataProtectionProvider) =>
     public override bool SupportsRenderMode(IComponentRenderMode renderMode) =>
         renderMode is null ||
         renderMode is InteractiveServerRenderMode || renderMode is InteractiveAutoRenderMode;
+
+    public void Clear()
+    {
+        ExistingState.Clear();
+    }
+}
+
+internal interface IClearableStore : IPersistentComponentStateStore
+{
+    void Clear();
 }