@oneuptime/common 9.4.7 → 9.4.8

package/Server/Utils/Workspace/Slack/Messages/AlertEpisode.ts

@@ -0,0 +1,120 @@
+import BadDataException from "../../../../../Types/Exception/BadDataException";
+import ObjectID from "../../../../../Types/ObjectID";
+import {
+  WorkspaceMessageBlock,
+  WorkspaceMessagePayloadButton,
+  WorkspacePayloadButtons,
+  WorkspacePayloadDivider,
+} from "../../../../../Types/Workspace/WorkspaceMessagePayload";
+import AlertEpisodeService from "../../../../Services/AlertEpisodeService";
+import SlackActionType from "../../../../Utils/Workspace/Slack/Actions/ActionTypes";
+import CaptureSpan from "../../../Telemetry/CaptureSpan";
+
+export default class SlackAlertEpisodeMessages {
+  @CaptureSpan()
+  public static async getAlertEpisodeCreateMessageBlocks(data: {
+    alertEpisodeId: ObjectID;
+    projectId: ObjectID;
+  }): Promise<Array<WorkspaceMessageBlock>> {
+    if (!data.alertEpisodeId) {
+      throw new BadDataException("Alert Episode ID is required");
+    }
+
+    // Slack.
+
+    const blockSlack: Array<WorkspaceMessageBlock> = [];
+
+    // add divider.
+
+    const dividerBlock: WorkspacePayloadDivider = {
+      _type: "WorkspacePayloadDivider",
+    };
+
+    blockSlack.push(dividerBlock);
+
+    /*
+     * now add buttons.
+     * View data.
+     * Execute On Call
+     * Acknowledge alert episode
+     * Resolve data.
+     * Change Alert Episode State.
+     * Add Note.
+     */
+
+    const buttons: Array<WorkspaceMessagePayloadButton> = [];
+
+    // view data.
+    const viewAlertEpisodeButton: WorkspaceMessagePayloadButton = {
+      _type: "WorkspaceMessagePayloadButton",
+      title: "🔗 View Episode",
+      url: await AlertEpisodeService.getEpisodeLinkInDashboard(
+        data.projectId!,
+        data.alertEpisodeId!,
+      ),
+      value: data.alertEpisodeId?.toString() || "",
+      actionId: SlackActionType.ViewAlertEpisode,
+    };
+
+    buttons.push(viewAlertEpisodeButton);
+
+    // execute on call.
+    const executeOnCallButton: WorkspaceMessagePayloadButton = {
+      _type: "WorkspaceMessagePayloadButton",
+      title: "📞 Execute On Call",
+      value: data.alertEpisodeId?.toString() || "",
+      actionId: SlackActionType.ViewExecuteAlertEpisodeOnCallPolicy,
+    };
+
+    buttons.push(executeOnCallButton);
+
+    // acknowledge data.
+    const acknowledgeAlertEpisodeButton: WorkspaceMessagePayloadButton = {
+      _type: "WorkspaceMessagePayloadButton",
+      title: "👀 Acknowledge Episode",
+      value: data.alertEpisodeId?.toString() || "",
+      actionId: SlackActionType.AcknowledgeAlertEpisode,
+    };
+
+    buttons.push(acknowledgeAlertEpisodeButton);
+
+    // resolve data.
+    const resolveAlertEpisodeButton: WorkspaceMessagePayloadButton = {
+      _type: "WorkspaceMessagePayloadButton",
+      title: "✅ Resolve Episode",
+      value: data.alertEpisodeId?.toString() || "",
+      actionId: SlackActionType.ResolveAlertEpisode,
+    };
+
+    buttons.push(resolveAlertEpisodeButton);
+
+    // change alert episode state.
+    const changeAlertEpisodeStateButton: WorkspaceMessagePayloadButton = {
+      _type: "WorkspaceMessagePayloadButton",
+      title: "➡️ Change Episode State",
+      value: data.alertEpisodeId?.toString() || "",
+      actionId: SlackActionType.ViewChangeAlertEpisodeState,
+    };
+
+    buttons.push(changeAlertEpisodeStateButton);
+
+    // add note.
+    const addNoteButton: WorkspaceMessagePayloadButton = {
+      _type: "WorkspaceMessagePayloadButton",
+      title: "📄 Add Note",
+      value: data.alertEpisodeId?.toString() || "",
+      actionId: SlackActionType.ViewAddAlertEpisodeNote,
+    };
+
+    buttons.push(addNoteButton);
+
+    const workspacePayloadButtons: WorkspacePayloadButtons = {
+      buttons: buttons,
+      _type: "WorkspacePayloadButtons",
+    };
+
+    blockSlack.push(workspacePayloadButtons);
+
+    return blockSlack;
+  }
+}

