@oneuptime/common 13.0.5 → 13.0.6

package/Tests/Types/Rules/RuleRun.test.ts

@@ -0,0 +1,315 @@
+import {
+  MAX_RULE_RUN_PASSES,
+  RULE_RUN_RESOURCES_PER_PASS,
+  RULE_RUN_TYPE_METADATA,
+  RuleRunAction,
+  RuleRunPassResult,
+  RuleRunResult,
+  RuleRunResultUtil,
+  RuleRunType,
+  RuleRunTypeUtil,
+} from "../../../Types/Rules/RuleRun";
+import { JSONObject } from "../../../Types/JSON";
+import { describe, expect, it } from "@jest/globals";
+import fs from "fs";
+import path from "path";
+
+/*
+ * Contract under test - the shapes "Run now" shares between the API and the
+ * dashboard.
+ *
+ * Three things here fail silently if they drift. The run type IS the rule
+ * model's tableName, and the dashboard recognises a runnable table by it, so a
+ * value that is not a real tableName is a rule table with no Run Now. The
+ * action decides what the confirmation promises, so a label rule mapped to the
+ * owner action would describe the wrong run. And the parser is what stands
+ * between a hand-rolled or old API response and "NaN monitors" in a modal.
+ */
+
+const MODELS_DIRECTORY: string = path.resolve(
+  __dirname,
+  "..",
+  "..",
+  "..",
+  "Models",
+  "DatabaseModels",
+);
+
+const RULE_ID: string = "44444444-4444-4444-8444-444444444444";
+
+function pass(overrides: Partial<RuleRunPassResult> = {}): RuleRunPassResult {
+  return {
+    ...RuleRunResultUtil.emptyCounts(),
+    nextCursor: null,
+    ownersNotified: false,
+    ...overrides,
+  };
+}
+
+describe("RuleRunType", () => {
+  const ruleTypes: Array<RuleRunType> = Object.values(RuleRunType);
+
+  it("covers every label, owner and privacy rule plus status page and SLO monitor rules", () => {
+    const modelFiles: Array<string> = fs
+      .readdirSync(MODELS_DIRECTORY)
+      .map((fileName: string): string => {
+        return fileName.replace(/\.ts$/, "");
+      });
+
+    const runnableRuleModelName: RegExp = /(LabelRule|OwnerRule|PrivacyRule)$/;
+
+    const expected: Array<string> = modelFiles
+      .filter((modelName: string): boolean => {
+        return runnableRuleModelName.test(modelName);
+      })
+      .concat(["StatusPageMonitorRule", "ServiceLevelObjectiveMonitorRule"])
+      .sort();
+
+    expect([...ruleTypes].sort()).toEqual(expected);
+  });
+
+  it.each(ruleTypes)(
+    "%s is the tableName of a real rule model",
+    (ruleType: RuleRunType) => {
+      const source: string = fs.readFileSync(
+        path.join(MODELS_DIRECTORY, `${ruleType}.ts`),
+        "utf8",
+      );
+
+      expect(source).toContain(`tableName: "${ruleType}"`);
+    },
+  );
+
+  /*
+   * The user-facing decision behind this feature: rules whose effect on an
+   * existing record is paging someone, executing a runbook or regrouping
+   * episodes are deliberately not runnable against old data.
+   */
+  it.each([
+    "IncidentOnCallRule",
+    "AlertOnCallRule",
+    "IncidentEpisodeOnCallRule",
+    "AlertEpisodeOnCallRule",
+    "RunbookRule",
+    "AutoRemediationRule",
+    "IncidentGroupingRule",
+    "AlertGroupingRule",
+    "IncidentReminderRule",
+    "NetworkSiteAssignmentRule",
+  ])("%s cannot be run", (tableName: string) => {
+    expect(RuleRunTypeUtil.fromTableName(tableName)).toBeNull();
+  });
+});
+
+describe("RULE_RUN_TYPE_METADATA", () => {
+  it.each(Object.values(RuleRunType))(
+    "%s has an action that matches its name and readable nouns",
+    (ruleType: RuleRunType) => {
+      const meta: (typeof RULE_RUN_TYPE_METADATA)[RuleRunType] =
+        RULE_RUN_TYPE_METADATA[ruleType];
+
+      const expectedAction: RuleRunAction = ruleType.endsWith("LabelRule")
+        ? RuleRunAction.AddLabels
+        : ruleType.endsWith("OwnerRule")
+          ? RuleRunAction.AddOwners
+          : ruleType.endsWith("PrivacyRule")
+            ? RuleRunAction.MarkPrivate
+            : ruleType === RuleRunType.ServiceLevelObjectiveMonitorRule
+              ? RuleRunAction.SyncSloMonitors
+              : RuleRunAction.SyncStatusPageMonitors;
+
+      expect(meta.action).toBe(expectedAction);
+      expect(meta.resourceSingular.length).toBeGreaterThan(0);
+      expect(meta.resourcePlural.length).toBeGreaterThan(
+        meta.resourceSingular.length - 1,
+      );
+      expect(meta.resourcePlural).not.toBe(meta.resourceSingular);
+    },
+  );
+
+  it("agrees on the resource between a resource's label and owner rules", () => {
+    expect(RULE_RUN_TYPE_METADATA[RuleRunType.HostLabelRule]).toEqual({
+      ...RULE_RUN_TYPE_METADATA[RuleRunType.HostOwnerRule],
+      action: RuleRunAction.AddLabels,
+    });
+    expect(
+      RULE_RUN_TYPE_METADATA[RuleRunType.IncidentPrivacyRule].resourcePlural,
+    ).toBe("incidents");
+  });
+});
+
+describe("RuleRunTypeUtil", () => {
+  it("recognises a runnable rule by its tableName", () => {
+    expect(RuleRunTypeUtil.fromTableName("MonitorLabelRule")).toBe(
+      RuleRunType.MonitorLabelRule,
+    );
+    expect(RuleRunTypeUtil.fromTableName("StatusPageMonitorRule")).toBe(
+      RuleRunType.StatusPageMonitorRule,
+    );
+    expect(
+      RuleRunTypeUtil.fromTableName("ServiceLevelObjectiveMonitorRule"),
+    ).toBe(RuleRunType.ServiceLevelObjectiveMonitorRule);
+  });
+
+  /*
+   * An SLO's monitors are the union of every enabled rule of the SLO, while a
+   * status page rule owns only what it added; the two syncs are described and
+   * run differently, so they must not share an action.
+   */
+  it("gives SLO monitor rules their own sync action, not the status page one", () => {
+    expect(
+      RuleRunTypeUtil.getAction(RuleRunType.ServiceLevelObjectiveMonitorRule),
+    ).toBe(RuleRunAction.SyncSloMonitors);
+    expect(RuleRunTypeUtil.getAction(RuleRunType.StatusPageMonitorRule)).toBe(
+      RuleRunAction.SyncStatusPageMonitors,
+    );
+  });
+
+  it("rejects anything else", () => {
+    expect(RuleRunTypeUtil.fromTableName(undefined)).toBeNull();
+    expect(RuleRunTypeUtil.fromTableName(null)).toBeNull();
+    expect(RuleRunTypeUtil.fromTableName("")).toBeNull();
+    expect(RuleRunTypeUtil.fromTableName("monitorlabelrule")).toBeNull();
+    expect(RuleRunTypeUtil.isRuleRunType(42)).toBe(false);
+    expect(RuleRunTypeUtil.isRuleRunType("__proto__")).toBe(false);
+  });
+
+  it("reads the action off the metadata", () => {
+    expect(RuleRunTypeUtil.getAction(RuleRunType.AlertOwnerRule)).toBe(
+      RuleRunAction.AddOwners,
+    );
+  });
+});
+
+describe("run bounds", () => {
+  it("covers a large project in one press while keeping each pass small", () => {
+    expect(RULE_RUN_RESOURCES_PER_PASS).toBeLessThanOrEqual(500);
+    expect(RULE_RUN_RESOURCES_PER_PASS * MAX_RULE_RUN_PASSES).toBeGreaterThan(
+      99999,
+    );
+  });
+});
+
+describe("RuleRunResultUtil.parsePassResult", () => {
+  it("reads every counter and the cursor", () => {
+    const json: JSONObject = {
+      resourcesEvaluated: 200,
+      resourcesMatched: 40,
+      resourcesUpdated: 12,
+      itemsAdded: 24,
+      itemsRemoved: 1,
+      resourcesFailed: 2,
+      nextCursor: RULE_ID,
+      ownersNotified: true,
+    };
+
+    expect(RuleRunResultUtil.parsePassResult(json)).toEqual(json);
+  });
+
+  it("reads an absent body as an empty, finished pass", () => {
+    expect(RuleRunResultUtil.parsePassResult(undefined)).toEqual(pass());
+    expect(RuleRunResultUtil.parsePassResult(null)).toEqual(pass());
+    expect(RuleRunResultUtil.parsePassResult({})).toEqual(pass());
+  });
+
+  it("reads junk counters as zero rather than NaN", () => {
+    const parsed: RuleRunPassResult = RuleRunResultUtil.parsePassResult({
+      resourcesEvaluated: "200",
+      resourcesMatched: Number.NaN,
+      resourcesUpdated: -3,
+      itemsAdded: Number.POSITIVE_INFINITY,
+      itemsRemoved: null,
+      resourcesFailed: 2.7,
+    } as unknown as JSONObject);
+
+    expect(parsed.resourcesEvaluated).toBe(0);
+    expect(parsed.resourcesMatched).toBe(0);
+    expect(parsed.resourcesUpdated).toBe(0);
+    expect(parsed.itemsAdded).toBe(0);
+    expect(parsed.itemsRemoved).toBe(0);
+    expect(parsed.resourcesFailed).toBe(2);
+  });
+
+  /*
+   * A cursor that is not an id would be rejected by the next request; reading
+   * it as "more to do" would turn one bad response into a loop of 400s.
+   */
+  it("ends the run on a cursor that is not an id", () => {
+    for (const cursor of ["", "not-a-uuid", 42, true, {}]) {
+      expect(
+        RuleRunResultUtil.parsePassResult({
+          nextCursor: cursor,
+        } as unknown as JSONObject).nextCursor,
+      ).toBeNull();
+    }
+  });
+
+  it("only reads a literal true as notified", () => {
+    expect(
+      RuleRunResultUtil.parsePassResult({ ownersNotified: "true" })
+        .ownersNotified,
+    ).toBe(false);
+    expect(
+      RuleRunResultUtil.parsePassResult({ ownersNotified: 1 }).ownersNotified,
+    ).toBe(false);
+  });
+});
+
+describe("RuleRunResultUtil.mergePasses", () => {
+  it("sums every counter across passes", () => {
+    const merged: RuleRunResult = RuleRunResultUtil.mergePasses({
+      passes: [
+        pass({
+          resourcesEvaluated: 200,
+          resourcesMatched: 10,
+          resourcesUpdated: 8,
+          itemsAdded: 16,
+          resourcesFailed: 1,
+          nextCursor: RULE_ID,
+        }),
+        pass({
+          resourcesEvaluated: 57,
+          resourcesMatched: 3,
+          resourcesUpdated: 3,
+          itemsAdded: 3,
+          itemsRemoved: 2,
+        }),
+      ],
+      isTruncated: false,
+    });
+
+    expect(merged).toEqual({
+      resourcesEvaluated: 257,
+      resourcesMatched: 13,
+      resourcesUpdated: 11,
+      itemsAdded: 19,
+      itemsRemoved: 2,
+      resourcesFailed: 1,
+      passes: 2,
+      isTruncated: false,
+      ownersNotified: false,
+    });
+  });
+
+  it("reports notification if any pass notified, and passes truncation through", () => {
+    const merged: RuleRunResult = RuleRunResultUtil.mergePasses({
+      passes: [pass(), pass({ ownersNotified: true }), pass()],
+      isTruncated: true,
+    });
+
+    expect(merged.ownersNotified).toBe(true);
+    expect(merged.isTruncated).toBe(true);
+    expect(merged.passes).toBe(3);
+  });
+
+  it("merges no passes into an empty result", () => {
+    expect(
+      RuleRunResultUtil.mergePasses({ passes: [], isTruncated: false }),
+    ).toEqual({
+      ...RuleRunResultUtil.emptyCounts(),
+      passes: 0,
+      isTruncated: false,
+      ownersNotified: false,
+    });
+  });
+});

