FI-705 fix: stricter type of expect function

feat: add field `maxIntervalBetweenRequestsInMs` ot abstract class `Page`
feat: add examples of `mapBackendResponseErrorToLog`/`mapBackendResponseToLog`
tests: more tests of types of selectors methods

autotests/configurator/index.ts

@@ -1,5 +1,7 @@
 export {doAfterPack} from './doAfterPack';
 export {doBeforePack} from './doBeforePack';
+export {mapBackendResponseErrorToLog} from './mapBackendResponseErrorToLog';
+export {mapBackendResponseToLog} from './mapBackendResponseToLog';
 export {mapLogPayloadInConsole} from './mapLogPayloadInConsole';
 export {mapLogPayloadInLogFile} from './mapLogPayloadInLogFile';
 export {mapLogPayloadInReport} from './mapLogPayloadInReport';

autotests/configurator/mapBackendResponseErrorToLog.ts

@@ -0,0 +1,32 @@
+import type {MapBackendResponseErrorToLog} from 'autotests/types/packSpecific';
+
+/**
+ * Maps responses with errors from the backend to "red" logs (as errors) during the test.
+ * It is assumed that the function will select responses with
+ * statuse codes of 400 and higher (client and server errors).
+ * Backend responses with errors are accumulated in separate "red" log step
+ * (with `logEventStatus: 'failed'`).
+ * Log the `responseBody` field carefully, as the body of backend response can be very large.
+ * If the function returns `undefined`, the response is not logged (skipped).
+ */
+export const mapBackendResponseErrorToLog: MapBackendResponseErrorToLog = ({
+  request,
+  responseBody,
+  responseHeaders,
+  statusCode,
+}) => {
+  if (statusCode < 400) {
+    return undefined;
+  }
+
+  const {requestBody, ...requestWithoutBody} = request ?? {};
+
+  return {
+    request: {
+      requestBody: requestBody instanceof Buffer ? String(requestBody) : requestBody,
+      ...requestWithoutBody,
+    },
+    responseBody: responseBody instanceof Buffer ? String(responseBody) : responseBody,
+    responseHeaders,
+  };
+};

autotests/configurator/mapBackendResponseToLog.ts

@@ -0,0 +1,29 @@
+import type {MapBackendResponseToLog} from 'autotests/types/packSpecific';
+
+/**
+ * Maps responses from the backend to logs during the test.
+ * Backend responses received during a certain test step are accumulated
+ * in an array in the `backendResponses` field of the log of this step.
+ * Log the `responseBody` field carefully, as the body of backend response can be very large.
+ * If the function returns `undefined`, the response is not logged (skipped).
+ */
+export const mapBackendResponseToLog: MapBackendResponseToLog = ({
+  request,
+  responseBody,
+  responseHeaders,
+  statusCode,
+}) => {
+  if (statusCode >= 400) {
+    return undefined;
+  }
+
+  if (request) {
+    return {statusCode, url: request?.url};
+  }
+
+  return {
+    responseBody: responseBody instanceof Buffer ? String(responseBody) : responseBody,
+    responseHeaders,
+    statusCode,
+  };
+};

autotests/packs/allTests.ts

