@oneuptime/common 11.5.8 → 11.5.10

package/Tests/Models/StatusPageEnableMcpServer.test.ts

@@ -0,0 +1,125 @@
+/**
+ * StatusPage.enableMcpServer column contract.
+ *
+ * The feature's headline promise is "MCP stays on unless the owner turns it
+ * off". Three separate mechanisms carry that promise, and they are easy to
+ * confuse:
+ * - NEW rows get true from the Postgres column default, declared by
+ *   @Column({ default: true }) and stored in TypeORM's metadata
+ * - EXISTING rows got true from the migration's NOT NULL DEFAULT true
+ * - @TableColumn({ defaultValue: true }) is documentation only — it feeds the
+ *   generated API schema and form metadata, and defaults nothing at runtime
+ *
+ * All three are pinned below, because a one-word edit to any of them silently
+ * flips the default for everyone. Asserting only the @TableColumn metadata
+ * would be a guard that catches nothing: flipping @Column to default: false
+ * leaves that assertion green while every new status page ships with MCP off.
+ *
+ * isDefaultValueColumn is pinned too: it keeps the column optional on create,
+ * where required: true would make DatabaseService reject creates that omit it.
+ */
+
+import StatusPage from "../../Models/DatabaseModels/StatusPage";
+import { TableColumnMetadata } from "../../Types/Database/TableColumn";
+import TableColumnType from "../../Types/Database/TableColumnType";
+import Permission from "../../Types/Permission";
+import { describe, expect, test } from "@jest/globals";
+import { getMetadataArgsStorage } from "typeorm";
+import { ColumnMetadataArgs } from "typeorm/metadata-args/ColumnMetadataArgs";
+import fs from "fs";
+import path from "path";
+
+const COLUMN: string = "enableMcpServer";
+
+const MIGRATION_PATH: string = path.join(
+  __dirname,
+  "..",
+  "..",
+  "Server",
+  "Infrastructure",
+  "Postgres",
+  "SchemaMigrations",
+  "1784137457184-AddEnableMcpServerToStatusPage.ts",
+);
+
+function metadata(): TableColumnMetadata {
+  return new StatusPage().getTableColumnMetadata(COLUMN);
+}
+
+function typeOrmColumn(): ColumnMetadataArgs | undefined {
+  return getMetadataArgsStorage().columns.find((column: ColumnMetadataArgs) => {
+    return column.target === StatusPage && column.propertyName === COLUMN;
+  });
+}
+
+describe("StatusPage.enableMcpServer", () => {
+  test("exists as a boolean column", () => {
+    expect(metadata()).toBeDefined();
+    expect(metadata().type).toBe(TableColumnType.Boolean);
+  });
+
+  test("a newly created status page has MCP enabled", () => {
+    /*
+     * This is the assertion that actually protects new status pages: the
+     * Postgres column default. Nothing else populates the column when a create
+     * omits it.
+     */
+    expect(typeOrmColumn()).toBeDefined();
+    expect(typeOrmColumn()?.options.default).toBe(true);
+  });
+
+  test("every pre-existing status page was backfilled as enabled", () => {
+    /*
+     * The migration is the only thing that decided the value for status pages
+     * that existed before this feature. Because isMcpServerEnabled queries
+     * `enableMcpServer: true`, losing this default would silently gate every
+     * status page created before the migration ran.
+     */
+    const migration: string = fs.readFileSync(MIGRATION_PATH, "utf8");
+
+    expect(migration).toContain('ALTER TABLE "StatusPage"');
+    expect(migration).toContain(
+      `ADD "${COLUMN}" boolean NOT NULL DEFAULT true`,
+    );
+  });
+
+  test("is documented as defaulting to enabled", () => {
+    /*
+     * Feeds the generated API schema and form metadata. Documentation only —
+     * see the tests above for the defaults that actually apply.
+     */
+    expect(metadata().defaultValue).toBe(true);
+  });
+
+  test("is a default-value column, so create may omit it", () => {
+    expect(new StatusPage().isDefaultValueColumn(COLUMN)).toBe(true);
+  });
+
+  test("is not required, so existing create calls keep working", () => {
+    expect(metadata().required).toBeFalsy();
+  });
+
+  test("is readable by status page viewers", () => {
+    const accessControl: Array<Permission> | undefined =
+      new StatusPage().getColumnAccessControlFor(COLUMN)?.read;
+
+    expect(accessControl).toContain(Permission.ProjectMember);
+    expect(accessControl).toContain(Permission.StatusPageAdmin);
+  });
+
+  test("is editable by status page editors", () => {
+    const accessControl: Array<Permission> | undefined =
+      new StatusPage().getColumnAccessControlFor(COLUMN)?.update;
+
+    expect(accessControl).toContain(Permission.EditProjectStatusPage);
+    expect(accessControl).toContain(Permission.StatusPageAdmin);
+  });
+
+  test("is not editable by a read-only viewer", () => {
+    const accessControl: Array<Permission> | undefined =
+      new StatusPage().getColumnAccessControlFor(COLUMN)?.update;
+
+    expect(accessControl).not.toContain(Permission.Viewer);
+    expect(accessControl).not.toContain(Permission.StatusPageViewer);
+  });
+});

