@oneuptime/common 13.0.5 → 13.0.6

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

@@ -0,0 +1,200 @@
+import { JSONObject } from "../../../Types/JSON";
+import StatusPageSubscriberNotificationStatus from "../../../Types/StatusPage/StatusPageSubscriberNotificationStatus";
+import SubscriberNotificationTrigger from "../../../Types/StatusPage/SubscriberNotificationTrigger";
+import SubscriberUpdateNotification from "../../../Types/StatusPage/SubscriberUpdateNotification";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * Editing an announcement or a public note notifies status page subscribers
+ * only when the editor asks for it on that edit. The ask travels as a misc
+ * data prop, so this is the one place that decides what counts as asking -
+ * and a false positive here emails every subscriber of a status page.
+ */
+describe("SubscriberUpdateNotification.isRequested", () => {
+  test("uses a stable misc data key the dashboard and the API share", () => {
+    expect(SubscriberUpdateNotification.miscDataKey).toBe(
+      "notifySubscribersOfUpdate",
+    );
+  });
+
+  test("is true for the boolean the dashboard form sends", () => {
+    expect(
+      SubscriberUpdateNotification.isRequested({
+        notifySubscribersOfUpdate: true,
+      }),
+    ).toBe(true);
+  });
+
+  test('is true for the string "true" a hand-written API request may send', () => {
+    expect(
+      SubscriberUpdateNotification.isRequested({
+        notifySubscribersOfUpdate: "true",
+      }),
+    ).toBe(true);
+  });
+
+  test("round-trips the misc data props it builds", () => {
+    expect(
+      SubscriberUpdateNotification.isRequested(
+        SubscriberUpdateNotification.getMiscDataProps(),
+      ),
+    ).toBe(true);
+    expect(SubscriberUpdateNotification.getMiscDataProps()).toEqual({
+      notifySubscribersOfUpdate: true,
+    });
+  });
+
+  test("returns a fresh object each time so callers cannot share state", () => {
+    const first: JSONObject = SubscriberUpdateNotification.getMiscDataProps();
+    first["notifySubscribersOfUpdate"] = false;
+
+    expect(SubscriberUpdateNotification.getMiscDataProps()).toEqual({
+      notifySubscribersOfUpdate: true,
+    });
+  });
+
+  test.each([
+    ["false", false],
+    ['the string "false"', "false"],
+    ["the number 1", 1],
+    ['the string "1"', "1"],
+    ['the string "yes"', "yes"],
+    ['the string "TRUE"', "TRUE"],
+    ["null", null],
+    ["an object", { value: true }],
+    ["an array", [true]],
+    ["an empty string", ""],
+  ] as Array<[string, unknown]>)(
+    "is false when the flag is %s",
+    (_label: string, value: unknown) => {
+      expect(
+        SubscriberUpdateNotification.isRequested({
+          notifySubscribersOfUpdate: value,
+        } as JSONObject),
+      ).toBe(false);
+    },
+  );
+
+  test.each([
+    ["undefined", undefined],
+    ["null", null],
+    ["an empty object", {}],
+  ] as Array<[string, JSONObject | undefined | null]>)(
+    "is false when the misc data props are %s",
+    (_label: string, value: JSONObject | undefined | null) => {
+      expect(SubscriberUpdateNotification.isRequested(value)).toBe(false);
+    },
+  );
+
+  test("ignores other misc data props that happen to be true", () => {
+    expect(
+      SubscriberUpdateNotification.isRequested({
+        notifySubscribers: true,
+        shouldStatusPageSubscribersBeNotified: true,
+        notifySubscribersOnUpdate: true,
+      }),
+    ).toBe(false);
+  });
+
+  test("is false for a non-object value smuggled in as misc data props", () => {
+    expect(
+      SubscriberUpdateNotification.isRequested(
+        "notifySubscribersOfUpdate" as unknown as JSONObject,
+      ),
+    ).toBe(false);
+  });
+});
+
+describe("SubscriberUpdateNotification.getSkipReasonForOriginalNotificationStatus", () => {
+  test.each([
+    StatusPageSubscriberNotificationStatus.Pending,
+    StatusPageSubscriberNotificationStatus.InProgress,
+  ])(
+    "skips while the original notification is %s, because it will carry the edit",
+    (status: StatusPageSubscriberNotificationStatus) => {
+      expect(
+        SubscriberUpdateNotification.getSkipReasonForOriginalNotificationStatus(
+          status,
+        ),
+      ).toBe(SubscriberUpdateNotification.notYetNotifiedMessage);
+    },
+  );
+
+  test.each([
+    StatusPageSubscriberNotificationStatus.Success,
+    StatusPageSubscriberNotificationStatus.Skipped,
+    StatusPageSubscriberNotificationStatus.Failed,
+  ])(
+    "lets the update through once the original notification is %s",
+    (status: StatusPageSubscriberNotificationStatus) => {
+      expect(
+        SubscriberUpdateNotification.getSkipReasonForOriginalNotificationStatus(
+          status,
+        ),
+      ).toBeNull();
+    },
+  );
+
+  test.each([undefined, null])(
+    "lets the update through when the original status is %s (rows that predate status tracking)",
+    (status: undefined | null) => {
+      expect(
+        SubscriberUpdateNotification.getSkipReasonForOriginalNotificationStatus(
+          status,
+        ),
+      ).toBeNull();
+    },
+  );
+
+  test("every status has a decision, so a new status cannot silently fall through", () => {
+    for (const status of Object.values(
+      StatusPageSubscriberNotificationStatus,
+    )) {
+      const reason: string | null =
+        SubscriberUpdateNotification.getSkipReasonForOriginalNotificationStatus(
+          status,
+        );
+
+      expect(reason === null || typeof reason === "string").toBe(true);
+    }
+  });
+
+  test("the skip message explains why nothing was sent", () => {
+    expect(SubscriberUpdateNotification.notYetNotifiedMessage).toMatch(
+      /not been notified/i,
+    );
+    expect(SubscriberUpdateNotification.notYetNotifiedMessage).toMatch(
+      /latest content/i,
+    );
+  });
+});
+
+describe("SubscriberUpdateNotification copy", () => {
+  test("every message is non-empty user-facing text", () => {
+    for (const message of [
+      SubscriberUpdateNotification.queuedMessage,
+      SubscriberUpdateNotification.resendQueuedMessage,
+      SubscriberUpdateNotification.sentMessage,
+      SubscriberUpdateNotification.notYetNotifiedMessage,
+      SubscriberUpdateNotification.formFieldTitle,
+    ]) {
+      expect(message.trim().length).toBeGreaterThan(0);
+    }
+  });
+
+  test("the sent message is distinguishable from the original notification's", () => {
+    expect(SubscriberUpdateNotification.sentMessage).not.toBe(
+      "Notifications sent successfully to all subscribers",
+    );
+    expect(SubscriberUpdateNotification.sentMessage).toMatch(/update/i);
+  });
+});
+
+describe("SubscriberNotificationTrigger", () => {
+  test("has exactly the created and updated triggers", () => {
+    expect(Object.values(SubscriberNotificationTrigger).sort()).toEqual([
+      "Created",
+      "Updated",
+    ]);
+  });
+});

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

