@oneuptime/common 13.0.7 → 14.0.0

package/Tests/Types/SecurityEvent/SigmaRule.test.ts

@@ -0,0 +1,142 @@
+import { describe, expect, test } from "@jest/globals";
+import {
+  SIGMA_DEFAULT_LEVEL,
+  SIGMA_LEVEL_TO_OCSF_SEVERITY,
+  SIGMA_SUPPORTED_MODIFIERS,
+  SigmaLevel,
+  isSevereSigmaLevel,
+} from "../../../Types/SecurityEvent/SigmaRule";
+import OcsfSeverity, {
+  OcsfSeverityId,
+} from "../../../Types/SecurityEvent/OcsfSeverity";
+import {
+  DETECTION_EVALUATION_INTERVAL_MAX_IN_MINUTES,
+  DETECTION_EVALUATION_INTERVAL_MIN_IN_MINUTES,
+  DETECTION_MAX_GROUPS_PER_EVALUATION,
+  DETECTION_MAX_LOOKBACK_IN_MINUTES,
+} from "../../../Types/SecurityEvent/DetectionFindingConstants";
+import {
+  THREAT_INTEL_DEFAULT_POLL_INTERVAL_IN_MINUTES,
+  THREAT_INTEL_FIRST_MATCH_WINDOW_IN_MINUTES,
+  THREAT_INTEL_MATCH_MAX_LOOKBACK_IN_MINUTES,
+  THREAT_INTEL_MAX_INDICATORS_PER_EVALUATION,
+  THREAT_INTEL_POLL_INTERVAL_MAX_IN_MINUTES,
+  THREAT_INTEL_POLL_INTERVAL_MIN_IN_MINUTES,
+} from "../../../Types/SecurityEvent/ThreatIntelConstants";
+
+/*
+ * The Sigma level map, modifier list and engine limits used to be private
+ * to the evaluator, parser and matcher. They now live in Types so the
+ * dashboard's guides can render them — which makes them a contract, and
+ * these are its invariants.
+ */
+
+const LEVELS_IN_RISING_ORDER: Array<SigmaLevel> = [
+  SigmaLevel.Informational,
+  SigmaLevel.Low,
+  SigmaLevel.Medium,
+  SigmaLevel.High,
+  SigmaLevel.Critical,
+];
+
+describe("SIGMA_LEVEL_TO_OCSF_SEVERITY", () => {
+  test("maps every Sigma level", () => {
+    expect(Object.keys(SIGMA_LEVEL_TO_OCSF_SEVERITY).sort()).toEqual(
+      Object.values(SigmaLevel).sort(),
+    );
+  });
+
+  test("maps each level to the OCSF severity of the same name", () => {
+    expect(SIGMA_LEVEL_TO_OCSF_SEVERITY).toEqual({
+      [SigmaLevel.Informational]: OcsfSeverity.Informational,
+      [SigmaLevel.Low]: OcsfSeverity.Low,
+      [SigmaLevel.Medium]: OcsfSeverity.Medium,
+      [SigmaLevel.High]: OcsfSeverity.High,
+      [SigmaLevel.Critical]: OcsfSeverity.Critical,
+    });
+  });
+
+  test("a more severe level never maps to a less severe OCSF severity", () => {
+    const ids: Array<number> = LEVELS_IN_RISING_ORDER.map(
+      (level: SigmaLevel): number => {
+        return OcsfSeverityId[SIGMA_LEVEL_TO_OCSF_SEVERITY[level]];
+      },
+    );
+
+    for (let index: number = 1; index < ids.length; index++) {
+      expect(ids[index]!).toBeGreaterThan(ids[index - 1]!);
+    }
+  });
+});
+
+describe("isSevereSigmaLevel", () => {
+  test.each(LEVELS_IN_RISING_ORDER)("%s", (level: SigmaLevel) => {
+    expect(isSevereSigmaLevel(level)).toBe(
+      level === SigmaLevel.High || level === SigmaLevel.Critical,
+    );
+  });
+});
+
+describe("SIGMA_DEFAULT_LEVEL", () => {
+  test("is a real level, and the middle one", () => {
+    expect(Object.values(SigmaLevel)).toContain(SIGMA_DEFAULT_LEVEL);
+    expect(SIGMA_DEFAULT_LEVEL).toBe(SigmaLevel.Medium);
+  });
+});
+
+describe("SIGMA_SUPPORTED_MODIFIERS", () => {
+  test("has no duplicates and only lowercase names, as the parser lowercases input", () => {
+    expect(new Set(SIGMA_SUPPORTED_MODIFIERS).size).toBe(
+      SIGMA_SUPPORTED_MODIFIERS.length,
+    );
+
+    for (const modifier of SIGMA_SUPPORTED_MODIFIERS) {
+      expect(modifier).toBe(modifier.toLowerCase());
+    }
+  });
+});
+
+describe("engine limits", () => {
+  test("detection rule interval bounds are ordered and whole", () => {
+    expect(Number.isInteger(DETECTION_EVALUATION_INTERVAL_MIN_IN_MINUTES)).toBe(
+      true,
+    );
+    expect(DETECTION_EVALUATION_INTERVAL_MIN_IN_MINUTES).toBeGreaterThanOrEqual(
+      1,
+    );
+    expect(DETECTION_EVALUATION_INTERVAL_MAX_IN_MINUTES).toBeGreaterThan(
+      DETECTION_EVALUATION_INTERVAL_MIN_IN_MINUTES,
+    );
+  });
+
+  test("a rule at its longest interval still fits in one lookback", () => {
+    expect(DETECTION_MAX_LOOKBACK_IN_MINUTES).toBeGreaterThanOrEqual(
+      DETECTION_EVALUATION_INTERVAL_MAX_IN_MINUTES,
+    );
+  });
+
+  test("threat intel's default poll interval is inside its bounds", () => {
+    expect(
+      THREAT_INTEL_DEFAULT_POLL_INTERVAL_IN_MINUTES,
+    ).toBeGreaterThanOrEqual(THREAT_INTEL_POLL_INTERVAL_MIN_IN_MINUTES);
+    expect(THREAT_INTEL_DEFAULT_POLL_INTERVAL_IN_MINUTES).toBeLessThanOrEqual(
+      THREAT_INTEL_POLL_INTERVAL_MAX_IN_MINUTES,
+    );
+  });
+
+  test("the matcher's first window fits inside its lookback cap", () => {
+    expect(THREAT_INTEL_FIRST_MATCH_WINDOW_IN_MINUTES).toBeLessThanOrEqual(
+      THREAT_INTEL_MATCH_MAX_LOOKBACK_IN_MINUTES,
+    );
+  });
+
+  test("per-run caps are positive whole numbers", () => {
+    for (const cap of [
+      DETECTION_MAX_GROUPS_PER_EVALUATION,
+      THREAT_INTEL_MAX_INDICATORS_PER_EVALUATION,
+    ]) {
+      expect(Number.isInteger(cap)).toBe(true);
+      expect(cap).toBeGreaterThan(0);
+    }
+  });
+});

