FI-1237 fix: state of "full mocks" after first retry

autotests/configurator/mapLogPayloadInConsole.ts

@@ -18,6 +18,8 @@ export const mapLogPayloadInConsole: MapLogPayloadInConsole = (message, payload)
   }
 
   if (
+    message.startsWith('✓') ||
+    message.startsWith('✘') ||
     message.startsWith('Caught an error when running tests in retry') ||
     message.startsWith('Warning from TestCafe:') ||
     message.startsWith('Usage:')

package.json

@@ -68,7 +68,8 @@
   "scripts": {
     "asserts": "assert-modules-support-case-insensitive-fs ./autotests ./src && assert-package-lock-is-consistent",
     "precheck:all": "npm run asserts && npm run clear:lint:cache && npm run build",
-    "check:all": "npm audit && npm run parallel lint test",
+    "check:all": "npm audit && npm run parallel check:branch lint test",
+    "check:branch": "node ./build/checkBranch.js",
     "clear:lint:cache": "rm -f ./build/tsconfig.tsbuildinfo ./node_modules/.cache/lint-*",
     "lint": "npm run parallel lint:es lint:prettier lint:types",
     "lint:es": "eslint --cache --cache-location=./node_modules/.cache/lint-es --cache-strategy=content --ext=.ts --max-warnings=0 --report-unused-disable-directives .",

scripts/checkBranch.ts

@@ -0,0 +1,14 @@
+/**
+ * @file Checks that current git branch is `main`.
+ */
+
+import {execFileSync} from 'node:child_process';
+
+const currentBranch = execFileSync('git', ['branch', '--show-current'], {encoding: 'utf8'}).trim();
+
+if (currentBranch !== 'main') {
+  throw new Error(`Current branch in not "main": "${currentBranch}"`);
+}
+
+// eslint-disable-next-line no-console
+console.log('[OK] Current branch is "main"');

src/types/retries.ts

@@ -14,7 +14,6 @@ export type RetriesState = Readonly<{
   retryIndex: number;
   startLastRetryTimeInMs: UtcTimeInMs;
   successfulTestRunNamesHash: Record<string, true>;
-  visitedTestNamesHash: Record<string, true>;
   visitedTestRunEventsFileName: readonly string[];
 }>;
 
@@ -25,7 +24,6 @@ export type RetriesState = Readonly<{
 export type RunRetryOptions = Readonly<{
   runLabel: RunLabel;
   successfulTestRunNamesHash: VisitedTestNamesHash;
-  visitedTestNamesHash: VisitedTestNamesHash;
 }>;
 
 /**

src/utils/fullMocks/index.ts

@@ -3,6 +3,4 @@ export {enableFullMocks} from './enableFullMocks';
 /** @internal */
 export {getResponseFromFullMocks} from './getResponseFromFullMocks';
 /** @internal */
-export {getShouldApplyMocks} from './getShouldApplyMocks';
-/** @internal */
 export {writeResponseToFullMocks} from './writeResponseToFullMocks';

src/utils/pack/runPackWithArgs.ts

@@ -16,9 +16,8 @@ export const runPackWithArgs = async (): Promise<void> => {
   const runLabel = createRunLabel({concurrency, maxRetriesCount: 1, retryIndex: 1});
 
   const successfulTestRunNamesHash = Object.create(null) as VisitedTestNamesHash;
-  const visitedTestNamesHash = Object.create(null) as VisitedTestNamesHash;
 
-  await runTests({runLabel, successfulTestRunNamesHash, visitedTestNamesHash});
+  await runTests({runLabel, successfulTestRunNamesHash});
 
   endE2ed(EndE2edReason.LocalRunEnded);
 };

src/utils/report/writeHtmlReport.ts

@@ -11,6 +11,8 @@ import {renderReportToHtml} from './render';
 
 import type {FilePathFromRoot, ReportData, UtcTimeInMs} from '../../types/internal';
 
+const bytesInMb = 1_048_576;
+
 /**
  * Writes HTML report (`report.html` file) with test runs results.
  * @internal
@@ -27,11 +29,13 @@ export const writeHtmlReport = async (reportData: ReportData): Promise<void> =>
 
   await writeFile(reportFilePath, String(reportHtml));
 
-  const reportFileSize = await getFileSize(reportFilePath);
+  const reportFileSizeInBytes = await getFileSize(reportFilePath);
+
+  const reportFileSizeInMb = (reportFileSizeInBytes / bytesInMb).toFixed(2);
 
   const durationWithUnits = getDurationWithUnits(Date.now() - startTimeInMs);
 
   generalLog(
-    `HTML report was written (${reportFileSize} bytes) to "${reportFilePath}" in ${durationWithUnits}`,
+    `HTML report was written (${reportFileSizeInMb} Mb) to "${reportFilePath}" in ${durationWithUnits}`,
   );
 };

src/utils/retry/processRetry.ts

@@ -14,13 +14,7 @@ import type {RetriesState, UtcTimeInMs} from '../../types/internal';
  * @internal
  */
 export const processRetry = async (retriesState: RetriesState): Promise<void> => {
-  const {
-    concurrency,
-    maxRetriesCount,
-    retryIndex,
-    successfulTestRunNamesHash,
-    visitedTestNamesHash,
-  } = retriesState;
+  const {concurrency, maxRetriesCount, retryIndex, successfulTestRunNamesHash} = retriesState;
   const runLabel = createRunLabel({concurrency, maxRetriesCount, retryIndex});
 
   const startLastRetryTimeInMs = Date.now() as UtcTimeInMs;
@@ -35,7 +29,7 @@ export const processRetry = async (retriesState: RetriesState): Promise<void> =>
   try {
     await writeLogsToFile();
 
-    await runRetry({runLabel, successfulTestRunNamesHash, visitedTestNamesHash});
+    await runRetry({runLabel, successfulTestRunNamesHash});
 
     setReadonlyProperty(retriesState, 'isLastRetrySuccessful', true);
   } catch (error) {

src/utils/retry/runPackWithRetries.ts

@@ -21,7 +21,6 @@ export const runPackWithRetries = async (): Promise<void> => {
     retryIndex: 1,
     startLastRetryTimeInMs: 0 as UtcTimeInMs,
     successfulTestRunNamesHash: Object.create(null) as {},
-    visitedTestNamesHash: Object.create(null) as {},
     visitedTestRunEventsFileName: [],
   };
 

src/utils/retry/updateRetriesStateAfterRetry.ts

@@ -21,7 +21,6 @@ export const updateRetriesStateAfterRetry = async (retriesState: RetriesState):
     maxRetriesCount,
     retryIndex,
     successfulTestRunNamesHash,
-    visitedTestNamesHash,
     visitedTestRunEventsFileName,
   } = retriesState;
   const {
@@ -44,7 +43,6 @@ export const updateRetriesStateAfterRetry = async (retriesState: RetriesState):
     );
 
     successfulTestRunNamesHash[name] = true;
-    visitedTestNamesHash[name] = true;
   }
 
   for (const {runId} of newFullTestRuns) {
@@ -80,10 +78,6 @@ export const updateRetriesStateAfterRetry = async (retriesState: RetriesState):
 
   const failedTestNamesInLastRetry = failedNewFullTestRuns.map(({name}) => name);
 
-  for (const name of failedTestNamesInLastRetry) {
-    visitedTestNamesHash[name] = true;
-  }
-
   const retriesStateUpdate: Partial<Mutable<RetriesState>> = {
     concurrency: concurrencyForNextRetry,
     failedTestNamesInLastRetry,

src/utils/test/getRunTest.ts

@@ -49,7 +49,9 @@ export const getRunTest =
 
         beforeTest({retry, runId, testFn: test.testFn, testStaticOptions});
 
-        await runTestFn(runId, {context, page, request}, testStaticOptions);
+        const testController = {context, page, request};
+
+        await runTestFn({retry, runId, testController, testStaticOptions});
       } catch (error) {
         hasRunError = true;
         unknownRunError = error;

src/utils/test/runTestFn.ts

@@ -3,7 +3,7 @@ import {getTestTimeout} from '../../context/testTimeout';
 
 import {getFullPackConfig} from '../config';
 import {getTestRunEvent} from '../events';
-import {enableFullMocks, getShouldApplyMocks} from '../fullMocks';
+import {enableFullMocks} from '../fullMocks';
 import {getPromiseWithResolveAndReject} from '../promise';
 
 import type {PlaywrightTestArgs} from '@playwright/test';
@@ -12,15 +12,23 @@ import type {RunId, TestStaticOptions} from '../../types/internal';
 
 const delayForTestRunPromiseResolutionAfterTestTimeoutInMs = 100;
 
+type Options = Readonly<{
+  retry: number;
+  runId: RunId;
+  testController: PlaywrightTestArgs;
+  testStaticOptions: TestStaticOptions;
+}>;
+
 /**
  * Runs test function with reject in test run event.
  * @internal
  */
-export const runTestFn = async (
-  runId: RunId,
-  testController: PlaywrightTestArgs,
-  testStaticOptions: TestStaticOptions,
-): Promise<void> => {
+export const runTestFn = async ({
+  runId,
+  retry,
+  testController,
+  testStaticOptions,
+}: Options): Promise<void> => {
   const testRunEvent = getTestRunEvent(runId);
   const testTimeout = getTestTimeout();
 
@@ -37,7 +45,7 @@ export const runTestFn = async (
   const {fullMocks} = getFullPackConfig();
 
   if (fullMocks?.filterTests(testStaticOptions)) {
-    const shouldApplyMocks = getShouldApplyMocks(testStaticOptions.name);
+    const shouldApplyMocks = retry === 1;
 
     await enableFullMocks(fullMocks, shouldApplyMocks, testStaticOptions.filePath);
   }

src/utils/tests/runTests.ts

@@ -6,7 +6,6 @@ import {getFullPackConfig} from '../config';
 import {getRunLabel, setRunLabel} from '../environment';
 import {E2edError} from '../error';
 import {generalLog} from '../generalLog';
-import {setVisitedTestNamesHash} from '../globalState';
 import {startResourceUsageReading} from '../resourceUsage';
 
 import {beforeRunFirstTest} from './beforeRunFirstTest';
@@ -21,12 +20,8 @@ const playwrightCliPath = require.resolve('@playwright/test').replace('index.js'
  * Rejects, if there are some failed tests.
  * @internal
  */
-export const runTests = async ({
-  runLabel,
-  visitedTestNamesHash,
-}: RunRetryOptions): Promise<void> => {
+export const runTests = async ({runLabel}: RunRetryOptions): Promise<void> => {
   setRunLabel(runLabel);
-  setVisitedTestNamesHash(visitedTestNamesHash);
 
   try {
     const {browserInitTimeout, enableLiveMode, resourceUsageReadingInternal} = getFullPackConfig();
@@ -70,10 +65,10 @@ export const runTests = async ({
         beforeRunFirstTest();
       }
 
-      const playwrightProcess = fork(playwrightCliPath, playwrightArgs);
+      const playwrightProcess = fork(playwrightCliPath, playwrightArgs, {stdio: 'pipe'});
 
       playwrightProcess.stdout?.on('data', (data) => {
-        const stringData = stripExtraLogs(String(data).trim());
+        const stringData = stripExtraLogs(String(data).trim()).trim();
 
         if (stringData !== '') {
           if (stringData.startsWith('[e2ed]')) {

src/utils/tests/stripExtraLogs.ts

@@ -13,7 +13,7 @@ export const stripExtraLogs = (text: string): string => {
       const endIndex = line.lastIndexOf('›');
 
       if (startIndex >= 0) {
-        lines[index] = line.slice(0, startIndex) + line.slice(endIndex + 1);
+        lines[index] = line.slice(0, startIndex) + line.slice(endIndex);
       }
     }
   }