cisco-perfmon 1.6.0 → 2.0.0

package/test/cli/connection.test.js

@@ -0,0 +1,151 @@
+const assert = require("assert");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+let passed = 0, failed = 0, total = 0;
+function describe(name, fn) { console.log(`  ${name}`); fn(); }
+function it(name, fn) {
+  total++;
+  try { fn(); console.log(`    \u2713 ${name}`); passed++; }
+  catch (e) { console.log(`    \u2717 ${name}: ${e.message}`); failed++; }
+}
+
+const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "cisco-perfmon-test-conn-"));
+process.env.CISCO_PERFMON_CONFIG_DIR = tmpDir;
+
+const { saveConfig } = require("../../cli/utils/config.js");
+const { resolveConfig } = require("../../cli/utils/connection.js");
+
+// Save env vars to restore later
+const savedHost = process.env.CUCM_HOST;
+const savedHostname = process.env.CUCM_HOSTNAME;
+const savedUsername = process.env.CUCM_USERNAME;
+const savedPassword = process.env.CUCM_PASSWORD;
+
+function clearEnv() {
+  delete process.env.CUCM_HOST;
+  delete process.env.CUCM_HOSTNAME;
+  delete process.env.CUCM_USERNAME;
+  delete process.env.CUCM_PASSWORD;
+}
+
+function restoreEnv() {
+  if (savedHost !== undefined) process.env.CUCM_HOST = savedHost; else delete process.env.CUCM_HOST;
+  if (savedHostname !== undefined) process.env.CUCM_HOSTNAME = savedHostname; else delete process.env.CUCM_HOSTNAME;
+  if (savedUsername !== undefined) process.env.CUCM_USERNAME = savedUsername; else delete process.env.CUCM_USERNAME;
+  if (savedPassword !== undefined) process.env.CUCM_PASSWORD = savedPassword; else delete process.env.CUCM_PASSWORD;
+}
+
+describe("resolveConfig — throws when nothing configured", () => {
+  it("throws when no flags, env, or config exist", () => {
+    clearEnv();
+    saveConfig({ activeCluster: null, clusters: {} });
+    assert.throws(() => resolveConfig({}), /No cluster configured/);
+  });
+});
+
+describe("resolveConfig — config file source", () => {
+  it("reads from config file when no flags or env set", () => {
+    clearEnv();
+    saveConfig({ activeCluster: "lab", clusters: { lab: { host: "config-host", username: "config-user", password: "config-pass" } } });
+    const result = resolveConfig({});
+    assert.strictEqual(result.host, "config-host");
+    assert.strictEqual(result.username, "config-user");
+    assert.strictEqual(result.password, "config-pass");
+  });
+
+  it("includes insecure from config", () => {
+    clearEnv();
+    saveConfig({ activeCluster: "lab", clusters: { lab: { host: "h", username: "u", password: "p", insecure: true } } });
+    const result = resolveConfig({});
+    assert.strictEqual(result.insecure, true);
+  });
+});
+
+describe("resolveConfig — env vars override config", () => {
+  it("CUCM_HOST overrides config host", () => {
+    saveConfig({ activeCluster: "lab", clusters: { lab: { host: "config-host", username: "config-user", password: "config-pass" } } });
+    clearEnv();
+    process.env.CUCM_HOST = "env-host";
+    process.env.CUCM_USERNAME = "env-user";
+    process.env.CUCM_PASSWORD = "env-pass";
+    const result = resolveConfig({});
+    assert.strictEqual(result.host, "env-host");
+    assert.strictEqual(result.username, "env-user");
+    assert.strictEqual(result.password, "env-pass");
+  });
+
+  it("CUCM_HOSTNAME also works as host env var", () => {
+    clearEnv();
+    process.env.CUCM_HOSTNAME = "hostname-env";
+    process.env.CUCM_USERNAME = "u";
+    process.env.CUCM_PASSWORD = "p";
+    saveConfig({ activeCluster: null, clusters: {} });
+    const result = resolveConfig({});
+    assert.strictEqual(result.host, "hostname-env");
+  });
+});
+
+describe("resolveConfig — flags override env and config", () => {
+  it("flag values take highest precedence", () => {
+    clearEnv();
+    process.env.CUCM_HOST = "env-host";
+    process.env.CUCM_USERNAME = "env-user";
+    process.env.CUCM_PASSWORD = "env-pass";
+    saveConfig({ activeCluster: "lab", clusters: { lab: { host: "config-host", username: "config-user", password: "config-pass" } } });
+    const result = resolveConfig({ host: "flag-host", username: "flag-user", password: "flag-pass" });
+    assert.strictEqual(result.host, "flag-host");
+    assert.strictEqual(result.username, "flag-user");
+    assert.strictEqual(result.password, "flag-pass");
+  });
+
+  it("flags can partially override (mix sources)", () => {
+    clearEnv();
+    process.env.CUCM_USERNAME = "env-user";
+    saveConfig({ activeCluster: "lab", clusters: { lab: { host: "config-host", username: "config-user", password: "config-pass" } } });
+    const result = resolveConfig({ host: "flag-host" });
+    assert.strictEqual(result.host, "flag-host");
+    assert.strictEqual(result.username, "env-user");
+    assert.strictEqual(result.password, "config-pass");
+  });
+});
+
+describe("resolveConfig — named cluster override", () => {
+  it("uses --cluster flag to select a specific cluster", () => {
+    clearEnv();
+    saveConfig({
+      activeCluster: "prod",
+      clusters: {
+        prod: { host: "prod-host", username: "prod-user", password: "prod-pass" },
+        lab: { host: "lab-host", username: "lab-user", password: "lab-pass" },
+      },
+    });
+    const result = resolveConfig({ cluster: "lab" });
+    assert.strictEqual(result.host, "lab-host");
+    assert.strictEqual(result.username, "lab-user");
+  });
+});
+
+describe("resolveConfig — insecure defaults to false", () => {
+  it("insecure is false when not set anywhere", () => {
+    clearEnv();
+    saveConfig({ activeCluster: "lab", clusters: { lab: { host: "h", username: "u", password: "p" } } });
+    const result = resolveConfig({});
+    assert.strictEqual(result.insecure, false);
+  });
+
+  it("insecure flag overrides config", () => {
+    clearEnv();
+    saveConfig({ activeCluster: "lab", clusters: { lab: { host: "h", username: "u", password: "p" } } });
+    const result = resolveConfig({ insecure: true });
+    assert.strictEqual(result.insecure, true);
+  });
+});
+
+// Restore env and cleanup
+restoreEnv();
+fs.rmSync(tmpDir, { recursive: true, force: true });
+
+console.log(`\n  connection.test.js: ${total} tests, ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);

package/test/cli/formatters.test.js

@@ -0,0 +1,144 @@
+const assert = require("assert");
+
+let passed = 0, failed = 0, total = 0;
+function describe(name, fn) { console.log(`  ${name}`); fn(); }
+function it(name, fn) {
+  total++;
+  try { fn(); console.log(`    \u2713 ${name}`); passed++; }
+  catch (e) { console.log(`    \u2717 ${name}: ${e.message}`); failed++; }
+}
+async function itAsync(name, fn) {
+  total++;
+  try { await fn(); console.log(`    \u2713 ${name}`); passed++; }
+  catch (e) { console.log(`    \u2717 ${name}: ${e.message}`); failed++; }
+}
+
+const formatTable = require("../../cli/formatters/table.js");
+const formatJson = require("../../cli/formatters/json.js");
+const formatCsv = require("../../cli/formatters/csv.js");
+const formatToon = require("../../cli/formatters/toon.js");
+
+const sampleList = [
+  { object: "Cisco CallManager", counter: "CallsActive", instance: "", value: "5", cstatus: "1" },
+  { object: "Cisco CallManager", counter: "CallsInProgress", instance: "", value: "12", cstatus: "1" },
+];
+const sampleItem = { object: "Cisco CallManager", counter: "CallsActive", instance: "", value: "5", cstatus: "1" };
+
+(async () => {
+  describe("table formatter", () => {
+    it("produces string output for an array", () => {
+      const result = formatTable(sampleList);
+      assert.strictEqual(typeof result, "string");
+      assert.ok(result.length > 0, "Output should not be empty");
+    });
+
+    it("includes column headers from object keys", () => {
+      const result = formatTable(sampleList);
+      assert.ok(result.includes("object"), "Should contain 'object' header");
+      assert.ok(result.includes("counter"), "Should contain 'counter' header");
+      assert.ok(result.includes("value"), "Should contain 'value' header");
+    });
+
+    it("includes data values", () => {
+      const result = formatTable(sampleList);
+      assert.ok(result.includes("CallsActive"), "Should contain counter name");
+      assert.ok(result.includes("Cisco CallManager"), "Should contain object name");
+    });
+
+    it("includes row count in output", () => {
+      const result = formatTable(sampleList);
+      assert.ok(result.includes("2 results found"), "Should show result count");
+    });
+
+    it("shows singular 'result' for single-item array", () => {
+      const result = formatTable([sampleItem]);
+      assert.ok(result.includes("1 result found"), "Should show singular result");
+    });
+
+    it("produces key-value output for a single object", () => {
+      const result = formatTable(sampleItem);
+      assert.strictEqual(typeof result, "string");
+      assert.ok(result.includes("CallsActive"), "Should contain item value");
+    });
+
+    it("returns 'No results found' for empty array", () => {
+      const result = formatTable([]);
+      assert.strictEqual(result, "No results found");
+    });
+
+    it("handles null/undefined values gracefully", () => {
+      const result = formatTable([{ object: "test", counter: null, value: undefined }]);
+      assert.strictEqual(typeof result, "string");
+    });
+  });
+
+  describe("json formatter", () => {
+    it("produces valid JSON for an array", () => {
+      const result = formatJson(sampleList);
+      const parsed = JSON.parse(result);
+      assert.ok(Array.isArray(parsed), "Parsed result should be an array");
+      assert.strictEqual(parsed.length, 2);
+    });
+
+    it("produces valid JSON for a single item", () => {
+      const result = formatJson(sampleItem);
+      const parsed = JSON.parse(result);
+      assert.strictEqual(parsed.counter, "CallsActive");
+    });
+
+    it("output is pretty-printed with 2-space indent", () => {
+      const result = formatJson(sampleItem);
+      assert.ok(result.includes("  "), "Should contain 2-space indentation");
+    });
+
+    it("preserves all fields", () => {
+      const result = formatJson(sampleItem);
+      const parsed = JSON.parse(result);
+      assert.strictEqual(parsed.object, "Cisco CallManager");
+      assert.strictEqual(parsed.value, "5");
+    });
+  });
+
+  describe("csv formatter", () => {
+    it("produces CSV with headers for an array", () => {
+      const result = formatCsv(sampleList);
+      const lines = result.trim().split("\n");
+      assert.ok(lines.length >= 3, "Should have header + 2 data rows");
+      assert.ok(lines[0].includes("object"), "First line should contain header 'object'");
+      assert.ok(lines[0].includes("counter"), "First line should contain header 'counter'");
+    });
+
+    it("produces CSV for a single item (wrapped in array)", () => {
+      const result = formatCsv(sampleItem);
+      const lines = result.trim().split("\n");
+      assert.ok(lines.length >= 2, "Should have header + 1 data row");
+    });
+
+    it("returns empty string for empty array", () => {
+      const result = formatCsv([]);
+      assert.strictEqual(result, "");
+    });
+
+    it("includes data values in rows", () => {
+      const result = formatCsv(sampleList);
+      assert.ok(result.includes("CallsActive"), "Should contain counter name");
+      assert.ok(result.includes("Cisco CallManager"), "Should contain object name");
+    });
+  });
+
+  console.log(`  toon formatter`);
+  await itAsync("produces string output", async () => {
+    const result = await formatToon(sampleItem);
+    assert.strictEqual(typeof result, "string");
+    assert.ok(result.length > 0, "Output should not be empty");
+  });
+
+  await itAsync("handles array input", async () => {
+    const result = await formatToon(sampleList);
+    assert.strictEqual(typeof result, "string");
+    assert.ok(result.length > 0, "Output should not be empty");
+  });
+
+  console.log(`\n  formatters.test.js: ${total} tests, ${passed} passed, ${failed} failed`);
+  if (failed > 0) process.exit(1);
+})();

package/test/cli/watch.test.js

@@ -0,0 +1,76 @@
+const assert = require("assert");
+
+let passed = 0, failed = 0, total = 0;
+function describe(name, fn) { console.log(`  ${name}`); fn(); }
+function it(name, fn) {
+  total++;
+  try { fn(); console.log(`    \u2713 ${name}`); passed++; }
+  catch (e) { console.log(`    \u2717 ${name}: ${e.message}`); failed++; }
+}
+
+// The watch module exports sparkline after self-registration
+const watchModule = require("../../cli/commands/watch.js");
+const sparkline = watchModule.sparkline;
+
+describe("sparkline", () => {
+  it("returns empty string for empty array", () => {
+    assert.strictEqual(sparkline([]), "");
+  });
+
+  it("returns a single block for a single value", () => {
+    const result = sparkline([5]);
+    assert.strictEqual(result.length, 1);
+  });
+
+  it("returns string with length equal to input length", () => {
+    const result = sparkline([1, 2, 3, 4, 5]);
+    assert.strictEqual(result.length, 5);
+  });
+
+  it("uses lowest block for minimum and highest for maximum", () => {
+    const result = sparkline([0, 100]);
+    // First char should be lowest block, second should be highest
+    assert.strictEqual(result[0], "\u2581");
+    assert.strictEqual(result[1], "\u2588");
+  });
+
+  it("produces all same blocks for constant values", () => {
+    const result = sparkline([50, 50, 50, 50]);
+    // All same value => range is 0 => formula uses range=1, all map to same block
+    const chars = new Set(result.split(""));
+    assert.strictEqual(chars.size, 1, "All blocks should be the same for constant values");
+  });
+
+  it("produces ascending blocks for ascending values", () => {
+    const result = sparkline([0, 1, 2, 3, 4, 5, 6, 7]);
+    // Each character should be >= the previous
+    for (let i = 1; i < result.length; i++) {
+      assert.ok(result.charCodeAt(i) >= result.charCodeAt(i - 1),
+        `Character at ${i} should be >= character at ${i - 1}`);
+    }
+  });
+
+  it("handles negative values", () => {
+    const result = sparkline([-10, -5, 0, 5, 10]);
+    assert.strictEqual(result.length, 5);
+    assert.strictEqual(result[0], "\u2581");
+    assert.strictEqual(result[4], "\u2588");
+  });
+
+  it("handles floating point values", () => {
+    const result = sparkline([0.1, 0.5, 0.9]);
+    assert.strictEqual(result.length, 3);
+    assert.strictEqual(typeof result, "string");
+  });
+
+  it("only uses valid sparkline block characters", () => {
+    const validChars = "\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588";
+    const result = sparkline([10, 20, 30, 40, 50, 60, 70, 80, 90, 100]);
+    for (const ch of result) {
+      assert.ok(validChars.includes(ch), `Character "${ch}" should be a valid sparkline block`);
+    }
+  });
+});
+
+console.log(`\n  watch.test.js: ${total} tests, ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);

