@oneuptime/common 13.0.4 → 13.0.5

package/Tests/Types/SecurityEvent/Connectors/SecurityEventConnectorCatalog.test.ts

@@ -0,0 +1,314 @@
+import IconProp from "../../../../Types/Icon/IconProp";
+import {
+  ConnectorField,
+  SecurityEventConnectorCatalog,
+  SecurityEventConnectorCategories,
+  SecurityEventConnectorDefinition,
+  getSecurityEventConnectorDefinition,
+  getSecurityEventConnectorTitle,
+} from "../../../../Types/SecurityEvent/Connectors/SecurityEventConnectorCatalog";
+import SecurityEventConnectorProvider, {
+  AllSecurityEventConnectorProviders,
+  isSecurityEventConnectorProvider,
+} from "../../../../Types/SecurityEvent/Connectors/SecurityEventConnectorProvider";
+import { describe, expect, test } from "@jest/globals";
+import fs from "fs";
+import path from "path";
+
+/*
+ * The catalog is the one place the dashboard form, the server validator
+ * and the docs agree on what a provider is called and which keys it
+ * stores. Nothing compiles against most of it (field keys are strings,
+ * docs paths are strings), so the invariants are pinned here: one
+ * definition per provider, unique keys, dropdown defaults that exist, a
+ * docs path for every provider that is actually reachable from the nav.
+ * (That the page itself exists, and names every field, is asserted by
+ * App/Tests/FeatureSet/Docs/SecurityConnectorDocs.test.ts, which reads the
+ * catalog too.)
+ */
+
+const REPO_ROOT: string = path.resolve(__dirname, "../../../../..");
+const DOCS_NAV_PATH: string = path.join(
+  REPO_ROOT,
+  "App/FeatureSet/Docs/Utils/Nav.ts",
+);
+
+const KNOWN_FIELD_TYPES: Array<string> = [
+  "text",
+  "url",
+  "password",
+  "number",
+  "toggle",
+  "dropdown",
+];
+
+const DEFINITION_CASES: Array<[string, SecurityEventConnectorDefinition]> =
+  SecurityEventConnectorCatalog.map(
+    (
+      definition: SecurityEventConnectorDefinition,
+    ): [string, SecurityEventConnectorDefinition] => {
+      return [definition.provider, definition];
+    },
+  );
+
+function allFields(
+  definition: SecurityEventConnectorDefinition,
+): Array<ConnectorField> {
+  return [...definition.configFields, ...definition.secretFields];
+}
+
+function escapeForRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+describe("SecurityEventConnectorCatalog - one definition per provider", () => {
+  test("every provider in the enum has exactly one definition", () => {
+    for (const provider of AllSecurityEventConnectorProviders) {
+      const matches: Array<SecurityEventConnectorDefinition> =
+        SecurityEventConnectorCatalog.filter(
+          (definition: SecurityEventConnectorDefinition): boolean => {
+            return definition.provider === provider;
+          },
+        );
+
+      expect({ provider, count: matches.length }).toEqual({
+        provider,
+        count: 1,
+      });
+    }
+  });
+
+  test("every definition names a provider that exists in the enum", () => {
+    for (const definition of SecurityEventConnectorCatalog) {
+      expect(isSecurityEventConnectorProvider(definition.provider)).toBe(true);
+    }
+
+    expect(SecurityEventConnectorCatalog).toHaveLength(
+      AllSecurityEventConnectorProviders.length,
+    );
+  });
+
+  test("the enum helper list matches the enum's own values", () => {
+    expect([...AllSecurityEventConnectorProviders].sort()).toEqual(
+      Object.values(SecurityEventConnectorProvider).sort(),
+    );
+  });
+
+  test("titles are unique so the provider picker never shows two identical cards", () => {
+    const titles: Array<string> = SecurityEventConnectorCatalog.map(
+      (definition: SecurityEventConnectorDefinition): string => {
+        return definition.title;
+      },
+    );
+
+    expect(new Set(titles).size).toBe(titles.length);
+  });
+
+  test("vendor/product pairs are unique because they are the dedupe scope", () => {
+    const scopes: Array<string> = SecurityEventConnectorCatalog.map(
+      (definition: SecurityEventConnectorDefinition): string => {
+        return `${definition.vendorName} ${definition.productName}`;
+      },
+    );
+
+    expect(new Set(scopes).size).toBe(scopes.length);
+  });
+
+  test("docs paths are unique", () => {
+    const paths: Array<string> = SecurityEventConnectorCatalog.map(
+      (definition: SecurityEventConnectorDefinition): string => {
+        return definition.docsPath;
+      },
+    );
+
+    expect(new Set(paths).size).toBe(paths.length);
+  });
+});
+
+describe.each(DEFINITION_CASES)(
+  "SecurityEventConnectorCatalog - %s",
+  (_provider: string, definition: SecurityEventConnectorDefinition) => {
+    test("carries the descriptive text the UI and the event rows need", () => {
+      expect(definition.title.trim()).not.toBe("");
+      expect(definition.vendorName.trim()).not.toBe("");
+      expect(definition.productName.trim()).not.toBe("");
+      expect(definition.description.trim()).not.toBe("");
+      expect(definition.importedRecordName.trim()).not.toBe("");
+      expect(SecurityEventConnectorCategories).toContain(definition.category);
+      expect(typeof definition.supportsAlertingOnlyToggle).toBe("boolean");
+    });
+
+    test("uses a real IconProp value", () => {
+      expect(Object.values(IconProp)).toContain(definition.icon);
+    });
+
+    test("default poll interval is a whole number of minutes the service accepts", () => {
+      expect(Number.isInteger(definition.defaultPollIntervalInMinutes)).toBe(
+        true,
+      );
+      expect(definition.defaultPollIntervalInMinutes).toBeGreaterThanOrEqual(1);
+      expect(definition.defaultPollIntervalInMinutes).toBeLessThanOrEqual(1440);
+    });
+
+    test("field keys are unique across config and secret fields", () => {
+      const keys: Array<string> = allFields(definition).map(
+        (field: ConnectorField): string => {
+          return field.key;
+        },
+      );
+
+      expect(new Set(keys).size).toBe(keys.length);
+    });
+
+    test("field titles are unique so the docs can name each field unambiguously", () => {
+      const titles: Array<string> = allFields(definition).map(
+        (field: ConnectorField): string => {
+          return field.title;
+        },
+      );
+
+      expect(new Set(titles).size).toBe(titles.length);
+    });
+
+    test("every field has a key, title, description and a known type", () => {
+      for (const field of allFields(definition)) {
+        expect(field.key).toMatch(/^[a-zA-Z][a-zA-Z0-9]*$/);
+        expect(field.title.trim()).not.toBe("");
+        expect(field.description.trim()).not.toBe("");
+        expect(KNOWN_FIELD_TYPES).toContain(field.type);
+        expect(typeof field.required).toBe("boolean");
+      }
+    });
+
+    test("secret fields are all passwords and no config field is a password", () => {
+      for (const field of definition.secretFields) {
+        expect({ key: field.key, type: field.type }).toEqual({
+          key: field.key,
+          type: "password",
+        });
+      }
+
+      for (const field of definition.configFields) {
+        expect({ key: field.key, type: field.type }).not.toEqual({
+          key: field.key,
+          type: "password",
+        });
+      }
+    });
+
+    test("has at least one secret field, otherwise the connection would store no credential", () => {
+      /*
+       * Splunk accepts either a token or a password, so neither is required
+       * on its own and the connector's validateSettings enforces "one of".
+       * Every other provider has one required credential.
+       */
+      expect(definition.secretFields.length).toBeGreaterThan(0);
+
+      if (
+        definition.provider ===
+        SecurityEventConnectorProvider.SplunkEnterpriseSecurity
+      ) {
+        expect(definition.secretFields.length).toBeGreaterThanOrEqual(2);
+        return;
+      }
+
+      expect(
+        definition.secretFields.some((field: ConnectorField): boolean => {
+          return field.required;
+        }),
+      ).toBe(true);
+    });
+
+    test("dropdown fields have options that include their default value", () => {
+      for (const field of allFields(definition)) {
+        if (field.type !== "dropdown") {
+          expect(field.options).toBeUndefined();
+          continue;
+        }
+
+        expect(field.options).toBeDefined();
+        expect(field.options!.length).toBeGreaterThan(0);
+
+        const values: Array<string> = field.options!.map(
+          (option: { value: string }): string => {
+            return option.value;
+          },
+        );
+
+        expect(new Set(values).size).toBe(values.length);
+
+        for (const option of field.options!) {
+          expect(option.label.trim()).not.toBe("");
+          expect(option.value.trim()).not.toBe("");
+        }
+
+        expect(typeof field.defaultValue).toBe("string");
+        expect(values).toContain(field.defaultValue);
+      }
+    });
+
+    test("default values match their field type", () => {
+      for (const field of allFields(definition)) {
+        if (field.defaultValue === undefined) {
+          continue;
+        }
+
+        if (field.type === "toggle") {
+          expect(typeof field.defaultValue).toBe("boolean");
+        } else if (field.type === "number") {
+          expect(typeof field.defaultValue).toBe("number");
+        } else {
+          expect(typeof field.defaultValue).toBe("string");
+        }
+      }
+    });
+
+    test("docsPath is an integrations page slug the docs server can serve", () => {
+      expect(definition.docsPath).toMatch(/^\/docs\/integrations\/[a-z0-9-]+$/);
+    });
+
+    test("docsPath is linked from the docs navigation", () => {
+      const navSource: string = fs.readFileSync(DOCS_NAV_PATH, "utf8");
+
+      /*
+       * Matched as a url property with either quote style, so prettier
+       * cannot break the test and a mention in a comment cannot fake it.
+       */
+      const link: RegExp = new RegExp(
+        `url:\\s*["']${escapeForRegExp(definition.docsPath)}["']`,
+      );
+
+      expect({
+        docsPath: definition.docsPath,
+        linked: link.test(navSource),
+      }).toEqual({ docsPath: definition.docsPath, linked: true });
+    });
+  },
+);
+
+describe("getSecurityEventConnectorDefinition", () => {
+  test("finds a definition by provider value", () => {
+    expect(
+      getSecurityEventConnectorDefinition(
+        SecurityEventConnectorProvider.OktaSystemLog,
+      )?.title,
+    ).toBe("Okta System Log");
+  });
+
+  test.each([undefined, "", "google-secops", "OKTA"])(
+    "returns undefined for %j",
+    (provider: string | undefined) => {
+      expect(getSecurityEventConnectorDefinition(provider)).toBeUndefined();
+    },
+  );
+
+  test("the title helper falls back to the raw provider, then to an empty string", () => {
+    expect(
+      getSecurityEventConnectorTitle(
+        SecurityEventConnectorProvider.CrowdStrikeFalcon,
+      ),
+    ).toBe("CrowdStrike Falcon");
+    expect(getSecurityEventConnectorTitle("mystery")).toBe("mystery");
+    expect(getSecurityEventConnectorTitle(undefined)).toBe("");
+  });
+});

