@oneuptime/common 13.0.0 → 13.0.1

package/Tests/Types/OnCallDutyPolicy/OverrideProvenance.test.ts

@@ -0,0 +1,295 @@
+import CalendarEvent from "../../../Types/Calendar/CalendarEvent";
+import ScheduleShiftUtil, {
+  OnCallShift,
+} from "../../../Types/OnCallDutyPolicy/ScheduleShiftUtil";
+import UserOverrideUtil, {
+  OverrideEventMeta,
+  UserOverrideRecord,
+} from "../../../Types/OnCallDutyPolicy/UserOverrideUtil";
+
+/*
+ * PROVENANCE: the two facts a screen needs before it can honestly describe a
+ * substitution, and which the engine used to drop on the floor.
+ *
+ * 1. WHICH override produced a segment - global, or scoped to one policy.
+ *    Without it a renderer can say "Bob is covering Alice" but not whether that
+ *    holds for the policy the reader actually cares about. A scoped override
+ *    re-routes exactly one policy's alerts; every OTHER policy escalating to
+ *    the same schedule still pages Alice. Presenting the two identically is the
+ *    difference between "you are covered" and "you are covered for one of your
+ *    four policies".
+ *
+ * 2. That an override window stays its OWN shift. The default grouping folds
+ *    consecutive segments of the same user together, and a shift inherits
+ *    metadata only from its first segment - so a substitute who is also on the
+ *    roster ends up with one merged block that either carries the wrong
+ *    override or none. https://github.com/OneUptime/oneuptime
+ */
+
+const POLICY_ID: string = "policy-database-oncall";
+
+function at(hours: number, minutes: number = 0): Date {
+  return new Date(2026, 0, 1, hours, minutes, 0, 0);
+}
+
+function event(
+  title: string,
+  startHour: number,
+  endHour: number,
+): CalendarEvent {
+  return {
+    id: 1,
+    title: title,
+    allDay: false,
+    start: at(startHour),
+    end: at(endHour),
+  };
+}
+
+function record(data: {
+  from: string;
+  to: string;
+  startHour: number;
+  endHour: number;
+  policyId?: string | null | undefined;
+}): UserOverrideRecord {
+  return {
+    overrideUserId: data.from,
+    routeAlertsToUserId: data.to,
+    startsAt: at(data.startHour),
+    endsAt: at(data.endHour),
+    onCallDutyPolicyId:
+      data.policyId === undefined ? null : (data.policyId as string | null),
+  };
+}
+
+function overriddenSegment(events: Array<CalendarEvent>): CalendarEvent {
+  const found: CalendarEvent | undefined = events.find(
+    (candidate: CalendarEvent) => {
+      return UserOverrideUtil.getOverrideMeta(candidate) !== null;
+    },
+  );
+
+  if (!found) {
+    throw new Error("expected at least one override segment");
+  }
+
+  return found;
+}
+
+describe("OverrideEventMeta carries the override's policy scope", () => {
+  test("a GLOBAL override stamps a null policy, not an absent key", () => {
+    const events: Array<CalendarEvent> =
+      UserOverrideUtil.applyOverridesToEvents({
+        events: [event("A", 8, 14)],
+        overrides: [record({ from: "A", to: "B", startHour: 9, endHour: 13 })],
+      });
+
+    const meta: OverrideEventMeta | null = UserOverrideUtil.getOverrideMeta(
+      overriddenSegment(events),
+    );
+
+    expect(meta).not.toBeNull();
+    /*
+     * Explicitly null rather than undefined so a consumer tests ONE value for
+     * "global". A key that is sometimes absent invites `meta.onCallDutyPolicyId
+     * === null` checks that silently fail for the undefined case and render the
+     * scoped wording for a global override.
+     */
+    expect(meta!.onCallDutyPolicyId).toBeNull();
+  });
+
+  test("a POLICY-SCOPED override stamps that policy's id", () => {
+    const events: Array<CalendarEvent> =
+      UserOverrideUtil.applyOverridesToEvents({
+        events: [event("A", 8, 14)],
+        overrides: [
+          record({
+            from: "A",
+            to: "B",
+            startHour: 9,
+            endHour: 13,
+            policyId: POLICY_ID,
+          }),
+        ],
+        currentOnCallDutyPolicyId: POLICY_ID,
+      });
+
+    const meta: OverrideEventMeta | null = UserOverrideUtil.getOverrideMeta(
+      overriddenSegment(events),
+    );
+
+    expect(meta!.onCallDutyPolicyId).toBe(POLICY_ID);
+  });
+
+  test("when a scoped and a global override compete, the meta names the one that actually won", () => {
+    /*
+     * applyOverridesToEvents sorts policy-scoped first so the scoped
+     * substitution claims the window. The stamped scope has to agree with that
+     * outcome: a segment routed by the scoped override that reported itself as
+     * global would tell the reader the swap covers every policy when it covers
+     * exactly one.
+     */
+    const events: Array<CalendarEvent> =
+      UserOverrideUtil.applyOverridesToEvents({
+        events: [event("A", 8, 14)],
+        overrides: [
+          record({ from: "A", to: "GLOBAL", startHour: 9, endHour: 13 }),
+          record({
+            from: "A",
+            to: "SCOPED",
+            startHour: 9,
+            endHour: 13,
+            policyId: POLICY_ID,
+          }),
+        ],
+        currentOnCallDutyPolicyId: POLICY_ID,
+      });
+
+    const segment: CalendarEvent = overriddenSegment(events);
+    expect(segment.title).toBe("SCOPED");
+    expect(UserOverrideUtil.getOverrideMeta(segment)!.onCallDutyPolicyId).toBe(
+      POLICY_ID,
+    );
+  });
+
+  test("the segments OUTSIDE the override window carry no meta at all", () => {
+    const events: Array<CalendarEvent> =
+      UserOverrideUtil.applyOverridesToEvents({
+        events: [event("A", 8, 14)],
+        overrides: [record({ from: "A", to: "B", startHour: 9, endHour: 13 })],
+      });
+
+    const untouched: Array<CalendarEvent> = events.filter(
+      (candidate: CalendarEvent) => {
+        return UserOverrideUtil.getOverrideMeta(candidate) === null;
+      },
+    );
+
+    // 08:00-09:00 and 13:00-14:00 are still plain A.
+    expect(untouched).toHaveLength(2);
+    for (const segment of untouched) {
+      expect(segment.title).toBe("A");
+    }
+  });
+});
+
+describe("ScheduleShiftUtil.groupKeyByUserAndOverride", () => {
+  test("keeps a substitute's own shift separate from the one they are covering", () => {
+    /*
+     * The regression this exists for. B is rostered 14:00-18:00 in their own
+     * right and is ALSO covering A from 12:00-14:00. The two segments touch and
+     * belong to the same user, so the default grouping merges them into one
+     * 12:00-18:00 block - and since a shift inherits metadata from its first
+     * segment only, the merged block claims to be four hours of cover when half
+     * of it is B's ordinary turn.
+     */
+    const events: Array<CalendarEvent> =
+      UserOverrideUtil.applyOverridesToEvents({
+        events: [event("A", 8, 14), { ...event("B", 14, 18), id: 2 }],
+        overrides: [record({ from: "A", to: "B", startHour: 12, endHour: 14 })],
+      });
+
+    const merged: Array<OnCallShift> =
+      ScheduleShiftUtil.groupEventsIntoShifts(events);
+    const split: Array<OnCallShift> = ScheduleShiftUtil.groupEventsIntoShifts(
+      events,
+      { groupKey: ScheduleShiftUtil.groupKeyByUserAndOverride },
+    );
+
+    // The default grouping folds B's cover into B's own turn: one block.
+    const mergedB: Array<OnCallShift> = merged.filter((s: OnCallShift) => {
+      return s.userId === "B";
+    });
+    expect(mergedB).toHaveLength(1);
+    expect(mergedB[0]!.end).toEqual(at(18));
+
+    // The override-aware grouping keeps them apart.
+    const splitB: Array<OnCallShift> = split.filter((s: OnCallShift) => {
+      return s.userId === "B";
+    });
+    expect(splitB).toHaveLength(2);
+
+    const cover: OnCallShift = splitB[0]!;
+    const ownTurn: OnCallShift = splitB[1]!;
+
+    expect(cover.start).toEqual(at(12));
+    expect(cover.end).toEqual(at(14));
+    expect(cover.override).toBeDefined();
+    expect(cover.override!.originalUserId).toBe("A");
+
+    expect(ownTurn.start).toEqual(at(14));
+    expect(ownTurn.end).toEqual(at(18));
+    expect(ownTurn.override).toBeUndefined();
+  });
+
+  test("two consecutive windows covering DIFFERENT people stay two shifts", () => {
+    const events: Array<CalendarEvent> =
+      UserOverrideUtil.applyOverridesToEvents({
+        events: [event("A", 8, 12), { ...event("C", 12, 16), id: 2 }],
+        overrides: [
+          record({ from: "A", to: "B", startHour: 8, endHour: 12 }),
+          record({ from: "C", to: "B", startHour: 12, endHour: 16 }),
+        ],
+      });
+
+    const shifts: Array<OnCallShift> = ScheduleShiftUtil.groupEventsIntoShifts(
+      events,
+      { groupKey: ScheduleShiftUtil.groupKeyByUserAndOverride },
+    );
+
+    expect(shifts).toHaveLength(2);
+    expect(shifts[0]!.override!.originalUserId).toBe("A");
+    expect(shifts[1]!.override!.originalUserId).toBe("C");
+  });
+
+  test("an ordinary rotation is grouped exactly as the default key groups it", () => {
+    /*
+     * The new key must not fragment schedules that have no overrides at all -
+     * every "upcoming hand-offs" list in the dashboard is built from it, and a
+     * key that split on something invisible would show hand-offs that are not
+     * hand-offs.
+     */
+    const events: Array<CalendarEvent> = [
+      event("A", 8, 12),
+      { ...event("A", 12, 16), id: 2 },
+      { ...event("B", 16, 20), id: 3 },
+    ];
+
+    const withDefault: Array<OnCallShift> =
+      ScheduleShiftUtil.groupEventsIntoShifts(events);
+    const withOverrideKey: Array<OnCallShift> =
+      ScheduleShiftUtil.groupEventsIntoShifts(events, {
+        groupKey: ScheduleShiftUtil.groupKeyByUserAndOverride,
+      });
+
+    expect(withOverrideKey).toEqual(withDefault);
+    expect(withOverrideKey).toHaveLength(2);
+  });
+
+  test("one override spanning a rotation boundary stays a single shift", () => {
+    /*
+     * Unlike groupKeyByUserOverrideAndLayer, this key deliberately ignores the
+     * rotation period: a person covering across a hand-over is doing one
+     * continuous stretch of cover, and splitting it would invent a hand-off the
+     * reader cannot act on.
+     */
+    const events: Array<CalendarEvent> =
+      UserOverrideUtil.applyOverridesToEvents({
+        events: [event("A", 8, 12), { ...event("C", 12, 16), id: 2 }],
+        overrides: [record({ from: "A", to: "B", startHour: 8, endHour: 12 })],
+      });
+
+    const shifts: Array<OnCallShift> = ScheduleShiftUtil.groupEventsIntoShifts(
+      events,
+      { groupKey: ScheduleShiftUtil.groupKeyByUserAndOverride },
+    );
+
+    const bShifts: Array<OnCallShift> = shifts.filter((s: OnCallShift) => {
+      return s.userId === "B";
+    });
+    expect(bShifts).toHaveLength(1);
+    expect(bShifts[0]!.start).toEqual(at(8));
+    expect(bShifts[0]!.end).toEqual(at(12));
+  });
+});

