DRY

Author: kobenguyent

bin/codecept.js

@@ -5,8 +5,7 @@ import Codecept from '../lib/codecept.js'
 import output from '../lib/output.js'
 const { print, error } = output
 import { printError } from '../lib/command/utils.js'
-import { isWindows } from '../lib/utils.js'
-import { pathToFileURL } from 'url'
+import { importModule } from '../lib/utils.js'
 
 const commandFlags = {
   ai: {
@@ -47,7 +46,7 @@ const errorHandler =
   }
 
 const dynamicImport = async modulePath => {
-  const module = isWindows() ? await import(pathToFileURL(modulePath).href) : await import(modulePath)
+  const module = await importModule(modulePath)
   return module.default || module
 }
 

lib/ai.js

@@ -4,9 +4,9 @@ import output from './output.js'
 import event from './event.js'
 import { removeNonInteractiveElements, minifyHtml, splitByChunks } from './html.js'
 import { generateText } from 'ai'
-import { fileURLToPath, pathToFileURL } from 'url'
+import { fileURLToPath } from 'url'
 import path from 'path'
-import { fileExists, isWindows } from './utils.js'
+import { fileExists, importModule } from './utils.js'
 import store from './store.js'
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
@@ -34,7 +34,7 @@ async function loadPrompts() {
     }
 
     try {
-      const module = isWindows() ?  await import(pathToFileURL(promptPath).href) : await import(promptPath)
+      const module = await importModule(promptPath)
       prompts[name] = module.default || module
       debug(`Loaded prompt ${name} from ${promptPath}`)
     } catch (err) {

lib/codecept.js

@@ -17,7 +17,7 @@ import event from './event.js'
 import runHook from './hooks.js'
 import ActorFactory from './actor.js'
 import output from './output.js'
-import { emptyFolder, isWindows } from './utils.js'
+import { emptyFolder, importModule } from './utils.js'
 import { initCodeceptGlobals } from './globals.js'
 import { validateTypeScriptSetup, getTSNodeESMWarning } from './utils/loaderCheck.js'
 import recorder from './recorder.js'
@@ -32,6 +32,7 @@ import globalTimeoutListener from './listener/globalTimeout.js'
 import globalRetryListener from './listener/globalRetry.js'
 import exitListener from './listener/exit.js'
 import emptyRunListener from './listener/emptyRun.js'
+import path from 'path'
 
 /**
  * CodeceptJS runner
@@ -86,7 +87,7 @@ class Codecept {
           }
         }
         // Use dynamic import for ESM
-        isWindows() ? await import(pathToFileURL(modulePath).href) : await import(modulePath)
+        await importModule(modulePath)
       }
     }
   }
@@ -137,7 +138,7 @@ class Codecept {
       ]
 
       for (const modulePath of listenerModules) {
-        const module = isWindows() ? await import(pathToFileURL(modulePath).href) : await import(modulePath)
+        const module = await importModule(modulePath)
         runHook(module.default || module)
       }
     }

lib/config.js

@@ -1,9 +1,8 @@
 import fs from 'fs'
 import path from 'path'
 import { createRequire } from 'module'
-import { fileExists, isFile, deepMerge, deepClone, isWindows } from './utils.js'
+import { fileExists, isFile, deepMerge, deepClone, importModule } from './utils.js'
 import { transpileTypeScript, cleanupTempFiles, fixErrorStack } from './utils/typescript.js'
-import { pathToFileURL } from 'url'
 
 const defaultConfig = {
   output: './_output',
@@ -243,7 +242,7 @@ async function loadConfigFile(configFile) {
           allTempFiles = result.allTempFiles
           fileMapping = result.fileMapping
 
-          configModule = isWindows() ? await import(pathToFileURL(tempFile).href) : await import(tempFile)
+          configModule = await importModule(tempFile)
           cleanupTempFiles(allTempFiles)
         } catch (err) {
           transpileError = err
@@ -259,12 +258,7 @@ async function loadConfigFile(configFile) {
         }
       } else {
         // Try ESM import first for JS files
-        const resolvedImportPath =
-          isWindows() && typeof configFile === 'string' && path.isAbsolute(configFile)
-            ? pathToFileURL(configFile).href
-            : configFile
-
-        configModule = await import(resolvedImportPath)
+        configModule = await importModule(configFile)
       }
     } catch (importError) {
       try {

lib/container.js

@@ -12,7 +12,7 @@ import {
   isAsyncFunction,
   installedLocally,
   deepMerge,
-  isWindows,
+  importModule,
 } from './utils.js'
 import { transpileTypeScript, cleanupTempFiles, fixErrorStack } from './utils/typescript.js'
 import Translation from './translation.js'
@@ -25,7 +25,6 @@ import Result from './result.js'
 import ai from './ai.js'
 import actorFactory from './actor.js'
 import Config from './config.js'
-import { pathToFileURL } from 'url'
 
 let asyncHelperPromise
 
@@ -444,12 +443,7 @@ async function requireHelperFromModule(helperName, config, HelperClass) {
       // For built-in helpers, use direct relative import with .js extension
       const helperPath = `${moduleName}.js`
 
-      const resolvedImportPath =
-        isWindows() && typeof helperPath === 'string' && path.isAbsolute(helperPath)
-          ? pathToFileURL(helperPath).href
-          : helperPath
-
-      const mod = await import(resolvedImportPath)
+      const mod = await importModule(helperPath)
       HelperClass = mod.default || mod
     } catch (err) {
       throw err
@@ -487,12 +481,7 @@ async function requireHelperFromModule(helperName, config, HelperClass) {
     // check if the new syntax export default HelperName is used and loads the Helper, otherwise loads the module that used old syntax export = HelperName.
     try {
       // Try dynamic import for both CommonJS and ESM modules
-      const resolvedImportPath =
-        isWindows() && typeof importPath === 'string' && path.isAbsolute(importPath)
-          ? pathToFileURL(importPath).href
-          : importPath
-
-      const mod = await import(resolvedImportPath)
+      const mod = await importModule(importPath)
 
       if (!mod && !mod.default) {
         throw new Error(`Helper module '${moduleName}' was not found. Make sure you have installed the package correctly.`)
@@ -704,7 +693,7 @@ async function loadPluginAsync(modulePath, config) {
   let pluginMod
   try {
     // Try dynamic import first (works for both ESM and CJS)
-    pluginMod = isWindows() ? await import(pathToFileURL(modulePath).href) : await import(modulePath)
+    pluginMod = await importModule(modulePath)
   } catch (err) {
     throw new Error(`Could not load plugin from '${modulePath}': ${err.message}`)
   }
@@ -911,12 +900,7 @@ async function loadSupportObject(modulePath, supportObjectName) {
 
     let obj
     try {
-      const resolvedImportPath =
-        isWindows() && typeof importPath === 'string' && path.isAbsolute(importPath)
-          ? pathToFileURL(importPath).href
-          : importPath
-
-      obj = await import(resolvedImportPath)
+      obj = await importModule(importPath)
     } catch (importError) {
       if (fileMapping) {
         fixErrorStack(importError, fileMapping)

lib/helper/ApiDataFactory.js

@@ -2,8 +2,7 @@ import path from 'path'
 import Helper from '@codeceptjs/helper'
 import REST from './REST.js'
 import store from '../store.js'
-import { isWindows } from '../utils.js'
-import { pathToFileURL } from 'url'
+import { importModule } from '../utils.js'
 
 /**
  * Helper for managing remote data using REST API.
@@ -330,7 +329,7 @@ class ApiDataFactory extends Helper {
         modulePath = path.join(store.codeceptDir, modulePath)
       }
       // check if the new syntax `export default new Factory()` is used and loads the builder, otherwise loads the module that used old syntax `module.exports = new Factory()`.
-      const module = isWindows() ? await import(pathToFileURL(modulePath).href) : await import(modulePath)
+      const module = await importModule(modulePath)
       const builder = module.default || module
       return builder.build(data, options)
     } catch (err) {

lib/rerun.js

@@ -5,8 +5,7 @@ import event from './event.js'
 import BaseCodecept from './codecept.js'
 import output from './output.js'
 import { createRequire } from 'module'
-import { isWindows } from './utils.js'
-import { pathToFileURL } from 'url'
+import { importModule } from './utils.js'
 
 const require = createRequire(import.meta.url)
 
@@ -53,7 +52,7 @@ class CodeceptRerunner extends BaseCodecept {
 
             // Force reload the module by using a cache-busting query parameter
             const fileUrl = `${fsPath.resolve(file)}?t=${Date.now()}`
-            isWindows() ? await import(pathToFileURL(fileUrl).href) : await import(fileUrl)
+            await importModule(fileUrl)
           } catch (e) {
             console.error(`Error loading test file ${file}:`, e)
           }

lib/utils.js

@@ -1,6 +1,7 @@
 import fs from 'fs'
 import os from 'os'
 import path from 'path'
+import { pathToFileURL } from 'url'
 import { createRequire } from 'module'
 import chalk from 'chalk'
 import getFunctionArguments from 'fn-args'
@@ -38,6 +39,20 @@ export const isAsyncFunction = function (fn) {
   return fn[Symbol.toStringTag] === 'AsyncFunction'
 }
 
+/**
+ * Dynamically imports a module.
+ * On Windows, absolute paths are converted to file URLs.
+ * @param {string} modulePath - The path to the module.
+ * @param {Object} [options] - Import options.
+ * @returns {Promise<any>} The imported module.
+ */
+export const importModule = async function (modulePath, options) {
+  if (isWindows() && typeof modulePath === 'string' && path.isAbsolute(modulePath)) {
+    return import(pathToFileURL(modulePath).href, options)
+  }
+  return import(modulePath, options)
+}
+
 export const fileExists = function (filePath) {
   return fs.existsSync(filePath)
 }

test/unit/utils_test.js

@@ -344,4 +344,36 @@ describe('utils', () => {
       expect(() => utils.requireWithFallback('unexisting-package', 'unexisting-package2')).to.throw(Error, 'Cannot find modules unexisting-package,unexisting-package2')
     })
   })
+
+  describe('#importModule', () => {
+    let osStub
+
+    afterEach(() => {
+      if (osStub) osStub.restore()
+    })
+
+    it('should import a module', async () => {
+      const module = await utils.importModule(path.join(__dirname, '../../lib/output.js'))
+      expect(module.default).to.be.ok
+    })
+
+    it('should import a module on Windows simulation', async () => {
+      // Mock Windows
+      osStub = sinon.stub(os, 'platform').callsFake(() => 'win32')
+
+      // Use an absolute path that exists
+      const absolutePath = path.resolve(__dirname, '../../lib/output.js')
+
+      const module = await utils.importModule(absolutePath)
+      expect(module.default).to.be.ok
+    })
+
+    it('should import a relative module', async () => {
+      // Relative to lib/utils.js where importModule is defined
+      // lib/utils.js is in lib/
+      // we want to import lib/output.js
+      const module = await utils.importModule('./output.js')
+      expect(module.default).to.be.ok
+    })
+  })
 })