@oneuptime/common 12.0.12 → 12.0.13

package/Tests/App/Dashboard/MonitorTypePicker.test.tsx

@@ -0,0 +1,300 @@
+import "@testing-library/jest-dom";
+import { fireEvent, render, screen } from "@testing-library/react";
+import React from "react";
+import { describe, expect, test } from "@jest/globals";
+import getJestMockFunction, { MockFunction } from "../../MockType";
+import MonitorType, {
+  MonitorTypeCategory,
+  MonitorTypeHelper,
+} from "../../../Types/Monitor/MonitorType";
+import CardSelect, {
+  CardSelectOption,
+  CardSelectOptionGroup,
+} from "../../../UI/Components/CardSelect/CardSelect";
+import MonitorTypeUtil from "../../../../App/FeatureSet/Dashboard/src/Utils/MonitorType";
+
+/*
+ * The real catalog, driven through the real picker. The unit tests either side
+ * of this one prove the search ranks correctly and the component renders
+ * correctly; what is pinned here is that the dashboard hands the component the
+ * data it needs to do either - the adapter drops keywords silently, and every
+ * search below still "works" while finding nothing.
+ */
+
+const categorizedOptions: Array<CardSelectOptionGroup> =
+  MonitorTypeUtil.monitorTypesAsCategorizedCardSelectOptions();
+
+type RenderPickerFunction = (value?: string) => MockFunction;
+
+const renderPicker: RenderPickerFunction = (value?: string): MockFunction => {
+  const onChange: MockFunction = getJestMockFunction();
+
+  render(
+    <CardSelect
+      options={categorizedOptions}
+      value={value}
+      onChange={onChange}
+      searchable={true}
+      searchPlaceholder="Search monitor types - try ping, ssl, k8s, postgres"
+      collapsibleGroups={true}
+    />,
+  );
+
+  return onChange;
+};
+
+type SearchFunction = (value: string) => void;
+
+const search: SearchFunction = (value: string): void => {
+  fireEvent.change(screen.getByTestId("card-select-search"), {
+    target: { value: value },
+  });
+};
+
+type ShownTypesFunction = () => Array<string>;
+
+const shownTypes: ShownTypesFunction = (): Array<string> => {
+  return screen.queryAllByRole("radio").map((card: HTMLElement) => {
+    return (card.getAttribute("data-testid") || "").replace(
+      "card-select-option-",
+      "",
+    );
+  });
+};
+
+describe("Monitor type picker", () => {
+  describe("the options the dashboard builds", () => {
+    test("carries the keywords through from the monitor type catalog", () => {
+      for (const group of categorizedOptions) {
+        for (const option of group.options) {
+          expect({
+            monitorType: option.value,
+            hasKeywords: Boolean(option.keywords && option.keywords.length > 0),
+          }).toEqual({ monitorType: option.value, hasKeywords: true });
+        }
+      }
+    });
+
+    test("carries keywords through the flat option list too", () => {
+      const flat: Array<CardSelectOption> =
+        MonitorTypeUtil.monitorTypesAsCardSelectOptions();
+
+      for (const option of flat) {
+        expect(option.keywords).toBeDefined();
+        expect((option.keywords || []).length).toBeGreaterThan(0);
+      }
+    });
+
+    test("offers one group per category, in catalog order", () => {
+      const categories: Array<MonitorTypeCategory> =
+        MonitorTypeHelper.getMonitorTypeCategories();
+
+      expect(
+        categorizedOptions.map((group: CardSelectOptionGroup) => {
+          return group.label;
+        }),
+      ).toEqual(
+        categories.map((category: MonitorTypeCategory) => {
+          return category.label;
+        }),
+      );
+    });
+  });
+
+  describe("what a user sees on opening the form", () => {
+    test("the everyday types are on screen without scrolling past anything", () => {
+      renderPicker();
+
+      expect(screen.getByTestId("card-select-option-Website")).toBeVisible();
+      expect(screen.getByTestId("card-select-option-API")).toBeVisible();
+      expect(screen.getByTestId("card-select-option-Ping")).toBeVisible();
+    });
+
+    /*
+     * The whole point of the change. Every type used to render at once - nine
+     * headings and 29 cards, about six thousand pixels of them.
+     */
+    test("the long tail starts folded away behind its headings", () => {
+      renderPicker();
+
+      expect(
+        screen.queryByTestId("card-select-option-Kubernetes"),
+      ).not.toBeInTheDocument();
+      expect(
+        screen.queryByTestId("card-select-option-Ceph"),
+      ).not.toBeInTheDocument();
+      expect(
+        screen.queryByTestId("card-select-option-Traces"),
+      ).not.toBeInTheDocument();
+    });
+
+    test("shows far fewer cards than the catalog holds", () => {
+      renderPicker();
+
+      const total: number = categorizedOptions.reduce(
+        (count: number, group: CardSelectOptionGroup) => {
+          return count + group.options.length;
+        },
+        0,
+      );
+
+      expect(shownTypes().length).toBeLessThan(total / 2);
+    });
+
+    test("every category is still reachable, with a count of what is inside", () => {
+      renderPicker();
+
+      for (const group of categorizedOptions) {
+        const header: HTMLElement = screen.getByTestId(
+          `card-select-group-${group.label}`,
+        );
+
+        expect(header).toBeVisible();
+        expect(header).toHaveTextContent(String(group.options.length));
+      }
+    });
+
+    test("says how many types there are to choose from", () => {
+      renderPicker();
+
+      expect(
+        screen.getByTestId("card-select-search-summary"),
+      ).toHaveTextContent("to choose from");
+    });
+  });
+
+  describe("finding a type by the words a user already knows", () => {
+    test.each([
+      ["k8s", MonitorType.Kubernetes],
+      ["postgres", MonitorType.SQLQuery],
+      ["heartbeat", MonitorType.IncomingRequest],
+      ["tls", MonitorType.SSLCertificate],
+      ["snmp", MonitorType.NetworkDevice],
+      ["icmp", MonitorType.Ping],
+      ["whois", MonitorType.Domain],
+      ["prometheus", MonitorType.Metrics],
+    ])("%s finds %s first", (query: string, expected: MonitorType) => {
+      renderPicker();
+
+      search(query);
+
+      expect(shownTypes()[0]).toBe(expected);
+    });
+
+    test("a search reaches types that are folded away", () => {
+      renderPicker();
+
+      expect(
+        screen.queryByTestId("card-select-option-Kubernetes"),
+      ).not.toBeInTheDocument();
+
+      search("k8s");
+
+      expect(screen.getByTestId("card-select-option-Kubernetes")).toBeVisible();
+    });
+
+    test("a search for a vendor finds the external status page monitor", () => {
+      renderPicker();
+
+      search("cloudflare");
+
+      expect(shownTypes()).toContain(MonitorType.ExternalStatusPage);
+    });
+
+    test("a category name gathers its types together", () => {
+      renderPicker();
+
+      search("telemetry");
+
+      const shown: Array<string> = shownTypes();
+
+      expect(shown).toContain(MonitorType.Logs);
+      expect(shown).toContain(MonitorType.Metrics);
+      expect(shown).toContain(MonitorType.Traces);
+      expect(shown).not.toContain(MonitorType.Website);
+    });
+
+    test("a word nothing uses says so instead of showing an empty grid", () => {
+      renderPicker();
+
+      search("mainframe");
+
+      expect(screen.getByTestId("card-select-no-results")).toBeVisible();
+      expect(shownTypes()).toEqual([]);
+    });
+
+    test("picking a type from the search results reports the monitor type", () => {
+      const onChange: MockFunction = renderPicker();
+
+      search("k8s");
+      fireEvent.click(screen.getByTestId("card-select-option-Kubernetes"));
+
+      expect(onChange).toHaveBeenCalledWith(MonitorType.Kubernetes);
+    });
+  });
+
+  describe("coming back to a form that already has a type", () => {
+    test("shows the selection rather than hiding it behind a closed heading", () => {
+      renderPicker(MonitorType.Ceph);
+
+      expect(screen.getByTestId("card-select-option-Ceph")).toBeVisible();
+      expect(screen.getByTestId("card-select-option-Ceph")).toHaveAttribute(
+        "aria-checked",
+        "true",
+      );
+    });
+
+    test("leaves the rest folded away", () => {
+      renderPicker(MonitorType.Ceph);
+
+      expect(
+        screen.queryByTestId("card-select-option-Traces"),
+      ).not.toBeInTheDocument();
+    });
+  });
+
+  describe("browsing without searching", () => {
+    test("opening a category shows every type in it", () => {
+      renderPicker();
+
+      fireEvent.click(screen.getByTestId("card-select-group-Telemetry"));
+
+      expect(screen.getByTestId("card-select-option-Logs")).toBeVisible();
+      expect(screen.getByTestId("card-select-option-Metrics")).toBeVisible();
+      expect(screen.getByTestId("card-select-option-Traces")).toBeVisible();
+      expect(screen.getByTestId("card-select-option-Exceptions")).toBeVisible();
+    });
+
+    test("a type can be picked by browsing, with no typing at all", () => {
+      const onChange: MockFunction = renderPicker();
+
+      fireEvent.click(screen.getByTestId("card-select-group-Infrastructure"));
+      fireEvent.click(screen.getByTestId("card-select-option-Kubernetes"));
+
+      expect(onChange).toHaveBeenCalledWith(MonitorType.Kubernetes);
+    });
+
+    test("every type in the catalog can be reached by opening its category", () => {
+      renderPicker();
+
+      // Only the closed ones - clicking an open heading would fold it away.
+      for (const group of categorizedOptions) {
+        const header: HTMLElement = screen.getByTestId(
+          `card-select-group-${group.label}`,
+        );
+
+        if (header.getAttribute("aria-expanded") === "false") {
+          fireEvent.click(header);
+        }
+      }
+
+      for (const group of categorizedOptions) {
+        for (const option of group.options) {
+          expect(
+            screen.getByTestId(`card-select-option-${option.value}`),
+          ).toBeVisible();
+        }
+      }
+    });
+  });
+});

