fixup(tests): replace concurrent-render probe with real Suspense/transition

Addresses @nrps9909's follow-up on #622.

The previous `tests/concurrent-render.test.tsx` used an error boundary
that replaced the Trigger's target with a `.target-fallback` span. The
fallback had none of Trigger's injected handlers, the test explicitly
acknowledged the wiring gap, and its final assertion looped over
`onOpenChange.mock.calls` which trivially passed when the array was
empty. As CodeRabbit and @nrps9909 both flagged, that probe could not
have caught a regression back to the render-body-write baseline.

Replace it with the causal probe from the review:

  1. Commit a controlled Trigger with `popupVisible={false}`; grab the
     committed target reference.
  2. Wrap `rerender(<Harness open attempt />)` in `React.startTransition`.
     The child throws a never-resolving promise, so the transition stays
     pending and React keeps the previously committed UI on screen. The
     original target reference is unchanged; the Suspense fallback does
     not mount.
  3. Fire `focus` on that still-committed target.
  4. Assert `onOpenChange` was called exactly once with `true`.

Verified locally that the test **fails** against a render-body-sync
revision — swapping the useEffect reset for
`if (lastDispatchRef.current !== rawOpen) lastDispatchRef.current = rawOpen`
gives 0 callbacks because the speculative render's `true` write
survives — and **passes** on this head (1 callback). Full repo suite:
20 suites / 137 tests (+1 pre-existing skip).

Refs #622 (review)

Author: hippye99

tests/concurrent-render.test.tsx

@@ -1,27 +1,36 @@
 /**
  * Regression coverage for the concurrent-render blocker flagged in the second
- * round of the #622 review by @nrps9909.
+ * review round of #622 by @nrps9909.
  *
- * A previous revision synchronized the dedup baseline in the render body:
+ * The specific scenario:
+ *
+ *   1. A controlled Trigger is committed with `popupVisible={false}`.
+ *   2. A `startTransition` attempts to move to `popupVisible={true}`, but a
+ *      child of the Trigger suspends. React holds the previously committed
+ *      UI while the transition is pending — the original target stays in
+ *      the DOM and remains the one wired to Trigger's `onFocus`/`onBlur`.
+ *   3. Focusing that still-committed original target should emit
+ *      `onOpenChange(true)` exactly once.
+ *
+ * A previous revision of the fix synchronized the dedup baseline in the
+ * render body:
  *
  *   if (lastDispatchedOpenRef.current !== rawOpen) {
  *     lastDispatchedOpenRef.current = rawOpen;
  *   }
  *
- * That write happens for **every** render, including speculative renders that
- * React later discards (Suspense / transitions). React does not roll back
- * ref writes when a render is discarded, so the discarded render's `rawOpen`
- * leaks into the baseline. If the old target is still committed and later
- * dispatches the same value the speculative render tried to reach, the
- * (real) dispatch is dropped as a duplicate.
- *
- * The current revision writes the ref only inside the dispatch handler and
- * resets it via `useEffect`, which never runs for discarded renders. This
- * test pins that: after a suspended transition never commits, focusing the
- * still-committed target must emit `onOpenChange(true)`.
+ * That write happens even in the *speculative* render for the suspended
+ * transition, and React does not roll back ref writes when a render is
+ * discarded. The ref then holds `true` (from the speculative rawOpen),
+ * so when the user focuses the still-committed target the dedup check
+ * treats the dispatch as a duplicate and drops it — 0 callbacks instead
+ * of 1.
  *
- * On the render-body-sync revision this asserts 0 callbacks; with the
- * useEffect-reset revision it asserts 1.
+ * The current revision moves the ref reset into `React.useEffect` and
+ * never writes the ref during render. `useEffect` runs only for
+ * committed renders, so a discarded suspended transition cannot pollute
+ * the baseline. This test asserts the one-callback behaviour and fails
+ * against a render-body-sync revision (0 callbacks).
  */
 import { act, cleanup, fireEvent, render } from '@testing-library/react';
 import { spyElementPrototypes } from '@rc-component/util/lib/test/domHook';
@@ -76,131 +85,84 @@ describe('Trigger.ConcurrentRender (#622 review)', () => {
     jest.useRealTimers();
   });
 
