snapshot of https://github.com/twentyhq/twenty.git (main, 2026-09-17; blobs > 131072B omitted)

packages/twenty-server/test/integration/microsoft/messaging/cross-folder-move.integration-spec.ts

@@ -0,0 +1,91 @@
+import { randomUUID } from 'node:crypto';
+
+import { ConnectedAccountProvider } from 'twenty-shared/types';
+
+import { setupMicrosoftMock } from 'test/integration/microsoft/mocks/setup-microsoft-mock.util';
+import { connectMessagingAccount } from 'test/integration/utils/connect-messaging-account.util';
+import { findImportedMessageSubjects } from 'test/integration/utils/find-imported-records.util';
+import { runMessageChannelSync } from 'test/integration/utils/run-message-channel-sync.util';
+
+const HANDLE = 'microsoft-cross-folder-move@apple.dev';
+
+const MOVED_SUBJECT = `Microsoft moved message ${randomUUID()}`;
+const DELETED_SUBJECT = `Microsoft deleted message ${randomUUID()}`;
+
+const FOLDERS = [
+  { id: 'inbox', displayName: 'Inbox' },
+  { id: 'sentitems', displayName: 'Sent Items' },
+  { id: 'archive', displayName: 'Archive' },
+];
+
+const inboxMessage = (id: string, subject: string) => ({
+  id,
+  subject,
+  body: { contentType: 'text', content: subject },
+  receivedDateTime: '2026-08-13T00:00:00.000Z',
+  internetMessageId: `<${id}@example.com>`,
+  conversationId: `${id}-conversation`,
+  parentFolderId: 'inbox',
+  isDraft: false,
+  from: { emailAddress: { address: 'sender@external.test' } },
+  toRecipients: [{ emailAddress: { address: HANDLE } }],
+});
+
+const MOVED_MESSAGE = inboxMessage(
+  'microsoft-cross-folder-moved-message',
+  MOVED_SUBJECT,
+);
+const DELETED_MESSAGE = inboxMessage(
+  'microsoft-cross-folder-deleted-message',
+  DELETED_SUBJECT,
+);
+
+describe('Microsoft cross-folder move (integration)', () => {
+  const microsoftMock = setupMicrosoftMock({
+    handle: HANDLE,
+    folders: FOLDERS,
+    messages: [MOVED_MESSAGE, DELETED_MESSAGE],
+  });
+
+  let channel: Awaited<ReturnType<typeof connectMessagingAccount>>;
+  let subjectsAfterInitialSync: string[];
+  let subjectsAfterMoveAndDelete: string[];
+
+  beforeAll(async () => {
+    channel = await connectMessagingAccount({
+      provider: ConnectedAccountProvider.MICROSOFT,
+      handle: HANDLE,
+    });
+
+    await runMessageChannelSync(channel.channelId);
+
+    subjectsAfterInitialSync = await findImportedMessageSubjects([
+      MOVED_SUBJECT,
+      DELETED_SUBJECT,
+    ]);
+
+    microsoftMock.moveMessageToFolder(MOVED_MESSAGE.id, 'archive');
+    microsoftMock.deleteMessage(DELETED_MESSAGE.id);
+
+    await runMessageChannelSync(channel.channelId);
+
+    subjectsAfterMoveAndDelete = await findImportedMessageSubjects([
+      MOVED_SUBJECT,
+      DELETED_SUBJECT,
+    ]);
+  }, 180000);
+
+  afterAll(async () => {
+    await channel?.cleanup().catch(() => undefined);
+  });
+
+  it('imports both inbox messages on the first sync', () => {
+    expect(subjectsAfterInitialSync).toEqual(
+      [MOVED_SUBJECT, DELETED_SUBJECT].sort(),
+    );
+  });
+
+  it('keeps the moved message the archive delta still returns and deletes the one no folder returns', () => {
+    expect(subjectsAfterMoveAndDelete).toEqual([MOVED_SUBJECT]);
+  });
+});

packages/twenty-server/test/integration/microsoft/messaging/folder-discovery.integration-spec.ts