package/Server/Utils/Workspace/WorkspaceMessages/AlertEpisode.ts

@@ -0,0 +1,74 @@
+import ObjectID from "../../../../Types/ObjectID";
+import NotificationRuleEventType from "../../../../Types/Workspace/NotificationRules/EventType";
+import NotificationRuleWorkspaceChannel from "../../../../Types/Workspace/NotificationRules/NotificationRuleWorkspaceChannel";
+import { WorkspaceMessageBlock } from "../../../../Types/Workspace/WorkspaceMessagePayload";
+import WorkspaceType from "../../../../Types/Workspace/WorkspaceType";
+import WorkspaceNotificationRuleService, {
+  MessageBlocksByWorkspaceType,
+} from "../../../Services/WorkspaceNotificationRuleService";
+import logger from "../../Logger";
+import SlackAlertEpisodeMessages from "../Slack/Messages/AlertEpisode";
+import CaptureSpan from "../../Telemetry/CaptureSpan";
+
+export default class AlertEpisodeWorkspaceMessages {
+  @CaptureSpan()
+  public static async createChannelsAndInviteUsersToChannels(data: {
+    projectId: ObjectID;
+    alertEpisodeId: ObjectID;
+    episodeNumber: number;
+  }): Promise<{
+    channelsCreated: NotificationRuleWorkspaceChannel[];
+  } | null> {
+    try {
+      // we will notify the workspace about the alert episode creation with the bot tokken which is in WorkspaceProjectAuth Table.
+      return await WorkspaceNotificationRuleService.createChannelsAndInviteUsersToChannelsBasedOnRules(
+        {
+          projectId: data.projectId,
+          notificationFor: {
+            alertEpisodeId: data.alertEpisodeId,
+          },
+          notificationRuleEventType: NotificationRuleEventType.AlertEpisode,
+          channelNameSiffix: data.episodeNumber.toString(),
+        },
+      );
+    } catch (err) {
+      // log the error and continue.
+      logger.error(
+        "Error in AlertEpisode createChannelsAndInviteUsersToChannels",
+      );
+      logger.error(err);
+      return null;
+    }
+  }
+
+  @CaptureSpan()
+  public static async getAlertEpisodeCreateMessageBlocks(data: {
+    alertEpisodeId: ObjectID;
+    projectId: ObjectID;
+  }): Promise<Array<MessageBlocksByWorkspaceType>> {
+    const { alertEpisodeId, projectId } = data;
+
+    const slackBlocks: WorkspaceMessageBlock[] =
+      await SlackAlertEpisodeMessages.getAlertEpisodeCreateMessageBlocks({
+        alertEpisodeId: alertEpisodeId,
+        projectId: projectId!,
+      });
+
+    const microsoftTeamsBlocks: WorkspaceMessageBlock[] =
+      await SlackAlertEpisodeMessages.getAlertEpisodeCreateMessageBlocks({
+        alertEpisodeId: alertEpisodeId,
+        projectId: projectId!,
+      });
+
+    return [
+      {
+        workspaceType: WorkspaceType.Slack,
+        messageBlocks: slackBlocks,
+      },
+      {
+        workspaceType: WorkspaceType.MicrosoftTeams,
+        messageBlocks: microsoftTeamsBlocks,
+      },
+    ];
+  }
+}

package/Tests/Server/Services/AlertEpisodeMemberService.test.ts

