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

packages/twenty-server/test/integration/microsoft/calendar/events-import.integration-spec.ts

@@ -0,0 +1,78 @@
+import { randomUUID } from 'node:crypto';
+
+import {
+  CalendarChannelSyncStage,
+  ConnectedAccountProvider,
+} from 'twenty-shared/types';
+
+import { microsoftCalendarEvent } from 'test/integration/microsoft/mocks/microsoft-calendar-event.util';
+import { setupMicrosoftMock } from 'test/integration/microsoft/mocks/setup-microsoft-mock.util';
+import { connectMessagingAccount } from 'test/integration/utils/connect-messaging-account.util';
+import { findImportedCalendarEventTitles } from 'test/integration/utils/find-imported-records.util';
+import { queryCalendarChannel } from 'test/integration/utils/query-messaging.util';
+import { runCalendarChannelEventsImport } from 'test/integration/utils/run-calendar-channel-events-import.util';
+import { runCalendarChannelListFetch } from 'test/integration/utils/run-calendar-channel-list-fetch.util';
+
+const HANDLE = 'microsoft-calendar-events-import@apple.dev';
+
+describe('Microsoft calendar events import (integration)', () => {
+  const microsoft = 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('imports calendar events through the real delta-fetch and import pipeline', async () => {
+    const eventTitle = `Calendar event ${randomUUID()}`;
+
+    microsoft.serveCalendarEvents([
+      microsoftCalendarEvent({ subject: eventTitle }),
+    ]);
+
+    await runCalendarChannelListFetch(channel.calendarChannelId);
+
+    const channelState = await queryCalendarChannel(channel);
+
+    expect(channelState.syncStage).toBe(
+      CalendarChannelSyncStage.CALENDAR_EVENTS_IMPORT_PENDING,
+    );
+
+    await runCalendarChannelEventsImport(channel.calendarChannelId);
+
+    expect(await findImportedCalendarEventTitles([eventTitle])).toEqual([
+      eventTitle,
+    ]);
+  }, 60000);
+
+  it('imports a newly created event through the delta-token continuation', async () => {
+    const newEventTitle = `Calendar event ${randomUUID()}`;
+
+    microsoft.serveCalendarEvents(
+      [microsoftCalendarEvent({ subject: newEventTitle })],
+      { deltaToken: 'mock-calendar-delta-token-2' },
+    );
+
+    await runCalendarChannelListFetch(channel.calendarChannelId);
+
+    const channelState = await queryCalendarChannel(channel);
+
+    expect(channelState.syncStage).toBe(
+      CalendarChannelSyncStage.CALENDAR_EVENTS_IMPORT_PENDING,
+    );
+
+    await runCalendarChannelEventsImport(channel.calendarChannelId);
+
+    expect(await findImportedCalendarEventTitles([newEventTitle])).toEqual([
+      newEventTitle,
+    ]);
+  }, 60000);
+});

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

