@oneuptime/common 14.0.2 → 14.0.5

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

@@ -0,0 +1,280 @@
+import "@testing-library/jest-dom";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import { act, cleanup, render, screen } from "@testing-library/react";
+import * as React from "react";
+import { MemoryRouter } from "react-router-dom";
+import getJestMockFunction, { MockFunction } from "../../MockType";
+
+/*
+ * When the Databases list refreshes the stat strip above it. The strip's
+ * nine counts are project-wide, so what the table below is showing — a
+ * page, a sort, a search, a facet — cannot change them: those fetches must
+ * not re-run them, and the table's first fetch must not repeat the strip's
+ * own first one. What CAN change them does refresh them at once: a
+ * database created, databases archived. Anything else (a refresh click, the
+ * live window moving on) refreshes them once they are old enough to have
+ * drifted.
+ */
+
+const countMock: MockFunction = getJestMockFunction();
+const stripTokens: Array<number> = [];
+
+interface TableProps {
+  onFetchSuccess: (data: Array<unknown>, totalCount: number) => void;
+  onCreateSuccess: (item: unknown) => Promise<unknown>;
+  bulkActions: {
+    buttons: Array<{
+      title: string;
+      onClick: (props: {
+        items: Array<unknown>;
+        onProgressInfo: (info: unknown) => void;
+        onBulkActionStart: () => void;
+        onBulkActionEnd: () => void;
+      }) => Promise<void>;
+    }>;
+  };
+}
+
+let tableProps: TableProps | null = null;
+const archiveEndMock: MockFunction = getJestMockFunction();
+
+// The arrow wrappers are load bearing: jest.mock is hoisted above the mocks.
+jest.mock("../../../UI/Utils/ModelAPI/ModelAPI", () => {
+  return {
+    __esModule: true,
+    default: {
+      count: (...args: Array<unknown>) => {
+        return countMock(...args);
+      },
+    },
+  };
+});
+
+jest.mock("../../../UI/Components/ModelTable/ModelTable", () => {
+  return {
+    __esModule: true,
+    default: (props: TableProps) => {
+      tableProps = props;
+      return <div data-testid="databases-table" />;
+    },
+  };
+});
+
+jest.mock(
+  "../../../../App/FeatureSet/Dashboard/src/Components/DatabaseServer/DatabaseServerSummaryStrip",
+  () => {
+    return {
+      __esModule: true,
+      default: (props: { refreshToken?: number }) => {
+        stripTokens.push(props.refreshToken || 0);
+        return (
+          <div data-testid="summary-strip">{String(props.refreshToken)}</div>
+        );
+      },
+    };
+  },
+);
+
+jest.mock(
+  "../../../../App/FeatureSet/Dashboard/src/Components/DatabaseServer/DocumentationCard",
+  () => {
+    return {
+      __esModule: true,
+      default: () => {
+        return <div />;
+      },
+    };
+  },
+);
+
+jest.mock(
+  "../../../../App/FeatureSet/Dashboard/src/Components/ResourceOwners/useResourceOwners",
+  () => {
+    return {
+      __esModule: true,
+      buildEnumFacetQuery: () => {
+        return undefined;
+      },
+      default: () => {
+        return {
+          getOwnersForResource: () => {
+            return [];
+          },
+          isLoadingOwners: false,
+          onResourcesFetched: () => {},
+          filterBar: <div />,
+          mergeFiltersIntoQuery: (query: unknown) => {
+            return query;
+          },
+          facetSaveState: undefined,
+          restoreFacetState: () => {},
+        };
+      },
+    };
+  },
+);
+
+jest.mock("../../../UI/Components/BulkUpdate/BulkLabelActions", () => {
+  return {
+    __esModule: true,
+    default: () => {
+      return { bulkActions: [], modals: <></> };
+    },
+  };
+});
+
+jest.mock("../../../UI/Components/BulkUpdate/BulkOwnerActions", () => {
+  return {
+    __esModule: true,
+    default: () => {
+      return { bulkActions: [], modals: <></> };
+    },
+  };
+});
+
+jest.mock("../../../UI/Components/BulkUpdate/BulkArchiveActions", () => {
+  return {
+    __esModule: true,
+    default: () => {
+      return {
+        archiveBulkActions: [
+          {
+            title: "Archive",
+            onClick: async (props: {
+              onBulkActionStart: () => void;
+              onBulkActionEnd: () => void;
+            }): Promise<void> => {
+              props.onBulkActionStart();
+              props.onBulkActionEnd();
+            },
+          },
+        ],
+        unarchiveBulkActions: [],
+      };
+    },
+  };
+});
+
+import Databases from "../../../../App/FeatureSet/Dashboard/src/Pages/Database/Databases";
+import { DATABASE_FLEET_SUMMARY_MIN_REFRESH_MS } from "../../../../App/FeatureSet/Dashboard/src/Pages/Database/Utils/DatabaseServerSummary";
+import PageComponentProps from "../../../../App/FeatureSet/Dashboard/src/Pages/PageComponentProps";
+import Route from "../../../Types/API/Route";
+
+const PAGE_PROPS: PageComponentProps = {
+  pageRoute: new Route("/dashboard/test/databases"),
+  currentProject: null,
+  hasPaymentMethod: true,
+};
+
+let now: number = Date.parse("2026-09-24T10:00:00.000Z");
+
+function latestToken(): number {
+  return stripTokens[stripTokens.length - 1] as number;
+}
+
+async function renderPage(): Promise<TableProps> {
+  render(
+    <MemoryRouter>
+      <Databases {...PAGE_PROPS} />
+    </MemoryRouter>,
+  );
+  await screen.findByTestId("summary-strip");
+  return tableProps as TableProps;
+}
+
+function tableFetched(table: TableProps): void {
+  act(() => {
+    table.onFetchSuccess([], 3);
+  });
+}
+
+beforeEach(() => {
+  now = Date.parse("2026-09-24T10:00:00.000Z");
+  jest.spyOn(Date, "now").mockImplementation((): number => {
+    return now;
+  });
+  countMock.mockReset();
+  countMock.mockResolvedValue(3);
+  archiveEndMock.mockReset();
+  stripTokens.length = 0;
+  tableProps = null;
+});
+
+afterEach(() => {
+  cleanup();
+  jest.restoreAllMocks();
+});
+
+describe("the Databases list's summary strip", () => {
+  test("the table's first fetch does not repeat the strip's own first one", async () => {
+    const table: TableProps = await renderPage();
+
+    tableFetched(table);
+
+    expect(latestToken()).toBe(0);
+  });
+
+  test("paging, sorting, searching and filtering the table leave the counts alone", async () => {
+    const table: TableProps = await renderPage();
+
+    for (let fetch: number = 0; fetch < 10; fetch++) {
+      now += 1000;
+      tableFetched(table);
+    }
+
+    expect(latestToken()).toBe(0);
+  });
+
+  test("a table fetch once the counts are old refreshes them (a refresh click, say)", async () => {
+    const table: TableProps = await renderPage();
+
+    now += DATABASE_FLEET_SUMMARY_MIN_REFRESH_MS;
+    tableFetched(table);
+    expect(latestToken()).toBe(1);
+
+    // And not again straight after.
+    now += 1000;
+    tableFetched(table);
+    expect(latestToken()).toBe(1);
+  });
+
+  test("creating a database refreshes them at once", async () => {
+    const table: TableProps = await renderPage();
+
+    await act(async () => {
+      await table.onCreateSuccess({});
+    });
+
+    expect(latestToken()).toBe(1);
+  });
+
+  test("archiving databases refreshes them at once, after the table's own end handler", async () => {
+    const table: TableProps = await renderPage();
+    const archive: TableProps["bulkActions"]["buttons"][number] | undefined =
+      table.bulkActions.buttons.find((button: { title: string }): boolean => {
+        return button.title === "Archive";
+      });
+    expect(archive).toBeDefined();
+
+    await act(async () => {
+      await archive!.onClick({
+        items: [],
+        onProgressInfo: (): void => {},
+        onBulkActionStart: (): void => {},
+        onBulkActionEnd: (): void => {
+          archiveEndMock();
+        },
+      });
+    });
+
+    expect(archiveEndMock).toHaveBeenCalledTimes(1);
+    expect(latestToken()).toBe(1);
+  });
+});

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