@@ -0,0 +1,40 @@
+import { ConnectedAccountProvider } from 'twenty-shared/types';
+
+import { setupMicrosoftMock } from 'test/integration/microsoft/mocks/setup-microsoft-mock.util';
+import { connectMessagingAccount } from 'test/integration/utils/connect-messaging-account.util';
+import { queryMessageFolders } from 'test/integration/utils/query-messaging.util';
+import { runMessageChannelSync } from 'test/integration/utils/run-message-channel-sync.util';
+
+const HANDLE = 'microsoft-folder-discovery@apple.dev';
+
+describe('Microsoft folder discovery (integration)', () => {
+  setupMicrosoftMock({ handle: HANDLE });
+
+  let channel: Awaited<ReturnType<typeof connectMessagingAccount>>;
+
+  beforeAll(async () => {
+    channel = await connectMessagingAccount({
+      provider: ConnectedAccountProvider.MICROSOFT,
+      handle: HANDLE,
+    });
+  }, 60000);
+
+  afterAll(async () => {
+    await channel?.cleanup().catch(() => undefined);
+  });
+
+  it('discovers Microsoft mail folders through the Graph delta sync', async () => {
+    await runMessageChannelSync(channel.channelId);
+
+    const folders = await queryMessageFolders(channel.channelId);
+
+    expect(
+      Object.fromEntries(
+        folders.map((folder) => [folder.name, folder.isSynced]),
+      ),
+    ).toEqual({
+      Inbox: true,
+      'Sent Items': true,
+    });
+  }, 60000);
+});

packages/twenty-server/test/integration/microsoft/messaging/folder-import-actions.integration-spec.ts

@@ -0,0 +1,109 @@
+import { randomUUID } from 'node:crypto';
+
+import {
+  ConnectedAccountProvider,
+  MessageFolderPendingSyncAction,
+} from 'twenty-shared/types';
+
+import { setupMicrosoftMock } from 'test/integration/microsoft/mocks/setup-microsoft-mock.util';
+import { connectMessagingAccount } from 'test/integration/utils/connect-messaging-account.util';
+import { findImportedMessageSubjects } from 'test/integration/utils/find-imported-records.util';
+import {
+  type MessageFolderDto,
+  queryMessageFolders,
+} from 'test/integration/utils/query-messaging.util';
+import {
+  FOLDER_ACTION_NAMES,
+  MESSAGE_COUNT_ABOVE_V8_SPREAD_ARGUMENT_LIMIT,
+  runFolderActions,
+  runFolderActionsWithoutPendingActions,
+} from 'test/integration/utils/run-folder-actions.util';
+import { runMessageChannelSync } from 'test/integration/utils/run-message-channel-sync.util';
+
+const HANDLE = 'microsoft-folder-actions@apple.dev';
+const DELETED_FOLDER_NAME = 'Inbox';
+const IMPORTED_SUBJECT = `Microsoft inbox message ${randomUUID()}`;
+
+const INBOX_MESSAGE = {
+  id: 'microsoft-folder-actions-message',
+  subject: IMPORTED_SUBJECT,
+  body: { contentType: 'text', content: 'Microsoft inbox body' },
+  receivedDateTime: '2026-08-13T00:00:00.000Z',
+  internetMessageId: '<microsoft-folder-actions@example.com>',
+  conversationId: 'microsoft-folder-actions-conversation',
+  parentFolderId: 'inbox',
+  isDraft: false,
+  from: { emailAddress: { address: 'sender@external.test' } },
+  toRecipients: [{ emailAddress: { address: HANDLE } }],
+};
+
+describe('Microsoft folder actions (integration)', () => {
+  setupMicrosoftMock({ handle: HANDLE, messages: [INBOX_MESSAGE] });
+
+  let channel: Awaited<ReturnType<typeof connectMessagingAccount>>;
+  let messageExternalIdsToImport: string[];
+  let messageExternalIdsWithoutPendingActions: string[];
+  let folders: MessageFolderDto[];
+  let subjectsBeforeFolderDeletion: string[];
+  let subjectsAfterFolderDeletion: string[];
+
+  beforeAll(async () => {
+    channel = await connectMessagingAccount({
+      provider: ConnectedAccountProvider.MICROSOFT,
+      handle: HANDLE,
+    });
+
+    await runMessageChannelSync(channel.channelId);
+
+    subjectsBeforeFolderDeletion = await findImportedMessageSubjects([
+      IMPORTED_SUBJECT,
+    ]);
+
+    messageExternalIdsToImport = await runFolderActions({
+      messageChannelId: channel.channelId,
+      folderNameToDelete: DELETED_FOLDER_NAME,
+    });
+
+    subjectsAfterFolderDeletion = await findImportedMessageSubjects([
+      IMPORTED_SUBJECT,
+    ]);
+    folders = await queryMessageFolders(channel.channelId);
+
+    messageExternalIdsWithoutPendingActions =
+      await runFolderActionsWithoutPendingActions(channel.channelId);
+  }, 180000);
+
+  afterAll(async () => {
+    jest.restoreAllMocks();
+    await channel?.cleanup().catch(() => undefined);
+  });
+
+  it('imports every message id of a folder larger than the spread-argument limit, deduplicated', () => {
+    expect(messageExternalIdsToImport).toHaveLength(
+      MESSAGE_COUNT_ABOVE_V8_SPREAD_ARGUMENT_LIMIT,
+    );
+  });
+
+  it('clears the pending action it processed, keeps the one it failed on, and drops the deleted folder', () => {
+    expect(
+      Object.fromEntries(
+        folders.map((folder) => [folder.name, folder.pendingSyncAction]),
+      ),
+    ).toEqual({
+      'Sent Items': MessageFolderPendingSyncAction.NONE,
+      [FOLDER_ACTION_NAMES.imported]: MessageFolderPendingSyncAction.NONE,
+      [FOLDER_ACTION_NAMES.failing]:
+        MessageFolderPendingSyncAction.FOLDER_IMPORT,
+      [FOLDER_ACTION_NAMES.untouched]: MessageFolderPendingSyncAction.NONE,
+    });
+  });
+
+  it('deletes the messages of the folder marked for deletion', () => {
+    expect(subjectsBeforeFolderDeletion).toEqual([IMPORTED_SUBJECT]);
+    expect(subjectsAfterFolderDeletion).toEqual([]);
+  });
+
+  it('imports nothing when no folder carries a pending action', () => {
+    expect(messageExternalIdsWithoutPendingActions).toEqual([]);
+  });
+});

