@oneuptime/common 12.0.25 → 12.0.27

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

@@ -0,0 +1,439 @@
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import * as React from "react";
+import { describe, expect, test } from "@jest/globals";
+import NotificationRuleConditionsElement from "../../../../App/FeatureSet/Dashboard/src/Components/Workspace/NotificationRuleForm/NotificationRuleConditions";
+import NotificationRuleViewConditionElement from "../../../../App/FeatureSet/Dashboard/src/Components/Workspace/NotificationRuleViewElement/NotificationRuleViewCondition";
+import NotificationRuleEventType from "../../../Types/Workspace/NotificationRules/EventType";
+import NotificationRuleCondition, {
+  ConditionType,
+  NotificationRuleConditionCheckOn,
+  NotificationRuleConditionUtil,
+} from "../../../Types/Workspace/NotificationRules/NotificationRuleCondition";
+import AlertSeverity from "../../../Models/DatabaseModels/AlertSeverity";
+import AlertState from "../../../Models/DatabaseModels/AlertState";
+import IncidentSeverity from "../../../Models/DatabaseModels/IncidentSeverity";
+import IncidentState from "../../../Models/DatabaseModels/IncidentState";
+import Label from "../../../Models/DatabaseModels/Label";
+import Monitor from "../../../Models/DatabaseModels/Monitor";
+import MonitorStatus from "../../../Models/DatabaseModels/MonitorStatus";
+import ScheduledMaintenanceState from "../../../Models/DatabaseModels/ScheduledMaintenanceState";
+import getJestMockFunction, { MockFunction } from "../../MockType";
+
+/*
+ * #3459 as the user met it: on On-Call Duty → a policy → Notification Rules →
+ * Microsoft Teams, "Add Condition" dropped in a condition block whose "Filter
+ * Type" dropdown opened onto react-select's "No options". Nothing could be
+ * chosen, so the rule stayed "trigger for every On-Call Duty Policy".
+ *
+ * OnCallDutyPolicyConditions.test.ts pins the option lists themselves. This
+ * file drives the real components, because "No options" is something
+ * react-select renders when the list it was handed is empty - a rule about
+ * lists cannot say whether that reaches the screen, only the rendered form
+ * can.
+ *
+ * Assertions stay on plain DOM text: jest-dom's matchers do not typecheck
+ * repo-wide.
+ */
+
+// react-select's own empty-list message, i.e. the bug as it appeared.
+const NO_OPTIONS: string = "No options";
+
+const PAYMENTS_LABEL_ID: string = "a1a1a1a1a1a1a1a1a1a1a1a1";
+const SEARCH_LABEL_ID: string = "b2b2b2b2b2b2b2b2b2b2b2b2";
+
+function named<T extends { _id?: string; name?: string }>(
+  model: T,
+  id: string,
+  name: string,
+): T {
+  model._id = id;
+  model.name = name;
+  return model;
+}
+
+function projectLabels(): Array<Label> {
+  return [
+    named(new Label(), PAYMENTS_LABEL_ID, "Payments"),
+    named(new Label(), SEARCH_LABEL_ID, "Search"),
+  ];
+}
+
+// Everything both components need to turn stored ids into names.
+function lookupProps(): {
+  monitors: Array<Monitor>;
+  labels: Array<Label>;
+  alertStates: Array<AlertState>;
+  alertSeverities: Array<AlertSeverity>;
+  incidentSeverities: Array<IncidentSeverity>;
+  incidentStates: Array<IncidentState>;
+  scheduledMaintenanceStates: Array<ScheduledMaintenanceState>;
+  monitorStatus: Array<MonitorStatus>;
+} {
+  return {
+    monitors: [named(new Monitor(), "c7c7c7c7c7c7c7c7c7c7c7c7", "API")],
+    labels: projectLabels(),
+    alertStates: [
+      named(new AlertState(), "c2c2c2c2c2c2c2c2c2c2c2c2", "Created"),
+    ],
+    alertSeverities: [
+      named(new AlertSeverity(), "c1c1c1c1c1c1c1c1c1c1c1c1", "Sev 1"),
+    ],
+    incidentSeverities: [
+      named(new IncidentSeverity(), "c3c3c3c3c3c3c3c3c3c3c3c3", "Major"),
+    ],
+    incidentStates: [
+      named(new IncidentState(), "c5c5c5c5c5c5c5c5c5c5c5c5", "Acknowledged"),
+    ],
+    scheduledMaintenanceStates: [
+      named(
+        new ScheduledMaintenanceState(),
+        "c6c6c6c6c6c6c6c6c6c6c6c6",
+        "Ongoing",
+      ),
+    ],
+    monitorStatus: [
+      named(new MonitorStatus(), "c4c4c4c4c4c4c4c4c4c4c4c4", "Offline"),
+    ],
+  };
+}
+
+function renderConditions(eventType: NotificationRuleEventType): {
+  onChange: MockFunction;
+} {
+  const onChange: MockFunction = getJestMockFunction();
+
+  render(
+    <NotificationRuleConditionsElement
+      {...lookupProps()}
+      eventType={eventType}
+      value={[]}
+      onChange={
+        onChange as unknown as (value: Array<NotificationRuleCondition>) => void
+      }
+    />,
+  );
+
+  return { onChange: onChange };
+}
+
+// The condition list the newest onChange handed back.
+function lastConditionsFrom(
+  onChange: MockFunction,
+): Array<NotificationRuleCondition> {
+  expect(onChange.mock.calls.length).toBeGreaterThan(0);
+
+  return onChange.mock.calls[
+    onChange.mock.calls.length - 1
+  ]![0] as Array<NotificationRuleCondition>;
+}
+
+async function clickAddCondition(): Promise<void> {
+  const user: ReturnType<typeof userEvent.setup> = userEvent.setup();
+  await user.click(screen.getByRole("button", { name: /Add Condition/i }));
+}
+
+/*
+ * react-select renders one text input per dropdown, in form order:
+ * 0 = Filter Type, 1 = Filter Condition, 2 = Value (when it is a dropdown).
+ */
+async function openDropdown(index: number): Promise<void> {
+  const user: ReturnType<typeof userEvent.setup> = userEvent.setup();
+  const comboboxes: Array<HTMLElement> = screen.getAllByRole("combobox");
+
+  expect(comboboxes.length).toBeGreaterThan(index);
+
+  await user.click(comboboxes[index]!);
+}
+
+async function pickFromDropdown(input: {
+  index: number;
+  optionLabel: string;
+}): Promise<void> {
+  const user: ReturnType<typeof userEvent.setup> = userEvent.setup();
+
+  await openDropdown(input.index);
+  await user.click(await screen.findByText(input.optionLabel));
+}
+
+describe("The workspace notification rule Conditions editor", () => {
+  describe("the On-Call Duty Policy editor reported in #3459", () => {
+    test("the Filter Type dropdown lists the on-call fields instead of 'No options'", async () => {
+      renderConditions(NotificationRuleEventType.OnCallDutyPolicy);
+
+      await clickAddCondition();
+      await openDropdown(0);
+
+      expect(screen.queryByText(NO_OPTIONS)).toBeNull();
+      expect(
+        screen.getAllByText(
+          NotificationRuleConditionCheckOn.OnCallDutyPolicyName,
+        ).length,
+      ).toBeGreaterThan(0);
+      expect(
+        screen.getAllByText(
+          NotificationRuleConditionCheckOn.OnCallDutyPolicyDescription,
+        ).length,
+      ).toBeGreaterThan(0);
+      expect(
+        screen.getAllByText(
+          NotificationRuleConditionCheckOn.OnCallDutyPolicyLabels,
+        ).length,
+      ).toBeGreaterThan(0);
+    });
+
+    test("Add Condition seeds a usable row rather than an undefined check-on", async () => {
+      const { onChange } = renderConditions(
+        NotificationRuleEventType.OnCallDutyPolicy,
+      );
+
+      await clickAddCondition();
+
+      const conditions: Array<NotificationRuleCondition> =
+        lastConditionsFrom(onChange);
+
+      expect(conditions.length).toBe(1);
+      expect(conditions[0]!.checkOn).toBe(
+        NotificationRuleConditionCheckOn.OnCallDutyPolicyName,
+      );
+      expect(conditions[0]!.conditionType).toBe(ConditionType.EqualTo);
+    });
+
+    test("the Filter Condition dropdown offers the text operators once a field is chosen", async () => {
+      renderConditions(NotificationRuleEventType.OnCallDutyPolicy);
+
+      await clickAddCondition();
+      await pickFromDropdown({
+        index: 0,
+        optionLabel:
+          NotificationRuleConditionCheckOn.OnCallDutyPolicyDescription,
+      });
+      await openDropdown(1);
+
+      expect(screen.queryByText(NO_OPTIONS)).toBeNull();
+      expect(
+        screen.getAllByText(ConditionType.Contains).length,
+      ).toBeGreaterThan(0);
+      expect(
+        screen.getAllByText(ConditionType.StartsWith).length,
+      ).toBeGreaterThan(0);
+    });
+
+    test("choosing the labels field offers the project's labels as the value", async () => {
+      renderConditions(NotificationRuleEventType.OnCallDutyPolicy);
+
+      await clickAddCondition();
+      await pickFromDropdown({
+        index: 0,
+        optionLabel: NotificationRuleConditionCheckOn.OnCallDutyPolicyLabels,
+      });
+      await pickFromDropdown({
+        index: 1,
+        optionLabel: ConditionType.ContainsAny,
+      });
+      await openDropdown(2);
+
+      expect(screen.queryByText(NO_OPTIONS)).toBeNull();
+      expect(screen.getAllByText("Payments").length).toBeGreaterThan(0);
+      expect(screen.getAllByText("Search").length).toBeGreaterThan(0);
+    });
+
+    test("a chosen label is recorded on the condition by id", async () => {
+      const { onChange } = renderConditions(
+        NotificationRuleEventType.OnCallDutyPolicy,
+      );
+
+      await clickAddCondition();
+      await pickFromDropdown({
+        index: 0,
+        optionLabel: NotificationRuleConditionCheckOn.OnCallDutyPolicyLabels,
+      });
+      await pickFromDropdown({
+        index: 1,
+        optionLabel: ConditionType.ContainsAny,
+      });
+      await pickFromDropdown({ index: 2, optionLabel: "Payments" });
+
+      const conditions: Array<NotificationRuleCondition> =
+        lastConditionsFrom(onChange);
+
+      expect(conditions[0]!.checkOn).toBe(
+        NotificationRuleConditionCheckOn.OnCallDutyPolicyLabels,
+      );
+      expect(conditions[0]!.conditionType).toBe(ConditionType.ContainsAny);
+      expect(conditions[0]!.value).toEqual([PAYMENTS_LABEL_ID]);
+    });
+  });
+
+  describe("every event type a Workspace Connections page can open", () => {
+    /*
+     * The On-Call page was not special: any event type missing from
+     * getCheckOnByEventType renders the same dead condition block. Walk the
+     * whole enum so the next resource cannot ship the same way.
+     */
+    test.each(Object.values(NotificationRuleEventType))(
+      "%s seeds a fully-formed condition and shows filter types",
+      async (eventType: NotificationRuleEventType) => {
+        const { onChange } = renderConditions(eventType);
+
+        await clickAddCondition();
+
+        const conditions: Array<NotificationRuleCondition> =
+          lastConditionsFrom(onChange);
+
+        expect(conditions.length).toBe(1);
+        expect(conditions[0]!.checkOn).toBeDefined();
+        expect(conditions[0]!.conditionType).toBeDefined();
+
+        await openDropdown(0);
+        expect(screen.queryByText(NO_OPTIONS)).toBeNull();
+      },
+    );
+
+    test.each(Object.values(NotificationRuleEventType))(
+      "%s seeds the first check-on its own option list starts with",
+      async (eventType: NotificationRuleEventType) => {
+        const { onChange } = renderConditions(eventType);
+
+        await clickAddCondition();
+
+        expect(lastConditionsFrom(onChange)[0]!.checkOn).toBe(
+          NotificationRuleConditionUtil.getCheckOnByEventType(eventType)[0],
+        );
+      },
+    );
+  });
+});
+
+describe("The saved-rule condition view", () => {
+  function renderView(condition: NotificationRuleCondition): void {
+    render(
+      <NotificationRuleViewConditionElement
+        {...lookupProps()}
+        notificationRuleCondition={condition}
+      />,
+    );
+  }
+
+  test("renders on-call policy labels by name, not by stored id", () => {
+    /*
+     * The label check-ons were listed one by one in the view, and the on-call
+     * one was missing - so a saved on-call rule read back as a raw uuid.
+     */
+    renderView({
+      checkOn: NotificationRuleConditionCheckOn.OnCallDutyPolicyLabels,
+      conditionType: ConditionType.ContainsAny,
+      value: [PAYMENTS_LABEL_ID],
+    });
+
+    expect(screen.getAllByText("Payments").length).toBeGreaterThan(0);
+    expect(screen.queryByText(PAYMENTS_LABEL_ID)).toBeNull();
+  });
+
+  test("renders alert episode labels by name", () => {
+    renderView({
+      checkOn: NotificationRuleConditionCheckOn.AlertEpisodeLabels,
+      conditionType: ConditionType.ContainsAny,
+      value: [SEARCH_LABEL_ID],
+    });
+
+    expect(screen.getAllByText("Search").length).toBeGreaterThan(0);
+    expect(screen.queryByText(SEARCH_LABEL_ID)).toBeNull();
+  });
+
+  test("renders incident episode labels by name", () => {
+    renderView({
+      checkOn: NotificationRuleConditionCheckOn.IncidentEpisodeLabels,
+      conditionType: ConditionType.ContainsAny,
+      value: [PAYMENTS_LABEL_ID],
+    });
+
+    expect(screen.getAllByText("Payments").length).toBeGreaterThan(0);
+    expect(screen.queryByText(PAYMENTS_LABEL_ID)).toBeNull();
+  });
+
+  test("renders alert episode severity by name", () => {
+    renderView({
+      checkOn: NotificationRuleConditionCheckOn.AlertEpisodeSeverity,
+      conditionType: ConditionType.ContainsAny,
+      value: ["c1c1c1c1c1c1c1c1c1c1c1c1"],
+    });
+
+    expect(screen.getAllByText("Sev 1").length).toBeGreaterThan(0);
+  });
+
+  test("renders alert episode state by name", () => {
+    renderView({
+      checkOn: NotificationRuleConditionCheckOn.AlertEpisodeState,
+      conditionType: ConditionType.ContainsAny,
+      value: ["c2c2c2c2c2c2c2c2c2c2c2c2"],
+    });
+
+    expect(screen.getAllByText("Created").length).toBeGreaterThan(0);
+  });
+
+  test("renders incident episode severity by name", () => {
+    renderView({
+      checkOn: NotificationRuleConditionCheckOn.IncidentEpisodeSeverity,
+      conditionType: ConditionType.ContainsAny,
+      value: ["c3c3c3c3c3c3c3c3c3c3c3c3"],
+    });
+
+    expect(screen.getAllByText("Major").length).toBeGreaterThan(0);
+  });
+
+  test("renders incident episode state by name", () => {
+    renderView({
+      checkOn: NotificationRuleConditionCheckOn.IncidentEpisodeState,
+      conditionType: ConditionType.ContainsAny,
+      value: ["c5c5c5c5c5c5c5c5c5c5c5c5"],
+    });
+
+    expect(screen.getAllByText("Acknowledged").length).toBeGreaterThan(0);
+  });
+
+  test("renders the on-call policy name filter as plain text", () => {
+    renderView({
+      checkOn: NotificationRuleConditionCheckOn.OnCallDutyPolicyName,
+      conditionType: ConditionType.Contains,
+      value: "Payments Escalation",
+    });
+
+    expect(screen.getAllByText("Payments Escalation").length).toBeGreaterThan(
+      0,
+    );
+  });
+
+  test.each([
+    NotificationRuleConditionCheckOn.OnCallDutyPolicyLabels,
+    NotificationRuleConditionCheckOn.IncidentLabels,
+    NotificationRuleConditionCheckOn.IncidentState,
+    NotificationRuleConditionCheckOn.Monitors,
+  ])(
+    "survives a %s condition saved without a value",
+    (checkOn: NotificationRuleConditionCheckOn) => {
+      /*
+       * A dropdown-backed condition whose value never got picked used to reach
+       * `undefined.includes(...)` and take the whole rule view down with it.
+       */
+      renderView({
+        checkOn: checkOn,
+        conditionType: ConditionType.ContainsAny,
+        value: undefined,
+      });
+
+      expect(screen.getAllByText(checkOn).length).toBeGreaterThan(0);
+      expect(screen.queryByText("Payments")).toBeNull();
+    },
+  );
+
+  test("survives a label condition saved as a single string", () => {
+    renderView({
+      checkOn: NotificationRuleConditionCheckOn.IncidentLabels,
+      conditionType: ConditionType.ContainsAny,
+      value: PAYMENTS_LABEL_ID,
+    });
+
+    expect(screen.getAllByText("Payments").length).toBeGreaterThan(0);
+  });
+});

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