package/Tests/Types/Telemetry/ExceptionSpanScope.test.ts

@@ -0,0 +1,89 @@
+import {
+  EXCEPTION_SPAN_SCOPE_MAX_FINGERPRINT_LENGTH,
+  EXCEPTION_SPAN_SCOPE_QUERY_KEY,
+  parseExceptionSpanScope,
+} from "../../../Types/Telemetry/ExceptionSpanScope";
+import { describe, expect, test } from "@jest/globals";
+
+const FINGERPRINT: string =
+  "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08";
+const SERVICE_ID: string = "60000000-0000-4000-8000-000000000001";
+
+describe("parseExceptionSpanScope", () => {
+  test("uses a stable synthetic query key", () => {
+    expect(EXCEPTION_SPAN_SCOPE_QUERY_KEY).toBe("exceptionScope");
+  });
+
+  test("accepts a fingerprint alone", () => {
+    expect(parseExceptionSpanScope({ fingerprint: FINGERPRINT })).toEqual({
+      fingerprint: FINGERPRINT,
+    });
+  });
+
+  test("accepts a fingerprint with a service id, trimming both", () => {
+    expect(
+      parseExceptionSpanScope({
+        fingerprint: `  ${FINGERPRINT} `,
+        primaryEntityId: ` ${SERVICE_ID} `,
+      }),
+    ).toEqual({ fingerprint: FINGERPRINT, primaryEntityId: SERVICE_ID });
+  });
+
+  test("accepts a serialized ObjectID for the service", () => {
+    expect(
+      parseExceptionSpanScope({
+        fingerprint: FINGERPRINT,
+        primaryEntityId: { _type: "ObjectID", value: SERVICE_ID },
+      }),
+    ).toEqual({ fingerprint: FINGERPRINT, primaryEntityId: SERVICE_ID });
+  });
+
+  test.each([
+    ["null", null],
+    ["a string", FINGERPRINT],
+    ["an array", [FINGERPRINT]],
+    ["an object without a fingerprint", { primaryEntityId: SERVICE_ID }],
+    ["a numeric fingerprint", { fingerprint: 42 }],
+    ["a blank fingerprint", { fingerprint: "   " }],
+    [
+      "an oversized fingerprint",
+      {
+        fingerprint: "a".repeat(
+          EXCEPTION_SPAN_SCOPE_MAX_FINGERPRINT_LENGTH + 1,
+        ),
+      },
+    ],
+    [
+      "a service id that is not a UUID",
+      { fingerprint: FINGERPRINT, primaryEntityId: "' OR 1=1 --" },
+    ],
+    ["a numeric service id", { fingerprint: FINGERPRINT, primaryEntityId: 7 }],
+  ])("rejects %s", (_name: string, value: unknown) => {
+    expect(parseExceptionSpanScope(value)).toBeNull();
+  });
+
+  test("treats an empty or null service id as absent", () => {
+    expect(
+      parseExceptionSpanScope({
+        fingerprint: FINGERPRINT,
+        primaryEntityId: "",
+      }),
+    ).toEqual({ fingerprint: FINGERPRINT });
+    expect(
+      parseExceptionSpanScope({
+        fingerprint: FINGERPRINT,
+        primaryEntityId: null,
+      }),
+    ).toEqual({ fingerprint: FINGERPRINT });
+  });
+
+  test("accepts a fingerprint exactly at the length limit", () => {
+    const fingerprint: string = "b".repeat(
+      EXCEPTION_SPAN_SCOPE_MAX_FINGERPRINT_LENGTH,
+    );
+
+    expect(parseExceptionSpanScope({ fingerprint })?.fingerprint).toBe(
+      fingerprint,
+    );
+  });
+});

