codeceptjs 4.0.0-beta.2 → 4.0.0-beta.21

package/lib/listener/retryEnhancer.js

@@ -0,0 +1,85 @@
+import event from '../event.js'
+import { enhanceMochaTest } from '../mocha/test.js'
+
+/**
+ * Enhance retried tests by copying CodeceptJS-specific properties from the original test
+ * This fixes the issue where Mocha's shallow clone during retries loses CodeceptJS properties
+ */
+export default function () {
+  event.dispatcher.on(event.test.before, test => {
+    // Check if this test is a retry (has a reference to the original test)
+    const originalTest = test.retriedTest && test.retriedTest()
+
+    if (originalTest) {
+      // This is a retried test - copy CodeceptJS-specific properties from the original
+      copyCodeceptJSProperties(originalTest, test)
+
+      // Ensure the test is enhanced with CodeceptJS functionality
+      enhanceMochaTest(test)
+    }
+  })
+}
+
+/**
+ * Copy CodeceptJS-specific properties from the original test to the retried test
+ * @param {CodeceptJS.Test} originalTest - The original test object
+ * @param {CodeceptJS.Test} retriedTest - The retried test object
+ */
+function copyCodeceptJSProperties(originalTest, retriedTest) {
+  // Copy CodeceptJS-specific properties
+  if (originalTest.opts !== undefined) {
+    retriedTest.opts = originalTest.opts ? { ...originalTest.opts } : {}
+  }
+
+  if (originalTest.tags !== undefined) {
+    retriedTest.tags = originalTest.tags ? [...originalTest.tags] : []
+  }
+
+  if (originalTest.notes !== undefined) {
+    retriedTest.notes = originalTest.notes ? [...originalTest.notes] : []
+  }
+
+  if (originalTest.meta !== undefined) {
+    retriedTest.meta = originalTest.meta ? { ...originalTest.meta } : {}
+  }
+
+  if (originalTest.artifacts !== undefined) {
+    retriedTest.artifacts = originalTest.artifacts ? [...originalTest.artifacts] : []
+  }
+
+  if (originalTest.steps !== undefined) {
+    retriedTest.steps = originalTest.steps ? [...originalTest.steps] : []
+  }
+
+  if (originalTest.config !== undefined) {
+    retriedTest.config = originalTest.config ? { ...originalTest.config } : {}
+  }
+
+  if (originalTest.inject !== undefined) {
+    retriedTest.inject = originalTest.inject ? { ...originalTest.inject } : {}
+  }
+
+  // Copy methods that might be missing
+  if (originalTest.addNote && !retriedTest.addNote) {
+    retriedTest.addNote = function (type, note) {
+      this.notes = this.notes || []
+      this.notes.push({ type, text: note })
+    }
+  }
+
+  if (originalTest.applyOptions && !retriedTest.applyOptions) {
+    retriedTest.applyOptions = originalTest.applyOptions.bind(retriedTest)
+  }
+
+  if (originalTest.simplify && !retriedTest.simplify) {
+    retriedTest.simplify = originalTest.simplify.bind(retriedTest)
+  }
+
+  // Preserve the uid if it exists
+  if (originalTest.uid !== undefined) {
+    retriedTest.uid = originalTest.uid
+  }
+
+  // Mark as enhanced
+  retriedTest.codeceptjs = true
+}

package/lib/listener/steps.js

@@ -1,86 +1,98 @@
-import debug from 'debug';
-import * as event from '../event.js';
-import { store } from '../store.js';
-import * as output from '../output.js';
+import debugModule from 'debug'
+const debug = debugModule('codeceptjs:steps')
+import event from '../event.js'
+import store from '../store.js'
+import output from '../output.js'
+import { BeforeHook, AfterHook, BeforeSuiteHook, AfterSuiteHook } from '../mocha/hooks.js'
+import recorder from '../recorder.js'
 
-debug('codeceptjs:steps');
+let currentTest
+let currentHook
 