@@ -0,0 +1,182 @@
+import BaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import EnterpriseLicense from "../../../Models/DatabaseModels/EnterpriseLicense";
+import ScheduledMaintenance from "../../../Models/DatabaseModels/ScheduledMaintenance";
+import { JSONObject } from "../../../Types/JSON";
+import JSONFunctions from "../../../Types/JSONFunctions";
+import OneUptimeDate from "../../../Types/Date";
+import { describe, expect, it } from "@jest/globals";
+
+/*
+ * Contract under test — what a date column holds after a JSON round trip.
+ *
+ * `BaseModel.fromJSON` is the single door every model comes through, and it
+ * runs on BOTH sides of the wire: ModelForm builds the model it is about to
+ * POST with it, and BaseAPI rebuilds that model from the request body with
+ * it. That makes it the one place that can fix the following, once.
+ *
+ * HTML has no Date input event — `<input type="date">` gives you
+ * `e.target.value`, the string "YYYY-MM-DD" — so the dashboard posted a plain
+ * string for every date field in the product. Postgres parses that string on
+ * the way in, so it was invisible everywhere except where something reads the
+ * column back off the saved model: TypeORM's `save()` returns the entity it
+ * was handed, never a re-read row.
+ *
+ * EnterpriseLicenseService.onCreateSuccess does exactly that, and creating an
+ * enterprise licence in the admin dashboard answered:
+ *
+ *   HTTP 500 — Server Error
+ *
+ * for every attempt, having written a licence row for every attempt, because
+ * `createdItem.expiresAt.toISOString()` was called on a string after the
+ * INSERT had committed.
+ */
+
+describe("BaseModel.fromJSON on date columns", () => {
+  /*
+   * The reported payload, exactly as the admin dashboard's Enterprise
+   * Licenses form sends it: expiresAt comes from an <input type="date">, so
+   * it is the string "YYYY-MM-DD".
+   */
+  it("turns the admin licence form's payload into a real Date", () => {
+    const posted: JSONObject = {
+      companyName: "Acme, Inc.",
+      licenseKey: "b6f4c1a2-1111-2222-3333-444455556666",
+      expiresAt: "2027-01-01",
+      isEvaluationLicense: false,
+    };
+
+    const model: EnterpriseLicense = BaseModel.fromJSON(
+      posted,
+      EnterpriseLicense,
+    ) as EnterpriseLicense;
+
+    expect(model.expiresAt).toBeInstanceOf(Date);
+    expect(model.expiresAt!.toISOString()).toBe("2027-01-01T00:00:00.000Z");
+  });
+
+  /*
+   * The regression in one line: this is the call that threw, and it has to be
+   * safe on a model built the way the API builds one.
+   */
+  it("leaves the created model safe to call toISOString on", () => {
+    const model: EnterpriseLicense = BaseModel.fromJSON(
+      { companyName: "Acme, Inc.", expiresAt: "2027-01-01" },
+      EnterpriseLicense,
+    ) as EnterpriseLicense;
+
+    expect(() => {
+      return model.expiresAt!.toISOString();
+    }).not.toThrow();
+  });
+
+  it("does the same for a datetime-local field on another model", () => {
+    const model: ScheduledMaintenance = BaseModel.fromJSON(
+      {
+        title: "Database upgrade",
+        startsAt: "2027-01-01T10:30",
+        endsAt: "2027-01-01T12:00",
+      },
+      ScheduledMaintenance,
+    ) as ScheduledMaintenance;
+
+    expect(model.startsAt).toBeInstanceOf(Date);
+    expect(model.startsAt!.toISOString()).toBe("2027-01-01T10:30:00.000Z");
+    expect(model.endsAt).toBeInstanceOf(Date);
+    expect(model.endsAt!.toISOString()).toBe("2027-01-01T12:00:00.000Z");
+  });
+
+  /*
+   * The path that always worked — a Date serialized by JSONFunctions into
+   * { _type: "DateTime", value } — must keep working. Coercion sits after
+   * deserialization, so by the time it runs this is already a Date and it has
+   * nothing to do.
+   */
+  it("still handles the serialized DateTime wrapper", () => {
+    const expiresAt: Date = new Date("2027-03-04T05:06:07.000Z");
+
+    const model: EnterpriseLicense = BaseModel.fromJSON(
+      JSONFunctions.serialize({
+        companyName: "Acme, Inc.",
+        expiresAt: expiresAt,
+      }),
+      EnterpriseLicense,
+    ) as EnterpriseLicense;
+
+    expect(model.expiresAt).toBeInstanceOf(Date);
+    expect(model.expiresAt!.getTime()).toBe(expiresAt.getTime());
+  });
+
+  it("passes a Date straight through", () => {
+    const expiresAt: Date = new Date("2027-03-04T05:06:07.000Z");
+
+    const model: EnterpriseLicense = BaseModel.fromJSON(
+      { companyName: "Acme, Inc.", expiresAt: expiresAt } as JSONObject,
+      EnterpriseLicense,
+    ) as EnterpriseLicense;
+
+    expect(model.expiresAt).toBeInstanceOf(Date);
+    expect(model.expiresAt!.getTime()).toBe(expiresAt.getTime());
+  });
+
+  /*
+   * The instant that reaches Postgres must not move. An offset-less literal
+   * in a timestamptz column is parsed in the session timezone — UTC in every
+   * OneUptime deployment — so the coerced Date has to be the same instant the
+   * raw string used to become.
+   */
+  it("produces the instant Postgres produced from the same string", () => {
+    const model: EnterpriseLicense = BaseModel.fromJSON(
+      { expiresAt: "2027-01-01" },
+      EnterpriseLicense,
+    ) as EnterpriseLicense;
+
+    expect(model.expiresAt!.toISOString()).toBe(
+      OneUptimeDate.fromString("2027-01-01T00:00:00Z").toISOString(),
+    );
+  });
+
+  it("does not touch the other columns on the way past", () => {
+    const model: EnterpriseLicense = BaseModel.fromJSON(
+      {
+        companyName: "Acme, Inc.",
+        email: "buyer@acme.com",
+        licenseKey: "key-1",
+        expiresAt: "2027-01-01",
+        userLimit: "50",
+        annualContractValue: "12000",
+        isEvaluationLicense: true,
+      },
+      EnterpriseLicense,
+    ) as EnterpriseLicense;
+
+    expect(model.companyName).toBe("Acme, Inc.");
+    expect(model.licenseKey).toBe("key-1");
+    expect(model.userLimit).toBe(50);
+    expect(model.annualContractValue).toBe(12000);
+    expect(model.isEvaluationLicense).toBe(true);
+    expect(model.expiresAt).toBeInstanceOf(Date);
+  });
+
+  it("leaves a cleared date field alone rather than inventing an epoch", () => {
+    const model: EnterpriseLicense = BaseModel.fromJSON(
+      { companyName: "Acme, Inc.", expiresAt: "" },
+      EnterpriseLicense,
+    ) as EnterpriseLicense;
+
+    expect(model.expiresAt).toBe("");
+  });
+
+  /*
+   * An unparseable date is left as the string it was, so the required-field
+   * and database layers report the field. Inventing a date here would store a
+   * silently wrong expiry on a licence.
+   */
+  it("leaves an unparseable date alone so validation reports it", () => {
+    const model: EnterpriseLicense = BaseModel.fromJSON(
+      { companyName: "Acme, Inc.", expiresAt: "not-a-date" },
+      EnterpriseLicense,
+    ) as EnterpriseLicense;
+
+    expect(model.expiresAt).toBe("not-a-date");
+  });
+});

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

