@oneuptime/common 14.0.8 → 14.0.10

package/Tests/Server/Infrastructure/GlobalCache.test.ts

@@ -455,6 +455,201 @@ describe("GlobalCache.deleteKeyIfValue", () => {
   });
 });
 
+/*
+ * getStrings backs the Proxmox native-push silent-node check
+ * (ProxmoxNativeNodeLiveness): every live node's status push reads the
+ * liveness key of each of its siblings. That is on the metrics ingest hot
+ * path, so it must stay ONE round-trip however large the cluster, and the
+ * reply must stay positional — the caller zips it back onto the node names,
+ * so a reply that dropped or reordered a missing key would pin one node's
+ * liveness on another and report a live node as down (or a dead one as up).
+ */
+type MgetMockClient = MockClient & {
+  mget: jest.Mock;
+};
+
+describe("GlobalCache.getStrings", () => {
+  let client: MgetMockClient;
+
+  beforeEach(() => {
+    client = {
+      set: jest.fn().mockResolvedValue("OK"),
+      expire: jest.fn().mockResolvedValue(1),
+      get: jest.fn(),
+      del: jest.fn().mockResolvedValue(1),
+      eval: jest.fn().mockResolvedValue(1),
+      mget: jest.fn().mockResolvedValue([]),
+    };
+    (Redis.getClient as jest.Mock).mockReturnValue(client);
+    (Redis.isConnected as jest.Mock).mockReturnValue(true);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test("reads every key in ONE MGET, namespaced exactly as getString does", async () => {
+    client.mget.mockResolvedValue(["1", "2", "3"]);
+
+    await GlobalCache.getStrings("ns", ["a", "b", "c"]);
+
+    expect(client.mget).toHaveBeenCalledTimes(1);
+    expect(client.mget).toHaveBeenCalledWith(["ns-a", "ns-b", "ns-c"]);
+    // One GET per key would be N round-trips on the ingest hot path.
+    expect(client.get).not.toHaveBeenCalled();
+  });
+
+  test("uses the same key getString and setString use", async () => {
+    client.get.mockResolvedValue("x");
+
+    await GlobalCache.setString("proxmox", "p:c:pve1", "x", {
+      expiresInSeconds: 120,
+    });
+    await GlobalCache.getString("proxmox", "p:c:pve1");
+    await GlobalCache.getStrings("proxmox", ["p:c:pve1"]);
+
+    const setKey: unknown = (client.set.mock.calls[0] as Array<unknown>)[0];
+    const getKey: unknown = (client.get.mock.calls[0] as Array<unknown>)[0];
+    const mgetKeys: unknown = (client.mget.mock.calls[0] as Array<unknown>)[0];
+
+    expect(setKey).toBe("proxmox-p:c:pve1");
+    expect(getKey).toBe(setKey);
+    expect(mgetKeys).toEqual([setKey]);
+  });
+
+  test("returns the values positionally, null where a key is missing", async () => {
+    client.mget.mockResolvedValue(["1,2", null, "5,6", null]);
+
+    await expect(
+      GlobalCache.getStrings("ns", ["a", "b", "c", "d"]),
+    ).resolves.toEqual(["1,2", null, "5,6", null]);
+  });
+
+  test("returns all nulls when no key exists", async () => {
+    client.mget.mockResolvedValue([null, null, null]);
+
+    await expect(
+      GlobalCache.getStrings("ns", ["a", "b", "c"]),
+    ).resolves.toEqual([null, null, null]);
+  });
+
+  // getString reads an empty value as missing; getStrings must agree.
+  test("reads an empty-string value as null, like getString", async () => {
+    client.mget.mockResolvedValue(["", "x", ""]);
+
+    await expect(
+      GlobalCache.getStrings("ns", ["a", "b", "c"]),
+    ).resolves.toEqual([null, "x", null]);
+  });
+
+  test("keeps duplicate keys at their own positions", async () => {
+    client.mget.mockResolvedValue(["v", "w", "v"]);
+
+    await expect(
+      GlobalCache.getStrings("ns", ["a", "b", "a"]),
+    ).resolves.toEqual(["v", "w", "v"]);
+    expect(client.mget).toHaveBeenCalledWith(["ns-a", "ns-b", "ns-a"]);
+  });
+
+  /*
+   * One entry per REQUESTED key, whatever the reply: a short reply (a
+   * proxy, a driver change) pads with null rather than shifting or
+   * shortening the result, and a long one is cut to the keys asked for.
+   */
+  test("always returns exactly one entry per requested key", async () => {
+    client.mget.mockResolvedValue(["1"]);
+    await expect(
+      GlobalCache.getStrings("ns", ["a", "b", "c"]),
+    ).resolves.toEqual(["1", null, null]);
+
+    client.mget.mockResolvedValue(["1", "2", "3", "4"]);
+    await expect(GlobalCache.getStrings("ns", ["a", "b"])).resolves.toEqual([
+      "1",
+      "2",
+    ]);
+
+    client.mget.mockResolvedValue([undefined, "2"]);
+    await expect(GlobalCache.getStrings("ns", ["a", "b"])).resolves.toEqual([
+      null,
+      "2",
+    ]);
+  });
+
+  test("stays one round-trip for a large cluster", async () => {
+    const keys: Array<string> = [];
+    for (let i: number = 0; i < 500; i++) {
+      keys.push(`node-${i}`);
+    }
+    client.mget.mockResolvedValue(
+      keys.map((key: string) => {
+        return `value-${key}`;
+      }),
+    );
+
+    const values: Array<string | null> = await GlobalCache.getStrings(
+      "ns",
+      keys,
+    );
+
+    expect(client.mget).toHaveBeenCalledTimes(1);
+    expect(values).toHaveLength(500);
+    expect(values[0]).toBe("value-node-0");
+    expect(values[499]).toBe("value-node-499");
+  });
+
+  test("does not mutate the caller's key array", async () => {
+    const keys: Array<string> = ["a", "b"];
+    client.mget.mockResolvedValue(["1", "2"]);
+
+    await GlobalCache.getStrings("ns", keys);
+
+    expect(keys).toEqual(["a", "b"]);
+  });
+
+  test("no keys: returns [] without a Redis call", async () => {
+    await expect(GlobalCache.getStrings("ns", [])).resolves.toEqual([]);
+    expect(client.mget).not.toHaveBeenCalled();
+  });
+
+  // Nothing to read, so nothing to fail: an empty sibling list is not an error.
+  test("no keys: returns [] even when the cache is not connected", async () => {
+    (Redis.isConnected as jest.Mock).mockReturnValue(false);
+
+    await expect(GlobalCache.getStrings("ns", [])).resolves.toEqual([]);
+  });
+
+  test("throws when the cache is not connected", async () => {
+    (Redis.isConnected as jest.Mock).mockReturnValue(false);
+
+    await expect(GlobalCache.getStrings("ns", ["a"])).rejects.toThrow(
+      DatabaseNotConnectedException,
+    );
+    expect(client.mget).not.toHaveBeenCalled();
+  });
+
+  test("throws when there is no client at all", async () => {
+    (Redis.getClient as jest.Mock).mockReturnValue(null);
+
+    await expect(GlobalCache.getStrings("ns", ["a"])).rejects.toThrow(
+      DatabaseNotConnectedException,
+    );
+    expect(client.mget).not.toHaveBeenCalled();
+  });
+
+  /*
+   * The caller decides what an MGET failure means (the silent-node check
+   * reports nothing); getStrings must not swallow it into "every key is
+   * missing", which would read as "every sibling is silent".
+   */
+  test("propagates an MGET failure instead of returning nulls", async () => {
+    client.mget.mockRejectedValue(new Error("ETIMEDOUT"));
+
+    await expect(GlobalCache.getStrings("ns", ["a", "b"])).rejects.toThrow(
+      "ETIMEDOUT",
+    );
+  });
+});
+
 describe("GlobalCache.getAndDeleteString", () => {
   let client: MockClient;
 

package/Tests/Server/Infrastructure/Postgres/AddDatabaseServerTablesMigration.test.ts

@@ -8,6 +8,8 @@ import DatabaseServerOwnerRule from "../../../../Models/DatabaseModels/DatabaseS
 import DatabaseServerOwnerTeam from "../../../../Models/DatabaseModels/DatabaseServerOwnerTeam";
 import DatabaseServerOwnerUser from "../../../../Models/DatabaseModels/DatabaseServerOwnerUser";
 import { describe, expect, test } from "@jest/globals";
+import fs from "fs";
+import path from "path";
 import {
   DefaultNamingStrategy,
   QueryRunner,
@@ -72,6 +74,53 @@ function persistedColumns(modelType: unknown): Array<string> {
   return names;
 }
 
+/*
+ * Columns a LATER migration adds to a table this migration creates (for
+ * example the Database AI agent's access columns on DatabaseServer). This
+ * migration has shipped, so a new column arrives in a new migration rather
+ * than in this CREATE TABLE; the invariant is "every model column is created
+ * here or added later", which still fails a column no migration mentions at
+ * all. The end-state schema itself is owned by the Schema Drift job.
+ */
+function columnsAddedByLaterMigrations(tableName: string): Set<string> {
+  const migrationsDirectory: string = path.join(
+    __dirname,
+    "../../../../Server/Infrastructure/Postgres/SchemaMigrations",
+  );
+  const ownFileName: string = "1795000000000-AddDatabaseServerTables.ts";
+  const added: Set<string> = new Set<string>();
+
+  for (const fileName of fs.readdirSync(migrationsDirectory)) {
+    const stamp: RegExpMatchArray | null = fileName.match(/^(\d{13})-/);
+
+    if (
+      !fileName.endsWith(".ts") ||
+      fileName === ownFileName ||
+      !stamp ||
+      Number(stamp[1]) <= 1795000000000
+    ) {
+      continue;
+    }
+
+    const source: string = fs.readFileSync(
+      path.join(migrationsDirectory, fileName),
+      "utf8",
+    );
+    const addPattern: RegExp = new RegExp(
+      `ALTER TABLE "${tableName}" ADD "([^"]+)"`,
+      "g",
+    );
+    let match: RegExpExecArray | null = addPattern.exec(source);
+
+    while (match) {
+      added.add(match[1]!);
+      match = addPattern.exec(source);
+    }
+  }
+
+  return added;
+}
+
 function createTableStatement(
   statements: Array<string>,
   tableName: string,
@@ -292,7 +341,18 @@ describe("AddDatabaseServerTables1795000000000", () => {
       const columns: Array<string> = persistedColumns(modelType);
       expect(columns.length).toBeGreaterThan(5);
 
+      const addedLater: Set<string> = columnsAddedByLaterMigrations(tableName);
+
       for (const column of columns) {
+        if (addedLater.has(column)) {
+          expect({
+            tableName,
+            column,
+            alsoCreatedHere: statement.includes(`"${column}"`),
+          }).toEqual({ tableName, column, alsoCreatedHere: false });
+          continue;
+        }
+
         expect({
           tableName,
           column,