@oneuptime/common 13.0.5 → 13.0.7

package/Tests/UI/Rum/ReplayTimeline.test.tsx

@@ -696,6 +696,228 @@ describe("ReplayTimeline activity lane", () => {
 
     expect(screen.getByTestId("timeline-activity").children).toHaveLength(2);
   });
+
+  /*
+   * A 10px label on its own row cost more height than the strip it named,
+   * for a lane nobody reads as a value - it is a shape you glance at to
+   * find where the session got busy. The word survives as an sr-only
+   * label in the gutter and as the strip's tooltip; what is DRAWN is a
+   * hairline sitting directly on top of the track it belongs to.
+   */
+  it("draws the strip as a hairline over the track with no labelled row of its own", () => {
+    render(
+      <ReplayTimeline
+        {...makeProps({
+          activity: [
+            {
+              chunkIndex: 0,
+              startMs: 0,
+              endMs: 15000,
+              intensity: 1,
+              isMeasured: true,
+            },
+          ],
+        })}
+      />,
+    );
+
+    const strip: HTMLElement = screen.getByTestId("timeline-activity");
+
+    expect(strip.className).toContain("h-1");
+    expect(strip.className).not.toContain("h-1.5");
+    expect(strip.getAttribute("title")).toContain("Activity");
+    expect(strip.parentElement?.className).toContain("mb-1");
+    expect(strip.parentElement?.className).not.toContain("mb-2");
+
+    /* Still named, even though the row draws no visible label. */
+    const label: HTMLElement = screen.getByText("Activity");
+
+    expect(label.className).toContain("sr-only");
+    expect(strip.parentElement).toContainElement(label);
+  });
+});
+
+/*
+ * The three marker lanes plus the legend are the tallest part of the
+ * timeline, and the player's stage is whatever height is left in the
+ * card. `showLanes` is how the shell hands that height back - it is a
+ * persisted view preference, so the default has to stay "shown" for every
+ * caller that does not know about it.
+ */
+describe("ReplayTimeline lanes", () => {
+  const laneMarkers: Array<ReplayTimelineMarker> = buildExactMarkers([
+    signal({
+      id: "rec:1:3",
+      kind: "client-error",
+      severity: "error",
+      offsetMs: 30000,
+      title: "TypeError: boom",
+    }),
+  ]);
+
+  const notice: ReplayTimelineMarker = {
+    id: "notice:snapshot-too-large",
+    lane: "track",
+    offsetMs: 90000,
+    kind: "notice",
+    severity: "warn",
+    title: "1:30 Snapshot too large - a stretch may be unplayable",
+    tone: "gray",
+    fidelity: "exact",
+    isHollow: false,
+  };
+
+  it("shows the three lanes and the legend when nothing says otherwise", () => {
+    render(<ReplayTimeline {...makeProps({ markers: laneMarkers })} />);
+
+    expect(screen.getByTestId("timeline-lane-errors")).toBeInTheDocument();
+    expect(screen.getByTestId("timeline-lane-network")).toBeInTheDocument();
+    expect(screen.getByTestId("timeline-lane-navigation")).toBeInTheDocument();
+    expect(screen.getByTestId("timeline-legend")).toBeInTheDocument();
+    expect(screen.getByTestId("timeline-marker")).toBeInTheDocument();
+  });
+
+  it("shows them for an explicit showLanes", () => {
+    render(
+      <ReplayTimeline
+        {...makeProps({ markers: laneMarkers, showLanes: true })}
+      />,
+    );
+
+    expect(screen.getByTestId("timeline-lane-errors")).toBeInTheDocument();
+    expect(screen.getByTestId("timeline-legend")).toBeInTheDocument();
+  });
+
+  it("hides the lanes, their markers and the legend when showLanes is false", () => {
+    render(
+      <ReplayTimeline
+        {...makeProps({ markers: laneMarkers, showLanes: false })}
+      />,
+    );
+
+    expect(screen.queryByTestId("timeline-lane-errors")).toBeNull();
+    expect(screen.queryByTestId("timeline-lane-network")).toBeNull();
+    expect(screen.queryByTestId("timeline-lane-navigation")).toBeNull();
+    expect(screen.queryByTestId("timeline-legend")).toBeNull();
+    expect(screen.queryAllByTestId("timeline-marker")).toHaveLength(0);
+    expect(screen.queryAllByTestId("timeline-marker-cluster")).toHaveLength(0);
+  });
+
+  /*
+   * A notice is not a lane: it says a stretch of the RECORDING cannot be
+   * played, which is the one thing a viewer must not be able to switch
+   * off by tidying the timeline. It stays on the track, and it still
+   * seeks a second early.
+   */
+  it("keeps the track, its bands and its notice markers with the lanes hidden", () => {
+    const seeks: Array<number> = [];
+
+    render(
+      <ReplayTimeline
+        {...makeProps({
+          showLanes: false,
+          markers: [...laneMarkers, notice],
+          bands: [
+            { kind: "gap", startMs: 0, endMs: 60000, label: "1m missing" },
+          ],
+          activity: [
+            {
+              chunkIndex: 0,
+              startMs: 0,
+              endMs: 15000,
+              intensity: 1,
+              isMeasured: true,
+            },
+          ],
+          onSeek: (offsetMs: number): void => {
+            seeks.push(offsetMs);
+          },
+        })}
+      />,
+    );
+
+    expect(screen.getByTestId("timeline-track")).toBeInTheDocument();
+    expect(screen.getByTestId("timeline-playhead")).toBeInTheDocument();
+    expect(screen.getByTestId("timeline-gap-band")).toBeInTheDocument();
+    expect(screen.getByTestId("timeline-activity")).toBeInTheDocument();
+
+    fireEvent.click(screen.getByTestId("timeline-notice-marker"));
+
+    expect(seeks).toEqual([89000]);
+  });
+
+  it("still seeks from the track while the lanes are hidden", () => {
+    const seeks: Array<number> = [];
+
+    render(
+      <ReplayTimeline
+        {...makeProps({
+          showLanes: false,
+          onSeek: (offsetMs: number): void => {
+            seeks.push(offsetMs);
+          },
+        })}
+      />,
+    );
+
+    const track: HTMLElement = getTrack();
+
+    firePointer(track, "pointerdown", 250);
+    firePointer(track, "pointerup", 250);
+
+    expect(seeks).toEqual([0.25 * DURATION_MS]);
+  });
+});
+
+/*
+ * The heights below are a budget, not a taste: the stage is what is left
+ * of the player card after this strip, so every row here is as short as
+ * it can be while staying a usable target. The label gutter and the
+ * legend's indent are ONE measurement (4rem + the 0.5rem gap = 4.5rem)
+ * and drift apart the moment somebody changes only one of them.
+ */
+describe("ReplayTimeline compact chrome", () => {
+  it("draws a 28px track and 16px lanes with a half-step between them", () => {
+    render(<ReplayTimeline {...makeProps()} />);
+
+    expect(screen.getByTestId("timeline-track").className).toContain("h-7");
+    expect(screen.getByTestId("timeline-track").className).not.toContain("h-8");
+
+    const errorsLane: HTMLElement = screen.getByTestId("timeline-lane-errors");
+
+    expect(errorsLane.className).toContain("h-4");
+    expect(errorsLane.className).not.toContain("h-5");
+
+    /* lane div -> the label+lane row -> the lanes wrapper. */
+    const lanesWrapper: HTMLElement | null | undefined =
+      errorsLane.parentElement?.parentElement;
+
+    expect(lanesWrapper?.className).toContain("mt-1.5");
+    expect(lanesWrapper?.className).toContain("space-y-0.5");
+  });
+
+  it("indents the legend by exactly the label gutter plus the gap", () => {
+    render(<ReplayTimeline {...makeProps()} />);
+
+    const legend: HTMLElement = screen.getByTestId("timeline-legend");
+
+    expect(screen.getByText("Recording").className).toContain("w-16");
+    expect(legend.className).toContain("pl-[4.5rem]");
+    expect(legend.className).not.toContain("pl-[5.5rem]");
+    /* Still one reserved line, so the lanes do not jump on hover. */
+    expect(legend.className).toContain("min-h-4");
+    expect(legend.className).toContain("mt-1.5");
+  });
+
+  it("names every lane in the gutter at the narrower width", () => {
+    render(<ReplayTimeline {...makeProps()} />);
+
+    ["Recording", "Errors", "Network", "Nav / clicks"].forEach(
+      (label: string): void => {
+        expect(screen.getByText(label).className).toContain("w-16");
+      },
+    );
+  });
 });
 
 /*

package/Tests/UI/Utils/DashboardStackingLayers.test.ts

@@ -69,8 +69,15 @@ function moreMenuZIndex(): number {
     "MoreMenu.tsx",
   );
 
+  /*
+   * The offset and the transform origin left this run when MoreMenu gained
+   * isOpeningUpwards: they are now `mt-2 origin-top-right` OR `bottom-full
+   * mb-2 origin-bottom-right`, appended per direction. The layer is not -
+   * it is the same for a menu whichever way it opens - so this anchors on
+   * the invariant part of the class list.
+   */
   const match: RegExpMatchArray | null = source.match(
-    /absolute right-0 z-(\d+) mt-2 w-56 origin-top-right/,
+    /absolute right-0 z-(\d+) w-56 rounded-lg/,
   );
 
   if (!match || match[1] === undefined) {

package/Tests/UI/Utils/RuleRunClient.test.ts

@@ -0,0 +1,303 @@
+import API from "../../../UI/Utils/API/API";
+import RuleRunClient, {
+  RuleRunOutcome,
+} from "../../../UI/Utils/Rules/RuleRunClient";
+import HTTPErrorResponse from "../../../Types/API/HTTPErrorResponse";
+import HTTPResponse from "../../../Types/API/HTTPResponse";
+import URL from "../../../Types/API/URL";
+import { JSONObject } from "../../../Types/JSON";
+import { RuleRunResult, RuleRunType } from "../../../Types/Rules/RuleRun";
+import { afterEach, describe, expect, it } from "@jest/globals";
+
+/*
+ * Contract under test - the dashboard half of "Run now".
+ *
+ * The server answers one bounded pass per request; this client is what turns
+ * passes into a run. What can go wrong here is invisible from the server:
+ * posting to the wrong route, sending the cursor back wrong (a run that loops
+ * on its first page, or skips the rest), trusting a cursor that never moves,
+ * sending the notify flag as anything but a real boolean, and reporting a run
+ * that failed half-way as if nothing had happened.
+ */
+
+const RULE_ID: string = "44444444-4444-4444-8444-444444444444";
+const CURSOR_1: string = "00000000-0000-4000-8000-000000000001";
+const CURSOR_2: string = "00000000-0000-4000-8000-000000000002";
+
+interface PostArgs {
+  url: URL;
+  data: JSONObject;
+  headers?: Record<string, string> | undefined;
+}
+
+function passBody(overrides: JSONObject = {}): JSONObject {
+  return {
+    resourcesEvaluated: 0,
+    resourcesMatched: 0,
+    resourcesUpdated: 0,
+    itemsAdded: 0,
+    itemsRemoved: 0,
+    resourcesFailed: 0,
+    nextCursor: null,
+    ownersNotified: false,
+    ...overrides,
+  };
+}
+
+function ok(body: JSONObject): HTTPResponse<JSONObject> {
+  return new HTTPResponse<JSONObject>(200, body, {});
+}
+
+function mockPostSequence(
+  responses: Array<HTTPResponse<JSONObject> | HTTPErrorResponse | Error>,
+): jest.SpyInstance {
+  const spy: jest.SpyInstance = jest.spyOn(API, "post");
+
+  for (const response of responses) {
+    if (response instanceof Error) {
+      spy.mockRejectedValueOnce(response as never);
+    } else {
+      spy.mockResolvedValueOnce(response as never);
+    }
+  }
+
+  return spy;
+}
+
+function postArgs(spy: jest.SpyInstance, index: number): PostArgs {
+  return (spy.mock.calls[index] as Array<unknown>)[0] as PostArgs;
+}
+
+describe("RuleRunClient.getRunRoute", () => {
+  it("routes every rule type through one endpoint", () => {
+    expect(
+      RuleRunClient.getRunRoute({
+        ruleType: RuleRunType.IncidentOwnerRule,
+        ruleId: RULE_ID,
+      }),
+    ).toBe(`/rule-run/IncidentOwnerRule/${RULE_ID}/run`);
+  });
+});
+
+describe("RuleRunClient.run", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it("refuses to post for a rule with no id", async () => {
+    const spy: jest.SpyInstance = mockPostSequence([]);
+
+    const outcome: RuleRunOutcome = await RuleRunClient.run({
+      ruleType: RuleRunType.MonitorLabelRule,
+      ruleId: "",
+    });
+
+    expect(outcome.isSuccess).toBe(false);
+    expect(outcome.message).toBe("This rule has no id, so it cannot be run.");
+    expect(outcome.result).toBeNull();
+    expect(spy).not.toHaveBeenCalled();
+  });
+
+  it("runs a single-pass rule and reports it", async () => {
+    const spy: jest.SpyInstance = mockPostSequence([
+      ok(
+        passBody({
+          resourcesEvaluated: 40,
+          resourcesMatched: 12,
+          resourcesUpdated: 12,
+          itemsAdded: 24,
+        }),
+      ),
+    ]);
+
+    const outcome: RuleRunOutcome = await RuleRunClient.run({
+      ruleType: RuleRunType.MonitorLabelRule,
+      ruleId: RULE_ID,
+      headers: { tenantid: "project-1" },
+    });
+
+    expect(outcome.isSuccess).toBe(true);
+    expect(outcome.message).toBe(
+      "Added labels to 12 monitors (24 labels attached).",
+    );
+    expect(outcome.result?.passes).toBe(1);
+
+    const args: PostArgs = postArgs(spy, 0);
+    expect(args.url.toString()).toContain(
+      `/rule-run/MonitorLabelRule/${RULE_ID}/run`,
+    );
+    expect(args.data).toEqual({ notifyOwners: false });
+    expect(args.headers).toEqual({ tenantid: "project-1" });
+  });
+
+  it("sends notifyOwners only as a real boolean", async () => {
+    const spy: jest.SpyInstance = mockPostSequence([ok(passBody())]);
+
+    await RuleRunClient.run({
+      ruleType: RuleRunType.HostOwnerRule,
+      ruleId: RULE_ID,
+      notifyOwners: true,
+    });
+
+    expect(postArgs(spy, 0).data["notifyOwners"]).toBe(true);
+  });
+
+  it("chains passes by sending each cursor back, and sums what they did", async () => {
+    const progress: Array<RuleRunResult> = [];
+    const spy: jest.SpyInstance = mockPostSequence([
+      ok(
+        passBody({
+          resourcesEvaluated: 200,
+          resourcesMatched: 5,
+          resourcesUpdated: 5,
+          itemsAdded: 5,
+          nextCursor: CURSOR_1,
+        }),
+      ),
+      ok(
+        passBody({
+          resourcesEvaluated: 200,
+          resourcesMatched: 1,
+          resourcesUpdated: 1,
+          itemsAdded: 2,
+          nextCursor: CURSOR_2,
+        }),
+      ),
+      ok(passBody({ resourcesEvaluated: 13 })),
+    ]);
+
+    const outcome: RuleRunOutcome = await RuleRunClient.run({
+      ruleType: RuleRunType.IncidentLabelRule,
+      ruleId: RULE_ID,
+      onProgress: (result: RuleRunResult) => {
+        progress.push(result);
+      },
+    });
+
+    expect(spy).toHaveBeenCalledTimes(3);
+    expect(postArgs(spy, 0).data["cursor"]).toBeUndefined();
+    expect(postArgs(spy, 1).data["cursor"]).toBe(CURSOR_1);
+    expect(postArgs(spy, 2).data["cursor"]).toBe(CURSOR_2);
+
+    expect(outcome.isSuccess).toBe(true);
+    expect(outcome.result).toMatchObject({
+      resourcesEvaluated: 413,
+      resourcesMatched: 6,
+      resourcesUpdated: 6,
+      itemsAdded: 7,
+      passes: 3,
+      isTruncated: false,
+    });
+
+    // Progress is reported between passes, never for the last one.
+    expect(
+      progress.map((result: RuleRunResult): number => {
+        return result.resourcesEvaluated;
+      }),
+    ).toEqual([200, 400]);
+  });
+
+  it("stops at the pass cap and reports the run as unfinished", async () => {
+    const spy: jest.SpyInstance = mockPostSequence([
+      ok(passBody({ resourcesEvaluated: 200, nextCursor: CURSOR_1 })),
+      ok(passBody({ resourcesEvaluated: 200, nextCursor: CURSOR_2 })),
+    ]);
+
+    const outcome: RuleRunOutcome = await RuleRunClient.run({
+      ruleType: RuleRunType.MonitorLabelRule,
+      ruleId: RULE_ID,
+      maxPasses: 2,
+    });
+
+    expect(spy).toHaveBeenCalledTimes(2);
+    expect(outcome.isSuccess).toBe(true);
+    expect(outcome.result?.isTruncated).toBe(true);
+    expect(outcome.message).toContain("The run stopped after evaluating");
+  });
+
+  it("does not loop on a cursor that does not move", async () => {
+    const spy: jest.SpyInstance = mockPostSequence([
+      ok(passBody({ resourcesEvaluated: 200, nextCursor: CURSOR_1 })),
+      ok(passBody({ resourcesEvaluated: 200, nextCursor: CURSOR_1 })),
+      ok(passBody({ resourcesEvaluated: 200, nextCursor: CURSOR_1 })),
+    ]);
+
+    const outcome: RuleRunOutcome = await RuleRunClient.run({
+      ruleType: RuleRunType.MonitorLabelRule,
+      ruleId: RULE_ID,
+    });
+
+    expect(spy).toHaveBeenCalledTimes(2);
+    expect(outcome.result?.isTruncated).toBe(true);
+  });
+
+  it("ends the run on a malformed cursor rather than posting it back", async () => {
+    const spy: jest.SpyInstance = mockPostSequence([
+      ok(passBody({ resourcesEvaluated: 5, nextCursor: "page-2" })),
+    ]);
+
+    const outcome: RuleRunOutcome = await RuleRunClient.run({
+      ruleType: RuleRunType.MonitorLabelRule,
+      ruleId: RULE_ID,
+    });
+
+    expect(spy).toHaveBeenCalledTimes(1);
+    expect(outcome.isSuccess).toBe(true);
+    expect(outcome.result?.isTruncated).toBe(false);
+  });
+
+  it("turns a refused first pass into the server's message", async () => {
+    mockPostSequence([
+      new HTTPErrorResponse(
+        400,
+        { message: "This rule is disabled. Enable it before running it." },
+        {},
+      ),
+    ]);
+
+    const outcome: RuleRunOutcome = await RuleRunClient.run({
+      ruleType: RuleRunType.MonitorLabelRule,
+      ruleId: RULE_ID,
+    });
+
+    expect(outcome.isSuccess).toBe(false);
+    expect(outcome.message).toBe(
+      "This rule is disabled. Enable it before running it.",
+    );
+    expect(outcome.result).toBeNull();
+  });
+
+  /*
+   * Earlier passes really changed resources. Hiding that behind "failed"
+   * invites a re-run that then appears to do nothing.
+   */
+  it("reports what a run that failed part-way had already done", async () => {
+    mockPostSequence([
+      ok(
+        passBody({
+          resourcesEvaluated: 200,
+          resourcesMatched: 4,
+          resourcesUpdated: 4,
+          itemsAdded: 4,
+          nextCursor: CURSOR_1,
+        }),
+      ),
+      new Error("Network request failed"),
+    ]);
+
+    const outcome: RuleRunOutcome = await RuleRunClient.run({
+      ruleType: RuleRunType.MonitorLabelRule,
+      ruleId: RULE_ID,
+    });
+
+    expect(outcome.isSuccess).toBe(false);
+    expect(outcome.message).toContain("The run stopped part-way.");
+    expect(outcome.message).toContain(
+      "Added labels to 4 monitors (4 labels attached).",
+    );
+    expect(outcome.result).toMatchObject({
+      resourcesUpdated: 4,
+      passes: 1,
+    });
+  });
+});

