@oneuptime/common 12.0.5 → 12.0.7

package/Tests/Server/Utils/InProcessMemo.test.ts

@@ -0,0 +1,292 @@
+import InProcessMemo from "../../../Server/Utils/InProcessMemo";
+import { describe, expect, jest, test, afterEach } from "@jest/globals";
+
+/*
+ * InProcessMemo is the L1 layer the telemetry ingest hot path now leans on
+ * in four places (autoDiscover entity ids, the maintenance-fence refusal
+ * memo, host resolution, resource retention). Its contract is small but
+ * every clause is load-bearing:
+ *
+ *   - a hit must be free and a miss must be honest (expired == absent),
+ *   - the map must stay bounded no matter what keys collectors invent,
+ *     because the keys come from collector-controlled resource attributes,
+ *   - eviction must be oldest-first so a hot steady-state working set is
+ *     not evicted by one burst of novel keys, and
+ *   - the clock must be steerable so the suites for the callers above can
+ *     prove their TTL behaviour without sleeping.
+ *
+ * A fixed injected clock is used for determinism everywhere except the
+ * lazy-Date.now test, which pins the property the module-level memos in
+ * production depend on: a jest Date.now spy installed AFTER construction
+ * must still steer the default clock.
+ */
+
+type Clock = { nowMs: number; now: () => number };
+
+function makeClock(startMs: number = 1_000_000): Clock {
+  const clock: Clock = {
+    nowMs: startMs,
+    now: (): number => {
+      return clock.nowMs;
+    },
+  };
+  return clock;
+}
+
+describe("InProcessMemo", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe("get / set", () => {
+    test("returns what was stored, within the TTL", () => {
+      const clock: Clock = makeClock();
+      const memo: InProcessMemo<string> = new InProcessMemo<string>({
+        ttlInMs: 1000,
+        now: clock.now,
+      });
+
+      memo.set("k", "v");
+
+      expect(memo.get("k")).toBe("v");
+    });
+
+    test("misses on a key never stored", () => {
+      const memo: InProcessMemo<string> = new InProcessMemo<string>({
+        ttlInMs: 1000,
+      });
+
+      expect(memo.get("absent")).toBeUndefined();
+    });
+
+    test("stores falsy-but-present values distinguishably from a miss", () => {
+      /*
+       * The fence memo stores booleans and the empty string is a legal
+       * cached value in principle — `undefined` alone must mean "miss".
+       */
+      const memo: InProcessMemo<string | boolean> = new InProcessMemo<
+        string | boolean
+      >({ ttlInMs: 1000 });
+
+      memo.set("empty", "");
+      memo.set("false", false);
+
+      expect(memo.get("empty")).toBe("");
+      expect(memo.get("false")).toBe(false);
+    });
+
+    test("a later set overwrites an earlier one", () => {
+      const memo: InProcessMemo<string> = new InProcessMemo<string>({
+        ttlInMs: 1000,
+      });
+
+      memo.set("k", "v1");
+      memo.set("k", "v2");
+
+      expect(memo.get("k")).toBe("v2");
+    });
+
+    test("keys are independent", () => {
+      const memo: InProcessMemo<string> = new InProcessMemo<string>({
+        ttlInMs: 1000,
+      });
+
+      memo.set("a", "va");
+      memo.set("b", "vb");
+
+      expect(memo.get("a")).toBe("va");
+      expect(memo.get("b")).toBe("vb");
+    });
+  });
+
+  describe("TTL", () => {
+    test("expires exactly at the boundary — an entry at its expiry instant is a miss", () => {
+      const clock: Clock = makeClock();
+      const memo: InProcessMemo<string> = new InProcessMemo<string>({
+        ttlInMs: 1000,
+        now: clock.now,
+      });
+
+      memo.set("k", "v");
+
+      clock.nowMs += 999;
+      expect(memo.get("k")).toBe("v");
+
+      clock.nowMs += 1;
+      expect(memo.get("k")).toBeUndefined();
+    });
+
+    test("an expired entry is deleted on read, freeing its slot", () => {
+      const clock: Clock = makeClock();
+      const memo: InProcessMemo<string> = new InProcessMemo<string>({
+        ttlInMs: 1000,
+        now: clock.now,
+      });
+
+      memo.set("k", "v");
+      clock.nowMs += 2000;
+
+      expect(memo.get("k")).toBeUndefined();
+      expect(memo.size()).toBe(0);
+    });
+
+    test("re-setting a key restarts its TTL", () => {
+      const clock: Clock = makeClock();
+      const memo: InProcessMemo<string> = new InProcessMemo<string>({
+        ttlInMs: 1000,
+        now: clock.now,
+      });
+
+      memo.set("k", "v1");
+      clock.nowMs += 900;
+      memo.set("k", "v2");
+      clock.nowMs += 900;
+
+      // 1800ms after the first set, but only 900ms after the second.
+      expect(memo.get("k")).toBe("v2");
+    });
+
+    test("a per-set TTL override wins over the instance TTL", () => {
+      /*
+       * ResourceHeartbeat caps each entry at that caller's own liveness
+       * window, which can be shorter than the memo's 60s default.
+       */
+      const clock: Clock = makeClock();
+      const memo: InProcessMemo<string> = new InProcessMemo<string>({
+        ttlInMs: 60_000,
+        now: clock.now,
+      });
+
+      memo.set("short", "v", 1000);
+      memo.set("default", "v");
+
+      clock.nowMs += 1001;
+
+      expect(memo.get("short")).toBeUndefined();
+      expect(memo.get("default")).toBe("v");
+    });
+
+    test("the lazy default clock is steerable by a Date.now spy installed later", () => {
+      /*
+       * The production memos are constructed at module load, long before
+       * any test runs. If the constructor captured the Date.now REFERENCE,
+       * a later spy would be invisible and no caller suite could ever test
+       * expiry. Pin the lazy read.
+       */
+      const memo: InProcessMemo<string> = new InProcessMemo<string>({
+        ttlInMs: 1000,
+      });
+
+      let nowMs: number = 5_000_000;
+      jest.spyOn(Date, "now").mockImplementation(() => {
+        return nowMs;
+      });
+
+      memo.set("k", "v");
+      nowMs += 1001;
+
+      expect(memo.get("k")).toBeUndefined();
+    });
+  });
+
+  describe("bounding", () => {
+    test("never grows past maxEntries under churn", () => {
+      const memo: InProcessMemo<number> = new InProcessMemo<number>({
+        ttlInMs: 60_000,
+        maxEntries: 5,
+      });
+
+      for (let i: number = 0; i < 500; i++) {
+        memo.set(`key-${i}`, i);
+      }
+
+      expect(memo.size()).toBeLessThanOrEqual(5);
+    });
+
+    test("evicts the oldest entry first", () => {
+      const memo: InProcessMemo<number> = new InProcessMemo<number>({
+        ttlInMs: 60_000,
+        maxEntries: 3,
+      });
+
+      memo.set("a", 1);
+      memo.set("b", 2);
+      memo.set("c", 3);
+      memo.set("d", 4);
+
+      expect(memo.get("a")).toBeUndefined();
+      expect(memo.get("b")).toBe(2);
+      expect(memo.get("c")).toBe(3);
+      expect(memo.get("d")).toBe(4);
+    });
+
+    test("re-setting an existing key refreshes its recency instead of evicting", () => {
+      const memo: InProcessMemo<number> = new InProcessMemo<number>({
+        ttlInMs: 60_000,
+        maxEntries: 3,
+      });
+
+      memo.set("a", 1);
+      memo.set("b", 2);
+      memo.set("c", 3);
+      // "a" becomes the youngest; "b" is now the oldest.
+      memo.set("a", 10);
+      memo.set("d", 4);
+
+      expect(memo.get("b")).toBeUndefined();
+      expect(memo.get("a")).toBe(10);
+      expect(memo.get("c")).toBe(3);
+      expect(memo.get("d")).toBe(4);
+    });
+
+    test("defaults the cap to 10k — the established ingest-path bound", () => {
+      const memo: InProcessMemo<number> = new InProcessMemo<number>({
+        ttlInMs: 60_000,
+      });
+
+      for (let i: number = 0; i < 10_500; i++) {
+        memo.set(`key-${i}`, i);
+      }
+
+      expect(memo.size()).toBeLessThanOrEqual(10_000);
+    });
+  });
+
+  describe("delete / clear", () => {
+    test("delete drops exactly one entry", () => {
+      const memo: InProcessMemo<string> = new InProcessMemo<string>({
+        ttlInMs: 60_000,
+      });
+
+      memo.set("a", "va");
+      memo.set("b", "vb");
+      memo.delete("a");
+
+      expect(memo.get("a")).toBeUndefined();
+      expect(memo.get("b")).toBe("vb");
+    });
+
+    test("delete of an absent key is a no-op", () => {
+      const memo: InProcessMemo<string> = new InProcessMemo<string>({
+        ttlInMs: 60_000,
+      });
+
+      expect(() => {
+        memo.delete("absent");
+      }).not.toThrow();
+    });
+
+    test("clear drops everything", () => {
+      const memo: InProcessMemo<string> = new InProcessMemo<string>({
+        ttlInMs: 60_000,
+      });
+
+      memo.set("a", "va");
+      memo.set("b", "vb");
+      memo.clear();
+
+      expect(memo.size()).toBe(0);
+      expect(memo.get("a")).toBeUndefined();
+    });
+  });
+});