@@ -0,0 +1,200 @@
+import AlertEpisodeMember, {
+  AlertEpisodeMemberAddedBy,
+} from "../../../Models/DatabaseModels/AlertEpisodeMember";
+import AlertEpisode from "../../../Models/DatabaseModels/AlertEpisode";
+import ObjectID from "../../../Types/ObjectID";
+import { describe, expect, test, beforeEach } from "@jest/globals";
+
+describe("AlertEpisodeMemberService", () => {
+  const projectId: ObjectID = ObjectID.generate();
+  const alertId: ObjectID = ObjectID.generate();
+  const episodeId: ObjectID = ObjectID.generate();
+  const memberId: ObjectID = ObjectID.generate();
+
+  let mockMember: AlertEpisodeMember;
+  let mockEpisode: AlertEpisode;
+
+  beforeEach(() => {
+    mockMember = new AlertEpisodeMember();
+    mockMember._id = memberId.toString();
+    mockMember.id = memberId;
+    mockMember.projectId = projectId;
+    mockMember.alertId = alertId;
+    mockMember.alertEpisodeId = episodeId;
+    mockMember.addedBy = AlertEpisodeMemberAddedBy.Rule;
+
+    mockEpisode = new AlertEpisode();
+    mockEpisode._id = episodeId.toString();
+    mockEpisode.id = episodeId;
+    mockEpisode.projectId = projectId;
+    mockEpisode.title = "Test Episode";
+  });
+
+  describe("AlertEpisodeMember Model", () => {
+    test("should create a new AlertEpisodeMember instance", () => {
+      const member: AlertEpisodeMember = new AlertEpisodeMember();
+      expect(member).toBeInstanceOf(AlertEpisodeMember);
+    });
+
+    test("should create AlertEpisodeMember with an ID", () => {
+      const id: ObjectID = ObjectID.generate();
+      const member: AlertEpisodeMember = new AlertEpisodeMember(id);
+      expect(member.id).toEqual(id);
+    });
+
+    test("should set and get projectId correctly", () => {
+      const member: AlertEpisodeMember = new AlertEpisodeMember();
+      const projectId: ObjectID = ObjectID.generate();
+      member.projectId = projectId;
+      expect(member.projectId).toEqual(projectId);
+    });
+
+    test("should set and get alertId correctly", () => {
+      const member: AlertEpisodeMember = new AlertEpisodeMember();
+      const alertId: ObjectID = ObjectID.generate();
+      member.alertId = alertId;
+      expect(member.alertId).toEqual(alertId);
+    });
+
+    test("should set and get alertEpisodeId correctly", () => {
+      const member: AlertEpisodeMember = new AlertEpisodeMember();
+      const episodeId: ObjectID = ObjectID.generate();
+      member.alertEpisodeId = episodeId;
+      expect(member.alertEpisodeId).toEqual(episodeId);
+    });
+
+    test("should set addedBy to Rule", () => {
+      const member: AlertEpisodeMember = new AlertEpisodeMember();
+      member.addedBy = AlertEpisodeMemberAddedBy.Rule;
+      expect(member.addedBy).toBe(AlertEpisodeMemberAddedBy.Rule);
+    });
+
+    test("should set addedBy to Manual", () => {
+      const member: AlertEpisodeMember = new AlertEpisodeMember();
+      member.addedBy = AlertEpisodeMemberAddedBy.Manual;
+      expect(member.addedBy).toBe(AlertEpisodeMemberAddedBy.Manual);
+    });
+
+    test("should set addedBy to API", () => {
+      const member: AlertEpisodeMember = new AlertEpisodeMember();
+      member.addedBy = AlertEpisodeMemberAddedBy.API;
+      expect(member.addedBy).toBe(AlertEpisodeMemberAddedBy.API);
+    });
+
+    test("should set and get matchedRuleId correctly", () => {
+      const member: AlertEpisodeMember = new AlertEpisodeMember();
+      const ruleId: ObjectID = ObjectID.generate();
+      member.matchedRuleId = ruleId;
+      expect(member.matchedRuleId).toEqual(ruleId);
+    });
+  });
+
+  describe("AlertEpisodeMember with full data", () => {
+    test("should handle complete member record", () => {
+      const id: ObjectID = ObjectID.generate();
+      const projectId: ObjectID = ObjectID.generate();
+      const alertId: ObjectID = ObjectID.generate();
+      const episodeId: ObjectID = ObjectID.generate();
+      const ruleId: ObjectID = ObjectID.generate();
+
+      const member: AlertEpisodeMember = new AlertEpisodeMember(id);
+      member.projectId = projectId;
+      member.alertId = alertId;
+      member.alertEpisodeId = episodeId;
+      member.addedBy = AlertEpisodeMemberAddedBy.Rule;
+      member.matchedRuleId = ruleId;
+
+      expect(member.id).toEqual(id);
+      expect(member.projectId).toEqual(projectId);
+      expect(member.alertId).toEqual(alertId);
+      expect(member.alertEpisodeId).toEqual(episodeId);
+      expect(member.addedBy).toBe(AlertEpisodeMemberAddedBy.Rule);
+      expect(member.matchedRuleId).toEqual(ruleId);
+    });
+
+    test("should create member with minimal data", () => {
+      const member: AlertEpisodeMember = new AlertEpisodeMember();
+      const alertId: ObjectID = ObjectID.generate();
+      const episodeId: ObjectID = ObjectID.generate();
+
+      member.alertId = alertId;
+      member.alertEpisodeId = episodeId;
+
+      expect(member.alertId).toEqual(alertId);
+      expect(member.alertEpisodeId).toEqual(episodeId);
+      expect(member.matchedRuleId).toBeUndefined();
+    });
+  });
+
+  describe("Multiple members", () => {
+    test("should create distinct member instances", () => {
+      const member1: AlertEpisodeMember = new AlertEpisodeMember();
+      const member2: AlertEpisodeMember = new AlertEpisodeMember();
+
+      const alertId1: ObjectID = ObjectID.generate();
+      const alertId2: ObjectID = ObjectID.generate();
+
+      member1.alertId = alertId1;
+      member2.alertId = alertId2;
+
+      expect(member1.alertId).toEqual(alertId1);
+      expect(member2.alertId).toEqual(alertId2);
+      expect(member1.alertId).not.toEqual(member2.alertId);
+    });
+
+    test("should allow same alert to be linked to different episodes (model level)", () => {
+      /*
+       * Note: The service layer enforces single-episode constraint,
+       * but the model itself allows it
+       */
+      const alertId: ObjectID = ObjectID.generate();
+      const episodeId1: ObjectID = ObjectID.generate();
+      const episodeId2: ObjectID = ObjectID.generate();
+
+      const member1: AlertEpisodeMember = new AlertEpisodeMember();
+      member1.alertId = alertId;
+      member1.alertEpisodeId = episodeId1;
+
+      const member2: AlertEpisodeMember = new AlertEpisodeMember();
+      member2.alertId = alertId;
+      member2.alertEpisodeId = episodeId2;
+
+      expect(member1.alertId).toEqual(member2.alertId);
+      expect(member1.alertEpisodeId).not.toEqual(member2.alertEpisodeId);
+    });
+
+    test("should allow different alerts to be in same episode", () => {
+      const episodeId: ObjectID = ObjectID.generate();
+      const alertId1: ObjectID = ObjectID.generate();
+      const alertId2: ObjectID = ObjectID.generate();
+
+      const member1: AlertEpisodeMember = new AlertEpisodeMember();
+      member1.alertId = alertId1;
+      member1.alertEpisodeId = episodeId;
+
+      const member2: AlertEpisodeMember = new AlertEpisodeMember();
+      member2.alertId = alertId2;
+      member2.alertEpisodeId = episodeId;
+
+      expect(member1.alertEpisodeId).toEqual(member2.alertEpisodeId);
+      expect(member1.alertId).not.toEqual(member2.alertId);
+    });
+  });
+
+  describe("AddedBy enum values", () => {
+    test("should have Rule value", () => {
+      expect(AlertEpisodeMemberAddedBy.Rule).toBeDefined();
+      expect(AlertEpisodeMemberAddedBy.Rule).toBe("rule");
+    });
+
+    test("should have Manual value", () => {
+      expect(AlertEpisodeMemberAddedBy.Manual).toBeDefined();
+      expect(AlertEpisodeMemberAddedBy.Manual).toBe("manual");
+    });
+
+    test("should have API value", () => {
+      expect(AlertEpisodeMemberAddedBy.API).toBeDefined();
+      expect(AlertEpisodeMemberAddedBy.API).toBe("api");
+    });
+  });
+});

