launchr-cli 1.0.0

package/test/cli.integration.test.mjs

@@ -0,0 +1,152 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { runCli } from "../src/cli.mjs";
+
+function createMemoryStream() {
+  let buffer = "";
+  return {
+    write(chunk) {
+      buffer += String(chunk);
+    },
+    toString() {
+      return buffer;
+    },
+  };
+}
+
+function buildSampleConfig() {
+  return {
+    grafana: {
+      description: "some useful information",
+      url: "https://grafana.com/{environments}/{query}/{timeframe}",
+      parameters: {
+        environments: {
+          type: "single-choice-list",
+          flag: "e",
+          defaultValue: "staging",
+          required: true,
+          values: ["staging", "production"],
+        },
+        query: {
+          type: "string",
+          flag: "q",
+          defaultValue: "error",
+          required: true,
+        },
+        timeframe: {
+          type: "single-choice-list",
+          flag: "t",
+          defaultValue: "5m",
+          required: true,
+          values: ["5m", "10m", "1h", "6h"],
+        },
+      },
+    },
+  };
+}
+
+async function createHomeWithConfig(configObject) {
+  const homeDir = await mkdtemp(path.join(os.tmpdir(), "launchr-cli-test-"));
+  const configDir = path.join(homeDir, ".launchr-configurations");
+  const configFile = path.join(configDir, "launchr-commands.json");
+  await mkdir(configDir, { recursive: true });
+  await writeFile(configFile, `${JSON.stringify(configObject, null, 2)}\n`, "utf8");
+  return homeDir;
+}
+
+test("runCli list prints configured commands", async () => {
+  const homeDir = await createHomeWithConfig(buildSampleConfig());
+  const stdout = createMemoryStream();
+  const stderr = createMemoryStream();
+
+  const code = await runCli(["list"], { homeDir, stdout, stderr });
+  assert.equal(code, 0);
+  assert.match(stdout.toString(), /grafana\s+- some useful information/);
+  assert.equal(stderr.toString(), "");
+});
+
+test("runCli with no command prints custom commands with descriptions", async () => {
+  const config = {
+    ...buildSampleConfig(),
+    yutup: {
+      description: "youtube ac",
+      url: "https://youtube.com",
+      parameters: {},
+    },
+  };
+
+  const homeDir = await createHomeWithConfig(config);
+  const stdout = createMemoryStream();
+  const stderr = createMemoryStream();
+
+  const code = await runCli([], { homeDir, stdout, stderr });
+
+  assert.equal(code, 0);
+  assert.match(stdout.toString(), /Built-in Commands:/);
+  assert.match(stdout.toString(), /Custom Commands:/);
+  assert.match(stdout.toString(), /^\s{2}help\s{2,}Show manual$/m);
+  assert.match(stdout.toString(), /^\s{2}list\s{2,}List available commands$/m);
+  assert.match(stdout.toString(), /^\s{2}init\s{2,}Interactive setup$/m);
+  assert.match(stdout.toString(), /^\s{2}grafana\s{2,}some useful information$/m);
+  assert.match(stdout.toString(), /^\s{2}yutup\s{2,}youtube ac$/m);
+  assert.equal(stderr.toString(), "");
+});
+
+test("runCli custom command validates params and opens URL", async () => {
+  const homeDir = await createHomeWithConfig(buildSampleConfig());
+  const stdout = createMemoryStream();
+  const stderr = createMemoryStream();
+  const openedUrls = [];
+
+  const code = await runCli(
+    ["grafana", "-e", "production", "-q", "error", "-t", "5m"],
+    {
+      homeDir,
+      stdout,
+      stderr,
+      openUrlFn: async (url) => {
+        openedUrls.push(url);
+      },
+    },
+  );
+
+  assert.equal(code, 0);
+  assert.deepEqual(openedUrls, ["https://grafana.com/production/error/5m"]);
+  assert.match(stdout.toString(), /Opening URL:/);
+  assert.equal(stderr.toString(), "");
+});
+
+test("runCli command help prints dynamic options", async () => {
+  const homeDir = await createHomeWithConfig(buildSampleConfig());
+  const stdout = createMemoryStream();
+  const stderr = createMemoryStream();
+
+  const code = await runCli(["grafana", "help"], {
+    homeDir,
+    stdout,
+    stderr,
+  });
+
+  assert.equal(code, 0);
+  assert.match(stdout.toString(), /launchr grafana -e <environments> -q <query> -t <timeframe>/);
+  assert.equal(stderr.toString(), "");
+});
+
+test("runCli exits with clear error when config creation is declined", async () => {
+  const homeDir = await mkdtemp(path.join(os.tmpdir(), "launchr-cli-test-"));
+  const stdout = createMemoryStream();
+  const stderr = createMemoryStream();
+
+  const code = await runCli(["help"], {
+    homeDir,
+    stdout,
+    stderr,
+    promptYesNoFn: async () => false,
+  });
+
+  assert.equal(code, 1);
+  assert.match(stderr.toString(), /Configuration file is required to use this CLI/);
+});

