Verify deferred DeleteReference runs in context-path finalizer test

Addresses review feedback that FinalizeContextReferenceFromDifferentThreadDoesNotThrow
only asserted IsDisposed (set before the delete is posted) and never confirmed the
deferred cleanup actually released the native reference.

Adds MockJSRuntime.RecordingSynchronizationContext (records posted callbacks for
deterministic pumping) and MockJSRuntime.HasReference, then asserts the finalizer defers
the delete off-thread, and that pumping the sync context runs it and releases the reference.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 144c87db-8d78-474f-bff9-21031a23e3e7

Author: GalaxiasKyklos

test/JSReferenceTests.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 using System;
+using Microsoft.JavaScript.NodeApi.Interop;
 using Xunit;
 using static Microsoft.JavaScript.NodeApi.Runtime.JSRuntime;
 
@@ -12,9 +13,13 @@ public class JSReferenceTests
     private readonly MockJSRuntime _mockRuntime = new();
 
     private JSValueScope TestScope(JSValueScopeType scopeType)
+        => TestScope(scopeType, new MockJSRuntime.SynchronizationContext());
+
+    private JSValueScope TestScope(
+        JSValueScopeType scopeType, JSSynchronizationContext synchronizationContext)
     {
         napi_env env = new(Environment.CurrentManagedThreadId);
-        return new(scopeType, env, _mockRuntime, new MockJSRuntime.SynchronizationContext());
+        return new(scopeType, env, _mockRuntime, synchronizationContext);
     }
 
     [Fact]
@@ -127,19 +132,31 @@ public void FinalizeNoContextReferenceFromDifferentThreadDoesNotThrow()
         Assert.True(reference.IsDisposed);
     }
 
-    // A reference with a runtime context posts its cleanup to the JS thread. The finalizer must
-    // likewise never throw when it runs on a thread with no current scope.
+    // A reference with a runtime context posts its cleanup to the JS thread instead of deleting it
+    // inline. The finalizer must never throw when it runs on a thread with no current scope, and
+    // the posted delete must actually release the native reference once the JS thread pumps it.
     [Fact]
     public void FinalizeContextReferenceFromDifferentThreadDoesNotThrow()
     {
-        using JSValueScope rootScope = TestScope(JSValueScopeType.Root);
+        var syncContext = new MockJSRuntime.RecordingSynchronizationContext();
+        using JSValueScope rootScope = TestScope(JSValueScopeType.Root, syncContext);
 
         JSValue value = JSValue.CreateObject();
         var reference = new FinalizerTestReference(value);
+        napi_ref handle = reference.Handle;
+        Assert.True(_mockRuntime.HasReference(handle));
 
         TestUtils.RunInThread(() => reference.SimulateFinalize()).Wait();
 
         Assert.True(reference.IsDisposed);
+
+        // The delete is deferred to the JS thread, not run inline on the finalizer thread.
+        Assert.True(_mockRuntime.HasReference(handle));
+        Assert.Equal(1, syncContext.PendingCount);
+
+        // Pumping the sync context runs the posted delete, releasing the native reference.
+        Assert.Equal(1, syncContext.RunPendingCallbacks());
+        Assert.False(_mockRuntime.HasReference(handle));
     }
 
     // Explicit disposal (disposing: true) preserves the documented behavior of asserting thread

test/MockJSRuntime.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using Microsoft.JavaScript.NodeApi.Interop;
 using Microsoft.JavaScript.NodeApi.Runtime;
 using Xunit;
@@ -187,6 +188,12 @@ public override napi_status DeleteReference(napi_env env, napi_ref @ref)
         return _references.Remove(@ref.Handle) ? napi_ok : napi_invalid_arg;
     }
 
+    /// <summary>
+    /// Reports whether a reference handle is still present (that is, has not been deleted by
+    /// <see cref="DeleteReference"/>). Lets a test assert that a deferred delete actually ran.
+    /// </summary>
+    public bool HasReference(napi_ref @ref) => _references.ContainsKey(@ref.Handle);
+
     /// <summary>
     /// Simulates the behavior of the JS runtime when a weakly-referenced value is released.
     /// </summary>
@@ -206,4 +213,43 @@ public class SynchronizationContext : JSSynchronizationContext
         public override void CloseAsyncScope() => throw new NotImplementedException();
         public override void OpenAsyncScope() => throw new NotImplementedException();
     }
+
+    // A synchronization context that records posted callbacks instead of running them, so a test
+    // can deterministically pump the queue with <see cref="RunPendingCallbacks"/> and assert that
+    // the posted work (for example a deferred DeleteReference) actually executed.
+    public class RecordingSynchronizationContext : JSSynchronizationContext
+    {
+        private readonly Queue<(SendOrPostCallback Callback, object? State)> _posted = new();
+
+        public int PendingCount => _posted.Count;
+
+        public override void Post(SendOrPostCallback callback, object? state)
+        {
+            if (IsDisposed) return;
+            _posted.Enqueue((callback, state));
+        }
+
+        public override void Send(SendOrPostCallback callback, object? state)
+        {
+            if (IsDisposed) return;
+            callback(state);
+        }
+
+        // Runs every callback posted so far and returns how many were run.
+        public int RunPendingCallbacks()
+        {
+            int count = 0;
+            while (_posted.Count > 0)
+            {
+                (SendOrPostCallback callback, object? state) = _posted.Dequeue();
+                callback(state);
+                count++;
+            }
+
+            return count;
+        }
+
+        public override void CloseAsyncScope() { }
+        public override void OpenAsyncScope() { }
+    }
 }