package/Tests/App/StatusPage/StatusPageIndexPageRobotsMeta.test.ts

@@ -0,0 +1,130 @@
+/**
+ * The <meta name="robots"> half of the status page indexing opt-out, rendered
+ * from the real template.
+ *
+ * This is the channel that matters most: it is in the server-rendered HTML
+ * before the JS bundle loads, so it is what a crawler that does not run
+ * JavaScript sees. The X-Robots-Tag header that backs it up is asserted in
+ * App/Tests/StatusPage/SearchEngineIndexingResponses.test.ts.
+ *
+ * The template is read off disk rather than reproduced here, because the
+ * failure this guards against is someone editing index.ejs - a copy of the
+ * markup would keep passing while the shipped page lost its tag. It lives
+ * under Common/Tests because that is where the ejs types are installed;
+ * Common/Tests/App is the established home for tests that reach into App.
+ */
+
+import { JSONObject } from "../../../Types/JSON";
+import { describe, expect, it } from "@jest/globals";
+import ejs from "ejs";
+import fs from "fs";
+import path from "path";
+
+const INDEX_TEMPLATE: string = path.join(
+  __dirname,
+  "..",
+  "..",
+  "..",
+  "..",
+  "App",
+  "FeatureSet",
+  "StatusPage",
+  "views",
+  "index.ejs",
+);
+
+const NOINDEX_META: RegExp =
+  /<meta\s+name="robots"\s+content="noindex,\s*nofollow">/;
+
+function renderIndexPage(variables: JSONObject): string {
+  return ejs.render(fs.readFileSync(INDEX_TEMPLATE, "utf8"), variables);
+}
+
+describe("the status page index template", () => {
+  it("tells crawlers not to index when the owner turned indexing off", () => {
+    const html: string = renderIndexPage({
+      title: "Acme Status",
+      description: "How Acme is doing.",
+      isSearchEngineIndexingEnabled: false,
+    });
+
+    expect(html).toMatch(NOINDEX_META);
+  });
+
+  it("keeps the noindex tag inside <head>, where crawlers read it", () => {
+    const html: string = renderIndexPage({
+      title: "Acme Status",
+      isSearchEngineIndexingEnabled: false,
+    });
+
+    const head: string = html.split("</head>")[0] || "";
+    expect(head).toMatch(NOINDEX_META);
+  });
+
+  it("says nothing about robots when indexing is on", () => {
+    /*
+     * Not "emits index, follow". A crawler already assumes that, and emitting
+     * it would override a noindex an operator set on a proxy in front of
+     * OneUptime - the last robots instruction a crawler reads is the one that
+     * counts.
+     */
+    const html: string = renderIndexPage({
+      title: "Acme Status",
+      description: "How Acme is doing.",
+      isSearchEngineIndexingEnabled: true,
+    });
+
+    expect(html).not.toContain('name="robots"');
+  });
+
+  it("says nothing about robots when the variable was never passed", () => {
+    /*
+     * The fallback render - a host that resolves to no status page - passes
+     * no flag at all, and must not throw on the missing variable either.
+     * That page is the generic placeholder and stays indexable, which is what
+     * shipped before this feature.
+     */
+    const html: string = renderIndexPage({ title: "Status Page" });
+
+    expect(html).not.toContain('name="robots"');
+    expect(html).toContain("<title>Status Page</title>");
+  });
+
+  it.each([
+    ["a truthy non-boolean", "no"],
+    ["null", null],
+    ["zero", 0],
+  ])(
+    "only an explicit false suppresses indexing, not %s",
+    (_label: string, value: unknown) => {
+      /*
+       * The template compares against false rather than testing falsiness, so
+       * a value arriving in an unexpected shape leaves the page indexable
+       * instead of silently de-indexing it.
+       */
+      const html: string = renderIndexPage({
+        title: "Acme Status",
+        isSearchEngineIndexingEnabled: value,
+      } as JSONObject);
+
+      expect(html).not.toContain('name="robots"');
+    },
+  );
+
+  it("still renders the rest of the head when indexing is off", () => {
+    /*
+     * The opt-out must not cost the page its title, description or favicon -
+     * a page kept out of search results is still a page people read.
+     */
+    const html: string = renderIndexPage({
+      title: "Acme Status",
+      description: "How Acme is doing.",
+      faviconUrl: "/status-page-api/favicon/acme",
+      isSearchEngineIndexingEnabled: false,
+    });
+
+    expect(html).toContain("<title>Acme Status</title>");
+    expect(html).toContain('content="How Acme is doing."');
+    expect(html).toContain('href="/status-page-api/favicon/acme"');
+  });
+});