@@ -17,22 +17,31 @@ import {
 import React from "react";
 import ActiveFilterChips from "../../../UI/Components/LogsViewer/components/ActiveFilterChips";
 import { ActiveFilter } from "../../../UI/Components/LogsViewer/types";
-import { getLockedFilterChipAriaLabel } from "../../../UI/Components/TelemetryViewer/components/LockedFilterChip";
 import {
-  getCopyLockedFiltersAriaLabel,
-  getOpenExplorerAriaLabel,
-} from "../../../UI/Components/TelemetryViewer/components/LockedFilterActions";
+  NO_SEARCH_SYNTAX_REASON,
+  getLockedFilterChipAriaLabel,
+} from "../../../UI/Components/TelemetryViewer/components/LockedFilterChip";
 import Route from "../../../Types/API/Route";
 import Includes from "../../../Types/BaseDatabase/Includes";
 
 /*
- * The logs chip list, now that its read-only chips are LockedFilterChips: a
- * locked chip explains itself through its detail, the copy / open actions
- * follow the locked group, and everything the list already did — remove
- * buttons, "Clear all", the open-trace icon-link, the operator-value
- * backstop — is untouched.
+ * The logs chip list, now that its read-only chips are LockedFilterChips. A
+ * locked chip's tooltip shows the search syntax its detail carries, or the
+ * reason there is none. No "Copy filter" / "Open in …" actions follow the
+ * locked group. Everything the list already did — remove buttons, "Clear
+ * all", the open-trace icon-link, the operator-value backstop — is untouched.
  */
 
