@oneuptime/common 12.0.12 → 12.0.14

package/Tests/Server/Utils/AnalyticsDatabase/StatementGenerator.test.ts

@@ -956,6 +956,219 @@ describe("StatementGenerator", () => {
       });
     });
 
+    /*
+     * resourceEntityScopes: the compiled form of a resource-facet selection
+     * (a Kubernetes cluster, a host, ...). Unlike entityScope it carries an
+     * `entityIds` branch, because the same resource can be a row's PRIMARY
+     * entity (agent-ingested telemetry) or merely one of its memberships
+     * (OTLP telemetry primary-keyed on its Service). Matching only
+     * primaryEntityId is what made a cluster filter return zero rows for
+     * collector-ingested logs.
+     */
+    describe("resourceEntityScopes synthetic key", () => {
+      class ResourceScopeModel extends AnalyticsBaseModel {
+        public constructor() {
+          super({
+            tableName: "<resource-scope-table>",
+            singularName: "<singular>",
+            pluralName: "<plural>",
+            tableColumns: [
+              new AnalyticsTableColumn({
+                key: "_id",
+                title: "<title>",
+                description: "<description>",
+                required: true,
+                type: TableColumnType.ObjectID,
+              }),
+              new AnalyticsTableColumn({
+                key: "primaryEntityId",
+                title: "<title>",
+                description: "<description>",
+                required: true,
+                type: TableColumnType.ObjectID,
+              }),
+              new AnalyticsTableColumn({
+                key: "entityKeys",
+                title: "<title>",
+                description: "<description>",
+                required: true,
+                defaultValue: [],
+                type: TableColumnType.ArrayText,
+              }),
+              new AnalyticsTableColumn({
+                key: "attributes",
+                title: "<title>",
+                description: "<description>",
+                required: true,
+                defaultValue: {},
+                type: TableColumnType.MapStringString,
+              }),
+            ],
+            crudApiPath: new Route("route"),
+            primaryKeys: ["_id"],
+            sortKeys: ["_id"],
+            partitionKey: "_id",
+            tableEngine: AnalyticsTableEngine.MergeTree,
+          });
+        }
+      }
+
+      const CLUSTER_ID: string = "8c0f2f1e-2e4f-4a8c-9a1a-2f5b6c7d8e9f";
+      const HOST_ID: string = "5f4e3d2c-1b0a-4998-8776-655443322110";
+
+      let resourceGenerator: StatementGenerator<ResourceScopeModel>;
+      beforeEach(() => {
+        resourceGenerator = new StatementGenerator<ResourceScopeModel>({
+          modelType: ResourceScopeModel,
+          database: ClickhouseAppInstance,
+        });
+      });
+
+      test("ORs the three membership branches inside one scope", () => {
+        const statement: Statement = resourceGenerator.toWhereStatement({
+          resourceEntityScopes: [
+            {
+              entityIds: [CLUSTER_ID],
+              entityKeys: ["210dac24142f1baa"],
+              attributeKey: "resource.k8s.cluster.name",
+              attributeValues: ["prod-eu"],
+            },
+          ],
+        } as any);
+
+        expect(statement.query).toBe(
+          "AND ({p0:Identifier} IN {p1:Array(String)} OR hasAny({p2:Identifier}, {p3:Array(String)}) OR {p4:Identifier}[{p5:String}] IN {p6:Array(String)})",
+        );
+        expect(statement.query_params).toStrictEqual({
+          p0: "primaryEntityId",
+          p1: [CLUSTER_ID],
+          p2: "entityKeys",
+          p3: ["210dac24142f1baa"],
+          p4: "attributes",
+          p5: "resource.k8s.cluster.name",
+          p6: ["prod-eu"],
+        });
+      });
+
+      test("ANDs separate scopes so two facets intersect", () => {
+        const statement: Statement = resourceGenerator.toWhereStatement({
+          resourceEntityScopes: [
+            { entityIds: [CLUSTER_ID], entityKeys: ["210dac24142f1baa"] },
+            { entityIds: [HOST_ID], entityKeys: ["9f8e7d6c5b4a3928"] },
+          ],
+        } as any);
+
+        expect(statement.query).toBe(
+          "AND ({p0:Identifier} IN {p1:Array(String)} OR hasAny({p2:Identifier}, {p3:Array(String)})) " +
+            "AND ({p4:Identifier} IN {p5:Array(String)} OR hasAny({p6:Identifier}, {p7:Array(String)}))",
+        );
+      });
+
+      test("composes with a Services predicate — cluster AND service", () => {
+        const statement: Statement = resourceGenerator.toWhereStatement({
+          primaryEntityId: "<service-id>",
+          resourceEntityScopes: [
+            { entityIds: [CLUSTER_ID], entityKeys: ["210dac24142f1baa"] },
+          ],
+        } as any);
+
+        /*
+         * The regression the issue reports: these two used to be coalesced
+         * into ONE primaryEntityId IN (...) list, so adding a service made
+         * results reappear while silently dropping the cluster.
+         */
+        expect(statement.query).toBe(
+          "AND {p0:Identifier} = {p1:String} " +
+            "AND ({p2:Identifier} IN {p3:Array(String)} OR hasAny({p4:Identifier}, {p5:Array(String)}))",
+        );
+      });
+
+      test("a scope that resolved to ids only still narrows by primaryEntityId", () => {
+        const statement: Statement = resourceGenerator.toWhereStatement({
+          resourceEntityScopes: [{ entityIds: [CLUSTER_ID], entityKeys: [] }],
+        } as any);
+
+        expect(statement.query).toBe(
+          "AND ({p0:Identifier} IN {p1:Array(String)})",
+        );
+      });
+
+      test("an empty scope emits no predicate rather than an empty IN", () => {
+        const statement: Statement = resourceGenerator.toWhereStatement({
+          resourceEntityScopes: [{ entityIds: [], entityKeys: [] }],
+        } as any);
+
+        expect(statement.query).toBe("");
+        expect(statement.query_params).toStrictEqual({});
+      });
+
+      test("an empty scope does not break separators for later predicates", () => {
+        const statement: Statement = resourceGenerator.toWhereStatement({
+          resourceEntityScopes: [{ entityIds: [], entityKeys: [] }],
+          _id: "<value>",
+        } as any);
+
+        expect(statement.query).toBe("AND {p0:Identifier} = {p1:String}");
+      });
+
+      test("a non-array value carries no predicate", () => {
+        const statement: Statement = resourceGenerator.toWhereStatement({
+          resourceEntityScopes: { entityIds: [CLUSTER_ID] },
+        } as any);
+
+        expect(statement.query).toBe("");
+      });
+
+      test("blank ids and keys are filtered out of their branches", () => {
+        const statement: Statement = resourceGenerator.toWhereStatement({
+          resourceEntityScopes: [
+            { entityIds: ["", CLUSTER_ID], entityKeys: [""] },
+          ],
+        } as any);
+
+        expect(statement.query).toBe(
+          "AND ({p0:Identifier} IN {p1:Array(String)})",
+        );
+        expect(statement.query_params).toStrictEqual({
+          p0: "primaryEntityId",
+          p1: [CLUSTER_ID],
+        });
+      });
+
+      test("drops the branches whose backing column the model lacks", () => {
+        // TestModel (outer generator) has neither primaryEntityId nor entityKeys.
+        const statement: Statement = generator.toWhereStatement({
+          resourceEntityScopes: [
+            { entityIds: [CLUSTER_ID], entityKeys: ["210dac24142f1baa"] },
+          ],
+        } as any);
+
+        expect(statement.query).toBe("");
+      });
+
+      test("qualifies every branch when a table alias is in play", () => {
+        const statement: Statement = resourceGenerator.toWhereStatement(
+          {
+            resourceEntityScopes: [
+              {
+                entityIds: [CLUSTER_ID],
+                entityKeys: ["210dac24142f1baa"],
+                attributeKey: "resource.k8s.cluster.name",
+                attributeValues: ["prod-eu"],
+              },
+            ],
+          } as any,
+          { tableAlias: "t" },
+        );
+
+        expect(statement.query).toBe(
+          "AND ({p0_t:Identifier}.{p0_c:Identifier} IN {p1:Array(String)} OR " +
+            "hasAny({p2_t:Identifier}.{p2_c:Identifier}, {p3:Array(String)}) OR " +
+            "{p4_t:Identifier}.{p4_c:Identifier}[{p5:String}] IN {p6:Array(String)})",
+        );
+      });
+    });
+
     /*
      * Table qualification (tableAlias option). Aggregate statements
      * alias expressions to real column names (`sum(col) as col`, and

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

@@ -0,0 +1,162 @@
+import { describe, expect, test } from "@jest/globals";
+import BrowserUtil from "../../../Server/Utils/Browser";
+import ScreenSizeType from "../../../Types/ScreenSizeType";
+
+/*
+ * BrowserUtil.getViewportHeightAndWidth is a pure, synchronous lookup: it maps
+ * a ScreenSizeType enum value to a fixed viewport { height, width }. It has one
+ * switch case per enum member plus a default arm that mirrors Desktop.
+ *
+ * These tests pin every branch (Desktop, Mobile, Tablet, default), the exact
+ * pixel values each branch returns, and the shape/orientation invariants that
+ * downstream page.setViewportSize relies on. The function touches no network,
+ * no filesystem, no clock and no randomness, so every assertion is fully
+ * deterministic.
+ */
+
+interface Viewport {
+  height: number;
+  width: number;
+}
+
+function viewportFor(screenSizeType: ScreenSizeType): Viewport {
+  return BrowserUtil.getViewportHeightAndWidth({
+    screenSizeType: screenSizeType,
+  });
+}
+
+describe("BrowserUtil.getViewportHeightAndWidth", () => {
+  describe("per screen size branch", () => {
+    test("Desktop maps to 1920x1080 (landscape full HD)", () => {
+      const viewport: Viewport = viewportFor(ScreenSizeType.Desktop);
+
+      expect(viewport).toEqual({ height: 1080, width: 1920 });
+    });
+
+    test("Mobile maps to 360x640 (portrait handset)", () => {
+      const viewport: Viewport = viewportFor(ScreenSizeType.Mobile);
+
+      expect(viewport).toEqual({ height: 640, width: 360 });
+    });
+
+    test("Tablet maps to 1024x768", () => {
+      const viewport: Viewport = viewportFor(ScreenSizeType.Tablet);
+
+      expect(viewport).toEqual({ height: 768, width: 1024 });
+    });
+  });
+
+  describe("default / unknown branch", () => {
+    test("an unknown screen size falls through to the Desktop defaults", () => {
+      /*
+       * The switch has an explicit default arm that assigns the same 1080x1920
+       * as Desktop. It is only reachable with a value outside the enum, so we
+       * cast an arbitrary string through unknown to exercise it. If a future
+       * change forgets the default, this catches the resulting 0x0 viewport.
+       */
+      const viewport: Viewport = viewportFor(
+        "SomeUnsupportedSize" as unknown as ScreenSizeType,
+      );
+
+      expect(viewport).toEqual({ height: 1080, width: 1920 });
+    });
+
+    test("the default branch never returns the 0x0 initial values", () => {
+      const viewport: Viewport = viewportFor("" as unknown as ScreenSizeType);
+
+      expect(viewport.height).toBeGreaterThan(0);
+      expect(viewport.width).toBeGreaterThan(0);
+    });
+
+    test("default and Desktop are indistinguishable", () => {
+      const desktop: Viewport = viewportFor(ScreenSizeType.Desktop);
+      const unknown: Viewport = viewportFor(
+        "not-a-real-size" as unknown as ScreenSizeType,
+      );
+
+      expect(unknown).toEqual(desktop);
+    });
+  });
+
+  describe("shape and value invariants", () => {
+    const allSizes: Array<ScreenSizeType> = [
+      ScreenSizeType.Desktop,
+      ScreenSizeType.Mobile,
+      ScreenSizeType.Tablet,
+    ];
+
+    test("every enum member yields exactly a height and width", () => {
+      for (const size of allSizes) {
+        const viewport: Viewport = viewportFor(size);
+
+        expect(Object.keys(viewport).sort()).toEqual(["height", "width"]);
+      }
+    });
+
+    test("every dimension is a positive, finite integer", () => {
+      for (const size of allSizes) {
+        const viewport: Viewport = viewportFor(size);
+
+        for (const value of [viewport.height, viewport.width]) {
+          expect(Number.isInteger(value)).toBe(true);
+          expect(Number.isFinite(value)).toBe(true);
+          expect(value).toBeGreaterThan(0);
+        }
+      }
+    });
+
+    test("Mobile is the only portrait orientation; Desktop and Tablet are landscape", () => {
+      const mobile: Viewport = viewportFor(ScreenSizeType.Mobile);
+      const desktop: Viewport = viewportFor(ScreenSizeType.Desktop);
+      const tablet: Viewport = viewportFor(ScreenSizeType.Tablet);
+
+      expect(mobile.width).toBeLessThan(mobile.height);
+      expect(desktop.width).toBeGreaterThan(desktop.height);
+      expect(tablet.width).toBeGreaterThan(tablet.height);
+    });
+
+    test("Desktop is the largest surface and Mobile the smallest", () => {
+      const areaOf: (viewport: Viewport) => number = (
+        viewport: Viewport,
+      ): number => {
+        return viewport.height * viewport.width;
+      };
+
+      const desktopArea: number = areaOf(viewportFor(ScreenSizeType.Desktop));
+      const tabletArea: number = areaOf(viewportFor(ScreenSizeType.Tablet));
+      const mobileArea: number = areaOf(viewportFor(ScreenSizeType.Mobile));
+
+      expect(desktopArea).toBeGreaterThan(tabletArea);
+      expect(tabletArea).toBeGreaterThan(mobileArea);
+    });
+
+    test("the three known sizes are all distinct", () => {
+      const serialized: Array<string> = allSizes.map(
+        (size: ScreenSizeType): string => {
+          return JSON.stringify(viewportFor(size));
+        },
+      );
+
+      expect(new Set(serialized).size).toBe(allSizes.length);
+    });
+  });
+
+  describe("purity and determinism", () => {
+    test("repeated calls with the same input return equal values", () => {
+      const first: Viewport = viewportFor(ScreenSizeType.Tablet);
+      const second: Viewport = viewportFor(ScreenSizeType.Tablet);
+
+      expect(second).toEqual(first);
+    });
+
+    test("each call returns a fresh object, so callers cannot corrupt later results", () => {
+      const first: Viewport = viewportFor(ScreenSizeType.Desktop);
+      first.height = -1;
+      first.width = -1;
+
+      const second: Viewport = viewportFor(ScreenSizeType.Desktop);
+
+      expect(second).toEqual({ height: 1080, width: 1920 });
+    });
+  });
+});