package/Tests/Server/API/BaseAnalyticsAPI.test.ts

@@ -0,0 +1,72 @@
+import "../TestingUtils/Init";
+import BaseAnalyticsAPI from "../../../Server/API/BaseAnalyticsAPI";
+import AnalyticsDataModel from "../../../Models/AnalyticsModels/AnalyticsBaseModel/AnalyticsBaseModel";
+import AggregateBy from "../../../Types/BaseDatabase/AggregateBy";
+import { LIMIT_PER_PROJECT } from "../../../Types/Database/LimitMax";
+import { describe, expect, it } from "@jest/globals";
+
+describe("BaseAnalyticsAPI.clampAggregateLimit", () => {
+  type MakeAggregateByFunction = (
+    limit: unknown,
+  ) => AggregateBy<AnalyticsDataModel>;
+
+  const makeAggregateBy: MakeAggregateByFunction = (
+    limit: unknown,
+  ): AggregateBy<AnalyticsDataModel> => {
+    return { limit } as unknown as AggregateBy<AnalyticsDataModel>;
+  };
+
+  it("clamps a client-sent limit above LIMIT_PER_PROJECT down to LIMIT_PER_PROJECT", () => {
+    const aggregateBy: AggregateBy<AnalyticsDataModel> =
+      makeAggregateBy(999999999);
+
+    BaseAnalyticsAPI.clampAggregateLimit(aggregateBy);
+
+    expect(aggregateBy.limit).toBe(LIMIT_PER_PROJECT);
+  });
+
+  it("clamps limit = LIMIT_PER_PROJECT + 1", () => {
+    const aggregateBy: AggregateBy<AnalyticsDataModel> = makeAggregateBy(
+      LIMIT_PER_PROJECT + 1,
+    );
+
+    BaseAnalyticsAPI.clampAggregateLimit(aggregateBy);
+
+    expect(aggregateBy.limit).toBe(LIMIT_PER_PROJECT);
+  });
+
+  it("does NOT clamp down to 1000 — grouped charts legitimately use the full 10k", () => {
+    const aggregateBy: AggregateBy<AnalyticsDataModel> =
+      makeAggregateBy(LIMIT_PER_PROJECT);
+
+    BaseAnalyticsAPI.clampAggregateLimit(aggregateBy);
+
+    expect(aggregateBy.limit).toBe(LIMIT_PER_PROJECT);
+  });
+
+  it("leaves an in-range limit untouched", () => {
+    const aggregateBy: AggregateBy<AnalyticsDataModel> = makeAggregateBy(500);
+
+    BaseAnalyticsAPI.clampAggregateLimit(aggregateBy);
+
+    expect(aggregateBy.limit).toBe(500);
+  });
+
+  it("leaves an absent limit for the service layer's own defaulting", () => {
+    const aggregateBy: AggregateBy<AnalyticsDataModel> =
+      makeAggregateBy(undefined);
+
+    BaseAnalyticsAPI.clampAggregateLimit(aggregateBy);
+
+    expect(aggregateBy.limit).toBeUndefined();
+  });
+
+  it("leaves a non-numeric limit untouched (existing validation handles it)", () => {
+    const aggregateBy: AggregateBy<AnalyticsDataModel> =
+      makeAggregateBy("not-a-number");
+
+    BaseAnalyticsAPI.clampAggregateLimit(aggregateBy);
+
+    expect(aggregateBy.limit).toBe("not-a-number" as unknown as number);
+  });
+});

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