package/test/flags.test.mjs

@@ -0,0 +1,18 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { parseShortFlags } from "../src/parsing/flags.mjs";
+
+test("parseShortFlags parses key-value pairs", () => {
+  const parsed = parseShortFlags(["-e", "production", "-q", "error"]);
+  assert.equal(parsed.get("e"), "production");
+  assert.equal(parsed.get("q"), "error");
+});
+
+test("parseShortFlags treats missing value as boolean true", () => {
+  const parsed = parseShortFlags(["-d"]);
+  assert.equal(parsed.get("d"), true);
+});
+
+test("parseShortFlags rejects invalid token", () => {
+  assert.throws(() => parseShortFlags(["query"]), /Unexpected token/);
+});

package/test/init.test.mjs

@@ -0,0 +1,52 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { runInitFlow } from "../src/commands/init.mjs";
+
+function createScriptedPrompter(answers) {
+  const queue = [...answers];
+  const writes = [];
+  return {
+    async ask() {
+      if (queue.length === 0) {
+        throw new Error("No more scripted answers");
+      }
+      return queue.shift();
+    },
+    write(message) {
+      writes.push(message);
+    },
+    close() {},
+    getWrites() {
+      return writes;
+    },
+  };
+}
+
+test("runInitFlow collects command definitions and saves config", async () => {
+  const prompter = createScriptedPrompter([
+    "google",
+    "search utility",
+    "https://google.com?q={query}",
+    "query",
+    "string",
+    "q",
+    "true",
+    "",
+    "done",
+    "no",
+  ]);
+
+  let savedConfig;
+  const result = await runInitFlow({
+    config: {},
+    prompter,
+    saveConfig: async (config) => {
+      savedConfig = config;
+    },
+  });
+
+  assert.equal(result.google.description, "search utility");
+  assert.equal(result.google.url, "https://google.com?q={query}");
+  assert.equal(result.google.parameters.query.flag, "q");
+  assert.equal(savedConfig.google.parameters.query.required, true);
+});

package/test/runtime-params.test.mjs

@@ -0,0 +1,63 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { resolveRuntimeParameters } from "../src/validation/runtime-params.mjs";
+
+const commandConfig = {
+  description: "search",
+  url: "https://google.com?query={query}&limit={limit}&debug={debug}",
+  parameters: {
+    query: {
+      type: "string",
+      flag: "q",
+      required: true,
+    },
+    limit: {
+      type: "integer",
+      flag: "l",
+      required: false,
+      defaultValue: 10,
+    },
+    debug: {
+      type: "boolean",
+      flag: "d",
+      required: false,
+      defaultValue: false,
+    },
+  },
+};
+
+test("resolveRuntimeParameters validates required fields", () => {
+  const flags = new Map();
+  assert.throws(
+    () => resolveRuntimeParameters("google", commandConfig, flags),
+    /Missing required parameter/,
+  );
+});
+
+test("resolveRuntimeParameters uses defaults and normalizes types", () => {
+  const flags = new Map([["q", "error"]]);
+  const result = resolveRuntimeParameters("google", commandConfig, flags);
+  assert.deepEqual(result.valuesInOrder, ["error", 10, false]);
+});
+
+test("resolveRuntimeParameters rejects unknown flags", () => {
+  const flags = new Map([
+    ["q", "error"],
+    ["x", "1"],
+  ]);
+
+  assert.throws(
+    () => resolveRuntimeParameters("google", commandConfig, flags),
+    /Unknown flag/,
+  );
+});
+
+test("resolveRuntimeParameters parses boolean true flag without explicit value", () => {
+  const flags = new Map([
+    ["q", "error"],
+    ["d", true],
+  ]);
+
+  const result = resolveRuntimeParameters("google", commandConfig, flags);
+  assert.deepEqual(result.valuesInOrder, ["error", 10, true]);
+});