packages/twenty-server/test/integration/microsoft/messaging/import-error-mapping.integration-spec.ts

@@ -0,0 +1,228 @@
+import { randomUUID } from 'node:crypto';
+
+import { isNonEmptyString } from '@sniptt/guards';
+import {
+  ConnectedAccountProvider,
+  MessageChannelSyncStage,
+  MessageChannelSyncStatus,
+} from 'twenty-shared/types';
+
+import { ConnectedAccountEntity } from 'src/engine/metadata-modules/connected-account/entities/connected-account.entity';
+import { MessageChannelEntity } from 'src/engine/metadata-modules/message-channel/entities/message-channel.entity';
+import { MessageFolderEntity } from 'src/engine/metadata-modules/message-folder/entities/message-folder.entity';
+import { MICROSOFT_PERMANENT_ACCOUNT_ERROR_CODES } from 'src/modules/connected-account/constants/microsoft-permanent-account-error-codes.constant';
+
+import {
+  type MicrosoftGraphFailure,
+  setupMicrosoftMock,
+} from 'test/integration/microsoft/mocks/setup-microsoft-mock.util';
+import { connectMessagingAccount } from 'test/integration/utils/connect-messaging-account.util';
+import { findImportedMessageSubjects } from 'test/integration/utils/find-imported-records.util';
+import { getCoreRepository } from 'test/integration/utils/get-core-repository.util';
+import {
+  queryConnectedAccount,
+  queryMessageChannel,
+} from 'test/integration/utils/query-messaging.util';
+import { resetMessageChannelSyncState } from 'test/integration/utils/reset-channel-sync-state.util';
+import { runMessageChannelSync } from 'test/integration/utils/run-message-channel-sync.util';
+
+const HANDLE = 'microsoft-import-error-mapping@apple.dev';
+
+const FETCHABLE_SUBJECT = `Microsoft fetchable message ${randomUUID()}`;
+const UNFETCHABLE_SUBJECT = `Microsoft unfetchable message ${randomUUID()}`;
+
+const inboxMessage = (id: string, subject: string) => ({
+  id,
+  subject,
+  body: { contentType: 'text', content: subject },
+  receivedDateTime: '2026-08-13T00:00:00.000Z',
+  internetMessageId: `<${id}@example.com>`,
+  conversationId: `${id}-conversation`,
+  parentFolderId: 'inbox',
+  isDraft: false,
+  from: { emailAddress: { address: 'sender@external.test' } },
+  toRecipients: [{ emailAddress: { address: HANDLE } }],
+});
+
+const FETCHABLE_MESSAGE = inboxMessage(
+  'microsoft-import-error-mapping-fetchable-message',
+  FETCHABLE_SUBJECT,
+);
+const UNFETCHABLE_MESSAGE = inboxMessage(
+  'microsoft-import-error-mapping-unfetchable-message',
+  UNFETCHABLE_SUBJECT,
+);
+
+const TEMPORARY_FAILURES: [string, MicrosoftGraphFailure][] = [
+  [
+    'a 429 throttled response',
+    {
+      status: 429,
+      code: 'ApplicationThrottled',
+      message: 'Too many requests',
+    },
+  ],
+  [
+    'a 500 response',
+    { status: 500, code: 'InternalServerError', message: 'Internal error' },
+  ],
+  [
+    'a 503 response',
+    { status: 503, code: 'ServiceUnavailable', message: 'Service unavailable' },
+  ],
+];
+
+describe('Microsoft messaging import error mapping (integration)', () => {
+  const microsoft = setupMicrosoftMock({
+    handle: HANDLE,
+    messages: [FETCHABLE_MESSAGE, UNFETCHABLE_MESSAGE],
+  });
+
+  let channel: Awaited<ReturnType<typeof connectMessagingAccount>>;
+
+  beforeAll(async () => {
+    channel = await connectMessagingAccount({
+      provider: ConnectedAccountProvider.MICROSOFT,
+      handle: HANDLE,
+    });
+  }, 60000);
+
+  afterAll(async () => {
+    await channel?.cleanup().catch(() => undefined);
+  });
+
+  beforeEach(async () => {
+    await resetMessageChannelSyncState(channel.channelId, '');
+
+    await getCoreRepository<ConnectedAccountEntity>(
+      ConnectedAccountEntity,
+    ).update({ id: channel.connectedAccountId }, { authFailedAt: null });
+  });
+
+  it.each(MICROSOFT_PERMANENT_ACCOUNT_ERROR_CODES)(
+    'fails the channel as insufficient-permissions on the permanent account error %s',
+    async (code) => {
+      microsoft.failMessageDelta({
+        status: 403,
+        code,
+        message: 'The mailbox is unavailable',
+      });
+
+      await runMessageChannelSync(channel.channelId);
+
+      const channelState = await queryMessageChannel(channel);
+
+      expect(channelState.syncStatus).toBe(
+        MessageChannelSyncStatus.FAILED_INSUFFICIENT_PERMISSIONS,
+      );
+      expect(channelState.syncStage).toBe(MessageChannelSyncStage.FAILED);
+
+      const account = await queryConnectedAccount(channel.connectedAccountId);
+
+      expect(account.authFailedAt).not.toBeNull();
+    },
+    60000,
+  );
+
+  it.each(TEMPORARY_FAILURES)(
+    'throttles the channel without failing it on %s',
+    async (_label, failure) => {
+      microsoft.failMessageDelta(failure);
+
+      await runMessageChannelSync(channel.channelId);
+
+      const channelState = await queryMessageChannel(channel);
+
+      expect(channelState.throttleFailureCount).toBe(1);
+      expect(channelState.syncStage).toBe(
+        MessageChannelSyncStage.MESSAGE_LIST_FETCH_PENDING,
+      );
+      expect(channelState.syncStatus).not.toBe(
+        MessageChannelSyncStatus.FAILED_UNKNOWN,
+      );
+    },
+    60000,
+  );
+
+  it('fails the channel as unknown on a 400 bad request', async () => {
+    microsoft.failMessageDelta({
+      status: 400,
+      code: 'BadRequest',
+      message: 'Invalid delta token',
+    });
+
+    await runMessageChannelSync(channel.channelId);
+
+    const channelState = await queryMessageChannel(channel);
+
+    expect(channelState.syncStatus).toBe(
+      MessageChannelSyncStatus.FAILED_UNKNOWN,
+    );
+    expect(channelState.syncStage).toBe(MessageChannelSyncStage.FAILED);
+  }, 60000);
+
+  it('fails the channel as unknown when the message list is not found', async () => {
+    microsoft.failMessageDelta({
+      status: 404,
+      code: 'ResourceNotFound',
+      message: 'Resource not found',
+    });
+
+    await runMessageChannelSync(channel.channelId);
+
+    const channelState = await queryMessageChannel(channel);
+
+    expect(channelState.syncStatus).toBe(
+      MessageChannelSyncStatus.FAILED_UNKNOWN,
+    );
+    expect(channelState.syncStage).toBe(MessageChannelSyncStage.FAILED);
+  }, 60000);
+
+  it('restarts the channel from a clean cursor on a 410 expired delta token', async () => {
+    microsoft.failMessageDelta({
+      status: 410,
+      code: 'syncStateNotFound',
+      message: 'The delta token is expired',
+    });
+
+    await runMessageChannelSync(channel.channelId);
+
+    const channelState = await queryMessageChannel(channel);
+
+    expect(channelState.syncStage).toBe(
+      MessageChannelSyncStage.MESSAGE_LIST_FETCH_PENDING,
+    );
+    expect(channelState.syncStatus).not.toBe(
+      MessageChannelSyncStatus.FAILED_UNKNOWN,
+    );
+    expect(channelState.throttleFailureCount).toBe(0);
+
+    const storedChannel = await getCoreRepository<MessageChannelEntity>(
+      MessageChannelEntity,
+    ).findOneByOrFail({ id: channel.channelId });
+
+    expect(storedChannel.syncCursor).toBeFalsy();
+  }, 60000);
+
+  it('imports the rest of the batch and keeps the folder cursors when one listed message is not found on fetch', async () => {
+    microsoft.failMessageFetch(UNFETCHABLE_MESSAGE.id);
+
+    await runMessageChannelSync(channel.channelId);
+
+    expect(
+      await findImportedMessageSubjects([
+        FETCHABLE_SUBJECT,
+        UNFETCHABLE_SUBJECT,
+      ]),
+    ).toEqual([FETCHABLE_SUBJECT]);
+
+    const syncedFolders = await getCoreRepository<MessageFolderEntity>(
+      MessageFolderEntity,
+    ).findBy({ messageChannelId: channel.channelId, isSynced: true });
+
+    expect(syncedFolders.length).toBeGreaterThan(0);
+    expect(
+      syncedFolders.every((folder) => isNonEmptyString(folder.syncCursor)),
+    ).toBe(true);
+  }, 60000);
+});

