test(e2e): migrate runner to rstest

[chenjiahan]

Summary

• Migrates the E2E test runner from @playwright/test to @rstest/core with a standalone e2e/rstest.config.ts, while keeping Playwright for browser automation.
• Updates E2E helpers to provide Playwright-like browser, context, page, request, and locator assertion compatibility so existing test cases can stay mostly unchanged.
• Restores Windows skip behavior for the affected E2E cases and applies targeted fixes needed for Rstest execution.

Validated with pnpm exec rslint --type-check e2e and full Rstest E2E coverage locally.

[gemini-code-assist]

Code Review

This pull request migrates the E2E testing framework from Playwright to Rstest, replacing @playwright/test with @rstest/core and implementing custom E2E test fixtures, assertions, and browser management. The review feedback highlights a correctness bug in getDeepTextContent when traversing shadow hosts and slot elements, a potential unhandled error in waitForExpectation if the timeout is too small, and redundant runtime Windows platform checks inside several test bodies since the skip logic has been moved to definition-time.

[gemini-code-assist]

The custom getDeepTextContent implementation has a correctness bug when traversing shadow hosts. If a shadow host contains a <slot> with fallback content, and light DOM children are assigned to it, the current implementation will traverse both the shadow root (including the fallback content inside the <slot>) and the light DOM children (node.childNodes). This results in both the fallback content (which is hidden/not rendered) and the slotted content being concatenated together.\n\nAdditionally, any light DOM children that are not assigned to any slot will still be traversed and included in the text.\n\nTo fix this, we should only traverse the shadow root if it exists, and when encountering an HTMLSlotElement, we should traverse its assigned nodes (slot.assignedNodes()) instead of its fallback children (unless assignedNodes() is empty).

const getLocatorTextContents = (locator: Locator) =>
  locator.evaluateAll((elements) => {
    const getDeepTextContent = (node: Node): string => {
      if (node.nodeType === Node.TEXT_NODE) {
        return node.textContent ?? '';
      }

      if (node instanceof HTMLSlotElement) {
        const assigned = node.assignedNodes();
        if (assigned.length > 0) {
          return assigned.map(getDeepTextContent).join('');
        }
      }

      if (node instanceof Element && node.shadowRoot) {
        return getDeepTextContent(node.shadowRoot);
      }

      let text = '';
      for (const child of node.childNodes) {
        text += getDeepTextContent(child);
      }
      return text;
    };

    return elements.map((element) => getDeepTextContent(element));
  });

[gemini-code-assist]

Using a while loop for waitForExpectation can lead to issues if the timeout is 0 or very small, or if there is clock drift, potentially throwing an unhandled undefined error because lastError is never initialized. \n\nUsing a do-while loop guarantees that the assertion check runs at least once, which is the standard behavior for assertion polling. We should also initialize lastError to a default fallback error to prevent throwing undefined.

const waitForExpectation = async (
  check: () => Promise<void>,
  options?: MatcherOptions,
) => {
  const timeout = options?.timeout ?? DEFAULT_EXPECT_TIMEOUT;
  const start = Date.now();
  let lastError: unknown = new Error('Timeout');

  do {
    try {
      await check();
      return;
    } catch (error) {
      lastError = error;
      await sleep(EXPECT_POLL_INTERVAL);
    }
  } while (Date.now() - start <= timeout);

  if (lastError instanceof Error) {
    throw lastError;
  }
  throw new Error(String(lastError));
};

[gemini-code-assist]

Since you have moved the Windows skip logic to definition-time via const test = process.platform === 'win32' ? baseTest.skip : baseTest;, the runtime check if (process.platform === 'win32') { test.skip(); } inside the test body is now redundant and unreachable. Consider removing the redundant runtime check from the test body.

[gemini-code-assist]

Since you have moved the Windows skip logic to definition-time via const test = process.platform === 'win32' ? baseTest.skip : baseTest;, the runtime check if (process.platform === 'win32') { test.skip(); } inside the test body is now redundant and unreachable. Consider removing the redundant runtime check from the test body.

[gemini-code-assist]

Since you have moved the Windows skip logic to definition-time via const test = process.platform === 'win32' ? baseTest.skip : baseTest;, the runtime check if (process.platform === 'win32') { test.skip(); } inside the test body is now redundant and unreachable. Consider removing the redundant runtime check from the test body.

[gemini-code-assist]

Since you have moved the Windows skip logic to definition-time via const test = process.platform === 'win32' ? baseTest.skip : baseTest;, the runtime check if (process.platform === 'win32') { test.skip(); } inside the test body is now redundant and unreachable. Consider removing the redundant runtime check from the test body.

[gemini-code-assist]

Since you have moved the Windows skip logic to definition-time via const test = process.platform === 'win32' ? baseTest.skip : baseTest;, the runtime check if (process.platform === 'win32') { test.skip(); } inside the test body is now redundant and unreachable. Consider removing the redundant runtime check from the test body.