package/Tests/Types/Telemetry/ResourceEntityFacet.test.ts

@@ -13,6 +13,7 @@ import {
   isServiceFacetKey,
   parseResourceEntityFacetSelections,
 } from "../../../Types/Telemetry/ResourceEntityFacet";
+import { RESOURCE_FACET_CATALOG_KEYS } from "../../../Types/Telemetry/ResourceFacetCatalog";
 
 /*
  * The split this module encodes is the whole fix for issue #3216: the
@@ -27,6 +28,24 @@ const CLUSTER_ID: string = "8c0f2f1e-2e4f-4a8c-9a1a-2f5b6c7d8e9f";
 const OTHER_CLUSTER_ID: string = "1a2b3c4d-5e6f-4071-8293-a4b5c6d7e8f9";
 const HOST_ID: string = "5f4e3d2c-1b0a-4998-8776-655443322110";
 const SERVICE_ID: string = "0d1c2b3a-4958-4867-9776-8574a3b2c1d0";
+const SWARM_ID: string = "6e5d4c3b-2a19-4807-8f6e-5d4c3b2a1908";
+const FLEET_ID: string = "9a8b7c6d-5e4f-4321-8fed-cba987654321";
+
+/*
+ * Every resource type the explorers now offer, beyond the original four.
+ * These used to be dropped by the parser, so a chip on them filtered
+ * nothing on the server.
+ */
+const NEWLY_FILTERABLE_KEYS: Array<string> = [
+  "dockerSwarmClusterId",
+  "proxmoxClusterId",
+  "vmwareVCenterId",
+  "cephClusterId",
+  "serverlessFunctionId",
+  "cloudResourceId",
+  "rumApplicationId",
+  "iotFleetId",
+];
 
 function facetMap(
   entries: Record<string, Array<string>>,
@@ -55,12 +74,38 @@ describe("ResourceEntityFacet", () => {
         "dockerHostId",
         "podmanHostId",
         "kubernetesClusterId",
+        ...NEWLY_FILTERABLE_KEYS,
       ]) {
         expect(isResourceEntityFacetKey(facetKey)).toBe(true);
+        expect(isResourceFacetKey(facetKey)).toBe(true);
         expect(isServiceFacetKey(facetKey)).toBe(false);
       }
     });
 