@@ -10,6 +10,8 @@ import {RunEnvironment, runEnvironment} from 'e2ed/configurator';
 import {
   doAfterPack,
   doBeforePack,
+  mapBackendResponseErrorToLog,
+  mapBackendResponseToLog,
   mapLogPayloadInConsole,
   mapLogPayloadInLogFile,
   mapLogPayloadInReport,
@@ -42,10 +44,8 @@ export const pack: Pack = {
   filterTestsIntoPack,
   liteReportFileName: 'lite-report.json',
   logFileName: 'pack-logs.log',
-  mapBackendResponseErrorToLog: ({request, responseHeaders, statusCode}) =>
-    statusCode >= 400 ? {request, responseHeaders, statusCode} : undefined,
-  mapBackendResponseToLog: ({request, statusCode}) =>
-    statusCode < 400 ? {statusCode, url: request?.url} : undefined,
+  mapBackendResponseErrorToLog,
+  mapBackendResponseToLog,
   mapLogPayloadInConsole,
   mapLogPayloadInLogFile,
   mapLogPayloadInReport,

autotests/pageObjects/pages/Main.ts

@@ -74,13 +74,16 @@ export class Main extends Page<CustomPageParams> {
   }
 
   override async waitForPageLoaded(): Promise<void> {
-    await waitForAllRequestsComplete(({url}) => {
-      if (url.startsWith('https://adservice.google.com/')) {
-        return false;
-      }
-
-      return true;
-    });
+    await waitForAllRequestsComplete(
+      ({url}) => {
+        if (url.startsWith('https://adservice.google.com/')) {
+          return false;
+        }
+
+        return true;
+      },
+      {maxIntervalBetweenRequestsInMs: this.maxIntervalBetweenRequestsInMs},
+    );
 
     await waitForInterfaceStabilization(this.pageStabilizationInterval);
   }

autotests/pageObjects/pages/Search.ts

@@ -34,18 +34,21 @@ export class Search extends MobilePage<CustomPageParams> {
   }
 
   override async waitForPageLoaded(): Promise<void> {
-    await waitForAllRequestsComplete(({url}) => {
-      if (
-        url.startsWith('https://adservice.google.com/') ||
-        url.startsWith('https://googleads.g.doubleclick.net/') ||
-        url.startsWith('https://play.google.com/') ||
-        url.startsWith('https://static.doubleclick.net/')
-      ) {
-        return false;
-      }
-
-      return true;
-    });
+    await waitForAllRequestsComplete(
+      ({url}) => {
+        if (
+          url.startsWith('https://adservice.google.com/') ||
+          url.startsWith('https://googleads.g.doubleclick.net/') ||
+          url.startsWith('https://play.google.com/') ||
+          url.startsWith('https://static.doubleclick.net/')
+        ) {
+          return false;
+        }
+
+        return true;
+      },
+      {maxIntervalBetweenRequestsInMs: this.maxIntervalBetweenRequestsInMs},
+    );
 
     await waitForInterfaceStabilization(this.pageStabilizationInterval);
   }

autotests/tests/internalTypeTests/selectors.skip.ts

@@ -5,25 +5,30 @@ import {
   locatorIdSelector,
 } from 'autotests/selectors';
 
+import type {Selector} from 'e2ed/types';
+
 // @ts-expect-error: wrong number of arguments
 htmlElementSelector.findByLocatorId();
 // @ts-expect-error: wrong type of arguments
 htmlElementSelector.findByLocatorId(0);
 // ok
-htmlElementSelector.findByLocatorId('id');
+htmlElementSelector.findByLocatorId('id') satisfies Selector;
 // ok
-htmlElementSelector.findByLocatorId('id').findByLocatorId('id2');
+htmlElementSelector.findByLocatorId('id').findByLocatorId('id2') satisfies Selector;
 // ok
-htmlElementSelector.findByLocatorId('id').find('.test-children');
+htmlElementSelector.findByLocatorId('id').find('.test-children') satisfies Selector;
 // ok
-htmlElementSelector.find('body').findByLocatorId('id');
+htmlElementSelector.find('body').findByLocatorId('id') satisfies Selector;
 
 // ok
-createSelector('id').findByLocatorId('id').find('body').findByLocatorId('id');
+createSelector('id').findByLocatorId('id').find('body').findByLocatorId('id') satisfies Selector;
 // ok
-createSelectorByCss('id').findByLocatorId('id').find('body').findByLocatorId('id');
+createSelectorByCss('id')
+  .findByLocatorId('id')
+  .find('body')
+  .findByLocatorId('id') satisfies Selector;
 // ok
-locatorIdSelector('id').findByLocatorId('id').find('body').findByLocatorId('id');
+locatorIdSelector('id').findByLocatorId('id').find('body').findByLocatorId('id') satisfies Selector;
 
 // @ts-expect-error: wrong number of arguments
 locatorIdSelector();
@@ -32,32 +37,32 @@ locatorIdSelector();
 locatorIdSelector(3);
 
 // ok
-htmlElementSelector.filterByLocatorId('id');
+htmlElementSelector.filterByLocatorId('id') satisfies Selector;
 // ok
-htmlElementSelector.parentByLocatorId('id');
+htmlElementSelector.parentByLocatorId('id') satisfies Selector;
 // ok
-htmlElementSelector.childByLocatorId('id');
+htmlElementSelector.childByLocatorId('id') satisfies Selector;
 // ok
-htmlElementSelector.siblingByLocatorId('id');
+htmlElementSelector.siblingByLocatorId('id') satisfies Selector;
 // ok
-htmlElementSelector.nextSiblingByLocatorId('id');
+htmlElementSelector.nextSiblingByLocatorId('id') satisfies Selector;
 // ok
-htmlElementSelector.prevSiblingByLocatorId('id');
+htmlElementSelector.prevSiblingByLocatorId('id') satisfies Selector;
 
 // ok
-htmlElementSelector.filterByLocatorParameter('prop', 'value');
+htmlElementSelector.filterByLocatorParameter('prop', 'value') satisfies Selector;
 // ok
-htmlElementSelector.findByLocatorParameter('prop', 'value');
+htmlElementSelector.findByLocatorParameter('prop', 'value') satisfies Selector;
 // ok
-htmlElementSelector.parentByLocatorParameter('prop', 'value');
+htmlElementSelector.parentByLocatorParameter('prop', 'value') satisfies Selector;
 // ok
-htmlElementSelector.childByLocatorParameter('prop', 'value');
+htmlElementSelector.childByLocatorParameter('prop', 'value') satisfies Selector;
 // ok
-htmlElementSelector.siblingByLocatorParameter('prop', 'value');
+htmlElementSelector.siblingByLocatorParameter('prop', 'value') satisfies Selector;
 // ok
-htmlElementSelector.nextSiblingByLocatorParameter('prop', 'value');
+htmlElementSelector.nextSiblingByLocatorParameter('prop', 'value') satisfies Selector;
 // ok
-htmlElementSelector.prevSiblingByLocatorParameter('prop', 'value');
+htmlElementSelector.prevSiblingByLocatorParameter('prop', 'value') satisfies Selector;
 
 // ok
 void htmlElementSelector.getLocatorId();
@@ -66,7 +71,7 @@ void htmlElementSelector.getLocatorId();
 void htmlElementSelector.getLocatorId('foo');
 
 // ok
-void htmlElementSelector.hasLocatorId();
+void htmlElementSelector.hasLocatorId() satisfies Promise<boolean>;
 
 // TODO: should be an error "wrong number of arguments"
 void htmlElementSelector.hasLocatorId('foo');
@@ -78,9 +83,9 @@ void htmlElementSelector.hasLocatorParameter();
 void htmlElementSelector.getLocatorParameter();
 
 // ok
-void htmlElementSelector.getLocatorParameter('prop');
+void htmlElementSelector.getLocatorParameter('prop') satisfies Promise<string>;
 // ok
-void htmlElementSelector.hasLocatorParameter('prop');
+void htmlElementSelector.hasLocatorParameter('prop') satisfies Promise<boolean>;
 
 // ok
 htmlElementSelector.getDescription() satisfies string | undefined;

src/Page.ts

@@ -26,11 +26,25 @@ export abstract class Page<PageParams = undefined> {
 
     this.pageParams = pageParams as PageParams;
 
-    const {pageStabilizationInterval} = getFullPackConfig();
+    const {
+      pageStabilizationInterval,
+      waitForAllRequestsComplete: {maxIntervalBetweenRequestsInMs},
+    } = getFullPackConfig();
 
+    this.maxIntervalBetweenRequestsInMs = maxIntervalBetweenRequestsInMs;
     this.pageStabilizationInterval = pageStabilizationInterval;
   }
 
+  /**
+   * Default maximum interval (in milliseconds) between requests.
+   * After navigating to the page, `e2ed` will wait until
+   * all requests will complete, and only after that it will consider the page loaded.
+   * If there are no new requests for more than this interval,
+   * then we will consider that all requests completes
+   * The default value is taken from the corresponding field of the pack config.
+   */
+  readonly maxIntervalBetweenRequestsInMs: number;
+
   /**
    * Immutable page parameters.
    */
@@ -40,6 +54,7 @@ export abstract class Page<PageParams = undefined> {
    * After navigating to the page, `e2ed` will wait until
    * the page is stable for the specified time in millisecond,
    * and only after that it will consider the page loaded.
+   * The default value is taken from the corresponding field of the pack config.
    */
   readonly pageStabilizationInterval: number;
 
@@ -80,7 +95,9 @@ export abstract class Page<PageParams = undefined> {
   abstract getRoute(): PageRoute<unknown>;
 
   async waitForPageLoaded(): Promise<void> {
-    await waitForAllRequestsComplete(() => true);
+    await waitForAllRequestsComplete(() => true, {
+      maxIntervalBetweenRequestsInMs: this.maxIntervalBetweenRequestsInMs,
+    });
 
     await waitForInterfaceStabilization(this.pageStabilizationInterval);
   }

src/types/config/ownE2edConfig.ts

@@ -191,6 +191,7 @@ export type OwnE2edConfig<
      * Default maximum interval (in milliseconds) between requests.
      * If there are no new requests for more than this interval, then the promise
      * returned by the `waitForAllRequestsComplete` function will be successfully resolved.
+     * This parameter can be overridden on a specific page instance.
      */
     maxIntervalBetweenRequestsInMs: number;