@oneuptime/common 13.0.0 → 13.0.3

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",
+      });
+    }
+  });
+});

package/Tests/Types/Telemetry/EntityTypeGroups.test.ts

@@ -46,6 +46,10 @@ describe("MANUAL_ENTITY_TYPES", () => {
     expect(MANUAL_ENTITY_TYPES.has(EntityType.Host)).toBe(false);
     expect(MANUAL_ENTITY_TYPES.has(EntityType.KubernetesPod)).toBe(false);
     expect(MANUAL_ENTITY_TYPES.has(EntityType.NetworkDevice)).toBe(false);
+    expect(MANUAL_ENTITY_TYPES.has(EntityType.VMwareVCenter)).toBe(false);
+    expect(MANUAL_ENTITY_TYPES.has(EntityType.VMwareVirtualMachine)).toBe(
+      false,
+    );
   });
 });
 
@@ -77,6 +81,21 @@ describe("INVENTORY_ENTITY_TYPES", () => {
       false,
     );
     expect(INVENTORY_ENTITY_TYPES.has(EntityType.ProxmoxGuest)).toBe(false);
+    /*
+     * VMware rows come purely from OTLP discovery (the vcenter receiver
+     * emits resources), not from a poller-fed inventory table — so they
+     * carry a heartbeat, are TTL-pruned, and must stay out of this set.
+     */
+    for (const entityType of [
+      EntityType.VMwareVCenter,
+      EntityType.VMwareCluster,
+      EntityType.VMwareHost,
+      EntityType.VMwareVirtualMachine,
+      EntityType.VMwareDatastore,
+    ]) {
+      expect(INVENTORY_ENTITY_TYPES.has(entityType)).toBe(false);
+      expect(isNonInventoryItemType(entityType)).toBe(false);
+    }
   });
 });
 

package/Tests/UI/ColorPickerBuild.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, test } from "@jest/globals";
+import childProcess from "child_process";
+import path from "path";
+
+const COMMON_ROOT: string = path.resolve(__dirname, "..", "..");
+const PICKER_SOURCE: string = path.join(
+  COMMON_ROOT,
+  "UI/Components/Forms/Fields/ColorPicker.tsx",
+);
+const COLOR_CONTROL_MODULE: RegExp =
+  /^(lib|es)\/(components\/(chrome|common)\/|helpers\/)/;
+
+/*
+ * FormField reaches this component even on pages without a color field. The
+ * react-color barrel included every picker implementation in those pages'
+ * bundles. Build the actual component with the frontend configuration and
+ * inspect emitted modules, so tree-shaking and type-only imports are accounted
+ * for. A subprocess supplies the native Node environment esbuild requires.
+ */
+function bundledColorModules(nodeEnv: string): Array<string> {
+  const script: string = `
+    const path = require("path");
+    const commonRoot = ${JSON.stringify(COMMON_ROOT)};
+    const esbuild = require(require.resolve("esbuild", { paths: [commonRoot] }));
+    const { createConfig } = require(path.join(commonRoot, "UI/esbuild-config.js"));
+    const config = createConfig({
+      serviceName: "Dashboard",
+      publicPath: "/dashboard/dist/",
+      entryPoint: ${JSON.stringify(PICKER_SOURCE)},
+    });
+
+    esbuild.build({
+      ...config,
+      write: false,
+      sourcemap: false,
+      metafile: true,
+      logLevel: "silent",
+    }).then((result) => {
+      const included = new Set();
+      for (const output of Object.values(result.metafile.outputs)) {
+        for (const [input, contribution] of Object.entries(output.inputs)) {
+          if (contribution.bytesInOutput > 0 && input.includes("/react-color/")) {
+            included.add(input.split("/react-color/")[1]);
+          }
+        }
+      }
+      console.log(JSON.stringify([...included].sort()));
+    }).catch((error) => {
+      console.error(error);
+      process.exitCode = 1;
+    });
+  `;
+
+  return JSON.parse(
+    childProcess.execFileSync(process.execPath, ["-e", script], {
+      cwd: COMMON_ROOT,
+      env: { ...process.env, NODE_ENV: nodeEnv },
+      encoding: "utf8",
+      timeout: 60000,
+      maxBuffer: 1024 * 1024,
+    }),
+  ) as Array<string>;
+}
+
+describe("color picker frontend bundle", () => {
+  test.each(["production", "development"])(
+    "includes Chrome and shared controls without the other pickers in %s",
+    (nodeEnv: string) => {
+      const modules: Array<string> = bundledColorModules(nodeEnv);
+
+      expect(modules).toEqual(
+        expect.arrayContaining([
+          expect.stringMatching(/^(lib|es)\/components\/chrome\/Chrome\.js$/),
+          expect.stringMatching(
+            /^(lib|es)\/components\/common\/ColorWrap\.js$/,
+          ),
+        ]),
+      );
+      expect(
+        modules.filter((modulePath: string) => {
+          return !COLOR_CONTROL_MODULE.test(modulePath);
+        }),
+      ).toEqual([]);
+    },
+  );
+});

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

@@ -1,5 +1,5 @@
 import { beforeEach, describe, expect, it, jest } from "@jest/globals";
-import { render, screen, waitFor } from "@testing-library/react";
+import { render, screen, waitFor, within } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import * as React from "react";
 import Color from "../../../Types/Color";
@@ -254,15 +254,22 @@ describe("AI investigation settings card", () => {
       await screen.findByText("Update", {}, { timeout: WAIT_TIMEOUT }),
     );
 
-    await waitFor(
-      () => {
-        expect(screen.getByText("Investigation")).toBeDefined();
+    /*
+     * Scoped to the progress nav on purpose: the form also renders the CURRENT
+     * step's name as a heading above its fields, so an unscoped getByText for
+     * the first step matches twice and throws. What this test is about is the
+     * step LIST, which is exactly what the nav holds.
+     */
+    const steps: HTMLElement = await waitFor(
+      (): HTMLElement => {
+        return screen.getByRole("navigation", { name: "Progress" });
       },
       { timeout: WAIT_TIMEOUT },
     );
 
-    expect(screen.getByText("Limits")).toBeDefined();
-    expect(screen.getByText("Fix Tasks")).toBeDefined();
+    expect(within(steps).getByText("Investigation")).toBeDefined();
+    expect(within(steps).getByText("Limits")).toBeDefined();
+    expect(within(steps).getByText("Fix Tasks")).toBeDefined();
 
     /*
      * Only the first step's fields are on screen - which is the point of