+    test("the non-Service group is exactly the resource facet catalog, in catalog order", () => {
+      expect([...RESOURCE_ENTITY_FACET_KEYS]).toEqual([
+        ...RESOURCE_FACET_CATALOG_KEYS,
+      ]);
+      expect(RESOURCE_ENTITY_FACET_KEYS).toHaveLength(12);
+    });
+
+    test("the non-Service group is a copy, not the catalog's own array", () => {
+      expect(RESOURCE_ENTITY_FACET_KEYS).not.toBe(RESOURCE_FACET_CATALOG_KEYS);
+    });
+
+    test("look-alike keys are not resource facets", () => {
+      for (const facetKey of [
+        "iotDeviceId",
+        "ProxmoxClusterId",
+        "cephclusterid",
+        " iotFleetId",
+        "constructor",
+        "__proto__",
+      ]) {
+        expect(isResourceFacetKey(facetKey)).toBe(false);
+      }
+    });
+
     test("non-resource facets belong to neither group", () => {
       for (const facetKey of [
         "severityText",
@@ -148,6 +193,37 @@ describe("ResourceEntityFacet", () => {
       expect(hasResourceEntityFacetSelections(selections)).toBe(false);
     });
 
+    test.each(NEWLY_FILTERABLE_KEYS)(
+      "keeps %s selections (collection used to drop them)",
+      (facetKey: string) => {
+        const selections: ResourceEntityFacetSelections =
+          collectResourceEntityFacetSelections(
+            facetMap({ [facetKey]: [SWARM_ID, FLEET_ID] }).entries(),
+          );
+
+        expect(selections).toEqual({ [facetKey]: [SWARM_ID, FLEET_ID] });
+        expect(hasResourceEntityFacetSelections(selections)).toBe(true);
+      },
+    );
+
+    test("keeps every resource facet in one pass, next to a Service chip it ignores", () => {
+      const selections: ResourceEntityFacetSelections =
+        collectResourceEntityFacetSelections(
+          Object.entries({
+            primaryEntityId: [SERVICE_ID],
+            dockerSwarmClusterId: [SWARM_ID],
+            iotFleetId: [FLEET_ID],
+            hostId: [HOST_ID],
+          }),
+        );
+
+      expect(selections).toEqual({
+        dockerSwarmClusterId: [SWARM_ID],
+        iotFleetId: [FLEET_ID],
+        hostId: [HOST_ID],
+      });
+    });
+
     test("skips blank values", () => {
       const selections: ResourceEntityFacetSelections =
         collectResourceEntityFacetSelections(
@@ -198,6 +274,26 @@ describe("ResourceEntityFacet", () => {
       ).toEqual({ kubernetesClusterId: [CLUSTER_ID] });
     });
 
+    test.each(NEWLY_FILTERABLE_KEYS)(
+      "accepts a %s selection",
+      (facetKey: string) => {
+        expect(
+          parseResourceEntityFacetSelections({ [facetKey]: [FLEET_ID] }),
+        ).toEqual({ [facetKey]: [FLEET_ID] });
+      },
+    );
+
+    test("accepts several new resource types side by side, validating each", () => {
+      expect(
+        parseResourceEntityFacetSelections({
+          proxmoxClusterId: [CLUSTER_ID, "not-an-id"],
+          cephClusterId: ["nope"],
+          iotFleetId: [FLEET_ID, FLEET_ID],
+          iotDeviceId: [FLEET_ID],
+        }),
+      ).toEqual({ proxmoxClusterId: [CLUSTER_ID], iotFleetId: [FLEET_ID] });
+    });
+
     test("drops ids that are not ObjectID strings", () => {
       expect(
         parseResourceEntityFacetSelections({