-  it('does not let a discarded render leak into the dedup baseline (suspense throws mid-render)', async () => {
+  it('a suspended transition attempting popupVisible=false→true does not corrupt the dedup baseline; focusing the still-committed target emits exactly one onOpenChange(true)', async () => {
     const onOpenChange = jest.fn();
 
-    // A child that throws mid-render when `attempt` is true. This mirrors a
-    // suspense/transition where an attempted render is abandoned before it
-    // commits. React catches the thrown value at the error boundary, so the
-    // Trigger's render body executes but the surrounding tree never
-    // commits with the attempted `popupVisible={true}`.
-    const AttemptChild: React.FC<{ attempt: boolean }> = ({ attempt }) => {
+    // A never-resolving promise, so a `startTransition` that reaches this
+    // component stays pending indefinitely and React keeps the previous
+    // commit on screen.
+    const suspender: Promise<void> = new Promise(() => {});
+
+    // A child that either renders a Trigger-wired target (attempt=false)
+    // or throws the suspender (attempt=true). Forwards Trigger's injected
+    // DOM handlers onto the target span so `onFocus`/`onBlur` reach the
+    // Trigger's own action wiring.
+    const Child = React.forwardRef<
+      HTMLSpanElement,
+      { attempt: boolean } & React.HTMLAttributes<HTMLSpanElement>
+    >(({ attempt, ...rest }, ref) => {
       if (attempt) {
-        throw new Error('attempted-render-should-not-commit');
-      }
-      return <span className="target" tabIndex={0} />;
-    };
-
-    class Boundary extends React.Component<
-      { children: React.ReactNode; onCatch: () => void },
-      { errored: boolean }
-    > {
-      state = { errored: false };
-      componentDidCatch() {
-        this.props.onCatch();
-        this.setState({ errored: true });
-      }
-      render() {
-        if (this.state.errored) {
-          return <span className="target-fallback" tabIndex={0} />;
-        }
-        return this.props.children;
+        throw suspender;
       }
-    }
-
-    const onCatch = jest.fn();
+      return <span ref={ref} className="target" tabIndex={0} {...rest} />;
+    });
 
     const Harness: React.FC<{ open: boolean; attempt: boolean }> = ({
       open,
       attempt,
     }) => (
-      <Boundary onCatch={onCatch}>
+      <React.Suspense fallback={<span className="fallback" tabIndex={0} />}>
         <Trigger
           action={['focus']}
           popup={<strong>popup</strong>}
           popupVisible={open}
           onOpenChange={onOpenChange}
         >
-          <AttemptChild attempt={attempt} />
+          <Child attempt={attempt} />
         </Trigger>
-      </Boundary>
+      </React.Suspense>
     );
 
-    // Initial committed render: closed, no throw.
+    // Commit the initial state: closed, no throw. The committed target is
+    // what all subsequent focus events must land on.
     const { container, rerender } = render(<Harness open={false} attempt={false} />);
     await flush();
-    onOpenChange.mockClear();
 
-    // Attempt to render open — the child throws, so this render never
-    // commits with `popupVisible={true}`. On the render-body-sync revision
-    // the ref would still have been written to `true` during this attempt.
-    act(() => {
-      rerender(<Harness open attempt />);
-    });
-    await flush();
-    expect(onCatch).toHaveBeenCalled();
-
-    // The boundary now renders a fallback target. Focus it. On the current
-    // (useEffect-reset) revision the ref is fresh, so this dispatch goes
-    // through; on the leaky render-body-sync revision it would be skipped
-    // as a duplicate of the discarded render's `true`.
-    const fallback = container.querySelector(
-      '.target-fallback',
-    ) as HTMLSpanElement;
-    act(() => {
-      fireEvent.focus(fallback);
-    });
-    await flush();
+    const committedTarget = container.querySelector('.target') as HTMLSpanElement;
+    expect(committedTarget).toBeTruthy();
 
-    // Focus wasn't actually wired through the Trigger for the fallback
-    // element — but the fallback is still the committed target of the
-    // controlled Trigger (`popupVisible={true}` never committed, so the
-    // effective committed state remains `false`). What we're testing is
-    // that a subsequent dispatch attempt is not silently dropped because
-    // of a stale ref written during the discarded render.
-    //
-    // Simulate that dispatch attempt by re-rendering with a new
-    // controlled value the parent *does* commit. The Trigger should then
-    // observe the transition and emit exactly one `onOpenChange(true)`.
-    onOpenChange.mockClear();
+    // Attempt the transition: popupVisible=false → true, but the child
+    // throws the never-resolving suspender. Wrapping in `startTransition`
+    // tells React to keep the previous UI committed while this attempt
+    // pends. On a render-body-sync revision the speculative render would
+    // have written `true` to the dedup ref before suspending.
     act(() => {
-      rerender(<Harness open attempt={false} />);
+      React.startTransition(() => {
+        rerender(<Harness open attempt />);
+      });
     });
     await flush();
 
-    // Now the parent commits `popupVisible=true` on the fallback target.
-    // Focus it to trigger `hideAction=['focus']`-adjacent dispatch. Since
-    // `action=['focus']` opens, first focus should attempt open — but the
-    // controlled prop is already true. We want to confirm no leftover
-    // stale-ref state suppresses the reverse dispatch.
-    act(() => {
-      fireEvent.focus(fallback);
-      fireEvent.blur(fallback);
-    });
-    await flush();
+    // The originally committed target must still be in the DOM; the
+    // Suspense fallback should not have taken over because the transition
+    // is pending.
+    const stillCommitted = container.querySelector('.target') as HTMLSpanElement;
+    expect(stillCommitted).toBe(committedTarget);
+    expect(container.querySelector('.fallback')).toBeNull();
 
-    // With the current fix `onOpenChange` should have been emitted at
-    // most once (the blur), and the ref state at the end must permit a
-    // fresh dispatch — i.e., there must not be a phantom dedup from the
-    // discarded render.
-    // The most portable assertion for jsdom + rc-trigger's action wiring
-    // is: emitting either onOpenChange call is fine, but the ref must
-    // remain writable — a subsequent dispatch of the opposite value must
-    // fire.
     onOpenChange.mockClear();
+
+    // Focus the still-committed target. `action=['focus']` routes this to
+    // Trigger's `internalTriggerOpen(true)`. On the current fix the dedup
+    // ref was never written (useEffect only runs for committed renders,
+    // and the speculative render's render body never touched the ref), so
+    // this dispatch goes through cleanly.
     act(() => {
-      fireEvent.blur(fallback);
+      fireEvent.focus(committedTarget);
     });
     await flush();
 
-    // If the ref were leaked, this blur would dedup against the stale
-    // `true`. With the fix it either dispatches (ref undefined) or dedups
-    // against the correctly-tracked `false` — never falsely against a
-    // discarded `true`.
-    // We can at least assert onOpenChange was not called with `true` from
-    // some phantom recovery path:
-    for (const call of onOpenChange.mock.calls) {
-      expect(call[0]).toBe(false);
-    }
+    expect(onOpenChange).toHaveBeenCalledTimes(1);
+    expect(onOpenChange).toHaveBeenLastCalledWith(true);
   });
 });