@oneuptime/common 12.0.18 → 12.0.19

package/Tests/Server/Utils/Workspace/MicrosoftTeamsDirectMessage.test.ts

@@ -0,0 +1,454 @@
+import { describe, expect, test, afterEach, beforeEach } from "@jest/globals";
+
+/*
+ * Tests for the Microsoft Teams DIRECT MESSAGE path —
+ * MicrosoftTeamsUtil.sendDirectMessageToUserAsBot, the sender behind the
+ * "Microsoft Teams" user notification method.
+ *
+ * The problem it solves, and the reason it exists next to the older
+ * sendDirectMessageToUser: WorkspaceUserAuthToken stores the user's Microsoft
+ * ENTRA OBJECT ID, but the Graph-based helper posts to /chats/{chatId} and so
+ * needs a CHAT id — the two id spaces never meet. This method resolves a
+ * deliverable conversation from the Entra id instead, two ways:
+ *
+ *   1. REUSE. A personal chat previously captured from a bot activity (whose
+ *      roster contained this Entra id) is known-deliverable and carries the
+ *      regional serviceUrl, so it is preferred and delivered through the
+ *      existing sendAdaptiveCardToChat path.
+ *
+ *   2. CREATE. Otherwise Bot Framework createConversation is asked to resolve
+ *      (or create) the 1:1 conversation from the member's Entra id — which
+ *      works exactly when the OneUptime app is installed for that user, so
+ *      Microsoft's opaque roster rejection is translated into "install the
+ *      OneUptime app" before anybody reads it off an on-call timeline.
+ */
+
+jest.mock("../../../../Server/EnvironmentConfig", () => {
+  return {
+    ...(jest.requireActual("../../../../Server/EnvironmentConfig") as Record<
+      string,
+      unknown
+    >),
+    MicrosoftTeamsAppClientId: "11111111-2222-3333-4444-555555555555",
+    MicrosoftTeamsAppClientSecret: "test-secret",
+    MicrosoftTeamsAppTenantId: "test-tenant",
+  };
+});
+
+jest.mock("botbuilder", () => {
+  return {
+    CloudAdapter: class CloudAdapter {},
+    ConfigurationBotFrameworkAuthentication: class ConfigurationBotFrameworkAuthentication {},
+    TeamsActivityHandler: class TeamsActivityHandler {},
+    TurnContext: class TurnContext {},
+    ActivityHandler: class ActivityHandler {},
+    MessageFactory: {
+      text: jest.fn(),
+      attachment: jest.fn((attachment: unknown) => {
+        return { type: "message", attachments: [attachment] };
+      }),
+    },
+    CardFactory: { heroCard: jest.fn() },
+    TeamsInfo: {
+      getMembers: jest.fn(),
+      getPagedMembers: jest.fn(),
+    },
+  };
+});
+
+import MicrosoftTeamsUtil from "../../../../Server/Utils/Workspace/MicrosoftTeams/MicrosoftTeams";
+import WorkspaceProjectAuthTokenService from "../../../../Server/Services/WorkspaceProjectAuthTokenService";
+import WorkspaceProjectAuthToken, {
+  MicrosoftTeamsChat,
+  MicrosoftTeamsMiscData,
+} from "../../../../Models/DatabaseModels/WorkspaceProjectAuthToken";
+import logger from "../../../../Server/Utils/Logger";
+import ObjectID from "../../../../Types/ObjectID";
+import BadDataException from "../../../../Types/Exception/BadDataException";
+import {
+  WorkspaceMessageBlock,
+  WorkspacePayloadMarkdown,
+} from "../../../../Types/Workspace/WorkspaceMessagePayload";
+import type { ConversationParameters, TurnContext } from "botbuilder";
+
+const MOCK_APP_CLIENT_ID: string = "11111111-2222-3333-4444-555555555555";
+const PROJECT_ID: ObjectID = new ObjectID(
+  "11111111-1111-4111-8111-111111111111",
+);
+const TENANT_ID: string = "tenant-xyz";
+const ENTRA_OBJECT_ID: string = "e6f1c1f7-aad0-4b6c-9c11-2f5b7c8d9e0f";
+const PERSONAL_CHAT_ID: string = "a:1personalchat";
+const DEFAULT_SERVICE_URL: string = "https://smba.trafficmanager.net/teams/";
+const REGIONAL_SERVICE_URL: string = "https://smba.emea.teams.microsoft.com/";
+const ROSTER_ERROR_TEXT: string =
+  "The bot is not part of the conversation roster.";
+
+function markdownBlocks(): Array<WorkspaceMessageBlock> {
+  const block: WorkspacePayloadMarkdown = {
+    _type: "WorkspacePayloadMarkdown",
+    text: "**incident** page body",
+  };
+  return [block];
+}
+
+function personalChat(
+  overrides: Partial<MicrosoftTeamsChat> = {},
+): MicrosoftTeamsChat {
+  return {
+    id: PERSONAL_CHAT_ID,
+    name: "Alice Example",
+    chatType: "personal",
+    serviceUrl: REGIONAL_SERVICE_URL,
+    memberAadObjectIds: [ENTRA_OBJECT_ID],
+    ...overrides,
+  } as MicrosoftTeamsChat;
+}
+
+function miscData(
+  overrides: Partial<MicrosoftTeamsMiscData> = {},
+): MicrosoftTeamsMiscData {
+  return {
+    tenantId: TENANT_ID,
+    teamId: "team-1",
+    teamName: "Engineering",
+    botId: "bot-1",
+    ...overrides,
+  } as MicrosoftTeamsMiscData;
+}
+
+function mockProjectAuth(
+  overrides: Partial<MicrosoftTeamsMiscData> = {},
+): jest.SpyInstance {
+  return jest
+    .spyOn(WorkspaceProjectAuthTokenService, "getProjectAuth")
+    .mockResolvedValue({
+      id: PROJECT_ID,
+      workspaceProjectId: TENANT_ID,
+      miscData: miscData(overrides),
+    } as unknown as WorkspaceProjectAuthToken as never);
+}
+
+interface FakeCreateAdapter {
+  createConversationAsync: jest.Mock;
+  capturedParams: Array<ConversationParameters>;
+  capturedServiceUrls: Array<string>;
+  sentActivities: Array<unknown>;
+}
+
+function installFakeCreateAdapter(options?: {
+  createError?: unknown;
+}): FakeCreateAdapter {
+  const capturedParams: Array<ConversationParameters> = [];
+  const capturedServiceUrls: Array<string> = [];
+  const sentActivities: Array<unknown> = [];
+
+  const createConversationAsync: jest.Mock = jest.fn(
+    async (
+      _appId: string,
+      _channelId: string,
+      serviceUrl: string,
+      _audience: string,
+      conversationParameters: ConversationParameters,
+      logic: (context: TurnContext) => Promise<void>,
+    ): Promise<void> => {
+      capturedServiceUrls.push(serviceUrl);
+      capturedParams.push(conversationParameters);
+
+      if (options && "createError" in options) {
+        throw options.createError;
+      }
+
+      const fakeContext: TurnContext = {
+        sendActivity: async (activity: unknown): Promise<unknown> => {
+          sentActivities.push(activity);
+          return { id: "msg-123" };
+        },
+      } as unknown as TurnContext;
+
+      await logic(fakeContext);
+    },
+  );
+
+  jest
+    .spyOn(MicrosoftTeamsUtil as any, "getBotAdapter")
+    .mockReturnValue({ createConversationAsync: createConversationAsync });
+
+  return {
+    createConversationAsync: createConversationAsync,
+    capturedParams: capturedParams,
+    capturedServiceUrls: capturedServiceUrls,
+    sentActivities: sentActivities,
+  };
+}
+
+describe("MicrosoftTeamsUtil.sendDirectMessageToUserAsBot", () => {
+  let sendToChat: jest.SpyInstance;
+
+  beforeEach(() => {
+    jest.spyOn(logger, "error").mockImplementation((): void => {
+      return undefined;
+    });
+    jest.spyOn(logger, "debug").mockImplementation((): void => {
+      return undefined;
+    });
+
+    sendToChat = jest
+      .spyOn(MicrosoftTeamsUtil, "sendAdaptiveCardToChat")
+      .mockResolvedValue({
+        channel: {
+          id: PERSONAL_CHAT_ID,
+          name: "Alice Example",
+          workspaceType: "MicrosoftTeams",
+        },
+        threadId: "msg-1",
+      } as never);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  /*
+   * ----------------------------------------------------------------------- *
+   * (A) Reusing a captured personal chat.
+   * -----------------------------------------------------------------------
+   */
+
+  describe("reusing a captured personal chat", () => {
+    test("a personal chat whose roster carries the Entra id is delivered through sendAdaptiveCardToChat", async () => {
+      mockProjectAuth({
+        availableChats: { [PERSONAL_CHAT_ID]: personalChat() },
+      });
+      const adapter: FakeCreateAdapter = installFakeCreateAdapter();
+
+      await MicrosoftTeamsUtil.sendDirectMessageToUserAsBot({
+        projectId: PROJECT_ID,
+        workspaceUserId: ENTRA_OBJECT_ID,
+        messageBlocks: markdownBlocks(),
+      });
+
+      expect(sendToChat).toHaveBeenCalledTimes(1);
+      const arg: { chatId: string; projectId: ObjectID } = sendToChat.mock
+        .calls[0][0] as { chatId: string; projectId: ObjectID };
+      expect(arg.chatId).toBe(PERSONAL_CHAT_ID);
+      expect(arg.projectId.toString()).toBe(PROJECT_ID.toString());
+
+      // The Bot Framework create path is not touched at all.
+      expect(adapter.createConversationAsync).not.toHaveBeenCalled();
+    });
+
+    test("a personal chat belonging to somebody ELSE is not reused", async () => {
+      mockProjectAuth({
+        availableChats: {
+          [PERSONAL_CHAT_ID]: personalChat({
+            memberAadObjectIds: ["some-other-user"],
+          }),
+        },
+      });
+      installFakeCreateAdapter();
+
+      await MicrosoftTeamsUtil.sendDirectMessageToUserAsBot({
+        projectId: PROJECT_ID,
+        workspaceUserId: ENTRA_OBJECT_ID,
+        messageBlocks: markdownBlocks(),
+      });
+
+      expect(sendToChat).not.toHaveBeenCalled();
+    });
+
+    test("a GROUP chat carrying the Entra id is not reused - a page is a direct message, not a group post", async () => {
+      mockProjectAuth({
+        availableChats: {
+          [PERSONAL_CHAT_ID]: personalChat({ chatType: "groupChat" }),
+        },
+      });
+      installFakeCreateAdapter();
+
+      await MicrosoftTeamsUtil.sendDirectMessageToUserAsBot({
+        projectId: PROJECT_ID,
+        workspaceUserId: ENTRA_OBJECT_ID,
+        messageBlocks: markdownBlocks(),
+      });
+
+      expect(sendToChat).not.toHaveBeenCalled();
+    });
+
+    test("a legacy personal chat with NO captured roster is not matched (absent means unknown, not mine)", async () => {
+      mockProjectAuth({
+        availableChats: {
+          [PERSONAL_CHAT_ID]: personalChat({ memberAadObjectIds: undefined }),
+        },
+      });
+      installFakeCreateAdapter();
+
+      await MicrosoftTeamsUtil.sendDirectMessageToUserAsBot({
+        projectId: PROJECT_ID,
+        workspaceUserId: ENTRA_OBJECT_ID,
+        messageBlocks: markdownBlocks(),
+      });
+
+      expect(sendToChat).not.toHaveBeenCalled();
+    });
+  });
+
+  /*
+   * ----------------------------------------------------------------------- *
+   * (B) Creating the conversation from the Entra id.
+   * -----------------------------------------------------------------------
+   */
+
+  describe("creating the 1:1 conversation via Bot Framework", () => {
+    test("createConversation is asked for a non-group conversation with the member's Entra id and the tenant", async () => {
+      mockProjectAuth();
+      const adapter: FakeCreateAdapter = installFakeCreateAdapter();
+
+      await MicrosoftTeamsUtil.sendDirectMessageToUserAsBot({
+        projectId: PROJECT_ID,
+        workspaceUserId: ENTRA_OBJECT_ID,
+        messageBlocks: markdownBlocks(),
+      });
+
+      expect(adapter.createConversationAsync).toHaveBeenCalledTimes(1);
+      const params: ConversationParameters = adapter
+        .capturedParams[0] as ConversationParameters;
+      expect(params.isGroup).toBe(false);
+      expect(params.members?.[0]?.id).toBe(ENTRA_OBJECT_ID);
+      expect(params.tenantId).toBe(TENANT_ID);
+      expect((params.channelData as { tenant: { id: string } }).tenant.id).toBe(
+        TENANT_ID,
+      );
+      // 28:<appId> is the Teams-side bot account id.
+      expect(params.bot?.id).toBe(`28:${MOCK_APP_CLIENT_ID}`);
+    });
+
+    test("the adaptive card is sent inside the created conversation", async () => {
+      mockProjectAuth();
+      const adapter: FakeCreateAdapter = installFakeCreateAdapter();
+
+      await MicrosoftTeamsUtil.sendDirectMessageToUserAsBot({
+        projectId: PROJECT_ID,
+        workspaceUserId: ENTRA_OBJECT_ID,
+        messageBlocks: markdownBlocks(),
+      });
+
+      expect(adapter.sentActivities).toHaveLength(1);
+      const activity: { attachments: Array<{ contentType: string }> } = adapter
+        .sentActivities[0] as { attachments: Array<{ contentType: string }> };
+      expect(activity.attachments[0]?.contentType).toBe(
+        "application/vnd.microsoft.card.adaptive",
+      );
+    });
+
+    test("falls back to the commercial-cloud serviceUrl when nothing regional was ever captured", async () => {
+      mockProjectAuth();
+      const adapter: FakeCreateAdapter = installFakeCreateAdapter();
+
+      await MicrosoftTeamsUtil.sendDirectMessageToUserAsBot({
+        projectId: PROJECT_ID,
+        workspaceUserId: ENTRA_OBJECT_ID,
+        messageBlocks: markdownBlocks(),
+      });
+
+      expect(adapter.capturedServiceUrls[0]).toBe(DEFAULT_SERVICE_URL);
+    });
+
+    test("prefers a regional serviceUrl captured on ANY chat (required for GCC/DoD)", async () => {
+      mockProjectAuth({
+        availableChats: {
+          "a:someoneelse": personalChat({
+            id: "a:someoneelse",
+            memberAadObjectIds: ["some-other-user"],
+            serviceUrl: REGIONAL_SERVICE_URL,
+          }),
+        },
+      });
+      const adapter: FakeCreateAdapter = installFakeCreateAdapter();
+
+      await MicrosoftTeamsUtil.sendDirectMessageToUserAsBot({
+        projectId: PROJECT_ID,
+        workspaceUserId: ENTRA_OBJECT_ID,
+        messageBlocks: markdownBlocks(),
+      });
+
+      expect(adapter.capturedServiceUrls[0]).toBe(REGIONAL_SERVICE_URL);
+    });
+  });
+
+  /*
+   * ----------------------------------------------------------------------- *
+   * (C) Failure translation and refusals.
+   * -----------------------------------------------------------------------
+   */
+
+  describe("failure translation and refusals", () => {
+    test("Microsoft's roster rejection becomes 'install the OneUptime app', the one fix that works", async () => {
+      mockProjectAuth();
+      installFakeCreateAdapter({
+        createError: new Error(ROSTER_ERROR_TEXT),
+      });
+
+      await expect(
+        MicrosoftTeamsUtil.sendDirectMessageToUserAsBot({
+          projectId: PROJECT_ID,
+          workspaceUserId: ENTRA_OBJECT_ID,
+          messageBlocks: markdownBlocks(),
+        }),
+      ).rejects.toThrow(
+        "The OneUptime app is not installed for this Microsoft Teams user. Ask them to add the OneUptime app in Microsoft Teams (personal scope) so the bot can message them directly.",
+      );
+    });
+
+    test("every other Bot Framework error passes through untouched", async () => {
+      mockProjectAuth();
+      installFakeCreateAdapter({
+        createError: new Error("throttled: too many requests"),
+      });
+
+      await expect(
+        MicrosoftTeamsUtil.sendDirectMessageToUserAsBot({
+          projectId: PROJECT_ID,
+          workspaceUserId: ENTRA_OBJECT_ID,
+          messageBlocks: markdownBlocks(),
+        }),
+      ).rejects.toThrow("throttled: too many requests");
+    });
+
+    test("a project with no Teams integration is refused before the Bot Framework is touched", async () => {
+      jest
+        .spyOn(WorkspaceProjectAuthTokenService, "getProjectAuth")
+        .mockResolvedValue(null as never);
+      const adapter: FakeCreateAdapter = installFakeCreateAdapter();
+
+      await expect(
+        MicrosoftTeamsUtil.sendDirectMessageToUserAsBot({
+          projectId: PROJECT_ID,
+          workspaceUserId: ENTRA_OBJECT_ID,
+          messageBlocks: markdownBlocks(),
+        }),
+      ).rejects.toThrow(
+        "Microsoft Teams integration not found for this project",
+      );
+
+      expect(adapter.createConversationAsync).not.toHaveBeenCalled();
+    });
+
+    test("a project auth row with no tenant id is refused", async () => {
+      jest
+        .spyOn(WorkspaceProjectAuthTokenService, "getProjectAuth")
+        .mockResolvedValue({
+          id: PROJECT_ID,
+          workspaceProjectId: undefined,
+          miscData: miscData(),
+        } as unknown as WorkspaceProjectAuthToken as never);
+      installFakeCreateAdapter();
+
+      await expect(
+        MicrosoftTeamsUtil.sendDirectMessageToUserAsBot({
+          projectId: PROJECT_ID,
+          workspaceUserId: ENTRA_OBJECT_ID,
+          messageBlocks: markdownBlocks(),
+        }),
+      ).rejects.toThrow(BadDataException);
+    });
+  });
+});

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

@@ -7,8 +7,10 @@ import NotificationMethodUtil, {
 import { DropdownOption } from "../../../UI/Components/Dropdown/Dropdown";
 import UserCall from "../../../Models/DatabaseModels/UserCall";
 import UserEmail from "../../../Models/DatabaseModels/UserEmail";
+import UserMicrosoftTeams from "../../../Models/DatabaseModels/UserMicrosoftTeams";
 import UserNotificationRule from "../../../Models/DatabaseModels/UserNotificationRule";
 import UserPush from "../../../Models/DatabaseModels/UserPush";
+import UserSlack from "../../../Models/DatabaseModels/UserSlack";
 import UserSMS from "../../../Models/DatabaseModels/UserSMS";
 import UserTelegram from "../../../Models/DatabaseModels/UserTelegram";
 import UserWebhook from "../../../Models/DatabaseModels/UserWebhook";
@@ -95,6 +97,34 @@ function push(id: string, deviceName?: string): UserPush {
   return model;
 }
 
+function slack(id: string, userName?: string, userId?: string): UserSlack {
+  const model: UserSlack = new UserSlack();
+  model.id = new ObjectID(id);
+  if (userName !== undefined) {
+    model.slackUserName = userName;
+  }
+  if (userId !== undefined) {
+    model.slackUserId = userId;
+  }
+  return model;
+}
+
+function microsoftTeams(
+  id: string,
+  userName?: string,
+  userId?: string,
+): UserMicrosoftTeams {
+  const model: UserMicrosoftTeams = new UserMicrosoftTeams();
+  model.id = new ObjectID(id);
+  if (userName !== undefined) {
+    model.microsoftTeamsUserName = userName;
+  }
+  if (userId !== undefined) {
+    model.microsoftTeamsUserId = userId;
+  }
+  return model;
+}
+
 function emptyModels(): NotificationMethodModels {
   return {
     userCalls: [],
@@ -103,20 +133,25 @@ function emptyModels(): NotificationMethodModels {
     userPush: [],
     userWhatsApps: [],
     userTelegrams: [],
+    userSlacks: [],
+    userMicrosoftTeamsAccounts: [],
     userWebhooks: [],
   };
 }
 
 // A 24-hex-char string is a valid ObjectID.
-const ID: Record<"a" | "b" | "c" | "d" | "e" | "f" | "g", string> = {
-  a: "aaaaaaaaaaaaaaaaaaaaaaaa",
-  b: "bbbbbbbbbbbbbbbbbbbbbbbb",
-  c: "cccccccccccccccccccccccc",
-  d: "dddddddddddddddddddddddd",
-  e: "eeeeeeeeeeeeeeeeeeeeeeee",
-  f: "ffffffffffffffffffffffff",
-  g: "abcabcabcabcabcabcabcabc",
-};
+const ID: Record<"a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i", string> =
+  {
+    a: "aaaaaaaaaaaaaaaaaaaaaaaa",
+    b: "bbbbbbbbbbbbbbbbbbbbbbbb",
+    c: "cccccccccccccccccccccccc",
+    d: "dddddddddddddddddddddddd",
+    e: "eeeeeeeeeeeeeeeeeeeeeeee",
+    f: "ffffffffffffffffffffffff",
+    g: "abcabcabcabcabcabcabcabc",
+    h: "cdecdecdecdecdecdecdecde",
+    i: "fabfabfabfabfabfabfabfab",
+  };
 
 /*
  * A minimal stand-in for a model row: getDisplayItems only needs getColumnValue,
@@ -144,7 +179,9 @@ describe("NotificationMethodUtil.getSelectForNotificationMethods", () => {
       [
         "userCall",
         "userEmail",
+        "userMicrosoftTeams",
         "userPush",
+        "userSlack",
         "userSms",
         "userTelegram",
         "userWebhook",
@@ -171,6 +208,14 @@ describe("NotificationMethodUtil.getSelectForNotificationMethods", () => {
       telegramUserHandle: true,
       telegramChatId: true,
     });
+    expect(select["userSlack"]).toEqual({
+      slackUserName: true,
+      slackUserId: true,
+    });
+    expect(select["userMicrosoftTeams"]).toEqual({
+      microsoftTeamsUserName: true,
+      microsoftTeamsUserId: true,
+    });
   });
 
   test("selects ONLY name for a webhook — never the credential-bearing URL or secret", () => {
@@ -284,6 +329,51 @@ describe("NotificationMethodUtil.getDisplayItems", () => {
     expect(items).toEqual([{ title: "Telegram", value: "999" }]);
   });
 
+  test("prefers the Slack user name over the Slack member id", () => {
+    const items: Array<NotificationMethodDisplayItem> =
+      NotificationMethodUtil.getDisplayItems(
+        reader({
+          userSlack: { slackUserName: "alice", slackUserId: "U0123ABCD" },
+        }),
+      );
+
+    expect(items).toEqual([{ title: "Slack", value: "alice" }]);
+  });
+
+  test("falls back to the Slack member id when the user name is absent", () => {
+    const items: Array<NotificationMethodDisplayItem> =
+      NotificationMethodUtil.getDisplayItems(
+        reader({ userSlack: { slackUserId: "U0123ABCD" } }),
+      );
+
+    expect(items).toEqual([{ title: "Slack", value: "U0123ABCD" }]);
+  });
+
+  test("prefers the Microsoft Teams user name over the Teams user id", () => {
+    const items: Array<NotificationMethodDisplayItem> =
+      NotificationMethodUtil.getDisplayItems(
+        reader({
+          userMicrosoftTeams: {
+            microsoftTeamsUserName: "Alice Example",
+            microsoftTeamsUserId: "29:1abc",
+          },
+        }),
+      );
+
+    expect(items).toEqual([
+      { title: "Microsoft Teams", value: "Alice Example" },
+    ]);
+  });
+
+  test("falls back to the Teams user id when the user name is absent", () => {
+    const items: Array<NotificationMethodDisplayItem> =
+      NotificationMethodUtil.getDisplayItems(
+        reader({ userMicrosoftTeams: { microsoftTeamsUserId: "29:1abc" } }),
+      );
+
+    expect(items).toEqual([{ title: "Microsoft Teams", value: "29:1abc" }]);
+  });
+
   test("ignores a relation whose value is not an object", () => {
     expect(
       NotificationMethodUtil.getDisplayItems(
@@ -306,12 +396,14 @@ describe("NotificationMethodUtil.getDisplayItems", () => {
         reader({
           userPush: { deviceName: "Pixel" },
           userEmail: { email: "jane@example.com" },
+          userSlack: { slackUserName: "alice" },
           userWebhook: { name: "Hook" },
         }),
       );
 
     expect(items).toEqual([
       { title: "Email", value: "jane@example.com" },
+      { title: "Slack", value: "alice" },
       { title: "Webhook", value: "Hook" },
       { title: "Push", value: "Pixel" },
     ]);
@@ -370,6 +462,32 @@ describe("NotificationMethodUtil.getLabel", () => {
     );
   });
 
+  test("labels a Slack method by user name, then member id, then Unknown Account", () => {
+    expect(NotificationMethodUtil.getLabel(slack(ID.a, "alice"))).toBe(
+      "Slack: alice",
+    );
+    expect(
+      NotificationMethodUtil.getLabel(slack(ID.b, undefined, "U0123ABCD")),
+    ).toBe("Slack: U0123ABCD");
+    expect(NotificationMethodUtil.getLabel(slack(ID.c))).toBe(
+      "Slack: Unknown Account",
+    );
+  });
+
+  test("labels a Teams method by user name, then user id, then Unknown Account", () => {
+    expect(
+      NotificationMethodUtil.getLabel(microsoftTeams(ID.a, "Alice Example")),
+    ).toBe("Microsoft Teams: Alice Example");
+    expect(
+      NotificationMethodUtil.getLabel(
+        microsoftTeams(ID.b, undefined, "29:1abc"),
+      ),
+    ).toBe("Microsoft Teams: 29:1abc");
+    expect(NotificationMethodUtil.getLabel(microsoftTeams(ID.c))).toBe(
+      "Microsoft Teams: Unknown Account",
+    );
+  });
+
   test("labels call, sms, whatsapp with the phone number and their prefix", () => {
     expect(NotificationMethodUtil.getLabel(call(ID.a, "+15555550100"))).toBe(
       "Call: +15555550100",
@@ -418,6 +536,8 @@ describe("NotificationMethodUtil.getDropdownOptions", () => {
       userPush: [push(ID.d, "Pixel")],
       userWhatsApps: [whatsApp(ID.e, "+15555550102")],
       userTelegrams: [telegram(ID.f, "@jane")],
+      userSlacks: [slack(ID.h, "alice")],
+      userMicrosoftTeamsAccounts: [microsoftTeams(ID.i, "Alice Example")],
       userWebhooks: [webhook(ID.g, "Hook")],
     };
 
@@ -434,6 +554,8 @@ describe("NotificationMethodUtil.getDropdownOptions", () => {
       "Push: Pixel",
       "WhatsApp: +15555550102",
       "Telegram: @jane",
+      "Slack: alice",
+      "Microsoft Teams: Alice Example",
       "Webhook: Hook",
     ]);
   });
@@ -465,6 +587,8 @@ describe("NotificationMethodUtil.setSelectedMethodOnRule", () => {
       userPush: [push(ID.d, "Pixel")],
       userWhatsApps: [whatsApp(ID.e, "+15555550102")],
       userTelegrams: [telegram(ID.f, "@jane")],
+      userSlacks: [slack(ID.h, "alice")],
+      userMicrosoftTeamsAccounts: [microsoftTeams(ID.i, "Alice Example")],
       userWebhooks: [webhook(ID.g, "Hook")],
     };
   }
@@ -489,6 +613,8 @@ describe("NotificationMethodUtil.setSelectedMethodOnRule", () => {
     expect(rule.userPushId).toBeUndefined();
     expect(rule.userWhatsAppId).toBeUndefined();
     expect(rule.userTelegramId).toBeUndefined();
+    expect(rule.userSlackId).toBeUndefined();
+    expect(rule.userMicrosoftTeamsId).toBeUndefined();
   });
 
   test("maps each method type to its own foreign key", () => {
@@ -499,6 +625,8 @@ describe("NotificationMethodUtil.setSelectedMethodOnRule", () => {
       { id: ID.d, key: "userPushId" },
       { id: ID.e, key: "userWhatsAppId" },
       { id: ID.f, key: "userTelegramId" },
+      { id: ID.h, key: "userSlackId" },
+      { id: ID.i, key: "userMicrosoftTeamsId" },
       { id: ID.g, key: "userWebhookId" },
     ];