@meshxdata/fops 0.0.1 → 0.0.3

package/src/config.test.js

@@ -1,70 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import os from "node:os";
-import { PKG, CLI_BRAND, printFoundationBanner } from "./config.js";
-
-describe("config", () => {
-  describe("PKG", () => {
-    it("exports name and version", () => {
-      expect(PKG.name).toBe("@meshxdata/fops");
-      expect(typeof PKG.version).toBe("string");
-      expect(PKG.version).toMatch(/^\d+\.\d+\.\d+/);
-    });
-
-    it("only exposes name and version (no extra fields)", () => {
-      expect(Object.keys(PKG).sort()).toEqual(["name", "version"]);
-    });
-  });
-
-  describe("CLI_BRAND", () => {
-    it("has the expected shape", () => {
-      expect(CLI_BRAND.title).toBe("Foundation Operator CLI");
-      expect(CLI_BRAND.version).toMatch(/^v\d+/);
-      expect(CLI_BRAND.byline).toContain("meshx");
-    });
-
-    it("version matches PKG.version", () => {
-      expect(CLI_BRAND.version).toBe(`v${PKG.version}`);
-    });
-  });
-
-  describe("printFoundationBanner", () => {
-    it("prints CLI info to stdout", () => {
-      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
-      printFoundationBanner("/tmp/test-project");
-      expect(spy).toHaveBeenCalled();
-      const output = spy.mock.calls.map((c) => c[0]).join("\n");
-      expect(output).toContain("Foundation Operator CLI");
-    });
-
-    it("shortens home dir to ~", () => {
-      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
-      const home = os.homedir();
-      printFoundationBanner(home + "/projects/test");
-      const output = spy.mock.calls.map((c) => c[0]).join("\n");
-      expect(output).toContain("~/projects/test");
-    });
-
-    it("does not replace ~ when path is not under homedir", () => {
-      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
-      printFoundationBanner("/opt/data/project");
-      const output = spy.mock.calls.map((c) => c[0]).join("\n");
-      expect(output).toContain("/opt/data/project");
-      expect(output).not.toContain("~");
-    });
-
-    it("prints version and byline", () => {
-      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
-      printFoundationBanner("/tmp");
-      const output = spy.mock.calls.map((c) => c[0]).join("\n");
-      expect(output).toContain(CLI_BRAND.version);
-      expect(output).toContain("meshx");
-    });
-
-    it("prints a trailing blank line", () => {
-      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
-      printFoundationBanner("/tmp");
-      // Last call should be empty string (blank line)
-      expect(spy.mock.calls[spy.mock.calls.length - 1][0]).toBe("");
-    });
-  });
-});

package/src/doctor.test.js

