@schwabyio/gta 0.12.0 → 0.14.0

package/dist/chunks/chunk-Q3VRXFS5.js

@@ -0,0 +1,577 @@
+#!/usr/bin/env node
+import { createRequire as __gtaCreateRequire } from 'node:module';
+const require = __gtaCreateRequire(import.meta.url);
+import {
+  COLLECTIONS_DIR,
+  DOC_EXTENSION,
+  SETTINGS_FILE,
+  TagSchema,
+  YamlMapError,
+  allSkipped,
+  discoverProject,
+  environmentNames,
+  external_exports,
+  flagOverrides,
+  iterationName,
+  loadProjectCollections,
+  loadProjectTls,
+  projectEnvironments,
+  readProject,
+  readYamlMap,
+  relativePosix,
+  resolveFlags,
+  resultName,
+  stepsForTags
+} from "./chunk-ZDHGCHIV.js";
+
+// src/args.ts
+var UsageError = class extends Error {
+  name = "UsageError";
+};
+function parseArgs(argv) {
+  const parsed = {
+    command: null,
+    overrides: {},
+    help: false,
+    version: false,
+    json: false,
+    flags: []
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const word = argv[i];
+    if (word === "-h" || word === "--help") {
+      parsed.help = true;
+    } else if (word === "-v" || word === "--version") {
+      parsed.version = true;
+    } else if (word === "--json") {
+      parsed.json = true;
+    } else if (word === "--flag" || word.startsWith("--flag=")) {
+      const value = word === "--flag" ? argv[++i] : word.slice("--flag=".length);
+      if (value === void 0 || value.startsWith("--")) {
+        throw new UsageError("--flag needs name=value, such as --flag newCheckout=true");
+      }
+      parsed.flags.push(value);
+    } else if (word.startsWith("--")) {
+      const body = word.slice(2);
+      const equals = body.indexOf("=");
+      if (equals > 0) {
+        parsed.overrides[body.slice(0, equals)] = body.slice(equals + 1);
+      } else {
+        const next = argv[i + 1];
+        if (next !== void 0 && !next.startsWith("--")) {
+          parsed.overrides[body] = next;
+          i++;
+        } else {
+          parsed.overrides[body] = true;
+        }
+      }
+    } else if (word.startsWith("-") && word.length > 1) {
+      throw new UsageError(`Unknown option ${word}. Settings are given as --settingsKey value.`);
+    } else if (parsed.command === null) {
+      parsed.command = word;
+    } else {
+      throw new UsageError(
+        `Unexpected "${word}". To run several collections, separate them with commas: gta ${parsed.command},${word}`
+      );
+    }
+  }
+  return parsed;
+}
+
+// src/select.ts
+var idOf = (collection) => collection.name;
+var placeOf = (collection) => collection.relativePath.slice(0, -DOC_EXTENSION.length);
+var normalize = (selector) => {
+  const cleaned = selector.normalize("NFC").trim().replace(/\\/g, "/").replace(/^(\.\/)+/, "").replace(/^collections\//, "");
+  return {
+    name: cleaned.replace(/\/+$/, "").replace(/\.yml$/, ""),
+    directoryOnly: cleaned.endsWith("/")
+  };
+};
+function findCollection(collections, selector) {
+  const { name, directoryOnly } = normalize(selector);
+  if (directoryOnly) return void 0;
+  return collections.find((c) => idOf(c) === name) ?? collections.find((c) => placeOf(c).normalize("NFC") === name);
+}
+function selectCollections(collections, request, options) {
+  const excluded = /* @__PURE__ */ new Set();
+  const inGroup = (group) => group.filter((c) => {
+    if (c.doc.exclude === true) excluded.add(c);
+    return c.doc.exclude !== true;
+  });
+  let chosen;
+  if (request.kind === "list") {
+    const unknown = [];
+    chosen = [];
+    for (const selector of request.selectors) {
+      const { name } = normalize(selector);
+      const exact = findCollection(collections, selector);
+      const inDirectory = collections.filter((c) => c.directory?.normalize("NFC") === name);
+      const found = exact ? [exact] : inDirectory.length > 0 ? inGroup(inDirectory) : null;
+      if (found) chosen.push(...found.filter((c) => !chosen.includes(c)));
+      else unknown.push(selector);
+    }
+    if (unknown.length > 0) {
+      throw new UsageError(
+        `No collection or folder is called ${unknown.map((u) => `"${u}"`).join(", ")}. List them with: gta get`
+      );
+    }
+  } else {
+    chosen = inGroup(collections);
+  }
+  const targets = [];
+  let untagged = 0;
+  for (const collection of chosen) {
+    const id = idOf(collection);
+    if (collection.problems.length > 0) {
+      const broken = collection.problems.map((p) => p.message).join("; ");
+      targets.push({ id, collection, steps: null, broken });
+      continue;
+    }
+    const picked = stepsForTags(collection.doc, options.tags, options.notTags ?? []);
+    if (picked.length === 0 && (options.tags.length > 0 || (options.notTags ?? []).length > 0)) {
+      untagged++;
+      continue;
+    }
+    const all = picked.length === collection.doc.steps.length;
+    targets.push({ id, collection, steps: all ? null : picked, broken: null });
+  }
+  return {
+    targets,
+    // Named on its own, an excluded collection ran: it was not left out.
+    excluded: [...excluded].filter((c) => !chosen.includes(c)).map(idOf),
+    untagged
+  };
+}
+var stepCountOf = (target) => target.steps?.length ?? target.collection.doc.steps.length;
+
+// src/report.ts
+function paint(enabled) {
+  const wrap = (open, close) => (text) => enabled ? `\x1B[${open}m${text}\x1B[${close}m` : text;
+  return {
+    red: wrap(31, 39),
+    green: wrap(32, 39),
+    cyan: wrap(36, 39),
+    yellow: wrap(33, 39),
+    dim: wrap(2, 22),
+    bold: wrap(1, 22)
+  };
+}
+function colorWanted(stream, env) {
+  if (env.FORCE_COLOR !== void 0 && env.FORCE_COLOR !== "0") return true;
+  if (env.NO_COLOR !== void 0 && env.NO_COLOR !== "") return false;
+  return stream.isTTY === true;
+}
+var tally = (target, outcome, durationMs) => tallyOf(target.id, stepCountOf(target), outcome, durationMs);
+function tallyOf(id, stepCount, outcome, durationMs) {
+  if (!outcome.ok) {
+    const total = stepCount;
+    return {
+      id,
+      passed: false,
+      durationMs,
+      steps: { total, passed: 0, failed: 0, errored: 0, skipped: total },
+      assertions: { total: 0, passed: 0, failed: 0 },
+      skipped: false,
+      error: outcome.message,
+      problems: []
+    };
+  }
+  const { summary: summary2 } = outcome;
+  const assertions = summary2.results.flatMap((r) => r.assertions);
+  const failed = assertions.filter((a) => a.status === "fail").length;
+  return {
+    id,
+    passed: summary2.failed === 0 && summary2.errored === 0,
+    durationMs,
+    steps: {
+      total: summary2.total,
+      passed: summary2.passed,
+      failed: summary2.failed,
+      errored: summary2.errored,
+      skipped: summary2.skipped
+    },
+    assertions: { total: assertions.length, passed: assertions.length - failed, failed },
+    skipped: allSkipped(summary2),
+    error: null,
+    // Named for the row they ran with, when a data file drove the collection.
+    problems: summary2.results.flatMap(
+      (r, i) => r.status === "fail" || r.status === "error" ? [{ ...r, item: { ...r.item, name: iterationName(resultName(r), outcome.steps[i]) } }] : []
+    )
+  };
+}
+var seconds = (ms) => `${(ms / 1e3).toFixed(3)}s`;
+var rule = (p, width = 100) => p.dim("\u2500".repeat(width));
+var field = (label, value, width = 14) => `${`${label}:`.padEnd(width)}${value}`;
+var NUMBER_COLUMNS = [
+  ["Time", 9],
+  ["Steps", 6],
+  ["Pass", 5],
+  ["Fail", 5],
+  ["Error", 6],
+  ["Skip", 5],
+  ["Asserts", 8],
+  ["Pass", 5],
+  ["Fail", 5]
+];
+var nameWidthFor = (ids) => Math.min(80, Math.max("Collection".length, ...ids.map((id) => id.length)));
+var tableWidth = (nameWidth) => 4 + 2 + nameWidth + 1 + NUMBER_COLUMNS.reduce((n, [, w]) => n + w + 1, 0) - 1 + 2 + "passed".length;
+function tableHeader(nameWidth, p) {
+  const cells = NUMBER_COLUMNS.map(([label, width]) => label.padStart(width));
+  return p.bold(`${"#".padStart(4)}  ${"Collection".padEnd(nameWidth)} ${cells.join(" ")}  Result`);
+}
+var nameCell = (id, width) => id.length > width ? `${id.slice(0, width - 1)}\u2026` : id.padEnd(width);
+function tableRow(n, t, nameWidth, p) {
+  const name = nameCell(t.id, nameWidth);
+  const values = [
+    seconds(t.durationMs),
+    t.steps.total,
+    t.steps.passed,
+    t.steps.failed,
+    t.steps.errored,
+    t.steps.skipped,
+    t.assertions.total,
+    t.assertions.passed,
+    t.assertions.failed
+  ];
+  const cells = values.map((value, i) => String(value).padStart(NUMBER_COLUMNS[i][1]));
+  const result = t.skipped ? p.cyan("skipped") : t.passed ? p.green("passed") : p.red("failed");
+  return `${String(n).padStart(4)}  ${name} ${cells.join(" ")}  ${result}`;
+}
+var clip = (text, max = 300) => text.length > max ? `${text.slice(0, max)}\u2026 (${text.length - max} more characters)` : text;
+function failureDetails(tallies, p) {
+  const lines = [];
+  for (const t of tallies) {
+    if (t.passed) continue;
+    lines.push(p.bold(t.id));
+    if (t.error) lines.push(`  ${p.red("\u2717")} ${t.error}`);
+    for (const result of t.problems) {
+      const where = result.use ? ` ${p.dim(`(${result.use.set} ${result.use.child + 1}/${result.use.of})`)}` : "";
+      const status = result.response ? ` ${p.dim(String(result.response.status))}` : "";
+      lines.push(`  ${p.red("\u2717")} ${result.item.name}${where}${status}`);
+      if (result.error) {
+        const { phase, script, line, message } = result.error;
+        const at = [script && `${script} script`, line && `line ${line}`].filter(Boolean).join(", ");
+        lines.push(`      ${p.red(`${phase} error${at ? ` (${at})` : ""}:`)} ${clip(message)}`);
+      }
+      for (const assertion of result.assertions) {
+        if (assertion.status !== "fail") continue;
+        const message = assertion.message ? `: ${assertion.message}` : "";
+        lines.push(`      ${assertion.name}${message}`);
+        if (assertion.expected !== void 0) {
+          lines.push(`        ${p.dim("expected")} ${clip(assertion.expected)}`);
+        }
+        if (assertion.actual !== void 0) {
+          lines.push(`        ${p.dim("actual  ")} ${clip(assertion.actual)}`);
+        }
+        if (assertion.unasserted?.length) {
+          lines.push(`        ${p.dim("not asserted")} ${clip(assertion.unasserted.join(", "))}`);
+        }
+      }
+    }
+    lines.push("");
+  }
+  return lines;
+}
+function totalsOf(tallies) {
+  const sum = (pick) => tallies.reduce((n, t) => n + pick(t), 0);
+  return {
+    collections: {
+      total: tallies.length,
+      passed: tallies.filter((t) => t.passed && !t.skipped).length,
+      failed: tallies.filter((t) => !t.passed).length,
+      skipped: tallies.filter((t) => t.skipped).length
+    },
+    steps: {
+      total: sum((t) => t.steps.total),
+      passed: sum((t) => t.steps.passed),
+      failed: sum((t) => t.steps.failed),
+      errored: sum((t) => t.steps.errored),
+      skipped: sum((t) => t.steps.skipped)
+    },
+    assertions: {
+      total: sum((t) => t.assertions.total),
+      passed: sum((t) => t.assertions.passed),
+      failed: sum((t) => t.assertions.failed)
+    }
+  };
+}
+function summary(totals, durationMs, p) {
+  const { collections: c, steps: s, assertions: a } = totals;
+  const passed = c.failed === 0;
+  return [
+    field(
+      "Collections",
+      `${c.total} total, ${c.passed} passed, ${c.failed} failed, ${c.skipped} skipped`
+    ),
+    field(
+      "Steps",
+      `${s.total} total, ${s.passed} passed, ${s.failed} failed, ${s.errored} errored, ${s.skipped} skipped`
+    ),
+    field("Assertions", `${a.total} total, ${a.passed} passed, ${a.failed} failed`),
+    field("Run time", seconds(durationMs)),
+    field("Result", passed ? p.green(p.bold("PASSED")) : p.red(p.bold("FAILED")))
+  ];
+}
+
+// src/settings.ts
+import path from "node:path";
+var SETTING_KEYS = {
+  environmentType: {
+    kind: "string",
+    doc: "The environment to run against, by name: environments/<name>.yml (the global project\u2019s too). Unset: no environment."
+  },
+  limitConcurrency: {
+    kind: "integer",
+    doc: "How many collections run at once. Steps within a collection always run in order."
+  },
+  timeoutCollection: {
+    kind: "integer",
+    doc: "Milliseconds a collection may take before it is stopped and reported failed."
+  },
+  bail: {
+    kind: "boolean",
+    doc: "Stop a collection at its first failing step; the rest are reported skipped."
+  },
+  tags: {
+    kind: "list",
+    doc: "Run only what has one of these tags (SPEC.md \xA72.4). Empty: everything."
+  },
+  notTags: {
+    kind: "list",
+    doc: "Leave out what has one of these tags: a collection tagged so, or a step where steps carry tags."
+  },
+  generateJUnitResults: {
+    kind: "boolean",
+    doc: "Write a JUnit XML report of the run to <testResultsBasePath>/junit/junit.xml, for CI."
+  },
+  generateJsonResults: {
+    kind: "boolean",
+    doc: "Write the run as JSON to <testResultsBasePath>/json/results.json, for tools and agents."
+  },
+  generateHtmlResults: {
+    kind: "boolean",
+    doc: "Write an HTML report of the run: <testResultsBasePath>/html/summary.html and a page per collection."
+  },
+  autoOpenTestResultHtml: {
+    kind: "boolean",
+    doc: "Write the HTML report and open its summary in the browser when the run ends."
+  },
+  testResultsBasePath: {
+    kind: "string",
+    doc: "Where reports are written: relative to the project folder, or absolute."
+  }
+};
+var KEYS = Object.keys(SETTING_KEYS);
+var positiveInteger = external_exports.number().int().min(1);
+var SettingsSchema = external_exports.strictObject({
+  environmentType: external_exports.string().trim().min(1).nullable().default(null),
+  limitConcurrency: positiveInteger.default(1),
+  timeoutCollection: positiveInteger.default(36e5),
+  bail: external_exports.boolean().default(false),
+  tags: external_exports.array(TagSchema).default([]),
+  notTags: external_exports.array(TagSchema).default([]),
+  generateJUnitResults: external_exports.boolean().default(false),
+  generateJsonResults: external_exports.boolean().default(false),
+  generateHtmlResults: external_exports.boolean().default(false),
+  autoOpenTestResultHtml: external_exports.boolean().default(false),
+  testResultsBasePath: external_exports.string().trim().min(1).default("test-results")
+});
+var DEFAULT_SETTINGS = SettingsSchema.parse({});
+var SettingsError = class extends Error {
+  name = "SettingsError";
+};
+var envNameOf = (key) => `GTA_${key.replace(/[A-Z]/g, (c) => `_${c}`).toUpperCase()}`;
+var DEFAULT_SOURCE = "default";
+async function loadSettings(options) {
+  const { root, global = null, overrides = {}, env = process.env } = options;
+  const overrideLabel = options.overrideLabel ?? ((key) => `--${key}`);
+  const own = await readSettingsFile(path.join(root, SETTINGS_FILE), SETTINGS_FILE);
+  if (own === null && !options.optionalFile) {
+    throw new SettingsError(
+      `There is no ${SETTINGS_FILE} in ${root}.
+gta runs from a project folder: the one holding collections/ and ${SETTINGS_FILE}.
+A minimal ${SETTINGS_FILE}:
+
+  environmentType: demo
+  limitConcurrency: 4
+`
+    );
+  }
+  const sharedLabel = global ? path.posix.join(global.uses, SETTINGS_FILE) : "";
+  const shared = global ? await readSettingsFile(path.join(global.root, SETTINGS_FILE), sharedLabel) : null;
+  const origin = /* @__PURE__ */ new Map();
+  const merged = {};
+  const files = [
+    [sharedLabel, shared],
+    [SETTINGS_FILE, own]
+  ];
+  for (const [label, fromFile] of files) {
+    for (const [key, value] of Object.entries(fromFile ?? {})) {
+      checkKey(key, label);
+      merged[key] = value;
+      origin.set(key, label);
+    }
+  }
+  for (const key of KEYS) {
+    const value = env[envNameOf(key)];
+    if (value === void 0 || value === "") continue;
+    merged[key] = coerce(key, value, envNameOf(key));
+    origin.set(key, envNameOf(key));
+  }
+  for (const [key, value] of Object.entries(overrides)) {
+    checkKey(key, overrideLabel(key));
+    merged[key] = coerce(key, value, overrideLabel(key));
+    origin.set(key, overrideLabel(key));
+  }
+  const result = SettingsSchema.safeParse(merged);
+  if (!result.success) {
+    const lines = result.error.issues.map((issue) => {
+      const key = String(issue.path[0] ?? "");
+      return `  ${key} (from ${origin.get(key) ?? SETTINGS_FILE}): ${issue.message}`;
+    });
+    throw new SettingsError(`Settings are not valid:
+${lines.join("\n")}`);
+  }
+  const sources = Object.fromEntries(
+    KEYS.map((key) => [key, origin.get(key) ?? DEFAULT_SOURCE])
+  );
+  return { settings: result.data, sources };
+}
+async function readSettingsFile(file, label) {
+  try {
+    return await readYamlMap(file, label, "limitConcurrency: 4");
+  } catch (cause) {
+    if (cause instanceof YamlMapError) throw new SettingsError(cause.message);
+    throw cause;
+  }
+}
+function checkKey(key, where) {
+  if (!Object.hasOwn(SETTING_KEYS, key)) {
+    throw new SettingsError(
+      `Unknown setting "${key}" (from ${where}). Settings are: ${KEYS.join(", ")}`
+    );
+  }
+}
+function coerce(key, value, where) {
+  const { kind } = SETTING_KEYS[key];
+  if (value === true) {
+    if (kind === "boolean") return true;
+    throw new SettingsError(`${where} needs a value`);
+  }
+  switch (kind) {
+    case "integer":
+      return /^\s*\d+\s*$/.test(value) ? Number(value) : value;
+    case "boolean":
+      return value === "true" ? true : value === "false" ? false : value;
+    case "list":
+      return value.split(",").map((item) => item.trim()).filter((item) => item !== "");
+    case "string":
+      return value;
+  }
+}
+
+// src/project.ts
+import fs from "node:fs/promises";
+import path2 from "node:path";
+var ProjectError = class extends Error {
+  name = "ProjectError";
+};
+async function loadProject(options) {
+  const { root, env } = options;
+  if (!await isDirectory(path2.join(root, COLLECTIONS_DIR))) {
+    throw new ProjectError(
+      `There is no ${COLLECTIONS_DIR}/ in ${root}.
+gta runs from a project folder: the one holding ${COLLECTIONS_DIR}/ and ${SETTINGS_FILE}.`
+    );
+  }
+  const info = await readProject(root);
+  const { settings, sources: settingSources } = await loadSettings({
+    root,
+    global: info.global,
+    env,
+    ...options.overrides ? { overrides: options.overrides } : {},
+    ...options.overrideLabel ? { overrideLabel: options.overrideLabel } : {},
+    ...options.optionalSettings ? { optionalFile: true } : {}
+  });
+  const layout = await discoverProject(root);
+  const collections = await loadProjectCollections(root, layout.files);
+  const environments = environmentNames(await projectEnvironments(root, info.global));
+  if (settings.environmentType && !environments.includes(settings.environmentType)) {
+    throw new ProjectError(
+      `environmentType (from ${settingSources.environmentType}): there is no environment called "${settings.environmentType}". ` + (environments.length > 0 ? `This project has: ${environments.join(", ")}` : `This project has no environments/.`)
+    );
+  }
+  let flags;
+  try {
+    flags = await resolveFlags({
+      root,
+      environmentName: settings.environmentType,
+      overrides: { ...flagOverrides(options.flagArgs ?? [], env), ...options.flagValues },
+      env: { ...process.env, ...env }
+    });
+  } catch (cause) {
+    throw new ProjectError(cause.message);
+  }
+  const tls = await loadProjectTls(root, info);
+  if (tls.problems.length > 0) {
+    throw new ProjectError(
+      `A certificate in tls.ca cannot be used:
+` + tls.problems.map((problem) => `  ${problem.path}: ${problem.message}`).join("\n")
+    );
+  }
+  return {
+    root,
+    name: info.doc?.name ?? path2.basename(root),
+    global: info.global ? { root: info.global.root, uses: info.global.uses } : null,
+    settings,
+    settingSources,
+    flags,
+    collections,
+    environments,
+    caFiles: tls.files.map(
+      (file) => `${relativePosix(root, file.file)} (${file.certificates.map((c) => c.subject).join(", ")})`
+    ),
+    warnings: [...info.problems, ...layout.problems].map(
+      (problem) => problem.path ? `${problem.path}: ${problem.message}` : problem.message
+    )
+  };
+}
+async function isDirectory(target) {
+  try {
+    return (await fs.stat(target)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+export {
+  UsageError,
+  parseArgs,
+  idOf,
+  findCollection,
+  selectCollections,
+  stepCountOf,
+  paint,
+  colorWanted,
+  tally,
+  tallyOf,
+  rule,
+  field,
+  nameWidthFor,
+  tableWidth,
+  tableHeader,
+  nameCell,
+  tableRow,
+  failureDetails,
+  totalsOf,
+  summary,
+  SETTING_KEYS,
+  DEFAULT_SETTINGS,
+  SettingsError,
+  envNameOf,
+  DEFAULT_SOURCE,
+  ProjectError,
+  loadProject,
+  isDirectory
+};