package/Tests/Types/Workflow/Components/JSON.test.ts

@@ -0,0 +1,182 @@
+import { describe, expect, test } from "@jest/globals";
+import JsonComponents from "../../../../Types/Workflow/Components/JSON";
+import AllComponents from "../../../../Types/Workflow/Components";
+import ComponentID from "../../../../Types/Workflow/ComponentID";
+import ComponentMetadata, {
+  Argument,
+  ComponentInputType,
+  ComponentType,
+  Port,
+  ReturnValue,
+} from "../../../../Types/Workflow/Component";
+import IconProp from "../../../../Types/Icon/IconProp";
+
+/*
+ * The JSON workflow block catalog. The server-side runners
+ * (Server/Types/Workflow/Components/JSON/*) look their metadata up here by
+ * ComponentID and then read args / emit return values / choose ports by the
+ * ids declared below, so a renamed id silently breaks saved workflows.
+ */
+
+const findComponent: (id: ComponentID) => ComponentMetadata = (
+  id: ComponentID,
+): ComponentMetadata => {
+  const component: ComponentMetadata | undefined = JsonComponents.find(
+    (item: ComponentMetadata) => {
+      return item.id === id;
+    },
+  );
+  if (!component) {
+    throw new Error(`Component ${id} not found`);
+  }
+  return component;
+};
+
+const argumentIds: (component: ComponentMetadata) => Array<string> = (
+  component: ComponentMetadata,
+): Array<string> => {
+  return component.arguments.map((argument: Argument) => {
+    return argument.id;
+  });
+};
+
+const returnValueIds: (component: ComponentMetadata) => Array<string> = (
+  component: ComponentMetadata,
+): Array<string> => {
+  return component.returnValues.map((returnValue: ReturnValue) => {
+    return returnValue.id;
+  });
+};
+
+const portIds: (ports: Array<Port>) => Array<string> = (
+  ports: Array<Port>,
+): Array<string> => {
+  return ports.map((port: Port) => {
+    return port.id;
+  });
+};
+
+describe("Workflow JSON components", () => {
+  test("exports exactly the three JSON blocks in order", () => {
+    expect(
+      JsonComponents.map((component: ComponentMetadata) => {
+        return component.id;
+      }),
+    ).toEqual([
+      ComponentID.JsonToText,
+      ComponentID.TextToJson,
+      ComponentID.MergeJson,
+    ]);
+  });
+
+  test("ids resolve to the expected stable string values", () => {
+    expect(ComponentID.JsonToText).toBe("json-to-text");
+    expect(ComponentID.TextToJson).toBe("text-to-json");
+    expect(ComponentID.MergeJson).toBe("merge-json");
+  });
+
+  test("component ids are unique", () => {
+    const ids: Array<string> = JsonComponents.map(
+      (component: ComponentMetadata) => {
+        return component.id;
+      },
+    );
+    expect(new Set(ids).size).toBe(ids.length);
+  });
+
+  test.each(JsonComponents)(
+    "$id shares the JSON category, icon and component type",
+    (component: ComponentMetadata) => {
+      expect(component.category).toBe("JSON");
+      expect(component.iconProp).toBe(IconProp.JSON);
+      expect(component.componentType).toBe(ComponentType.Component);
+      expect(component.title.trim().length).toBeGreaterThan(0);
+      expect(component.description.trim().length).toBeGreaterThan(0);
+    },
+  );
+
+  test.each(JsonComponents)(
+    "$id has a single 'in' port and success / error out ports",
+    (component: ComponentMetadata) => {
+      expect(portIds(component.inPorts)).toEqual(["in"]);
+      expect(portIds(component.outPorts)).toEqual(["success", "error"]);
+      for (const port of [...component.inPorts, ...component.outPorts]) {
+        expect(port.title.length).toBeGreaterThan(0);
+        expect(port.description.length).toBeGreaterThan(0);
+      }
+    },
+  );
+
+  test.each(JsonComponents)(
+    "$id marks every argument and return value as required",
+    (component: ComponentMetadata) => {
+      for (const argument of component.arguments) {
+        expect(argument.required).toBe(true);
+      }
+      for (const returnValue of component.returnValues) {
+        expect(returnValue.required).toBe(true);
+      }
+    },
+  );
+
+  test.each(JsonComponents)(
+    "$id has unique argument and return value ids",
+    (component: ComponentMetadata) => {
+      const args: Array<string> = argumentIds(component);
+      const returns: Array<string> = returnValueIds(component);
+      expect(new Set(args).size).toBe(args.length);
+      expect(new Set(returns).size).toBe(returns.length);
+    },
+  );
+
+  test("JSON to Text takes JSON 'json' and returns Text 'text'", () => {
+    const component: ComponentMetadata = findComponent(ComponentID.JsonToText);
+    expect(component.title).toBe("JSON to Text");
+    expect(argumentIds(component)).toEqual(["json"]);
+    expect(component.arguments[0]!.type).toBe(ComponentInputType.JSON);
+    expect(returnValueIds(component)).toEqual(["text"]);
+    expect(component.returnValues[0]!.type).toBe(ComponentInputType.Text);
+  });
+
+  test("Text to JSON takes Text 'text' and returns JSON 'json'", () => {
+    const component: ComponentMetadata = findComponent(ComponentID.TextToJson);
+    expect(component.title).toBe("Text to JSON");
+    expect(argumentIds(component)).toEqual(["text"]);
+    expect(component.arguments[0]!.type).toBe(ComponentInputType.Text);
+    expect(returnValueIds(component)).toEqual(["json"]);
+    expect(component.returnValues[0]!.type).toBe(ComponentInputType.JSON);
+  });
+
+  test("Merge JSON takes two JSON args 'json1' / 'json2' and returns JSON 'json'", () => {
+    const component: ComponentMetadata = findComponent(ComponentID.MergeJson);
+    expect(component.title).toBe("Merge JSON");
+    expect(argumentIds(component)).toEqual(["json1", "json2"]);
+    for (const argument of component.arguments) {
+      expect(argument.type).toBe(ComponentInputType.JSON);
+    }
+    expect(
+      component.arguments.map((argument: Argument) => {
+        return argument.name;
+      }),
+    ).toEqual(["JSON 1", "JSON 2"]);
+    expect(returnValueIds(component)).toEqual(["json"]);
+    expect(component.returnValues[0]!.type).toBe(ComponentInputType.JSON);
+  });
+
+  test("every JSON block is registered in the global component catalog", () => {
+    for (const component of JsonComponents) {
+      expect(AllComponents).toContain(component);
+    }
+  });
+
+  test("no other workflow block reuses a JSON block id", () => {
+    for (const component of JsonComponents) {
+      const matches: Array<ComponentMetadata> = AllComponents.filter(
+        (item: ComponentMetadata) => {
+          return item.id === component.id;
+        },
+      );
+      expect(matches).toHaveLength(1);
+    }
+  });
+});