package/Tests/Server/Services/AlertEpisodeService.test.ts

@@ -0,0 +1,240 @@
+import AlertEpisode from "../../../Models/DatabaseModels/AlertEpisode";
+import AlertState from "../../../Models/DatabaseModels/AlertState";
+import ObjectID from "../../../Types/ObjectID";
+import { describe, expect, test, beforeEach } from "@jest/globals";
+
+describe("AlertEpisodeService", () => {
+  const projectId: ObjectID = ObjectID.generate();
+  const episodeId: ObjectID = ObjectID.generate();
+
+  let mockEpisode: AlertEpisode;
+  let mockResolvedState: AlertState;
+  let mockAcknowledgedState: AlertState;
+
+  beforeEach(() => {
+    mockEpisode = new AlertEpisode();
+    mockEpisode._id = episodeId.toString();
+    mockEpisode.id = episodeId;
+    mockEpisode.projectId = projectId;
+    mockEpisode.title = "Test Episode";
+    mockEpisode.alertCount = 5;
+
+    mockResolvedState = new AlertState();
+    mockResolvedState._id = ObjectID.generate().toString();
+    mockResolvedState.order = 100;
+    mockResolvedState.isResolvedState = true;
+
+    mockAcknowledgedState = new AlertState();
+    mockAcknowledgedState._id = ObjectID.generate().toString();
+    mockAcknowledgedState.order = 50;
+    mockAcknowledgedState.isAcknowledgedState = true;
+  });
+
+  describe("AlertEpisode Model", () => {
+    test("should create a new AlertEpisode instance", () => {
+      const episode: AlertEpisode = new AlertEpisode();
+      expect(episode).toBeInstanceOf(AlertEpisode);
+    });
+
+    test("should create AlertEpisode with an ID", () => {
+      const id: ObjectID = ObjectID.generate();
+      const episode: AlertEpisode = new AlertEpisode(id);
+      expect(episode.id).toEqual(id);
+    });
+
+    test("should set and get title correctly", () => {
+      const episode: AlertEpisode = new AlertEpisode();
+      episode.title = "CPU Alert Episode";
+      expect(episode.title).toBe("CPU Alert Episode");
+    });
+
+    test("should set and get description correctly", () => {
+      const episode: AlertEpisode = new AlertEpisode();
+      episode.description = "Multiple CPU alerts grouped together";
+      expect(episode.description).toBe("Multiple CPU alerts grouped together");
+    });
+
+    test("should set and get alertCount correctly", () => {
+      const episode: AlertEpisode = new AlertEpisode();
+      episode.alertCount = 10;
+      expect(episode.alertCount).toBe(10);
+    });
+
+    test("should set and get projectId correctly", () => {
+      const episode: AlertEpisode = new AlertEpisode();
+      const projectId: ObjectID = ObjectID.generate();
+      episode.projectId = projectId;
+      expect(episode.projectId).toEqual(projectId);
+    });
+
+    test("should set and get isManuallyCreated correctly", () => {
+      const episode: AlertEpisode = new AlertEpisode();
+      episode.isManuallyCreated = true;
+      expect(episode.isManuallyCreated).toBe(true);
+    });
+
+    test("should set and get titleTemplate correctly", () => {
+      const episode: AlertEpisode = new AlertEpisode();
+      episode.titleTemplate = "{{alertTitle}} - {{alertCount}} alerts";
+      expect(episode.titleTemplate).toBe(
+        "{{alertTitle}} - {{alertCount}} alerts",
+      );
+    });
+
+    test("should set and get descriptionTemplate correctly", () => {
+      const episode: AlertEpisode = new AlertEpisode();
+      episode.descriptionTemplate = "Episode with {{alertCount}} alerts";
+      expect(episode.descriptionTemplate).toBe(
+        "Episode with {{alertCount}} alerts",
+      );
+    });
+
+    test("should set and get groupingKey correctly", () => {
+      const episode: AlertEpisode = new AlertEpisode();
+      episode.groupingKey = "monitor:abc123|severity:critical";
+      expect(episode.groupingKey).toBe("monitor:abc123|severity:critical");
+    });
+
+    test("should set and get rootCause correctly", () => {
+      const episode: AlertEpisode = new AlertEpisode();
+      episode.rootCause = "Database connection pool exhausted";
+      expect(episode.rootCause).toBe("Database connection pool exhausted");
+    });
+
+    test("should set and get lastAlertAddedAt correctly", () => {
+      const episode: AlertEpisode = new AlertEpisode();
+      const date: Date = new Date();
+      episode.lastAlertAddedAt = date;
+      expect(episode.lastAlertAddedAt).toEqual(date);
+    });
+
+    test("should set and get resolvedAt correctly", () => {
+      const episode: AlertEpisode = new AlertEpisode();
+      const date: Date = new Date();
+      episode.resolvedAt = date;
+      expect(episode.resolvedAt).toEqual(date);
+    });
+
+    test("should set and get assignedToUserId correctly", () => {
+      const episode: AlertEpisode = new AlertEpisode();
+      const userId: ObjectID = ObjectID.generate();
+      episode.assignedToUserId = userId;
+      expect(episode.assignedToUserId).toEqual(userId);
+    });
+
+    test("should set and get assignedToTeamId correctly", () => {
+      const episode: AlertEpisode = new AlertEpisode();
+      const teamId: ObjectID = ObjectID.generate();
+      episode.assignedToTeamId = teamId;
+      expect(episode.assignedToTeamId).toEqual(teamId);
+    });
+  });
+
+  describe("Episode with full data", () => {
+    test("should handle complete episode record", () => {
+      const id: ObjectID = ObjectID.generate();
+      const projectId: ObjectID = ObjectID.generate();
+      const userId: ObjectID = ObjectID.generate();
+      const teamId: ObjectID = ObjectID.generate();
+      const ruleId: ObjectID = ObjectID.generate();
+      const severityId: ObjectID = ObjectID.generate();
+
+      const episode: AlertEpisode = new AlertEpisode(id);
+      episode.projectId = projectId;
+      episode.title = "Database Connection Issues";
+      episode.description = "Multiple connection timeout alerts";
+      episode.alertCount = 15;
+      episode.isManuallyCreated = false;
+      episode.groupingKey = "monitor:db-server|severity:critical";
+      episode.titleTemplate = "DB Issues ({{alertCount}})";
+      episode.descriptionTemplate = "{{alertCount}} connection alerts";
+      episode.rootCause = "Network congestion";
+      episode.assignedToUserId = userId;
+      episode.assignedToTeamId = teamId;
+      episode.alertGroupingRuleId = ruleId;
+      episode.alertSeverityId = severityId;
+
+      expect(episode.id).toEqual(id);
+      expect(episode.projectId).toEqual(projectId);
+      expect(episode.title).toBe("Database Connection Issues");
+      expect(episode.description).toBe("Multiple connection timeout alerts");
+      expect(episode.alertCount).toBe(15);
+      expect(episode.isManuallyCreated).toBe(false);
+      expect(episode.groupingKey).toBe("monitor:db-server|severity:critical");
+      expect(episode.titleTemplate).toBe("DB Issues ({{alertCount}})");
+      expect(episode.descriptionTemplate).toBe(
+        "{{alertCount}} connection alerts",
+      );
+      expect(episode.rootCause).toBe("Network congestion");
+      expect(episode.assignedToUserId).toEqual(userId);
+      expect(episode.assignedToTeamId).toEqual(teamId);
+      expect(episode.alertGroupingRuleId).toEqual(ruleId);
+      expect(episode.alertSeverityId).toEqual(severityId);
+    });
+  });
+
+  describe("Template rendering helper", () => {
+    test("should replace {{alertCount}} in title template", () => {
+      const template: string = "CPU Issues - {{alertCount}} alerts";
+      const alertCount: number = 5;
+      const result: string = template.replace(
+        /\{\{alertCount\}\}/g,
+        alertCount.toString(),
+      );
+      expect(result).toBe("CPU Issues - 5 alerts");
+    });
+
+    test("should replace multiple occurrences of {{alertCount}}", () => {
+      const template: string = "{{alertCount}} alerts ({{alertCount}} total)";
+      const alertCount: number = 7;
+      const result: string = template.replace(
+        /\{\{alertCount\}\}/g,
+        alertCount.toString(),
+      );
+      expect(result).toBe("7 alerts (7 total)");
+    });
+
+    test("should handle template without placeholders", () => {
+      const template: string = "Static Episode Title";
+      const alertCount: number = 10;
+      const result: string = template.replace(
+        /\{\{alertCount\}\}/g,
+        alertCount.toString(),
+      );
+      expect(result).toBe("Static Episode Title");
+    });
+
+    test("should handle empty template", () => {
+      const template: string = "";
+      const alertCount: number = 3;
+      const result: string = template.replace(
+        /\{\{alertCount\}\}/g,
+        alertCount.toString(),
+      );
+      expect(result).toBe("");
+    });
+  });
+
+  describe("AlertState comparison", () => {
+    test("should correctly compare state orders for resolution check", () => {
+      const currentOrder: number = 100;
+      const resolvedOrder: number = 100;
+      const isResolved: boolean = currentOrder >= resolvedOrder;
+      expect(isResolved).toBe(true);
+    });
+
+    test("should correctly identify unresolved state", () => {
+      const currentOrder: number = 50;
+      const resolvedOrder: number = 100;
+      const isResolved: boolean = currentOrder >= resolvedOrder;
+      expect(isResolved).toBe(false);
+    });
+
+    test("should correctly identify acknowledged state", () => {
+      const currentOrder: number = 50;
+      const acknowledgedOrder: number = 50;
+      const isAcknowledged: boolean = currentOrder >= acknowledgedOrder;
+      expect(isAcknowledged).toBe(true);
+    });
+  });
+});