@oneuptime/common 12.0.34 → 13.0.1

package/Tests/App/Dashboard/CloudDocumentationMarkdown.test.ts

@@ -0,0 +1,215 @@
+import { describe, expect, test } from "@jest/globals";
+import {
+  CLOUD_DOC_OTHER_PLATFORMS_POINTER,
+  DEFAULT_CLOUD_DOC_PLATFORM,
+  DocVars,
+  getCloudDocMarkdown,
+  getCloudDocMarkdownForPlatform,
+} from "../../../../App/FeatureSet/Dashboard/src/Components/TelemetryResource/documentationMarkdown";
+import {
+  MANAGED_CLOUD_PLATFORMS,
+  ManagedCloudPlatform,
+  ManagedCloudPlatformDescriptor,
+  getManagedCloudPlatformDescriptor,
+} from "../../../Types/Cloud/CloudPlatform";
+
+/*
+ * The in-app "Connect a managed cloud environment" guide, per platform.
+ *
+ * These are pure string builders, so the whole contract is checkable: every
+ * managed platform gets a guide that carries the project's own endpoint and
+ * token (copy-paste ready), names its exact cloud.platform value (the one
+ * string ingest gates on), walks the console in numbered steps, says where
+ * the secret goes, and links to the registry's docs page for the platform.
+ * The platform-less entry point stays the ECS guide so its existing callers
+ * keep rendering what they rendered before, plus a pointer to the picker.
+ */
+
+const VARS: DocVars = {
+  oneuptimeUrl: "https://oneuptime.example.test",
+  apiKey: "tok-0123456789abcdef",
+};
+
+const FENCE_LINE: RegExp = /^\s*```/;
+const NUMBERED_STEP: RegExp = /^\d+\. \S/m;
+
+function fenceCount(markdown: string): number {
+  return markdown.split("\n").filter((line: string): boolean => {
+    return FENCE_LINE.test(line);
+  }).length;
+}
+
+describe("getCloudDocMarkdownForPlatform", () => {
+  test.each(
+    MANAGED_CLOUD_PLATFORMS.map(
+      (
+        descriptor: ManagedCloudPlatformDescriptor,
+      ): [string, ManagedCloudPlatformDescriptor] => {
+        return [descriptor.platform, descriptor];
+      },
+    ),
+  )(
+    "%s: endpoint, token, platform value, console steps, secret, docs link",
+    (_platform: string, descriptor: ManagedCloudPlatformDescriptor) => {
+      const markdown: string = getCloudDocMarkdownForPlatform(
+        VARS,
+        descriptor.platform,
+      );
+
+      expect(markdown.startsWith(`## Connect ${descriptor.productName}`)).toBe(
+        true,
+      );
+
+      // Copy-paste ready: the project's own endpoint and token, not placeholders.
+      expect(markdown).toContain(`${VARS.oneuptimeUrl}/otlp`);
+      expect(markdown).toContain(VARS.apiKey);
+      expect(markdown).toContain(`x-oneuptime-token`);
+      expect(markdown).not.toContain("YOUR_TELEMETRY_INGESTION_TOKEN");
+
+      // The exact string ingest gates on.
+      expect(markdown).toContain(`cloud.platform=${descriptor.platform}`);
+
+      // Console navigation as numbered steps, not just YAML.
+      expect(markdown).toMatch(NUMBERED_STEP);
+
+      // Where the token lives on this platform.
+      expect(markdown).toMatch(/secret/i);
+
+      // IAM / networking and verification are always present.
+      expect(markdown).toContain("networking checklist");
+      expect(markdown).toContain(`${VARS.oneuptimeUrl}/otlp/v1/validate`);
+      expect(markdown).toContain("Cloud → All Environments");
+
+      // What identifies an instance on this platform.
+      expect(markdown).toContain(`\`${descriptor.instanceAttribute}\``);
+
+      // The registry's docs page for the platform, and troubleshooting.
+      expect(markdown).toContain(`](${descriptor.docsUrl})`);
+      expect(markdown).toContain("/docs/telemetry/cloud-troubleshooting");
+
+      expect(fenceCount(markdown) % 2).toBe(0);
+    },
+  );
+
+  test("covers every ManagedCloudPlatform value with a distinct guide", () => {
+    const guides: Set<string> = new Set<string>();
+
+    for (const platform of Object.values(ManagedCloudPlatform)) {
+      guides.add(getCloudDocMarkdownForPlatform(VARS, platform));
+    }
+
+    expect(guides.size).toBe(Object.values(ManagedCloudPlatform).length);
+  });
+
+  test("falls back to the default platform for an unknown or empty value", () => {
+    const fallback: string = getCloudDocMarkdownForPlatform(
+      VARS,
+      DEFAULT_CLOUD_DOC_PLATFORM,
+    );
+
+    expect(getCloudDocMarkdownForPlatform(VARS, "")).toBe(fallback);
+    expect(getCloudDocMarkdownForPlatform(VARS, "aws_ec2")).toBe(fallback);
+    expect(getCloudDocMarkdownForPlatform(VARS, "kubernetes")).toBe(fallback);
+  });
+
+  test("survives the placeholder URL the card uses when HOST is unset", () => {
+    const markdown: string = getCloudDocMarkdownForPlatform(
+      { oneuptimeUrl: "<YOUR_ONEUPTIME_URL>", apiKey: "<YOUR_API_KEY>" },
+      ManagedCloudPlatform.AwsEcs,
+    );
+
+    expect(markdown).toContain("<YOUR_ONEUPTIME_URL>/otlp");
+    expect(markdown).toContain("<YOUR_API_KEY>");
+  });
+
+  test("AWS ECS: sidecar with container metrics, Secrets Manager, detector and egress", () => {
+    const ecs: string = getCloudDocMarkdownForPlatform(
+      VARS,
+      ManagedCloudPlatform.AwsEcs,
+    );
+
+    expect(ecs).toContain("awsecscontainermetrics");
+    expect(ecs).toContain("detectors: [env, ecs]");
+    expect(ecs).toContain("secretsmanager:GetSecretValue");
+    expect(ecs).toContain("--config=env:OTEL_COLLECTOR_CONFIG");
+    expect(ecs).toContain("${env:ONEUPTIME_TOKEN}");
+    expect(ecs).toContain("http://localhost:4318");
+    expect(ecs).toContain("assignPublicIp=ENABLED");
+    expect(ecs).toContain("TCP 443 to `oneuptime.example.test`");
+    expect(ecs).toContain("OTEL_NODE_RESOURCE_DETECTORS=env,host,os,aws");
+  });
+
+  test("Cloud Run: secretAccessor, the gcp detector, container dependencies and the Serverless overlap", () => {
+    const run: string = getCloudDocMarkdownForPlatform(
+      VARS,
+      ManagedCloudPlatform.GcpCloudRun,
+    );
+
+    expect(run).toContain("roles/secretmanager.secretAccessor");
+    expect(run).toContain("detectors: [env, gcp]");
+    expect(run).toContain("container-dependencies");
+    expect(run).toContain("Serverless");
+    expect(run).toContain("Cloud NAT");
+  });
+
+  test("Container Apps: explicit attributes, replica name, az CLI and the managed agent", () => {
+    const aca: string = getCloudDocMarkdownForPlatform(
+      VARS,
+      ManagedCloudPlatform.AzureContainerApps,
+    );
+
+    expect(aca).toContain("az containerapp secret set");
+    expect(aca).toContain("--set-env-vars");
+    expect(aca).toContain("secretref:");
+    expect(aca).toContain("CONTAINER_APP_REPLICA_NAME");
+    expect(aca).toContain("detectors: [env, azurecontainerapps]");
+    expect(aca).toContain("override: false");
+    expect(aca).toContain("`azure.container_app.instance.id`");
+    /* The managed agent is gRPC-only, so it targets the host on 443, not /otlp. */
+    expect(aca).toContain(":443");
+    expect(aca).toContain(
+      "cloud.provider=azure,cloud.platform=azure_container_apps,cloud.region=",
+    );
+    expect(aca).toContain("az containerapp env telemetry otlp add");
+  });
+});
+
+describe("getCloudDocMarkdown", () => {
+  test("is the AWS ECS guide plus a one-line pointer to the other platforms", () => {
+    const legacy: string = getCloudDocMarkdown(VARS);
+    const ecs: string = getCloudDocMarkdownForPlatform(
+      VARS,
+      ManagedCloudPlatform.AwsEcs,
+    );
+
+    expect(DEFAULT_CLOUD_DOC_PLATFORM).toBe(ManagedCloudPlatform.AwsEcs);
+    expect(legacy.startsWith(ecs)).toBe(true);
+    expect(legacy.slice(ecs.length)).toBe(
+      `\n\n${CLOUD_DOC_OTHER_PLATFORMS_POINTER}`,
+    );
+    expect(CLOUD_DOC_OTHER_PLATFORMS_POINTER).not.toContain("\n");
+    expect(CLOUD_DOC_OTHER_PLATFORMS_POINTER).toContain(
+      "/docs/telemetry/cloud-environments",
+    );
+  });
+
+  test("the pointer names every platform that is not the default", () => {
+    for (const descriptor of MANAGED_CLOUD_PLATFORMS) {
+      if (descriptor.platform === DEFAULT_CLOUD_DOC_PLATFORM) {
+        continue;
+      }
+
+      const shortName: string = descriptor.productName
+        .replace(/^(AWS|Google|Azure) /, "")
+        .replace(/^GCP /, "");
+
+      expect(CLOUD_DOC_OTHER_PLATFORMS_POINTER).toContain(shortName);
+    }
+  });
+
+  test("the default platform has a registry descriptor", () => {
+    expect(
+      getManagedCloudPlatformDescriptor(DEFAULT_CLOUD_DOC_PLATFORM),
+    ).not.toBeNull();
+  });
+});