@@ -1,134 +0,0 @@
-import { describe, it, expect } from "vitest";
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const doctorSource = fs.readFileSync(path.join(__dirname, "doctor.js"), "utf8");
-
-// readNetrcToken is not exported, so we inline a copy for testing
-function readNetrcToken(content, machine) {
-  const lines = content.replace(/\r\n/g, "\n").split("\n");
-  let inMachine = false;
-  for (const line of lines) {
-    const tokens = line.trim().split(/\s+/);
-    for (let i = 0; i < tokens.length; i++) {
-      if (tokens[i] === "machine" && tokens[i + 1] === machine) {
-        inMachine = true;
-      } else if (tokens[i] === "machine" && tokens[i + 1] !== machine) {
-        if (inMachine) return null;
-      }
-      if (inMachine && tokens[i] === "password" && tokens[i + 1]) {
-        return tokens[i + 1];
-      }
-    }
-  }
-  return null;
-}
-
-describe("doctor", () => {
-  describe("readNetrcToken", () => {
-    it("returns token for multi-line netrc", () => {
-      const content = `machine github.com\nlogin user\npassword ghp_abc123\n`;
-      expect(readNetrcToken(content, "github.com")).toBe("ghp_abc123");
-    });
-
-    it("returns token for single-line netrc", () => {
-      const content = `machine github.com login user password ghp_abc123`;
-      expect(readNetrcToken(content, "github.com")).toBe("ghp_abc123");
-    });
-
-    it("returns null for wrong machine", () => {
-      const content = `machine gitlab.com\nlogin user\npassword glpat_xyz\n`;
-      expect(readNetrcToken(content, "github.com")).toBe(null);
-    });
-
-    it("returns null for missing password", () => {
-      const content = `machine github.com\nlogin user\n`;
-      expect(readNetrcToken(content, "github.com")).toBe(null);
-    });
-
-    it("handles multiple machines", () => {
-      const content = [
-        "machine gitlab.com login a password glpat_xyz",
-        "machine github.com login b password ghp_123",
-      ].join("\n");
-      expect(readNetrcToken(content, "github.com")).toBe("ghp_123");
-      expect(readNetrcToken(content, "gitlab.com")).toBe("glpat_xyz");
-    });
-
-    it("stops at next machine block", () => {
-      const content = [
-        "machine github.com",
-        "login user",
-        "machine other.com",
-        "password secret",
-      ].join("\n");
-      expect(readNetrcToken(content, "github.com")).toBe(null);
-    });
-
-    it("handles windows line endings", () => {
-      const content = "machine github.com\r\nlogin user\r\npassword ghp_win\r\n";
-      expect(readNetrcToken(content, "github.com")).toBe("ghp_win");
-    });
-
-    it("handles empty content", () => {
-      expect(readNetrcToken("", "github.com")).toBe(null);
-    });
-
-    it("handles whitespace-only content", () => {
-      expect(readNetrcToken("   \n  \n  ", "github.com")).toBe(null);
-    });
-
-    it("handles machine with no following tokens", () => {
-      const content = "machine\ngithub.com\npassword ghp_123";
-      // "machine" without immediate next token matching
-      expect(readNetrcToken(content, "github.com")).toBe(null);
-    });
-
-    it("handles mixed multi-line and single-line entries", () => {
-      const content = [
-        "machine gitlab.com login gl password glpat_abc",
-        "",
-        "machine github.com",
-        "login gh",
-        "password ghp_xyz",
-      ].join("\n");
-      expect(readNetrcToken(content, "github.com")).toBe("ghp_xyz");
-      expect(readNetrcToken(content, "gitlab.com")).toBe("glpat_abc");
-    });
-
-    it("returns first password for a machine", () => {
-      const content = "machine github.com login user password first_token";
-      expect(readNetrcToken(content, "github.com")).toBe("first_token");
-    });
-  });
-
-  describe("KEY_PORTS", () => {
-    it("defines all expected ports", () => {
-      expect(doctorSource).toContain("5432");
-      expect(doctorSource).toContain("Postgres");
-      expect(doctorSource).toContain("9092");
-      expect(doctorSource).toContain("Kafka");
-      expect(doctorSource).toContain("9001");
-      expect(doctorSource).toContain("Backend");
-      expect(doctorSource).toContain("3002");
-      expect(doctorSource).toContain("Frontend");
-      expect(doctorSource).toContain("8081");
-      expect(doctorSource).toContain("Trino");
-      expect(doctorSource).toContain("9083");
-      expect(doctorSource).toContain("Hive Metastore");
-      expect(doctorSource).toContain("8181");
-      expect(doctorSource).toContain("OPA");
-      expect(doctorSource).toContain("18201");
-      expect(doctorSource).toContain("Vault");
-    });
-  });
-
-  describe("runDoctor export", () => {
-    it("is exported as a function", async () => {
-      const { runDoctor } = await import("./doctor.js");
-      expect(typeof runDoctor).toBe("function");
-    });
-  });
-});

package/src/plugins/api.test.js

