@vellumai/cli 0.8.6 → 0.8.7-dev.202606052135.3e62c5a

package/src/__tests__/flags.test.ts

@@ -0,0 +1,248 @@
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  spyOn,
+  test,
+} from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { type AssistantEntry } from "../lib/assistant-config.js";
+import { flags } from "../commands/flags.js";
+
+const testDir = mkdtempSync(join(tmpdir(), "cli-flags-test-"));
+const originalArgv = [...process.argv];
+const originalExit = process.exit;
+const originalFetch = globalThis.fetch;
+const originalLockfileDir = process.env.VELLUM_LOCKFILE_DIR;
+
+let consoleLogSpy: ReturnType<typeof spyOn>;
+let consoleErrorSpy: ReturnType<typeof spyOn>;
+let fetchCalls: Array<{ url: string; method: string }>;
+
+function makeEntry(
+  assistantId: string,
+  extra: Partial<AssistantEntry> = {},
+): AssistantEntry {
+  return {
+    assistantId,
+    runtimeUrl: `http://127.0.0.1:${7800 + assistantId.length}`,
+    cloud: "local",
+    ...extra,
+  };
+}
+
+function writeLockfile(
+  entries: AssistantEntry[],
+  activeAssistant?: string,
+): void {
+  mkdirSync(testDir, { recursive: true });
+  writeFileSync(
+    join(testDir, ".vellum.lock.json"),
+    JSON.stringify(
+      {
+        assistants: entries,
+        ...(activeAssistant ? { activeAssistant } : {}),
+      },
+      null,
+      2,
+    ),
+  );
+}
+
+/**
+ * Build a Response stub that callers shape per subcommand. `setFlag` needs
+ * a 200 OK with the gateway's updated flag payload; `getFlag`/`listFlags`
+ * need a flag list. Body content is the minimal valid shape — the tests
+ * exercise URL routing, not response parsing.
+ */
+function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json" },
+  });
+}
+
+describe("vellum flags --assistant routing", () => {
+  beforeEach(() => {
+    process.env.VELLUM_LOCKFILE_DIR = testDir;
+    rmSync(join(testDir, ".vellum.lock.json"), { force: true });
+    fetchCalls = [];
+    // Capture every outgoing fetch and respond with a stub matching the
+    // subcommand's expected shape. The URL is what the test asserts on.
+    globalThis.fetch = (async (
+      input: RequestInfo | URL,
+      init?: RequestInit,
+    ) => {
+      const url = typeof input === "string" ? input : input.toString();
+      const method = init?.method ?? "GET";
+      fetchCalls.push({ url, method });
+      if (method === "PATCH") {
+        return jsonResponse({
+          key: "external-plugins",
+          enabled: true,
+          defaultEnabled: false,
+          label: "External Plugins",
+          description: "test",
+        });
+      }
+      return jsonResponse({ flags: [] });
+    }) as typeof globalThis.fetch;
+    process.exit = ((code?: number) => {
+      throw new Error(`process.exit:${code}`);
+    }) as typeof process.exit;
+    consoleLogSpy = spyOn(console, "log").mockImplementation(() => {});
+    consoleErrorSpy = spyOn(console, "error").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    process.argv = originalArgv;
+    process.exit = originalExit;
+    globalThis.fetch = originalFetch;
+    consoleLogSpy.mockRestore();
+    consoleErrorSpy.mockRestore();
+  });
+
+  afterAll(() => {
+    if (originalLockfileDir === undefined) {
+      delete process.env.VELLUM_LOCKFILE_DIR;
+    } else {
+      process.env.VELLUM_LOCKFILE_DIR = originalLockfileDir;
+    }
+    rmSync(testDir, { recursive: true, force: true });
+  });
+
+  test("set --assistant <id> routes to the explicit instance's runtime URL, not the active one", async () => {
+    // Two assistants on different ports. The active one is "alice"; the
+    // explicit --assistant target is "bob". A correct routing impl hits
+    // bob's URL — a regression that silently uses the active assistant
+    // would hit alice's URL.
+    writeLockfile(
+      [
+        makeEntry("alice-1", { name: "Alice" }),
+        makeEntry("bob-2", { name: "Bob" }),
+      ],
+      "alice-1",
+    );
+    process.argv = [
+      "bun",
+      "vellum",
+      "flags",
+      "set",
+      "external-plugins",
+      "true",
+      "--assistant",
+      "Bob",
+    ];
+
+    await flags();
+
+    expect(fetchCalls.length).toBe(1);
+    expect(fetchCalls[0].method).toBe("PATCH");
+    // bob-2 has assistantId.length === 5, so port = 7800 + 5 = 7805.
+    expect(fetchCalls[0].url).toContain("http://127.0.0.1:7805");
+    expect(fetchCalls[0].url).toContain(
+      "/v1/assistants/bob-2/feature-flags/external-plugins",
+    );
+  });
+
+  test("set --assistant <id> placed BEFORE positional args still parses correctly", async () => {
+    // Eval harness composes `vellum flags set <key> <value> --assistant <id>`
+    // but human users might write `--assistant <id> set <key> <value>`.
+    // The extractor strips --assistant from anywhere in argv so positional
+    // parsing downstream sees the same shape either way.
+    writeLockfile([
+      makeEntry("alice-1", { name: "Alice" }),
+      makeEntry("bob-2", { name: "Bob" }),
+    ]);
+    process.argv = [
+      "bun",
+      "vellum",
+      "flags",
+      "--assistant",
+      "Bob",
+      "set",
+      "external-plugins",
+      "true",
+    ];
+
+    await flags();
+
+    expect(fetchCalls.length).toBe(1);
+    expect(fetchCalls[0].url).toContain(
+      "/v1/assistants/bob-2/feature-flags/external-plugins",
+    );
+  });
+
+  test("set without --assistant uses the active assistant", async () => {
+    // Backwards-compat: behavior unchanged for invocations that don't
+    // pass --assistant. The active assistant ("alice-1") wins.
+    writeLockfile(
+      [
+        makeEntry("alice-1", { name: "Alice" }),
+        makeEntry("bob-2", { name: "Bob" }),
+      ],
+      "alice-1",
+    );
+    process.argv = [
+      "bun",
+      "vellum",
+      "flags",
+      "set",
+      "external-plugins",
+      "true",
+    ];
+
+    await flags();
+
+    expect(fetchCalls.length).toBe(1);
+    // alice-1 has assistantId.length === 7, so port = 7800 + 7 = 7807.
+    expect(fetchCalls[0].url).toContain("http://127.0.0.1:7807");
+    expect(fetchCalls[0].url).toContain(
+      "/v1/assistants/alice-1/feature-flags/external-plugins",
+    );
+  });
+
+  test("set --assistant <name> exits with a lookup error when no assistant matches", async () => {
+    writeLockfile([makeEntry("alice-1", { name: "Alice" })]);
+    process.argv = [
+      "bun",
+      "vellum",
+      "flags",
+      "set",
+      "external-plugins",
+      "true",
+      "--assistant",
+      "Ghost",
+    ];
+
+    // The Error thrown by createClient propagates out of flags().
+    // No fetch should ever fire because lookup fails before the
+    // AssistantClient is constructed.
+    await expect(flags()).rejects.toThrow(/Ghost/);
+    expect(fetchCalls.length).toBe(0);
+  });
+
+  test("--assistant without a value exits via the explicit missing-value branch", async () => {
+    writeLockfile([makeEntry("alice-1", { name: "Alice" })]);
+    process.argv = [
+      "bun",
+      "vellum",
+      "flags",
+      "set",
+      "external-plugins",
+      "true",
+      "--assistant",
+    ];
+
+    await expect(flags()).rejects.toThrow(/process\.exit:1/);
+    expect(consoleErrorSpy.mock.calls.flat().join("\n")).toContain(
+      "Missing value for --assistant <name>",
+    );
+    expect(fetchCalls.length).toBe(0);
+  });
+});

