tests: interop contract enable unbind checks for event/bind

Author: damyanpetev

skills/igniteui-blazor-lite-testing/references/interop-contracts.md

@@ -114,7 +114,7 @@ A `[Parameter] TValue X` plus `EventCallback<TValue> XChanged` is what `@bind-X`
       argsJson: """{"detail": true}""", expect: true)
 ```
 
-One dispatch pins: the driving event's registration crossed, the callback member kept the callback, the binding received the decoded value, and the property adopted it. Payload is the same shape and can be reused from the driving event's own `.Event` spec.
+One dispatch pins: the driving event's registration crossed, the callback member kept the callback, the binding received the decoded value, and the property adopted it. Clearing the parameter then has to stop the callback. Payload is the same shape and can be reused from the driving event's own `.Event` spec.
 
 - `expect:` is the value the dispatch must produce, often a projection of the detail — a checkbox detail is an object, the bound value is its `checked` field. The runner checks the property doesn't already hold it, so a spec can't pass without the change happening. For a type with no value equality add `assert:` and check field-wise.
 - `arrange:` when the dispatch needs more — Calendar's `Selection` for the `Values` branch, Combo's `Data`. Order the named arguments arrange → argsJson → expect, so a spec reads arrange/act/assert.

tests/IgniteUI.Blazor.Tests/ComponentWithContractTestBase.cs

@@ -399,21 +399,36 @@ void Sink(object? value)
                         $"{bind.PropertyName} did not adopt the value pushed to the binding — {mismatch.Message}");
                 }
 
-                // TODO: unbinding is blocked by the same defect as an event callback's, so one fix
-                // covers both — clearing the parameter arrives as a callback with a Receiver and a
-                // null Delegate, which fails the setter's Empty check, takes the *bound* branch, and
-                // NREs in BaseRendererControl.CompareEventCallbacks on leftDelegate.Equals(...).
-                // What to assert differs from an event's, though: a bind member's empty branch only
-                // nulls its field (no SetHandler(null), no OnRefChanged), so the driving event stays
-                // registered and the property keeps adopting client changes — only the callback
-                // stops. Needs BindPair to accept a null sink, as EventContractSpec.Bind already
-                // does. Then:
-                // received = null;
-                // cut.Render(ps => bind.BindPair(ps, null));
-                // Assert.False(bind.ChangedIsBound(cut.Instance));   // member resets to Empty
-                // harness.RaiseEvent(containerId, bind.DrivingEvent, bind.ArgsJson.Get(harness, cut));
-                // Assert.Null(received);                             // the callback stops firing
-                // Assert.NotNull(bind.ReadProperty(cut.Instance));   // but the property still tracks
+                // Unbinding stops the callback. Either callback carrying no handler must clear it,
+                // so both are verified.
+                // Unlike an event member, a bind member's empty branch only nulls its own field,
+                // so the driving event stays subscribed and the property keeps adopting client changes.
+                // TODO: Evaluate design, since EnsureXHandled forced that registration and never withdraws it.
+                VerifyUnbind(useEmpty: false);
+                Rebind();
+                VerifyUnbind(useEmpty: true);
+
+                void VerifyUnbind(bool useEmpty)
+                {
+                    var assigned = useEmpty ? "EventCallback<T>.Empty" : "default";
+
+                    cut.Render(ps => bind.BindPair(ps, null, useEmpty));
+                    Assert.False(
+                        bind.ChangedIsBound(cut.Instance),
+                        $"{bind.PropertyName}Changed still reports a bound callback after being cleared with {assigned}");
+
+                    delivered = false;
+                    harness.RaiseEvent(containerId, bind.DrivingEvent, bind.ArgsJson.Get(harness, cut));
+                    Assert.False(delivered, $"{bind.PropertyName}Changed fired after being unbound with {assigned}");
+                }
+
+                void Rebind()
+                {
+                    cut.Render(ps => bind.BindPair(ps, Sink));
+                    Assert.True(
+                        bind.ChangedIsBound(cut.Instance),
+                        $"{bind.PropertyName}Changed did not take the callback again after being cleared");
+                }
             }
             catch (Exception ex) when (ex is not ContractViolationException)
             {
@@ -454,10 +469,11 @@ protected void VerifyEventContract()
             {
                 object? received = null;
                 object bound = null!;
+                void Sink(object args) => received = args;
                 var cut = Render<TComponent>(ps =>
                 {
                     evt.Arrange?.Invoke(ps);
-                    bound = evt.Bind(ps, args => received = args);
+                    bound = evt.Bind(ps, Sink);
                 });
                 var containerId = harness.ContainerIdOf(cut);
 
@@ -487,21 +503,61 @@ protected void VerifyEventContract()
                 evt.AssertWithComponent?.Invoke(cut.Instance, received);
                 evt.AssertWithCut?.Invoke(cut, received);
 
-                // TODO: removing a bound callback crashes today, on either path. Razor-bound
-                // values arrive wrapped by EventCallback.Factory.Create, so a "default"
-                // carries a Receiver with a null Delegate — that fails the setter's Empty
-                // check, takes the *bound* branch, and NREs in
-                // BaseRendererControl.CompareEventCallbacks on leftDelegate.Equals(...);
-                // a raw Empty (what bUnit/programmatic SetParameters passes) does reach the
-                // unset branch and NREs in OnRefChanged on newValue.ToString(). Once fixed,
-                // validate the removal round-trip; pin the actual cleared wire shape then:
-                // cut.Render(ps => bound = evt.Bind(ps, null));   // bUnit 2.x: no SetParametersAndRender
-                // Assert.Equal(bound, evt.Get(cut.Instance)); // member resets to the empty callback
-                // var cleared = harness.FindPropertyUpdate(containerId, wireName);
-                // Assert.Equal(JsonValueKind.Null, cleared!.Value.ValueKind);
-                // received = null;
-                // harness.RaiseEvent(containerId, evt.EventName, argsJson);
-                // Assert.Null(received); // deregistered handlers must not be invoked
+                // Re-binding an equivalent callback must not read as a new subscription — Blazor hands over a
+                // fresh delegate for the same handler every render. Read through the member (a setter assigns
+                // and registers in one branch) since probing the wire for an absent message costs a 2s retry.
+                // Only bites on net8.0/net9.0, whose EventCallback.Equals compares the delegate by reference.
+                cut.Render(ps => evt.Bind(ps, Sink));
+                Assert.Equal(bound, evt.Get(cut.Instance));
+
+                // Unbinding is the other half of the registration contract: clearing the parameter
+                // must reset the member, tell the client to unsubscribe, and stop delivery. Either
+                // callback carrying no handler must clear it, so both are verified.
+                VerifyUnbind(useEmpty: false);
+                Rebind();
+                VerifyUnbind(useEmpty: true);
+
+                void VerifyUnbind(bool useEmpty)
+                {
+                    var assigned = useEmpty ? "EventCallback<T>.Empty" : "default";
+
+                    // Forget the previous phase's traffic, so what follows is the client state
+                    harness.ClearObserved();
+                    cut.Render(ps => evt.Bind(ps, null, useEmpty));
+
+                    // Asserted through the member rather than against the assigned value: clearing with
+                    // default reads back as Empty, since the getter substitutes it for a null field.
+                    Assert.False(
+                        evt.IsBound(cut.Instance),
+                        $"clearing \"{evt.EventName}\" with {assigned} left the member holding a live callback");
+
+                    // TODO: active @bind-X may still need the sub; fix will make this check conditional.
+                    var cleared = harness.FindPropertyUpdate(containerId, wireName);
+                    if (cleared is null || cleared.Value.ValueKind != JsonValueKind.Null)
+                    {
+                        throw new XunitException(
+                            $"clearing \"{evt.EventName}\" with {assigned} left it registered as " +
+                            $"{cleared?.ToString() ?? "nothing"} — the client would keep reporting an " +
+                            "event nobody handles");
+                    }
+
+                    received = null;
+                    harness.RaiseEvent(containerId, evt.EventName, argsJson);
+                    Assert.Null(received);
+                }
+
+                void Rebind()
+                {
+                    harness.ClearObserved();
+                    cut.Render(ps => evt.Bind(ps, Sink));
+                    var rebound = harness.FindPropertyUpdate(containerId, wireName);
+                    if (rebound is null || rebound.Value.GetString() != evt.EventName)
+                    {
+                        throw new XunitException(
+                            $"re-binding \"{evt.EventName}\" transmitted {rebound?.ToString() ?? "no registration"} — " +
+                            "the client would never resubscribe");
+                    }
+                }
             }
             catch (Exception ex) when (ex is not ContractViolationException)
             {

tests/IgniteUI.Blazor.Tests/Interop/ComponentContract.cs

@@ -155,15 +155,28 @@ public sealed class EventContractSpec<TComponent> where TComponent : IComponent
 
     /// <summary>
     /// Sets the event parameter and returns the boxed <see cref="EventCallback{TValue}"/> it
-    /// assigned, so the runner can assert the member round-trips that exact value: with a
-    /// sink, a callback forwarding received args to it; with null, an empty callback (the
-    /// removal round-trip — bUnit has no parameter removal, unbinding IS an add).
+    /// assigned: with a sink, a callback forwarding received args to it; with a null sink, one of the
+    /// two callbacks that carry no handler — <c>default</c>, or <see cref="EventCallback{TValue}.Empty"/>
+    /// when <paramref name="useEmpty"/> is set. (bUnit has no parameter removal, so unbinding IS an add.)
     /// </summary>
-    public required Func<ComponentParameterCollectionBuilder<TComponent>, Action<object>?, object> Bind { get; init; }
+    public delegate object BindEvent(
+        ComponentParameterCollectionBuilder<TComponent> ps,
+        Action<object>? sink,
+        bool useEmpty = false);
+
+    /// <inheritdoc cref="BindEvent"/>
+    public required BindEvent Bind { get; init; }
 
     /// <summary>Reads the event member back (boxed) — the typed read half of <see cref="Bind"/>.</summary>
     public required Func<TComponent, object> Get { get; init; }
 
+    /// <summary>
+    /// Whether the member holds a live subscription. What was assigned and what reads back differ
+    /// when clearing with <c>default</c> — the getter substitutes <c>Empty</c> for its null backing
+    /// field — so unbinding is asserted through this rather than against the assigned value.
+    /// </summary>
+    public required Func<TComponent, bool> IsBound { get; init; }
+
     /// <summary>The declared event args type; the runner asserts the received args are assignable to it.</summary>
     public required Type ArgsType { get; init; }
     /// <summary>The dispatched payload, settled against the render when the spec declared it late.</summary>
@@ -198,9 +211,16 @@ public sealed class BindContractSpec<TComponent> where TComponent : IComponent
     /// <summary>
     /// Arranges the render exactly as <c>@bind-X</c> would (bUnit's <c>ps.Bind</c>), routing the
     /// pushed value to the sink so the spec asserts the user-facing contract rather than the
-    /// callback member. Returns nothing — the sink is the observation.
+    /// callback member. Returns nothing — the sink is the observation. A null sink clears the
+    /// callback instead, as <c>default</c> or as <c>Empty</c> when <paramref name="useEmpty"/> is set.
     /// </summary>
-    public required Action<ComponentParameterCollectionBuilder<TComponent>, Action<object?>> BindPair { get; init; }
+    public delegate void BindPairSetup(
+        ComponentParameterCollectionBuilder<TComponent> ps,
+        Action<object?>? sink,
+        bool useEmpty = false);
+
+    /// <inheritdoc cref="BindPairSetup"/>
+    public required BindPairSetup BindPair { get; init; }
 
     /// <summary>Reads the bound property back off the component, to assert it was updated.</summary>
     public required Func<TComponent, object?> ReadProperty { get; init; }
@@ -685,8 +705,9 @@ public ComponentContract<TComponent> Event(
         _events.Add(new EventContractSpec<TComponent>
         {
             EventName = name ?? MemberName(member),
-            Bind = (ps, on) => BindMember(ps, member, on),
+            Bind = (ps, on, useEmpty) => BindMember(ps, member, on, useEmpty),
             Get = GetterOf(member),
+            IsBound = IsBoundOf(member),
             ArgsType = typeof(IgbVoidEventArgs),
             Source = new SpecSource(atFile, atLine),
         });
@@ -744,9 +765,19 @@ public ComponentContract<TComponent> Bind<TValue, TArgs>(
             DrivingEvent = MemberName(via),
             // Exactly what @bind-X expands to, via bUnit's own two-way binding helper. The
             // wrappers have no <Prop>Expression parameter, so the value expression is omitted.
-            BindPair = (ps, sink) => ps.Bind(property, initial, value => sink(value)),
+            BindPair = (ps, sink, useEmpty) =>
+            {
+                if (sink is null)
+                {
+                    ps.Add(changed, useEmpty ? EventCallback<TValue>.Empty : default);
+                }
+                else
+                {
+                    ps.Bind(property, initial, value => sink(value));
+                }
+            },
             ReadProperty = c => readProp(c),
-            ChangedIsBound = c => !EventCallback<TValue>.Empty.Equals(readChanged(c)),
+            ChangedIsBound = c => readChanged(c).HasHandler(),
             ArgsJson = argsJson,
             Expected = expect,
             AssertValue = assert is null ? null : o => assert((TValue)o!),
@@ -778,8 +809,9 @@ public ComponentContract<TComponent> Event<TArgs>(
         _events.Add(new EventContractSpec<TComponent>
         {
             EventName = name ?? MemberName(member),
-            Bind = (ps, on) => BindMember(ps, member, on),
+            Bind = (ps, on, useEmpty) => BindMember(ps, member, on, useEmpty),
             Get = GetterOf(member),
+            IsBound = IsBoundOf(member),
             ArgsType = typeof(TArgs),
             ArgsJson = argsJson,
             AssertArgs = assert is null ? null : o => assert((TArgs)o),
@@ -803,8 +835,9 @@ public ComponentContract<TComponent> Event<TArgs>(
         _events.Add(new EventContractSpec<TComponent>
         {
             EventName = MemberName(member),
-            Bind = (ps, on) => BindMember(ps, member, on),
+            Bind = (ps, on, useEmpty) => BindMember(ps, member, on, useEmpty),
             Get = GetterOf(member),
+            IsBound = IsBoundOf(member),
             ArgsType = typeof(TArgs),
             ArgsJson = argsJson,
             AssertWithComponent = (c, o) => assert(c, (TArgs)o),
@@ -831,8 +864,9 @@ public ComponentContract<TComponent> Event<TArgs>(
         _events.Add(new EventContractSpec<TComponent>
         {
             EventName = MemberName(member),
-            Bind = (ps, on) => BindMember(ps, member, on),
+            Bind = (ps, on, useEmpty) => BindMember(ps, member, on, useEmpty),
             Get = GetterOf(member),
+            IsBound = IsBoundOf(member),
             ArgsType = typeof(TArgs),
             Arrange = arrange,
             ArgsJson = argsJson,
@@ -851,16 +885,20 @@ private static string MemberName<TArgs>(Expression<Func<TComponent, EventCallbac
         MemberOf(member).Name;
 
     /// <summary>
-    /// The write half of an event spec's bind/read loop, captured here where the args type
-    /// is known: assigns the parameter (an empty callback when <paramref name="sink"/> is
-    /// null) and returns the exact boxed callback for the runner's round-trip assert.
+    /// The write half of an event spec's bind/read loop, captured here where the args type is known.
+    /// Assigns the parameter and returns exactly what it assigned. A null <paramref name="sink"/>
+    /// clears it, as either of the two callbacks that carry no handler — <c>default</c>, or
+    /// <see cref="EventCallback{TValue}.Empty"/> when <paramref name="useEmpty"/> is set.
     /// </summary>
     private static EventCallback<TArgs> BindMember<TArgs>(
         ComponentParameterCollectionBuilder<TComponent> ps,
         Expression<Func<TComponent, EventCallback<TArgs>>> member,
-        Action<object>? sink)
+        Action<object>? sink,
+        bool useEmpty = false)
     {
-        var callback = sink is null ? default : new EventCallback<TArgs>(null, sink);
+        var callback = sink is null
+            ? (useEmpty ? EventCallback<TArgs>.Empty : default)
+            : new EventCallback<TArgs>(null, sink);
         ps.Add(member, callback);
         return callback;
     }
@@ -872,6 +910,13 @@ private static Func<TComponent, object> GetterOf<TArgs>(Expression<Func<TCompone
         return c => get(c);
     }
 
+    /// <summary>Reads whether the member holds a live subscription (see <see cref="EventContractSpec{TComponent}.IsBound"/>).</summary>
+    private static Func<TComponent, bool> IsBoundOf<TArgs>(Expression<Func<TComponent, EventCallback<TArgs>>> member)
+    {
+        var get = member.Compile();
+        return c => get(c).HasHandler();
+    }
+
     /// <summary>Derives the wire return kind from the .NET return type; exotic shapes use the InteropReturn overloads.</summary>
     private static InteropReturn StubFor<TResult>(TResult value) => value switch
     {