PRO-9847 fix: options of waitForRequest/waitForResponse actions

uid11 · uid11 · commit 7849902c0481 · 2025-04-07T07:26:45.000+03:00
fix: skip `waitForRequest`/`waitForResponse` errors after end of test
fix: handle `uncaughtException`/`unhandledRejection` global errors
diff --git a/src/README.md b/src/README.md
@@ -39,16 +39,17 @@ Modules in the dependency graph should only import the modules above them:
 32. `utils/promise`
 33. `utils/resourceUsage`
 34. `utils/fs`
-35. `utils/tests`
-36. `utils/end`
-37. `utils/pack`
-38. `useContext`
-39. `context`
-40. `utils/apiStatistics`
-41. `utils/selectors`
-42. `selectors`
-43. `utils/log`
-44. `utils/waitForEvents`
-45. `utils/expect`
-46. `expect`
-47. ...
+35. `utils/getGlobalErrorHandler`
+36. `utils/tests`
+37. `utils/end`
+38. `utils/pack`
+39. `useContext`
+40. `context`
+41. `utils/apiStatistics`
+42. `utils/selectors`
+43. `selectors`
+44. `utils/log`
+45. `utils/waitForEvents`
+46. `utils/expect`
+47. `expect`
+48. ...
diff --git a/src/actions/waitFor/waitForNewTab.ts b/src/actions/waitFor/waitForNewTab.ts
@@ -9,21 +9,22 @@ import type {InternalTab, Tab, Trigger, UtcTimeInMs} from '../../types/internal'
 
 type Options = Readonly<{skipLogs?: boolean; timeout?: number}>;
 