package/src/__tests__/guardian-token.test.ts

@@ -1,11 +1,20 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  utimesSync,
+  writeFileSync,
+} from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 
 import {
   getOrCreatePersistedDeviceId,
   loadGuardianToken,
+  refreshGuardianToken,
   saveGuardianToken,
   seedGuardianTokenFromSiblingEnv,
   type GuardianTokenData,
@@ -223,3 +232,118 @@ describe("guardian-token paths are env-scoped", () => {
     );
   });
 });
+
+describe("refreshGuardianToken", () => {
+  let tempHome: string;
+  let savedXdg: string | undefined;
+  let savedEnv: string | undefined;
+  const ORIGINAL_FETCH = globalThis.fetch;
+
+  const future = () => new Date(Date.now() + 60 * 60 * 1000).toISOString();
+
+  function lockPath(id: string): string {
+    return join(tempHome, "vellum", "assistants", id, "refresh.lock");
+  }
+
+  function seed(refreshExpiresAt: string | number): void {
+    saveGuardianToken("px", {
+      guardianPrincipalId: "imported",
+      accessToken: "old-acc",
+      accessTokenExpiresAt: future(),
+      refreshToken: "old-ref",
+      refreshTokenExpiresAt: refreshExpiresAt,
+      refreshAfter: "",
+      isNew: false,
+      deviceId: "dev",
+      leasedAt: new Date().toISOString(),
+    });
+  }
+
+  beforeEach(() => {
+    savedXdg = process.env.XDG_CONFIG_HOME;
+    savedEnv = process.env.VELLUM_ENVIRONMENT;
+    tempHome = mkdtempSync(join(tmpdir(), "cli-refresh-test-"));
+    process.env.XDG_CONFIG_HOME = tempHome;
+    delete process.env.VELLUM_ENVIRONMENT;
+  });
+
+  afterEach(() => {
+    globalThis.fetch = ORIGINAL_FETCH;
+    if (savedXdg === undefined) delete process.env.XDG_CONFIG_HOME;
+    else process.env.XDG_CONFIG_HOME = savedXdg;
+    if (savedEnv === undefined) delete process.env.VELLUM_ENVIRONMENT;
+    else process.env.VELLUM_ENVIRONMENT = savedEnv;
+    rmSync(tempHome, { recursive: true, force: true });
+  });
+
+  test("refreshes, persists the rotated token, sends an abort signal, releases the lock", async () => {
+    seed(future());
+    let sawSignal = false;
+    globalThis.fetch = (async (_url: unknown, init?: RequestInit) => {
+      sawSignal = init?.signal instanceof AbortSignal;
+      return new Response(
+        JSON.stringify({
+          accessToken: "new-acc",
+          refreshToken: "new-ref",
+          accessTokenExpiresAt: future(),
+          refreshTokenExpiresAt: future(),
+          refreshAfter: "",
+        }),
+        { status: 200, headers: { "content-type": "application/json" } },
+      );
+    }) as typeof fetch;
+
+    const result = await refreshGuardianToken("http://10.0.0.9:7830", "px");
+
+    expect(result?.accessToken).toBe("new-acc");
+    expect(loadGuardianToken("px")?.accessToken).toBe("new-acc");
+    expect(sawSignal).toBe(true); // fetch carries a timeout AbortSignal
+    expect(existsSync(lockPath("px"))).toBe(false); // lock released
+  });
+
+  test("returns null without calling the gateway when the refresh token is expired", async () => {
+    seed(new Date(Date.now() - 1000).toISOString());
+    let called = false;
+    globalThis.fetch = (async (_url: unknown, _init?: RequestInit) => {
+      called = true;
+      return new Response("", { status: 200 });
+    }) as typeof fetch;
+
+    expect(await refreshGuardianToken("http://10.0.0.9:7830", "px")).toBeNull();
+    expect(called).toBe(false);
+  });
+
+  test("returns null when there is no stored token", async () => {
+    let called = false;
+    globalThis.fetch = (async (_url: unknown, _init?: RequestInit) => {
+      called = true;
+      return new Response("", { status: 200 });
+    }) as typeof fetch;
+
+    expect(
+      await refreshGuardianToken("http://10.0.0.9:7830", "missing"),
+    ).toBeNull();
+    expect(called).toBe(false);
+  });
+
+  test("steals a stale lock and still refreshes", async () => {
+    seed(future());
+    // Pre-create a stale lock (mtime well in the past) as if a crashed holder
+    // left it behind; the refresh must steal it rather than block.
+    const lp = lockPath("px");
+    mkdirSync(dirname(lp), { recursive: true });
+    writeFileSync(lp, "99999");
+    const old = new Date(Date.now() - 60_000);
+    utimesSync(lp, old, old);
+
+    globalThis.fetch = (async (_url: unknown, _init?: RequestInit) =>
+      new Response(JSON.stringify({ accessToken: "new-acc" }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      })) as typeof fetch;
+
+    const result = await refreshGuardianToken("http://10.0.0.9:7830", "px");
+    expect(result?.accessToken).toBe("new-acc");
+    expect(existsSync(lp)).toBe(false); // stolen lock cleaned up after release
+  });
+});

