fix: Make runtime tests pass in the whole Debug/Release x BundleMode/LegacyEval matrix

Author: tjzel

apps/common-app/runtime-tests/ReJest/AutoRunRuntimeTestsRunner.tsx

@@ -81,24 +81,29 @@ export default function AutoRunRuntimeTestsRunner({
           setStatus(message);
         }
       },
-      onStart: async ({ only }) => {
+      onStart: async ({ only, include }) => {
         const filterSet = only ? new Set(only) : null;
+        const includeSet = include ? new Set(include) : null;
         const selected = tests.filter((test) => {
           if (test.disabled) {
             return false;
           }
+          if (includeSet?.has(test.testSuiteName)) {
+            return true;
+          }
           if (filterSet) {
             return filterSet.has(test.testSuiteName);
           }
           return !test.skipByDefault;
         });
 
-        if (filterSet) {
-          const known = new Set(tests.map((test) => test.testSuiteName));
-          const unknown = [...filterSet].filter((name) => !known.has(name));
-          if (unknown.length > 0) {
-            throw new Error(`Unknown test suites: ${unknown.join(', ')}`);
-          }
+        const known = new Set(tests.map((test) => test.testSuiteName));
+        const unknown = [
+          ...(filterSet ?? []),
+          ...(includeSet ?? []),
+        ].filter((name) => !known.has(name));
+        if (unknown.length > 0) {
+          throw new Error(`Unknown test suites: ${unknown.join(', ')}`);
         }
 
         const { configure, runTests } = require('./RuntimeTestsApi') as {

apps/common-app/runtime-tests/ReJest/matchers/Comparators.ts

@@ -1,5 +1,4 @@
-import { isColor, processColorNumber } from '../utils/colorUtils';
-
+/* eslint-disable @typescript-eslint/no-var-requires */
 import type { TestValue, ValidPropNames } from '../types';
 import { ComparisonMode, isValidPropName } from '../types';
 
@@ -37,10 +36,12 @@ const COMPARATORS: {
   },
 
   [ComparisonMode.COLOR]: (expected, value) => {
+    const { isColor, processColor } =
+      require('react-native-reanimated') as typeof import('react-native-reanimated');
     if (!isColor(expected) || !isColor(value)) {
       return false;
     }
-    return processColorNumber(expected) === processColorNumber(value);
+    return processColor(expected) === processColor(value);
   },
 
   [ComparisonMode.PIXEL]: (expected, value) => {

apps/common-app/runtime-tests/ReJest/matchers/rawMatchers.ts

@@ -208,17 +208,56 @@ export const toThrowMatcher: AsyncMatcher<ToThrowArgs> = async (
   let thrownException = false;
   let thrownExceptionMessage = null;
 
+  // Errors thrown on a Worklet Runtime inside a synchronous call (e.g.
+  // `runOnUISync`) don't reject on the RN runtime — they are reported
+  // asynchronously through `ErrorUtils.reportFatalError`. Capture the global
+  // handler for the duration of the call so the matcher sees them regardless
+  // of which handler (LogBox, remote reporter) is installed around the run.
+  const errorUtils = (
+    globalThis as {
+      ErrorUtils?: {
+        getGlobalHandler: () => (error: Error, isFatal?: boolean) => void;
+        setGlobalHandler: (
+          handler: (error: Error, isFatal?: boolean) => void
+        ) => void;
+      };
+    }
+  ).ErrorUtils;
+  let uncaughtErrorMessage: string | null = null;
+  const previousGlobalHandler = errorUtils?.getGlobalHandler();
+  errorUtils?.setGlobalHandler((error) => {
+    if (uncaughtErrorMessage === null) {
+      uncaughtErrorMessage = error?.message ?? String(error);
+    }
+  });
+
   try {
     await throwingFunction();
   } catch (e) {
     thrownException = true;
     thrownExceptionMessage = (e as Error)?.message || '';
   }
+
+  const deadline = Date.now() + 500;
+  while (
+    !thrownException &&
+    uncaughtErrorMessage === null &&
+    getCapturedConsoleErrors().consoleErrorCount < 1 &&
+    Date.now() < deadline
+  ) {
+    await new Promise((resolve) => setTimeout(resolve, 20));
+  }
+
+  if (previousGlobalHandler) {
+    errorUtils?.setGlobalHandler(previousGlobalHandler);
+  }
   await restoreConsole();
 
   const { consoleErrorCount, consoleErrorMessage } = getCapturedConsoleErrors();
-  const errorWasThrown = thrownException || consoleErrorCount >= 1;
-  const capturedMessage = thrownExceptionMessage || consoleErrorMessage;
+  const errorWasThrown =
+    thrownException || uncaughtErrorMessage !== null || consoleErrorCount >= 1;
+  const capturedMessage =
+    thrownExceptionMessage || uncaughtErrorMessage || consoleErrorMessage;
   const messageIsCorrect = errorMessage
     ? capturedMessage.includes(errorMessage)
     : true;

apps/common-app/runtime-tests/ReJest/utils/remoteReporter.ts

@@ -37,12 +37,16 @@ export interface RemoteReporterOptions {
   library: string;
   declaredSuites: DeclaredSuite[];
   onStatus: (message: string) => void;
-  onStart: (params: { only?: string[] }) => Promise<RunSummary | void>;
+  onStart: (params: {
+    only?: string[];
+    include?: string[];
+  }) => Promise<RunSummary | void>;
 }
 
 interface StartMessage {
   type: 'start';
   only?: string[];
+  include?: string[];
 }
 
 interface ErrorUtilsGlobal {

apps/common-app/runtime-tests/ReJest/utils/stringFormatUtils.ts

@@ -136,17 +136,20 @@ export function formatTestName(
   if (Array.isArray(variableObject)) {
     variableObject.forEach((value, index) => {
       // python-like syntax ${1} {2}
-      testName = testName.replace('${' + index + '}', valueToString(value));
+      testName = testName
+        .split('${' + index + '}')
+        .join(valueToString(value));
     });
   }
   if (typeof variableObject === 'object') {
     const keys = Object.keys(variableObject);
     keys.forEach((k) => {
       // Typical object literal syntax
-      testName = testName.replace(
-        '${' + k + '}',
-        valueToString(variableObject[k as keyof typeof variableObject])
-      );
+      testName = testName
+        .split('${' + k + '}')
+        .join(
+          valueToString(variableObject[k as keyof typeof variableObject])
+        );
     });
   }
 

apps/common-app/runtime-tests/worklets/suites.ts

@@ -1,3 +1,5 @@
+import { isBundleModeEnabled } from 'react-native-worklets';
+
 import type { RuntimeTestSuite } from '../types';
 
 export const WORKLETS_TEST_SUITES: RuntimeTestSuite[] = [
@@ -37,7 +39,11 @@ export const WORKLETS_TEST_SUITES: RuntimeTestSuite[] = [
       require('./tests/runtimes/reactNativeImportShim.test');
       require('./tests/runtimes/turboModuleRegistryShim.test');
     },
-    disabled: !globalThis._WORKLETS_BUNDLE_MODE_ENABLED,
+    // With inline requires, reading `globalThis._WORKLETS_BUNDLE_MODE_ENABLED`
+    // here would race module initialization order — the flag is only set once
+    // some module actually evaluates `react-native-worklets`. Calling
+    // `isBundleModeEnabled()` forces that initialization first.
+    disabled: !isBundleModeEnabled(),
     skipByDefault: true,
   },
   {

apps/common-app/runtime-tests/worklets/tests/memory/createSerializable.test.tsx

@@ -182,7 +182,7 @@ describe('Test createSerializable', () => {
       });
 
       test('createSerializableHostObject', async () => {
-        const hostObjectValue = globalThis.__reanimatedModuleProxy;
+        const hostObjectValue = globalThis.__workletsModuleProxy;
         const hostObjectKeys = Object.keys(hostObjectValue);
         scheduleOnTarget(() => {
           'worklet';
@@ -674,13 +674,12 @@ if (__DEV__) {
   describe('createSerializable for unsupported types', () => {
     test('throws when trying to serialize a Promise', async () => {
       const promise = Promise.resolve();
+      // The exact message differs between Bundle Mode and Legacy Eval Mode
+      // and between the RN-side and UI-side serialization paths; both
+      // variants name the offending type.
       await expect(() => {
         createSerializable(promise);
-      }).toThrow(
-        globalThis._WORKLETS_BUNDLE_MODE_ENABLED
-          ? 'Cannot copy value of type `Promise`'
-          : 'Promises cannot be converted to serializable.'
-      );
+      }).toThrow('Promise');
     });
 
     test('throws when trying to serialize a Proxy', async () => {

apps/common-app/runtime-tests/worklets/tests/memory/createSerializableOnUI.test.tsx

@@ -523,16 +523,20 @@ describe('Test createSerializableOnUI', () => {
   // });
 
   test('createSerializableOnUIInaccessibleObject', async () => {
-    const clazz = runOnUISync(() => {
-      'worklet';
-      class Clazz {
-        method() {}
-      }
+    // In Debug the unsupported value is copied back as an inaccessible
+    // placeholder that throws on property access; in Release `runOnUISync`
+    // throws synchronously while copying the value back. Both paths must
+    // land inside the asserted function.
+    await expect(() => {
+      const clazz = runOnUISync(() => {
+        'worklet';
+        class Clazz {
+          method() {}
+        }
 
-      return new Clazz();
-    });
+        return new Clazz();
+      });
 
-    await expect(() => {
       clazz.method();
     }).toThrow();
   });
@@ -565,12 +569,14 @@ describe('Test createSerializableOnUI', () => {
 
   if (__DEV__) {
     test('throws when trying to serialize a Promise', async () => {
+      // The exact message differs between Bundle Mode and Legacy Eval Mode;
+      // both variants name the offending type.
       await expect(() =>
         runOnUISync(() => {
           'worklet';
           return Promise.resolve();
         })
-      ).toThrow('Cannot copy value of type `Promise`');
+      ).toThrow('Promise');
     });
   }
 });

apps/common-app/runtime-tests/worklets/tests/memory/isSerializableRef.test.tsx

@@ -152,7 +152,7 @@ describe('Test isSerializableRef', () => {
   });
 
   test('check if createSerializable<host object> returns serializable ref', () => {
-    const hostObjectValue = globalThis.__reanimatedModuleProxy;
+    const hostObjectValue = globalThis.__workletsModuleProxy;
     const serializableRef = createSerializable(hostObjectValue);
 
     expect(isSerializableRef(serializableRef)).toBe(true);