@scalvert/bin-tester/dist/index.cjs

A test harness to invoke a CLI in a tmp directory

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var index_exports = {};
__export(index_exports, {
  BinTesterProject: () => BinTesterProject,
  createBinTester: () => createBinTester
});
module.exports = __toCommonJS(index_exports);

// src/create-bin-tester.ts
var import_execa2 = require("execa");

// src/project.ts
var import_execa = require("execa");
var import_fixturify_project = require("fixturify-project");
var ROOT = process.cwd();
var BinTesterProject = class extends import_fixturify_project.Project {
  /**
   * Constructs an instance of a BinTesterProject.
   * @param {string} name - The name of the project. Used within the package.json as the name property.
   * @param {string} version - The version of the project. Used within the package.json as the version property.
   * @param {Function} cb - An optional callback for additional setup steps after the project is constructed.
   */
  constructor(name = "fake-project", version, cb) {
    super(name, version, cb);
    this._dirChanged = false;
    this.pkg = Object.assign({}, this.pkg, {
      license: "MIT",
      description: "Fake project",
      repository: "http://fakerepo.com"
    });
  }
  /**
   * Runs `git init` inside a project.
   * @returns {*} {ResultPromise}
   */
  gitInit() {
    return (0, import_execa.execa)("git", ["init", "-q", this.baseDir]);
  }
  /**
   * Writes the project files to disk.
   */
  async write() {
    return super.write();
  }
  /**
   * Changes a directory from inside the project.
   */
  async chdir() {
    this._dirChanged = true;
    await this.write();
    process.chdir(this.baseDir);
  }
  /**
   * Correctly disposes of the project, observing when the directory has been changed.
   * @returns {void}
   */
  dispose() {
    if (this._dirChanged) {
      process.chdir(ROOT);
    }
    return super.dispose();
  }
};

// src/create-bin-tester.ts
var DEFAULT_BIN_TESTER_OPTIONS = {
  staticArgs: []
};
function parseArgs(args) {
  if (args.length > 0 && typeof args[args.length - 1] === "object") {
    const argsCopy = [...args];
    const execaOptions = argsCopy.pop();
    return {
      args: argsCopy,
      execaOptions
    };
  } else {
    return {
      args: [...args],
      execaOptions: {}
    };
  }
}
function createBinTester(options) {
  let project;
  const mergedOptions = {
    ...DEFAULT_BIN_TESTER_OPTIONS,
    ...options
  };
  function runBin(...args) {
    const mergedRunOptions = parseArgs(args);
    const binPath = typeof mergedOptions.binPath === "function" ? mergedOptions.binPath(project) : mergedOptions.binPath;
    const optionsEnv = mergedRunOptions.execaOptions.env;
    const debugEnv = optionsEnv?.BIN_TESTER_DEBUG ?? process.env.BIN_TESTER_DEBUG;
    const nodeOptions = [];
    if (debugEnv && debugEnv !== "0" && debugEnv.toLowerCase() !== "false") {
      if (debugEnv.toLowerCase() === "break") {
        nodeOptions.push("--inspect-brk=0");
      } else {
        nodeOptions.push("--inspect=0");
      }
      console.log(`[bin-tester] Debugging enabled. Fixture: ${project.baseDir}`);
    }
    const resolvedCwd = mergedRunOptions.execaOptions.cwd ?? project.baseDir;
    return (0, import_execa2.execaNode)(binPath, [...mergedOptions.staticArgs, ...mergedRunOptions.args], {
      reject: false,
      cwd: resolvedCwd,
      nodeOptions,
      ...mergedRunOptions.execaOptions
    });
  }
  function runBinDebug(...args) {
    const parsedArgs = parseArgs(args);
    const debugEnv = process.env.BIN_TESTER_DEBUG || "attach";
    parsedArgs.execaOptions = {
      ...parsedArgs.execaOptions,
      env: {
        ...parsedArgs.execaOptions.env,
        BIN_TESTER_DEBUG: debugEnv
      }
    };
    const reconstructedArgs = [...parsedArgs.args, parsedArgs.execaOptions];
    return runBin(...reconstructedArgs);
  }
  async function setupProject() {
    project = "createProject" in mergedOptions ? await mergedOptions.createProject() : new BinTesterProject();
    await project.write();
    return project;
  }
  async function setupTmpDir() {
    if (typeof project === "undefined") {
      await setupProject();
    }
    return project.baseDir;
  }
  function teardownProject() {
    const debugEnv = process.env.BIN_TESTER_DEBUG;
    if (debugEnv && debugEnv !== "0" && debugEnv.toLowerCase() !== "false") {
      console.log(`[bin-tester] Fixture preserved: ${project.baseDir}`);
      return;
    }
    project.dispose();
  }
  return {
    runBin,
    runBinDebug,
    setupProject,
    teardownProject,
    setupTmpDir
  };
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  BinTesterProject,
  createBinTester
});