@oneuptime/common 12.0.13 → 12.0.15

package/Tests/Utils/Analytics.test.ts

@@ -107,3 +107,190 @@ describe("Analytics Class", () => {
     expect(posthog.capture).not.toHaveBeenCalled();
   });
 });
+
+describe("Analytics.toGA4EventName", () => {
+  /*
+   * GA4 event names must start with a letter and contain only letters, digits
+   * and underscores, with a maximum length of 40 characters.
+   */
+  const GA4_EVENT_NAME_REGEX: RegExp = /^[a-z][a-z0-9_]*$/;
+
+  it.each([
+    // Names product code sends today that GA4 would otherwise reject.
+    ["Page View: Project > Home", "page_view_project_home"],
+    ["FORM SUBMIT: Register", "form_submit_register"],
+    ["accounts/login", "accounts_login"],
+    ["accounts/register", "accounts_register"],
+    ["dashboard/home", "dashboard_home"],
+    ["dashboard/ai-copilot", "dashboard_ai_copilot"],
+    ["dashboard/billing/plan-changed", "dashboard_billing_plan_changed"],
+    [
+      "dashboard/home/getting-started-task",
+      "dashboard_home_getting_started_task",
+    ],
+    [
+      "dashboard/home/getting-started-dismissed",
+      "dashboard_home_getting_started_dismissed",
+    ],
+    // Leading and trailing separators are dropped rather than kept.
+    ["  /accounts/login/  ", "accounts_login"],
+    // A name with no leading letter gets a prefix.
+    ["404 page not found", "event_404_page_not_found"],
+    ["_leading_underscore", "leading_underscore"],
+    // A name with nothing usable in it falls back entirely.
+    ["***", "event"],
+    ["", "event"],
+    // Casing is normalised.
+    ["testEvent", "testevent"],
+  ])("normalises %j to %j", (input: string, expected: string) => {
+    expect(Analytics.toGA4EventName(input)).toBe(expected);
+  });
+
+  it("truncates to 40 characters without leaving a trailing underscore", () => {
+    const normalized: string = Analytics.toGA4EventName(
+      "Page View: Project > Settings > Notification > Email",
+    );
+
+    expect(normalized).toBe("page_view_project_settings_notification");
+    expect(normalized.length).toBeLessThanOrEqual(40);
+  });
+
+  it("truncates a name that is exactly at the boundary", () => {
+    const normalized: string = Analytics.toGA4EventName(
+      "Page View: Project > Settings > Notifications > Email",
+    );
+
+    expect(normalized).toBe("page_view_project_settings_notifications");
+    expect(normalized).toHaveLength(40);
+  });
+
+  it("leaves already GA4-compatible revenue event names untouched", () => {
+    for (const eventName of Object.values(RevenueEventName)) {
+      expect(Analytics.toGA4EventName(eventName)).toBe(eventName);
+    }
+  });
+
+  it("always produces a GA4-valid name", () => {
+    const inputs: Array<string> = [
+      "Page View: Project > Home",
+      "FORM SUBMIT: Register",
+      "accounts/login",
+      "404",
+      "___",
+      "!!!",
+      "",
+      "  ",
+      "a".repeat(200),
+      "1".repeat(200),
+      "Page View: " + "Very Long Breadcrumb > ".repeat(10),
+    ];
+
+    for (const input of inputs) {
+      const normalized: string = Analytics.toGA4EventName(input);
+
+      expect(normalized).toMatch(GA4_EVENT_NAME_REGEX);
+      expect(normalized.length).toBeGreaterThan(0);
+      expect(normalized.length).toBeLessThanOrEqual(40);
+      // Normalising an already-normalised name must be a no-op.
+      expect(Analytics.toGA4EventName(normalized)).toBe(normalized);
+    }
+  });
+});
+
+describe("Analytics dataLayer (GA4) branch", () => {
+  let dataLayer: Array<JSONObject>;
+
+  beforeEach(() => {
+    dataLayer = [];
+    (window as any).dataLayer = dataLayer;
+  });
+
+  afterEach(() => {
+    delete (window as any).dataLayer;
+    jest.clearAllMocks();
+  });
+
+  it("pushes a normalised event name while PostHog keeps the original", () => {
+    const analytics: Analytics = new Analytics(apiHost, apiKey);
+
+    analytics.capture("Page View: Project > Home");
+
+    expect(posthog.capture).toHaveBeenCalledWith(
+      "Page View: Project > Home",
+      undefined,
+    );
+    expect(dataLayer).toHaveLength(1);
+    expect(dataLayer[0]).toEqual({
+      event: "page_view_project_home",
+      eventCategory: "analytics",
+      eventAction: "Page View: Project > Home",
+    });
+  });
+
+  it("pushes to the dataLayer even when PostHog is not initialized", () => {
+    const analytics: Analytics = new Analytics("", "");
+
+    analytics.capture("FORM SUBMIT: Register");
+
+    expect(posthog.capture).not.toHaveBeenCalled();
+    expect(dataLayer).toHaveLength(1);
+    expect(dataLayer[0]).toMatchObject({
+      event: "form_submit_register",
+      eventAction: "FORM SUBMIT: Register",
+    });
+  });
+
+  it("includes event properties in the pushed payload", () => {
+    const analytics: Analytics = new Analytics(apiHost, apiKey);
+
+    analytics.capture("dashboard/billing/plan-changed", {
+      plan_name: "growth",
+      is_paid_conversion: true,
+    });
+
+    expect(dataLayer[0]).toEqual({
+      event: "dashboard_billing_plan_changed",
+      eventCategory: "analytics",
+      eventAction: "dashboard/billing/plan-changed",
+      plan_name: "growth",
+      is_paid_conversion: true,
+    });
+  });
+
+  it("does not let event properties override the GA4 event name", () => {
+    const analytics: Analytics = new Analytics(apiHost, apiKey);
+
+    analytics.capture("accounts/login", { event: "Not A Valid GA4 Name" });
+
+    expect(dataLayer[0]).toMatchObject({ event: "accounts_login" });
+  });
+
+  it("pushes revenue event names unchanged", () => {
+    const analytics: Analytics = new Analytics(apiHost, apiKey);
+
+    analytics.captureRevenueEvent(RevenueEventName.WorkspaceCreated, {
+      funnel_stage: RevenueFunnelStage.Activation,
+      project_id: "project-123",
+    });
+
+    expect(dataLayer[0]).toEqual({
+      event: RevenueEventName.WorkspaceCreated,
+      eventCategory: "analytics",
+      eventAction: RevenueEventName.WorkspaceCreated,
+      funnel_stage: RevenueFunnelStage.Activation,
+      project_id: "project-123",
+      event_schema_version: REVENUE_EVENT_SCHEMA_VERSION,
+    });
+  });
+
+  it("does not throw when window.dataLayer is not defined", () => {
+    delete (window as any).dataLayer;
+
+    const analytics: Analytics = new Analytics(apiHost, apiKey);
+
+    expect(() => {
+      analytics.capture("accounts/login");
+    }).not.toThrow();
+    expect(posthog.capture).toHaveBeenCalledWith("accounts/login", undefined);
+  });
+});