@@ -36,7 +36,15 @@ function mockRedisClient(): ClientType {
 }
 
 function lastMockPermit(): MockPermit {
-  const result: unknown = redisSemaphoreConstructor.mock.results.at(-1)?.value;
+  /*
+   * Indexed rather than .at(-1): this project targets es2017, so
+   * Array.prototype.at is outside its lib. Older @types/node pulled in newer
+   * lib references that happened to declare it, which is why this compiled
+   * before the types were aligned with the Node 26 runtime.
+   */
+  const results: Array<{ value: unknown }> =
+    redisSemaphoreConstructor.mock.results;
+  const result: unknown = results[results.length - 1]?.value;
   return result as MockPermit;
 }
 

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

@@ -364,14 +364,33 @@ describe("AnalyticsDatabaseService", () => {
       const query: string = service.toAggregateStatement(makeBaseAggregateBy())
         .statement.query;
 
-      // 1-day window derives an Hour bucket, grouped by the time column.
+      /*
+       * 1-day window derives a FifteenMinutes bucket (see
+       * AggregationIntervalUtil), which compiles through the shared
+       * expression map — NOT via lowercasing the enum into date_trunc.
+       */
       expect(query).toContain(
-        "date_trunc('hour', toStartOfInterval(column_ObjectID, INTERVAL 1 hour))",
+        "toStartOfInterval(column_ObjectID, INTERVAL 15 MINUTE) as column_ObjectID",
       );
+      expect(query).not.toContain("date_trunc('fifteenminutes'");
       expect(query).toContain("GROUP BY column_ObjectID");
       expect(query).not.toContain("min(column_ObjectID)");
     });
 
