Fixes

Author: dariatiurina

src/Components/QuickGrid/Microsoft.AspNetCore.Components.QuickGrid/test/FailingQuickGrid.cs

@@ -35,11 +35,6 @@ internal class FailingQuickGrid<TGridItem> : QuickGrid<TGridItem>, IAsyncDisposa
     public new async ValueTask DisposeAsync()
     {
         DisposeAsyncWasCalled = true;
-        // Intentionally do nothing to prevent _disposeBool from being set to true
-        // This means the OnAfterRenderAsync method will not detect that the component is disposed
-        // and will proceed to call init() even after disposal, demonstrating the race condition
-
-        // DO NOT call base.DisposeAsync() - this is the key to simulating the race condition
         await Task.CompletedTask;
     }
 

src/Components/QuickGrid/Microsoft.AspNetCore.Components.QuickGrid/test/GridRaceConditionTest.cs

@@ -39,15 +39,18 @@ public async Task CanCorrectlyDisposeAsync()
         // Complete the JS module loading
         moduleLoadCompletion.SetResult();
 
-        // Assert that init was not called after disposal
+        // Wait until after OnAfterRenderAsync has completed to test the disposal of the jsModule
+        var notFailingGrid = testComponent.NotFailingGrid;
+        await notFailingGrid.OnAfterRenderCompleted;
+
+        // Assert that init was not called after disposal and JsModule was disposed of
         Assert.False(testJsRuntime.InitWasCalledAfterDisposal,
             "Init should not be called on a disposed component.");
-        await Task.Yield();
         Assert.True(testJsRuntime.JsModuleDisposed);
     }
 
     [Fact]
-    public async Task FailingQuickGrid_CallsInitAfterDisposal_DemonstratesRaceCondition()
+    public async Task FailingQuickGridCallsInitAfterDisposal()
     {
         var moduleLoadCompletion = new TaskCompletionSource();
         var moduleImportStarted = new TaskCompletionSource();
@@ -69,21 +72,17 @@ public async Task FailingQuickGrid_CallsInitAfterDisposal_DemonstratesRaceCondit
         testJsRuntime.MarkDisposed();
         await renderer.DisposeAsync();
 
-        // Verify our FailingQuickGrid's DisposeAsync was called and _disposeBool should still be false
-        var failingGrid = testComponent.FailingQuickGrid;
-        Assert.NotNull(failingGrid);
-        Assert.True(failingGrid.DisposeAsyncWasCalled, "FailingQuickGrid.DisposeAsync should have been called");
-        Assert.True(failingGrid.IsWasDisposedFalse(), "_wasDisposed should still be false since we didn't call base.DisposeAsync()");
-
         // Complete the JS module loading - this allows the FailingQuickGrid's OnAfterRenderAsync to continue
         // and demonstrate the race condition by calling init after disposal
         moduleLoadCompletion.SetResult();
 
         // Wait for OnAfterRenderAsync to complete - deterministic timing instead of arbitrary delay
+        var failingGrid = testComponent.FailingQuickGrid;
         await failingGrid.OnAfterRenderCompleted;
 
-        // Assert that init WAS called after disposal (demonstrating the race condition bug)
+        // Assert that init WAS called after disposal
         // The FailingQuickGrid's OnAfterRenderAsync should have called init despite being disposed
+        // The FailingQuickGrid should not have disposed of JsModule 
         Assert.True(testJsRuntime.InitWasCalledAfterDisposal,
             $"FailingQuickGrid should call init after disposal, demonstrating the race condition bug. " +
             $"InitWasCalledAfterDisposal: {testJsRuntime.InitWasCalledAfterDisposal}, " +
@@ -122,16 +121,14 @@ protected override void BuildRenderTree(RenderTreeBuilder builder)
             b.AddAttribute(1, "Property", (System.Linq.Expressions.Expression<Func<Person, int>>)(p => p.Id));
             b.CloseComponent();
         }));
-        if (typeof(TGrid) != typeof(QuickGrid<Person>))
-        {
-            builder.AddComponentReferenceCapture(3, component => _grid = (TGrid)component);
-        }
+        builder.AddComponentReferenceCapture(3, component => _grid = (TGrid)component);
         builder.CloseComponent();
     }
 }
 
-internal class SimpleTestComponent : BaseTestComponent<QuickGrid<Person>>
+internal class SimpleTestComponent : BaseTestComponent<NotFailingGrid<Person>>
 {
+    public NotFailingGrid<Person> NotFailingGrid => Grid;
 }
 
 internal class FailingGridTestComponent : BaseTestComponent<FailingQuickGrid<Person>>

src/Components/QuickGrid/Microsoft.AspNetCore.Components.QuickGrid/test/NotFailingQuickGrid.cs

@@ -0,0 +1,49 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Microsoft.JSInterop;
+
+namespace Microsoft.AspNetCore.Components.QuickGrid.Tests;
+/// <summary>
+/// A QuickGrid implementation that uses the same implementation of the basic QuickGrid with the additions of the OnAfterRenderCompleted task.
+/// </summary>
+/// /// <typeparam name="TGridItem">The type of data represented by each row in the grid.</typeparam>
+internal class NotFailingGrid<TGridItem> : QuickGrid<TGridItem>
+{
+    [Inject] private IJSRuntime JS { get; set; } = default!;
+
+    private readonly TaskCompletionSource _onAfterRenderCompleted = new();
+
+    private bool _completionSignaled;
+
+    /// <summary>
+    /// Task that completes when OnAfterRenderAsync has finished executing.
+    /// This allows tests to wait deterministically for the race condition to occur.
+    /// </summary>
+    public Task OnAfterRenderCompleted => _onAfterRenderCompleted.Task;
+
+    protected override async Task OnAfterRenderAsync(bool firstRender)
+    {
+        try
+        {
+            if (firstRender)
+            {
+                await base.OnAfterRenderAsync(firstRender);
+                _onAfterRenderCompleted.TrySetResult();
+                _completionSignaled = true;
+                return;
+            }
+        }
+        finally
+        {
+            if (firstRender && _completionSignaled)
+            {
+                _onAfterRenderCompleted.TrySetResult();
+                _completionSignaled = true;
+            }
+        }
+    }
+}