package/Tests/UI/Components/BasicFormDropdownNormalization.test.tsx

@@ -2,9 +2,10 @@ import BasicForm from "../../../UI/Components/Forms/BasicForm";
 import Fields from "../../../UI/Components/Forms/Types/Fields";
 import FormFieldSchemaType from "../../../UI/Components/Forms/Types/FormFieldSchemaType";
 import FormValues from "../../../UI/Components/Forms/Types/FormValues";
+import { FormStep } from "../../../UI/Components/Forms/Types/FormStep";
 import { DropdownOption } from "../../../UI/Components/Dropdown/Dropdown";
 import ObjectID from "../../../Types/ObjectID";
-import { render, screen } from "@testing-library/react";
+import { act, render, screen, within } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import * as React from "react";
 import { describe, expect, test } from "@jest/globals";
@@ -164,4 +165,118 @@ describe("BasicForm dropdown initial-value normalization", () => {
 
     expect(submitted["snmpVersion"]).toBeUndefined();
   });
+
+  test("preserves all multiselect IDs when available options contain only some selections", async () => {
+    const submitted: FormValues<any> = await submitForm(
+      { owners: ["unavailable-owner", "available-owner"] },
+      [
+        {
+          field: { owners: true },
+          title: "Owners",
+          fieldType: FormFieldSchemaType.MultiSelectDropdown,
+          dropdownOptions: [
+            { label: "Available Owner", value: "available-owner" },
+          ],
+        },
+      ],
+    );
+
+    expect(submitted["owners"]).toEqual([
+      "unavailable-owner",
+      "available-owner",
+    ]);
+  });
+
+  test("preserves and canonicalizes multiselect ObjectIDs before options load", async () => {
+    const firstId: ObjectID = new ObjectID(
+      "3f1b6b0e-0000-4000-8000-000000000003",
+    );
+    const secondId: ObjectID = new ObjectID(
+      "3f1b6b0e-0000-4000-8000-000000000004",
+    );
+    const submitted: FormValues<any> = await submitForm(
+      { owners: [firstId, secondId] } as unknown as FormValues<any>,
+      [
+        {
+          field: { owners: true },
+          title: "Owners",
+          fieldType: FormFieldSchemaType.MultiSelectDropdown,
+        },
+      ],
+    );
+
+    expect(submitted["owners"]).toEqual([
+      firstId.toString(),
+      secondId.toString(),
+    ]);
+  });
+
+  test("keeps saved owners visible and submitted when their step loads options after initialization", async () => {
+    const onSubmit: MockFunction = getJestMockFunction();
+    const ownerId: string = "3f1b6b0e-0000-4000-8000-000000000005";
+    let resolveOptions: (options: Array<DropdownOption>) => void = () => {};
+    const optionsLoaded: Promise<Array<DropdownOption>> = new Promise(
+      (resolve: (options: Array<DropdownOption>) => void) => {
+        resolveOptions = resolve;
+      },
+    );
+    const steps: Array<FormStep<FormValues<any>>> = [
+      { id: "details", title: "Details" },
+      { id: "owners", title: "Owner Settings" },
+    ];
+    const fields: Fields<FormValues<any>> = [
+      {
+        field: { title: true },
+        title: "Rule Title",
+        fieldType: FormFieldSchemaType.Text,
+        stepId: "details",
+      },
+      {
+        field: { owners: true },
+        title: "Owners",
+        fieldType: FormFieldSchemaType.MultiSelectDropdown,
+        stepId: "owners",
+        fetchDropdownOptions: async (): Promise<Array<DropdownOption>> => {
+          return optionsLoaded;
+        },
+      },
+    ];
+    const user: ReturnType<typeof userEvent.setup> = userEvent.setup({
+      delay: null,
+    });
+
+    render(
+      <BasicForm
+        fields={fields}
+        steps={steps}
+        initialValues={{ title: "Existing rule", owners: [ownerId] }}
+        onSubmit={onSubmit}
+        submitButtonText="Save"
+        disableAutofocus={true}
+      />,
+    );
+
+    await screen.findByRole("textbox", { name: /^Rule Title/ });
+    await user.click(screen.getByRole("button", { name: "Next" }));
+    await screen.findByRole("combobox", { name: /^Owners/ });
+    await act(async () => {
+      resolveOptions([{ label: "Saved Owner", value: ownerId }]);
+      await optionsLoaded;
+    });
+
+    expect(await screen.findByText("Saved Owner")).toBeTruthy();
+    await user.click(
+      within(screen.getByRole("navigation", { name: "Progress" })).getByText(
+        "Details",
+      ),
+    );
+    await user.click(screen.getByRole("button", { name: "Next" }));
+    expect(await screen.findByText("Saved Owner")).toBeTruthy();
+    await user.click(screen.getByRole("button", { name: "Save" }));
+
+    expect(onSubmit.mock.calls[0]?.[0]).toEqual({
+      title: "Existing rule",
+      owners: [ownerId],
+    });
+  });
 });