@@ -1,95 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { createPluginApi } from "./api.js";
-import { createRegistry } from "./registry.js";
-
-describe("plugins/api", () => {
-  describe("createPluginApi", () => {
-    it("returns api with id and methods", () => {
-      const registry = createRegistry();
-      const api = createPluginApi("test-plugin", registry);
-      expect(api.id).toBe("test-plugin");
-      expect(typeof api.registerCommand).toBe("function");
-      expect(typeof api.registerDoctorCheck).toBe("function");
-      expect(typeof api.registerHook).toBe("function");
-    });
-
-    it("has config property (empty by default)", () => {
-      const registry = createRegistry();
-      const api = createPluginApi("test-plugin", registry);
-      expect(api.config).toEqual({});
-    });
-
-    it("registerCommand adds to registry.commands", () => {
-      const registry = createRegistry();
-      const api = createPluginApi("test-plugin", registry);
-      const spec = { name: "my-cmd", description: "A command" };
-      api.registerCommand(spec);
-      expect(registry.commands).toHaveLength(1);
-      expect(registry.commands[0]).toEqual({ pluginId: "test-plugin", spec });
-    });
-
-    it("registerCommand can add multiple commands", () => {
-      const registry = createRegistry();
-      const api = createPluginApi("test-plugin", registry);
-      api.registerCommand({ name: "cmd1" });
-      api.registerCommand({ name: "cmd2" });
-      api.registerCommand({ name: "cmd3" });
-      expect(registry.commands).toHaveLength(3);
-    });
-
-    it("registerDoctorCheck adds to registry.doctorChecks", () => {
-      const registry = createRegistry();
-      const api = createPluginApi("test-plugin", registry);
-      const fn = vi.fn();
-      api.registerDoctorCheck({ name: "check-foo", fn });
-      expect(registry.doctorChecks).toHaveLength(1);
-      expect(registry.doctorChecks[0].name).toBe("check-foo");
-      expect(registry.doctorChecks[0].fn).toBe(fn);
-      expect(registry.doctorChecks[0].pluginId).toBe("test-plugin");
-    });
-
-    it("registerHook adds to registry.hooks with default priority", () => {
-      const registry = createRegistry();
-      const api = createPluginApi("test-plugin", registry);
-      const handler = vi.fn();
-      api.registerHook("pre:up", handler);
-      expect(registry.hooks).toHaveLength(1);
-      expect(registry.hooks[0]).toEqual({
-        pluginId: "test-plugin",
-        event: "pre:up",
-        handler,
-        priority: 0,
-      });
-    });
-
-    it("registerHook respects custom priority", () => {
-      const registry = createRegistry();
-      const api = createPluginApi("test-plugin", registry);
-      const handler = vi.fn();
-      api.registerHook("post:up", handler, 10);
-      expect(registry.hooks[0].priority).toBe(10);
-    });
-
-    it("multiple plugins can register on same registry", () => {
-      const registry = createRegistry();
-      const api1 = createPluginApi("plugin-a", registry);
-      const api2 = createPluginApi("plugin-b", registry);
-      api1.registerCommand({ name: "cmd-a" });
-      api2.registerCommand({ name: "cmd-b" });
-      api1.registerHook("pre:up", vi.fn());
-      api2.registerHook("pre:up", vi.fn());
-      expect(registry.commands).toHaveLength(2);
-      expect(registry.hooks).toHaveLength(2);
-      expect(registry.commands[0].pluginId).toBe("plugin-a");
-      expect(registry.commands[1].pluginId).toBe("plugin-b");
-    });
-
-    it("registerDoctorCheck preserves fn reference", () => {
-      const registry = createRegistry();
-      const api = createPluginApi("test", registry);
-      const checkFn = async (ok, warn, fail) => { ok("test passed"); };
-      api.registerDoctorCheck({ name: "my-check", fn: checkFn });
-      expect(registry.doctorChecks[0].fn).toBe(checkFn);
-    });
-  });
-});

package/src/plugins/discovery.test.js