-type WaitForNewTab = ((trigger: Trigger, options?: Options) => Promise<Tab>) &
+type WaitForNewTab = ((trigger: Trigger | undefined, options?: Options) => Promise<Tab>) &
   ((options?: Options) => Promise<Tab>);
 
 /**
  * Waits for opening of new tab and returns this tab.
  */
 export const waitForNewTab = (async (
-  triggerOrOptions?: Options | Trigger,
+  triggerOrOptions?: Options | Trigger | undefined,
   options?: Options,
 ): Promise<Tab> => {
   const startTimeInMs = Date.now() as UtcTimeInMs;
 
   const context = getPlaywrightPage().context();
   const trigger = typeof triggerOrOptions === 'function' ? triggerOrOptions : undefined;
-  const finalOptions = typeof triggerOrOptions === 'function' ? options : triggerOrOptions;
+  const finalOptions =
+    typeof triggerOrOptions === 'function' ? options : (triggerOrOptions ?? options);
 
   const timeout = finalOptions?.timeout ?? getFullPackConfig().navigationTimeout;
   const timeoutWithUnits = getDurationWithUnits(timeout);
diff --git a/src/actions/waitFor/waitForRequest.ts b/src/actions/waitFor/waitForRequest.ts
@@ -1,4 +1,5 @@
 import {LogEventType} from '../../constants/internal';
+import {getTestRunPromise} from '../../context/testRunPromise';
 import {getPlaywrightPage} from '../../useContext';
 import {getFullPackConfig} from '../../utils/config';
 import {E2edError} from '../../utils/error';
@@ -33,15 +34,16 @@ type Options = Readonly<{skipLogs?: boolean; timeout?: number}>;
  */
 export const waitForRequest = (async <SomeRequest extends Request>(
   predicate: RequestPredicate<SomeRequest>,
-  triggerOrOptions?: Options | Trigger,
+  triggerOrOptions?: Options | Trigger | undefined,
   options?: Options,
 ): Promise<RequestWithUtcTimeInMs<SomeRequest>> => {
   const startTimeInMs = Date.now() as UtcTimeInMs;
 
   setCustomInspectOnFunction(predicate);
 
   const trigger = typeof triggerOrOptions === 'function' ? triggerOrOptions : undefined;
-  const finalOptions = typeof triggerOrOptions === 'function' ? options : triggerOrOptions;
+  const finalOptions =
+    typeof triggerOrOptions === 'function' ? options : (triggerOrOptions ?? options);
 
   const timeout = finalOptions?.timeout ?? getFullPackConfig().waitForRequestTimeout;
 
@@ -50,6 +52,13 @@ export const waitForRequest = (async <SomeRequest extends Request>(
   }
 
   const page = getPlaywrightPage();
+  const testRunPromise = getTestRunPromise();
+
+  let isTestRunCompleted = false;
+
+  void testRunPromise.then(() => {
+    isTestRunCompleted = true;
+  });
 
   const promise = page
     .waitForRequest(
@@ -73,7 +82,14 @@ export const waitForRequest = (async <SomeRequest extends Request>(
     .then(
       (playwrightRequest) =>
         getRequestFromPlaywrightRequest(playwrightRequest) as RequestWithUtcTimeInMs<SomeRequest>,
-    );
+    )
+    .catch((error: unknown) => {
+      if (isTestRunCompleted) {
+        return new Promise<RequestWithUtcTimeInMs<SomeRequest>>(() => {});
+      }
+
+      throw error;
+    });
 
   const timeoutWithUnits = getDurationWithUnits(timeout);
 
diff --git a/src/actions/waitFor/waitForRequestToRoute.ts b/src/actions/waitFor/waitForRequestToRoute.ts
@@ -53,13 +53,14 @@ export const waitForRequestToRoute = (async <
   SomeResponse extends Response,
 >(
   Route: ApiRouteClassTypeWithGetParamsFromUrl<RouteParams, SomeRequest, SomeResponse>,
-  triggerOrOptions?: Options<RouteParams, SomeRequest> | Trigger,
+  triggerOrOptions?: Options<RouteParams, SomeRequest> | Trigger | undefined,
   options?: Options<RouteParams, SomeRequest>,
 ): Return<RouteParams, SomeRequest> => {
   const startTimeInMs = Date.now() as UtcTimeInMs;
 
   const trigger = typeof triggerOrOptions === 'function' ? triggerOrOptions : undefined;
-  const finalOptions = typeof triggerOrOptions === 'function' ? options : triggerOrOptions;
+  const finalOptions =
+    typeof triggerOrOptions === 'function' ? options : (triggerOrOptions ?? options);
 
   const {predicate = () => true} = finalOptions ?? {};
   const timeout = finalOptions?.timeout ?? getFullPackConfig().waitForRequestTimeout;
diff --git a/src/actions/waitFor/waitForResponse.ts b/src/actions/waitFor/waitForResponse.ts
@@ -1,6 +1,7 @@
 import {AsyncLocalStorage} from 'node:async_hooks';
 
 import {LogEventType} from '../../constants/internal';
+import {getTestRunPromise} from '../../context/testRunPromise';
 import {getPlaywrightPage} from '../../useContext';
 import {getFullPackConfig} from '../../utils/config';
 import {setCustomInspectOnFunction} from '../../utils/fn';
@@ -39,15 +40,16 @@ export const waitForResponse = (async <
   SomeResponse extends Response = Response,
 >(
   predicate: ResponsePredicate<SomeRequest, SomeResponse>,
-  triggerOrOptions?: Options | Trigger,
+  triggerOrOptions?: Options | Trigger | undefined,
   options?: Options,
 ): Promise<ResponseWithRequest<SomeRequest, SomeResponse>> => {
   const startTimeInMs = Date.now() as UtcTimeInMs;
 
   setCustomInspectOnFunction(predicate);
 
   const trigger = typeof triggerOrOptions === 'function' ? triggerOrOptions : undefined;
-  const finalOptions = typeof triggerOrOptions === 'function' ? options : triggerOrOptions;
+  const finalOptions =
+    typeof triggerOrOptions === 'function' ? options : (triggerOrOptions ?? options);
 
   const timeout = finalOptions?.timeout ?? getFullPackConfig().waitForResponseTimeout;
 
@@ -56,6 +58,13 @@ export const waitForResponse = (async <
   }
 
   const page = getPlaywrightPage();
+  const testRunPromise = getTestRunPromise();
+
+  let isTestRunCompleted = false;
+
+  void testRunPromise.then(() => {
+    isTestRunCompleted = true;
+  });
 
   const promise = page
     .waitForResponse(
@@ -73,7 +82,14 @@ export const waitForResponse = (async <
         getResponseFromPlaywrightResponse(playwrightResponse) as Promise<
           ResponseWithRequest<SomeRequest, SomeResponse>
         >,
-    );
+    )
+    .catch((error: unknown) => {
+      if (isTestRunCompleted) {
+        return new Promise<ResponseWithRequest<SomeRequest, SomeResponse>>(() => {});
+      }
+
+      throw error;
+    });
 
   const timeoutWithUnits = getDurationWithUnits(timeout);
 
diff --git a/src/actions/waitFor/waitForResponseToRoute.ts b/src/actions/waitFor/waitForResponseToRoute.ts
@@ -53,13 +53,14 @@ export const waitForResponseToRoute = (async <
   SomeResponse extends Response,
 >(
   Route: ApiRouteClassTypeWithGetParamsFromUrl<RouteParams, SomeRequest, SomeResponse>,
-  triggerOrOptions?: Options<RouteParams, SomeRequest, SomeResponse> | Trigger,
+  triggerOrOptions?: Options<RouteParams, SomeRequest, SomeResponse> | Trigger | undefined,
   options?: Options<RouteParams, SomeRequest, SomeResponse>,
 ): Return<RouteParams, SomeRequest, SomeResponse> => {
   const startTimeInMs = Date.now() as UtcTimeInMs;
 
   const trigger = typeof triggerOrOptions === 'function' ? triggerOrOptions : undefined;
-  const finalOptions = typeof triggerOrOptions === 'function' ? options : triggerOrOptions;
+  const finalOptions =
+    typeof triggerOrOptions === 'function' ? options : (triggerOrOptions ?? options);
 
   const {predicate = () => true} = finalOptions ?? {};
   const timeout = finalOptions?.timeout ?? getFullPackConfig().waitForResponseTimeout;
diff --git a/src/bin/runE2edInDockerEnvironment.ts b/src/bin/runE2edInDockerEnvironment.ts
@@ -2,8 +2,12 @@ import {RunEnvironment, setRunEnvironment} from '../configurator';
 import {setProcessEndHandlers} from '../utils/end';
 import {registerEndE2edRunEvent, registerStartE2edRunEvent} from '../utils/events';
 import {logStartE2edError} from '../utils/generalLog';
+import {getGlobalErrorHandler} from '../utils/getGlobalErrorHandler';
 import {runPackWithRetries} from '../utils/retry';
 
+process.on('uncaughtException', getGlobalErrorHandler('E2edUncaughtException'));
+process.on('unhandledRejection', getGlobalErrorHandler('E2edUnhandledRejection'));
+
 setProcessEndHandlers();
 setRunEnvironment(RunEnvironment.Docker);
 
diff --git a/src/bin/runE2edInLocalEnvironment.ts b/src/bin/runE2edInLocalEnvironment.ts
@@ -4,6 +4,7 @@ import {setProcessEndHandlers} from '../utils/end';
 import {setPathToPack} from '../utils/environment';
 import {registerEndE2edRunEvent, registerStartE2edRunEvent} from '../utils/events';
 import {logStartE2edError} from '../utils/generalLog';
+import {getGlobalErrorHandler} from '../utils/getGlobalErrorHandler';
 import {runPackWithArgs} from '../utils/pack';
 import {setUiMode} from '../utils/uiMode';
 
@@ -21,6 +22,9 @@ const [pathToPack] = process.argv.splice(2, 1);
 
 assertValueIsDefined(pathToPack, 'pathToPack is defined', {argv: process.argv});
 
+process.on('uncaughtException', getGlobalErrorHandler('E2edUncaughtException'));
+process.on('unhandledRejection', getGlobalErrorHandler('E2edUnhandledRejection'));
+
 setPathToPack(pathToPack as FilePathFromRoot);
 setProcessEndHandlers();
 setRunEnvironment(RunEnvironment.Local);
diff --git a/src/bin/runTestsSubprocess.ts b/src/bin/runTestsSubprocess.ts
@@ -1,4 +1,5 @@
 import {getFullPackConfig} from '../utils/config';
+import {getGlobalErrorHandler} from '../utils/getGlobalErrorHandler';
 import {exitFromTestsSubprocess, runTests} from '../utils/tests';
 
 import type {RunRetryOptions} from '../types/internal';
@@ -9,6 +10,9 @@ const testIdleTimeoutObject = setInterval(() => process.send?.(null), testIdleTi
 
 testIdleTimeoutObject.unref();
 
+process.on('uncaughtException', getGlobalErrorHandler('SubprocessUncaughtException'));
+process.on('unhandledRejection', getGlobalErrorHandler('SubprocessUnhandledRejection'));
+
 /**
  * Returns exit code `0`, if all tests passed, and `1` otherwise.
  */
diff --git a/src/constants/internal.ts b/src/constants/internal.ts
@@ -50,6 +50,7 @@ export {
   DOT_ENV_PATH,
   EVENTS_DIRECTORY_PATH,
   EXPECTED_SCREENSHOTS_DIRECTORY_PATH,
+  GLOBAL_ERRORS_PATH,
   INSTALLED_E2ED_DIRECTORY_PATH,
   INTERNAL_DIRECTORY_NAME,
   INTERNAL_REPORTS_DIRECTORY_PATH,
diff --git a/src/constants/paths.ts b/src/constants/paths.ts
@@ -122,6 +122,12 @@ export const EXPECTED_SCREENSHOTS_DIRECTORY_PATH = join(
   'expectedScreenshots',
 ) as DirectoryPathFromRoot;
 
+/**
+ * Relative (from root) path to file with global errors of run.
+ * @internal
+ */
+export const GLOBAL_ERRORS_PATH = join(TMP_DIRECTORY_PATH, 'globalErrors.txt') as FilePathFromRoot;
+
 /**
  * Relative (from root) path to directory with tests screenshots.
  * @internal
diff --git a/src/test.ts b/src/test.ts
@@ -1,11 +1,17 @@
 import {getFullPackConfig} from './utils/config';
+import {getGlobalErrorHandler} from './utils/getGlobalErrorHandler';
 import {getRunTest} from './utils/test';
 import {isUiMode} from './utils/uiMode';
 
 import type {TestFunction} from './types/internal';
 
 import {test as playwrightTest} from '@playwright/test';
 
+process.removeAllListeners('unhandledRejection');
+
+process.on('uncaughtException', getGlobalErrorHandler('TestUncaughtException'));
+process.on('unhandledRejection', getGlobalErrorHandler('TestUnhandledRejection'));
+
 /**
  * Creates test with name, metatags, options and test function.
  * @internal
diff --git a/src/types/errors.ts b/src/types/errors.ts
@@ -12,6 +12,13 @@ export type E2edPrintedFields = Readonly<{
   stackTrace: readonly string[];
 }>;
 
+/**
+ * Global error type.
+ * @internal
+ */
+export type GlobalErrorType =
+  `${'E2ed' | 'Subprocess' | 'Test'}${'UncaughtException' | 'UnhandledRejection'}`;
+
 /**
  * JS error from browser.
  */
diff --git a/src/types/internal.ts b/src/types/internal.ts
@@ -30,7 +30,7 @@ export type {DeepMutable, DeepPartial, DeepReadonly, DeepRequired} from './deep'
 export type {E2edEnvironment} from './environment';
 export type {E2edPrintedFields, JsError} from './errors';
 /** @internal */
-export type {MaybeWithIsTestRunBroken} from './errors';
+export type {GlobalErrorType, MaybeWithIsTestRunBroken} from './errors';
 export type {LogEvent, Onlog, TestRunEvent} from './events';
 /** @internal */
 export type {EndTestRunEvent, FullEventsData} from './events';
diff --git a/src/utils/fs/index.ts b/src/utils/fs/index.ts
@@ -13,13 +13,17 @@ export {readEventFromFile} from './readEventFromFile';
 /** @internal */
 export {readEventsFromFiles} from './readEventsFromFiles';
 /** @internal */
+export {readGlobalErrors} from './readGlobalErrors';
+/** @internal */
 export {readStartInfo} from './readStartInfo';
 /** @internal */
 export {removeDirectory} from './removeDirectory';
 /** @internal */
 export {writeApiStatistics} from './writeApiStatistics';
 export {writeFile} from './writeFile';
 /** @internal */
+export {writeGlobalError} from './writeGlobalError';
+/** @internal */
 export {writeStartInfo} from './writeStartInfo';
 /** @internal */
 export {writeTestRunToJsonFile} from './writeTestRunToJsonFile';
diff --git a/src/utils/fs/readGlobalErrors.ts b/src/utils/fs/readGlobalErrors.ts
@@ -0,0 +1,15 @@
+import {readFile} from 'node:fs/promises';
+
+import {GLOBAL_ERRORS_PATH, READ_FILE_OPTIONS} from '../../constants/internal';
+
+/**
+ * Reads global errors of run from directory.
+ * @internal
+ */
+export const readGlobalErrors = async (): Promise<readonly string[]> => {
+  const globalErrorsJsonString = await readFile(GLOBAL_ERRORS_PATH, READ_FILE_OPTIONS).catch(
+    () => '',
+  );
+
+  return JSON.parse(`[${globalErrorsJsonString.slice(0, -2)}]`) as string[];
+};
diff --git a/src/utils/fs/writeGlobalError.ts b/src/utils/fs/writeGlobalError.ts
@@ -0,0 +1,13 @@
+import {appendFile} from 'node:fs/promises';
+
+import {GLOBAL_ERRORS_PATH} from '../../constants/internal';
+
+/**
+ * Writes single global error of run to common file.
+ * @internal
+ */
+export const writeGlobalError = async (globalError: string): Promise<void> => {
+  const globalErrorJsonString = JSON.stringify(globalError);
+
+  await appendFile(GLOBAL_ERRORS_PATH, `${globalErrorJsonString},\n`);
+};
diff --git a/src/utils/getGlobalErrorHandler.ts b/src/utils/getGlobalErrorHandler.ts
@@ -0,0 +1,21 @@
+import {E2edError} from './error';
+import {writeGlobalError} from './fs';
+import {generalLog} from './generalLog';
+
+import type {GlobalErrorType} from '../types/internal';
+
+/**
+ * Get handler for `uncaughtException` and `unhandledRejection` errors.
+ * @internal
+ */
+export const getGlobalErrorHandler =
+  (type: GlobalErrorType) =>
+  (cause: unknown): void => {
+    const message = `Caught ${type}`;
+
+    generalLog(message, {cause});
+
+    const error = new E2edError(message, {cause});
+
+    void writeGlobalError(error.toString());
+  };
diff --git a/src/utils/report/getReportErrors.ts b/src/utils/report/getReportErrors.ts
@@ -1,4 +1,5 @@
 import {getFullPackConfig} from '../config';
+import {readGlobalErrors} from '../fs';
 import {
   collectTestFilePaths,
   getUnsuccessfulTestFilePaths,
@@ -16,7 +17,7 @@ export const getReportErrors = async (
   notIncludedInPackTests: readonly TestFilePath[],
 ): Promise<readonly string[]> => {
   const {testFileGlobs} = getFullPackConfig();
-  const errors: string[] = [];
+  const errors = (await readGlobalErrors()) as string[];
 
   const allTestFilePaths = await collectTestFilePaths();
   const unsuccessfulTestFilePaths = await getUnsuccessfulTestFilePaths(
diff --git a/src/utils/selectors/Selector.ts b/src/utils/selectors/Selector.ts