package/Tests/UI/Components/Dropdown/DropdownAsyncOptions.test.tsx

@@ -0,0 +1,81 @@
+import Dropdown, {
+  DropdownOption,
+} from "../../../../UI/Components/Dropdown/Dropdown";
+import getJestMockFunction, { MockFunction } from "../../../MockType";
+import "@testing-library/jest-dom";
+import { render, RenderResult, screen } from "@testing-library/react";
+import React from "react";
+import { describe, expect, test } from "@jest/globals";
+
+describe("Dropdown asynchronous options", () => {
+  const owner: DropdownOption = { value: "owner-1", label: "Saved Owner" };
+
+  test("resolves a controlled multiselect's unchanged IDs when options arrive", () => {
+    const onChange: MockFunction = getJestMockFunction();
+    // BasicForm passes the stored IDs, before their option labels are fetched.
+    const value: Array<DropdownOption> = [
+      owner.value,
+    ] as unknown as Array<DropdownOption>;
+    const { rerender }: RenderResult = render(
+      <Dropdown
+        isMultiSelect={true}
+        options={[]}
+        value={value}
+        onChange={onChange}
+      />,
+    );
+
+    expect(screen.queryByText(owner.label)).not.toBeInTheDocument();
+    rerender(
+      <Dropdown
+        isMultiSelect={true}
+        options={[owner]}
+        value={value}
+        onChange={onChange}
+      />,
+    );
+
+    expect(screen.getByText(owner.label)).toBeVisible();
+    expect(
+      screen.getByRole("button", { name: "Remove Saved Owner" }),
+    ).toBeVisible();
+    expect(onChange).not.toHaveBeenCalled();
+  });
+
+  test("resolves a controlled single value when options arrive", () => {
+    const value: DropdownOption = owner.value as unknown as DropdownOption;
+    const { rerender }: RenderResult = render(
+      <Dropdown options={[]} value={value} />,
+    );
+
+    rerender(<Dropdown options={[owner]} value={value} />);
+
+    expect(screen.getByText(owner.label)).toBeVisible();
+  });
+
+  test("does not clear an uncontrolled selection when its options refresh", () => {
+    const { rerender }: RenderResult = render(
+      <Dropdown options={[owner]} initialValue={owner} />,
+    );
+
+    rerender(
+      <Dropdown
+        options={[owner, { value: "owner-2", label: "Another Owner" }]}
+        initialValue={owner}
+      />,
+    );
+
+    expect(screen.getByText(owner.label)).toBeVisible();
+    expect(screen.queryByText("Another Owner")).not.toBeInTheDocument();
+  });
+
+  test("still clears a controlled selection when its value becomes undefined", () => {
+    const { rerender }: RenderResult = render(
+      <Dropdown options={[owner]} value={owner} />,
+    );
+
+    rerender(<Dropdown options={[owner]} value={undefined} />);
+
+    expect(screen.queryByText(owner.label)).not.toBeInTheDocument();
+  });
+});

