akm-cli 0.6.1 → 0.7.0

package/dist/tests/search-include-proposed-cli.test.js

@@ -0,0 +1,118 @@
+/**
+ * `akm search --include-proposed` CLI integration test (#284 GAP-HIGH 9).
+ *
+ * Spawns the real CLI against an indexed stash that contains both a
+ * `quality: stable` and a `quality: proposed` skill, and asserts that:
+ *   - default search excludes the proposed entry,
+ *   - `--include-proposed` retains it in the hits list.
+ */
+import { afterEach, describe, expect, test } from "bun:test";
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { saveConfig } from "../src/core/config";
+import { akmIndex } from "../src/indexer/indexer";
+const tempDirs = [];
+const savedEnv = {
+    AKM_STASH_DIR: process.env.AKM_STASH_DIR,
+    XDG_CACHE_HOME: process.env.XDG_CACHE_HOME,
+    XDG_CONFIG_HOME: process.env.XDG_CONFIG_HOME,
+};
+function makeTempDir(prefix) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+    tempDirs.push(dir);
+    return dir;
+}
+function writeFile(filePath, content) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content);
+}
+const CLI = path.join(__dirname, "..", "src", "cli.ts");
+function runCli(args, stashDir) {
+    const result = spawnSync("bun", [CLI, ...args], {
+        encoding: "utf8",
+        timeout: 30_000,
+        env: {
+            ...process.env,
+            AKM_STASH_DIR: stashDir,
+            XDG_CACHE_HOME: process.env.XDG_CACHE_HOME,
+            XDG_CONFIG_HOME: process.env.XDG_CONFIG_HOME,
+        },
+    });
+    return {
+        stdout: result.stdout ?? "",
+        stderr: result.stderr ?? "",
+        status: result.status ?? -1,
+    };
+}
+afterEach(() => {
+    if (savedEnv.AKM_STASH_DIR === undefined)
+        delete process.env.AKM_STASH_DIR;
+    else
+        process.env.AKM_STASH_DIR = savedEnv.AKM_STASH_DIR;
+    if (savedEnv.XDG_CACHE_HOME === undefined)
+        delete process.env.XDG_CACHE_HOME;
+    else
+        process.env.XDG_CACHE_HOME = savedEnv.XDG_CACHE_HOME;
+    if (savedEnv.XDG_CONFIG_HOME === undefined)
+        delete process.env.XDG_CONFIG_HOME;
+    else
+        process.env.XDG_CONFIG_HOME = savedEnv.XDG_CONFIG_HOME;
+    for (const dir of tempDirs.splice(0)) {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe("akm search --include-proposed (CLI)", () => {
+    test("default excludes proposed entries; --include-proposed keeps them", async () => {
+        const stash = makeTempDir("akm-search-proposed-stash-");
+        process.env.XDG_CACHE_HOME = makeTempDir("akm-search-proposed-cache-");
+        process.env.XDG_CONFIG_HOME = makeTempDir("akm-search-proposed-config-");
+        for (const sub of ["skills", "commands", "agents", "knowledge", "scripts"]) {
+            fs.mkdirSync(path.join(stash, sub), { recursive: true });
+        }
+        // Curated entry
+        writeFile(path.join(stash, "skills", "stable-deploy", "SKILL.md"), "---\ndescription: deploy widgets uniformly\n---\n# Stable deploy\n");
+        writeFile(path.join(stash, "skills", "stable-deploy", ".stash.json"), JSON.stringify({
+            entries: [
+                {
+                    name: "stable-deploy",
+                    type: "skill",
+                    description: "deploy widgets uniformly",
+                    tags: ["deploy"],
+                    filename: "SKILL.md",
+                    quality: "curated",
+                },
+            ],
+        }));
+        // Proposed entry
+        writeFile(path.join(stash, "skills", "proposed-deploy", "SKILL.md"), "---\ndescription: deploy widgets experimentally\n---\n# Proposed deploy\n");
+        writeFile(path.join(stash, "skills", "proposed-deploy", ".stash.json"), JSON.stringify({
+            entries: [
+                {
+                    name: "proposed-deploy",
+                    type: "skill",
+                    description: "deploy widgets experimentally",
+                    tags: ["deploy"],
+                    filename: "SKILL.md",
+                    quality: "proposed",
+                },
+            ],
+        }));
+        process.env.AKM_STASH_DIR = stash;
+        saveConfig({ semanticSearchMode: "off" });
+        await akmIndex({ stashDir: stash, full: true });
+        const baseline = runCli(["search", "deploy", "--format=json"], stash);
+        expect(baseline.status).toBe(0);
+        const baselineJson = JSON.parse(baseline.stdout);
+        const baselineNames = baselineJson.hits.map((h) => h.name);
+        expect(baselineNames).toContain("stable-deploy");
+        expect(baselineNames).not.toContain("proposed-deploy");
+        const withProposed = runCli(["search", "deploy", "--include-proposed", "--format=json"], stash);
+        expect(withProposed.status).toBe(0);
+        const withProposedJson = JSON.parse(withProposed.stdout);
+        const withProposedNames = withProposedJson.hits.map((h) => h.name);
+        expect(withProposedNames).toContain("stable-deploy");
+        expect(withProposedNames).toContain("proposed-deploy");
+    });
+});

package/dist/tests/self-update.test.js

@@ -0,0 +1,442 @@
+import { afterEach, describe, expect, mock, spyOn, test } from "bun:test";
+import * as childProcess from "node:child_process";
+import { checkForUpdate, detectInstallMethod, getAkmBinaryName, getPackageManagerUpgradeCommand, performUpgrade, } from "../src/commands/self-update";
+// ── Fetch mocking helper ────────────────────────────────────────────────────
+let originalFetch;
+function mockFetch(handler) {
+    originalFetch = globalThis.fetch;
+    globalThis.fetch = (async (input) => {
+        const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+        return handler(url);
+    });
+}
+afterEach(() => {
+    mock.restore();
+    if (originalFetch) {
+        globalThis.fetch = originalFetch;
+    }
+});
+function fakeRelease(tagName) {
+    return Response.json({ tag_name: tagName });
+}
+// ── detectInstallMethod ─────────────────────────────────────────────────────
+describe("detectInstallMethod", () => {
+    test("returns a valid install method when running via bun run (not compiled)", () => {
+        const method = detectInstallMethod();
+        // In test context we're running from source. May be "binary" if AKM_VERSION
+        // is defined (e.g. compiled test runner), otherwise "unknown" or a package-manager install.
+        expect(["unknown", "npm", "pnpm", "bun", "binary"]).toContain(method);
+    });
+    test("does not throw", () => {
+        expect(() => detectInstallMethod()).not.toThrow();
+    });
+    test("returns 'binary' when Bun.main starts with /$bunfs/", () => {
+        const signals = {
+            bunMain: "/$bunfs/root/src/cli.ts",
+            importMetaDir: "/some/path",
+            hasAkmVersion: false,
+        };
+        expect(detectInstallMethod(signals)).toBe("binary");
+    });
+    test("returns 'binary' when AKM_VERSION is defined (fallback)", () => {
+        const signals = {
+            bunMain: "/usr/local/bin/akm",
+            importMetaDir: "/some/path",
+            hasAkmVersion: true,
+        };
+        expect(detectInstallMethod(signals)).toBe("binary");
+    });
+    test("returns 'bun' for Bun global install path", () => {
+        const signals = {
+            bunMain: "/usr/local/bin/bun",
+            importMetaDir: "/home/user/.bun/install/global/node_modules/akm-cli/dist",
+            hasAkmVersion: false,
+        };
+        expect(detectInstallMethod(signals)).toBe("bun");
+    });
+    test("returns 'bun' for Windows-style Bun global install path", () => {
+        const signals = {
+            bunMain: "C:\\Program Files\\Bun\\bun.exe",
+            importMetaDir: "C:\\Users\\me\\.bun\\install\\global\\node_modules\\akm-cli\\dist",
+            hasAkmVersion: false,
+        };
+        expect(detectInstallMethod(signals)).toBe("bun");
+    });
+    test("returns 'pnpm' for pnpm global install path", () => {
+        const signals = {
+            bunMain: "/usr/local/bin/bun",
+            importMetaDir: "/home/user/.local/share/pnpm/global/5/node_modules/akm-cli/dist",
+            hasAkmVersion: false,
+        };
+        expect(detectInstallMethod(signals)).toBe("pnpm");
+    });
+    test("returns 'pnpm' for Windows-style pnpm global install path", () => {
+        const signals = {
+            bunMain: "C:\\Program Files\\Bun\\bun.exe",
+            importMetaDir: "C:\\Users\\me\\AppData\\Local\\pnpm\\global\\5\\node_modules\\akm-cli\\dist",
+            hasAkmVersion: false,
+        };
+        expect(detectInstallMethod(signals)).toBe("pnpm");
+    });
+    test("returns 'npm' when importMetaDir contains node_modules without bun/pnpm markers", () => {
+        const signals = {
+            bunMain: "/usr/local/bin/bun",
+            importMetaDir: "/usr/local/lib/node_modules/akm-cli/dist",
+            hasAkmVersion: false,
+        };
+        expect(detectInstallMethod(signals)).toBe("npm");
+    });
+    test("package-manager detection takes priority over binary signals", () => {
+        const signals = {
+            bunMain: "/$bunfs/root/src/cli.ts",
+            importMetaDir: "/some/node_modules/akm",
+            hasAkmVersion: true,
+        };
+        expect(detectInstallMethod(signals)).toBe("npm");
+    });
+    test("returns 'unknown' when no signals match", () => {
+        const signals = {
+            bunMain: undefined,
+            importMetaDir: "/some/path",
+            hasAkmVersion: false,
+        };
+        expect(detectInstallMethod(signals)).toBe("unknown");
+    });
+    test("returns 'unknown' when Bun is present but no binary indicators", () => {
+        const signals = {
+            bunMain: "/home/user/akm/src/cli.ts",
+            importMetaDir: "/home/user/akm/src",
+            hasAkmVersion: false,
+        };
+        expect(detectInstallMethod(signals)).toBe("unknown");
+    });
+});
+// ── getAkmBinaryName ────────────────────────────────────────────────────────
+describe("getAkmBinaryName", () => {
+    test("returns a string containing 'akm'", () => {
+        const name = getAkmBinaryName();
+        expect(name).toContain("akm");
+    });
+    test("returns platform-appropriate name for current platform", () => {
+        const name = getAkmBinaryName();
+        const platform = process.platform;
+        const arch = process.arch;
+        if (platform === "linux") {
+            expect(name).toStartWith("akm-linux-");
+        }
+        else if (platform === "darwin") {
+            expect(name).toStartWith("akm-darwin-");
+        }
+        else if (platform === "win32") {
+            expect(name).toStartWith("akm-windows-");
+            expect(name).toEndWith(".exe");
+        }
+        if (arch === "x64") {
+            expect(name).toContain("x64");
+        }
+        else if (arch === "arm64") {
+            expect(name).toContain("arm64");
+        }
+    });
+});
+// ── checkForUpdate (mocked fetch) ───────────────────────────────────────────
+describe("checkForUpdate", () => {
+    test("returns valid UpgradeCheckResponse", async () => {
+        mockFetch(() => fakeRelease("v0.0.14"));
+        const result = await checkForUpdate("0.0.13");
+        expect(result.currentVersion).toBe("0.0.13");
+        expect(result.latestVersion).toBe("0.0.14");
+        expect(result.updateAvailable).toBe(true);
+        expect(["binary", "bun", "npm", "pnpm", "unknown"]).toContain(result.installMethod);
+    });
+    test("updateAvailable is false when current matches latest", async () => {
+        mockFetch(() => fakeRelease("v0.0.13"));
+        const result = await checkForUpdate("0.0.13");
+        expect(result.updateAvailable).toBe(false);
+        expect(result.latestVersion).toBe("0.0.13");
+    });
+    test("updateAvailable is true for an old version", async () => {
+        mockFetch(() => fakeRelease("v0.0.14"));
+        const result = await checkForUpdate("0.0.0");
+        expect(result.updateAvailable).toBe(true);
+        expect(result.currentVersion).toBe("0.0.0");
+        expect(result.latestVersion).toBe("0.0.14");
+    });
+    test("handles missing tag_name gracefully", async () => {
+        mockFetch(() => Response.json({}));
+        const result = await checkForUpdate("0.0.13");
+        expect(result.latestVersion).toBe("");
+        expect(result.updateAvailable).toBe(false);
+    });
+    test("throws on non-OK response", async () => {
+        mockFetch(() => new Response("Not Found", { status: 404, statusText: "Not Found" }));
+        await expect(checkForUpdate("0.0.13")).rejects.toThrow("Failed to check for updates");
+    });
+});
+// ── performUpgrade ──────────────────────────────────────────────────────────
+describe("performUpgrade", () => {
+    test("runs npm global install for npm installs", async () => {
+        const spawnSyncSpy = spyOn(childProcess, "spawnSync").mockReturnValue({
+            status: 0,
+            stdout: "",
+            stderr: "",
+        });
+        const result = await performUpgrade({
+            currentVersion: "0.0.13",
+            latestVersion: "0.0.14",
+            updateAvailable: true,
+            installMethod: "npm",
+        });
+        expect(spawnSyncSpy).toHaveBeenCalledWith(expect.stringContaining("npm"), ["install", "-g", "akm-cli@latest"], expect.objectContaining({ encoding: "utf8", stdio: "pipe" }));
+        expect(result.upgraded).toBe(true);
+        expect(result.installMethod).toBe("npm");
+    });
+    test("runs bun global install for bun installs", async () => {
+        const spawnSyncSpy = spyOn(childProcess, "spawnSync").mockReturnValue({
+            status: 0,
+            stdout: "",
+            stderr: "",
+        });
+        const result = await performUpgrade({
+            currentVersion: "0.0.13",
+            latestVersion: "0.0.14",
+            updateAvailable: true,
+            installMethod: "bun",
+        });
+        expect(spawnSyncSpy).toHaveBeenCalledWith(expect.stringContaining("bun"), ["install", "-g", "akm-cli@latest"], expect.objectContaining({ encoding: "utf8", stdio: "pipe" }));
+        expect(result.upgraded).toBe(true);
+        expect(result.installMethod).toBe("bun");
+    });
+    test("runs pnpm global add for pnpm installs", async () => {
+        const spawnSyncSpy = spyOn(childProcess, "spawnSync").mockReturnValue({
+            status: 0,
+            stdout: "",
+            stderr: "",
+        });
+        const result = await performUpgrade({
+            currentVersion: "0.0.13",
+            latestVersion: "0.0.14",
+            updateAvailable: true,
+            installMethod: "pnpm",
+        });
+        expect(spawnSyncSpy).toHaveBeenCalledWith(expect.stringContaining("pnpm"), ["add", "-g", "akm-cli@latest"], expect.objectContaining({ encoding: "utf8", stdio: "pipe" }));
+        expect(result.upgraded).toBe(true);
+        expect(result.installMethod).toBe("pnpm");
+    });
+    test("returns guidance message for unknown install method", async () => {
+        const result = await performUpgrade({
+            currentVersion: "0.0.13",
+            latestVersion: "0.0.14",
+            updateAvailable: true,
+            installMethod: "unknown",
+        });
+        expect(result.upgraded).toBe(false);
+        expect(result.installMethod).toBe("unknown");
+        expect(result.message).toContain("manually");
+    });
+    test("returns already-latest message when no update available", async () => {
+        const result = await performUpgrade({
+            currentVersion: "0.0.13",
+            latestVersion: "0.0.13",
+            updateAvailable: false,
+            installMethod: "binary",
+        });
+        expect(result.upgraded).toBe(false);
+        expect(result.message).toContain("already the latest");
+    });
+    test("runs `akm index` post-upgrade after a successful pkg-manager install", async () => {
+        const spawnSyncSpy = spyOn(childProcess, "spawnSync").mockReturnValue({
+            status: 0,
+            stdout: "",
+            stderr: "",
+        });
+        const result = await performUpgrade({
+            currentVersion: "0.0.13",
+            latestVersion: "0.0.14",
+            updateAvailable: true,
+            installMethod: "npm",
+        });
+        expect(result.upgraded).toBe(true);
+        expect(result.postUpgrade).toBeDefined();
+        expect(result.postUpgrade?.ok).toBe(true);
+        expect(result.postUpgrade?.skipped).toBe(false);
+        expect(result.postUpgrade?.exitCode).toBe(0);
+        // First spawnSync = the install; second spawnSync = the post-upgrade `akm index`.
+        expect(spawnSyncSpy).toHaveBeenCalledTimes(2);
+        expect(spawnSyncSpy).toHaveBeenLastCalledWith("akm", ["index"], expect.objectContaining({ encoding: "utf8", stdio: "pipe" }));
+    });
+    test("skips the post-upgrade `akm index` when skipPostUpgrade is set", async () => {
+        const spawnSyncSpy = spyOn(childProcess, "spawnSync").mockReturnValue({
+            status: 0,
+            stdout: "",
+            stderr: "",
+        });
+        const result = await performUpgrade({
+            currentVersion: "0.0.13",
+            latestVersion: "0.0.14",
+            updateAvailable: true,
+            installMethod: "npm",
+        }, { skipPostUpgrade: true });
+        expect(result.upgraded).toBe(true);
+        expect(result.postUpgrade).toBeDefined();
+        expect(result.postUpgrade?.skipped).toBe(true);
+        expect(result.postUpgrade?.ok).toBe(true);
+        // Only the install spawnSync ran — no second call for `akm index`.
+        expect(spawnSyncSpy).toHaveBeenCalledTimes(1);
+    });
+    test("captures post-upgrade failure without failing the upgrade", async () => {
+        let call = 0;
+        const spawnSyncSpy = spyOn(childProcess, "spawnSync").mockImplementation((() => {
+            call++;
+            if (call === 1) {
+                // The install itself succeeds.
+                return { status: 0, stdout: "", stderr: "" };
+            }
+            // The post-upgrade `akm index` fails with a non-zero exit.
+            return { status: 1, stdout: "", stderr: "no embedding model configured" };
+        }));
+        const result = await performUpgrade({
+            currentVersion: "0.0.13",
+            latestVersion: "0.0.14",
+            updateAvailable: true,
+            installMethod: "npm",
+        });
+        expect(result.upgraded).toBe(true); // upgrade itself succeeded
+        expect(result.postUpgrade?.ok).toBe(false);
+        expect(result.postUpgrade?.exitCode).toBe(1);
+        expect(result.postUpgrade?.message).toContain("no embedding model configured");
+        expect(spawnSyncSpy).toHaveBeenCalledTimes(2);
+    });
+    test("throws when latestVersion is empty and force is used", async () => {
+        await expect(performUpgrade({
+            currentVersion: "0.0.13",
+            latestVersion: "",
+            updateAvailable: false,
+            installMethod: "binary",
+        }, { force: true })).rejects.toThrow("Unable to determine latest version");
+    });
+    // Note: tests for the binary install path (installMethod: "binary") that test
+    // checksum verification must avoid actually reaching the filesystem write step,
+    // which would overwrite the running bun binary. We mock the download to return
+    // a non-OK status after the checksum check fails, so the code throws before
+    // trying to write to disk.
+    test("blocks upgrade when checksum URL returns 404 (default)", async () => {
+        mockFetch((url) => {
+            if (url.includes("checksums.txt"))
+                return new Response("", { status: 404, statusText: "Not Found" });
+            // Use a non-OK download response so the code throws before reaching the write step
+            return new Response("", { status: 500 });
+        });
+        // The binary download fails first (500), but if checksum fetch is tried before
+        // binary download, it should throw a checksum error.
+        const spawnSyncSpy = spyOn(childProcess, "spawnSync").mockReturnValue({
+            status: 0,
+            stdout: "",
+            stderr: "",
+        });
+        await expect(performUpgrade({
+            currentVersion: "0.0.13",
+            latestVersion: "0.0.14",
+            updateAvailable: true,
+            installMethod: "npm",
+        }, { skipPostUpgrade: true })).resolves.toMatchObject({ upgraded: true, installMethod: "npm" });
+        // Only the install spawnSync ran; skipPostUpgrade keeps the test focused
+        // on the checksum-bypass behavior, not the new post-upgrade hook.
+        expect(spawnSyncSpy).toHaveBeenCalledTimes(1);
+    });
+    test("checksum URL 404 throws Checksum verification failed for binary install", async () => {
+        // Use a mock that: binary download succeeds, checksum returns 404.
+        // IMPORTANT: We ensure the test does NOT write to disk by making the checksum
+        // step fail first (it runs after binary download).
+        mockFetch((url) => {
+            if (url.includes("checksums.txt"))
+                return new Response("", { status: 404 });
+            // Fake binary download — must succeed for checksum check to be reached
+            return new Response(new Uint8Array(100), { status: 200 });
+        });
+        await expect(performUpgrade({
+            currentVersion: "0.0.13",
+            latestVersion: "0.0.14",
+            updateAvailable: true,
+            installMethod: "binary",
+        })).rejects.toThrow(/Checksum verification failed/);
+    });
+    test("skipChecksum: true option is accepted by performUpgrade (npm path)", async () => {
+        const spawnSyncSpy = spyOn(childProcess, "spawnSync").mockReturnValue({
+            status: 0,
+            stdout: "",
+            stderr: "",
+        });
+        const result = await performUpgrade({
+            currentVersion: "0.0.13",
+            latestVersion: "0.0.14",
+            updateAvailable: true,
+            installMethod: "npm",
+        }, { skipChecksum: true, skipPostUpgrade: true });
+        // Only the install spawnSync ran; skipPostUpgrade keeps the test focused
+        // on the skipChecksum option, not the new post-upgrade hook.
+        expect(spawnSyncSpy).toHaveBeenCalledTimes(1);
+        expect(result.upgraded).toBe(true);
+        expect(result.installMethod).toBe("npm");
+    });
+    test("blocks upgrade when binary name not in checksums.txt (default)", async () => {
+        const binaryName = getAkmBinaryName();
+        mockFetch((url) => {
+            if (url.includes("checksums.txt")) {
+                // Valid checksums format but does NOT include the current binary name
+                return new Response(`${"a".repeat(64)}  other-binary\n${"b".repeat(64)}  another-binary\n`, { status: 200 });
+            }
+            return new Response(new Uint8Array(100), { status: 200 });
+        });
+        await expect(performUpgrade({
+            currentVersion: "0.0.13",
+            latestVersion: "0.0.14",
+            updateAvailable: true,
+            installMethod: "binary",
+        })).rejects.toThrow(new RegExp(`${binaryName.replace(".", "\\.")}.*not listed|Checksum verification failed`));
+    });
+    test("blocks upgrade on checksum mismatch (default)", async () => {
+        const binaryName = getAkmBinaryName();
+        const wrongHash = "0".repeat(64);
+        mockFetch((url) => {
+            if (url.includes("checksums.txt")) {
+                return new Response(`${wrongHash}  ${binaryName}\n`, { status: 200 });
+            }
+            // Return binary content that will NOT match the all-zeros hash
+            return new Response(new Uint8Array(Array.from({ length: 100 }, (_, i) => i % 256)), { status: 200 });
+        });
+        await expect(performUpgrade({
+            currentVersion: "0.0.13",
+            latestVersion: "0.0.14",
+            updateAvailable: true,
+            installMethod: "binary",
+        })).rejects.toThrow(/Checksum mismatch/);
+    });
+});
+describe("getPackageManagerUpgradeCommand", () => {
+    test("returns npm install command", () => {
+        expect(getPackageManagerUpgradeCommand("npm", "akm-cli")).toEqual({
+            command: expect.stringContaining("npm"),
+            args: ["install", "-g", "akm-cli@latest"],
+            displayCommand: "npm install -g akm-cli@latest",
+        });
+    });
+    test("returns bun install command", () => {
+        expect(getPackageManagerUpgradeCommand("bun", "akm-cli")).toEqual({
+            command: expect.stringContaining("bun"),
+            args: ["install", "-g", "akm-cli@latest"],
+            displayCommand: "bun install -g akm-cli@latest",
+        });
+    });
+    test("returns pnpm add command", () => {
+        expect(getPackageManagerUpgradeCommand("pnpm", "akm-cli")).toEqual({
+            command: expect.stringContaining("pnpm"),
+            args: ["add", "-g", "akm-cli@latest"],
+            displayCommand: "pnpm add -g akm-cli@latest",
+        });
+    });
+    test("returns undefined for non-package-manager installs", () => {
+        expect(getPackageManagerUpgradeCommand("binary", "akm-cli")).toBeUndefined();
+        expect(getPackageManagerUpgradeCommand("unknown", "akm-cli")).toBeUndefined();
+    });
+});