@oneuptime/common 14.0.3 → 14.0.6

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

@@ -0,0 +1,225 @@
+import IncomingCallPolicyEscalationRule from "../../../Models/DatabaseModels/IncomingCallPolicyEscalationRule";
+import IncomingCallPolicyEscalationRuleService from "../../../Server/Services/IncomingCallPolicyEscalationRuleService";
+import CreateBy from "../../../Server/Types/Database/CreateBy";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import ObjectID from "../../../Types/ObjectID";
+import PositiveNumber from "../../../Types/PositiveNumber";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+
+/*
+ * An escalation rule escalates to exactly one target: a user, or an on-call
+ * schedule. A rule with neither escalates to nobody and a rule with both is
+ * ambiguous, so both are refused at write time rather than discovered when a
+ * call comes in. onBeforeCreate is protected; reach it through the singleton
+ * the way the DatabaseService pipeline does.
+ */
+type HookAccess = {
+  onBeforeCreate: (
+    createBy: CreateBy<IncomingCallPolicyEscalationRule>,
+  ) => Promise<{ createBy: CreateBy<IncomingCallPolicyEscalationRule> }>;
+};
+
+const service: HookAccess =
+  IncomingCallPolicyEscalationRuleService as unknown as HookAccess;
+
+const POLICY_ID: ObjectID = new ObjectID(
+  "11111111-1111-4111-8111-111111111111",
+);
+const USER_ID: ObjectID = new ObjectID("22222222-2222-4222-8222-222222222222");
+const SCHEDULE_ID: ObjectID = new ObjectID(
+  "33333333-3333-4333-8333-333333333333",
+);
+
+function makeCreateBy(
+  data: Partial<IncomingCallPolicyEscalationRule>,
+): CreateBy<IncomingCallPolicyEscalationRule> {
+  const rule: IncomingCallPolicyEscalationRule =
+    new IncomingCallPolicyEscalationRule();
+  Object.assign(rule, data);
+
+  return {
+    data: rule,
+    props: { isRoot: true },
+  } as CreateBy<IncomingCallPolicyEscalationRule>;
+}
+
+/*
+ * Spy handles are held through this rather than a SpyInstance type: two
+ * SpyInstance declarations are in scope in this project (the global jest
+ * namespace's two-parameter form and @jest/globals' one-parameter form), and
+ * naming the wrong one fails only in the compile job. These tests read
+ * exactly one thing off a spy, so that is all this names.
+ */
+interface SpyCalls {
+  mock: { calls: Array<Array<unknown>> };
+}
+
+// Ordering is exercised separately; stub the two calls that reach the DB.
+function stubCountBy(existingRules: number): SpyCalls {
+  return jest
+    .spyOn(IncomingCallPolicyEscalationRuleService, "countBy")
+    .mockResolvedValue(
+      new PositiveNumber(existingRules) as never,
+    ) as unknown as SpyCalls;
+}
+
+let countBy: SpyCalls;
+
+beforeEach(() => {
+  countBy = stubCountBy(0);
+
+  jest
+    .spyOn(IncomingCallPolicyEscalationRuleService, "findBy")
+    .mockResolvedValue([] as never);
+});
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+describe("IncomingCallPolicyEscalationRuleService.onBeforeCreate — target", () => {
+  test("accepts a rule that escalates to a user", async () => {
+    const result: { createBy: CreateBy<IncomingCallPolicyEscalationRule> } =
+      await service.onBeforeCreate(
+        makeCreateBy({
+          incomingCallPolicyId: POLICY_ID,
+          userId: USER_ID,
+        }),
+      );
+
+    expect(result.createBy.data.userId).toBe(USER_ID);
+  });
+
+  test("accepts a rule that escalates to an on-call schedule", async () => {
+    const result: { createBy: CreateBy<IncomingCallPolicyEscalationRule> } =
+      await service.onBeforeCreate(
+        makeCreateBy({
+          incomingCallPolicyId: POLICY_ID,
+          onCallDutyPolicyScheduleId: SCHEDULE_ID,
+        }),
+      );
+
+    expect(result.createBy.data.onCallDutyPolicyScheduleId).toBe(SCHEDULE_ID);
+  });
+
+  // A rule with no target would silently escalate to nobody.
+  test("rejects a rule with no target at all", async () => {
+    await expect(
+      service.onBeforeCreate(makeCreateBy({ incomingCallPolicyId: POLICY_ID })),
+    ).rejects.toThrow(BadDataException);
+
+    await expect(
+      service.onBeforeCreate(makeCreateBy({ incomingCallPolicyId: POLICY_ID })),
+    ).rejects.toThrow(/Either a User or an On-Call Schedule/);
+  });
+
+  // A rule with two targets is ambiguous about who the call reaches.
+  test("rejects a rule that names both a user and a schedule", async () => {
+    await expect(
+      service.onBeforeCreate(
+        makeCreateBy({
+          incomingCallPolicyId: POLICY_ID,
+          userId: USER_ID,
+          onCallDutyPolicyScheduleId: SCHEDULE_ID,
+        }),
+      ),
+    ).rejects.toThrow(/Only one of User or On-Call Schedule/);
+  });
+
+  test("rejects a rule that belongs to no policy", async () => {
+    await expect(
+      service.onBeforeCreate(makeCreateBy({ userId: USER_ID })),
+    ).rejects.toThrow(/incomingCallPolicyId is required/);
+  });
+
+  /*
+   * The target check runs before the policy check, so a payload that is wrong
+   * in both ways reports the target problem — the one the user can act on.
+   */
+  test("refuses an untargeted rule before it looks at the policy", async () => {
+    await expect(service.onBeforeCreate(makeCreateBy({}))).rejects.toThrow(
+      /Either a User or an On-Call Schedule/,
+    );
+  });
+
+  test("does not touch the database when validation fails", async () => {
+    await expect(
+      service.onBeforeCreate(makeCreateBy({ incomingCallPolicyId: POLICY_ID })),
+    ).rejects.toThrow(BadDataException);
+
+    expect(countBy.mock.calls).toHaveLength(0);
+  });
+});
+
+describe("IncomingCallPolicyEscalationRuleService.onBeforeCreate — order", () => {
+  /*
+   * A rule created without an explicit order goes to the end of the policy's
+   * escalation chain, which is one past the rules already there.
+   */
+  test("appends a rule with no order to the end of the chain", async () => {
+    countBy = stubCountBy(3);
+
+    const result: { createBy: CreateBy<IncomingCallPolicyEscalationRule> } =
+      await service.onBeforeCreate(
+        makeCreateBy({
+          incomingCallPolicyId: POLICY_ID,
+          userId: USER_ID,
+        }),
+      );
+
+    expect(result.createBy.data.order).toBe(4);
+  });
+
+  test("gives the first rule of a policy order 1", async () => {
+    countBy = stubCountBy(0);
+
+    const result: { createBy: CreateBy<IncomingCallPolicyEscalationRule> } =
+      await service.onBeforeCreate(
+        makeCreateBy({
+          incomingCallPolicyId: POLICY_ID,
+          userId: USER_ID,
+        }),
+      );
+
+    expect(result.createBy.data.order).toBe(1);
+  });
+
+  // Counting must be scoped to the policy, or orders collide across policies.
+  test("counts only the rules of the policy being appended to", async () => {
+    await service.onBeforeCreate(
+      makeCreateBy({
+        incomingCallPolicyId: POLICY_ID,
+        userId: USER_ID,
+      }),
+    );
+
+    const query: { incomingCallPolicyId?: ObjectID } = (
+      countBy.mock.calls[0]![0] as unknown as {
+        query: { incomingCallPolicyId?: ObjectID };
+      }
+    ).query;
+
+    expect(query.incomingCallPolicyId).toBe(POLICY_ID);
+  });
+
+  test("keeps an explicitly requested order", async () => {
+    const result: { createBy: CreateBy<IncomingCallPolicyEscalationRule> } =
+      await service.onBeforeCreate(
+        makeCreateBy({
+          incomingCallPolicyId: POLICY_ID,
+          userId: USER_ID,
+          order: 2,
+        }),
+      );
+
+    expect(result.createBy.data.order).toBe(2);
+    expect(countBy.mock.calls).toHaveLength(0);
+  });
+});

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