package/Tests/Models/DatabaseModels/DatabaseBaseModelToJSONObjectCache.test.ts

@@ -0,0 +1,180 @@
+import BaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import Incident from "../../../Models/DatabaseModels/Incident";
+import IncidentSeverity from "../../../Models/DatabaseModels/IncidentSeverity";
+import Label from "../../../Models/DatabaseModels/Label";
+import Monitor from "../../../Models/DatabaseModels/Monitor";
+import Color from "../../../Types/Color";
+import { JSONArray, JSONObject } from "../../../Types/JSON";
+import ObjectID from "../../../Types/ObjectID";
+import { describe, expect, it } from "@jest/globals";
+
+/*
+ * toJSONObject reads table-column metadata off a cached, frozen, per-class
+ * vanilla instance instead of constructing one per row. These tests pin the
+ * contract that makes the cache safe: output is identical to a fresh
+ * construction, no state bleeds between rows or tenants, the cache is keyed
+ * on the declared modelType (not the instance's runtime class), and fromJSON
+ * still hands out a fresh mutable instance every call.
+ */
+
+describe("DatabaseBaseModel.toJSONObject with cached vanilla model", () => {
+  it("serializes a populated model with nested Entity and EntityArray columns", () => {
+    const severity: IncidentSeverity = new IncidentSeverity();
+    severity._id = "severity-id";
+    severity.name = "Critical";
+
+    const monitorOne: Monitor = new Monitor();
+    monitorOne._id = "monitor-one-id";
+    monitorOne.name = "Monitor One";
+
+    const monitorTwo: Monitor = new Monitor();
+    monitorTwo._id = "monitor-two-id";
+    monitorTwo.name = "Monitor Two";
+
+    const incident: Incident = new Incident();
+    incident._id = "incident-id";
+    incident.title = "Database is down";
+    incident.projectId = new ObjectID("project-one");
+    incident.incidentSeverity = severity;
+    incident.monitors = [monitorOne, monitorTwo];
+
+    const json: JSONObject = BaseModel.toJSONObject(incident, Incident);
+
+    expect(json["_id"]).toBe("incident-id");
+    expect(json["title"]).toBe("Database is down");
+    expect(json["projectId"]).toBe(incident.projectId);
+
+    // Nested Entity column is recursively serialized to a plain object.
+    const severityJson: JSONObject = json["incidentSeverity"] as JSONObject;
+    expect(severityJson).not.toBeInstanceOf(BaseModel);
+    expect(severityJson["_id"]).toBe("severity-id");
+    expect(severityJson["name"]).toBe("Critical");
+
+    // Nested EntityArray column is serialized item by item, order preserved.
+    const monitorsJson: JSONArray = json["monitors"] as JSONArray;
+    expect(Array.isArray(monitorsJson)).toBe(true);
+    expect(
+      monitorsJson.map((monitor: JSONObject | unknown) => {
+        expect(monitor).not.toBeInstanceOf(BaseModel);
+        return (monitor as JSONObject)["name"];
+      }),
+    ).toEqual(["Monitor One", "Monitor Two"]);
+
+    // Unset columns are skipped entirely.
+    expect("description" in json).toBe(false);
+  });
+
+  it("keeps each row's JSON isolated across repeated calls for the same class", () => {
+    const tenantOneProjectId: ObjectID = ObjectID.generate();
+    const tenantTwoProjectId: ObjectID = ObjectID.generate();
+
+    const tenantOneLabel: Label = new Label();
+    tenantOneLabel._id = "label-tenant-one";
+    tenantOneLabel.name = "Tenant One Label";
+    tenantOneLabel.projectId = tenantOneProjectId;
+
+    const tenantTwoLabel: Label = new Label();
+    tenantTwoLabel._id = "label-tenant-two";
+    tenantTwoLabel.name = "Tenant Two Label";
+    tenantTwoLabel.projectId = tenantTwoProjectId;
+
+    const jsonOne: JSONObject = BaseModel.toJSONObject(tenantOneLabel, Label);
+    const jsonTwo: JSONObject = BaseModel.toJSONObject(tenantTwoLabel, Label);
+
+    // Second serialization must not disturb the first result.
+    expect(jsonOne["_id"]).toBe("label-tenant-one");
+    expect(jsonOne["name"]).toBe("Tenant One Label");
+    expect(jsonOne["projectId"]).toBe(tenantOneProjectId);
+
+    expect(jsonTwo["_id"]).toBe("label-tenant-two");
+    expect(jsonTwo["name"]).toBe("Tenant Two Label");
+    expect(jsonTwo["projectId"]).toBe(tenantTwoProjectId);
+  });
+
+  it("does not leak a key set on an earlier row into a later row without it", () => {
+    const labelWithColor: Label = new Label();
+    labelWithColor.name = "Colored";
+    labelWithColor.color = new Color("#112233");
+
+    const labelWithoutColor: Label = new Label();
+    labelWithoutColor.name = "Plain";
+
+    const jsonWithColor: JSONObject = BaseModel.toJSONObject(
+      labelWithColor,
+      Label,
+    );
+    const jsonWithoutColor: JSONObject = BaseModel.toJSONObject(
+      labelWithoutColor,
+      Label,
+    );
+
+    expect(jsonWithColor["color"]).toBe(labelWithColor.color);
+    expect("color" in jsonWithoutColor).toBe(false);
+  });
+
+  it("serializes by the declared modelType, not the instance's runtime class", () => {
+    const label: Label = new Label();
+    label._id = "declared-type-label";
+    label.name = "Declared Type";
+    label.color = new Color("#445566");
+    label.projectId = ObjectID.generate();
+
+    /*
+     * Warm the subclass cache first so a cache wrongly keyed on
+     * model.constructor would surface Label columns below.
+     */
+    BaseModel.toJSONObject(label, Label);
+
+    const baseJson: JSONObject = BaseModel.toJSONObject(label, BaseModel);
+
+    const baseColumns: Array<string> = new BaseModel().getTableColumns()
+      .columns;
+    for (const key of Object.keys(baseJson)) {
+      expect(baseColumns).toContain(key);
+    }
+
+    expect(baseJson["_id"]).toBe("declared-type-label");
+    expect("color" in baseJson).toBe(false);
+    expect("projectId" in baseJson).toBe(false);
+  });
+
+  it("toJSONObject on a fresh base model returns an empty object", () => {
+    const json: JSONObject = BaseModel.toJSONObject(new BaseModel(), BaseModel);
+    expect(json).toEqual({});
+  });
+
+  it("fromJSON returns a fresh mutable instance on every call", () => {
+    const json: JSONObject = {
+      name: "oneuptime",
+      description: "a label",
+    };
+
+    const first: Label = BaseModel.fromJSON(json, Label) as Label;
+    const second: Label = BaseModel.fromJSON(json, Label) as Label;
+
+    expect(first).toBeInstanceOf(Label);
+    expect(second).toBeInstanceOf(Label);
+    expect(first).not.toBe(second);
+
+    first.name = "mutated";
+    expect(second.name).toBe("oneuptime");
+    expect(second.description).toBe("a label");
+  });
+
+  it("toJSONObjectArray serializes every item correctly on the cache-hit path", () => {
+    const labels: Array<Label> = [1, 2, 3, 4].map((index: number) => {
+      const label: Label = new Label();
+      label._id = `label-${index}`;
+      label.name = `Label ${index}`;
+      return label;
+    });
+
+    const jsonArray: JSONArray = BaseModel.toJSONObjectArray(labels, Label);
+
+    expect(jsonArray).toHaveLength(4);
+    jsonArray.forEach((item: JSONObject | unknown, index: number) => {
+      expect((item as JSONObject)["_id"]).toBe(`label-${index + 1}`);
+      expect((item as JSONObject)["name"]).toBe(`Label ${index + 1}`);
+    });
+  });
+});