@oneuptime/common 14.0.2 → 14.0.5

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

@@ -0,0 +1,234 @@
+import { AddUserProjectSsoConsent1795100000000 } from "../../../../Server/Infrastructure/Postgres/SchemaMigrations/1795100000000-AddUserProjectSsoConsent";
+import SchemaMigrations from "../../../../Server/Infrastructure/Postgres/SchemaMigrations/Index";
+import UserProjectSsoConsent from "../../../../Models/DatabaseModels/UserProjectSsoConsent";
+import { describe, expect, test } from "@jest/globals";
+import {
+  DefaultNamingStrategy,
+  QueryRunner,
+  getMetadataArgsStorage,
+} from "typeorm";
+import type { ColumnMetadataArgs } from "typeorm/metadata-args/ColumnMetadataArgs";
+
+/*
+ * The schema half of "a project's SSO may sign an account in only once the
+ * account's mailbox has agreed to it".
+ *
+ * The migration was generated against the model, so its names are TypeORM's
+ * by construction. What this pins is that it stays the migration for it: the
+ * table has every column the model persists, one live consent per (user,
+ * project) is enforced by the database -- the service absorbs a racing second
+ * insert by relying on exactly this -- a consent goes with its user or its
+ * project, the unique index keeps the name the model declares (a hand edit
+ * that renamed it would pass review and then fail the Schema Drift job), and
+ * down() undoes up().
+ *
+ * Fake QueryRunner only.
+ */
+
+const TABLE: string = "UserProjectSsoConsent";
+const MIGRATION_NAME: string = "AddUserProjectSsoConsent1795100000000";
+const MIGRATION_TIMESTAMP: number = 1795100000000;
+const UNIQUE_INDEX_NAME: string = "IDX_UserProjectSsoConsent_userId_projectId";
+
+const namingStrategy: DefaultNamingStrategy = new DefaultNamingStrategy();
+
+type RecordQueriesFunction = (
+  direction: "up" | "down",
+) => Promise<Array<string>>;
+
+const recordQueries: RecordQueriesFunction = async (
+  direction: "up" | "down",
+): Promise<Array<string>> => {
+  const statements: Array<string> = [];
+
+  const queryRunner: QueryRunner = {
+    query: async (statement: string): Promise<void> => {
+      statements.push(statement);
+    },
+  } as unknown as QueryRunner;
+
+  await new AddUserProjectSsoConsent1795100000000()[direction](queryRunner);
+
+  return statements;
+};
+
+// Columns a model persists, inherited ones (_id, version, ...) included.
+function persistedColumns(modelType: unknown): Array<string> {
+  const names: Array<string> = [];
+  let current: unknown = modelType;
+
+  while (typeof current === "function" && current !== Function.prototype) {
+    for (const column of getMetadataArgsStorage().columns) {
+      if (column.target === current) {
+        const args: ColumnMetadataArgs = column;
+        names.push(args.options.name || args.propertyName);
+      }
+    }
+
+    current = Object.getPrototypeOf(current);
+  }
+
+  return names;
+}
+
+function captured(statements: Array<string>, pattern: RegExp): Array<string> {
+  return statements
+    .map((statement: string): string | null => {
+      const match: RegExpMatchArray | null = statement.match(pattern);
+      return match ? match[1]! : null;
+    })
+    .filter((value: string | null): value is string => {
+      return value !== null;
+    });
+}
+
+function registeredNames(): Array<string> {
+  return (SchemaMigrations as unknown as Array<{ name: string }>).map(
+    (registered: { name: string }): string => {
+      return registered.name;
+    },
+  );
+}
+
+describe("AddUserProjectSsoConsent1795100000000", () => {
+  test("is registered under the name its class carries", () => {
+    expect(new AddUserProjectSsoConsent1795100000000().name).toBe(
+      MIGRATION_NAME,
+    );
+    expect(SchemaMigrations).toContain(AddUserProjectSsoConsent1795100000000);
+  });
+
+  test("nothing registered before it is newer than it", () => {
+    const names: Array<string> = registeredNames();
+    const ownIndex: number = names.indexOf(MIGRATION_NAME);
+
+    expect(ownIndex).toBeGreaterThan(0);
+
+    const notBehind: Array<string> = names
+      .slice(0, ownIndex)
+      .filter((className: string): boolean => {
+        const match: RegExpMatchArray | null = className.match(/(\d{13})$/);
+        return match !== null && Number(match[1]) >= MIGRATION_TIMESTAMP;
+      });
+
+    expect(notBehind).toEqual([]);
+  });
+
+  test("nothing registered after it is older than it", () => {
+    const names: Array<string> = registeredNames();
+    const ownIndex: number = names.indexOf(MIGRATION_NAME);
+
+    const olderAfter: Array<string> = names
+      .slice(ownIndex + 1)
+      .filter((className: string): boolean => {
+        const match: RegExpMatchArray | null = className.match(/(\d{13})$/);
+        return match === null || Number(match[1]) <= MIGRATION_TIMESTAMP;
+      });
+
+    expect(olderAfter).toEqual([]);
+  });
+
+  test("touches only its own table", async () => {
+    for (const statement of await recordQueries("up")) {
+      const table: RegExpMatchArray | null = statement.match(
+        /^(?:CREATE TABLE|ALTER TABLE|CREATE (?:UNIQUE )?INDEX "[^"]+" ON) "([^"]+)"/,
+      );
+
+      expect({ statement, table: table?.[1] }).toEqual({
+        statement,
+        table: TABLE,
+      });
+    }
+  });
+
+  test("creates the table with every column the model persists", async () => {
+    const statements: Array<string> = await recordQueries("up");
+    const creates: Array<string> = statements.filter(
+      (statement: string): boolean => {
+        return statement.startsWith(`CREATE TABLE "${TABLE}" (`);
+      },
+    );
+
+    expect(creates).toHaveLength(1);
+
+    const columns: Array<string> = persistedColumns(UserProjectSsoConsent);
+
+    expect(columns).toEqual(
+      expect.arrayContaining(["_id", "userId", "projectId", "deletedAt"]),
+    );
+
+    for (const column of columns) {
+      expect({ column, created: creates[0]!.includes(`"${column}"`) }).toEqual({
+        column,
+        created: true,
+      });
+    }
+
+    expect(creates[0]).toContain('"userId" uuid NOT NULL');
+    expect(creates[0]).toContain('"projectId" uuid NOT NULL');
+    expect(creates[0]).toContain(
+      `CONSTRAINT "${namingStrategy.primaryKeyName(TABLE, ["_id"])}" PRIMARY KEY ("_id")`,
+    );
+  });
+
+  test("allows one live consent per user and project, under the model's index name", async () => {
+    expect(await recordQueries("up")).toContain(
+      `CREATE UNIQUE INDEX "${UNIQUE_INDEX_NAME}" ON "${TABLE}" ("userId", "projectId") WHERE "deletedAt" IS NULL`,
+    );
+  });
+
+  test.each(["userId", "projectId"])(
+    "indexes %s on its own",
+    async (column: string) => {
+      const name: string = namingStrategy.indexName(TABLE, [column]);
+
+      expect(await recordQueries("up")).toContain(
+        `CREATE INDEX "${name}" ON "${TABLE}" ("${column}") `,
+      );
+    },
+  );
+
+  test.each([
+    ["userId", "User"],
+    ["projectId", "Project"],
+  ])(
+    "%s references %s and goes with it when it is deleted",
+    async (column: string, referenced: string) => {
+      const name: string = namingStrategy.foreignKeyName(TABLE, [column]);
+
+      expect(await recordQueries("up")).toContain(
+        `ALTER TABLE "${TABLE}" ADD CONSTRAINT "${name}" FOREIGN KEY ("${column}") REFERENCES "${referenced}"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+      );
+    },
+  );
+
+  test("down() removes every constraint up() added, in reverse", async () => {
+    const added: Array<string> = captured(
+      await recordQueries("up"),
+      /ADD CONSTRAINT "([^"]+)"/,
+    );
+    const dropped: Array<string> = captured(
+      await recordQueries("down"),
+      /DROP CONSTRAINT "([^"]+)"/,
+    );
+
+    expect(added).toHaveLength(2);
+    expect(dropped).toEqual([...added].reverse());
+  });
+
+  test("down() drops every index up() created, then the table, last", async () => {
+    const created: Array<string> = captured(
+      await recordQueries("up"),
+      /^CREATE (?:UNIQUE )?INDEX "([^"]+)"/,
+    );
+    const down: Array<string> = await recordQueries("down");
+    const dropped: Array<string> = captured(
+      down,
+      /^DROP INDEX "public"\."([^"]+)"$/,
+    );
+
+    expect(created).toHaveLength(3);
+    expect([...dropped].sort()).toEqual([...created].sort());
+    expect(down[down.length - 1]).toBe(`DROP TABLE "${TABLE}"`);
+  });
+});

package/Tests/Server/Services/ContainerSnapshotUpsertPostgres.test.ts

@@ -0,0 +1,319 @@
+import DockerResourceService from "../../../Server/Services/DockerResourceService";
+import PodmanResourceService from "../../../Server/Services/PodmanResourceService";
+import ObjectID from "../../../Types/ObjectID";
+import { JSONObject } from "../../../Types/JSON";
+import { Client } from "pg";
+
+/*
+ * The metrics snapshot's Container upsert (bulkUpsertContainers) EXECUTED
+ * on Postgres, with the inventory snapshot's bulkUpsert beside it: the
+ * Compose / Testcontainers labels the agents copy onto their metrics are
+ * MERGED into a row's labels (never wiping what the inventory wrote), the
+ * container's start time fills resourceCreationTimestamp and only moves
+ * forward on a restart or a recreation, and a row without them is left
+ * alone. Values are the end-to-end run's (compose-postgres-1, started
+ * 23:26:39.057 on the 24th).
+ *
+ * Opt in with RUN_POSTGRES_DATABASE_SERVER_SQL_TESTS=true, as for
+ * DatabaseContainerCommandPostgres (any database will do: the tables are
+ * session TEMP tables shadowing public). Credentials from
+ * DATABASE_USERNAME / DATABASE_PASSWORD, database from
+ * DATABASE_SERVER_SQL_TEST_DATABASE_NAME or DATABASE_NAME, endpoint from
+ * DATABASE_SERVER_SQL_TEST_DATABASE_HOST / _PORT (default localhost:5400).
+ */
+const describePostgres: typeof describe =
+  process.env["RUN_POSTGRES_DATABASE_SERVER_SQL_TESTS"] === "true"
+    ? describe
+    : describe.skip;
+
+const PROJECT_ID: ObjectID = ObjectID.generate();
+const HOST_ID: ObjectID = ObjectID.generate();
+
+const CONTAINER_ID: string =
+  "1b09d4df414d90f1c3afc18ed6076e56d0f27e8b18cca4c18e1776ae7e8ad107";
+const RECREATED_ID: string =
+  "9f0e2d4c6b8a0f1e3d5c7b9a1f3e5d7c9b1a3f5e7d9c1b3a5f7e9d1c3b5a7f9e";
+const STARTED_AT: Date = new Date("2026-09-24T23:26:39.057Z");
+const SCRAPE_AT: Date = new Date("2026-09-25T01:10:20.523Z");
+const MINUTE_MS: number = 60 * 1000;
+
+const COMPOSE_LABELS: JSONObject = {
+  "com.docker.compose.service": "postgres",
+  "com.docker.compose.oneoff": "False",
+  "com.docker.compose.project": "e2e-docker-spans-compose",
+};
+
+interface StoredRow {
+  containerId: string | null;
+  labels: JSONObject | null;
+  resourceCreationTimestamp: Date | null;
+  lastSeenAt: Date;
+}
+
+function tableDdl(table: string, parentColumn: string): string {
+  return `CREATE TEMP TABLE "${table}" (
+    "_id" uuid NOT NULL DEFAULT gen_random_uuid(),
+    "createdAt" timestamptz NOT NULL DEFAULT now(),
+    "updatedAt" timestamptz NOT NULL DEFAULT now(),
+    "deletedAt" timestamptz,
+    "version" integer NOT NULL,
+    "projectId" uuid NOT NULL,
+    "${parentColumn}" uuid NOT NULL,
+    "kind" varchar(100) NOT NULL,
+    "name" varchar(500) NOT NULL,
+    "containerId" varchar(100),
+    "imageName" varchar(500),
+    "state" varchar(100),
+    "labels" jsonb,
+    "latestCpuPercent" numeric,
+    "latestMemoryBytes" bigint,
+    "metricsUpdatedAt" timestamptz,
+    "lastSeenAt" timestamptz NOT NULL,
+    "resourceCreationTimestamp" timestamptz
+  );
+  CREATE UNIQUE INDEX ON "${table}" ("projectId", "${parentColumn}", "kind", "name");`;
+}
+
+describePostgres("the container snapshot upsert on Postgres", () => {
+  let client: Client;
+
+  beforeAll(async () => {
+    client = new Client({
+      host:
+        process.env["DATABASE_SERVER_SQL_TEST_DATABASE_HOST"] || "localhost",
+      port: Number(
+        process.env["DATABASE_SERVER_SQL_TEST_DATABASE_PORT"] || "5400",
+      ),
+      user: process.env["DATABASE_USERNAME"] || "postgres",
+      password: process.env["DATABASE_PASSWORD"] || "password",
+      database:
+        process.env["DATABASE_SERVER_SQL_TEST_DATABASE_NAME"] ||
+        process.env["DATABASE_NAME"] ||
+        "oneuptimedb",
+    });
+    await client.connect();
+    await client.query(tableDdl("DockerResource", "dockerHostId"));
+    await client.query(tableDdl("PodmanResource", "podmanHostId"));
+  });
+
+  afterAll(async () => {
+    await client.end();
+  });
+
+  beforeEach(async () => {
+    await client.query(`DELETE FROM "DockerResource"`);
+    await client.query(`DELETE FROM "PodmanResource"`);
+    const manager: {
+      query: (sql: string, params: Array<unknown>) => Promise<unknown>;
+    } = {
+      query: async (sql: string, params: Array<unknown>): Promise<unknown> => {
+        return (await client.query(sql, params)).rows;
+      },
+    };
+    for (const service of [DockerResourceService, PodmanResourceService]) {
+      jest
+        .spyOn(service, "getRepository")
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        .mockReturnValue({ manager } as any);
+    }
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  async function scrape(data: {
+    service: "docker" | "podman";
+    at: Date;
+    containerId?: string;
+    labels?: JSONObject | null;
+    startedAt?: Date | null;
+  }): Promise<void> {
+    const container: {
+      containerName: string;
+      containerId: string;
+      imageName: string;
+      state: string;
+      cpuPercent: number;
+      memoryBytes: number;
+      observedAt: Date;
+      labels: JSONObject | null;
+      startedAt: Date | null;
+    } = {
+      containerName: "e2e-docker-spans-compose-postgres-1",
+      containerId: data.containerId ?? CONTAINER_ID,
+      imageName: "postgres:16",
+      state: "running",
+      cpuPercent: 0.53,
+      memoryBytes: 24289280,
+      observedAt: data.at,
+      labels: data.labels === undefined ? COMPOSE_LABELS : data.labels,
+      startedAt: data.startedAt === undefined ? STARTED_AT : data.startedAt,
+    };
+    if (data.service === "docker") {
+      await DockerResourceService.bulkUpsertContainers({
+        projectId: PROJECT_ID,
+        dockerHostId: HOST_ID,
+        containers: [container],
+      });
+    } else {
+      await PodmanResourceService.bulkUpsertContainers({
+        projectId: PROJECT_ID,
+        podmanHostId: HOST_ID,
+        containers: [container],
+      });
+    }
+  }
+
+  async function stored(service: "docker" | "podman"): Promise<StoredRow> {
+    const table: string =
+      service === "docker" ? "DockerResource" : "PodmanResource";
+    const result: { rows: Array<StoredRow> } = await client.query(
+      `SELECT "containerId", "labels", "resourceCreationTimestamp", "lastSeenAt" FROM "${table}"`,
+    );
+    expect(result.rows).toHaveLength(1);
+    return result.rows[0]!;
+  }
+
+  describe.each(["docker", "podman"] as Array<"docker" | "podman">)(
+    "%s",
+    (service: "docker" | "podman") => {
+      test("regression: a new row gets the labels and the start time the agent reported", async () => {
+        await scrape({ service, at: SCRAPE_AT });
+
+        const row: StoredRow = await stored(service);
+        expect(row.labels).toEqual(COMPOSE_LABELS);
+        expect(row.resourceCreationTimestamp).toEqual(STARTED_AT);
+      });
+
+      test("an existing row without them (written before the fix) is filled in", async () => {
+        await scrape({
+          service,
+          at: new Date(SCRAPE_AT.getTime() - MINUTE_MS),
+          labels: null,
+          startedAt: null,
+        });
+        expect((await stored(service)).labels).toBeNull();
+
+        await scrape({ service, at: SCRAPE_AT });
+
+        const row: StoredRow = await stored(service);
+        expect(row.labels).toEqual(COMPOSE_LABELS);
+        expect(row.resourceCreationTimestamp).toEqual(STARTED_AT);
+      });
+
+      test("labels the inventory snapshot wrote are merged into, never wiped", async () => {
+        const inventoryLabels: JSONObject = {
+          ...COMPOSE_LABELS,
+          "com.docker.compose.config-hash": "abc123",
+          maintainer: "PostgreSQL Docker Maintainers",
+        };
+        const upsert: {
+          projectId: ObjectID;
+          resources: Array<{
+            kind: string;
+            name: string;
+            containerId: string;
+            imageName: string;
+            state: string;
+            labels: JSONObject;
+            resourceCreationTimestamp: Date;
+            lastSeenAt: Date;
+          }>;
+        } = {
+          projectId: PROJECT_ID,
+          resources: [
+            {
+              kind: "Container",
+              name: "e2e-docker-spans-compose-postgres-1",
+              containerId: CONTAINER_ID,
+              imageName: "postgres:16",
+              state: "running",
+              labels: inventoryLabels,
+              resourceCreationTimestamp: new Date(STARTED_AT.getTime() - 2000),
+              lastSeenAt: new Date(SCRAPE_AT.getTime() - MINUTE_MS),
+            },
+          ],
+        };
+        if (service === "docker") {
+          await DockerResourceService.bulkUpsert({
+            ...upsert,
+            dockerHostId: HOST_ID,
+          });
+        } else {
+          await PodmanResourceService.bulkUpsert({
+            ...upsert,
+            podmanHostId: HOST_ID,
+          });
+        }
+
+        await scrape({ service, at: SCRAPE_AT });
+
+        const row: StoredRow = await stored(service);
+        expect(row.labels).toEqual(inventoryLabels);
+        // The inventory's own creation time stands (the start is 2 s later).
+        expect(row.resourceCreationTimestamp).toEqual(
+          new Date(STARTED_AT.getTime() - 2000),
+        );
+      });
+
+      test("scrape jitter never rewrites the start time; a restart moves it forward", async () => {
+        await scrape({ service, at: SCRAPE_AT });
+        await scrape({
+          service,
+          at: new Date(SCRAPE_AT.getTime() + 30000),
+          startedAt: new Date(STARTED_AT.getTime() + 800),
+        });
+        expect((await stored(service)).resourceCreationTimestamp).toEqual(
+          STARTED_AT,
+        );
+
+        const restartedAt: Date = new Date(SCRAPE_AT.getTime() + 5 * MINUTE_MS);
+        await scrape({
+          service,
+          at: new Date(SCRAPE_AT.getTime() + 6 * MINUTE_MS),
+          startedAt: restartedAt,
+        });
+        expect((await stored(service)).resourceCreationTimestamp).toEqual(
+          restartedAt,
+        );
+      });
+
+      test("a container recreated under the same name replaces the labels and the start time", async () => {
+        await scrape({
+          service,
+          at: SCRAPE_AT,
+          labels: { ...COMPOSE_LABELS, "org.testcontainers": "true" },
+        });
+
+        const recreatedAt: Date = new Date(SCRAPE_AT.getTime() + 20000);
+        await scrape({
+          service,
+          at: new Date(SCRAPE_AT.getTime() + 30000),
+          containerId: RECREATED_ID,
+          startedAt: recreatedAt,
+        });
+
+        const row: StoredRow = await stored(service);
+        expect(row.containerId).toBe(RECREATED_ID);
+        expect(row.labels).toEqual(COMPOSE_LABELS);
+        expect(row.resourceCreationTimestamp).toEqual(recreatedAt);
+      });
+
+      test("an out-of-order older scrape changes nothing", async () => {
+        await scrape({ service, at: SCRAPE_AT });
+        await scrape({
+          service,
+          at: new Date(SCRAPE_AT.getTime() - 5 * MINUTE_MS),
+          labels: { "com.docker.compose.project": "other" },
+          startedAt: new Date(SCRAPE_AT.getTime() - MINUTE_MS),
+        });
+
+        const row: StoredRow = await stored(service);
+        expect(row.labels).toEqual(COMPOSE_LABELS);
+        expect(row.resourceCreationTimestamp).toEqual(STARTED_AT);
+        expect(row.lastSeenAt).toEqual(SCRAPE_AT);
+      });
+    },
+  );
+});

package/Tests/Server/Services/CrossProjectRelationWriteGuard.test.ts

@@ -12,6 +12,7 @@ import AlertSeverity from "../../../Models/DatabaseModels/AlertSeverity";
 import AlertState from "../../../Models/DatabaseModels/AlertState";
 import CephCluster from "../../../Models/DatabaseModels/CephCluster";
 import DatabaseBaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import DatabaseServer from "../../../Models/DatabaseModels/DatabaseServer";
 import DockerHost from "../../../Models/DatabaseModels/DockerHost";
 import DockerResource from "../../../Models/DatabaseModels/DockerResource";
 import DockerSwarmCluster from "../../../Models/DatabaseModels/DockerSwarmCluster";
@@ -42,6 +43,7 @@ import AlertSeverityService from "../../../Server/Services/AlertSeverityService"
 import AlertStateService from "../../../Server/Services/AlertStateService";
 import CephClusterService from "../../../Server/Services/CephClusterService";
 import CustomFieldMappingService from "../../../Server/Services/CustomFieldMappingService";
+import DatabaseServerService from "../../../Server/Services/DatabaseServerService";
 import DockerHostService from "../../../Server/Services/DockerHostService";
 import DockerResourceService from "../../../Server/Services/DockerResourceService";
 import DockerSwarmClusterService from "../../../Server/Services/DockerSwarmClusterService";
@@ -235,6 +237,17 @@ const RESOURCE_LISTS: Array<ResourceList> = [
     PodmanResourceService,
   ),
   resourceList(14, "services", "Service", ServiceModel, ServiceService),
+  /*
+   * Appended, not inserted next to cephClusters: tests below address
+   * services as RESOURCE_LISTS[13].
+   */
+  resourceList(
+    15,
+    "databaseServers",
+    "Database",
+    DatabaseServer,
+    DatabaseServerService,
+  ),
 ];
 
 // Only scheduled maintenance events carry this one.