+    test("derives an Hour bucket for a 5-day window", () => {
+      const query: string = service.toAggregateStatement(
+        makeBaseAggregateBy({
+          startTimestamp: new Date("2024-01-01"),
+          endTimestamp: new Date("2024-01-06"),
+        }),
+      ).statement.query;
+
+      expect(query).toContain(
+        "date_trunc('hour', toStartOfInterval(column_ObjectID, INTERVAL 1 hour))",
+      );
+      expect(query).toContain("GROUP BY column_ObjectID");
+    });
+
     test("Total with no group-by drops the time bucket and guards empty windows", () => {
       const query: string = service.toAggregateStatement(
         makeBaseAggregateBy({ aggregationInterval: "Total" }),

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

@@ -0,0 +1,173 @@
+import TelemetryEntity, {
+  ExtractedEntity,
+  keyForContainer,
+} from "../../../Server/Utils/Telemetry/TelemetryEntity";
+import {
+  keyForHost,
+  keyForKubernetesCluster,
+  keyForService,
+} from "../../../Utils/Telemetry/EntityKey";
+import EntityType from "../../../Types/Telemetry/EntityType";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * Pins the read-side key derivations MetricService's entity-MV routing
+ * uses (keyForHost / keyForKubernetesCluster / keyForContainer /
+ * keyForService) against the ingest side that stamps the scalar
+ * entity-key columns the per-entity rollup MVs group by
+ * (TelemetryEntity.extractEntities -> serviceEntityKey / hostEntityKey /
+ * k8sClusterEntityKey / containerEntityKey on MetricItemV3; the MVs copy
+ * the stamped column verbatim — `WHERE <key> != '' GROUP BY ... <key>`).
+ *
+ * Byte-equality between the two sides is what makes an MV lookup
+ * correct: a routed predicate whose key doesn't match the stamp finds
+ * nothing. This is the sibling of EntityKeySqlParity.test.ts (which pins
+ * keyForHost against ClickHouse's SQL SHA-256); the host vector below
+ * reuses that test's live-ClickHouse-verified literal so the ingest
+ * stamping stays anchored to the same externally computed value.
+ */
+describe("entity-MV routing keys — parity with ingest-stamped scalar entity keys", () => {
+  const projectId: string = "proj-123";
+
+  /*
+   * A resource carrying all four routable identities at once, with
+   * casing/whitespace drift to exercise canonicalization.
+   */
+  const attributes: Record<string, string> = {
+    "host.name": "Web-Server-01 ",
+    "k8s.cluster.name": "Prod-EU-1",
+    "container.id": "ABC123def456",
+    "service.name": "Checkout",
+  };
+
+  type FirstOfTypeFunction = (
+    entities: Array<ExtractedEntity>,
+    entityType: EntityType,
+  ) => string;
+
+  /*
+   * Mirrors OtelIngestBaseService.scalarEntityKeysFromEntities: the
+   * FIRST extracted entity of a type is what lands in the scalar column
+   * ('' when the type is absent).
+   */
+  const firstOfType: FirstOfTypeFunction = (
+    entities: Array<ExtractedEntity>,
+    entityType: EntityType,
+  ): string => {
+    return (
+      entities.find((entity: ExtractedEntity) => {
+        return entity.entityType === entityType;
+      })?.entityKey || ""
+    );
+  };
+
+  test("each routable read-side key byte-matches the stamped scalar column", () => {
+    const entities: Array<ExtractedEntity> = TelemetryEntity.extractEntities({
+      projectId,
+      attributes,
+    });
+
+    expect(firstOfType(entities, EntityType.Host)).toBe(
+      keyForHost(projectId, "Web-Server-01 "),
+    );
+    expect(firstOfType(entities, EntityType.KubernetesCluster)).toBe(
+      keyForKubernetesCluster(projectId, "Prod-EU-1"),
+    );
+    expect(firstOfType(entities, EntityType.Container)).toBe(
+      keyForContainer(projectId, "ABC123def456"),
+    );
+    expect(firstOfType(entities, EntityType.Service)).toBe(
+      keyForService(projectId, "Checkout"),
+    );
+  });
+
+  test("read-side keys canonicalize exactly like ingest (spelling drift lands on one rollup stream)", () => {
+    const drifted: Array<ExtractedEntity> = TelemetryEntity.extractEntities({
+      projectId,
+      attributes: {
+        "host.name": "web-server-01",
+        "k8s.cluster.name": " prod-eu-1 ",
+        "container.id": "abc123DEF456",
+        "service.name": "  checkout",
+      },
+    });
+
+    expect(firstOfType(drifted, EntityType.Host)).toBe(
+      keyForHost(projectId, "Web-Server-01 "),
+    );
+    expect(firstOfType(drifted, EntityType.KubernetesCluster)).toBe(
+      keyForKubernetesCluster(projectId, "Prod-EU-1"),
+    );
+    expect(firstOfType(drifted, EntityType.Container)).toBe(
+      keyForContainer(projectId, "ABC123def456"),
+    );
+    expect(firstOfType(drifted, EntityType.Service)).toBe(
+      keyForService(projectId, "Checkout"),
+    );
+  });
+
+  test("host stamping matches the live-ClickHouse-verified vector from EntityKeySqlParity", () => {
+    const entities: Array<ExtractedEntity> = TelemetryEntity.extractEntities({
+      projectId: "proj-123",
+      attributes: { "host.name": "Web-Server-01 " },
+    });
+
+    // Literal output of ClickHouse 25.7's SHA-256 SQL for this identity.
+    expect(firstOfType(entities, EntityType.Host)).toBe("dba90fb9cca1242e");
+  });
+
+  test("service.namespace forks the stamped key — the bare-name key MUST NOT be assumed (registry required)", () => {
+    const namespaced: Array<ExtractedEntity> = TelemetryEntity.extractEntities({
+      projectId,
+      attributes: {
+        "service.name": "checkout",
+        "service.namespace": "prod",
+      },
+    });
+
+    const stampedKey: string = firstOfType(namespaced, EntityType.Service);
+
+    // Ingest folds the namespace in ...
+    expect(stampedKey).toBe(keyForService(projectId, "checkout", "prod"));
+    /*
+     * ... so the bare-name derivation finds NOTHING for these rows. This
+     * is why MetricService resolves service key SETS from the registry
+     * and falls back to raw on a miss, instead of computing one key.
+     */
+    expect(stampedKey).not.toBe(keyForService(projectId, "checkout"));
+  });
+
+  test("a blank namespace is not identity-bearing on either side", () => {
+    const blankNamespace: Array<ExtractedEntity> =
+      TelemetryEntity.extractEntities({
+        projectId,
+        attributes: {
+          "service.name": "checkout",
+          "service.namespace": "   ",
+        },
+      });
+
+    expect(firstOfType(blankNamespace, EntityType.Service)).toBe(
+      keyForService(projectId, "checkout"),
+    );
+    expect(keyForService(projectId, "checkout", "   ")).toBe(
+      keyForService(projectId, "checkout"),
+    );
+  });
+
+  test("entityKeys membership (the entityScope raw predicate) contains every routable key", () => {
+    const membershipKeys: Array<string> = TelemetryEntity.extractEntityKeys({
+      projectId,
+      attributes,
+    });
+
+    for (const key of [
+      keyForHost(projectId, "Web-Server-01 "),
+      keyForKubernetesCluster(projectId, "Prod-EU-1"),
+      keyForContainer(projectId, "ABC123def456"),
+      keyForService(projectId, "Checkout"),
+    ]) {
+      expect(membershipKeys).toContain(key);
+    }
+  });
+});