package/Tests/App/Dashboard/CloudFleetSummary.test.ts

@@ -0,0 +1,183 @@
+import { describe, expect, test } from "@jest/globals";
+import {
+  CloudFleetCounts,
+  CloudFleetSummaryTile,
+  describeProviderBreakdown,
+  summarizeCloudFleet,
+} from "../../../../App/FeatureSet/Dashboard/src/Pages/Cloud/Utils/CloudFleetSummary";
+
+/*
+ * The stat strip's wording lives in a pure function so it can be checked
+ * without a renderer. The tiles are positional (the component pairs them
+ * with icons by index), so the order is part of the contract.
+ */
+
+function tileByTitle(
+  tiles: Array<CloudFleetSummaryTile>,
+  title: string,
+): CloudFleetSummaryTile {
+  const tile: CloudFleetSummaryTile | undefined = tiles.find(
+    (candidate: CloudFleetSummaryTile): boolean => {
+      return candidate.title === title;
+    },
+  );
+  if (!tile) {
+    throw new Error(`No tile titled "${title}"`);
+  }
+  return tile;
+}
+
+describe("summarizeCloudFleet", () => {
+  test("returns four tiles in a fixed order", () => {
+    const tiles: Array<CloudFleetSummaryTile> = summarizeCloudFleet({
+      total: 0,
+      connected: 0,
+      disconnected: 0,
+      byProvider: {},
+      liveInstances: 0,
+    });
+
+    expect(
+      tiles.map((tile: CloudFleetSummaryTile): string => {
+        return tile.title;
+      }),
+    ).toEqual(["Environments", "Connected", "Disconnected", "Live instances"]);
+  });
+
+  test("an empty fleet reads as empty rather than as a broken one", () => {
+    const tiles: Array<CloudFleetSummaryTile> = summarizeCloudFleet({
+      total: 0,
+      connected: 0,
+      disconnected: 0,
+      byProvider: {},
+      liveInstances: 0,
+    });
+
+    expect(tileByTitle(tiles, "Environments")).toEqual({
+      title: "Environments",
+      value: "0",
+      sublabel: "none discovered yet",
+    });
+    expect(tileByTitle(tiles, "Connected").value).toBe("0");
+    expect(tileByTitle(tiles, "Connected").sublabel).toBe(
+      "nothing reporting yet",
+    );
+    expect(tileByTitle(tiles, "Disconnected").value).toBe("0");
+    expect(tileByTitle(tiles, "Live instances")).toEqual({
+      title: "Live instances",
+      value: "0",
+      sublabel: "seen in the last 15 min",
+    });
+  });
+
+  test("a mixed fleet breaks the total down by provider, busiest first", () => {
+    const counts: CloudFleetCounts = {
+      total: 6,
+      connected: 4,
+      disconnected: 2,
+      byProvider: { aws: 3, gcp: 1, azure: 2 },
+      liveInstances: 17,
+    };
+
+    const tiles: Array<CloudFleetSummaryTile> = summarizeCloudFleet(counts);
+
+    expect(tileByTitle(tiles, "Environments")).toEqual({
+      title: "Environments",
+      value: "6",
+      sublabel: "3 AWS · 2 Azure · 1 Google Cloud",
+    });
+    expect(tileByTitle(tiles, "Connected")).toEqual({
+      title: "Connected",
+      value: "4",
+      sublabel: "67% of environments",
+    });
+    expect(tileByTitle(tiles, "Disconnected")).toEqual({
+      title: "Disconnected",
+      value: "2",
+      sublabel: "no telemetry recently",
+    });
+    expect(tileByTitle(tiles, "Live instances").value).toBe("17");
+  });
+
+  test("an all-disconnected fleet says so without pretending anything is live", () => {
+    const tiles: Array<CloudFleetSummaryTile> = summarizeCloudFleet({
+      total: 3,
+      connected: 0,
+      disconnected: 3,
+      byProvider: { aws: 3 },
+      liveInstances: 0,
+    });
+
+    expect(tileByTitle(tiles, "Connected")).toEqual({
+      title: "Connected",
+      value: "0",
+      sublabel: "0% of environments",
+    });
+    expect(tileByTitle(tiles, "Disconnected")).toEqual({
+      title: "Disconnected",
+      value: "3",
+      sublabel: "no telemetry recently",
+    });
+    expect(tileByTitle(tiles, "Environments").sublabel).toBe("3 AWS");
+  });
+
+  test("a fully connected fleet celebrates instead of showing a zero warning", () => {
+    const tiles: Array<CloudFleetSummaryTile> = summarizeCloudFleet({
+      total: 2,
+      connected: 2,
+      disconnected: 0,
+      byProvider: { gcp: 2 },
+      liveInstances: 5,
+    });
+
+    expect(tileByTitle(tiles, "Connected").sublabel).toBe(
+      "100% of environments",
+    );
+    expect(tileByTitle(tiles, "Disconnected").sublabel).toBe(
+      "every environment is reporting",
+    );
+  });
+
+  test("never shows negative or over-100% numbers when counts arrive inconsistent", () => {
+    /*
+     * The six counts are separate requests; a create between two of them
+     * can make "connected" exceed "total" for one refresh.
+     */
+    const tiles: Array<CloudFleetSummaryTile> = summarizeCloudFleet({
+      total: 1,
+      connected: 2,
+      disconnected: -1,
+      byProvider: {},
+      liveInstances: -3,
+    });
+
+    expect(tileByTitle(tiles, "Connected").value).toBe("1");
+    expect(tileByTitle(tiles, "Connected").sublabel).toBe(
+      "100% of environments",
+    );
+    expect(tileByTitle(tiles, "Disconnected").value).toBe("0");
+    expect(tileByTitle(tiles, "Live instances").value).toBe("0");
+  });
+});
+
+describe("describeProviderBreakdown", () => {
+  test("uses the shared provider labels and drops zero counts", () => {
+    expect(describeProviderBreakdown({ aws: 0, gcp: 2, azure: 0 })).toBe(
+      "2 Google Cloud",
+    );
+  });
+
+  test("orders by count, then by label, so refreshes do not reshuffle", () => {
+    expect(describeProviderBreakdown({ azure: 2, aws: 2, gcp: 5 })).toBe(
+      "5 Google Cloud · 2 AWS · 2 Azure",
+    );
+  });
+
+  test("falls back to the raw value for a provider it has no label for", () => {
+    expect(describeProviderBreakdown({ oracle: 1 })).toBe("1 oracle");
+  });
+
+  test("is empty when nothing has a count", () => {
+    expect(describeProviderBreakdown({})).toBe("");
+  });
+});

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