package/test/unit.js

@@ -0,0 +1,24 @@
+const { execSync } = require("child_process");
+const { readdirSync } = require("fs");
+const path = require("path");
+
+const testDir = path.join(__dirname, "cli");
+const files = readdirSync(testDir).filter(f => f.endsWith(".test.js"));
+
+let passed = 0;
+let failed = 0;
+
+for (const file of files) {
+  try {
+    console.log(`\nRunning ${file}...`);
+    execSync(`node ${path.join(testDir, file)}`, { stdio: "inherit" });
+    passed++;
+  } catch {
+    failed++;
+  }
+}
+
+console.log(`\n================================`);
+console.log(`  Results: ${passed + failed} files, ${passed} passed, ${failed} failed`);
+console.log(`================================`);
+process.exitCode = failed > 0 ? 1 : 0;

package/types/index.d.ts

@@ -1,6 +1,10 @@
 export interface PerfmonOptions {
+  /** Max number of retries on network/HTTP errors. Defaults to PM_RETRY env var or 3. */
+  retries?: number;
+  /** Delay in ms between retries. Defaults to PM_RETRY_DELAY env var or 5000. */
+  retryDelay?: number;
   Cookie?: string;
-  [key: string]: string | undefined;
+  [key: string]: string | number | undefined;
 }
 
 export interface PerfmonResult {