fix more tests

Author: kobenguyent

lib/command/gherkin/init.js

@@ -3,9 +3,7 @@ import { mkdirp } from 'mkdirp'
 
 import output from '../../output.js'
 import { fileExists } from '../../utils.js'
-import {
-  getConfig, getTestRoot, updateConfig, safeFileWrite, findConfigFile,
-} from '../utils.js'
+import { getConfig, getTestRoot, updateConfig, safeFileWrite, findConfigFile } from '../utils.js'
 
 const featureFile = `Feature: Business rules
   In order to achieve my goals
@@ -14,68 +12,68 @@ const featureFile = `Feature: Business rules
 
   Scenario: do something
     Given I have a defined step
-`;
+`
 
 const stepsFile = `const { I } = inject();
 // Add in your custom step files
 
 Given('I have a defined step', () => {
   // TODO: replace with your own step
 });
-`;
+`
 
 export default async function (genPath) {
-  const testsPath = getTestRoot(genPath);
-  const configFile = findConfigFile(testsPath);
+  const testsPath = getTestRoot(genPath)
+  const configFile = findConfigFile(testsPath)
 
   if (!configFile) {
-    output.error(
-      "Can't initialize Gherkin. This command must be run in an already initialized project.",
-    );
-    process.exit(1);
+    output.error("Can't initialize Gherkin. This command must be run in an already initialized project.")
+    process.exit(1)
   }
 
-  const config = await getConfig(testsPath);
-  const extension = path.extname(configFile).substring(1);
+  const config = await getConfig(testsPath)
+  const extension = path.extname(configFile).substring(1)
 
-  output.print('Initializing Gherkin (Cucumber BDD) for CodeceptJS');
-  output.print('--------------------------');
+  output.print('Initializing Gherkin (Cucumber BDD) for CodeceptJS')
+  output.print('--------------------------')
 
   if (config.gherkin && config.gherkin.steps) {
-    output.error('Gherkin is already initialized in this project. See `gherkin` section in the config');
-    process.exit(1);
+    output.error('Gherkin is already initialized in this project. See `gherkin` section in the config')
+    process.exit(1)
   }
 
-  let dir;
-  dir = path.join(testsPath, 'features');
+  let dir
+  dir = path.join(testsPath, 'features')
   if (!fileExists(dir)) {
-    mkdirp.sync(dir);
-    output.success(`Created ${dir}, place your *.feature files in it`);
+    mkdirp.sync(dir)
+    // Use relative path for output
+    const relativeDir = path.relative(process.cwd(), dir)
+    output.success(`Created ${relativeDir}, place your *.feature files in it`)
   }
 
   if (safeFileWrite(path.join(dir, 'basic.feature'), featureFile)) {
-    output.success('Created sample feature file: features/basic.feature');
+    output.success('Created sample feature file: features/basic.feature')
   }
 
-  dir = path.join(testsPath, 'step_definitions');
+  dir = path.join(testsPath, 'step_definitions')
   if (!fileExists(dir)) {
-    mkdirp.sync(dir);
-    output.success(`Created ${dir}, place step definitions into it`);
+    mkdirp.sync(dir)
+    // Use relative path for output
+    const relativeDir = path.relative(process.cwd(), dir)
+    output.success(`Created ${relativeDir}, place step definitions into it`)
   }
 
   if (safeFileWrite(path.join(dir, `steps.${extension}`), stepsFile)) {
-    output.success(
-      `Created sample steps file: step_definitions/steps.${extension}`,
-    );
+    output.success(`Created sample steps file: step_definitions/steps.${extension}`)
   }
 
   config.gherkin = {
     features: './features/*.feature',
     steps: [`./step_definitions/steps.${extension}`],
-  };
+  }
 
-  updateConfig(testsPath, config, extension);
+  updateConfig(testsPath, config, extension)
 
-  output.success('Gherkin setup is done.');
-  output.success('Start writing feature files and implement corresponding steps.');
-};
+  output.success('Gherkin setup is done.')
+  output.success('Start writing feature files and implement corresponding steps.')
+}

lib/config.js

@@ -138,29 +138,66 @@ async function loadConfigFile(configFile) {
   const require = createRequire(import.meta.url)
   const extensionName = path.extname(configFile)
 
-  if (extensionName === '.ts') {
-    try {
-      require('ts-node/register')
-    } catch (err) {
-      console.log('ts-node package is required to parse codecept.conf.ts config correctly')
-    }
-  }
-
   // .conf.js config file
   if (extensionName === '.js' || extensionName === '.ts' || extensionName === '.cjs') {
     let configModule
     try {
-      // Try ESM import first
-      configModule = await import(configFile)
+      // For .ts files, try to compile and load as JavaScript
+      if (extensionName === '.ts') {
+        try {
+          // Try to load ts-node and compile the file
+          const { transpile } = require('typescript')
+          const tsContent = fs.readFileSync(configFile, 'utf8')
+
+          // Transpile TypeScript to JavaScript with ES module output
+          const jsContent = transpile(tsContent, {
+            module: 99, // ModuleKind.ESNext
+            target: 99, // ScriptTarget.ESNext
+            esModuleInterop: true,
+            allowSyntheticDefaultImports: true,
+          })
+
+          // Create a temporary JS file with .mjs extension to force ES module treatment
+          const tempJsFile = configFile.replace('.ts', '.temp.mjs')
+          fs.writeFileSync(tempJsFile, jsContent)
+
+          try {
+            configModule = await import(tempJsFile)
+            // Clean up temp file
+            fs.unlinkSync(tempJsFile)
+          } catch (err) {
+            // Clean up temp file even on error
+            if (fs.existsSync(tempJsFile)) {
+              fs.unlinkSync(tempJsFile)
+            }
+            throw err
+          }
+        } catch (tsError) {
+          // If TypeScript compilation fails, fallback to ts-node
+          try {
+            require('ts-node/register')
+            configModule = require(configFile)
+          } catch (tsNodeError) {
+            throw new Error(`Failed to load TypeScript config: ${tsError.message}`)
+          }
+        }
+      } else {
+        // Try ESM import first for JS files
+        configModule = await import(configFile)
+      }
     } catch (importError) {
       try {
-        // Fall back to CommonJS require
-        configModule = require(configFile)
+        // Fall back to CommonJS require for .js/.cjs files
+        if (extensionName !== '.ts') {
+          configModule = require(configFile)
+        } else {
+          throw importError
+        }
       } catch (requireError) {
         throw new Error(`Failed to load config file ${configFile}: ${importError.message}`)
       }
     }
-    
+
     const rawConfig = configModule.config || configModule.default?.config || configModule
 
     // Process helpers to extract imported classes

lib/mocha/asyncWrapper.js

@@ -5,6 +5,7 @@ import assertThrown from '../assert/throws.js'
 import { ucfirst, isAsyncFunction } from '../utils.js'
 import { getInjectedArguments } from './inject.js'
 import { fireHook } from './hooks.js'
+import Config from '../config.js'
 
 const injectHook = function (inject, suite) {
   // Run the hook body inside recorder queue to ensure async parts complete before returning
@@ -59,6 +60,7 @@ function test(test) {
     const doneFn = makeDoneCallableOnce(done)
     let testPassed = false
     let testFailed = false
+    let testAfterEmitted = false
 
     // Ensure recorder is running so any steps added inside test function are executed
     recorder.startUnlessRunning()
@@ -82,7 +84,10 @@ function test(test) {
           // Add test.after emission after event listeners have added their operations
           process.nextTick(() => {
             recorder.add('fire test.after', () => {
-              event.emit(event.test.after, test)
+              if (!testAfterEmitted) {
+                testAfterEmitted = true
+                event.emit(event.test.after, test)
+              }
             })
           })
           recorder.add(doneFn)
@@ -95,11 +100,12 @@ function test(test) {
       test.err = err
       event.emit(event.test.failed, test, err)
       event.emit(event.test.finished, test)
-      // Add test.after emission after event listeners have added their operations
-      setImmediate(() => {
-        recorder.add('fire test.after for failed test', () => {
+      // Add test.after emission immediately after helper events
+      recorder.add('fire test.after for failed test', () => {
+        if (!testAfterEmitted) {
+          testAfterEmitted = true
           event.emit(event.test.after, test)
-        })
+        }
       })
       recorder.add(() => doneFn(err))
     })
@@ -127,7 +133,10 @@ function test(test) {
         // Add test.after to the queue after event listeners have added their operations
         process.nextTick(() => {
           recorder.add('fire test.after', () => {
-            event.emit(event.test.after, test)
+            if (!testAfterEmitted) {
+              testAfterEmitted = true
+              event.emit(event.test.after, test)
+            }
           })
         })
       })
@@ -152,7 +161,10 @@ function test(test) {
           // Add test.after to the queue after event listeners have added their operations
           process.nextTick(() => {
             recorder.add('fire test.after', () => {
-              event.emit(event.test.after, test)
+              if (!testAfterEmitted) {
+                testAfterEmitted = true
+                event.emit(event.test.after, test)
+              }
             })
           })
         })
@@ -206,7 +218,18 @@ function injected(fn, suite, hookName) {
     }
 
     const opts = suite.opts || {}
-    const retries = opts[`retry${ucfirst(hookName)}`] || 0
+    let retries = opts[`retry${ucfirst(hookName)}`] || 0
+
+    // If no retries set and this is a hook, check the global retry config directly
+    if (retries === 0 && (hookName === 'beforeSuite' || hookName === 'afterSuite' || hookName === 'before' || hookName === 'after')) {
+      const retryConfig = Config.get('retry')
+      if (retryConfig && typeof retryConfig === 'object' && !Array.isArray(retryConfig)) {
+        const hookRetryKey = ucfirst(hookName)
+        if (retryConfig[hookRetryKey]) {
+          retries = retryConfig[hookRetryKey]
+        }
+      }
+    }
 
     const currentTest = hookName === 'before' || hookName === 'after' ? suite?.ctx?.currentTest : null
 
@@ -275,19 +298,10 @@ function teardown(suite) {
 }
 
 function suiteSetup(suite) {
-  // Execute immediately to ensure config is applied before tests run
-  ;(async () => {
+  return () => {
     recorder.startUnlessRunning()
-    const suiteModule = await import('./suite.js')
-    const { enhanceMochaSuite } = suiteModule.default || suiteModule
-    const enhancedSuite = enhanceMochaSuite(suite)
-    event.emit(event.suite.before, enhancedSuite)
-  })().catch(err => {
-    console.error('Suite setup error:', err)
-  })
-
-  // Return empty function for Mocha hook compatibility
-  return () => {}
+    event.emit(event.suite.before, suite)
+  }
 }
 
 function suiteTeardown(suite) {

lib/mocha/gherkin.js

@@ -43,7 +43,7 @@ const gherkinParser = (text, file) => {
 
   suite.beforeEach('codeceptjs.before', () => setup(suite))
   suite.afterEach('codeceptjs.after', () => teardown(suite))
-  suite.beforeAll('codeceptjs.beforeSuite', () => suiteSetup(suite))
+  suite.beforeAll('codeceptjs.beforeSuite', () => suiteSetup(suite)())
   suite.afterAll('codeceptjs.afterSuite', () => suiteTeardown(suite))
 
   const runSteps = async steps => {
@@ -201,7 +201,7 @@ function getTranslation(language) {
     // Translations not loaded yet, return null (will use default)
     return null
   }
-  
+
   const translationKeys = Object.keys(translations)
   for (const availableTranslation of translationKeys) {
     if (!language) {

lib/mocha/ui.js

@@ -104,7 +104,7 @@ export default function (suite) {
       suite.beforeEach('codeceptjs.before', () => setup(suite))
       afterEachHooks.push(['finalize codeceptjs', () => teardown(suite)])
 
-      suite.beforeAll('codeceptjs.beforeSuite', () => suiteSetup(suite))
+      suite.beforeAll('codeceptjs.beforeSuite', () => suiteSetup(suite)())
       afterAllHooks.push(['codeceptjs.afterSuite', () => suiteTeardown(suite)])
 
       return new FeatureConfig(suite)

test/data/sandbox/configs/gherkin/config_ts/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "es2020",
+    "module": "esnext",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "skipLibCheck": true,
+    "declaration": false
+  },
+  "ts-node": {
+    "esm": true
+  }
+}

test/runner/gherkin_test.js

@@ -1,12 +1,12 @@
-import chai from 'chai';
-chai.should();
-import assert from 'assert';
-import path from 'path';
-import fs from 'fs';
-import { exec } from 'child_process';
-import { fileURLToPath } from 'url';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+import chai from 'chai'
+chai.should()
+import assert from 'assert'
+import path from 'path'
+import fs from 'fs'
+import { exec } from 'child_process'
+import { fileURLToPath } from 'url'
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
 
 const runner = path.join(__dirname, '/../../bin/codecept.js')
 const codecept_dir = path.join(__dirname, '/../data/sandbox/configs/gherkin/')
@@ -58,13 +58,17 @@ describe('gherkin bdd commands', () => {
       it(`prepare CodeceptJS to run feature files (codecept.conf.${extension})`, done => {
         exec(`${runner} gherkin:init ${codecept_dir_test}`, (err, stdout) => {
           let dir = path.join(codecept_dir_test, 'features')
+          // Convert to relative path for output comparison
+          let relativeDir = path.relative(process.cwd(), dir)
 
           stdout.should.include('Initializing Gherkin (Cucumber BDD) for CodeceptJS')
-          stdout.should.include(`Created ${dir}, place your *.feature files in it`)
+          stdout.should.include(`Created ${relativeDir}, place your *.feature files in it`)
           stdout.should.include('Created sample feature file: features/basic.feature')
 
           dir = path.join(codecept_dir_test, 'step_definitions')
-          stdout.should.include(`Created ${dir}, place step definitions into it`)
+          // Convert to relative path for output comparison
+          relativeDir = path.relative(process.cwd(), dir)
+          stdout.should.include(`Created ${relativeDir}, place step definitions into it`)
           stdout.should.include(`Created sample steps file: step_definitions/steps.${extension}`)
           assert(!err)