package/src/__tests__/multi-local.test.ts

@@ -156,7 +156,7 @@ describe("multi-local", () => {
 
     test("allocation picks env-specific port bases for non-prod envs", async () => {
       // Each non-prod env sits in its own 1000-port window (see
-      // environments/seeds.ts). Hatching under VELLUM_ENVIRONMENT=dev should
+      // @vellumai/environments seeds). Hatching under VELLUM_ENVIRONMENT=dev should
       // produce ports in the dev block (18000+), not the production defaults.
       const prevEnv = process.env.VELLUM_ENVIRONMENT;
       const prevXdg = process.env.XDG_DATA_HOME;

package/src/__tests__/orphan-detection.test.ts

@@ -3,6 +3,8 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
+import type { EnvironmentDefinition } from "@vellumai/environments";
+
 // Point lockfile operations at a temp directory before importing anything that
 // would otherwise resolve real on-host paths.
 const testDir = mkdtempSync(join(tmpdir(), "cli-orphan-detection-test-"));
@@ -16,7 +18,6 @@ import {
   loadAllAssistantsAcrossEnvs,
   type AssistantEntry,
 } from "../lib/assistant-config.js";
-import type { EnvironmentDefinition } from "../lib/environments/types.js";
 
 afterAll(() => {
   rmSync(testDir, { recursive: true, force: true });
@@ -74,11 +75,12 @@ describe("getKnownPidsFromAssistants", () => {
   });
 
   test("collects daemon, gateway, qdrant, and embed-worker PIDs", () => {
-    const entry = makeLocalEntry(
-      "alpha",
-      join(perTestDir, "alpha"),
-      { daemon: "100", gateway: "200", qdrant: "300", embed: "400" },
-    );
+    const entry = makeLocalEntry("alpha", join(perTestDir, "alpha"), {
+      daemon: "100",
+      gateway: "200",
+      qdrant: "300",
+      embed: "400",
+    });
     const pids = getKnownPidsFromAssistants([entry]);
     expect(pids).toEqual(new Set(["100", "200", "300", "400"]));
   });

package/src/__tests__/pair.test.ts

@@ -0,0 +1,271 @@
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  spyOn,
+  test,
+} from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// Real assistant-config reads the lockfile from VELLUM_LOCKFILE_DIR.
+const testDir = mkdtempSync(join(tmpdir(), "pair-command-test-"));
+process.env.VELLUM_LOCKFILE_DIR = testDir;
+
+import { pair } from "../commands/pair.js";
+
+// Distinct loopback (mint) vs reachable (advertised) URLs to verify the split.
+const LOCAL_URL = "http://127.0.0.1:7830";
+const RUNTIME_URL = "http://192.168.1.50:7830";
+
+function writeLockfile(): void {
+  writeFileSync(
+    join(testDir, ".vellum.lock.json"),
+    JSON.stringify({
+      assistants: [
+        {
+          assistantId: "pair-test",
+          runtimeUrl: RUNTIME_URL,
+          localUrl: LOCAL_URL,
+          cloud: "local",
+        },
+      ],
+      activeAssistant: "pair-test",
+    }),
+  );
+}
+
+// Capture the real argv ONCE, before any test mutates it, and restore after
+// every test — so a `['bun','vellum','pair',...]` argv can't leak into other
+// test files in the same Bun run.
+const ORIGINAL_ARGV = [...process.argv];
+
+describe("pair command", () => {
+  beforeEach(() => {
+    writeLockfile();
+  });
+
+  afterEach(() => {
+    process.argv = [...ORIGINAL_ARGV];
+  });
+
+  afterAll(() => {
+    rmSync(testDir, { recursive: true, force: true });
+    delete process.env.VELLUM_LOCKFILE_DIR;
+  });
+
+  test("POSTs a cli device-bound pair request and prints a decodable bundle", async () => {
+    const calls: Array<[string, RequestInit]> = [];
+    const origFetch = globalThis.fetch;
+    globalThis.fetch = (async (url: string, init: RequestInit) => {
+      calls.push([url, init]);
+      return new Response(
+        JSON.stringify({
+          token: "test-access-token",
+          expiresAt: "2026-06-04T00:00:00.000Z",
+          guardianId: "guardian-001",
+          assistantId: "self",
+        }),
+        { status: 200, headers: { "content-type": "application/json" } },
+      );
+    }) as unknown as typeof fetch;
+
+    const logs: string[] = [];
+    const logSpy = spyOn(console, "log").mockImplementation(
+      (...a: unknown[]) => {
+        logs.push(a.join(" "));
+      },
+    );
+
+    process.argv = ["bun", "vellum", "pair", "--json"];
+    try {
+      await pair();
+    } finally {
+      logSpy.mockRestore();
+      globalThis.fetch = origFetch;
+    }
+
+    // Mint over the loopback (localUrl), not the reachable runtime URL.
+    expect(calls).toHaveLength(1);
+    const [url, init] = calls[0];
+    expect(url).toBe(`${LOCAL_URL}/v1/pair`);
+    expect(init.method).toBe("POST");
+    const headers = Object.fromEntries(
+      Object.entries(init.headers as Record<string, string>).map(([k, v]) => [
+        k.toLowerCase(),
+        v,
+      ]),
+    );
+    expect(headers["x-vellum-interface-id"]).toBe("cli");
+    const body = JSON.parse(init.body as string);
+    expect(typeof body.deviceId).toBe("string");
+    expect(body.deviceId.length).toBeGreaterThan(0);
+    expect(body.platform).toBe("cli");
+
+    // The bundle advertises the REACHABLE runtime URL, not loopback.
+    const out = JSON.parse(logs.join("\n"));
+    expect(out.gatewayUrl).toBe(RUNTIME_URL);
+    expect(out.assistantId).toBe("self");
+    expect(out.token).toBe("test-access-token");
+    expect(out.deviceId).toBe(body.deviceId);
+  });
+
+  test("resolves an unquoted multi-word display name", async () => {
+    // Assistant whose display name has a space; passed as separate argv tokens.
+    writeFileSync(
+      join(testDir, ".vellum.lock.json"),
+      JSON.stringify({
+        assistants: [
+          {
+            assistantId: "pair-test",
+            name: "My Assistant",
+            runtimeUrl: RUNTIME_URL,
+            localUrl: LOCAL_URL,
+            cloud: "local",
+          },
+        ],
+        activeAssistant: "pair-test",
+      }),
+    );
+
+    let fetchCalled = false;
+    const origFetch = globalThis.fetch;
+    globalThis.fetch = (async () => {
+      fetchCalled = true;
+      return new Response(
+        JSON.stringify({
+          token: "t",
+          expiresAt: "2026-06-04T00:00:00.000Z",
+          guardianId: "g",
+          assistantId: "self",
+        }),
+        { status: 200, headers: { "content-type": "application/json" } },
+      );
+    }) as unknown as typeof fetch;
+    const logSpy = spyOn(console, "log").mockImplementation(() => {});
+
+    process.argv = ["bun", "vellum", "pair", "My", "Assistant", "--json"];
+    try {
+      await pair();
+    } finally {
+      logSpy.mockRestore();
+      globalThis.fetch = origFetch;
+    }
+
+    // Resolution succeeded (no exit), so the mint request was made.
+    expect(fetchCalled).toBe(true);
+  });
+
+  test("refuses to advertise a loopback URL without --url (suggests the assistant's own port)", async () => {
+    // Local hatch on a NON-default gateway port (e.g. a 2nd instance).
+    const LOOPBACK_CUSTOM = "http://127.0.0.1:7842";
+    writeFileSync(
+      join(testDir, ".vellum.lock.json"),
+      JSON.stringify({
+        assistants: [
+          {
+            assistantId: "pair-test",
+            runtimeUrl: LOOPBACK_CUSTOM,
+            localUrl: LOOPBACK_CUSTOM,
+            cloud: "local",
+          },
+        ],
+        activeAssistant: "pair-test",
+      }),
+    );
+
+    let fetchCalled = false;
+    const origFetch = globalThis.fetch;
+    globalThis.fetch = (async () => {
+      fetchCalled = true;
+      return new Response("{}", { status: 200 });
+    }) as unknown as typeof fetch;
+    const errors: string[] = [];
+    const errSpy = spyOn(console, "error").mockImplementation(
+      (...a: unknown[]) => {
+        errors.push(a.join(" "));
+      },
+    );
+    const exitSpy = spyOn(process, "exit").mockImplementation(((
+      code?: number,
+    ) => {
+      throw new Error(`exit:${code}`);
+    }) as never);
+
+    process.argv = ["bun", "vellum", "pair"];
+    let exited = false;
+    try {
+      await pair();
+    } catch (e) {
+      exited = (e as Error).message === "exit:1";
+    } finally {
+      errSpy.mockRestore();
+      exitSpy.mockRestore();
+      globalThis.fetch = origFetch;
+    }
+
+    // The suggested --url uses the assistant's actual port, not the default.
+    expect(errors.join("\n")).toContain(":7842");
+    expect(errors.join("\n")).not.toContain(":7830");
+
+    // Exited with an error before minting — no token created for a dead URL.
+    expect(exited).toBe(true);
+    expect(fetchCalled).toBe(false);
+  });
+
+  test("--url override allows pairing even when the runtime URL is loopback", async () => {
+    writeFileSync(
+      join(testDir, ".vellum.lock.json"),
+      JSON.stringify({
+        assistants: [
+          {
+            assistantId: "pair-test",
+            runtimeUrl: LOCAL_URL,
+            localUrl: LOCAL_URL,
+            cloud: "local",
+          },
+        ],
+        activeAssistant: "pair-test",
+      }),
+    );
+
+    const calls: Array<[string, RequestInit]> = [];
+    const origFetch = globalThis.fetch;
+    globalThis.fetch = (async (url: string, init: RequestInit) => {
+      calls.push([url, init]);
+      return new Response(
+        JSON.stringify({
+          token: "t",
+          expiresAt: "2026-06-04T00:00:00.000Z",
+          guardianId: "g",
+          assistantId: "self",
+        }),
+        { status: 200, headers: { "content-type": "application/json" } },
+      );
+    }) as unknown as typeof fetch;
+    const logs: string[] = [];
+    const logSpy = spyOn(console, "log").mockImplementation(
+      (...a: unknown[]) => {
+        logs.push(a.join(" "));
+      },
+    );
+
+    const OVERRIDE = "https://abc123.ngrok.app";
+    process.argv = ["bun", "vellum", "pair", "--url", OVERRIDE, "--json"];
+    try {
+      await pair();
+    } finally {
+      logSpy.mockRestore();
+      globalThis.fetch = origFetch;
+    }
+
+    // Mint still over loopback; bundle advertises the override.
+    expect(calls).toHaveLength(1);
+    expect(calls[0][0]).toBe(`${LOCAL_URL}/v1/pair`);
+    const out = JSON.parse(logs.join("\n"));
+    expect(out.gatewayUrl).toBe(OVERRIDE);
+  });
+});