@@ -339,7 +339,7 @@ describe("existing InventoryItem display-name convergence", () => {
 });
 
 describe("InventoryItemService.deriveDisplayName for inferred dependencies", () => {
-  test("a database reads as its namespace, then its host, then its engine", () => {
+  test("a database reads as '<namespace> @ <server>', then its server, then its namespace, then its engine", () => {
     expect(
       InventoryItemService.deriveDisplayName(
         entity({
@@ -351,7 +351,7 @@ describe("InventoryItemService.deriveDisplayName for inferred dependencies", ()
           },
         }),
       ),
-    ).toBe("orders");
+    ).toBe("orders @ db.internal");
     expect(
       InventoryItemService.deriveDisplayName(
         entity({
@@ -363,6 +363,17 @@ describe("InventoryItemService.deriveDisplayName for inferred dependencies", ()
         }),
       ),
     ).toBe("cache.internal");
+    expect(
+      InventoryItemService.deriveDisplayName(
+        entity({
+          entityType: EntityType.Database,
+          identifyingAttributes: {
+            "db.system.name": "sqlite",
+            "db.namespace": "orders",
+          },
+        }),
+      ),
+    ).toBe("orders");
     expect(
       InventoryItemService.deriveDisplayName(
         entity({
@@ -373,6 +384,121 @@ describe("InventoryItemService.deriveDisplayName for inferred dependencies", ()
     ).toBe("sqlite");
   });
 
+  /*
+   * e2e: the Service Map's table search for "orders" listed nine rows all
+   * reading "orders · Database · PostgreSQL" - InventoryItem rows for
+   * 172.20.0.2, e2e-receivers-postgres, legacy-db.example.com,
+   * orders-db.example.com, orders-db.prod, orders-db-receivers.example.com,
+   * pg16.rcv-e2e.example.net, pgdb.corp.internal and rare-db.example.com,
+   * every one displayName "orders". Only opening each told them apart.
+   */
+  test("the e2e project's 'orders' databases get ten different names", () => {
+    const servers: Array<[string, string]> = [
+      ["172.20.0.2", "5432"],
+      ["e2e-receivers-postgres", "5432"],
+      ["legacy-db.example.com", "5432"],
+      ["orders-db.example.com", "5432"],
+      ["orders-db.prod", "5432"],
+      ["orders-db-receivers.example.com", "5432"],
+      ["pg16.rcv-e2e.example.net", "5432"],
+      ["pgdb.corp.internal", "5432"],
+      ["rare-db.example.com", "5432"],
+      ["orders-db.example.com", "6432"],
+    ];
+
+    const names: Array<string> = servers.map(
+      ([host, port]: [string, string]): string => {
+        return InventoryItemService.deriveDisplayName(
+          entity({
+            entityType: EntityType.Database,
+            identifyingAttributes: {
+              "db.system.name": "postgresql",
+              "server.address": host,
+              "db.namespace": "orders",
+            },
+            descriptiveAttributes: {
+              "db.system.name": "postgresql",
+              "oneuptime.database.endpoint": `${host}:${port}`,
+              "server.port": port,
+            },
+          }),
+        );
+      },
+    );
+
+    expect(new Set<string>(names).size).toBe(servers.length);
+    expect(names[0]).toBe("orders @ 172.20.0.2:5432");
+    expect(names[8]).toBe("orders @ rare-db.example.com:5432");
+    expect(names[9]).toBe("orders @ orders-db.example.com:6432");
+  });
+
+  test("the port is the one the calls named - none, or several, leaves it off", () => {
+    const identifying: Record<string, string> = {
+      "db.system.name": "postgresql",
+      "server.address": "orders-db.example.com",
+      "db.namespace": "orders",
+    };
+
+    for (const port of ["", "not-a-port"]) {
+      expect(
+        InventoryItemService.deriveDisplayName(
+          entity({
+            entityType: EntityType.Database,
+            identifyingAttributes: identifying,
+            descriptiveAttributes: { "server.port": port },
+          }),
+        ),
+      ).toBe("orders @ orders-db.example.com");
+    }
+  });
+
+  test("an IPv6 server is bracketed before its port; a host list keeps its own ports", () => {
+    expect(
+      InventoryItemService.deriveDisplayName(
+        entity({
+          entityType: EntityType.Database,
+          identifyingAttributes: {
+            "db.system.name": "postgresql",
+            "server.address": "fd00::5",
+            "db.namespace": "orders",
+          },
+          descriptiveAttributes: { "server.port": "5432" },
+        }),
+      ),
+    ).toBe("orders @ [fd00::5]:5432");
+    expect(
+      InventoryItemService.deriveDisplayName(
+        entity({
+          entityType: EntityType.Database,
+          identifyingAttributes: {
+            "db.system.name": "mongodb",
+            "server.address": "mongo-a:27017,mongo-b:27017",
+            "db.namespace": "orders",
+          },
+          descriptiveAttributes: { "server.port": "27017" },
+        }),
+      ),
+    ).toBe("orders @ mongo-a:27017,mongo-b:27017");
+  });
+
+  test("the name never changes the node's identity", () => {
+    const node: ExtractedEntity = entity({
+      entityType: EntityType.Database,
+      identifyingAttributes: {
+        "db.system.name": "postgresql",
+        "server.address": "orders-db.example.com",
+        "db.namespace": "orders",
+      },
+      descriptiveAttributes: { "server.port": "5432" },
+    });
+    const identityBefore: string = JSON.stringify(node.identifyingAttributes);
+
+    InventoryItemService.deriveDisplayName(node);
+
+    expect(JSON.stringify(node.identifyingAttributes)).toBe(identityBefore);
+    expect(node.entityKey).toBe("0123456789abcdef");
+  });
+
   test("a remote service reads as the name callers gave it, then its host", () => {
     expect(
       InventoryItemService.deriveDisplayName(
@@ -403,3 +529,155 @@ describe("InventoryItemService.deriveDisplayName for inferred dependencies", ()
     ).toBe("acme.ledger.v1.ledger");
   });
 });
+
+/*
+ * A Database dependency node describes the database SERVER its calls
+ * reached (`oneuptime.database.endpoint`, `server.port`) for the Service
+ * Map's "Open database" link. That description is presentation data: it
+ * never names the node, and a later run's '' (the node reached several
+ * servers) must overwrite a stale endpoint on the stored row.
+ */
+describe("a database node's server description", () => {
+  const identifying: Record<string, string> = {
+    "db.system.name": "postgresql",
+    "server.address": "postgres.data",
+    "db.namespace": "orders",
+  };
+
+  function databaseNode(descriptive: Record<string, string>): ExtractedEntity {
+    return entity({
+      entityType: EntityType.Database,
+      identifyingAttributes: identifying,
+      descriptiveAttributes: descriptive,
+    });
+  }
+
+  function descriptiveUpdate(
+    extracted: ExtractedEntity,
+    existing: InventoryItem,
+  ): Record<string, unknown> | undefined {
+    return (
+      InventoryItemService as unknown as {
+        buildDescriptiveUpdate: (
+          incoming: ExtractedEntity,
+          row: InventoryItem,
+        ) => { descriptiveAttributes?: Record<string, unknown> };
+      }
+    ).buildDescriptiveUpdate(extracted, existing).descriptiveAttributes;
+  }
+
+  test("the canonical endpoint never names the node: the host its calls named does, with their port", () => {
+    expect(
+      InventoryItemService.deriveDisplayName(
+        databaseNode({
+          "db.system.name": "postgresql",
+          "oneuptime.database.endpoint":
+            "postgres.data.svc.cluster.local:5432@prod-eu",
+          "server.port": "5432",
+        }),
+      ),
+    ).toBe("orders @ postgres.data:5432");
+  });
+
+  function displayNameUpdate(
+    extracted: ExtractedEntity,
+    existingName: string | undefined,
+  ): string | undefined {
+    const existing: InventoryItem = new InventoryItem();
+    existing.displayName = existingName as string;
+    return (
+      InventoryItemService as unknown as {
+        buildDescriptiveUpdate: (
+          incoming: ExtractedEntity,
+          row: InventoryItem,
+        ) => { displayName?: string };
+      }
+    ).buildDescriptiveUpdate(extracted, existing).displayName;
+  }
+
+  test("a node still named by the old rule ('orders') is renamed when seen again", () => {
+    expect(
+      displayNameUpdate(databaseNode({ "server.port": "5432" }), "orders"),
+    ).toBe("orders @ postgres.data:5432");
+    expect(displayNameUpdate(databaseNode({ "server.port": "5432" }), "")).toBe(
+      "orders @ postgres.data:5432",
+    );
+  });
+
+  test("a port-less generated name gains the port once the calls name one", () => {
+    expect(
+      displayNameUpdate(
+        databaseNode({ "server.port": "5432" }),
+        "orders @ postgres.data",
+      ),
+    ).toBe("orders @ postgres.data:5432");
+  });
+
+  test("a name a person typed is never replaced", () => {
+    expect(
+      displayNameUpdate(
+        databaseNode({ "server.port": "5432" }),
+        "Orders primary (eu)",
+      ),
+    ).toBeUndefined();
+  });
+
+  test("a sighting that names no port does not undo a name that has one", () => {
+    expect(
+      displayNameUpdate(
+        databaseNode({ "server.port": "" }),
+        "orders @ postgres.data:5432",
+      ),
+    ).toBeUndefined();
+  });
+
+  test("a current name writes nothing", () => {
+    expect(
+      displayNameUpdate(
+        databaseNode({ "server.port": "5432" }),
+        "orders @ postgres.data:5432",
+      ),
+    ).toBeUndefined();
+  });
+
+  test("an ambiguous ('') description overwrites a stale endpoint, keeping the rest", () => {
+    const existing: InventoryItem = new InventoryItem();
+    existing.displayName = "orders";
+    existing.descriptiveAttributes = {
+      "db.system.name": "postgresql",
+      "oneuptime.database.endpoint":
+        "postgres.data.svc.cluster.local:5432@prod-eu",
+      "server.port": "5432",
+    };
+
+    expect(
+      descriptiveUpdate(
+        databaseNode({
+          "db.system.name": "postgresql",
+          "oneuptime.database.endpoint": "",
+          "server.port": "5432",
+        }),
+        existing,
+      ),
+    ).toEqual({
+      "db.system.name": "postgresql",
+      "oneuptime.database.endpoint": "",
+      "server.port": "5432",
+    });
+  });
+
+  test("an unchanged description writes nothing", () => {
+    const description: Record<string, string> = {
+      "db.system.name": "postgresql",
+      "oneuptime.database.endpoint":
+        "postgres.data.svc.cluster.local:5432@prod-eu",
+    };
+    const existing: InventoryItem = new InventoryItem();
+    existing.displayName = "orders";
+    existing.descriptiveAttributes = { ...description };
+
+    expect(
+      descriptiveUpdate(databaseNode(description), existing),
+    ).toBeUndefined();
+  });
+});

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

@@ -245,7 +245,8 @@ const CASES: Array<UpsertCase> = [
     service: DockerResourceService,
     model: new DockerResource(),
     boundedColumnCount: 5,
-    jsonPayloadColumnCount: 0,
+    // The Compose / Testcontainers labels the agent copies onto its metrics.
+    jsonPayloadColumnCount: 1,
     invoke: async (): Promise<void> => {
       await DockerResourceService.bulkUpsertContainers({
         projectId: PROJECT_ID,
@@ -259,6 +260,8 @@ const CASES: Array<UpsertCase> = [
             cpuPercent: 1,
             memoryBytes: 1024,
             observedAt: OBSERVED_AT,
+            labels: { "com.docker.compose.project": OVERSIZED },
+            startedAt: OBSERVED_AT,
           },
         ],
       });
@@ -294,7 +297,8 @@ const CASES: Array<UpsertCase> = [
     service: PodmanResourceService,
     model: new PodmanResource(),
     boundedColumnCount: 5,
-    jsonPayloadColumnCount: 0,
+    // The Compose / Testcontainers labels the agent copies onto its metrics.
+    jsonPayloadColumnCount: 1,
     invoke: async (): Promise<void> => {
       await PodmanResourceService.bulkUpsertContainers({
         projectId: PROJECT_ID,
@@ -308,6 +312,8 @@ const CASES: Array<UpsertCase> = [
             cpuPercent: 1,
             memoryBytes: 1024,
             observedAt: OBSERVED_AT,
+            labels: { "com.docker.compose.project": OVERSIZED },
+            startedAt: OBSERVED_AT,
           },
         ],
       });