test(rsc-mf): assert request coverage across action families

Author: cursoragent

tests/integration/rsc-mf/host/src/server-component-root/App.tsx

@@ -56,6 +56,34 @@ const App = () => {
     new Set(hostProxyActionIds),
   ).sort();
   const uniqueHostProxyActionIdsCount = uniqueHostProxyActionIds.length;
+  const incrementProxyActionIds = Array.from(
+    new Set(
+      [proxyIncrementRemoteCount, proxyBundledIncrementRemoteCount]
+        .map(action => getServerActionId(action))
+        .filter((actionId): actionId is string => Boolean(actionId)),
+    ),
+  ).sort();
+  const echoProxyActionIds = Array.from(
+    new Set(
+      [proxyRemoteActionEcho, proxyBundledRemoteActionEcho]
+        .map(action => getServerActionId(action))
+        .filter((actionId): actionId is string => Boolean(actionId)),
+    ),
+  ).sort();
+  const nestedProxyActionIds = Array.from(
+    new Set(
+      [proxyNestedRemoteAction, proxyBundledNestedRemoteAction]
+        .map(action => getServerActionId(action))
+        .filter((actionId): actionId is string => Boolean(actionId)),
+    ),
+  ).sort();
+  const defaultProxyActionIds = Array.from(
+    new Set(
+      [proxyDefaultRemoteAction, proxyBundledDefaultRemoteAction]
+        .map(action => getServerActionId(action))
+        .filter((actionId): actionId is string => Boolean(actionId)),
+    ),
+  ).sort();
 
   // Map remote action IDs to host-local proxy action IDs so client-side
   // callbacks can always post a host-resolvable action id. This keeps
@@ -177,6 +205,18 @@ const App = () => {
       <p className="host-bundled-proxy-action-ids">
         {bundledHostProxyActionIds.join(',')}
       </p>
+      <p className="host-increment-proxy-action-ids">
+        {incrementProxyActionIds.join(',')}
+      </p>
+      <p className="host-echo-proxy-action-ids">
+        {echoProxyActionIds.join(',')}
+      </p>
+      <p className="host-nested-proxy-action-ids">
+        {nestedProxyActionIds.join(',')}
+      </p>
+      <p className="host-default-proxy-action-ids">
+        {defaultProxyActionIds.join(',')}
+      </p>
       <Suspense fallback={<div>Loading Remote Async Server Info...</div>}>
         <AsyncRemoteServerInfo />
       </Suspense>

tests/integration/rsc-mf/tests/index.test.ts

@@ -74,6 +74,10 @@ async function renderRemoteRscIntoHost({ hostPort, page }: TestContext) {
   expect(html).toContain('host-proxy-action-ids');
   expect(html).toContain('host-direct-proxy-action-ids');
   expect(html).toContain('host-bundled-proxy-action-ids');
+  expect(html).toContain('host-increment-proxy-action-ids');
+  expect(html).toContain('host-echo-proxy-action-ids');
+  expect(html).toContain('host-nested-proxy-action-ids');
+  expect(html).toContain('host-default-proxy-action-ids');
 
   await page.goto(`http://127.0.0.1:${hostPort}${HOST_RSC_URL}`, {
     waitUntil: ['networkidle0', 'domcontentloaded'],
@@ -201,6 +205,38 @@ async function renderRemoteRscIntoHost({ hostPort, page }: TestContext) {
     ?.split(',')
     .filter(Boolean) as string[];
   expect(hostBundledProxyActionIdList.length).toBe(4);
+  const hostIncrementProxyActionIds = await page.$eval(
+    '.host-increment-proxy-action-ids',
+    el => el.textContent?.trim(),
+  );
+  const hostIncrementProxyActionIdList = hostIncrementProxyActionIds
+    ?.split(',')
+    .filter(Boolean) as string[];
+  expect(hostIncrementProxyActionIdList.length).toBeGreaterThan(0);
+  const hostEchoProxyActionIds = await page.$eval(
+    '.host-echo-proxy-action-ids',
+    el => el.textContent?.trim(),
+  );
+  const hostEchoProxyActionIdList = hostEchoProxyActionIds
+    ?.split(',')
+    .filter(Boolean) as string[];
+  expect(hostEchoProxyActionIdList.length).toBeGreaterThan(0);
+  const hostNestedProxyActionIds = await page.$eval(
+    '.host-nested-proxy-action-ids',
+    el => el.textContent?.trim(),
+  );
+  const hostNestedProxyActionIdList = hostNestedProxyActionIds
+    ?.split(',')
+    .filter(Boolean) as string[];
+  expect(hostNestedProxyActionIdList.length).toBeGreaterThan(0);
+  const hostDefaultProxyActionIds = await page.$eval(
+    '.host-default-proxy-action-ids',
+    el => el.textContent?.trim(),
+  );
+  const hostDefaultProxyActionIdList = hostDefaultProxyActionIds
+    ?.split(',')
+    .filter(Boolean) as string[];
+  expect(hostDefaultProxyActionIdList.length).toBeGreaterThan(0);
   const groupedProxyActionIdUnion = new Set([
     ...hostDirectProxyActionIdList,
     ...hostBundledProxyActionIdList,
@@ -515,10 +551,62 @@ function runTests({ mode }: TestConfig) {
       const usesBundledProxyIds = actionRequestIds.some(id =>
         bundledProxyActionIdSet.has(id),
       );
+      const incrementProxyActionIdSet = new Set(
+        (
+          await page.$eval(
+            '.host-increment-proxy-action-ids',
+            el => el.textContent || '',
+          )
+        )
+          .split(',')
+          .filter(Boolean),
+      );
+      const echoProxyActionIdSet = new Set(
+        (
+          await page.$eval(
+            '.host-echo-proxy-action-ids',
+            el => el.textContent || '',
+          )
+        )
+          .split(',')
+          .filter(Boolean),
+      );
+      const nestedProxyActionIdSet = new Set(
+        (
+          await page.$eval(
+            '.host-nested-proxy-action-ids',
+            el => el.textContent || '',
+          )
+        )
+          .split(',')
+          .filter(Boolean),
+      );
+      const defaultProxyActionIdSet = new Set(
+        (
+          await page.$eval(
+            '.host-default-proxy-action-ids',
+            el => el.textContent || '',
+          )
+        )
+          .split(',')
+          .filter(Boolean),
+      );
       expect(usesDirectProxyIds || usesBundledProxyIds).toBe(true);
       if (!usesDirectProxyIds || !usesBundledProxyIds) {
         expect(hostProxyMapCollisionCount).toBeGreaterThan(0);
       }
+      expect(
+        actionRequestIds.some(id => incrementProxyActionIdSet.has(id)),
+      ).toBe(true);
+      expect(actionRequestIds.some(id => echoProxyActionIdSet.has(id))).toBe(
+        true,
+      );
+      expect(actionRequestIds.some(id => nestedProxyActionIdSet.has(id))).toBe(
+        true,
+      );
+      expect(actionRequestIds.some(id => defaultProxyActionIdSet.has(id))).toBe(
+        true,
+      );
       expect(
         actionRequestIds.every(
           id =>