add the support of reran mid-test due to a cy.visit

Author: netkardam

eslint.config.mjs

@@ -32,7 +32,7 @@ export default defineConfig([
                 Cypress: true
             },
 
-            ecmaVersion: 2018,
+            ecmaVersion: 2022,
             sourceType: 'module'
         },
 

reporter/index.js

@@ -1,10 +1,12 @@
 require('./commands');
 const {
-    clearAllureHookStepsFromTests,
     setTestIdToScreenshot,
     reorderAllureHooks,
-    ALLURE_AFTER_HOOK,
-    ALLURE_AFTER_EACH_HOOK
+    buildPendingResults,
+    loadPendingResults,
+    clearAllureHookStepsFromTests,
+    clearAllureHookStepsFromHook,
+    ALLURE_HOOK_NAME
 } = require('./patching.js');
 
 const {
@@ -80,21 +82,20 @@ const invokeResultsWriter = (allure, isGlobal) => {
     }
     try {
         clearAllureHookStepsFromTests(
-            allure &&
-                allure.reporter &&
-                allure.reporter.runtime &&
-                allure.reporter.runtime.config &&
-                allure.reporter.runtime.config.writer &&
-                allure.reporter.runtime.config.writer.tests,
+            allure.reporter.runtime.config.writer.tests,
             config.logAllureHooksEnabled()
         );
+
         return cy
             .task(
                 'writeAllureResults',
                 {
-                    results: allure.reporter.runtime.config,
+                    pendingResults: buildPendingResults({
+                        currentSpec:
+                            Cypress.spec.relative || Cypress.spec.absolute,
+                        allure
+                    }),
                     files: allure.reporter.files || [],
-                    mapping: allure.reporter.mochaIdToAllure,
                     clearSkipped: config.clearSkipped(),
                     isGlobal,
                     defineHistoryId: allure.reporter.defineHistoryId
@@ -110,6 +111,17 @@ const invokeResultsWriter = (allure, isGlobal) => {
     }
 };
 
+const skipAlreadyRunTest = (test) => {
+    if (test && test._ALREADY_RAN) {
+        if (!(test.id in Cypress.Allure.reporter.mochaIdToAllure)) {
+            test['_ALLURE_RUN'] = true;
+            return false;
+        }
+        return !test._ALLURE_RUN;
+    }
+    return false;
+};
+
 class CypressAllureReporter {
     constructor() {
         logger.allure(
@@ -157,13 +169,22 @@ class CypressAllureReporter {
                 this.reporter.endSuite(isGlobal);
             })
             .on(EVENT_TEST_BEGIN, (test) => {
+                if (skipAlreadyRunTest(test)) {
+                    return;
+                }
                 onTestBegin(test);
             })
             .on(EVENT_TEST_FAIL, (test, err) => {
+                if (skipAlreadyRunTest(test)) {
+                    return;
+                }
                 onTestFail(test, err);
             })
             .on(EVENT_TEST_PASS, (test) => {
                 logger.mocha(`EVENT_TEST_PASS: %s %O`, test.title, test);
+                if (skipAlreadyRunTest(test)) {
+                    return;
+                }
                 this.reporter.passTestCase(test);
             })
             .on(EVENT_TEST_RETRY, (test) => {
@@ -173,9 +194,15 @@ class CypressAllureReporter {
             })
             .on(EVENT_TEST_PENDING, (test) => {
                 logger.mocha(`EVENT_TEST_PENDING: %s %O`, test.title, test);
+                if (skipAlreadyRunTest(test)) {
+                    return;
+                }
                 this.reporter.pendingTestCase(test);
             })
             .on(EVENT_TEST_END, (test) => {
+                if (skipAlreadyRunTest(test)) {
+                    return;
+                }
                 onTestEnd(test);
             })
             .on(EVENT_HOOK_BEGIN, (hook) => {
@@ -184,6 +211,11 @@ class CypressAllureReporter {
             })
             .on(EVENT_HOOK_END, (hook) => {
                 logger.mocha(`EVENT_HOOK_END: %s %O`, hook.title, hook);
+                clearAllureHookStepsFromHook({
+                    hook,
+                    reporter: this.reporter,
+                    allureLogHooks: config.logAllureHooksEnabled()
+                });
                 this.reporter.endHook(hook);
             });
 
@@ -298,13 +330,11 @@ if (!Cypress.Allure) {
 Cypress.Screenshot.defaults({
     onAfterScreenshot(_, details) {
         logger.cy(`onAfterScreenshot: %O`, details);
-        setTestIdToScreenshot(
-            config.allureEnabled(),
-            Cypress.Allure &&
-                Cypress.Allure.reporter &&
-                Cypress.Allure.reporter.mochaIdToAllure,
+        setTestIdToScreenshot({
+            allureEnabled: config.allureEnabled(),
+            allure: Cypress.Allure,
             details
-        );
+        });
         if (
             config.allureEnabled() &&
             !shouldUseAfterSpec(Cypress.config()) &&
@@ -384,12 +414,19 @@ const attachVideo = (reporter, test, status) => {
 };
 
 if (config.allureEnabled()) {
-    afterEach(ALLURE_AFTER_EACH_HOOK, function () {
+    before(ALLURE_HOOK_NAME['before'], () => {
+        logger.allure('########### before all ################');
+        cy.task('getPendingAllureResults', undefined, {
+            log: config.logAllureHooksEnabled()
+        }).then(loadPendingResults);
+    });
+
+    afterEach(ALLURE_HOOK_NAME['afterEach'], () => {
         logger.allure('########### after each ################');
         cy.then(() => invokeResultsWriter(Cypress.Allure, false));
     });
 
-    after(ALLURE_AFTER_HOOK, function () {
+    after(ALLURE_HOOK_NAME['after'], () => {
         logger.allure('########### after all ################');
         cy.then(() => {
             Cypress.Allure.reporter.prepareAllureReport(

reporter/patching.js

@@ -1,20 +1,41 @@
 const logger = require('./debug');
 
-const ALLURE_AFTER_HOOK = '__allure_after_hook__';
-const ALLURE_AFTER_EACH_HOOK = '__allure_after_each_hook__';
-
-const isAllureAfterHook = (nameOrFn) => nameOrFn.includes(ALLURE_AFTER_HOOK);
+const ALLURE_HOOK_NAME = {
+    after: '__allure_after_hook__',
+    afterEach: '__allure_after_each_hook__',
+    before: '__allure_before_hook__',
+    beforeEach: '__allure_before_each_hook__'
+};
 
-const isAllureAfterEachHook = (nameOrFn) =>
-    nameOrFn.includes(ALLURE_AFTER_EACH_HOOK);
+/**
+ * isAllureSpecificHook
+ * @param {string} hookName
+ * @param  {Array<String>} type - can be after/afterEach/before/beforeEach
+ * @return true/false
+ */
+const isAllureSpecificHook = (hookName, ...type) => {
+    if (!hookName) {
+        return false;
+    }
+    let keys = type.flat(Infinity);
+    if (keys.length === 0) {
+        keys = Object.keys(ALLURE_HOOK_NAME);
+    }
+    keys = keys.filter((key) => key in ALLURE_HOOK_NAME);
+    return keys.some((key) => hookName.includes(ALLURE_HOOK_NAME[key]));
+};
 
-const isAllureHook = (nameOrFn) =>
-    isAllureAfterHook(nameOrFn) || isAllureAfterEachHook(nameOrFn);
+const isAllureHook = (hookName) => isAllureSpecificHook(hookName);
 
 const reorderAllureHooksArray = (hooksArray) => {
     let commonHooks = hooksArray.filter((hook) => !isAllureHook(hook.title));
-    let allureHooks = hooksArray.filter((hook) => isAllureHook(hook.title));
-    return [...commonHooks, ...allureHooks];
+    let allureBeforeHooks = hooksArray.filter((hook) =>
+        isAllureSpecificHook(hook.title, 'before', 'beforeEach')
+    );
+    let allureAfterHooks = hooksArray.filter((hook) =>
+        isAllureSpecificHook(hook.title, 'after', 'afterEach')
+    );
+    return [...allureBeforeHooks, ...commonHooks, ...allureAfterHooks];
 };
 
 const reorderAllureHooksGeneric = (
@@ -41,11 +62,10 @@ const reorderAllureHooksGeneric = (
     }
 };
 
-const clearAllureHookSteps = (test, allureLogHooks = false) => {
+const clearTestAllureHookSteps = (test, allureLogHooks = false) => {
     if (!(test && test.steps && test.steps.length)) {
         return test;
     }
-
     test.steps = test.steps.reduce((steps, step) => {
         if (
             isAllureHook(step.name) &&
@@ -68,26 +88,31 @@ const clearAllureHookSteps = (test, allureLogHooks = false) => {
 const clearAllureHookStepsFromTests = (tests, allureLogHooks = false) => {
     if (tests) {
         tests.forEach((test) => {
-            clearAllureHookSteps(test, allureLogHooks);
+            clearTestAllureHookSteps(test, allureLogHooks);
         });
     }
 };
 
-const reorderAllureAfterHooks = (suite) => {
+const reorderAllureAfterAllHooks = (suite) => {
     reorderAllureHooksGeneric(suite, 'afterAll');
 };
 
 const reorderAllureAfterEachHooks = (suite) => {
     reorderAllureHooksGeneric(suite, 'afterEach');
 };
 
+const reorderAllureBeforeAllHooks = (suite) => {
+    reorderAllureHooksGeneric(suite, 'beforeAll');
+};
+
 const reorderAllureGlobalHooks = (suite) => {
     reorderAllureHooksGeneric(suite, 'hooks', '');
 };
 
 const reorderAllureHooks = (suite) => {
+    reorderAllureBeforeAllHooks(suite);
     reorderAllureAfterEachHooks(suite);
-    reorderAllureAfterHooks(suite);
+    reorderAllureAfterAllHooks(suite);
     reorderAllureGlobalHooks(suite);
 };
 
@@ -110,11 +135,12 @@ const isLastRootHook = () => {
     return lastHook && lastHook.hookId === currentRunnable.hookId;
 };
 
-const setTestIdToScreenshot = (allureEnabled, mochaIdToAllure, details) => {
-    if (allureEnabled) {
+const setTestIdToScreenshot = ({ allureEnabled, allure, details }) => {
+    if (allureEnabled && allure && allure.reporter) {
         let currentTest = cy.state('test');
+        let { mochaIdToAllure } = allure.reporter;
         if (details && currentTest && mochaIdToAllure) {
-            const testIds = mochaIdToAllure[currentTest && currentTest.id];
+            const testIds = mochaIdToAllure[currentTest.id];
             if (testIds) {
                 details['testId'] = currentTest.id;
                 let testId = testIds.at(-1);
@@ -127,16 +153,84 @@ const setTestIdToScreenshot = (allureEnabled, mochaIdToAllure, details) => {
     }
 };
 
+const buildPendingResults = ({ currentSpec, allure }) => {
+    return {
+        currentSpec: currentSpec,
+        allureMapping: allure.reporter.mochaIdToAllure,
+        allureResults: allure.reporter.runtime.config,
+        allureResultContainer: allure.reporter.suites.map(
+            (suite) => suite.testResultContainer
+        )
+    };
+};
+
+const clearAllureHookStepsFromHook = ({
+    hook,
+    reporter,
+    allureLogHooks = false
+}) => {
+    if (!hook || !reporter) {
+        return;
+    }
+    let { currentHook } = reporter;
+    if (currentHook && !allureLogHooks && isAllureHook(hook.title)) {
+        // remove allure hook steps so hook will not be kept in the report
+        currentHook.info && (currentHook.info['steps'] = []);
+        currentHook.stepResult && (currentHook.stepResult['steps'] = []);
+    }
+};
+
+const loadPendingResults = ({
+    currentSpec,
+    allureResults,
+    allureMapping,
+    allureResultContainer
+}) => {
+    if (!currentSpec) {
+        return;
+    }
+    let currentRunningSpec = Cypress.spec.relative || Cypress.spec.absolute;
+    if (currentRunningSpec === currentSpec) {
+        if (
+            allureMapping &&
+            Object.keys(Cypress.Allure.reporter.mochaIdToAllure || {})
+                .length === 0
+        ) {
+            Cypress.Allure.reporter.mochaIdToAllure = allureMapping;
+        }
+        if (allureResults && allureResults.writer) {
+            Object.keys(allureResults.writer).forEach((key) => {
+                Cypress.Allure.reporter.runtime.config.writer[key] =
+                    allureResults.writer[key];
+            });
+        }
+        if (allureResultContainer) {
+            Cypress.Allure.reporter.runtime.config.writer['groups'].push(
+                ...allureResultContainer
+            );
+        }
+    } else {
+        cy.task(
+            'savePendingAllureResults',
+            {},
+            {
+                log: config.logAllureHooksEnabled()
+            }
+        ).then((pendingResults) => {
+            logger.allure(
+                '########### Reinit pendingResults ################ %O',
+                pendingResults
+            );
+        });
+    }
+};
 // Export everything
 module.exports = {
-    ALLURE_AFTER_HOOK,
-    ALLURE_AFTER_EACH_HOOK,
-    isAllureHook,
-    clearAllureHookStepsFromTests,
-    reorderAllureAfterHooks,
-    reorderAllureAfterEachHooks,
-    reorderAllureGlobalHooks,
+    ALLURE_HOOK_NAME,
     reorderAllureHooks,
-    isLastRootHook,
-    setTestIdToScreenshot
+    setTestIdToScreenshot,
+    buildPendingResults,
+    loadPendingResults,
+    clearAllureHookStepsFromTests,
+    clearAllureHookStepsFromHook
 };