@@ -0,0 +1,321 @@
+import { describe, expect, test } from "@jest/globals";
+import fs from "fs";
+import path from "path";
+import {
+  DATABASE_SERVER_ADDRESS_DESCRIPTION,
+  DATABASE_SERVER_SERVICE_NAME_CLUSTER_REQUIRED,
+  getDatabaseServerAddressHint,
+  validateDatabaseServerAddress,
+} from "../../../../App/FeatureSet/Dashboard/src/Pages/Database/Utils/DatabaseManualEndpointForm";
+import { getDatabaseEndpointSourceLabel } from "../../../../App/FeatureSet/Dashboard/src/Pages/Database/Utils/DatabaseServerPresentation";
+
+/*
+ * The Databases pages' form helpers.
+ *
+ * The create form's Server Address: its help text documents the forms the
+ * identity rules accept (`@<cluster>` for an address that only resolves
+ * inside one cluster or private network, `host\INSTANCE` for a SQL Server
+ * named instance, never `user@host`), its validation refuses what could
+ * never become an endpoint with a message that says what to change, and its
+ * hint offers the `@<cluster>` form — saying, for a Kubernetes Service name,
+ * that the server requires it once the project has a Kubernetes cluster.
+ *
+ * The Endpoints tab's "Added by" pill: which of discovery's claims an
+ * endpoint is.
+ */
+
+describe("the create form's Server Address help", () => {
+  test("documents the cluster qualifier, the named instance and the user@host rule", () => {
+    expect(DATABASE_SERVER_ADDRESS_DESCRIPTION).toContain(
+      "pg.shop.svc.cluster.local:5432@prod-eu",
+    );
+    expect(DATABASE_SERVER_ADDRESS_DESCRIPTION).toContain(
+      "(pg.shop.svc.cluster.local, pg.shop.svc)",
+    );
+    expect(DATABASE_SERVER_ADDRESS_DESCRIPTION).toContain("private IP");
+    expect(DATABASE_SERVER_ADDRESS_DESCRIPTION).toContain("host\\INSTANCE");
+    expect(DATABASE_SERVER_ADDRESS_DESCRIPTION).toContain(
+      "Do not include a user name (user@host)",
+    );
+    expect(DATABASE_SERVER_ADDRESS_DESCRIPTION).toContain("Never localhost");
+  });
+
+  test("every example the help gives is accepted as written", () => {
+    for (const example of [
+      "pg.shop.svc.cluster.local:5432@prod-eu",
+      "pg.shop@prod-eu",
+      "10.0.0.5:5432@prod-eu",
+      "sql1\\INST01",
+    ]) {
+      expect({
+        example,
+        error: validateDatabaseServerAddress({
+          dbSystem: "postgresql",
+          serverAddress: example,
+        }),
+      }).toEqual({ example, error: null });
+    }
+  });
+
+  /*
+   * Regression: the help gave `pg.shop` as a cluster-only name, but the
+   * create form has no namespace to complete it with, so it reads as an
+   * ordinary two-label domain — no cluster advice, and a database no pod's
+   * calls would match.
+   */
+  test("every cluster-only example the help gives is read as cluster-only on the create form", () => {
+    const examples: Array<string> = (
+      DATABASE_SERVER_ADDRESS_DESCRIPTION.match(
+        /one Kubernetes cluster \(([^)]+)\)/,
+      ) as RegExpMatchArray
+    )[1]!.split(", ");
+
+    expect(examples).toEqual(["pg.shop.svc.cluster.local", "pg.shop.svc"]);
+
+    for (const serverAddress of examples) {
+      expect({
+        serverAddress,
+        advises: Boolean(
+          getDatabaseServerAddressHint({
+            dbSystem: "postgresql",
+            serverAddress,
+          })?.includes("@<cluster name>"),
+        ),
+      }).toEqual({ serverAddress, advises: true });
+    }
+
+    // The old example: a two-label domain here, never cluster-only.
+    expect(
+      getDatabaseServerAddressHint({
+        dbSystem: "postgresql",
+        serverAddress: "pg.shop",
+      }),
+    ).toBeNull();
+  });
+});
+
+describe("validateDatabaseServerAddress", () => {
+  test("a plain host, with or without a port, is accepted", () => {
+    expect(
+      validateDatabaseServerAddress({
+        dbSystem: "postgresql",
+        serverAddress: "db.prod.example.com",
+      }),
+    ).toBeNull();
+    expect(
+      validateDatabaseServerAddress({
+        dbSystem: "mysql",
+        serverAddress: "db.prod.example.com:3307",
+        serverPort: "",
+      }),
+    ).toBeNull();
+  });
+
+  test("user@host is refused, and told to drop the user", () => {
+    const error: string | null = validateDatabaseServerAddress({
+      dbSystem: "postgresql",
+      serverAddress: "admin@db.example.com:5432",
+    });
+    expect(error).toContain('Remove "admin@"');
+    expect(error).toContain("does not belong in an endpoint");
+  });
+
+  test("a dotted user name is a user name too, not a host", () => {
+    expect(
+      validateDatabaseServerAddress({
+        dbSystem: "postgresql",
+        serverAddress: "john.doe@db.example.com",
+      }),
+    ).toContain('Remove "john.doe@"');
+  });
+
+  test("a cluster qualifier on a public name is refused", () => {
+    expect(
+      validateDatabaseServerAddress({
+        dbSystem: "postgresql",
+        serverAddress: "db.example.com@prod",
+      }),
+    ).toContain('Remove "@prod"');
+  });
+
+  test("loopback is refused", () => {
+    expect(
+      validateDatabaseServerAddress({
+        dbSystem: "redis",
+        serverAddress: "localhost:6379",
+      }),
+    ).toContain("loopback");
+  });
+
+  test("the port field is checked with the address", () => {
+    expect(
+      validateDatabaseServerAddress({
+        dbSystem: "postgresql",
+        serverAddress: "db.example.com",
+        serverPort: 70000,
+      }),
+    ).toBe("Server port must be a whole number between 1 and 65535.");
+    expect(
+      validateDatabaseServerAddress({
+        dbSystem: "postgresql",
+        serverAddress: "db.example.com:99999",
+      }),
+    ).toContain("port outside 1-65535");
+    expect(
+      validateDatabaseServerAddress({
+        dbSystem: "postgresql",
+        serverAddress: "db.example.com",
+        serverPort: 6432,
+      }),
+    ).toBeNull();
+  });
+
+  test("works before an engine is picked, and on empty input", () => {
+    expect(
+      validateDatabaseServerAddress({ serverAddress: "db.example.com" }),
+    ).toBeNull();
+    expect(validateDatabaseServerAddress({ serverAddress: "" })).toContain(
+      "Server address is required",
+    );
+    expect(validateDatabaseServerAddress(null)).toContain(
+      "Server address is required",
+    );
+  });
+});
+
+describe("getDatabaseServerAddressHint", () => {
+  test("an unqualified cluster-local name or private IP gets the @<cluster> advice", () => {
+    for (const serverAddress of [
+      "pg.shop.svc.cluster.local",
+      "10.0.0.5",
+      "db.internal",
+    ]) {
+      const hint: string | null = getDatabaseServerAddressHint({
+        dbSystem: "postgresql",
+        serverAddress,
+      });
+      expect({
+        serverAddress,
+        advises: Boolean(hint?.includes("@<cluster name>")),
+      }).toEqual({ serverAddress, advises: true });
+    }
+  });
+
+  test("a Kubernetes Service name is told the cluster is required where clusters exist", () => {
+    for (const serverAddress of [
+      "pg.shop.svc.cluster.local",
+      "pg.shop.svc",
+      "pg.shop.svc.cluster.local:5433",
+      "mongo-0.mongo-hl.data.svc.cluster.local",
+    ]) {
+      const hint: string | null = getDatabaseServerAddressHint({
+        dbSystem: "postgresql",
+        serverAddress,
+      });
+      expect({
+        serverAddress,
+        advises: Boolean(hint?.includes("@<cluster name>")),
+        required: Boolean(
+          hint?.endsWith(DATABASE_SERVER_SERVICE_NAME_CLUSTER_REQUIRED),
+        ),
+      }).toEqual({ serverAddress, advises: true, required: true });
+    }
+  });
+
+  test("says 'required' on exactly the test the server's refusal applies", () => {
+    // DatabaseServerService refuses when both of these hold (and clusters exist).
+    const service: string = fs.readFileSync(
+      path.join(__dirname, "../../../Server/Services/DatabaseServerService.ts"),
+      "utf8",
+    );
+    const refusal: string = service.substring(
+      service.indexOf("private async refuseUnqualifiedKubernetesServiceName"),
+    );
+
+    expect(refusal).toContain("!data.manual.clusterQualifierHint");
+    expect(refusal).toContain("!isKubernetesServiceDnsHost(endpoint.host)");
+  });
+
+  test("a private IP or private-zone name is only advised, never told it is required", () => {
+    for (const serverAddress of ["10.0.0.5", "db.internal", "pg.local:5432"]) {
+      const hint: string | null = getDatabaseServerAddressHint({
+        dbSystem: "postgresql",
+        serverAddress,
+      });
+      expect({
+        serverAddress,
+        advises: Boolean(hint?.includes("@<cluster name>")),
+        required: Boolean(
+          hint?.includes(DATABASE_SERVER_SERVICE_NAME_CLUSTER_REQUIRED),
+        ),
+      }).toEqual({ serverAddress, advises: true, required: false });
+    }
+  });
+
+  test("a qualified, public or refused address gets no hint", () => {
+    for (const serverAddress of [
+      "pg.shop.svc.cluster.local:5432@prod-eu",
+      "db.example.com",
+      "admin@10.0.0.5",
+      "",
+    ]) {
+      expect({
+        serverAddress,
+        hint: getDatabaseServerAddressHint({
+          dbSystem: "postgresql",
+          serverAddress,
+        }),
+      }).toEqual({ serverAddress, hint: null });
+    }
+  });
+});
+
+describe("getDatabaseEndpointSourceLabel", () => {
+  test("says who added each endpoint, in words short enough for the 'Added by' pill", () => {
+    expect(getDatabaseEndpointSourceLabel("user")).toMatchObject({
+      text: "A person",
+      isUser: true,
+    });
+    expect(getDatabaseEndpointSourceLabel("workload")).toMatchObject({
+      text: "Kubernetes Service",
+      isUser: false,
+    });
+    expect(getDatabaseEndpointSourceLabel("auto")).toMatchObject({
+      text: "Discovery",
+      isUser: false,
+    });
+    /*
+     * "Discovered (Kubernetes Service)" made the pill 268 px wide and the
+     * Endpoints table overflow its card at 1440 px.
+     */
+    for (const value of ["user", "workload", "auto"]) {
+      expect(
+        getDatabaseEndpointSourceLabel(value).text.length,
+      ).toBeLessThanOrEqual(18);
+    }
+  });
+
+  test("the sentence the pill used to say is its hover text", () => {
+    expect(getDatabaseEndpointSourceLabel("user").description).toContain(
+      "by a person",
+    );
+    expect(getDatabaseEndpointSourceLabel("workload").description).toContain(
+      "Service name of the Kubernetes workload",
+    );
+    expect(getDatabaseEndpointSourceLabel("auto").description).toContain(
+      "Discovered",
+    );
+  });
+
+  test("is case- and space-tolerant, and reads anything unknown as discovered", () => {
+    expect(getDatabaseEndpointSourceLabel(" USER ").isUser).toBe(true);
+    expect(getDatabaseEndpointSourceLabel("Workload").text).toBe(
+      "Kubernetes Service",
+    );
+    for (const value of [undefined, null, "", "something-new", 42]) {
+      expect(getDatabaseEndpointSourceLabel(value)).toEqual(
+        getDatabaseEndpointSourceLabel("auto"),
+      );
+    }
+  });
+});