package/test/schema.test.mjs

@@ -0,0 +1,101 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { validateConfigSchema } from "../src/config/schema.mjs";
+
+test("validateConfigSchema accepts valid config", () => {
+  const config = {
+    grafana: {
+      description: "some useful information",
+      url: "https://grafana.com/{environments}/{query}/{timeframe}",
+      parameters: {
+        environments: {
+          type: "single-choice-list",
+          flag: "e",
+          defaultValue: "as01-prd01",
+          required: true,
+          values: ["as01-prd01", "eu01-prd01"],
+        },
+        query: {
+          type: "string",
+          flag: "q",
+          defaultValue: "error",
+          required: true,
+        },
+        timeframe: {
+          type: "single-choice-list",
+          flag: "t",
+          defaultValue: "5m",
+          required: true,
+          values: ["5m", "10m", "1h", "6h"],
+        },
+      },
+    },
+  };
+
+  assert.equal(validateConfigSchema(config), config);
+});
+
+test("validateConfigSchema rejects unknown placeholders", () => {
+  const config = {
+    google: {
+      description: "search",
+      url: "https://google.com/{query}/{scope}",
+      parameters: {
+        query: {
+          type: "string",
+          flag: "q",
+          required: true,
+        },
+      },
+    },
+  };
+
+  assert.throws(() => validateConfigSchema(config), /unknown placeholders/);
+});
+
+test("validateConfigSchema rejects missing placeholders", () => {
+  const config = {
+    google: {
+      description: "search",
+      url: "https://google.com/{query}",
+      parameters: {
+        query: {
+          type: "string",
+          flag: "q",
+          required: true,
+        },
+        scope: {
+          type: "string",
+          flag: "s",
+          required: false,
+          defaultValue: "all",
+        },
+      },
+    },
+  };
+
+  assert.throws(() => validateConfigSchema(config), /missing placeholders/);
+});
+
+test("validateConfigSchema rejects duplicated flags", () => {
+  const config = {
+    google: {
+      description: "search",
+      url: "https://google.com/{query}/{term}",
+      parameters: {
+        query: {
+          type: "string",
+          flag: "q",
+          required: true,
+        },
+        term: {
+          type: "string",
+          flag: "q",
+          required: true,
+        },
+      },
+    },
+  };
+
+  assert.throws(() => validateConfigSchema(config), /duplicated flag/);
+});

package/test/url-template.test.mjs

@@ -0,0 +1,30 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { interpolateUrlTemplate, extractTemplatePlaceholders } from "../src/utils/url-template.mjs";
+
+test("extractTemplatePlaceholders returns parameter keys in order", () => {
+  assert.deepEqual(
+    extractTemplatePlaceholders("https://grafana.com/{environments}/{query}/{timeframe}"),
+    ["environments", "query", "timeframe"],
+  );
+});
+
+test("interpolateUrlTemplate replaces named placeholders by key", () => {
+  const value = interpolateUrlTemplate(
+    "https://grafana.com/{environments}/{query}/{timeframe}",
+    {
+      environments: "staging",
+      query: "error signal",
+      timeframe: "5m",
+    },
+  );
+
+  assert.equal(value, "https://grafana.com/staging/error%20signal/5m");
+});
+
+test("interpolateUrlTemplate throws when placeholder has no matching value", () => {
+  assert.throws(
+    () => interpolateUrlTemplate("https://google.com/{query}/{scope}", { query: "k8s" }),
+    /no matching parameter value/,
+  );
+});