@@ -0,0 +1,166 @@
+import {
+  CalendarChannelSyncStage,
+  CalendarChannelSyncStatus,
+  ConnectedAccountProvider,
+} from 'twenty-shared/types';
+
+import { CalendarChannelEntity } from 'src/engine/metadata-modules/calendar-channel/entities/calendar-channel.entity';
+import { ConnectedAccountEntity } from 'src/engine/metadata-modules/connected-account/entities/connected-account.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 { getCoreRepository } from 'test/integration/utils/get-core-repository.util';
+import {
+  queryCalendarChannel,
+  queryConnectedAccount,
+} from 'test/integration/utils/query-messaging.util';
+import { resetCalendarChannelSyncState } from 'test/integration/utils/reset-channel-sync-state.util';
+import { runCalendarChannelListFetch } from 'test/integration/utils/run-calendar-channel-list-fetch.util';
+
+const HANDLE = 'microsoft-calendar-error-mapping@apple.dev';
+
+// 429 and 503 are retried inside the Graph client before the driver sees them,
+// so they are exercised through the messaging suite instead.
+const TEMPORARY_FAILURES: [string, MicrosoftGraphFailure][] = [
+  [
+    'a 500 response',
+    { status: 500, code: 'InternalServerError', message: 'Internal error' },
+  ],
+];
+
+describe('Microsoft calendar import error mapping (integration)', () => {
+  const microsoft = 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);
+  });
+
+  beforeEach(async () => {
+    await resetCalendarChannelSyncState(channel.calendarChannelId, '');
+
+    await getCoreRepository<ConnectedAccountEntity>(
+      ConnectedAccountEntity,
+    ).update({ id: channel.connectedAccountId }, { authFailedAt: null });
+  });
+
+  it.each(MICROSOFT_PERMANENT_ACCOUNT_ERROR_CODES)(
+    'fails the calendar channel as insufficient-permissions on the permanent account error %s',
+    async (code) => {
+      microsoft.failCalendarDelta({
+        status: 403,
+        code,
+        message: 'The mailbox is unavailable',
+      });
+
+      await runCalendarChannelListFetch(channel.calendarChannelId);
+
+      const channelState = await queryCalendarChannel(channel);
+
+      expect(channelState.syncStatus).toBe(
+        CalendarChannelSyncStatus.FAILED_INSUFFICIENT_PERMISSIONS,
+      );
+      expect(channelState.syncStage).toBe(CalendarChannelSyncStage.FAILED);
+
+      const account = await queryConnectedAccount(channel.connectedAccountId);
+
+      expect(account.authFailedAt).not.toBeNull();
+    },
+    60000,
+  );
+
+  it.each(TEMPORARY_FAILURES)(
+    'throttles the calendar channel without failing it on %s',
+    async (_label, failure) => {
+      microsoft.failCalendarDelta(failure);
+
+      await runCalendarChannelListFetch(channel.calendarChannelId);
+
+      const channelState = await queryCalendarChannel(channel);
+
+      expect(channelState.throttleFailureCount).toBe(1);
+      expect(channelState.syncStage).toBe(
+        CalendarChannelSyncStage.CALENDAR_EVENT_LIST_FETCH_PENDING,
+      );
+      expect(channelState.syncStatus).not.toBe(
+        CalendarChannelSyncStatus.FAILED_UNKNOWN,
+      );
+    },
+    60000,
+  );
+
+  it('fails the calendar channel as unknown on a 400 bad request', async () => {
+    microsoft.failCalendarDelta({
+      status: 400,
+      code: 'BadRequest',
+      message: 'Invalid delta token',
+    });
+
+    await runCalendarChannelListFetch(channel.calendarChannelId);
+
+    const channelState = await queryCalendarChannel(channel);
+
+    expect(channelState.syncStatus).toBe(
+      CalendarChannelSyncStatus.FAILED_UNKNOWN,
+    );
+    expect(channelState.syncStage).toBe(CalendarChannelSyncStage.FAILED);
+  }, 60000);
+
+  it('leaves the calendar channel untouched on a 404 during list fetch', async () => {
+    microsoft.failCalendarDelta({
+      status: 404,
+      code: 'ResourceNotFound',
+      message: 'Resource not found',
+    });
+
+    await runCalendarChannelListFetch(channel.calendarChannelId);
+
+    const channelState = await queryCalendarChannel(channel);
+
+    expect(channelState.syncStatus).not.toBe(
+      CalendarChannelSyncStatus.FAILED_UNKNOWN,
+    );
+    expect(channelState.throttleFailureCount).toBe(0);
+
+    const storedChannel = await getCoreRepository<CalendarChannelEntity>(
+      CalendarChannelEntity,
+    ).findOneByOrFail({ id: channel.calendarChannelId });
+
+    expect(storedChannel.syncCursor).toBeFalsy();
+  }, 60000);
+
+  it('restarts the calendar channel from a clean cursor on a 410 expired delta token', async () => {
+    microsoft.failCalendarDelta({
+      status: 410,
+      code: 'syncStateNotFound',
+      message: 'The delta token is expired',
+    });
+
+    await runCalendarChannelListFetch(channel.calendarChannelId);
+
+    const channelState = await queryCalendarChannel(channel);
+
+    expect(channelState.syncStage).toBe(
+      CalendarChannelSyncStage.CALENDAR_EVENT_LIST_FETCH_PENDING,
+    );
+    expect(channelState.throttleFailureCount).toBe(0);
+
+    const storedChannel = await getCoreRepository<CalendarChannelEntity>(
+      CalendarChannelEntity,
+    ).findOneByOrFail({ id: channel.calendarChannelId });
+
+    expect(storedChannel.syncCursor).toBeFalsy();
+  }, 60000);
+});

packages/twenty-server/test/integration/microsoft/calendar/token-refresh-failure.integration-spec.ts

