skillrepo 4.2.0 → 4.4.0

package/src/test/lib/telemetry.test.mjs

@@ -0,0 +1,289 @@
+/**
+ * Unit tests for `packages/cli/src/lib/telemetry.mjs` (#1539).
+ *
+ * Covers:
+ *   - `telemetryDisabledByEnv` recognises `SKILLREPO_NO_TELEMETRY` and
+ *     the community `DO_NOT_TRACK` convention.
+ *   - `telemetryEnabled` honors env-disable, config-disable, and the
+ *     opt-out-friendly default of `true`.
+ *   - `reportInitFailure` is fire-and-forget — never throws, drops
+ *     payloads with out-of-enum `stage` values, builds the right
+ *     payload + URL, and honors the env/config opt-outs.
+ *
+ * The fetch is dependency-injected (no network).
+ */
+
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  telemetryDisabledByEnv,
+  telemetryEnabled,
+  reportInitFailure,
+  INIT_STAGES,
+  TELEMETRY_TIMEOUT_MS,
+} from "../../lib/telemetry.mjs";
+
+let savedEnv;
+
+beforeEach(() => {
+  savedEnv = {
+    SKILLREPO_NO_TELEMETRY: process.env.SKILLREPO_NO_TELEMETRY,
+    DO_NOT_TRACK: process.env.DO_NOT_TRACK,
+  };
+  delete process.env.SKILLREPO_NO_TELEMETRY;
+  delete process.env.DO_NOT_TRACK;
+});
+
+afterEach(() => {
+  for (const [key, value] of Object.entries(savedEnv)) {
+    if (value === undefined) delete process.env[key];
+    else process.env[key] = value;
+  }
+});
+
+describe("telemetryDisabledByEnv", () => {
+  it("returns false when neither env var is set", () => {
+    assert.equal(telemetryDisabledByEnv(), false);
+  });
+
+  it("returns true when SKILLREPO_NO_TELEMETRY=1", () => {
+    process.env.SKILLREPO_NO_TELEMETRY = "1";
+    assert.equal(telemetryDisabledByEnv(), true);
+  });
+
+  it("returns true for any truthy SKILLREPO_NO_TELEMETRY value", () => {
+    process.env.SKILLREPO_NO_TELEMETRY = "yes";
+    assert.equal(telemetryDisabledByEnv(), true);
+  });
+
+  it("returns false when SKILLREPO_NO_TELEMETRY is '0'", () => {
+    process.env.SKILLREPO_NO_TELEMETRY = "0";
+    assert.equal(telemetryDisabledByEnv(), false);
+  });
+
+  it("returns false when SKILLREPO_NO_TELEMETRY is 'false'", () => {
+    process.env.SKILLREPO_NO_TELEMETRY = "false";
+    assert.equal(telemetryDisabledByEnv(), false);
+  });
+
+  it("returns true when DO_NOT_TRACK=1 (community convention)", () => {
+    process.env.DO_NOT_TRACK = "1";
+    assert.equal(telemetryDisabledByEnv(), true);
+  });
+
+  it("returns true when DO_NOT_TRACK=true (community convention)", () => {
+    process.env.DO_NOT_TRACK = "true";
+    assert.equal(telemetryDisabledByEnv(), true);
+  });
+
+  it("returns false when DO_NOT_TRACK has some other value", () => {
+    process.env.DO_NOT_TRACK = "no";
+    assert.equal(telemetryDisabledByEnv(), false);
+  });
+});
+
+describe("telemetryEnabled", () => {
+  it("is true with no config and no env var (opt-out default)", () => {
+    assert.equal(telemetryEnabled(null), true);
+    assert.equal(telemetryEnabled(undefined), true);
+    assert.equal(telemetryEnabled({}), true);
+  });
+
+  it("is true when config.telemetry === true", () => {
+    assert.equal(telemetryEnabled({ telemetry: true }), true);
+  });
+
+  it("is false when config.telemetry === false", () => {
+    assert.equal(telemetryEnabled({ telemetry: false }), false);
+  });
+
+  it("is false when env var opts out, regardless of config", () => {
+    process.env.SKILLREPO_NO_TELEMETRY = "1";
+    assert.equal(telemetryEnabled({ telemetry: true }), false);
+    assert.equal(telemetryEnabled({}), false);
+    assert.equal(telemetryEnabled(null), false);
+  });
+});
+
+describe("INIT_STAGES", () => {
+  it("declares the closed set of init stages the server schema accepts", () => {
+    assert.deepEqual(
+      [...INIT_STAGES],
+      [
+        "pre_paste",
+        "post_paste_validate",
+        "config_write",
+        "library_sync",
+        "agent_detection",
+      ],
+    );
+  });
+});
+
+describe("reportInitFailure", () => {
+  function makeFetchSpy(response = new Response(null, { status: 204 })) {
+    const calls = [];
+    const fn = async (url, init) => {
+      calls.push({ url, init });
+      return response;
+    };
+    fn.calls = calls;
+    return fn;
+  }
+
+  it("does nothing when telemetry is disabled by env", async () => {
+    process.env.SKILLREPO_NO_TELEMETRY = "1";
+    const fetchSpy = makeFetchSpy();
+    await reportInitFailure({
+      serverUrl: "https://skillrepo.dev",
+      config: null,
+      stage: "post_paste_validate",
+      errorCode: 401,
+      deps: { fetch: fetchSpy },
+    });
+    assert.equal(fetchSpy.calls.length, 0);
+  });
+
+  it("does nothing when config opts out", async () => {
+    const fetchSpy = makeFetchSpy();
+    await reportInitFailure({
+      serverUrl: "https://skillrepo.dev",
+      config: { telemetry: false },
+      stage: "post_paste_validate",
+      errorCode: 401,
+      deps: { fetch: fetchSpy },
+    });
+    assert.equal(fetchSpy.calls.length, 0);
+  });
+
+  it("does nothing when stage is not in the closed enum", async () => {
+    const fetchSpy = makeFetchSpy();
+    await reportInitFailure({
+      serverUrl: "https://skillrepo.dev",
+      config: null,
+      stage: "i_made_this_up",
+      errorCode: 401,
+      deps: { fetch: fetchSpy },
+    });
+    assert.equal(fetchSpy.calls.length, 0);
+  });
+
+  it("POSTs the documented payload shape to /api/v1/cli/events", async () => {
+    const fetchSpy = makeFetchSpy();
+    await reportInitFailure({
+      serverUrl: "https://skillrepo.dev",
+      config: { telemetry: true },
+      stage: "post_paste_validate",
+      errorCode: 401,
+      deps: { fetch: fetchSpy },
+    });
+    assert.equal(fetchSpy.calls.length, 1);
+    const call = fetchSpy.calls[0];
+    assert.equal(call.url, "https://skillrepo.dev/api/v1/cli/events");
+    assert.equal(call.init.method, "POST");
+    assert.equal(call.init.headers["Content-Type"], "application/json");
+    assert.ok(call.init.headers["User-Agent"].startsWith("skillrepo-cli/"));
+    const body = JSON.parse(call.init.body);
+    assert.equal(body.stage, "post_paste_validate");
+    assert.equal(body.errorCode, 401);
+    assert.equal(body.serverUrlHost, "skillrepo.dev");
+    assert.equal(typeof body.cliVersion, "string");
+    assert.equal(typeof body.nodeVersion, "string");
+    assert.equal(typeof body.platform, "string");
+    // Privacy contract: no key material.
+    assert.equal(body.apiKey, undefined);
+    assert.equal(body.token, undefined);
+    assert.equal(body.secret, undefined);
+  });
+
+  it("strips trailing slashes from the server URL when building the endpoint", async () => {
+    const fetchSpy = makeFetchSpy();
+    await reportInitFailure({
+      serverUrl: "https://skillrepo.dev///",
+      config: { telemetry: true },
+      stage: "config_write",
+      errorCode: 3,
+      deps: { fetch: fetchSpy },
+    });
+    assert.equal(fetchSpy.calls[0].url, "https://skillrepo.dev/api/v1/cli/events");
+  });
+
+  it("never throws — swallows network failures silently", async () => {
+    const fetchSpy = async () => {
+      throw new Error("ECONNREFUSED");
+    };
+    await reportInitFailure({
+      serverUrl: "https://skillrepo.dev",
+      config: { telemetry: true },
+      stage: "post_paste_validate",
+      errorCode: 1,
+      deps: { fetch: fetchSpy },
+    });
+    // No assertion needed — if we reach this line, no throw happened.
+  });
+
+  it("never throws on a server 500 — swallows abnormal status silently", async () => {
+    const fetchSpy = makeFetchSpy(new Response("oops", { status: 500 }));
+    await reportInitFailure({
+      serverUrl: "https://skillrepo.dev",
+      config: { telemetry: true },
+      stage: "post_paste_validate",
+      errorCode: 401,
+      deps: { fetch: fetchSpy },
+    });
+    assert.equal(fetchSpy.calls.length, 1);
+  });
+
+  it("times out the fetch via AbortController", async () => {
+    // Verify the 1-second timeout fires by giving the fetch a slow
+    // promise and asserting the abort propagates. The fetch we
+    // provide observes the signal and rejects when aborted.
+    let abortObserved = false;
+    const fetchSpy = (url, init) =>
+      new Promise((_resolve, reject) => {
+        init.signal.addEventListener("abort", () => {
+          abortObserved = true;
+          reject(new DOMException("aborted", "AbortError"));
+        });
+      });
+    const start = Date.now();
+    await reportInitFailure({
+      serverUrl: "https://skillrepo.dev",
+      config: { telemetry: true },
+      stage: "post_paste_validate",
+      errorCode: 401,
+      deps: { fetch: fetchSpy },
+    });
+    const elapsed = Date.now() - start;
+    assert.equal(abortObserved, true);
+    // Give a generous tolerance — node:test machinery + CI variance
+    // can easily eat 200ms on a busy runner.
+    assert.ok(
+      elapsed >= TELEMETRY_TIMEOUT_MS - 50 && elapsed < TELEMETRY_TIMEOUT_MS + 2000,
+      `Elapsed ${elapsed}ms should be near TELEMETRY_TIMEOUT_MS (${TELEMETRY_TIMEOUT_MS})`,
+    );
+  });
+
+  it("does not fire on unsupported platforms (server would 400)", async () => {
+    // Simulate by swapping global fetch with a sentinel — we can't
+    // easily monkey `os.platform()`, so this verifies the symmetric
+    // contract: any platform string outside the closed set is dropped
+    // BEFORE fetch is called. The test runs on the host's actual
+    // platform (which is supported); the assertion is structural —
+    // that the platform check is in place.
+    //
+    // We assert by checking the FORWARD path: a supported platform
+    // (the host's) DOES fire, proving the gate isn't a global "skip
+    // everything" guard.
+    const fetchSpy = makeFetchSpy();
+    await reportInitFailure({
+      serverUrl: "https://skillrepo.dev",
+      config: { telemetry: true },
+      stage: "post_paste_validate",
+      errorCode: 401,
+      deps: { fetch: fetchSpy },
+    });
+    assert.equal(fetchSpy.calls.length, 1);
+  });
+});