+const CLUSTER_SEARCH_TOKEN: string = "@resource.k8s.cluster.name:prod-eks-01";
+
+const TRACE_SEARCH_TOKEN: string = "trace:trace-1";
+
+/*
+ * The Dashboard's SESSION_NO_SYNTAX_REASON, spelled out here because a Common
+ * test cannot import from App. The chip shows whatever reason it is given.
+ */
+const SESSION_REASON: string = "Session filters have no search syntax.";
+
 beforeEach(() => {
   jest.useFakeTimers();
   Object.defineProperty(navigator, "clipboard", {
@@ -60,15 +69,7 @@ function lockedClusterChip(
     displayValue: "production",
     readOnly: true,
     lockedDetail: {
-      source: "Pinned by this page",
-      summary: "Only logs from this Kubernetes cluster are shown.",
-      predicates: [
-        {
-          label: "Attribute",
-          expression: 'resource.k8s.cluster.name = "prod-eks-01"',
-        },
-      ],
-      searchToken: "@resource.k8s.cluster.name:prod-eks-01",
+      searchToken: CLUSTER_SEARCH_TOKEN,
     },
     ...overrides,
   };
@@ -91,8 +92,19 @@ async function hover(trigger: HTMLElement): Promise<void> {
   });
 }
 
+function getClusterChip(hasSearchToken: boolean = true): HTMLElement {
+  return screen.getByRole("button", {
+    name: getLockedFilterChipAriaLabel("Cluster", "production", hasSearchToken),
+  });
+}
+
+// The search syntax the open tooltip shows, read from its token element.
+function getTooltipSearchToken(): string | null {
+  return screen.getByTestId("locked-filter-search-token").textContent;
+}
+
 describe("ActiveFilterChips — locked chips", () => {
-  test("a read-only chip renders as a locked chip: a named button, no remove control", () => {
+  test("a read-only chip renders as a locked chip: a named button, no remove control", async () => {
     render(
       <ActiveFilterChips
         filters={[lockedClusterChip()]}
@@ -101,16 +113,18 @@ describe("ActiveFilterChips — locked chips", () => {
       />,
     );
 
-    const chip: HTMLElement = screen.getByRole("button", {
-      name: getLockedFilterChipAriaLabel("Cluster", "production", true),
-    });
+    const chip: HTMLElement = getClusterChip();
 
     expect(chip).toHaveTextContent("Cluster:");
     expect(chip).toHaveTextContent("production");
     expect(screen.queryByTitle(/^Remove /)).not.toBeInTheDocument();
+
+    await hover(chip);
+
+    expect(getTooltipSearchToken()).toBe(CLUSTER_SEARCH_TOKEN);
   });
 
-  test("hovering the locked chip explains the filter", async () => {
+  test("hovering the locked chip shows only its search syntax", async () => {
     render(
       <ActiveFilterChips
         filters={[lockedClusterChip()]}
@@ -119,25 +133,73 @@ describe("ActiveFilterChips — locked chips", () => {
       />,
     );
 
-    await hover(
-      screen.getByRole("button", {
-        name: getLockedFilterChipAriaLabel("Cluster", "production", true),
-      }),
-    );
+    await hover(getClusterChip());
 
     const tooltip: HTMLElement = screen.getByRole("tooltip");
 
-    expect(tooltip).toHaveTextContent(
-      "Only logs from this Kubernetes cluster are shown.",
-    );
-    expect(tooltip).toHaveTextContent("@resource.k8s.cluster.name:prod-eks-01");
+    expect(tooltip).toHaveTextContent("Search syntax");
+    expect(getTooltipSearchToken()).toBe(CLUSTER_SEARCH_TOKEN);
     // The list is the logs list: it names its explorer without being told.
     expect(tooltip).toHaveTextContent(
       "Paste into the Logs explorer search bar.",
     );
+    // A chip with syntax shows that syntax, never a reason in its place.
+    expect(tooltip).not.toHaveTextContent(NO_SEARCH_SYNTAX_REASON);
+    expect(tooltip.textContent).toBe(
+      `Search syntax${CLUSTER_SEARCH_TOKEN}CopyPaste into the Logs explorer search bar.`,
+    );
+  });
+
+  test("a locked chip whose detail has no syntax shows its reason, with nothing to copy", async () => {
+    render(
+      <ActiveFilterChips
+        filters={[
+          lockedClusterChip({
+            lockedDetail: { searchTokenUnavailableReason: SESSION_REASON },
+          }),
+        ]}
+        onRemove={() => {}}
+        onClearAll={() => {}}
+      />,
+    );
+
+    // No syntax, so the chip's name does not offer Enter to copy.
+    await hover(getClusterChip(false));
+
+    const tooltip: HTMLElement = screen.getByRole("tooltip");
+
+    expect(tooltip.textContent).toBe(`Search syntax${SESSION_REASON}`);
+    expect(
+      screen.queryByTestId("locked-filter-search-token"),
+    ).not.toBeInTheDocument();
+    expect(
+      screen.queryByRole("button", { name: "Copy search syntax" }),
+    ).not.toBeInTheDocument();
   });
 
-  test("a read-only chip without a detail keeps the plain title", () => {
+  test("a locked chip whose detail names neither syntax nor a reason falls back to the default reason", async () => {
+    render(
+      <ActiveFilterChips
+        filters={[lockedClusterChip({ lockedDetail: {} })]}
+        onRemove={() => {}}
+        onClearAll={() => {}}
+      />,
+    );
+
+    await hover(getClusterChip(false));
+
+    expect(screen.getByRole("tooltip").textContent).toBe(
+      `Search syntax${NO_SEARCH_SYNTAX_REASON}`,
+    );
+    expect(
+      screen.queryByTestId("locked-filter-search-token"),
+    ).not.toBeInTheDocument();
+    expect(
+      screen.queryByRole("button", { name: "Copy search syntax" }),
+    ).not.toBeInTheDocument();
+  });
+
+  test("a read-only chip without a detail keeps the plain title and opens no tooltip", async () => {
     render(
       <ActiveFilterChips
         filters={[lockedClusterChip({ lockedDetail: undefined })]}
@@ -149,9 +211,17 @@ describe("ActiveFilterChips — locked chips", () => {
     expect(
       document.querySelector("[title='Cluster: production (applied filter)']"),
     ).not.toBeNull();
+
+    await hover(screen.getByTestId("locked-filter-chip"));
+
+    // No detail: neither a search token nor a reason to show.
+    expect(screen.queryByRole("tooltip")).not.toBeInTheDocument();
+    expect(
+      screen.queryByTestId("locked-filter-search-token"),
+    ).not.toBeInTheDocument();
   });
 
-  test("a read-only chip with an openRoute keeps its icon-link inside the pill", () => {
+  test("a read-only chip with an openRoute keeps its icon-link inside the pill", async () => {
     render(
       <ActiveFilterChips
         filters={[
@@ -161,6 +231,7 @@ describe("ActiveFilterChips — locked chips", () => {
             displayKey: "Trace",
             displayValue: "trace-1",
             openRoute: new Route("/traces/view/trace-1"),
+            lockedDetail: { searchToken: TRACE_SEARCH_TOKEN },
           }),
         ]}
         onRemove={() => {}}
@@ -180,6 +251,11 @@ describe("ActiveFilterChips — locked chips", () => {
     // Beside the chip's own control, never inside it.
     expect(control).not.toContainElement(link);
     expect(link).toHaveAttribute("href", "/traces/view/trace-1");
+
+    await hover(control);
+
+    // The link does not displace the tooltip: it still shows the chip's token.
+    expect(getTooltipSearchToken()).toBe(TRACE_SEARCH_TOKEN);
   });
 
   test("a read-only chip without a detail is not a tab stop and has no name of its own", () => {
@@ -226,90 +302,70 @@ describe("ActiveFilterChips — locked chips", () => {
   });
 });
 
-describe("ActiveFilterChips — locked filter actions", () => {
-  test("renders the actions after the locked chips and before the removable ones", () => {
+describe("ActiveFilterChips — no locked filter actions", () => {
+  test("renders no Copy filter or Open in … actions next to the locked chips", async () => {
     render(
       <ActiveFilterChips
-        filters={[removableChip(), lockedClusterChip()]}
+        filters={[lockedClusterChip(), removableChip()]}
         onRemove={() => {}}
         onClearAll={() => {}}
-        lockedFilterActions={{
-          copyText: "@resource.k8s.cluster.name:prod-eks-01",
-          openExplorerRoute: new Route("/dashboard/p1/logs?filters=x"),
-        }}
+        signal="logs"
       />,
     );
 
-    const locked: HTMLElement = screen.getByRole("button", {
-      name: getLockedFilterChipAriaLabel("Cluster", "production", true),
-    });
-    const actions: HTMLElement = screen.getByTestId("locked-filter-actions");
-    const remove: HTMLElement = screen.getByTitle("Remove Severity: Error");
-
-    expect(
-      locked.compareDocumentPosition(actions) &
-        Node.DOCUMENT_POSITION_FOLLOWING,
-    ).toBeTruthy();
     expect(
-      actions.compareDocumentPosition(remove) &
-        Node.DOCUMENT_POSITION_FOLLOWING,
-    ).toBeTruthy();
-
+      screen.queryByTestId("locked-filter-actions"),
+    ).not.toBeInTheDocument();
     expect(
-      screen.getByRole("button", {
-        name: getCopyLockedFiltersAriaLabel("Logs"),
-      }),
-    ).toBeInTheDocument();
+      screen.queryByRole("group", { name: "Locked filter actions" }),
+    ).not.toBeInTheDocument();
+    expect(screen.queryByText("Copy filter")).not.toBeInTheDocument();
+    expect(screen.queryByText(/^Open in /)).not.toBeInTheDocument();
     expect(
-      screen.getByRole("link", { name: getOpenExplorerAriaLabel("Logs") }),
-    ).toHaveAttribute("href", "/dashboard/p1/logs?filters=x");
-  });
+      screen.queryByRole("button", { name: /^Copy locked filters/ }),
+    ).not.toBeInTheDocument();
+    expect(screen.queryByRole("link")).not.toBeInTheDocument();
 
-  test("renders no actions when there is no locked chip, even if the host offers them", () => {
-    render(
-      <ActiveFilterChips
-        filters={[removableChip()]}
-        onRemove={() => {}}
-        onClearAll={() => {}}
-        lockedFilterActions={{ copyText: "@k:v" }}
-      />,
-    );
+    // The chip's own tooltip is where its search syntax lives now.
+    await hover(getClusterChip());
 
-    expect(
-      screen.queryByTestId("locked-filter-actions"),
-    ).not.toBeInTheDocument();
+    expect(getTooltipSearchToken()).toBe(CLUSTER_SEARCH_TOKEN);
   });
 
-  test("renders no actions when the host offers none", () => {
+  test("locked chips are followed directly by the removable ones", () => {
     render(
       <ActiveFilterChips
-        filters={[lockedClusterChip()]}
+        filters={[removableChip(), lockedClusterChip()]}
         onRemove={() => {}}
         onClearAll={() => {}}
       />,
     );
 
-    expect(
-      screen.queryByTestId("locked-filter-actions"),
-    ).not.toBeInTheDocument();
+    const pill: HTMLElement = screen.getByTestId("locked-filter-chip");
+    const remove: HTMLElement = screen.getByTitle("Remove Severity: Error");
+
+    expect(pill.nextElementSibling).toContainElement(remove);
   });
 
-  test("a signal other than logs names that explorer instead", () => {
+  test("a signal other than logs names that explorer in the chip's tooltip", async () => {
     render(
       <ActiveFilterChips
         filters={[lockedClusterChip()]}
         onRemove={() => {}}
         onClearAll={() => {}}
         signal="traces"
-        lockedFilterActions={{ copyText: "@k:v" }}
       />,
     );
 
+    await hover(getClusterChip());
+
+    expect(getTooltipSearchToken()).toBe(CLUSTER_SEARCH_TOKEN);
+    expect(screen.getByRole("tooltip").textContent).toBe(
+      `Search syntax${CLUSTER_SEARCH_TOKEN}CopyPaste into the Traces explorer search bar.`,
+    );
     expect(
-      screen.getByRole("button", {
-        name: getCopyLockedFiltersAriaLabel("Traces"),
-      }),
-    ).toBeInTheDocument();
+      screen.queryByTestId("locked-filter-actions"),
+    ).not.toBeInTheDocument();
   });
 });
 
@@ -331,7 +387,6 @@ describe("ActiveFilterChips — unchanged behaviour", () => {
         onClearAll={() => {
           cleared += 1;
         }}
-        lockedFilterActions={{ copyText: "@k:v" }}
       />,
     );
 
@@ -348,7 +403,6 @@ describe("ActiveFilterChips — unchanged behaviour", () => {
         filters={[]}
         onRemove={() => {}}
         onClearAll={() => {}}
-        lockedFilterActions={{ copyText: "@k:v" }}
       />,
     );