package/Tests/Types/Rum/SessionReplayApiContracts.test.ts

@@ -239,6 +239,7 @@ describe("SessionReplayApi DTOs - today's wire shapes satisfy them", () => {
     expect(
       legacyManifestResponse.tabs[0]?.firstChunkStartOffsetMs,
     ).toBeUndefined();
+    expect(legacyManifestResponse.tabs[0]?.hasRecordingEnded).toBeUndefined();
     expect(
       legacyManifestResponse.tabs[0]?.chunks[0]?.clickCount,
     ).toBeUndefined();
@@ -306,12 +307,14 @@ describe("SessionReplayApi DTOs - today's wire shapes satisfy them", () => {
     const richTab: SessionReplayManifestTabDto = {
       ...legacyTab,
       firstChunkStartOffsetMs: 134000,
+      hasRecordingEnded: true,
       chunks: [{ ...legacyChunk, clickCount: 4, url: "https://acme.com/cart" }],
     };
 
     expect(richItem.tags?.["build"]).toBe("1.4.2");
     expect(richHeader.recorderCapabilities).toHaveLength(2);
     expect(richTab.chunks[0]?.url).toBe("https://acme.com/cart");
+    expect(richTab.hasRecordingEnded).toBe(true);
   });
 
   it("request bodies: the list request matches what SessionReplayTable posts, the manifest request accepts the refresh fields", () => {
@@ -504,6 +507,63 @@ describe("SessionReplayApi - the additive contracts the surfaces already ship",
     expect(liveItem.hasRecordingEnded).toBe(false);
   });
 
+  /*
+   * The recorder mints a new tab id on every page load, so one recording's
+   * "tabs" are the pages the person walked through, and the header's single
+   * hasRecordingEnded ("every tab has ended") cannot say which of them is
+   * still open. Each manifest tab therefore carries its own flag, additive
+   * exactly like the header's: an older server answers tabs without it, and
+   * the player then cannot tell an open tab from a closed one - which is
+   * what it did before the field existed.
+   */
+  it("/manifest: each tab carries its own additive hasRecordingEnded, and a payload without it still parses", () => {
+    expect(legacyTab.hasRecordingEnded).toBeUndefined();
+
+    const olderTabWire: JSONObject = JSON.parse(
+      JSON.stringify(legacyTab),
+    ) as JSONObject;
+
+    expect("hasRecordingEnded" in olderTabWire).toBe(false);
+    /* Absent reads as "not known to have ended", never as "open". */
+    expect(readDtoBoolean(olderTabWire, "hasRecordingEnded")).toBe(false);
+
+    /* A live session mid-navigation: page 1 closed, page 2 still open. */
+    const closedTab: SessionReplayManifestTabDto = {
+      ...legacyTab,
+      tabId: "tab-1",
+      hasRecordingEnded: true,
+    };
+    const openTab: SessionReplayManifestTabDto = {
+      ...legacyTab,
+      tabId: "tab-2",
+      hasRecordingEnded: false,
+    };
+
+    const liveManifest: SessionReplayManifestResponseDto = {
+      ...legacyManifestResponse,
+      header: { ...legacyHeader, isFinalized: false, hasRecordingEnded: false },
+      tabs: [closedTab, openTab],
+    };
+
+    const wire: JSONObject = JSON.parse(
+      JSON.stringify(liveManifest),
+    ) as JSONObject;
+    const wireTabs: Array<JSONObject> = wire[
+      "tabs"
+    ] as unknown as Array<JSONObject>;
+
+    expect(readDtoBoolean(wireTabs[0]!, "hasRecordingEnded")).toBe(true);
+    expect(readDtoBoolean(wireTabs[1]!, "hasRecordingEnded")).toBe(false);
+
+    /* The per-tab flags are independent of the session-level one. */
+    expect(liveManifest.header.hasRecordingEnded).toBe(false);
+    expect(
+      liveManifest.tabs.filter((tab: SessionReplayManifestTabDto): boolean => {
+        return tab.hasRecordingEnded === true;
+      }),
+    ).toHaveLength(1);
+  });
+
   /*
    * POST /telemetry/rum/session-replay/users: the list rolled up by
    * person. Its own route because a keyset page of sessions cannot be

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

@@ -40,6 +40,7 @@ const KNOWN_FIELD_TYPES: Array<string> = [
   "number",
   "toggle",
   "dropdown",
+  "json",
 ];
 
 const DEFINITION_CASES: Array<[string, SecurityEventConnectorDefinition]> =
@@ -180,11 +181,16 @@ describe.each(DEFINITION_CASES)(
       }
     });
 
-    test("secret fields are all passwords and no config field is a password", () => {
+    test("secret fields are passwords or JSON documents, and no config field is either", () => {
+      /*
+       * "json" is a secret too: a service-account key pasted into a code
+       * editor. A config field of either type would be readable back from
+       * the API, which is the one thing a credential must never be.
+       */
       for (const field of definition.secretFields) {
-        expect({ key: field.key, type: field.type }).toEqual({
+        expect({ key: field.key, secretType: ["password", "json"] }).toEqual({
           key: field.key,
-          type: "password",
+          secretType: expect.arrayContaining([field.type]),
         });
       }
 
@@ -193,6 +199,10 @@ describe.each(DEFINITION_CASES)(
           key: field.key,
           type: "password",
         });
+        expect({ key: field.key, type: field.type }).not.toEqual({
+          key: field.key,
+          type: "json",
+        });
       }
     });
 
@@ -242,6 +252,21 @@ describe.each(DEFINITION_CASES)(
           expect(option.value.trim()).not.toBe("");
         }
 
+        /*
+         * A required dropdown may leave the choice to the person on purpose
+         * (Google SecOps's region: a preselected "us" would silently save
+         * the wrong regional endpoint for a tenant elsewhere). It must then
+         * say so with a placeholder. Every other dropdown defaults to one
+         * of its own options.
+         */
+        if (field.defaultValue === undefined && field.required) {
+          expect({ key: field.key, placeholder: field.placeholder }).toEqual({
+            key: field.key,
+            placeholder: expect.stringMatching(/\S/),
+          });
+          continue;
+        }
+
         expect(typeof field.defaultValue).toBe("string");
         expect(values).toContain(field.defaultValue);
       }