@@ -1,92 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-
-describe("plugins/discovery", () => {
-  let tmpHome;
-
-  beforeEach(() => {
-    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "fops-home-"));
-    vi.spyOn(os, "homedir").mockReturnValue(tmpHome);
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-    fs.rmSync(tmpHome, { recursive: true, force: true });
-  });
-
-  it("returns empty when no plugin dirs exist", async () => {
-    vi.resetModules();
-    const { discoverPlugins } = await import("./discovery.js");
-    const result = discoverPlugins();
-    const globalPlugins = result.filter((p) => p.source === "global");
-    expect(globalPlugins).toHaveLength(0);
-  });
-
-  it("discovers global plugins with fops.plugin.json", async () => {
-    const pluginDir = path.join(tmpHome, ".fops", "plugins", "my-plugin");
-    fs.mkdirSync(pluginDir, { recursive: true });
-    fs.writeFileSync(
-      path.join(pluginDir, "fops.plugin.json"),
-      JSON.stringify({ id: "my-plugin", name: "My Plugin", version: "1.0.0" })
-    );
-
-    vi.resetModules();
-    const { discoverPlugins } = await import("./discovery.js");
-    const result = discoverPlugins();
-    const globalPlugins = result.filter((p) => p.source === "global");
-    expect(globalPlugins).toHaveLength(1);
-    expect(globalPlugins[0].id).toBe("my-plugin");
-    expect(globalPlugins[0].path).toBe(pluginDir);
-    expect(globalPlugins[0].source).toBe("global");
-  });
-
-  it("skips global dirs without fops.plugin.json", async () => {
-    const pluginDir = path.join(tmpHome, ".fops", "plugins", "no-manifest");
-    fs.mkdirSync(pluginDir, { recursive: true });
-    fs.writeFileSync(path.join(pluginDir, "index.js"), "");
-
-    vi.resetModules();
-    const { discoverPlugins } = await import("./discovery.js");
-    const result = discoverPlugins();
-    const globalPlugins = result.filter((p) => p.source === "global");
-    expect(globalPlugins).toHaveLength(0);
-  });
-
-  it("discovers multiple global plugins", async () => {
-    for (const name of ["plugin-a", "plugin-b", "plugin-c"]) {
-      const dir = path.join(tmpHome, ".fops", "plugins", name);
-      fs.mkdirSync(dir, { recursive: true });
-      fs.writeFileSync(
-        path.join(dir, "fops.plugin.json"),
-        JSON.stringify({ id: name, name, version: "1.0.0" })
-      );
-    }
-
-    vi.resetModules();
-    const { discoverPlugins } = await import("./discovery.js");
-    const result = discoverPlugins();
-    const globalPlugins = result.filter((p) => p.source === "global");
-    expect(globalPlugins).toHaveLength(3);
-  });
-
-  it("skips files (non-directories) in plugins dir", async () => {
-    const pluginsDir = path.join(tmpHome, ".fops", "plugins");
-    fs.mkdirSync(pluginsDir, { recursive: true });
-    fs.writeFileSync(path.join(pluginsDir, "not-a-dir.txt"), "");
-
-    vi.resetModules();
-    const { discoverPlugins } = await import("./discovery.js");
-    const result = discoverPlugins();
-    const globalPlugins = result.filter((p) => p.source === "global");
-    expect(globalPlugins).toHaveLength(0);
-  });
-
-  it("returns array even when ~/.fops/plugins does not exist", async () => {
-    vi.resetModules();
-    const { discoverPlugins } = await import("./discovery.js");
-    const result = discoverPlugins();
-    expect(Array.isArray(result)).toBe(true);
-  });
-});

package/src/plugins/hooks.test.js