@@ -0,0 +1,82 @@
+import AllModelTypes from "../../../Models/DatabaseModels/Index";
+import BaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import { TableColumnMetadata } from "../../../Types/Database/TableColumn";
+import TableColumnType from "../../../Types/Database/TableColumnType";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * Contract under test: every relation column (Entity / EntityArray) on every
+ * database model resolves to a real related model at read time.
+ *
+ * The case that prompted this: Monitor and NetworkDevice import each other to
+ * declare their mutual relation. That is a circular import, and whichever
+ * module the loader reached second saw the first as `undefined` while its own
+ * @TableColumn decorators ran - so an eager `modelType: TheOtherModel` captured
+ * `undefined`. Nothing complained until a query selected that relation (the
+ * delete audit snapshot fetches every column), at which point the permission
+ * layer threw "Select not supported ... because this column modelType is not
+ * found" - a 400 that made the Terraform E2E monitor delete fail every run.
+ *
+ * Sweeping every model rather than asserting on the one pair is the point: the
+ * next two models that import each other fail here, in a fast unit test, rather
+ * than in a delete path or a relation query in production.
+ */
+
+type ModelType = { new (): BaseModel };
+
+const MODEL_TYPES: Array<ModelType> = AllModelTypes as Array<ModelType>;
+
+function modelName(modelType: ModelType): string {
+  return modelType.name;
+}
+
+describe("Relation column modelType coverage across database models", () => {
+  test("every Entity / EntityArray column resolves a related model", () => {
+    const offenders: Array<string> = [];
+
+    for (const modelType of MODEL_TYPES) {
+      const model: BaseModel = new modelType();
+
+      for (const column of model.getTableColumns().columns) {
+        const metadata: TableColumnMetadata =
+          model.getTableColumnMetadata(column);
+
+        if (!metadata) {
+          continue;
+        }
+
+        const isRelation: boolean =
+          metadata.type === TableColumnType.Entity ||
+          metadata.type === TableColumnType.EntityArray;
+
+        if (!isRelation) {
+          continue;
+        }
+
+        if (!metadata.modelType) {
+          offenders.push(
+            `${modelName(modelType)}.${column} (${metadata.type})`,
+          );
+          continue;
+        }
+
+        // The resolved modelType must be constructable into a real model.
+        try {
+          const related: BaseModel = new metadata.modelType();
+
+          if (!(related instanceof BaseModel)) {
+            offenders.push(
+              `${modelName(modelType)}.${column} resolves to a non-model`,
+            );
+          }
+        } catch {
+          offenders.push(
+            `${modelName(modelType)}.${column} modelType is not constructable`,
+          );
+        }
+      }
+    }
+
+    expect(offenders.sort()).toEqual([]);
+  });
+});