@@ -0,0 +1,248 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import "@testing-library/jest-dom";
+import { cleanup, render, screen, waitFor } from "@testing-library/react";
+import * as React from "react";
+
+/*
+ * ModelAPI is the only thing between the strip and the network. Stubbed
+ * inline because jest.mock is hoisted above the imports — a helper module
+ * would not be initialised when the factory runs. Names carry the "mock"
+ * prefix jest requires of anything a hoisted factory closes over.
+ */
+interface CountRequest {
+  modelType: { name: string };
+  query: Record<string, unknown>;
+}
+
+const mockCountCalls: Array<CountRequest> = [];
+
+let mockCountResponse: (
+  request: CountRequest,
+) => Promise<number> = (): Promise<number> => {
+  return Promise.resolve(0);
+};
+
+jest.mock("../../../UI/Utils/ModelAPI/ModelAPI", () => {
+  return {
+    __esModule: true,
+    default: {
+      count: (request: CountRequest): Promise<number> => {
+        mockCountCalls.push(request);
+        return mockCountResponse(request);
+      },
+    },
+  };
+});
+
+import CloudFleetSummary from "../../../../App/FeatureSet/Dashboard/src/Components/Cloud/CloudFleetSummary";
+import GreaterThan from "../../../Types/BaseDatabase/GreaterThan";
+
+/*
+ * Answers each of the six count requests from what it asks for, so the
+ * test describes a fleet rather than a call order.
+ */
+function fleet(counts: {
+  total: number;
+  connected: number;
+  byProvider: Record<string, number>;
+  liveInstances: number;
+}): (request: CountRequest) => Promise<number> {
+  return (request: CountRequest): Promise<number> => {
+    if (request.modelType.name === "CloudResourceInstance") {
+      return Promise.resolve(counts.liveInstances);
+    }
+    if (request.query["otelCollectorStatus"] === "connected") {
+      return Promise.resolve(counts.connected);
+    }
+    if (typeof request.query["cloudProvider"] === "string") {
+      return Promise.resolve(
+        counts.byProvider[request.query["cloudProvider"] as string] || 0,
+      );
+    }
+    return Promise.resolve(counts.total);
+  };
+}
+
+beforeEach(() => {
+  mockCountCalls.length = 0;
+  mockCountResponse = fleet({
+    total: 0,
+    connected: 0,
+    byProvider: {},
+    liveInstances: 0,
+  });
+});
+
+afterEach(() => {
+  cleanup();
+});
+
+describe("CloudFleetSummary", () => {
+  test("renders one tile per summary entry from the counts it fetched", async () => {
+    mockCountResponse = fleet({
+      total: 5,
+      connected: 3,
+      byProvider: { aws: 4, gcp: 1 },
+      liveInstances: 12,
+    });
+
+    render(<CloudFleetSummary />);
+
+    await waitFor(() => {
+      expect(screen.getByTestId("cloud-fleet-summary")).toBeInTheDocument();
+    });
+
+    expect(screen.getAllByTestId("cloud-fleet-summary-tile")).toHaveLength(4);
+
+    expect(screen.getByText("Environments")).toBeInTheDocument();
+    expect(screen.getByText("5")).toBeInTheDocument();
+    expect(screen.getByText("4 AWS · 1 Google Cloud")).toBeInTheDocument();
+
+    expect(screen.getByText("Connected")).toBeInTheDocument();
+    expect(screen.getByText("3")).toBeInTheDocument();
+    expect(screen.getByText("60% of environments")).toBeInTheDocument();
+
+    // Disconnected is derived: total - connected, never a seventh request.
+    expect(screen.getByText("Disconnected")).toBeInTheDocument();
+    expect(screen.getByText("2")).toBeInTheDocument();
+
+    expect(screen.getByText("Live instances")).toBeInTheDocument();
+    expect(screen.getByText("12")).toBeInTheDocument();
+    expect(screen.getByText("seen in the last 15 min")).toBeInTheDocument();
+  });
+
+  test("issues at most six count requests, all scoped to unarchived rows", async () => {
+    mockCountResponse = fleet({
+      total: 1,
+      connected: 1,
+      byProvider: { azure: 1 },
+      liveInstances: 0,
+    });
+
+    render(<CloudFleetSummary />);
+
+    await waitFor(() => {
+      expect(screen.getByTestId("cloud-fleet-summary")).toBeInTheDocument();
+    });
+
+    expect(mockCountCalls.length).toBeLessThanOrEqual(6);
+
+    const environmentCounts: Array<CountRequest> = mockCountCalls.filter(
+      (request: CountRequest): boolean => {
+        return request.modelType.name === "CloudResource";
+      },
+    );
+    const instanceCounts: Array<CountRequest> = mockCountCalls.filter(
+      (request: CountRequest): boolean => {
+        return request.modelType.name === "CloudResourceInstance";
+      },
+    );
+
+    // total, connected, and one per provider (aws, gcp, azure).
+    expect(environmentCounts).toHaveLength(5);
+    for (const request of environmentCounts) {
+      expect(request.query["isArchived"]).toBe(false);
+    }
+    expect(
+      environmentCounts
+        .map((request: CountRequest): unknown => {
+          return request.query["cloudProvider"];
+        })
+        .filter(Boolean)
+        .sort(),
+    ).toEqual(["aws", "azure", "gcp"]);
+
+    /*
+     * The live-instance count has to be a lower bound on lastSeenAt; a
+     * plain equality or no filter would count every row ever written.
+     */
+    expect(instanceCounts).toHaveLength(1);
+    const lastSeenAt: unknown = instanceCounts[0]!.query["lastSeenAt"];
+    expect(lastSeenAt).toBeInstanceOf(GreaterThan);
+    const since: Date = (lastSeenAt as GreaterThan<Date>).value;
+    const ageInMinutes: number = (Date.now() - since.getTime()) / 60000;
+    expect(ageInMinutes).toBeGreaterThan(14);
+    expect(ageInMinutes).toBeLessThan(16);
+  });
+
+  test("renders nothing while there are no environments to summarise", async () => {
+    mockCountResponse = fleet({
+      total: 0,
+      connected: 0,
+      byProvider: {},
+      liveInstances: 0,
+    });
+
+    const { container } = render(<CloudFleetSummary />);
+
+    await waitFor(() => {
+      expect(mockCountCalls.length).toBeGreaterThan(0);
+    });
+
+    // Let the resolved promises settle before asserting on the absence.
+    await new Promise((resolve: (value: unknown) => void): void => {
+      setTimeout(resolve, 0);
+    });
+
+    expect(screen.queryByTestId("cloud-fleet-summary")).not.toBeInTheDocument();
+    expect(container).toBeEmptyDOMElement();
+  });
+
+  test("renders nothing, and does not throw, when a count fails", async () => {
+    mockCountResponse = (): Promise<number> => {
+      return Promise.reject(new Error("network down"));
+    };
+
+    const { container } = render(<CloudFleetSummary />);
+
+    await waitFor(() => {
+      expect(mockCountCalls.length).toBeGreaterThan(0);
+    });
+
+    await new Promise((resolve: (value: unknown) => void): void => {
+      setTimeout(resolve, 0);
+    });
+
+    expect(screen.queryByTestId("cloud-fleet-summary")).not.toBeInTheDocument();
+    expect(container).toBeEmptyDOMElement();
+  });
+
+  test("refetches when the refresh token changes", async () => {
+    mockCountResponse = fleet({
+      total: 1,
+      connected: 1,
+      byProvider: { aws: 1 },
+      liveInstances: 0,
+    });
+
+    const { rerender } = render(<CloudFleetSummary refreshToken={1} />);
+
+    await waitFor(() => {
+      expect(screen.getByTestId("cloud-fleet-summary")).toBeInTheDocument();
+    });
+
+    const callsAfterFirstLoad: number = mockCountCalls.length;
+
+    mockCountResponse = fleet({
+      total: 2,
+      connected: 2,
+      byProvider: { aws: 2 },
+      liveInstances: 0,
+    });
+
+    rerender(<CloudFleetSummary refreshToken={2} />);
+
+    await waitFor(() => {
+      expect(screen.getByText("2 AWS")).toBeInTheDocument();
+    });
+
+    expect(mockCountCalls.length).toBeGreaterThan(callsAfterFirstLoad);
+  });
+});