@@ -1,118 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { runHook } from "./hooks.js";
-
-describe("plugins/hooks", () => {
-  describe("runHook", () => {
-    it("runs matching handlers", async () => {
-      const handler = vi.fn();
-      const registry = {
-        hooks: [{ event: "pre:up", handler, priority: 0 }],
-      };
-      await runHook(registry, "pre:up", { root: "/project" });
-      expect(handler).toHaveBeenCalledWith({ root: "/project" });
-    });
-
-    it("skips non-matching events", async () => {
-      const handler = vi.fn();
-      const registry = {
-        hooks: [{ event: "pre:up", handler, priority: 0 }],
-      };
-      await runHook(registry, "post:up");
-      expect(handler).not.toHaveBeenCalled();
-    });
-
-    it("sorts by priority (higher first)", async () => {
-      const order = [];
-      const low = vi.fn(() => order.push("low"));
-      const high = vi.fn(() => order.push("high"));
-      const registry = {
-        hooks: [
-          { event: "pre:up", handler: low, priority: 1 },
-          { event: "pre:up", handler: high, priority: 10 },
-        ],
-      };
-      await runHook(registry, "pre:up");
-      expect(order).toEqual(["high", "low"]);
-    });
-
-    it("runs handlers sequentially (not parallel)", async () => {
-      const order = [];
-      const slow = vi.fn(async () => {
-        await new Promise((r) => setTimeout(r, 10));
-        order.push("slow");
-      });
-      const fast = vi.fn(() => order.push("fast"));
-      const registry = {
-        hooks: [
-          { event: "test", handler: slow, priority: 10 },
-          { event: "test", handler: fast, priority: 0 },
-        ],
-      };
-      await runHook(registry, "test");
-      expect(order).toEqual(["slow", "fast"]);
-    });
-
-    it("handles empty hooks array", async () => {
-      const registry = { hooks: [] };
-      await expect(runHook(registry, "pre:up")).resolves.toBeUndefined();
-    });
-
-    it("passes context to all handlers", async () => {
-      const h1 = vi.fn();
-      const h2 = vi.fn();
-      const ctx = { root: "/proj", extra: "data" };
-      const registry = {
-        hooks: [
-          { event: "test", handler: h1, priority: 0 },
-          { event: "test", handler: h2, priority: 0 },
-        ],
-      };
-      await runHook(registry, "test", ctx);
-      expect(h1).toHaveBeenCalledWith(ctx);
-      expect(h2).toHaveBeenCalledWith(ctx);
-    });
-
-    it("uses empty object as default context", async () => {
-      const handler = vi.fn();
-      const registry = {
-        hooks: [{ event: "test", handler, priority: 0 }],
-      };
-      await runHook(registry, "test");
-      expect(handler).toHaveBeenCalledWith({});
-    });
-
-    it("handles three priority levels correctly", async () => {
-      const order = [];
-      const registry = {
-        hooks: [
-          { event: "e", handler: () => order.push("med"), priority: 5 },
-          { event: "e", handler: () => order.push("low"), priority: 1 },
-          { event: "e", handler: () => order.push("high"), priority: 10 },
-        ],
-      };
-      await runHook(registry, "e");
-      expect(order).toEqual(["high", "med", "low"]);
-    });
-
-    it("only runs handlers for the exact event name", async () => {
-      const h1 = vi.fn();
-      const h2 = vi.fn();
-      const registry = {
-        hooks: [
-          { event: "pre:up", handler: h1, priority: 0 },
-          { event: "pre:down", handler: h2, priority: 0 },
-        ],
-      };
-      await runHook(registry, "pre:up");
-      expect(h1).toHaveBeenCalled();
-      expect(h2).not.toHaveBeenCalled();
-    });
-
-    it("handler errors propagate", async () => {
-      const registry = {
-        hooks: [{ event: "test", handler: () => { throw new Error("boom"); }, priority: 0 }],
-      };
-      await expect(runHook(registry, "test")).rejects.toThrow("boom");
-    });
-  });
-});

package/src/plugins/manifest.test.js