@@ -0,0 +1,63 @@
+import {
+  CalendarChannelSyncStage,
+  CalendarChannelSyncStatus,
+  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 { getCoreRepository } from 'test/integration/utils/get-core-repository.util';
+import {
+  queryCalendarChannel,
+  queryConnectedAccount,
+} from 'test/integration/utils/query-messaging.util';
+import { runCalendarChannelListFetch } from 'test/integration/utils/run-calendar-channel-list-fetch.util';
+
+const HANDLE = 'microsoft-calendar-revoked@apple.dev';
+
+const EXPIRED_CREDENTIALS_AT = new Date(Date.now() - 56 * 60 * 1000);
+
+describe('Microsoft calendar token refresh failure (integration)', () => {
+  const microsoft = setupMicrosoftMock({ handle: HANDLE });
+
+  let channel: Awaited<ReturnType<typeof connectMessagingAccount>>;
+
+  beforeAll(async () => {
+    channel = await connectMessagingAccount({
+      provider: ConnectedAccountProvider.MICROSOFT,
+      handle: HANDLE,
+    });
+  }, 120000);
+
+  afterAll(async () => {
+    await channel?.cleanup().catch(() => undefined);
+  });
+
+  it('fails the channel as insufficient-permissions when the refresh token is declined', async () => {
+    // resolveTokens short-circuits on a still-valid access token, so the refresh
+    // token is only consulted once lastCredentialsRefreshedAt is stale.
+    await getCoreRepository<ConnectedAccountEntity>(
+      ConnectedAccountEntity,
+    ).update(
+      { id: channel.connectedAccountId },
+      { lastCredentialsRefreshedAt: EXPIRED_CREDENTIALS_AT },
+    );
+
+    microsoft.declineTokenRefresh();
+
+    await runCalendarChannelListFetch(channel.calendarChannelId);
+
+    const channelState = await queryCalendarChannel(channel);
+
+    expect(channelState.syncStatus).toBe(
+      CalendarChannelSyncStatus.FAILED_INSUFFICIENT_PERMISSIONS,
+    );
+    expect(channelState.syncStage).toBe(CalendarChannelSyncStage.FAILED);
+
+    const account = await queryConnectedAccount(channel.connectedAccountId);
+
+    expect(account.authFailedAt).not.toBeNull();
+  }, 60000);
+});

packages/twenty-server/test/integration/microsoft/calendar/webhook-sync.integration-spec.ts

@@ -0,0 +1,195 @@
+import { randomUUID } from 'node:crypto';
+
+import {
+  CalendarChannelSyncStage,
+  ConnectedAccountProvider,
+} from 'twenty-shared/types';
+
+import { CALENDAR_EVENT_WEBHOOK_SYNC_INLINE_IMPORT_MAX_EVENTS } from 'src/modules/connected-account-sync-webhooks/calendar-event-webhook-sync/constants/calendar-event-webhook-sync-inline-import-max-events.constant';
+
+import { microsoftCalendarEvent } from 'test/integration/microsoft/mocks/microsoft-calendar-event.util';
+import { setupMicrosoftMock } from 'test/integration/microsoft/mocks/setup-microsoft-mock.util';
+import { connectMessagingAccount } from 'test/integration/utils/connect-messaging-account.util';
+import { findCalendarEventAssociationChannelIds } from 'test/integration/utils/find-calendar-event-association-channel-ids.util';
+import { findImportedCalendarEventTitles } from 'test/integration/utils/find-imported-records.util';
+import { queryCalendarChannel } from 'test/integration/utils/query-messaging.util';
+import { runCalendarChannelEventsImport } from 'test/integration/utils/run-calendar-channel-events-import.util';
+import { runCalendarChannelWebhookSync } from 'test/integration/utils/run-calendar-channel-webhook-sync.util';
+
+const HANDLE = 'microsoft-calendar-webhook-sync@apple.dev';
+
+const deltaToken = () => `webhook-sync-delta-token-${randomUUID()}`;
+
+describe('Microsoft calendar webhook sync (integration)', () => {
+  const microsoft = 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('imports a new event in a single job without a separate import run', async () => {
+    const eventTitle = `Webhook event ${randomUUID()}`;
+
+    microsoft.serveCalendarEvents(
+      [microsoftCalendarEvent({ subject: eventTitle })],
+      { deltaToken: deltaToken() },
+    );
+
+    await runCalendarChannelWebhookSync(channel.calendarChannelId);
+
+    expect(await findImportedCalendarEventTitles([eventTitle])).toEqual([
+      eventTitle,
+    ]);
+
+    const channelState = await queryCalendarChannel(channel);
+
+    expect(channelState.syncStage).toBe(
+      CalendarChannelSyncStage.CALENDAR_EVENT_LIST_FETCH_PENDING,
+    );
+  }, 60000);
+
+  it('applies an update to an already imported event', async () => {
+    const eventExternalId = `microsoft-calendar-event-${randomUUID()}`;
+    const originalTitle = `Webhook event ${randomUUID()}`;
+    const updatedTitle = `Webhook event updated ${randomUUID()}`;
+
+    microsoft.serveCalendarEvents(
+      [microsoftCalendarEvent({ id: eventExternalId, subject: originalTitle })],
+      { deltaToken: deltaToken() },
+    );
+
+    await runCalendarChannelWebhookSync(channel.calendarChannelId);
+
+    expect(await findImportedCalendarEventTitles([originalTitle])).toEqual([
+      originalTitle,
+    ]);
+
+    microsoft.serveCalendarEvents(
+      [microsoftCalendarEvent({ id: eventExternalId, subject: updatedTitle })],
+      { deltaToken: deltaToken() },
+    );
+
+    await runCalendarChannelWebhookSync(channel.calendarChannelId);
+
+    expect(await findImportedCalendarEventTitles([updatedTitle])).toEqual([
+      updatedTitle,
+    ]);
+    expect(await findImportedCalendarEventTitles([originalTitle])).toEqual([]);
+  }, 60000);
+
+  it('deletes the calendar event once the delta reports it removed', async () => {
+    const eventExternalId = `microsoft-calendar-event-${randomUUID()}`;
+    const eventTitle = `Webhook removable event ${randomUUID()}`;
+
+    microsoft.serveCalendarEvents(
+      [microsoftCalendarEvent({ id: eventExternalId, subject: eventTitle })],
+      { deltaToken: deltaToken() },
+    );
+
+    await runCalendarChannelWebhookSync(channel.calendarChannelId);
+
+    expect(
+      await findCalendarEventAssociationChannelIds(eventExternalId),
+    ).toEqual([channel.calendarChannelId]);
+
+    microsoft.serveCalendarEvents([], {
+      deltaToken: deltaToken(),
+      removedEventIds: [eventExternalId],
+    });
+
+    await runCalendarChannelWebhookSync(channel.calendarChannelId);
+
+    expect(
+      await findCalendarEventAssociationChannelIds(eventExternalId),
+    ).toEqual([]);
+    expect(await findImportedCalendarEventTitles([eventTitle])).toEqual([]);
+  }, 60000);
+
+  it('keeps the events that the delta did not report removed', async () => {
+    const removedExternalId = `microsoft-calendar-event-${randomUUID()}`;
+    const removedTitle = `Webhook removed ${randomUUID()}`;
+    const survivingTitle = `Webhook surviving ${randomUUID()}`;
+
+    microsoft.serveCalendarEvents(
+      [
+        microsoftCalendarEvent({
+          id: removedExternalId,
+          subject: removedTitle,
+        }),
+        microsoftCalendarEvent({ subject: survivingTitle }),
+      ],
+      { deltaToken: deltaToken() },
+    );
+
+    await runCalendarChannelWebhookSync(channel.calendarChannelId);
+
+    expect(
+      await findImportedCalendarEventTitles([removedTitle, survivingTitle]),
+    ).toEqual([removedTitle, survivingTitle].sort());
+
+    microsoft.serveCalendarEvents([], {
+      deltaToken: deltaToken(),
+      removedEventIds: [removedExternalId],
+    });
+
+    await runCalendarChannelWebhookSync(channel.calendarChannelId);
+
+    expect(await findImportedCalendarEventTitles([removedTitle])).toEqual([]);
+    expect(await findImportedCalendarEventTitles([survivingTitle])).toEqual([
+      survivingTitle,
+    ]);
+  }, 60000);
+
+  it('leaves a delta larger than the inline cap to the import cron', async () => {
+    const eventTitles = Array.from(
+      { length: CALENDAR_EVENT_WEBHOOK_SYNC_INLINE_IMPORT_MAX_EVENTS + 1 },
+      () => `Webhook bulk event ${randomUUID()}`,
+    );
+
+    microsoft.serveCalendarEvents(
+      eventTitles.map((subject) => microsoftCalendarEvent({ subject })),
+      { deltaToken: deltaToken() },
+    );
+
+    await runCalendarChannelWebhookSync(channel.calendarChannelId);
+
+    expect(await findImportedCalendarEventTitles(eventTitles)).toEqual([]);
+
+    const channelState = await queryCalendarChannel(channel);
+
+    expect(channelState.syncStage).toBe(
+      CalendarChannelSyncStage.CALENDAR_EVENTS_IMPORT_PENDING,
+    );
+
+    await runCalendarChannelEventsImport(channel.calendarChannelId);
+
+    expect(await findImportedCalendarEventTitles(eventTitles)).toEqual(
+      [...eventTitles].sort(),
+    );
+  }, 120000);
+
+  it('does not sync when the channel is already being synced', async () => {
+    const eventTitle = `Webhook event ${randomUUID()}`;
+
+    microsoft.serveCalendarEvents(
+      [microsoftCalendarEvent({ subject: eventTitle })],
+      { deltaToken: deltaToken() },
+    );
+
+    await runCalendarChannelWebhookSync(
+      channel.calendarChannelId,
+      CalendarChannelSyncStage.CALENDAR_EVENT_LIST_FETCH_ONGOING,
+    );
+
+    expect(await findImportedCalendarEventTitles([eventTitle])).toEqual([]);
+  }, 60000);
+});