@oneuptime/common 13.0.7 → 13.0.8

package/Tests/Server/Utils/Workspace/MicrosoftTeams/Messages/Incident.test.ts

@@ -0,0 +1,194 @@
+import { afterEach, beforeEach, describe, expect, test } from "@jest/globals";
+import DatabaseConfig from "../../../../../../Server/DatabaseConfig";
+import IncidentService from "../../../../../../Server/Services/IncidentService";
+import { MicrosoftTeamsIncidentActionType } from "../../../../../../Server/Utils/Workspace/MicrosoftTeams/Actions/ActionTypes";
+import MicrosoftTeamsIncidentMessages from "../../../../../../Server/Utils/Workspace/MicrosoftTeams/Messages/Incident";
+import Hostname from "../../../../../../Types/API/Hostname";
+import Protocol from "../../../../../../Types/API/Protocol";
+import BadDataException from "../../../../../../Types/Exception/BadDataException";
+import ObjectID from "../../../../../../Types/ObjectID";
+import {
+  WorkspaceMessageBlock,
+  WorkspaceMessagePayloadButton,
+  WorkspacePayloadButtons,
+} from "../../../../../../Types/Workspace/WorkspaceMessagePayload";
+
+const getButtons: (
+  blocks: Array<WorkspaceMessageBlock>,
+) => Array<WorkspaceMessagePayloadButton> = (
+  blocks: Array<WorkspaceMessageBlock>,
+): Array<WorkspaceMessagePayloadButton> => {
+  return (blocks[1] as WorkspacePayloadButtons).buttons;
+};
+
+describe("MicrosoftTeamsIncidentMessages.getIncidentCreateMessageBlocks", () => {
+  const projectId: ObjectID = ObjectID.generate();
+  const incidentId: ObjectID = ObjectID.generate();
+
+  beforeEach(() => {
+    jest
+      .spyOn(DatabaseConfig, "getHost")
+      .mockResolvedValue(new Hostname("oneuptime.test"));
+    jest
+      .spyOn(DatabaseConfig, "getHttpProtocol")
+      .mockResolvedValue(Protocol.HTTPS);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("returns a divider followed by a single buttons block", async () => {
+    const blocks: Array<WorkspaceMessageBlock> =
+      await MicrosoftTeamsIncidentMessages.getIncidentCreateMessageBlocks({
+        incidentId,
+        projectId,
+      });
+
+    expect(blocks).toHaveLength(2);
+    expect(blocks[0]).toEqual({ _type: "WorkspacePayloadDivider" });
+    expect(blocks[1]!._type).toBe("WorkspacePayloadButtons");
+  });
+
+  test("emits the 6 buttons in order with the expected action ids and titles", async () => {
+    const buttons: Array<WorkspaceMessagePayloadButton> = getButtons(
+      await MicrosoftTeamsIncidentMessages.getIncidentCreateMessageBlocks({
+        incidentId,
+        projectId,
+      }),
+    );
+
+    expect(
+      buttons.map((button: WorkspaceMessagePayloadButton) => {
+        return button.actionId;
+      }),
+    ).toEqual([
+      MicrosoftTeamsIncidentActionType.ViewIncident,
+      MicrosoftTeamsIncidentActionType.ViewExecuteIncidentOnCallPolicy,
+      MicrosoftTeamsIncidentActionType.AckIncident,
+      MicrosoftTeamsIncidentActionType.ResolveIncident,
+      MicrosoftTeamsIncidentActionType.ViewChangeIncidentState,
+      MicrosoftTeamsIncidentActionType.ViewAddIncidentNote,
+    ]);
+
+    expect(
+      buttons.map((button: WorkspaceMessagePayloadButton) => {
+        return button.title;
+      }),
+    ).toEqual([
+      "🔗 View Incident",
+      "📞 Execute On Call",
+      "👀 Acknowledge Incident",
+      "✅ Resolve Incident",
+      "➡️ Change Incident State",
+      "📄 Add Note",
+    ]);
+  });
+
+  test("every button carries the incident id as its value", async () => {
+    const buttons: Array<WorkspaceMessagePayloadButton> = getButtons(
+      await MicrosoftTeamsIncidentMessages.getIncidentCreateMessageBlocks({
+        incidentId,
+        projectId,
+      }),
+    );
+
+    expect(buttons).toHaveLength(6);
+
+    for (const button of buttons) {
+      expect(button._type).toBe("WorkspaceMessagePayloadButton");
+      expect(button.value).toBe(incidentId.toString());
+      expect(button.value).not.toBe(projectId.toString());
+    }
+  });
+
+  test("only the view button links to the incident page in the dashboard", async () => {
+    const buttons: Array<WorkspaceMessagePayloadButton> = getButtons(
+      await MicrosoftTeamsIncidentMessages.getIncidentCreateMessageBlocks({
+        incidentId,
+        projectId,
+      }),
+    );
+
+    expect(buttons[0]!.url?.toString()).toBe(
+      `https://oneuptime.test/dashboard/${projectId.toString()}/incidents/${incidentId.toString()}`,
+    );
+
+    for (const button of buttons.slice(1)) {
+      expect(button.url).toBeUndefined();
+    }
+  });
+
+  test("asks IncidentService for the link with the project and incident ids", async () => {
+    const linkSpy: jest.SpiedFunction<
+      typeof IncidentService.getIncidentLinkInDashboard
+    > = jest.spyOn(IncidentService, "getIncidentLinkInDashboard");
+
+    await MicrosoftTeamsIncidentMessages.getIncidentCreateMessageBlocks({
+      incidentId,
+      projectId,
+    });
+
+    expect(linkSpy).toHaveBeenCalledTimes(1);
+    expect(linkSpy).toHaveBeenCalledWith(projectId, incidentId);
+  });
+
+  test("throws BadDataException when the incident id is missing", async () => {
+    const linkSpy: jest.SpiedFunction<
+      typeof IncidentService.getIncidentLinkInDashboard
+    > = jest.spyOn(IncidentService, "getIncidentLinkInDashboard");
+
+    await expect(
+      MicrosoftTeamsIncidentMessages.getIncidentCreateMessageBlocks({
+        incidentId: undefined as unknown as ObjectID,
+        projectId,
+      }),
+    ).rejects.toThrow(new BadDataException("Incident ID is required"));
+
+    expect(linkSpy).not.toHaveBeenCalled();
+  });
+
+  test("throws when the project id is missing (no dashboard link can be built)", async () => {
+    await expect(
+      MicrosoftTeamsIncidentMessages.getIncidentCreateMessageBlocks({
+        incidentId,
+        projectId: undefined as unknown as ObjectID,
+      }),
+    ).rejects.toThrow();
+  });
+
+  test("propagates a failure while building the dashboard link", async () => {
+    jest
+      .spyOn(IncidentService, "getIncidentLinkInDashboard")
+      .mockRejectedValue(new Error("dashboard url unavailable"));
+
+    await expect(
+      MicrosoftTeamsIncidentMessages.getIncidentCreateMessageBlocks({
+        incidentId,
+        projectId,
+      }),
+    ).rejects.toThrow("dashboard url unavailable");
+  });
+
+  test("builds a fresh block list for each incident", async () => {
+    const otherId: ObjectID = ObjectID.generate();
+
+    const first: Array<WorkspaceMessageBlock> =
+      await MicrosoftTeamsIncidentMessages.getIncidentCreateMessageBlocks({
+        incidentId,
+        projectId,
+      });
+    const second: Array<WorkspaceMessageBlock> =
+      await MicrosoftTeamsIncidentMessages.getIncidentCreateMessageBlocks({
+        incidentId: otherId,
+        projectId,
+      });
+
+    expect(first).not.toBe(second);
+    expect(getButtons(first)[0]!.value).toBe(incidentId.toString());
+    expect(getButtons(second)[0]!.value).toBe(otherId.toString());
+    expect(getButtons(second)[0]!.url?.toString()).toContain(
+      `/incidents/${otherId.toString()}`,
+    );
+  });
+});

package/Tests/Server/Utils/Workspace/MicrosoftTeams/Messages/ScheduledMaintenance.test.ts

@@ -0,0 +1,231 @@
+import { afterEach, beforeEach, describe, expect, test } from "@jest/globals";
+import DatabaseConfig from "../../../../../../Server/DatabaseConfig";
+import ScheduledMaintenanceService from "../../../../../../Server/Services/ScheduledMaintenanceService";
+import { MicrosoftTeamsScheduledMaintenanceActionType } from "../../../../../../Server/Utils/Workspace/MicrosoftTeams/Actions/ActionTypes";
+import MicrosoftTeamsScheduledMaintenanceMessages from "../../../../../../Server/Utils/Workspace/MicrosoftTeams/Messages/ScheduledMaintenance";
+import Hostname from "../../../../../../Types/API/Hostname";
+import Protocol from "../../../../../../Types/API/Protocol";
+import BadDataException from "../../../../../../Types/Exception/BadDataException";
+import ObjectID from "../../../../../../Types/ObjectID";
+import {
+  WorkspaceMessageBlock,
+  WorkspaceMessagePayloadButton,
+  WorkspacePayloadButtons,
+} from "../../../../../../Types/Workspace/WorkspaceMessagePayload";
+
+/*
+ * NOTE: the "Change State" and "Add Note" buttons use
+ * ScheduledMaintenanceStateChanged / AddScheduledMaintenanceNote, whereas
+ * MicrosoftTeamsScheduledMaintenanceActions dispatches on
+ * ViewChangeScheduledMaintenanceState / ViewAddScheduledMaintenanceNote.
+ * These tests pin the current output.
+ */
+
+const getButtons: (
+  blocks: Array<WorkspaceMessageBlock>,
+) => Array<WorkspaceMessagePayloadButton> = (
+  blocks: Array<WorkspaceMessageBlock>,
+): Array<WorkspaceMessagePayloadButton> => {
+  return (blocks[1] as WorkspacePayloadButtons).buttons;
+};
+
+describe("MicrosoftTeamsScheduledMaintenanceMessages.getScheduledMaintenanceCreateMessageBlocks", () => {
+  const projectId: ObjectID = ObjectID.generate();
+  const scheduledMaintenanceId: ObjectID = ObjectID.generate();
+
+  beforeEach(() => {
+    jest
+      .spyOn(DatabaseConfig, "getHost")
+      .mockResolvedValue(new Hostname("oneuptime.test"));
+    jest
+      .spyOn(DatabaseConfig, "getHttpProtocol")
+      .mockResolvedValue(Protocol.HTTPS);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("returns a divider followed by a single buttons block", async () => {
+    const blocks: Array<WorkspaceMessageBlock> =
+      await MicrosoftTeamsScheduledMaintenanceMessages.getScheduledMaintenanceCreateMessageBlocks(
+        {
+          scheduledMaintenanceId,
+          projectId,
+        },
+      );
+
+    expect(blocks).toHaveLength(2);
+    expect(blocks[0]).toEqual({ _type: "WorkspacePayloadDivider" });
+    expect(blocks[1]!._type).toBe("WorkspacePayloadButtons");
+  });
+
+  test("emits the 5 buttons in order with the expected action ids and titles", async () => {
+    const buttons: Array<WorkspaceMessagePayloadButton> = getButtons(
+      await MicrosoftTeamsScheduledMaintenanceMessages.getScheduledMaintenanceCreateMessageBlocks(
+        {
+          scheduledMaintenanceId,
+          projectId,
+        },
+      ),
+    );
+
+    expect(
+      buttons.map((button: WorkspaceMessagePayloadButton) => {
+        return button.actionId;
+      }),
+    ).toEqual([
+      MicrosoftTeamsScheduledMaintenanceActionType.ViewScheduledMaintenance,
+      MicrosoftTeamsScheduledMaintenanceActionType.MarkAsOngoing,
+      MicrosoftTeamsScheduledMaintenanceActionType.MarkAsComplete,
+      MicrosoftTeamsScheduledMaintenanceActionType.ScheduledMaintenanceStateChanged,
+      MicrosoftTeamsScheduledMaintenanceActionType.AddScheduledMaintenanceNote,
+    ]);
+
+    expect(
+      buttons.map((button: WorkspaceMessagePayloadButton) => {
+        return button.title;
+      }),
+    ).toEqual([
+      "🔗 View ScheduledMaintenance",
+      "⌛ Mark as Ongoing",
+      "✅ Mark as Completed",
+      "➡️ Change Scheduled Maintenance State",
+      "📄 Add Note",
+    ]);
+  });
+
+  test("every button carries the scheduled maintenance id as its value", async () => {
+    const buttons: Array<WorkspaceMessagePayloadButton> = getButtons(
+      await MicrosoftTeamsScheduledMaintenanceMessages.getScheduledMaintenanceCreateMessageBlocks(
+        {
+          scheduledMaintenanceId,
+          projectId,
+        },
+      ),
+    );
+
+    expect(buttons).toHaveLength(5);
+
+    for (const button of buttons) {
+      expect(button._type).toBe("WorkspaceMessagePayloadButton");
+      expect(button.value).toBe(scheduledMaintenanceId.toString());
+      expect(button.value).not.toBe(projectId.toString());
+    }
+  });
+
+  test("only the view button links to the scheduled maintenance page in the dashboard", async () => {
+    const buttons: Array<WorkspaceMessagePayloadButton> = getButtons(
+      await MicrosoftTeamsScheduledMaintenanceMessages.getScheduledMaintenanceCreateMessageBlocks(
+        {
+          scheduledMaintenanceId,
+          projectId,
+        },
+      ),
+    );
+
+    expect(buttons[0]!.url?.toString()).toBe(
+      `https://oneuptime.test/dashboard/${projectId.toString()}/scheduled-maintenance-events/${scheduledMaintenanceId.toString()}`,
+    );
+
+    for (const button of buttons.slice(1)) {
+      expect(button.url).toBeUndefined();
+    }
+  });
+
+  test("asks ScheduledMaintenanceService for the link with the project and scheduled maintenance ids", async () => {
+    const linkSpy: jest.SpiedFunction<
+      typeof ScheduledMaintenanceService.getScheduledMaintenanceLinkInDashboard
+    > = jest.spyOn(
+      ScheduledMaintenanceService,
+      "getScheduledMaintenanceLinkInDashboard",
+    );
+
+    await MicrosoftTeamsScheduledMaintenanceMessages.getScheduledMaintenanceCreateMessageBlocks(
+      {
+        scheduledMaintenanceId,
+        projectId,
+      },
+    );
+
+    expect(linkSpy).toHaveBeenCalledTimes(1);
+    expect(linkSpy).toHaveBeenCalledWith(projectId, scheduledMaintenanceId);
+  });
+
+  test("throws BadDataException when the scheduled maintenance id is missing", async () => {
+    const linkSpy: jest.SpiedFunction<
+      typeof ScheduledMaintenanceService.getScheduledMaintenanceLinkInDashboard
+    > = jest.spyOn(
+      ScheduledMaintenanceService,
+      "getScheduledMaintenanceLinkInDashboard",
+    );
+
+    await expect(
+      MicrosoftTeamsScheduledMaintenanceMessages.getScheduledMaintenanceCreateMessageBlocks(
+        {
+          scheduledMaintenanceId: undefined as unknown as ObjectID,
+          projectId,
+        },
+      ),
+    ).rejects.toThrow(
+      new BadDataException("ScheduledMaintenance ID is required"),
+    );
+
+    expect(linkSpy).not.toHaveBeenCalled();
+  });
+
+  test("throws BadDataException when the project id is missing", async () => {
+    await expect(
+      MicrosoftTeamsScheduledMaintenanceMessages.getScheduledMaintenanceCreateMessageBlocks(
+        {
+          scheduledMaintenanceId,
+          projectId: undefined as unknown as ObjectID,
+        },
+      ),
+    ).rejects.toThrow(new BadDataException("projectId is required"));
+  });
+
+  test("propagates a failure while building the dashboard link", async () => {
+    jest
+      .spyOn(
+        ScheduledMaintenanceService,
+        "getScheduledMaintenanceLinkInDashboard",
+      )
+      .mockRejectedValue(new Error("dashboard url unavailable"));
+
+    await expect(
+      MicrosoftTeamsScheduledMaintenanceMessages.getScheduledMaintenanceCreateMessageBlocks(
+        {
+          scheduledMaintenanceId,
+          projectId,
+        },
+      ),
+    ).rejects.toThrow("dashboard url unavailable");
+  });
+
+  test("builds a fresh block list for each scheduled maintenance", async () => {
+    const otherId: ObjectID = ObjectID.generate();
+
+    const first: Array<WorkspaceMessageBlock> =
+      await MicrosoftTeamsScheduledMaintenanceMessages.getScheduledMaintenanceCreateMessageBlocks(
+        {
+          scheduledMaintenanceId,
+          projectId,
+        },
+      );
+    const second: Array<WorkspaceMessageBlock> =
+      await MicrosoftTeamsScheduledMaintenanceMessages.getScheduledMaintenanceCreateMessageBlocks(
+        {
+          scheduledMaintenanceId: otherId,
+          projectId,
+        },
+      );
+
+    expect(first).not.toBe(second);
+    expect(getButtons(first)[0]!.value).toBe(scheduledMaintenanceId.toString());
+    expect(getButtons(second)[0]!.value).toBe(otherId.toString());
+    expect(getButtons(second)[0]!.url?.toString()).toContain(
+      `/scheduled-maintenance-events/${otherId.toString()}`,
+    );
+  });
+});

package/Tests/Server/Utils/Workspace/Slack/Messages/Alert.test.ts

@@ -0,0 +1,194 @@
+import { afterEach, beforeEach, describe, expect, test } from "@jest/globals";
+import DatabaseConfig from "../../../../../../Server/DatabaseConfig";
+import AlertService from "../../../../../../Server/Services/AlertService";
+import SlackActionType from "../../../../../../Server/Utils/Workspace/Slack/Actions/ActionTypes";
+import SlackAlertMessages from "../../../../../../Server/Utils/Workspace/Slack/Messages/Alert";
+import Hostname from "../../../../../../Types/API/Hostname";
+import Protocol from "../../../../../../Types/API/Protocol";
+import BadDataException from "../../../../../../Types/Exception/BadDataException";
+import ObjectID from "../../../../../../Types/ObjectID";
+import {
+  WorkspaceMessageBlock,
+  WorkspaceMessagePayloadButton,
+  WorkspacePayloadButtons,
+} from "../../../../../../Types/Workspace/WorkspaceMessagePayload";
+
+const getButtons: (
+  blocks: Array<WorkspaceMessageBlock>,
+) => Array<WorkspaceMessagePayloadButton> = (
+  blocks: Array<WorkspaceMessageBlock>,
+): Array<WorkspaceMessagePayloadButton> => {
+  return (blocks[1] as WorkspacePayloadButtons).buttons;
+};
+
+describe("SlackAlertMessages.getAlertCreateMessageBlocks", () => {
+  const projectId: ObjectID = ObjectID.generate();
+  const alertId: ObjectID = ObjectID.generate();
+
+  beforeEach(() => {
+    jest
+      .spyOn(DatabaseConfig, "getHost")
+      .mockResolvedValue(new Hostname("oneuptime.test"));
+    jest
+      .spyOn(DatabaseConfig, "getHttpProtocol")
+      .mockResolvedValue(Protocol.HTTPS);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("returns a divider followed by a single buttons block", async () => {
+    const blocks: Array<WorkspaceMessageBlock> =
+      await SlackAlertMessages.getAlertCreateMessageBlocks({
+        alertId,
+        projectId,
+      });
+
+    expect(blocks).toHaveLength(2);
+    expect(blocks[0]).toEqual({ _type: "WorkspacePayloadDivider" });
+    expect(blocks[1]!._type).toBe("WorkspacePayloadButtons");
+  });
+
+  test("emits the 6 buttons in order with the expected action ids and titles", async () => {
+    const buttons: Array<WorkspaceMessagePayloadButton> = getButtons(
+      await SlackAlertMessages.getAlertCreateMessageBlocks({
+        alertId,
+        projectId,
+      }),
+    );
+
+    expect(
+      buttons.map((button: WorkspaceMessagePayloadButton) => {
+        return button.actionId;
+      }),
+    ).toEqual([
+      SlackActionType.ViewAlert,
+      SlackActionType.ViewExecuteAlertOnCallPolicy,
+      SlackActionType.AcknowledgeAlert,
+      SlackActionType.ResolveAlert,
+      SlackActionType.ViewChangeAlertState,
+      SlackActionType.ViewAddAlertNote,
+    ]);
+
+    expect(
+      buttons.map((button: WorkspaceMessagePayloadButton) => {
+        return button.title;
+      }),
+    ).toEqual([
+      "🔗 View Alert",
+      "📞 Execute On Call",
+      "👀 Acknowledge Alert",
+      "✅ Resolve Alert",
+      "➡️ Change Alert State",
+      "📄 Add Note",
+    ]);
+  });
+
+  test("every button carries the alert id as its value", async () => {
+    const buttons: Array<WorkspaceMessagePayloadButton> = getButtons(
+      await SlackAlertMessages.getAlertCreateMessageBlocks({
+        alertId,
+        projectId,
+      }),
+    );
+
+    expect(buttons).toHaveLength(6);
+
+    for (const button of buttons) {
+      expect(button._type).toBe("WorkspaceMessagePayloadButton");
+      expect(button.value).toBe(alertId.toString());
+      expect(button.value).not.toBe(projectId.toString());
+    }
+  });
+
+  test("only the view button links to the alert page in the dashboard", async () => {
+    const buttons: Array<WorkspaceMessagePayloadButton> = getButtons(
+      await SlackAlertMessages.getAlertCreateMessageBlocks({
+        alertId,
+        projectId,
+      }),
+    );
+
+    expect(buttons[0]!.url?.toString()).toBe(
+      `https://oneuptime.test/dashboard/${projectId.toString()}/alerts/${alertId.toString()}`,
+    );
+
+    for (const button of buttons.slice(1)) {
+      expect(button.url).toBeUndefined();
+    }
+  });
+
+  test("asks AlertService for the link with the project and alert ids", async () => {
+    const linkSpy: jest.SpiedFunction<
+      typeof AlertService.getAlertLinkInDashboard
+    > = jest.spyOn(AlertService, "getAlertLinkInDashboard");
+
+    await SlackAlertMessages.getAlertCreateMessageBlocks({
+      alertId,
+      projectId,
+    });
+
+    expect(linkSpy).toHaveBeenCalledTimes(1);
+    expect(linkSpy).toHaveBeenCalledWith(projectId, alertId);
+  });
+
+  test("throws BadDataException when the alert id is missing", async () => {
+    const linkSpy: jest.SpiedFunction<
+      typeof AlertService.getAlertLinkInDashboard
+    > = jest.spyOn(AlertService, "getAlertLinkInDashboard");
+
+    await expect(
+      SlackAlertMessages.getAlertCreateMessageBlocks({
+        alertId: undefined as unknown as ObjectID,
+        projectId,
+      }),
+    ).rejects.toThrow(new BadDataException("Alert ID is required"));
+
+    expect(linkSpy).not.toHaveBeenCalled();
+  });
+
+  test("throws when the project id is missing (no dashboard link can be built)", async () => {
+    await expect(
+      SlackAlertMessages.getAlertCreateMessageBlocks({
+        alertId,
+        projectId: undefined as unknown as ObjectID,
+      }),
+    ).rejects.toThrow();
+  });
+
+  test("propagates a failure while building the dashboard link", async () => {
+    jest
+      .spyOn(AlertService, "getAlertLinkInDashboard")
+      .mockRejectedValue(new Error("dashboard url unavailable"));
+
+    await expect(
+      SlackAlertMessages.getAlertCreateMessageBlocks({
+        alertId,
+        projectId,
+      }),
+    ).rejects.toThrow("dashboard url unavailable");
+  });
+
+  test("builds a fresh block list for each alert", async () => {
+    const otherId: ObjectID = ObjectID.generate();
+
+    const first: Array<WorkspaceMessageBlock> =
+      await SlackAlertMessages.getAlertCreateMessageBlocks({
+        alertId,
+        projectId,
+      });
+    const second: Array<WorkspaceMessageBlock> =
+      await SlackAlertMessages.getAlertCreateMessageBlocks({
+        alertId: otherId,
+        projectId,
+      });
+
+    expect(first).not.toBe(second);
+    expect(getButtons(first)[0]!.value).toBe(alertId.toString());
+    expect(getButtons(second)[0]!.value).toBe(otherId.toString());
+    expect(getButtons(second)[0]!.url?.toString()).toContain(
+      `/alerts/${otherId.toString()}`,
+    );
+  });
+});