package/Tests/Server/Utils/InlineImageAccessTokenSync.test.ts

@@ -0,0 +1,202 @@
+import {
+  extractImageAccessTokens,
+  setIsPublicForMarkdownImages,
+  syncIsPublicForMarkdownImages,
+} from "../../../Server/Utils/InlineImageAccessTokenSync";
+import FileService from "../../../Server/Services/FileService";
+import { beforeEach, describe, expect, it } from "@jest/globals";
+
+jest.mock("../../../Server/Services/FileService", () => {
+  return {
+    findOneBy: jest.fn(),
+    updateOneById: jest.fn(),
+  };
+});
+
+jest.mock("../../../Server/Utils/Logger", () => {
+  return {
+    __esModule: true,
+    default: {
+      error: jest.fn(),
+      warn: jest.fn(),
+      info: jest.fn(),
+      debug: jest.fn(),
+    },
+  };
+});
+
+const urlFor: (token: string) => string = (token: string): string => {
+  return `https://example.com/file/image/access-token/${token}`;
+};
+
+describe("extractImageAccessTokens", () => {
+  it("returns nothing for empty, null or undefined markdown", () => {
+    expect(extractImageAccessTokens("")).toEqual([]);
+    expect(extractImageAccessTokens(null)).toEqual([]);
+    expect(extractImageAccessTokens(undefined)).toEqual([]);
+  });
+
+  it("returns nothing when the markdown has no inline images", () => {
+    expect(extractImageAccessTokens("Just some **notes** about the outage.")) //
+      .toEqual([]);
+  });
+
+  it("extracts a single token", () => {
+    expect(extractImageAccessTokens(`![shot](${urlFor("abc123")})`)).toEqual([
+      "abc123",
+    ]);
+  });
+
+  it("extracts every distinct token in the markdown", () => {
+    const markdown: string = `![a](${urlFor("aaa111")}) and ![b](${urlFor("bbb222")})`;
+
+    expect(extractImageAccessTokens(markdown)).toEqual(["aaa111", "bbb222"]);
+  });
+
+  it("de-duplicates a token referenced more than once", () => {
+    const markdown: string = `![a](${urlFor("aaa111")}) again ![a](${urlFor("aaa111")})`;
+
+    expect(extractImageAccessTokens(markdown)).toEqual(["aaa111"]);
+  });
+
+  it("ignores urls that are not access-token image urls", () => {
+    const markdown: string = `![logo](https://example.com/file/image/abc123) ![x](https://example.com/img.png)`;
+
+    expect(extractImageAccessTokens(markdown)).toEqual([]);
+  });
+
+  it("only matches hex tokens", () => {
+    expect(extractImageAccessTokens(`![a](${urlFor("zzzznothex")})`)).toEqual(
+      [],
+    );
+  });
+});
+
+describe("setIsPublicForMarkdownImages", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("does nothing when the markdown has no inline images", async () => {
+    await setIsPublicForMarkdownImages("no images here", true);
+
+    expect(FileService.findOneBy).not.toHaveBeenCalled();
+    expect(FileService.updateOneById).not.toHaveBeenCalled();
+  });
+
+  it("flips every referenced file to public", async () => {
+    (FileService.findOneBy as unknown as jest.Mock).mockResolvedValue({
+      _id: "11111111-1111-1111-1111-111111111111",
+    } as never);
+
+    await setIsPublicForMarkdownImages(
+      `![a](${urlFor("aaa111")}) ![b](${urlFor("bbb222")})`,
+      true,
+    );
+
+    expect(FileService.updateOneById).toHaveBeenCalledTimes(2);
+    expect(
+      (FileService.updateOneById as unknown as jest.Mock).mock.calls[0]?.[0],
+    ).toMatchObject({
+      data: { isPublic: true },
+    });
+  });
+
+  it("flips files back to private when told to", async () => {
+    (FileService.findOneBy as unknown as jest.Mock).mockResolvedValue({
+      _id: "11111111-1111-1111-1111-111111111111",
+    } as never);
+
+    await setIsPublicForMarkdownImages(`![a](${urlFor("aaa111")})`, false);
+
+    expect(
+      (FileService.updateOneById as unknown as jest.Mock).mock.calls[0]?.[0],
+    ).toMatchObject({
+      data: { isPublic: false },
+    });
+  });
+
+  it("skips tokens with no matching file", async () => {
+    (FileService.findOneBy as unknown as jest.Mock).mockResolvedValue(
+      null as never,
+    );
+
+    await setIsPublicForMarkdownImages(`![a](${urlFor("aaa111")})`, true);
+
+    expect(FileService.updateOneById).not.toHaveBeenCalled();
+  });
+
+  /*
+   * One unreadable file must not strand the rest of the note's images in the
+   * wrong visibility — a half-published note is worse than a slow one.
+   */
+  it("keeps going when one token fails", async () => {
+    (FileService.findOneBy as unknown as jest.Mock)
+      .mockRejectedValueOnce(new Error("db down") as never)
+      .mockResolvedValueOnce({
+        _id: "22222222-2222-2222-2222-222222222222",
+      } as never);
+
+    await setIsPublicForMarkdownImages(
+      `![a](${urlFor("aaa111")}) ![b](${urlFor("bbb222")})`,
+      true,
+    );
+
+    expect(FileService.updateOneById).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("syncIsPublicForMarkdownImages", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("flips images public like the unwrapped call", async () => {
+    (FileService.findOneBy as unknown as jest.Mock).mockResolvedValue({
+      _id: "11111111-1111-1111-1111-111111111111",
+    } as never);
+
+    await syncIsPublicForMarkdownImages(
+      `![a](${urlFor("aaa111")})`,
+      true,
+      "test context",
+    );
+
+    expect(
+      (FileService.updateOneById as unknown as jest.Mock).mock.calls[0]?.[0],
+    ).toMatchObject({
+      data: { isPublic: true },
+    });
+  });
+
+  /*
+   * Visibility sync is best-effort by design: publishing a note must not fail
+   * because an image could not be flipped.
+   */
+  it("never throws, even when the markdown itself is unusable", async () => {
+    await expect(
+      syncIsPublicForMarkdownImages(
+        123 as unknown as string,
+        true,
+        "test context",
+      ),
+    ).resolves.toBeUndefined();
+  });
+
+  it("never throws when the update itself fails", async () => {
+    (FileService.findOneBy as unknown as jest.Mock).mockResolvedValue({
+      _id: "11111111-1111-1111-1111-111111111111",
+    } as never);
+    (FileService.updateOneById as unknown as jest.Mock).mockRejectedValue(
+      new Error("write failed") as never,
+    );
+
+    await expect(
+      syncIsPublicForMarkdownImages(
+        `![a](${urlFor("aaa111")})`,
+        true,
+        "test context",
+      ),
+    ).resolves.toBeUndefined();
+  });
+});