packages/twenty-server/test/integration/microsoft/messaging/outbound.integration-spec.ts

@@ -0,0 +1,335 @@
+import { randomUUID } from 'node:crypto';
+
+import { ConnectedAccountProvider } from 'twenty-shared/types';
+
+import { ConnectedAccountEntity } from 'src/engine/metadata-modules/connected-account/entities/connected-account.entity';
+
+import { setupMicrosoftMock } from 'test/integration/microsoft/mocks/setup-microsoft-mock.util';
+import { connectMessagingAccount } from 'test/integration/utils/connect-messaging-account.util';
+import { createCalendarEvent } from 'test/integration/utils/create-calendar-event.util';
+import { findImportedCalendarEventTitles } from 'test/integration/utils/find-imported-records.util';
+import { findRecordNodesByFilter } from 'test/integration/utils/find-records-by-filter.util';
+import { getCoreRepository } from 'test/integration/utils/get-core-repository.util';
+import { runMessageChannelSync } from 'test/integration/utils/run-message-channel-sync.util';
+import { sendEmail } from 'test/integration/utils/send-email.util';
+
+const HANDLE = 'microsoft-outbound@apple.dev';
+const ALIAS = 'microsoft-outbound-alias@apple.dev';
+const RECIPIENTS = {
+  to: 'to-recipient@example.com',
+  cc: 'cc-recipient@example.com',
+  bcc: 'bcc-recipient@example.com',
+};
+const DRAFT_SUBJECT = `Microsoft draft ${randomUUID()}`;
+const DRAFT_MESSAGE = {
+  id: 'microsoft-draft-message',
+  subject: DRAFT_SUBJECT,
+  body: { contentType: 'text', content: 'Microsoft draft body' },
+  receivedDateTime: '2026-08-13T00:00:00.000Z',
+  internetMessageId: '<microsoft-draft@example.com>',
+  conversationId: 'microsoft-draft-conversation',
+  parentFolderId: 'drafts',
+  isDraft: true,
+  from: { emailAddress: { address: HANDLE } },
+  toRecipients: [{ emailAddress: { address: RECIPIENTS.to } }],
+  ccRecipients: [{ emailAddress: { address: RECIPIENTS.cc } }],
+  bccRecipients: [{ emailAddress: { address: RECIPIENTS.bcc } }],
+};
+
+describe('Microsoft outbound messaging and calendar creation (integration)', () => {
+  const microsoft = setupMicrosoftMock({
+    handle: HANDLE,
+    aliases: [ALIAS],
+    folders: [
+      { id: 'inbox', displayName: 'Inbox' },
+      { id: 'sentitems', displayName: 'Sent Items' },
+      { id: 'drafts', displayName: 'Drafts' },
+    ],
+    messages: [DRAFT_MESSAGE],
+  });
+
+  let channel: Awaited<ReturnType<typeof connectMessagingAccount>>;
+
+  beforeAll(async () => {
+    channel = await connectMessagingAccount({
+      provider: ConnectedAccountProvider.MICROSOFT,
+      handle: HANDLE,
+    });
+    await runMessageChannelSync(channel.channelId);
+  }, 60000);
+
+  beforeEach(() => {
+    microsoft.createdMessages.length = 0;
+    microsoft.patchedMessages.length = 0;
+    microsoft.sentMessageIds.length = 0;
+    microsoft.createdCalendarEvents.length = 0;
+  });
+
+  afterAll(async () => {
+    await channel?.cleanup().catch(() => undefined);
+  });
+
+  it('sends a reply through Graph with To, CC, and BCC recipients', async () => {
+    const subject = `Microsoft outbound ${randomUUID()}`;
+
+    const result = await sendEmail({
+      connectedAccountId: channel.connectedAccountId,
+      to: RECIPIENTS.to,
+      cc: RECIPIENTS.cc,
+      bcc: RECIPIENTS.bcc,
+      subject,
+      body: '<p>Microsoft reply body</p>',
+      inReplyTo: '<microsoft-parent@example.com>',
+    });
+
+    expect(result).toMatchObject({ success: true });
+    expect(microsoft.patchedMessages).toEqual([
+      expect.objectContaining({
+        subject,
+        toRecipients: [{ emailAddress: { address: RECIPIENTS.to } }],
+        ccRecipients: [{ emailAddress: { address: RECIPIENTS.cc } }],
+        bccRecipients: [{ emailAddress: { address: RECIPIENTS.bcc } }],
+      }),
+    ]);
+    expect(microsoft.sentMessageIds).toEqual(['microsoft-reply-message']);
+    const [message] = await findRecordNodesByFilter<{
+      id: string;
+      isDraft: boolean;
+      messageThreadId: string | null;
+      text: string | null;
+    }>('message', 'messages', 'id isDraft messageThreadId text', {
+      subject: { eq: subject },
+    });
+
+    expect(message).toMatchObject({
+      isDraft: false,
+      messageThreadId: expect.any(String),
+      text: 'Microsoft reply body',
+    });
+    expect(
+      await findRecordNodesByFilter<{
+        messageChannelId: string;
+        messageExternalId: string;
+      }>(
+        'messageChannelMessageAssociation',
+        'messageChannelMessageAssociations',
+        'messageChannelId messageExternalId',
+        { messageId: { eq: message.id } },
+      ),
+    ).toEqual([
+      expect.objectContaining({
+        messageChannelId: channel.channelId,
+        messageExternalId: 'microsoft-reply-message',
+      }),
+    ]);
+    expect(
+      await findRecordNodesByFilter<{ handle: string; role: string }>(
+        'messageParticipant',
+        'messageParticipants',
+        'handle role',
+        { messageId: { eq: message.id } },
+      ),
+    ).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ handle: RECIPIENTS.to, role: 'TO' }),
+        expect.objectContaining({ handle: RECIPIENTS.cc, role: 'CC' }),
+        expect.objectContaining({ handle: RECIPIENTS.bcc, role: 'BCC' }),
+      ]),
+    );
+  }, 60000);
+
+  it('sends a synced Microsoft draft through GraphQL and replaces it in the database', async () => {
+    const [draft] = await findRecordNodesByFilter<{
+      id: string;
+      isDraft: boolean;
+    }>('message', 'messages', 'id isDraft', {
+      subject: { eq: DRAFT_SUBJECT },
+    });
+
+    expect(draft).toMatchObject({
+      isDraft: true,
+    });
+    expect(
+      await findRecordNodesByFilter<{
+        messageChannelId: string;
+        messageExternalId: string;
+      }>(
+        'messageChannelMessageAssociation',
+        'messageChannelMessageAssociations',
+        'messageChannelId messageExternalId',
+        { messageId: { eq: draft.id } },
+      ),
+    ).toEqual([
+      expect.objectContaining({
+        messageChannelId: channel.channelId,
+        messageExternalId: DRAFT_MESSAGE.id,
+      }),
+    ]);
+    expect(
+      await findRecordNodesByFilter<{ handle: string; role: string }>(
+        'messageParticipant',
+        'messageParticipants',
+        'handle role',
+        { messageId: { eq: draft.id } },
+      ),
+    ).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ handle: RECIPIENTS.to, role: 'TO' }),
+        expect.objectContaining({ handle: RECIPIENTS.cc, role: 'CC' }),
+        expect.objectContaining({ handle: RECIPIENTS.bcc, role: 'BCC' }),
+      ]),
+    );
+
+    const result = await sendEmail({
+      connectedAccountId: channel.connectedAccountId,
+      to: RECIPIENTS.to,
+      cc: RECIPIENTS.cc,
+      bcc: RECIPIENTS.bcc,
+      subject: DRAFT_SUBJECT,
+      body: 'Microsoft draft body',
+      draftMessageId: draft.id,
+    });
+
+    expect(result).toMatchObject({ success: true });
+    expect(microsoft.createdMessages).toEqual([
+      expect.objectContaining({
+        subject: DRAFT_SUBJECT,
+        toRecipients: [{ emailAddress: { address: RECIPIENTS.to } }],
+        ccRecipients: [{ emailAddress: { address: RECIPIENTS.cc } }],
+        bccRecipients: [{ emailAddress: { address: RECIPIENTS.bcc } }],
+      }),
+    ]);
+    expect(microsoft.sentMessageIds).toEqual(['microsoft-message-1']);
+    const [sentMessage] = await findRecordNodesByFilter<{
+      id: string;
+      isDraft: boolean;
+      messageThreadId: string | null;
+      text: string | null;
+    }>('message', 'messages', 'id isDraft messageThreadId text', {
+      subject: { eq: DRAFT_SUBJECT },
+    });
+
+    expect(sentMessage).toMatchObject({
+      isDraft: false,
+      messageThreadId: expect.any(String),
+      text: 'Microsoft draft body',
+    });
+    expect(
+      await findRecordNodesByFilter<{
+        messageChannelId: string;
+        messageExternalId: string;
+      }>(
+        'messageChannelMessageAssociation',
+        'messageChannelMessageAssociations',
+        'messageChannelId messageExternalId',
+        { messageId: { eq: sentMessage.id } },
+      ),
+    ).toEqual([
+      expect.objectContaining({
+        messageChannelId: channel.channelId,
+        messageExternalId: 'microsoft-message-1',
+      }),
+    ]);
+    expect(result.messageThreadId).toEqual(expect.any(String));
+  }, 60000);
+
+  it('imports the verified aliases during sync and sends from one of them', async () => {
+    const connectedAccount = await getCoreRepository<ConnectedAccountEntity>(
+      ConnectedAccountEntity,
+    ).findOneByOrFail({ id: channel.connectedAccountId });
+
+    expect(connectedAccount.handleAliases).toEqual([ALIAS]);
+
+    const subject = `Microsoft alias outbound ${randomUUID()}`;
+
+    const result = await sendEmail({
+      connectedAccountId: channel.connectedAccountId,
+      fromHandle: ALIAS,
+      to: RECIPIENTS.to,
+      subject,
+      body: '<p>Microsoft alias body</p>',
+    });
+
+    expect(result).toMatchObject({ success: true });
+    expect(microsoft.createdMessages).toEqual([
+      expect.objectContaining({
+        subject,
+        from: { emailAddress: { address: ALIAS } },
+      }),
+    ]);
+  }, 60000);
+
+  it('replies from a verified alias by patching the reply draft', async () => {
+    const subject = `Microsoft alias reply ${randomUUID()}`;
+
+    const result = await sendEmail({
+      connectedAccountId: channel.connectedAccountId,
+      fromHandle: ALIAS,
+      to: RECIPIENTS.to,
+      subject,
+      body: '<p>Microsoft alias reply body</p>',
+      inReplyTo: '<microsoft-parent@example.com>',
+    });
+
+    expect(result).toMatchObject({ success: true });
+    expect(microsoft.patchedMessages).toEqual([
+      expect.objectContaining({
+        subject,
+        from: { emailAddress: { address: ALIAS } },
+      }),
+    ]);
+  }, 60000);
+
+  it('refuses to send from an address the account has not verified', async () => {
+    const result = await sendEmail({
+      connectedAccountId: channel.connectedAccountId,
+      fromHandle: 'not-my-alias@apple.dev',
+      to: RECIPIENTS.to,
+      subject: `Microsoft rejected sender ${randomUUID()}`,
+      body: '<p>Microsoft rejected body</p>',
+    });
+
+    expect(result).toMatchObject({
+      success: false,
+      error: expect.stringContaining(
+        'is not the connected account handle nor one of its verified aliases',
+      ),
+    });
+    expect(microsoft.createdMessages).toEqual([]);
+  }, 60000);
+
+  it('creates and persists a calendar event with invitations and conferencing', async () => {
+    const title = `Microsoft calendar outbound ${randomUUID()}`;
+
+    const result = await createCalendarEvent({
+      connectedAccountId: channel.connectedAccountId,
+      title,
+      description: 'Planning meeting',
+      location: 'Room 101',
+      startsAt: '2026-08-13T09:00:00Z',
+      endsAt: '2026-08-13T10:00:00Z',
+      timeZone: 'UTC',
+      attendees: RECIPIENTS.to,
+      sendInvitations: true,
+      addConferencing: true,
+    });
+
+    expect(result).toMatchObject({ success: true });
+    expect(result.iCalUid).toContain('@microsoft.com');
+    expect(microsoft.createdCalendarEvents).toEqual([
+      expect.objectContaining({
+        subject: title,
+        location: { displayName: 'Room 101' },
+        attendees: [
+          {
+            emailAddress: { address: RECIPIENTS.to },
+            type: 'required',
+          },
+        ],
+        isOnlineMeeting: true,
+        onlineMeetingProvider: 'teamsForBusiness',
+      }),
+    ]);
+    expect(await findImportedCalendarEventTitles([title])).toEqual([title]);
+  }, 60000);
+});