@@ -1,106 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { validateManifest } from "./manifest.js";
-
-describe("plugins/manifest", () => {
-  let tmpDir;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "fops-manifest-"));
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it("returns null when no fops.plugin.json exists", () => {
-    expect(validateManifest(tmpDir)).toBe(null);
-  });
-
-  it("returns null for invalid JSON", () => {
-    fs.writeFileSync(path.join(tmpDir, "fops.plugin.json"), "not json{{{");
-    expect(validateManifest(tmpDir)).toBe(null);
-  });
-
-  it("returns null when id is missing", () => {
-    fs.writeFileSync(
-      path.join(tmpDir, "fops.plugin.json"),
-      JSON.stringify({ name: "Test", version: "1.0.0" })
-    );
-    expect(validateManifest(tmpDir)).toBe(null);
-  });
-
-  it("returns null when name is missing", () => {
-    fs.writeFileSync(
-      path.join(tmpDir, "fops.plugin.json"),
-      JSON.stringify({ id: "test", version: "1.0.0" })
-    );
-    expect(validateManifest(tmpDir)).toBe(null);
-  });
-
-  it("returns null when version is missing", () => {
-    fs.writeFileSync(
-      path.join(tmpDir, "fops.plugin.json"),
-      JSON.stringify({ id: "test", name: "Test" })
-    );
-    expect(validateManifest(tmpDir)).toBe(null);
-  });
-
-  it("returns null when fields are not strings", () => {
-    fs.writeFileSync(
-      path.join(tmpDir, "fops.plugin.json"),
-      JSON.stringify({ id: "test", name: "Test", version: 1 })
-    );
-    expect(validateManifest(tmpDir)).toBe(null);
-  });
-
-  it("returns null when id is empty string", () => {
-    fs.writeFileSync(
-      path.join(tmpDir, "fops.plugin.json"),
-      JSON.stringify({ id: "", name: "Test", version: "1.0.0" })
-    );
-    expect(validateManifest(tmpDir)).toBe(null);
-  });
-
-  it("returns null when fields are numbers", () => {
-    fs.writeFileSync(
-      path.join(tmpDir, "fops.plugin.json"),
-      JSON.stringify({ id: 1, name: 2, version: 3 })
-    );
-    expect(validateManifest(tmpDir)).toBe(null);
-  });
-
-  it("returns manifest when all required fields present", () => {
-    const manifest = { id: "test-plugin", name: "Test Plugin", version: "1.0.0" };
-    fs.writeFileSync(path.join(tmpDir, "fops.plugin.json"), JSON.stringify(manifest));
-    const result = validateManifest(tmpDir);
-    expect(result).toEqual(manifest);
-  });
-
-  it("preserves extra fields in manifest", () => {
-    const manifest = {
-      id: "test-plugin",
-      name: "Test Plugin",
-      version: "1.0.0",
-      description: "A test",
-      author: "test",
-      skills: ["skills/foo"],
-    };
-    fs.writeFileSync(path.join(tmpDir, "fops.plugin.json"), JSON.stringify(manifest));
-    const result = validateManifest(tmpDir);
-    expect(result.description).toBe("A test");
-    expect(result.skills).toEqual(["skills/foo"]);
-  });
-
-  it("returns null for empty JSON object", () => {
-    fs.writeFileSync(path.join(tmpDir, "fops.plugin.json"), "{}");
-    expect(validateManifest(tmpDir)).toBe(null);
-  });
-
-  it("returns null for empty file", () => {
-    fs.writeFileSync(path.join(tmpDir, "fops.plugin.json"), "");
-    expect(validateManifest(tmpDir)).toBe(null);
-  });
-});

package/src/plugins/registry.test.js

@@ -1,43 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { createRegistry } from "./registry.js";
-
-describe("plugins/registry", () => {
-  describe("createRegistry", () => {
-    it("returns object with expected arrays", () => {
-      const reg = createRegistry();
-      expect(reg).toEqual({
-        plugins: [],
-        commands: [],
-        doctorChecks: [],
-        hooks: [],
-        skills: [],
-      });
-    });
-
-    it("creates independent instances", () => {
-      const a = createRegistry();
-      const b = createRegistry();
-      a.plugins.push({ id: "test" });
-      expect(b.plugins).toHaveLength(0);
-    });
-
-    it("all arrays are mutable", () => {
-      const reg = createRegistry();
-      reg.plugins.push({ id: "p1" });
-      reg.commands.push({ pluginId: "p1", spec: {} });
-      reg.doctorChecks.push({ pluginId: "p1", name: "check" });
-      reg.hooks.push({ pluginId: "p1", event: "test" });
-      reg.skills.push({ pluginId: "p1", name: "skill" });
-      expect(reg.plugins).toHaveLength(1);
-      expect(reg.commands).toHaveLength(1);
-      expect(reg.doctorChecks).toHaveLength(1);
-      expect(reg.hooks).toHaveLength(1);
-      expect(reg.skills).toHaveLength(1);
-    });
-
-    it("has exactly 5 keys", () => {
-      const reg = createRegistry();
-      expect(Object.keys(reg)).toHaveLength(5);
-    });
-  });
-});