-let currentTest;
-let currentHook;
+// Session names that should not contribute steps to the main test trace
+const EXCLUDED_SESSIONS = ['tryTo', 'hopeThat']
 
 /**
  * Register steps inside tests
  */
 export default function () {
-  event.dispatcher.on(event.test.before, (test) => {
-    test.startedAt = +new Date();
-    test.artifacts = {};
-  });
+  event.dispatcher.on(event.test.before, test => {
+    test.startedAt = +new Date()
+  })
 
-  event.dispatcher.on(event.test.started, (test) => {
-    currentTest = test;
-    currentTest.steps = [];
-    if (!('retryNum' in currentTest)) currentTest.retryNum = 0;
-    else currentTest.retryNum += 1;
-  });
+  event.dispatcher.on(event.test.started, test => {
+    currentTest = test
+    currentTest.steps = []
+    if (!('retryNum' in currentTest)) currentTest.retryNum = 0
+    else currentTest.retryNum += 1
+    output.scenario.started(test)
+  })
 
-  event.dispatcher.on(event.test.after, (test) => {
-    currentTest = null;
-  });
+  event.dispatcher.on(event.test.after, test => {
+    currentTest = null
+  })
 
-  event.dispatcher.on(event.test.finished, (test) => {
-  });
+  event.dispatcher.on(event.test.finished, test => {})
 
-  event.dispatcher.on(event.hook.started, (suite) => {
-    currentHook = suite.ctx.test;
-    currentHook.steps = [];
+  event.dispatcher.on(event.hook.started, hook => {
+    currentHook = hook.ctx.test
+    currentHook.steps = []
 
-    if (suite.ctx && suite.ctx.test) output.output.log(`--- STARTED ${suite.ctx.test.title} ---`);
-  });
+    output.hook.started(hook)
 
-  event.dispatcher.on(event.hook.passed, (suite) => {
-    currentHook = null;
-    if (suite.ctx && suite.ctx.test) output.output.log(`--- ENDED ${suite.ctx.test.title} ---`);
-  });
+    if (hook.ctx && hook.ctx.test) debug(`--- STARTED ${hook.ctx.test.title} ---`)
+  })
+
+  event.dispatcher.on(event.hook.passed, hook => {
+    currentHook = null
+    output.hook.passed(hook)
+    if (hook.ctx && hook.ctx.test) debug(`--- ENDED ${hook.ctx.test.title} ---`)
+  })
 
   event.dispatcher.on(event.test.failed, () => {
     const cutSteps = function (current) {
-      const failureIndex = current.steps.findIndex(el => el.status === 'failed');
+      const failureIndex = current.steps.findIndex(el => el.status === 'failed')
       // To be sure that failed test will be failed in report
-      current.state = 'failed';
-      current.steps.length = failureIndex + 1;
-      return current;
-    };
+      current.state = 'failed'
+      current.steps.length = failureIndex + 1
+      return current
+    }
     if (currentHook && Array.isArray(currentHook.steps) && currentHook.steps.length) {
-      currentHook = cutSteps(currentHook);
-      return currentHook = null;
+      currentHook = cutSteps(currentHook)
+      return (currentHook = null)
     }
-    if (!currentTest) return;
+    if (!currentTest) return
     // last step is failing step
-    if (!currentTest.steps.length) return;
-    return currentTest = cutSteps(currentTest);
-  });
+    if (!currentTest.steps.length) return
+    return (currentTest = cutSteps(currentTest))
+  })
 
   event.dispatcher.on(event.test.passed, () => {
-    if (!currentTest) return;
+    if (!currentTest) return
     // To be sure that passed test will be passed in report
-    delete currentTest.err;
-    currentTest.state = 'passed';
-  });
+    delete currentTest.err
+    currentTest.state = 'passed'
+  })
 
-  event.dispatcher.on(event.step.started, (step) => {
-    step.startedAt = +new Date();
-    step.test = currentTest;
+  event.dispatcher.on(event.step.started, step => {
+    store.currentStep = step
     if (currentHook && Array.isArray(currentHook.steps)) {
-      return currentHook.steps.push(step);
+      return currentHook.steps.push(step)
+    }
+    if (!currentTest || !currentTest.steps) return
+
+    // Check if we're in a session that should be excluded from main test steps
+    const currentSessionId = recorder.getCurrentSessionId()
+    if (currentSessionId && EXCLUDED_SESSIONS.includes(currentSessionId)) {
+      // Skip adding this step to the main test steps
+      return
     }
-    if (!currentTest || !currentTest.steps) return;
-    currentTest.steps.push(step);
-  });
-
-  event.dispatcher.on(event.step.finished, (step) => {
-    step.finishedAt = +new Date();
-    if (step.startedAt) step.duration = step.finishedAt - step.startedAt;
-    debug(`Step '${step}' finished; Duration: ${step.duration || 0}ms`);
-  });
+
+    currentTest.steps.push(step)
+  })
+
+  event.dispatcher.on(event.step.finished, step => {
+    store.currentStep = null
+    store.stepOptions = null
+  })
 }

package/lib/listener/store.js

@@ -0,0 +1,20 @@
+import event from '../event.js'
+import store from '../store.js'
+
+export default function () {
+  event.dispatcher.on(event.suite.before, suite => {
+    store.currentSuite = suite
+  })
+
+  event.dispatcher.on(event.suite.after, () => {
+    store.currentSuite = null
+  })
+
+  event.dispatcher.on(event.test.before, test => {
+    store.currentTest = test
+  })
+
+  event.dispatcher.on(event.test.finished, () => {
+    store.currentTest = null
+  })
+}