@@ -295,7 +320,7 @@ describe("getSecurityEventConnectorDefinition", () => {
     ).toBe("Okta System Log");
   });
 
-  test.each([undefined, "", "google-secops", "OKTA"])(
+  test.each([undefined, "", "not-a-provider", "OKTA"])(
     "returns undefined for %j",
     (provider: string | undefined) => {
       expect(getSecurityEventConnectorDefinition(provider)).toBeUndefined();

package/Tests/Types/StatusPage/SubscriberNotificationTemplateVariables.test.ts

@@ -0,0 +1,217 @@
+import StatusPageSubscriberNotificationEventType from "../../../Types/StatusPage/StatusPageSubscriberNotificationEventType";
+import SubscriberNotificationTemplateVariables, {
+  SubscriberNotificationTemplateVariable,
+} from "../../../Types/StatusPage/SubscriberNotificationTemplateVariables";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * The variables a custom subscriber notification template may use, per event
+ * type. The dashboard shows this list to template authors and the workers are
+ * tested against it, so it has to answer for every event type the template
+ * form offers - it used to throw for the episode and subscription events.
+ */
+
+const Event: typeof StatusPageSubscriberNotificationEventType =
+  StatusPageSubscriberNotificationEventType;
+
+const ALL_EVENTS: Array<StatusPageSubscriberNotificationEventType> =
+  Object.values(StatusPageSubscriberNotificationEventType);
+
+const STATUS_PAGE: Array<string> = [
+  "statusPageName",
+  "statusPageUrl",
+  "unsubscribeUrl",
+];
+
+const COMMON: Array<string> = [...STATUS_PAGE, "resourcesAffected"];
+
+// Messages about the subscription itself, or the report - not about a resource.
+const ACCOUNT_EVENTS: Array<StatusPageSubscriberNotificationEventType> = [
+  StatusPageSubscriberNotificationEventType.SubscriberSubscriptionConfirmation,
+  StatusPageSubscriberNotificationEventType.SubscriberSubscribed,
+  StatusPageSubscriberNotificationEventType.SubscriberManageSubscription,
+  StatusPageSubscriberNotificationEventType.SubscriberReport,
+];
+
+const EVENT_EVENTS: Array<StatusPageSubscriberNotificationEventType> =
+  Object.values(StatusPageSubscriberNotificationEventType).filter(
+    (event: StatusPageSubscriberNotificationEventType): boolean => {
+      return !ACCOUNT_EVENTS.includes(event);
+    },
+  );
+
+function names(
+  event: StatusPageSubscriberNotificationEventType,
+): Array<string> {
+  return SubscriberNotificationTemplateVariables.getVariableNamesForEventType(
+    event,
+  );
+}
+
+describe("SubscriberNotificationTemplateVariables", () => {
+  test.each(ALL_EVENTS)(
+    "%s has a variable list",
+    (event: StatusPageSubscriberNotificationEventType) => {
+      expect(() => {
+        return SubscriberNotificationTemplateVariables.getAvailableVariablesForEventType(
+          event,
+        );
+      }).not.toThrow();
+    },
+  );
+
+  test.each(ALL_EVENTS)(
+    "%s lists the status page variables",
+    (event: StatusPageSubscriberNotificationEventType) => {
+      expect(names(event)).toEqual(expect.arrayContaining(STATUS_PAGE));
+    },
+  );
+
+  test.each(EVENT_EVENTS)(
+    "%s offers the resources it affects",
+    (event: StatusPageSubscriberNotificationEventType) => {
+      expect(names(event)).toContain("resourcesAffected");
+    },
+  );
+
+  test.each(ACCOUNT_EVENTS)(
+    "%s is not about a resource, so it does not offer resourcesAffected",
+    (event: StatusPageSubscriberNotificationEventType) => {
+      expect(names(event)).not.toContain("resourcesAffected");
+    },
+  );
+
+  test("every event type is either an event or an account message", () => {
+    expect(EVENT_EVENTS.length + ACCOUNT_EVENTS.length).toBe(ALL_EVENTS.length);
+    expect(EVENT_EVENTS.length).toBeGreaterThan(10);
+  });
+
+  test.each(ALL_EVENTS)(
+    "%s lists each variable once, with a description",
+    (event: StatusPageSubscriberNotificationEventType) => {
+      const variables: Array<SubscriberNotificationTemplateVariable> =
+        SubscriberNotificationTemplateVariables.getAvailableVariablesForEventType(
+          event,
+        );
+
+      expect(new Set(names(event)).size).toBe(variables.length);
+
+      for (const variable of variables) {
+        expect(variable.name).toMatch(/^[A-Za-z][\w.]*$/);
+        expect(variable.description.trim().length).toBeGreaterThan(0);
+      }
+    },
+  );
+
+  test("returns a new list each time, so callers cannot change it for others", () => {
+    const first: Array<SubscriberNotificationTemplateVariable> =
+      SubscriberNotificationTemplateVariables.getAvailableVariablesForEventType(
+        Event.SubscriberIncidentCreated,
+      );
+    first.push({ name: "injected", description: "x" });
+    first[0]!.name = "renamed";
+
+    expect(names(Event.SubscriberIncidentCreated)).not.toContain("injected");
+    expect(names(Event.SubscriberIncidentCreated)).toContain("statusPageName");
+  });
+
+  test("refuses an event type it does not know", () => {
+    expect(() => {
+      SubscriberNotificationTemplateVariables.getAvailableVariablesForEventType(
+        "Subscriber Something Else" as StatusPageSubscriberNotificationEventType,
+      );
+    }).toThrow(/Unknown event type/);
+  });
+
+  test.each([
+    [Event.SubscriberAnnouncementCreated, Event.SubscriberAnnouncementUpdated],
+    [Event.SubscriberIncidentNoteCreated, Event.SubscriberIncidentNoteUpdated],
+    [Event.SubscriberEpisodeNoteCreated, Event.SubscriberEpisodeNoteUpdated],
+    [
+      Event.SubscriberScheduledMaintenanceNoteCreated,
+      Event.SubscriberScheduledMaintenanceNoteUpdated,
+    ],
+  ])(
+    "%s and its update twin %s offer the same variables",
+    (
+      created: StatusPageSubscriberNotificationEventType,
+      updated: StatusPageSubscriberNotificationEventType,
+    ) => {
+      expect(names(updated)).toEqual(names(created));
+    },
+  );
+
+  test.each([
+    [
+      Event.SubscriberIncidentNoteCreated,
+      [
+        "incidentTitle",
+        "incidentSeverity",
+        "incidentState",
+        "postedAt",
+        "note",
+        "detailsUrl",
+      ],
+    ],
+    [
+      Event.SubscriberScheduledMaintenanceNoteCreated,
+      [
+        "scheduledMaintenanceTitle",
+        "scheduledMaintenanceDescription",
+        "scheduledMaintenanceState",
+        "postedAt",
+        "note",
+        "detailsUrl",
+      ],
+    ],
+    [
+      Event.SubscriberEpisodeNoteCreated,
+      ["episodeTitle", "episodeSeverity", "note", "detailsUrl"],
+    ],
+    [
+      Event.SubscriberAnnouncementCreated,
+      ["announcementTitle", "announcementDescription", "detailsUrl"],
+    ],
+    [
+      Event.SubscriberEpisodeCreated,
+      ["episodeTitle", "episodeDescription", "episodeSeverity", "detailsUrl"],
+    ],
+    [
+      Event.SubscriberEpisodeStateChanged,
+      ["episodeTitle", "episodeSeverity", "episodeState", "detailsUrl"],
+    ],
+  ] as Array<[StatusPageSubscriberNotificationEventType, Array<string>]>)(
+    "%s offers exactly its event variables on top of the common ones",
+    (
+      event: StatusPageSubscriberNotificationEventType,
+      eventVariables: Array<string>,
+    ) => {
+      expect([...names(event)].sort()).toEqual(
+        [...COMMON, ...eventVariables].sort(),
+      );
+    },
+  );
+
+  test.each([
+    [Event.SubscriberSubscriptionConfirmation, ["confirmationUrl"]],
+    [Event.SubscriberManageSubscription, ["manageSubscriptionUrl"]],
+    [Event.SubscriberSubscribed, []],
+  ] as Array<[StatusPageSubscriberNotificationEventType, Array<string>]>)(
+    "%s offers exactly its own variables on top of the status page ones",
+    (
+      event: StatusPageSubscriberNotificationEventType,
+      eventVariables: Array<string>,
+    ) => {
+      expect([...names(event)].sort()).toEqual(
+        [...STATUS_PAGE, ...eventVariables].sort(),
+      );
+    },
+  );
+
+  test("the report documents its structured fields rather than flat values", () => {
+    const report: Array<string> = names(Event.SubscriberReport);
+
+    expect(report).toContain("report.averageUptimePercent");
+    expect(report).toContain("report.rows");
+  });
+});