@plugjs/expect5/dist/execution/executor.cjs

Unit Testing for the PlugJS Build System ========================================

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// execution/executor.ts
var executor_exports = {};
__export(executor_exports, {
  runSuite: () => runSuite
});
module.exports = __toCommonJS(executor_exports);
var import_node_assert = __toESM(require("node:assert"), 1);
var import_node_events = require("node:events");
var import_executable = require("./executable.cjs");
function runSuite(suite) {
  const _emitter = new import_node_events.EventEmitter();
  let resolve;
  let reject;
  const promise = new Promise((_resolve, _reject) => {
    resolve = _resolve;
    reject = _reject;
  });
  const result = {
    time: 0,
    passed: 0,
    failed: 0,
    skipped: 0,
    failures: [],
    records: []
  };
  const execution = {
    result: promise,
    on: (event, listener) => {
      _emitter.on(event, listener);
      return execution;
    },
    off: (event, listener) => {
      _emitter.off(event, listener);
      return execution;
    },
    once: (event, listener) => {
      _emitter.once(event, listener);
      return execution;
    }
  };
  const start = (executable) => {
    const type = executable instanceof import_executable.Suite ? "suite" : executable instanceof import_executable.Spec ? "spec" : executable instanceof import_executable.Hook ? "hook" : (
      /* coverage ignore next */
      import_node_assert.default.fail(`Unable to start ${Object.getPrototypeOf(executable)?.constructor?.name}`)
    );
    const now = Date.now();
    _emitter.emit(`${type}:start`, executable);
    let done = false;
    let failure;
    return {
      done(skipped = false) {
        const time = Date.now() - now;
        done = true;
        if (type === "suite") {
          _emitter.emit(`${type}:done`, executable, time);
          return;
        }
        if (failure) {
          _emitter.emit(`${type}:fail`, executable, time, failure);
          if (type === "spec") result.failed++;
        } else if (skipped) {
          _emitter.emit(`${type}:skip`, executable, time);
          if (type === "spec") result.skipped++;
        } else {
          const slow = time >= executable.timeout * 0.75;
          _emitter.emit(`${type}:pass`, executable, time, slow);
          if (type === "spec") result.passed++;
        }
      },
      notify(error) {
        const number = result.failures.length + 1;
        const fail = { error, number, source: executable, type };
        result.failures.push(fail);
        if (failure || done) {
          _emitter.emit(`${type}:error`, executable, fail);
        } else {
          failure = fail;
        }
      }
    };
  };
  const suiteRecords = [{ type: "suite", name: "", records: [] }];
  execution.on("suite:start", (current) => {
    const record = { type: "suite", name: current.name, records: [] };
    suiteRecords[suiteRecords.length - 1].records.push(record);
    suiteRecords.push(record);
  });
  execution.on("suite:done", () => {
    if (suiteRecords.length > 1) suiteRecords.pop();
  });
  execution.on("spec:skip", (spec, ms) => {
    const record = { type: "spec", name: spec.name, result: "skipped", ms };
    suiteRecords[suiteRecords.length - 1].records.push(record);
  });
  execution.on("spec:pass", (spec, ms) => {
    const record = { type: "spec", name: spec.name, result: "passed", ms };
    suiteRecords[suiteRecords.length - 1].records.push(record);
    if (ms >= spec.timeout * 0.75) record.slow = true;
  });
  execution.on("spec:fail", (spec, ms, { number }) => {
    const record = { type: "spec", name: spec.name, result: "failed", failure: number, ms };
    suiteRecords[suiteRecords.length - 1].records.push(record);
  });
  execution.on("hook:fail", (hook, _, { number }) => {
    const record = { type: "hook", name: hook.name, result: "failed", failure: number };
    suiteRecords[suiteRecords.length - 1].records.push(record);
  });
  setImmediate(() => Promise.resolve().then(async () => {
    const now = Date.now();
    await suite.setup();
    await suite.execute({ start });
    result.time = Date.now() - now;
    result.records.push(...suiteRecords[0].records);
    resolve(result);
  }).catch((error) => reject(error)));
  return execution;
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  runSuite
});
//# sourceMappingURL=executor.cjs.map