package/Tests/Utils/Dashboard/Components/DashboardKubernetesResourceListShared.test.ts

@@ -0,0 +1,347 @@
+import { describe, expect, test } from "@jest/globals";
+import {
+  ComponentArgument,
+  ComponentInputType,
+  EntityFilterModelType,
+} from "../../../../Types/Dashboard/DashboardComponents/ComponentArgument";
+import DashboardBaseComponent from "../../../../Types/Dashboard/DashboardComponents/DashboardBaseComponent";
+import {
+  KubernetesCommonArgumentsOptions,
+  KubernetesDisplaySection,
+  KubernetesFiltersSection,
+  getKubernetesCommonArguments,
+} from "../../../../Utils/Dashboard/Components/DashboardKubernetesResourceListShared";
+
+/*
+ * getKubernetesCommonArguments builds the shared config-form fields for every
+ * Kubernetes resource-list widget (pods, deployments, services, ...). It is a
+ * fixed sequence of args.push() calls with exactly one conditional branch: the
+ * "Namespaces" text filter is appended only when
+ * options.includeNamespaceFilter is true.
+ *
+ * The failure modes worth guarding are the quiet ones the compiler cannot see:
+ *  - the namespace branch leaking into a widget that has no namespaces, or
+ *    being dropped from one that does;
+ *  - an argument being mis-sectioned so a Display option renders under Filters
+ *    (or vice-versa), since section is what the editor groups fields by;
+ *  - a wrong ComponentInputType or a wrong entityFilterModelType, which would
+ *    render the wrong editor or wire the cluster picker to the wrong model;
+ *  - a duplicated id, which silently makes the second field overwrite the
+ *    first's stored value;
+ *  - the function returning a shared/mutated array across calls, which would
+ *    let one widget's edited config bleed into the next.
+ *
+ * All inputs are pure booleans, so the whole suite is deterministic with no
+ * mocks, network, DB, clock, or randomness.
+ */
+
+type Args = Array<ComponentArgument<DashboardBaseComponent>>;
+
+const withNamespace: KubernetesCommonArgumentsOptions = {
+  includeNamespaceFilter: true,
+};
+
+const withoutNamespace: KubernetesCommonArgumentsOptions = {
+  includeNamespaceFilter: false,
+};
+
+function build(withNamespaceFilter: boolean): Args {
+  return getKubernetesCommonArguments<DashboardBaseComponent>({
+    includeNamespaceFilter: withNamespaceFilter,
+  });
+}
+
+function findById(
+  args: Args,
+  id: string,
+): ComponentArgument<DashboardBaseComponent> {
+  const match: ComponentArgument<DashboardBaseComponent> | undefined =
+    args.find((a: ComponentArgument<DashboardBaseComponent>) => {
+      return String(a.id) === id;
+    });
+  if (!match) {
+    throw new Error(`Expected an argument with id "${id}" but none was found`);
+  }
+  return match;
+}
+
+describe("getKubernetesCommonArguments", () => {
+  describe("argument count and namespace branch", () => {
+    test("includes the namespace filter as a 5th argument when requested", () => {
+      const args: Args = build(true);
+      expect(args).toHaveLength(5);
+    });
+
+    test("omits the namespace filter when not requested", () => {
+      const args: Args = build(false);
+      expect(args).toHaveLength(4);
+    });
+
+    test("the only structural difference between the two modes is the Namespaces field", () => {
+      const withNs: Args = build(true);
+      const withoutNs: Args = build(false);
+
+      /*
+       * The first four arguments must be identical in both modes; the branch
+       * appends, it must never re-order or alter the fields before it.
+       */
+      expect(withNs.slice(0, 4)).toEqual(withoutNs);
+
+      const extra: ComponentArgument<DashboardBaseComponent> | undefined =
+        withNs[4];
+      expect(extra).toBeDefined();
+      expect(String(extra!.id)).toBe("namespaces");
+    });
+
+    test("the namespaces argument is absent (not merely undefined) when excluded", () => {
+      const args: Args = build(false);
+      const ids: Array<string> = args.map(
+        (a: ComponentArgument<DashboardBaseComponent>) => {
+          return String(a.id);
+        },
+      );
+      expect(ids).not.toContain("namespaces");
+    });
+  });
+
+  describe("argument order and identity", () => {
+    test("arguments are emitted in a stable, documented order (with namespace)", () => {
+      const ids: Array<string> = build(true).map(
+        (a: ComponentArgument<DashboardBaseComponent>) => {
+          return String(a.id);
+        },
+      );
+      expect(ids).toEqual([
+        "title",
+        "maxRows",
+        "viewMode",
+        "kubernetesClusterIds",
+        "namespaces",
+      ]);
+    });
+
+    test("arguments are emitted in a stable order (without namespace)", () => {
+      const ids: Array<string> = build(false).map(
+        (a: ComponentArgument<DashboardBaseComponent>) => {
+          return String(a.id);
+        },
+      );
+      expect(ids).toEqual([
+        "title",
+        "maxRows",
+        "viewMode",
+        "kubernetesClusterIds",
+      ]);
+    });
+
+    test("no argument id is duplicated in either mode", () => {
+      for (const args of [build(true), build(false)]) {
+        const ids: Array<string> = args.map(
+          (a: ComponentArgument<DashboardBaseComponent>) => {
+            return String(a.id);
+          },
+        );
+        expect(new Set<string>(ids).size).toBe(ids.length);
+      }
+    });
+  });
+
+  describe("Title argument", () => {
+    test("is an optional text field in the Display section", () => {
+      const title: ComponentArgument<DashboardBaseComponent> = findById(
+        build(true),
+        "title",
+      );
+      expect(title.name).toBe("Title");
+      expect(title.type).toBe(ComponentInputType.Text);
+      expect(title.required).toBe(false);
+      expect(title.section).toBe(KubernetesDisplaySection);
+      expect(title.description.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe("Max Rows argument", () => {
+    test("is an optional number field with a placeholder in the Display section", () => {
+      const maxRows: ComponentArgument<DashboardBaseComponent> = findById(
+        build(true),
+        "maxRows",
+      );
+      expect(maxRows.name).toBe("Max Rows");
+      expect(maxRows.type).toBe(ComponentInputType.Number);
+      expect(maxRows.required).toBe(false);
+      expect(maxRows.placeholder).toBe("25");
+      expect(maxRows.section).toBe(KubernetesDisplaySection);
+    });
+  });
+
+  describe("View Mode argument", () => {
+    test("is the shared dropdown offering list and honeycomb views", () => {
+      const viewMode: ComponentArgument<DashboardBaseComponent> = findById(
+        build(true),
+        "viewMode",
+      );
+      expect(viewMode.name).toBe("View Mode");
+      expect(viewMode.type).toBe(ComponentInputType.Dropdown);
+      expect(viewMode.required).toBe(false);
+      expect(viewMode.section).toBe(KubernetesDisplaySection);
+
+      const values: Array<unknown> = (viewMode.dropdownOptions ?? []).map(
+        (o: { value: unknown }) => {
+          return o.value;
+        },
+      );
+      expect(values).toEqual(["list", "honeycomb"]);
+    });
+  });
+
+  describe("Clusters argument", () => {
+    test("is an entity multi-select bound to the KubernetesCluster model in the Filters section", () => {
+      const clusters: ComponentArgument<DashboardBaseComponent> = findById(
+        build(true),
+        "kubernetesClusterIds",
+      );
+      expect(clusters.name).toBe("Clusters");
+      expect(clusters.type).toBe(ComponentInputType.EntityMultiSelectDropdown);
+      expect(clusters.required).toBe(false);
+      expect(clusters.placeholder).toBe("All clusters");
+      expect(clusters.section).toBe(KubernetesFiltersSection);
+      expect(clusters.entityFilterModelType).toBe(
+        EntityFilterModelType.KubernetesCluster,
+      );
+    });
+  });
+
+  describe("Namespaces argument", () => {
+    test("is an optional text field with an example placeholder in the Filters section", () => {
+      const namespaces: ComponentArgument<DashboardBaseComponent> = findById(
+        build(true),
+        "namespaces",
+      );
+      expect(namespaces.name).toBe("Namespaces");
+      expect(namespaces.type).toBe(ComponentInputType.Text);
+      expect(namespaces.required).toBe(false);
+      expect(namespaces.placeholder).toBe("default, kube-system");
+      expect(namespaces.section).toBe(KubernetesFiltersSection);
+
+      /*
+       * The cluster picker is an entity dropdown; the namespaces field is a
+       * free-text list, so it must NOT carry an entityFilterModelType.
+       */
+      expect(namespaces.entityFilterModelType).toBeUndefined();
+    });
+  });
+
+  describe("section assignment and exported section constants", () => {
+    test("every argument is required=false (all fields are optional filters/options)", () => {
+      for (const args of [build(true), build(false)]) {
+        for (const arg of args) {
+          expect(arg.required).toBe(false);
+        }
+      }
+    });
+
+    test("Display options come before Filters and are grouped by their sections", () => {
+      const args: Args = build(true);
+
+      const displayIds: Array<string> = args
+        .filter((a: ComponentArgument<DashboardBaseComponent>) => {
+          return a.section === KubernetesDisplaySection;
+        })
+        .map((a: ComponentArgument<DashboardBaseComponent>) => {
+          return String(a.id);
+        });
+      const filterIds: Array<string> = args
+        .filter((a: ComponentArgument<DashboardBaseComponent>) => {
+          return a.section === KubernetesFiltersSection;
+        })
+        .map((a: ComponentArgument<DashboardBaseComponent>) => {
+          return String(a.id);
+        });
+
+      expect(displayIds).toEqual(["title", "maxRows", "viewMode"]);
+      expect(filterIds).toEqual(["kubernetesClusterIds", "namespaces"]);
+    });
+
+    test("every argument references one of the two known sections", () => {
+      for (const args of [build(true), build(false)]) {
+        for (const arg of args) {
+          const isKnownSection: boolean =
+            arg.section === KubernetesDisplaySection ||
+            arg.section === KubernetesFiltersSection;
+          expect(isKnownSection).toBe(true);
+        }
+      }
+    });
+
+    test("the exported sections carry the expected ordering and collapse behavior", () => {
+      expect(KubernetesDisplaySection.name).toBe("Display Options");
+      expect(KubernetesDisplaySection.order).toBe(1);
+
+      expect(KubernetesFiltersSection.name).toBe("Filters");
+      expect(KubernetesFiltersSection.order).toBe(2);
+
+      /*
+       * Filters render below Display, so they default to collapsed while
+       * Display stays open.
+       */
+      expect(KubernetesFiltersSection.defaultCollapsed).toBe(true);
+      expect(KubernetesDisplaySection.defaultCollapsed).toBeUndefined();
+      expect(KubernetesFiltersSection.order).toBeGreaterThan(
+        KubernetesDisplaySection.order,
+      );
+    });
+  });
+
+  describe("well-formedness of every argument", () => {
+    const validInputTypes: Set<string> = new Set<string>(
+      Object.values(ComponentInputType),
+    );
+
+    test("each argument has a non-empty name, id, boolean required, and valid input type", () => {
+      for (const args of [build(true), build(false)]) {
+        for (const arg of args) {
+          expect(typeof arg.name).toBe("string");
+          expect(arg.name.length).toBeGreaterThan(0);
+
+          expect(typeof arg.id).toBe("string");
+          expect(String(arg.id).length).toBeGreaterThan(0);
+
+          expect(typeof arg.required).toBe("boolean");
+
+          expect(validInputTypes.has(arg.type)).toBe(true);
+
+          expect(typeof arg.description).toBe("string");
+          expect(arg.description.length).toBeGreaterThan(0);
+        }
+      }
+    });
+  });
+
+  describe("determinism and array independence", () => {
+    test("repeated calls with the same options are deeply equal but not the same reference", () => {
+      const first: Args = build(true);
+      const second: Args = build(true);
+      expect(second).toEqual(first);
+      expect(second).not.toBe(first);
+    });
+
+    test("mutating a returned array does not affect a subsequent call", () => {
+      const first: Args = build(true);
+      first.pop();
+      first[0]!.name = "MUTATED";
+
+      const fresh: Args = build(true);
+      expect(fresh).toHaveLength(5);
+      expect(fresh[0]!.name).toBe("Title");
+    });
+
+    test("accepts the options object literals defined for both modes", () => {
+      expect(
+        getKubernetesCommonArguments<DashboardBaseComponent>(withNamespace),
+      ).toHaveLength(5);
+      expect(
+        getKubernetesCommonArguments<DashboardBaseComponent>(withoutNamespace),
+      ).toHaveLength(4);
+    });
+  });
+});