package/Tests/UI/Components/EditionLabelLapseCopy.ts

@@ -0,0 +1,104 @@
+/*
+ * What the edition dialog must say about an Enterprise license lapse. Shared
+ * by the core EditionLabel suite and ee/Tests/UI/License, which renders the
+ * same dialog with the Enterprise license manager.
+ *
+ * When the license lapses (after the trial or the grace period), single
+ * sign-on (SAML and OIDC), SCIM provisioning and audit logging stop - the
+ * Community Edition's behaviour - and "Require SSO" stops being enforced at
+ * the same moment, so nobody is locked out: users sign in with their
+ * password. Everything resumes as soon as a license is activated. The trial
+ * and grace notices must say so BEFORE it happens, and the lapsed notice must
+ * say what is off.
+ *
+ * The dialog used to promise the opposite ("SSO, SCIM and audit logging never
+ * stop"), so the checks reject that copy too. Plain functions over text, with
+ * no jest dependency, so a test can prove each check fails on the wrong copy.
+ */
+
+// Before the lapse: the trial and grace notices, after "Without a valid license (...), ".
+export const LAPSE_WARNING_PHRASES: ReadonlyArray<string> = [
+  "single sign-on (SAML and OIDC) stops",
+  '"Require SSO" is no longer enforced, so users sign in with their password',
+  "SCIM provisioning stops",
+  "audit logging stops recording",
+  "enterprise configuration becomes read-only",
+  "the enterprise admin dashboards are locked",
+  "Everything resumes as soon as a license is activated",
+  "core monitoring is never affected",
+];
+
+// After the lapse: the license-required notice (expired, missing, invalid).
+export const LAPSED_STATE_PHRASES: ReadonlyArray<string> = [
+  "Single sign-on (SAML and OIDC) and SCIM provisioning are off",
+  '"Require SSO" is not enforced, so users sign in with their password',
+  "SCIM requests are refused",
+  "Audit logging is not recording",
+  "Enterprise configuration is read-only",
+  "Everything resumes, without a restart, as soon as a valid license is added",
+  "core monitoring is never affected",
+];
+
+// The soft-enforcement promises the dialog made before. None may come back.
+export const RETIRED_SOFT_ENFORCEMENT_COPY: ReadonlyArray<RegExp> = [
+  /never stop/i,
+  /already configured keeps working/i,
+  /configured stops working/i,
+  /keeps? working as configured/i,
+  /never (?:silently )?weakens?/i,
+];
+
+// The copy the dialog shipped before the owner's decision, verbatim.
+export const RETIRED_NOTICE_EXAMPLES: ReadonlyArray<string> = [
+  "Without a valid license (after the 14-day grace period), enterprise configuration becomes read-only and the enterprise admin dashboards are locked. Everything you already configured keeps working — SSO, SCIM and audit logging never stop — and core monitoring is never affected.",
+  "Without a valid license (after the 14-day trial), enterprise configuration becomes read-only and the enterprise admin dashboards are locked. Everything you already configured keeps working — SSO, SCIM and audit logging never stop — and core monitoring is never affected.",
+  "The Enterprise license expired and its grace period is over. Enterprise configuration is read-only and the enterprise admin dashboards are locked until a valid license is added. Everything you already configured keeps working — SSO, SCIM and audit logging never stop — and core monitoring is never affected.",
+];
+
+type CopyCheck = (text: string | null | undefined) => Array<string>;
+
+// Whitespace-normalized, so a check does not depend on how JSX wraps a line.
+const normalize: (text: string | null | undefined) => string = (
+  text: string | null | undefined,
+): string => {
+  return (text || "").replace(/\s+/g, " ").trim();
+};
+
+const copyProblems: (
+  text: string | null | undefined,
+  requiredPhrases: ReadonlyArray<string>,
+) => Array<string> = (
+  text: string | null | undefined,
+  requiredPhrases: ReadonlyArray<string>,
+): Array<string> => {
+  const flat: string = normalize(text);
+  const problems: Array<string> = [];
+
+  for (const phrase of requiredPhrases) {
+    if (!flat.includes(phrase)) {
+      problems.push(`missing: ${phrase}`);
+    }
+  }
+
+  for (const retired of RETIRED_SOFT_ENFORCEMENT_COPY) {
+    if (retired.test(flat)) {
+      problems.push(`retired: ${retired.source}`);
+    }
+  }
+
+  return problems;
+};
+
+// What is wrong with a trial or grace notice (empty when it is right).
+export const lapseWarningProblems: CopyCheck = (
+  text: string | null | undefined,
+): Array<string> => {
+  return copyProblems(text, LAPSE_WARNING_PHRASES);
+};
+
+// What is wrong with the notice shown once the license has lapsed.
+export const lapsedStateProblems: CopyCheck = (
+  text: string | null | undefined,
+): Array<string> => {
+  return copyProblems(text, LAPSED_STATE_PHRASES);
+};