package/Tests/UI/Utils/Telemetry/TelemetryEntityNames.test.ts

@@ -397,6 +397,7 @@ describe("getTelemetryEntityTypeLabel", () => {
     [ServiceType.Incident, "Incident"],
     [ServiceType.Alert, "Alert"],
     [ServiceType.ScheduledMaintenance, "Scheduled Maintenance"],
+    [ServiceType.ServiceLevelObjective, "SLO"],
     [ServiceType.Unknown, "Service"],
   ])("%s -> %s", (type: ServiceType, label: string) => {
     expect(getTelemetryEntityTypeLabel(type)).toBe(label);

package/Tests/Utils/API.test.ts

@@ -11,6 +11,9 @@ import APIException from "../../Types/Exception/ApiException";
 import BadDataException from "../../Types/Exception/BadDataException";
 import GenericObject from "../../Types/GenericObject";
 import { JSONObject } from "../../Types/JSON";
+import RequestFailedDetails, {
+  RequestFailedPhase,
+} from "../../Types/Probe/RequestFailedDetails";
 import API from "../../Utils/API";
 import { HTTPResponseBodyBudget } from "../../Utils/HTTPResponseBodyReader";
 import { expect, jest } from "@jest/globals";
@@ -494,6 +497,46 @@ describe("API.getFriendlyErrorMessage", () => {
   });
 });
 