package/Tests/Types/Runner/RunnerLiveStatus.test.ts

@@ -225,8 +225,8 @@ describe("getRunnerLiveStatusLabel", () => {
 
   /*
    * "Connected" and "Disconnected" are pre-existing i18next keys, translated
-   * in all sixteen locale files for the probe pages. Changing the casing or
-   * wording here would silently drop fifteen translations back to English.
+   * in all seventeen locale files for the probe pages. Changing the casing or
+   * wording here would silently drop sixteen translations back to English.
    */
   test("it reuses the exact pre-existing locale keys", () => {
     expect(getRunnerLiveStatusLabel(RunnerLiveStatus.Connected)).not.toBe(

package/Tests/Types/SignupPassword.test.ts

@@ -0,0 +1,205 @@
+import {
+  getPasswordValidationError,
+  getSignupPasswordValidationError,
+  isPredictableSignupPassword,
+  MAXIMUM_PASSWORD_LENGTH,
+  MINIMUM_SIGNUP_PASSWORD_LENGTH,
+} from "../../Types/Password";
+import { describe, expect, test } from "@jest/globals";
+
+describe("signup password pattern feedback", () => {
+  test.each(["", " ", "\t\n", "\u00a0\u2003"])(
+    "does not mark the pattern requirement complete for blank input (%p)",
+    (value: string) => {
+      expect(isPredictableSignupPassword(value)).toBe(true);
+    },
+  );
+
+  test.each([
+    ["a common word", "password"],
+    ["a common word with mixed case and digits", "PaSsWoRd123"],
+    ["a common word padded with punctuation", " !welcome! "],
+    ["a common word with currency symbols", "£admin123$"],
+    ["a common word with math symbols", "+letmein="],
+    ["a common word with modifier symbols", "^changeme^"],
+    ["a repeated character", "aa"],
+    ["repeated punctuation", "!!"],
+    ["repeated Unicode symbols", "🔒🔒"],
+    ["repeated words with separators", "river-river"],
+    ["a numeric sequence", "12345"],
+    ["a reversed numeric sequence", "54321"],
+    ["an alphabetical sequence", "abcde"],
+    ["a reversed alphabetical sequence", "edcba"],
+    ["a keyboard sequence", "qwerty"],
+    ["a reversed keyboard sequence", "ytrewq"],
+  ])(
+    "identifies %s before reaching the minimum length",
+    (_label: string, value: string) => {
+      expect(Array.from(value).length).toBeLessThan(
+        MINIMUM_SIGNUP_PASSWORD_LENGTH,
+      );
+      expect(isPredictableSignupPassword(value)).toBe(true);
+      expect(getSignupPasswordValidationError(value)).toBe(
+        "Password must be at least 15 characters.",
+      );
+    },
+  );
+
+  test.each([
+    ["unrelated lowercase words", "river fox"],
+    ["mixed character types", "N7#pR2!v"],
+    ["non-Latin words", "花鳥風月海"],
+    ["accented words", "café rivière"],
+    ["varied emoji", "🌍🍋🎈🐢🌊"],
+  ])(
+    "can complete the pattern requirement for %s while length is unfinished",
+    (_label: string, value: string) => {
+      expect(isPredictableSignupPassword(value)).toBe(false);
+      expect(getSignupPasswordValidationError(value)).toBe(
+        "Password must be at least 15 characters.",
+      );
+    },
+  );
+
+  test("keeps maximum-length errors ahead of pattern errors", () => {
+    const value: string = "a".repeat(MAXIMUM_PASSWORD_LENGTH + 1);
+    expect(isPredictableSignupPassword(value)).toBe(true);
+    expect(getSignupPasswordValidationError(value)).toBe(
+      "Password cannot be more than 100 characters.",
+    );
+  });
+});
+
+describe("signup password policy", () => {
+  test.each([undefined, null, ""])(
+    "requires a password (%p)",
+    (value: unknown) => {
+      expect(getSignupPasswordValidationError(value)).toBe(
+        "Password is required.",
+      );
+    },
+  );
+
+  test.each([
+    false,
+    true,
+    123456789012345,
+    [],
+    ["a long enough password"],
+    {},
+    { value: "a long enough password" },
+  ])("rejects non-string input (%p)", (value: unknown) => {
+    expect(getSignupPasswordValidationError(value)).toBe(
+      "Password must be a string.",
+    );
+  });
+
+  test.each([" ", "\t\n", " ".repeat(15), " ".repeat(101)])(
+    "rejects whitespace-only input (%p)",
+    (value: string) => {
+      expect(getSignupPasswordValidationError(value)).toBe(
+        "Password cannot be blank.",
+      );
+    },
+  );
+
+  test.each(["a", "sample", "password", "Password123!", "birch lake sun"])(
+    "rejects short passwords (%p)",
+    (value: string) => {
+      expect(getSignupPasswordValidationError(value)).toBe(
+        `Password must be at least ${MINIMUM_SIGNUP_PASSWORD_LENGTH} characters.`,
+      );
+    },
+  );
+
+  test("accepts exactly 15 characters without requiring mixed character types", () => {
+    const value: string = "birch lake suns";
+    expect(Array.from(value)).toHaveLength(MINIMUM_SIGNUP_PASSWORD_LENGTH);
+    expect(getSignupPasswordValidationError(value)).toBeNull();
+  });
+
+  test("accepts exactly the maximum and rejects the next character", () => {
+    const value: string = "violet river lantern".repeat(5);
+    expect(value).toHaveLength(MAXIMUM_PASSWORD_LENGTH);
+    expect(getSignupPasswordValidationError(value)).toBeNull();
+    expect(getSignupPasswordValidationError(value + "!")).toBe(
+      `Password cannot be more than ${MAXIMUM_PASSWORD_LENGTH} characters.`,
+    );
+  });
+
+  test.each([
+    "aaaaaaaaaaaaaaa",
+    "111111111111111",
+    "!!!!!!!!!!!!!!!!",
+    "!\n".repeat(8),
+    "$\r\n".repeat(6),
+    "abcabcabcabcabc",
+    "PasswordPassword",
+    "password password",
+    "PASSWORD-PASSWORD!",
+    "password123456789",
+    "Password123456789!",
+    "OneUptime123456789!",
+    "OneUptimeOneUptime",
+    "LetMeIn123456789!",
+    "Welcome123456789!",
+    "Admin12345678901!",
+    "ChangeMe12345678!",
+    "123456789012345",
+    "987654321098765",
+    "abcdefghijklmnop",
+    "ponmlkjihgfedcba",
+    "qwertyuiopasdfghjkl",
+    "qwertyuiopqwertyuiop",
+    "lkjhgfdsapoiuytrewq",
+    "    password    ",
+    "🔒".repeat(15),
+  ])("rejects obvious predictable patterns (%p)", (value: string) => {
+    expect(isPredictableSignupPassword(value)).toBe(true);
+    expect(getSignupPasswordValidationError(value)).toBe(
+      "Choose a less predictable password. Try a few unrelated words.",
+    );
+  });
+
+  test.each([
+    "violet river lantern",
+    "unrelatedwordstogether",
+    "N7#pR2!vK9@wQ4$x",
+    " space matters here ",
+    "雨の中で踊る小さな青い鳥たちの歌",
+    "café rivière forêt tranquille",
+    "🎈 violet river 🌿 lantern",
+    "🌍🍋🎈🐢🌊🍂🪁🦉🚲🎸🍄🧭🐬🌻a",
+    "a password manager picked this phrase",
+  ])("accepts long passwords and passphrases (%p)", (value: string) => {
+    expect(isPredictableSignupPassword(value)).toBe(false);
+    expect(getSignupPasswordValidationError(value)).toBeNull();
+  });
+
+  test("counts emoji as single characters at both length boundaries", () => {
+    const short: string = "🎈birch lake su";
+    expect(short.length).toBe(15);
+    expect(Array.from(short)).toHaveLength(14);
+    expect(getSignupPasswordValidationError(short)).toBe(
+      "Password must be at least 15 characters.",
+    );
+    expect(getSignupPasswordValidationError(short + "n")).toBeNull();
+    const maximum: string =
+      "🎈" + "violet river lantern ".repeat(5).slice(0, 99);
+    expect(Array.from(maximum)).toHaveLength(100);
+    expect(getSignupPasswordValidationError(maximum)).toBeNull();
+    expect(getSignupPasswordValidationError(maximum + "🌿")).toBe(
+      "Password cannot be more than 100 characters.",
+    );
+  });
+
+  test("does not include the submitted password in error messages", () => {
+    const secret: string = "Password123!";
+    expect(getSignupPasswordValidationError(secret)).not.toContain(secret);
+  });
+
+  test("preserves the existing policy for other password flows", () => {
+    expect(getPasswordValidationError("sample")).toBeNull();
+    expect(getSignupPasswordValidationError("sample")).not.toBeNull();
+  });
+});

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

@@ -0,0 +1,44 @@
+import {
+  DEFAULT_STATUS_PAGE_LANGUAGE,
+  StatusPageLanguage,
+  SUPPORTED_STATUS_PAGE_LANGUAGES,
+  SUPPORTED_STATUS_PAGE_LANGUAGE_CODES,
+} from "../../../Types/StatusPage/StatusPageLanguage";
+import { describe, expect, test } from "@jest/globals";
+
+describe("SUPPORTED_STATUS_PAGE_LANGUAGES", () => {
+  test("registers Persian (fa) with its native and English names", () => {
+    const persian: StatusPageLanguage | undefined =
+      SUPPORTED_STATUS_PAGE_LANGUAGES.find((language: StatusPageLanguage) => {
+        return language.code === "fa";
+      });
+
+    expect(persian).toEqual({
+      code: "fa",
+      nativeName: "فارسی",
+      englishName: "Persian",
+    });
+  });
+
+  test("includes fa in the derived language-code list", () => {
+    expect(SUPPORTED_STATUS_PAGE_LANGUAGE_CODES).toContain("fa");
+  });
+
+  test("does not change the default language", () => {
+    expect(DEFAULT_STATUS_PAGE_LANGUAGE).toBe("en");
+  });
+
+  test("every supported language has a unique, non-blank code", () => {
+    const codes: Array<string> = SUPPORTED_STATUS_PAGE_LANGUAGES.map(
+      (language: StatusPageLanguage) => {
+        return language.code;
+      },
+    );
+
+    for (const code of codes) {
+      expect(code.trim().length).toBeGreaterThan(0);
+    }
+
+    expect(new Set<string>(codes).size).toBe(codes.length);
+  });
+});

package/Tests/Types/SupportedLanguages.test.ts

@@ -0,0 +1,119 @@
+import {
+  AccountsLanguage,
+  DEFAULT_ACCOUNTS_LANGUAGE,
+  SUPPORTED_ACCOUNTS_LANGUAGES,
+} from "../../Types/Accounts/AccountsLanguage";
+import {
+  AdminDashboardLanguage,
+  DEFAULT_ADMIN_DASHBOARD_LANGUAGE,
+  SUPPORTED_ADMIN_DASHBOARD_LANGUAGES,
+} from "../../Types/AdminDashboard/AdminDashboardLanguage";
+import {
+  DashboardLanguage,
+  DEFAULT_DASHBOARD_LANGUAGE,
+  SUPPORTED_DASHBOARD_LANGUAGES,
+} from "../../Types/Dashboard/DashboardLanguage";
+import {
+  DEFAULT_DOCS_LANGUAGE,
+  DocsLanguage,
+  SUPPORTED_DOCS_LANGUAGES,
+} from "../../Types/Docs/DocsLanguage";
+import {
+  DEFAULT_STATUS_PAGE_LANGUAGE,
+  StatusPageLanguage,
+  SUPPORTED_STATUS_PAGE_LANGUAGES,
+} from "../../Types/StatusPage/StatusPageLanguage";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * The five registries below are separate arrays that every localized surface
+ * reads from: the Dashboard, the Admin Dashboard, Accounts, the Status Page,
+ * and Docs (which the API Reference shares). Nothing in the type system ties
+ * them together, so a language added to one of them and forgotten in the other
+ * four ships a language switcher that offers Persian on the status page and
+ * nothing anywhere else - which is exactly how Farsi first landed.
+ *
+ * These assertions are deliberately whole-array comparisons rather than a
+ * membership check for one code: they fail for any language added to a subset
+ * of surfaces, not just the one that prompted them.
+ */
+
+type LanguageEntry =
+  | AccountsLanguage
+  | AdminDashboardLanguage
+  | DashboardLanguage
+  | DocsLanguage
+  | StatusPageLanguage;
+
+const REGISTRIES: Array<[string, Array<LanguageEntry>]> = [
+  ["Accounts", SUPPORTED_ACCOUNTS_LANGUAGES],
+  ["AdminDashboard", SUPPORTED_ADMIN_DASHBOARD_LANGUAGES],
+  ["Dashboard", SUPPORTED_DASHBOARD_LANGUAGES],
+  ["Docs", SUPPORTED_DOCS_LANGUAGES],
+  ["StatusPage", SUPPORTED_STATUS_PAGE_LANGUAGES],
+];
+
+const DEFAULTS: Array<[string, string]> = [
+  ["Accounts", DEFAULT_ACCOUNTS_LANGUAGE],
+  ["AdminDashboard", DEFAULT_ADMIN_DASHBOARD_LANGUAGE],
+  ["Dashboard", DEFAULT_DASHBOARD_LANGUAGE],
+  ["Docs", DEFAULT_DOCS_LANGUAGE],
+  ["StatusPage", DEFAULT_STATUS_PAGE_LANGUAGE],
+];
+
+describe("supported language registries", () => {
+  test.each(REGISTRIES)(
+    "%s offers the same languages, in the same order, as the Status Page",
+    (_name: string, languages: Array<LanguageEntry>) => {
+      expect(languages).toEqual(SUPPORTED_STATUS_PAGE_LANGUAGES);
+    },
+  );
+
+  test.each(DEFAULTS)(
+    "%s falls back to English",
+    (_name: string, defaultLanguage: string) => {
+      expect(defaultLanguage).toBe("en");
+    },
+  );
+
+  test.each(REGISTRIES)(
+    "%s has a unique, non-blank code for every language",
+    (_name: string, languages: Array<LanguageEntry>) => {
+      const codes: Array<string> = languages.map((language: LanguageEntry) => {
+        return language.code;
+      });
+
+      for (const code of codes) {
+        expect(code.trim().length).toBeGreaterThan(0);
+      }
+
+      expect(new Set<string>(codes).size).toBe(codes.length);
+    },
+  );
+
+  test.each(REGISTRIES)(
+    "%s names every language in English and in the language itself",
+    (_name: string, languages: Array<LanguageEntry>) => {
+      for (const language of languages) {
+        expect(language.englishName.trim().length).toBeGreaterThan(0);
+        expect(language.nativeName.trim().length).toBeGreaterThan(0);
+      }
+    },
+  );
+
+  test("English is the first language every switcher offers", () => {
+    for (const [, languages] of REGISTRIES) {
+      expect(languages[0]?.code).toBe("en");
+    }
+  });
+
+  test("Persian is registered on every surface, not just the Status Page", () => {
+    for (const [, languages] of REGISTRIES) {
+      expect(languages).toContainEqual({
+        code: "fa",
+        nativeName: "فارسی",
+        englishName: "Persian",
+      });
+    }
+  });
+});