fix: codepcept-js code and types

Author: kobenguyent

lib/codecept.js

@@ -1,7 +1,6 @@
 import { existsSync, readFileSync } from 'fs';
 import glob from 'glob';
-import fsPath, { resolve, dirname } from 'path';
-import generated from '@codeceptjs/helper';
+import { resolve, dirname, isAbsolute, join } from 'path';
 import { fileURLToPath } from 'url';
 import { createRequire } from 'node:module';
 import container from './container.js';
@@ -12,237 +11,218 @@ import * as output from './output.js';
 import { emptyFolder } from './utils.js';
 import * as index from './index.js';
 
-import * as actor0 from './actor.js';
-
-import pause0 from './pause.js';
-
-import within0 from './within.js';
-
-import session0 from './session.js';
-
+// Helpers and features
+import * as actor from './actor.js';
+import pause from './pause.js';
+import within from './within.js';
+import session from './session.js';
 import data from './data/table.js';
-
 import Locator from './locator.js';
-
 import secret from './secret.js';
-
-// BDD
 import * as stepDefinitions from './interfaces/bdd.js';
 
+// Listeners
 import listener from './listener/steps.js';
-
-import listener0 from './listener/artifacts.js';
-
-import listener01 from './listener/config.js';
-
-import listener012 from './listener/helpers.js';
-
-import listener0123 from './listener/retry.js';
-
-import listener01234 from './listener/timeout.js';
-
-import listener012345 from './listener/exit.js';
+import listenerArtifacts from './listener/artifacts.js';
+import listenerConfig from './listener/config.js';
+import listenerHelpers from './listener/helpers.js';
+import listenerRetry from './listener/retry.js';
+import listenerTimeout from './listener/timeout.js';
+import listenerExit from './listener/exit.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
 
 /**
- * CodeceptJS runner
+ * CodeceptJS runner class.
  */
 export default class Codecept {
   /**
-   * Create CodeceptJS runner.
-   * Config and options should be passed
-   *
-   * @param {*} config
-   * @param {*} opts
+   * Initializes CodeceptJS runner with config and options.
+   * @param {Object} config - Configuration object.
+   * @param {Object} opts - Options.
    */
   constructor(config, opts) {
     this.config = Config.create(config);
     this.opts = opts;
-    this.testFiles = new Array(0);
-    this.requireModules(config.require);
+    this.testFiles = [];
+    this.requireModules(config?.require);
   }
 
   /**
-   * Require modules before codeceptjs running
-   *
-   * @param {string[]} requiringModules
+   * Requires necessary modules before running CodeceptJS.
+   * @param {string[]} requiringModules - List of modules to require.
    */
   requireModules(requiringModules) {
-    if (requiringModules) {
-      requiringModules.forEach((requiredModule) => {
-        const isLocalFile = existsSync(requiredModule) || existsSync(`${requiredModule}.js`);
-        if (isLocalFile) {
-          requiredModule = resolve(requiredModule);
-        }
-        require(requiredModule);
-      });
-    }
+    requiringModules?.forEach((requiredModule) => {
+      const isLocalFile = existsSync(requiredModule) || existsSync(`${requiredModule}.js`);
+      const modulePath = isLocalFile ? resolve(requiredModule) : requiredModule;
+      require(modulePath);
+    });
   }
 
   /**
-   * Initialize CodeceptJS at specific directory.
-   * If async initialization is required, pass callback as second parameter.
-   *
-   * @param {string} dir
+   * Initializes CodeceptJS in a specific directory.
+   * @param {string} dir - Directory path.
    */
   init(dir) {
     this.initGlobals(dir);
-    // initializing listeners
     container.create(this.config, this.opts);
     this.runHooks();
   }
 
   /**
-   * Creates global variables
-   *
-   * @param {string} dir
+   * Initializes global variables.
+   * @param {string} dir - Directory path.
    */
   initGlobals(dir) {
-    // @ts-ignore
     global.codecept_dir = dir;
-    // @ts-ignore
-    global.output_dir = fsPath.resolve(dir, this.config.output);
+    global.output_dir = resolve(dir, this.config.output);
 
     if (this.config.emptyOutputFolder) emptyFolder(global.output_dir);
 
     if (!this.config.noGlobals) {
-      global.Helper = global.codecept_helper = generated;
-      global.actor = global.codecept_actor = actor0;
-      global.pause = pause0;
-      global.within = within0;
-      global.session = session0;
-      global.DataTable = data;
-      global.locate = locator => new Locator(locator);
-      global.inject = container.support;
-      global.share = container.share;
-      global.secret = secret;
-      global.codecept_debug = output.debug;
-      global.codeceptjs = index; // load all objects
-      global.Given = stepDefinitions.Given;
-      global.When = stepDefinitions.When;
-      global.Then = stepDefinitions.Then;
-      global.DefineParameterType = stepDefinitions.defineParameterType;
-
-      // debug mode
-      global.debugMode = false;
+      this.initGlobalHelpers();
     }
   }
 
   /**
-   * Executes hooks.
+   * Initializes global helpers and other CodeceptJS features.
+   */
+  initGlobalHelpers() {
+    global.Helper = global.codecept_helper = index.generated;
+    global.actor = global.codecept_actor = actor;
+    global.pause = pause;
+    global.within = within;
+    global.session = session;
+    global.DataTable = data;
+    global.locate = (locator) => new Locator(locator);
+    global.inject = container.support;
+    global.share = container.share;
+    global.secret = secret;
+    global.codecept_debug = output.debug;
+    global.codeceptjs = index;
+
+    // BDD
+    global.Given = stepDefinitions.Given;
+    global.When = stepDefinitions.When;
+    global.Then = stepDefinitions.Then;
+    global.DefineParameterType = stepDefinitions.defineParameterType;
+    global.debugMode = false;
+  }
+
+  /**
+   * Runs all hooks, including custom and default.
    */
   runHooks() {
-    // default hooks
-    runHook(listener);
-    runHook(listener0);
-    runHook(listener01);
-    runHook(listener012);
-    runHook(listener0123);
-    runHook(listener01234);
-    runHook(listener012345);
-
-    // custom hooks (previous iteration of plugins)
-    this.config.hooks.forEach(hook => runHook(hook));
+    const listeners = [
+      listener,
+      listenerArtifacts,
+      listenerConfig,
+      listenerHelpers,
+      listenerRetry,
+      listenerTimeout,
+      listenerExit,
+    ];
+
+    listeners.forEach(runHook);
+
+    // Run custom hooks
+    this.config.hooks.forEach(runHook);
   }
 
   /**
-   * Executes bootstrap.
-   *
+   * Executes the bootstrap process.
    */
   async bootstrap() {
     return runHook(this.config.bootstrap, 'bootstrap');
   }
 
   /**
-   * Executes teardown.
-
+   * Executes the teardown process.
    */
   async teardown() {
     return runHook(this.config.teardown, 'teardown');
   }
 
   /**
-   * Loads tests by pattern or by config.tests
-   *
-   * @param {string} [pattern]
+   * Loads test files based on the given pattern or config.
+   * @param {string} [pattern] - Optional pattern for loading tests.
    */
   loadTests(pattern) {
-    const options = {
-      cwd: global.codecept_dir,
-    };
-
-    let patterns = [pattern];
-    if (!pattern) {
-      patterns = [];
-
-      // If the user wants to test a specific set of test files as an array or string.
-      if (this.config.tests && !this.opts.features) {
-        if (Array.isArray(this.config.tests)) {
-          patterns.push(...this.config.tests);
-        } else {
-          patterns.push(this.config.tests);
+    const patterns = this.getTestPatterns(pattern);
+    const options = { cwd: global.codecept_dir };
+
+    patterns.forEach((p) => {
+      glob.sync(p, options).forEach((file) => {
+        if (!file.includes('node_modules')) {
+          const fullPath = isAbsolute(file) ? file : join(global.codecept_dir, file);
+          const resolvedFile = resolve(fullPath);
+
+          if (!this.testFiles.includes(resolvedFile)) {
+            this.testFiles.push(resolvedFile);
+          }
         }
-      }
+      });
+    });
+  }
 
-      if (this.config.gherkin.features && !this.opts.tests) {
-        if (Array.isArray(this.config.gherkin.features)) {
-          this.config.gherkin.features.forEach(feature => {
-            patterns.push(feature);
-          });
-        } else {
-          patterns.push(this.config.gherkin.features);
-        }
-      }
+  /**
+   * Gets test patterns based on config and options.
+   * @param {string} [pattern] - Test pattern to match.
+   * @returns {string[]} - Array of test patterns.
+   */
+  getTestPatterns(pattern) {
+    if (pattern) return [pattern];
+
+    const patterns = [];
+    const { tests, gherkin } = this.config;
+
+    if (tests && !this.opts.features) {
+      patterns.push(...(Array.isArray(tests) ? tests : [tests]));
     }
 
-    for (pattern of patterns) {
-      glob.sync(pattern, options).forEach((file) => {
-        if (file.includes('node_modules')) return;
-        if (!fsPath.isAbsolute(file)) {
-          file = fsPath.join(global.codecept_dir, file);
-        }
-        if (!this.testFiles.includes(fsPath.resolve(file))) {
-          this.testFiles.push(fsPath.resolve(file));
-        }
-      });
+    if (gherkin?.features && !this.opts.tests) {
+      patterns.push(...(Array.isArray(gherkin.features) ? gherkin.features : [gherkin.features]));
     }
+
+    return patterns;
   }
 
   /**
-   * Run a specific test or all loaded tests.
-   *
-   * @param {string} [test]
+   * Runs tests either specific to a file or all loaded tests.
+   * @param {string} [test] - Test file to run.
    * @returns {Promise<void>}
    */
   async run(test) {
-    return new Promise((resolve, reject) => {
-      const mocha = container.mocha();
-      mocha.files = this.testFiles;
-      if (test) {
-        if (!fsPath.isAbsolute(test)) {
-          test = fsPath.join(global.codecept_dir, test);
-        }
-        mocha.files = mocha.files.filter(t => fsPath.basename(t, '.js') === test || t === test);
-      }
-      const done = () => {
-        event.emit(event.all.result, this);
-        event.emit(event.all.after, this);
-        resolve();
-      };
+    const mocha = container.mocha();
+    mocha.files = this.testFiles;
 
-      try {
+    if (test) {
+      const testPath = isAbsolute(test) ? test : join(global.codecept_dir, test);
+      mocha.files = mocha.files.filter((t) => resolve(t) === resolve(testPath));
+    }
+
+    return new Promise((resolve, reject) => {
+      try {x
         event.emit(event.all.before, this);
-        mocha.run(() => done());
-      } catch (e) {
-        output.output.error(e.stack);
-        reject(e);
+        mocha.run(() => {
+          event.emit(event.all.result, this);
+          event.emit(event.all.after, this);
+          resolve();
+        });
+      } catch (error) {
+        output.output.error(error.stack);
+        reject(error);
       }
     });
   }
 }
 
+/**
+ * Retrieves the version from package.json.
+ * @returns {string} - The version of the package.
+ */
 export function version() {
-  return JSON.parse(readFileSync(`${__dirname}/../package.json`, 'utf8')).version;
+  return JSON.parse(readFileSync(resolve(__dirname, '../package.json'), 'utf8')).version;
 }