+describe("API.getRequestFailedDetails", () => {
+  test.each([
+    { code: "ETIMEDOUT", failedPhase: RequestFailedPhase.RequestTimeout },
+    { code: "ESOCKETTIMEDOUT", failedPhase: RequestFailedPhase.RequestTimeout },
+    { code: "ECONNABORTED", failedPhase: RequestFailedPhase.RequestAborted },
+  ])(
+    "classifies native $code errors without relying on message text",
+    (scenario: { code: string; failedPhase: RequestFailedPhase }) => {
+      const error: NodeJS.ErrnoException = new Error("The operation failed.");
+      error.code = scenario.code;
+
+      const details: RequestFailedDetails = API.getRequestFailedDetails(error);
+
+      expect(details.errorCode).toBe(scenario.code);
+      expect(details.failedPhase).toBe(scenario.failedPhase);
+      expect(details.rawErrorMessage).toBe(error.message);
+    },
+  );
+
+  test.each([
+    { code: 408 },
+    { code: null },
+    { code: {} },
+    { code: ["ETIMEDOUT"] },
+  ])(
+    "ignores a non-string native error code: $code",
+    (scenario: { code: unknown }) => {
+      const error: Error & { code: unknown } = Object.assign(
+        new Error("The operation failed."),
+        { code: scenario.code },
+      );
+
+      const details: RequestFailedDetails = API.getRequestFailedDetails(error);
+
+      expect(details.errorCode).toBeUndefined();
+      expect(details.failedPhase).toBe(RequestFailedPhase.Unknown);
+    },
+  );
+});
+
 describe("API instance properties", () => {
   test("should return protocol with trailing slashes", () => {
     const api: API = new API(Protocol.HTTPS, new Hostname("example.com"));
@@ -637,6 +680,59 @@ describe("API.fetch with options", () => {
     expect(budget.remainingBytes).toBe(1024 - Buffer.byteLength(json));
   });
 
+  test.each([200, 400, 503])(
+    "should cancel a stalled status %s body even after Axios has settled",
+    async (status: number) => {
+      mockedAxios.mockClear();
+      HTTPErrorResponseMock.mockClear();
+      const controller: AbortController = new AbortController();
+      let resolveReading: () => void = (): void => {};
+      const reading: Promise<void> = new Promise((resolve: () => void) => {
+        resolveReading = resolve;
+      });
+      const body: Readable = new Readable({
+        read: (): void => {
+          resolveReading();
+        },
+      });
+      const response: AxiosResponse = createAxiosResponse({
+        data: body,
+        status: status,
+      });
+      if (status >= 400) {
+        mockedAxios.mockRejectedValueOnce(
+          createAxiosError({ response: response }),
+        );
+      } else {
+        mockedAxios.mockResolvedValueOnce(response);
+      }
+
+      const pending: Promise<HTTPResponse<JSONObject>> = API.fetch({
+        method: HTTPMethod.GET,
+        url: new URL(
+          Protocol.HTTPS,
+          "api.example.com",
+          new Route("stalled-body"),
+        ),
+        options: {
+          signal: controller.signal,
+          responseBodyBudget: new HTTPResponseBodyBudget(100),
+        },
+      });
+      const rejected: Promise<void> = expect(pending).rejects.toThrow(
+        "Response body read was aborted",
+      );
+
+      await reading;
+      controller.abort();
+      await rejected;
+
+      expect(body.destroyed).toBe(true);
+      expect(mockedAxios).toHaveBeenCalledTimes(1);
+      expect(HTTPErrorResponseMock).not.toHaveBeenCalled();
+    },
+  );
+
   test("should strip a leading UTF-8 BOM before parsing a budgeted JSON stream", async () => {
     mockedAxios.mockClear();
     const bodyText: string = `\uFEFF${JSON.stringify(responseData)}`;

package/Tests/Utils/Dashboard/Components/DashboardComponentDefaults.test.ts

@@ -45,6 +45,7 @@ import DashboardProxmoxNodeListComponentUtil from "../../../../Utils/Dashboard/C
 import DashboardSecurityEventsFlowComponentUtil from "../../../../Utils/Dashboard/Components/DashboardSecurityEventsFlowComponent";
 import DashboardSecurityEventsListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardSecurityEventsListComponent";
 import DashboardSloComponentUtil from "../../../../Utils/Dashboard/Components/DashboardSloComponent";
+import DashboardSloListComponentUtil from "../../../../Utils/Dashboard/Components/DashboardSloListComponent";
 import DashboardTableComponentUtil from "../../../../Utils/Dashboard/Components/DashboardTableComponent";
 import DashboardTextComponentUtil from "../../../../Utils/Dashboard/Components/DashboardTextComponent";
 import DashboardTraceChartComponentUtil from "../../../../Utils/Dashboard/Components/DashboardTraceChartComponent";
@@ -108,6 +109,7 @@ const TYPE_TO_UTIL: Record<DashboardComponentType, ComponentUtil> = {
   [DashboardComponentType.AlertList]: DashboardAlertListComponentUtil,
   [DashboardComponentType.MonitorList]: DashboardMonitorListComponentUtil,
   [DashboardComponentType.Slo]: DashboardSloComponentUtil,
+  [DashboardComponentType.SloList]: DashboardSloListComponentUtil,
   [DashboardComponentType.KubernetesPodList]:
     DashboardKubernetesPodListComponentUtil,
   [DashboardComponentType.KubernetesNodeList]: