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

packages/twenty-server/test/integration/workflow-actions/send-email/drivers/gmail.integration-spec.ts

@@ -0,0 +1,167 @@
+import { randomUUID } from 'node:crypto';
+
+import { ConnectedAccountProvider } from 'twenty-shared/types';
+
+import { setupGoogleMock } from 'test/integration/google/mocks/setup-google-mock.util';
+import { runWorkflowActionStep } from 'test/integration/graphql/suites/workflow/utils/run-workflow-action-step.util';
+import { connectMessagingAccount } from 'test/integration/utils/connect-messaging-account.util';
+import { findRecordNodesByFilter } from 'test/integration/utils/find-records-by-filter.util';
+import { setTestConnectedAccountHandleAliases } from 'test/integration/utils/set-test-connected-account-handle-aliases.util';
+
+const HANDLE = 'gmail-send-email-action@apple.dev';
+const ALIAS = 'gmail-send-email-action-alias@apple.dev';
+const RECIPIENTS = {
+  to: 'to-recipient@example.com',
+  cc: 'cc-recipient@example.com',
+  bcc: 'bcc-recipient@example.com',
+};
+
+describe('SEND_EMAIL workflow action on Gmail (integration)', () => {
+  const google = setupGoogleMock({ handle: HANDLE });
+
+  let channel: Awaited<ReturnType<typeof connectMessagingAccount>>;
+
+  beforeAll(async () => {
+    channel = await connectMessagingAccount({
+      provider: ConnectedAccountProvider.GOOGLE,
+      handle: HANDLE,
+    });
+    await setTestConnectedAccountHandleAliases({
+      connectedAccountId: channel.connectedAccountId,
+      handleAliases: [ALIAS],
+    });
+  }, 60000);
+
+  afterAll(async () => {
+    await channel?.cleanup().catch(() => undefined);
+  });
+
+  it('sends an email with recipients resolved from the trigger payload', async () => {
+    const subject = `Gmail workflow send ${randomUUID()}`;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'Gmail send email workflow',
+      stepType: 'SEND_EMAIL',
+      input: {
+        connectedAccountId: channel.connectedAccountId,
+        recipients: {
+          to: '{{trigger.to}}',
+          cc: '{{trigger.cc}}',
+          bcc: '{{trigger.bcc}}',
+        },
+        subject: '{{trigger.subject}}',
+        body: '<p>Gmail workflow body</p>',
+      },
+      payload: { ...RECIPIENTS, subject },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'COMPLETED',
+      stepStatus: 'SUCCESS',
+    });
+    expect(workflowRun.stepResult).toMatchObject({
+      recipients: [RECIPIENTS.to],
+      ccRecipients: [RECIPIENTS.cc],
+      bccRecipients: [RECIPIENTS.bcc],
+      subject,
+      connectedAccountId: channel.connectedAccountId,
+      messageId: expect.any(String),
+      messageThreadId: expect.any(String),
+    });
+    expect(google.sentMessages).toHaveLength(1);
+
+    const [{ raw }] = google.sentMessages;
+
+    expect(raw).toContain(`To: ${RECIPIENTS.to}`);
+    expect(raw).toContain(`Cc: ${RECIPIENTS.cc}`);
+    expect(raw).toContain(`Bcc: ${RECIPIENTS.bcc}`);
+    expect(raw).toContain(`Subject: ${subject}`);
+
+    const [message] = await findRecordNodesByFilter<{
+      id: string;
+      isDraft: boolean;
+      text: string | null;
+    }>('message', 'messages', 'id isDraft text', {
+      subject: { eq: subject },
+    });
+
+    expect(message).toMatchObject({
+      isDraft: false,
+      text: 'Gmail workflow body',
+    });
+    expect(
+      await findRecordNodesByFilter<{ messageChannelId: string }>(
+        'messageChannelMessageAssociation',
+        'messageChannelMessageAssociations',
+        'messageChannelId',
+        { messageId: { eq: message.id } },
+      ),
+    ).toEqual([
+      expect.objectContaining({ messageChannelId: channel.channelId }),
+    ]);
+    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 from a verified alias configured on the step', async () => {
+    const subject = `Gmail workflow alias send ${randomUUID()}`;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'Gmail alias send email workflow',
+      stepType: 'SEND_EMAIL',
+      input: {
+        connectedAccountId: channel.connectedAccountId,
+        fromHandle: ALIAS,
+        recipients: { to: RECIPIENTS.to, cc: '', bcc: '' },
+        subject,
+        body: '<p>Gmail workflow alias body</p>',
+      },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'COMPLETED',
+      stepStatus: 'SUCCESS',
+    });
+
+    const [{ raw }] = google.sentMessages.slice(-1);
+
+    expect(raw).toContain(`<${ALIAS}>`);
+  }, 60000);
+
+  it('fails the step when the from handle is not a verified alias', async () => {
+    const sentMessageCount = google.sentMessages.length;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'Gmail rejected sender send email workflow',
+      stepType: 'SEND_EMAIL',
+      input: {
+        connectedAccountId: channel.connectedAccountId,
+        fromHandle: 'not-my-alias@apple.dev',
+        recipients: { to: RECIPIENTS.to, cc: '', bcc: '' },
+        subject: `Gmail workflow rejected sender ${randomUUID()}`,
+        body: '<p>Gmail workflow rejected body</p>',
+      },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'FAILED',
+      stepStatus: 'FAILED',
+      stepError: expect.stringContaining(
+        'is not the connected account handle nor one of its verified aliases',
+      ),
+    });
+    expect(google.sentMessages).toHaveLength(sentMessageCount);
+  }, 60000);
+});

packages/twenty-server/test/integration/workflow-actions/send-email/drivers/imap-smtp.integration-spec.ts

@@ -0,0 +1,186 @@
+import { randomUUID } from 'node:crypto';
+
+import { isNonEmptyString } from '@sniptt/guards';
+
+import { EmailConnectionSecurity } from 'src/engine/core-modules/imap-smtp-caldav-connection/enums/email-connection-security.enum';
+import { MessageChannelEntity } from 'src/engine/metadata-modules/message-channel/entities/message-channel.entity';
+
+import { runWorkflowActionStep } from 'test/integration/graphql/suites/workflow/utils/run-workflow-action-step.util';
+import { deleteConnectedAccount } from 'test/integration/metadata/suites/connected-account/utils/delete-connected-account.util';
+import { saveImapSmtpCaldavAccount } from 'test/integration/metadata/suites/connected-account/utils/save-imap-smtp-caldav-account.util';
+import { updateConfigVariable } from 'test/integration/twenty-config/utils/update-config-variable.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 {
+  type GreenmailServer,
+  startGreenmailContainer,
+} from 'test/integration/utils/start-greenmail-container.util';
+
+const PASSWORD = 'greenmail-password';
+const HANDLE = `smtp-send-email-action-${randomUUID()}@acme.test`;
+
+describe('SEND_EMAIL workflow action on SMTP (integration)', () => {
+  let greenmail: GreenmailServer;
+  let connectedAccountId: string;
+  let messageChannelId: string;
+
+  beforeAll(async () => {
+    await updateConfigVariable({
+      input: { key: 'OUTBOUND_HTTP_ALLOWED_INTERNAL_HOSTS', value: ['*'] },
+    });
+
+    greenmail = await startGreenmailContainer({
+      username: HANDLE,
+      password: PASSWORD,
+    });
+
+    const { data } = await saveImapSmtpCaldavAccount({
+      input: {
+        handle: HANDLE,
+        connectionParameters: {
+          IMAP: {
+            host: greenmail.host,
+            port: greenmail.imapPort,
+            username: HANDLE.split('@')[0],
+            password: PASSWORD,
+            connectionSecurity: EmailConnectionSecurity.NONE,
+          },
+          SMTP: {
+            host: greenmail.host,
+            port: greenmail.smtpPort,
+            username: HANDLE.split('@')[0],
+            password: PASSWORD,
+            connectionSecurity: EmailConnectionSecurity.NONE,
+          },
+        },
+      },
+      expectToFail: false,
+    });
+
+    connectedAccountId = data.connectedAccountId;
+    messageChannelId = (
+      await getCoreRepository<MessageChannelEntity>(
+        MessageChannelEntity,
+      ).findOneByOrFail({ connectedAccountId })
+    ).id;
+
+    await runMessageChannelSync(messageChannelId);
+  }, 300000);
+
+  afterAll(async () => {
+    await updateConfigVariable({
+      input: { key: 'OUTBOUND_HTTP_ALLOWED_INTERNAL_HOSTS', value: [] },
+    }).catch(() => undefined);
+
+    if (isNonEmptyString(connectedAccountId)) {
+      await deleteConnectedAccount({
+        id: connectedAccountId,
+        expectToFail: false,
+      }).catch(() => undefined);
+    }
+
+    await greenmail?.stop().catch(() => undefined);
+  });
+
+  it('sends an email over SMTP and persists it', async () => {
+    const subject = `IMAP/SMTP workflow send ${randomUUID()}`;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'IMAP/SMTP send email workflow',
+      stepType: 'SEND_EMAIL',
+      input: {
+        connectedAccountId,
+        recipients: {
+          to: '{{trigger.to}}',
+          cc: '{{trigger.cc}}',
+          bcc: '{{trigger.bcc}}',
+        },
+        subject: '{{trigger.subject}}',
+        body: '<p>SMTP workflow body</p>',
+      },
+      payload: { to: HANDLE, cc: HANDLE, bcc: HANDLE, subject },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'COMPLETED',
+      stepStatus: 'SUCCESS',
+    });
+    expect(workflowRun.stepResult).toMatchObject({
+      recipients: [HANDLE],
+      ccRecipients: [HANDLE],
+      bccRecipients: [HANDLE],
+      subject,
+      connectedAccountId,
+      messageId: expect.any(String),
+      messageThreadId: expect.any(String),
+    });
+
+    const [message] = await findRecordNodesByFilter<{
+      id: string;
+      isDraft: boolean;
+      text: string | null;
+    }>('message', 'messages', 'id isDraft text', {
+      subject: { eq: subject },
+    });
+
+    expect(message).toMatchObject({
+      isDraft: false,
+      text: 'SMTP workflow body',
+    });
+    expect(
+      await findRecordNodesByFilter<{ messageChannelId: string }>(
+        'messageChannelMessageAssociation',
+        'messageChannelMessageAssociations',
+        'messageChannelId',
+        { messageId: { eq: message.id } },
+      ),
+    ).toEqual([expect.objectContaining({ messageChannelId })]);
+    expect(
+      await findRecordNodesByFilter<{ handle: string; role: string }>(
+        'messageParticipant',
+        'messageParticipants',
+        'handle role',
+        { messageId: { eq: message.id } },
+      ),
+    ).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ handle: HANDLE, role: 'TO' }),
+        expect.objectContaining({ handle: HANDLE, role: 'CC' }),
+        expect.objectContaining({ handle: HANDLE, role: 'BCC' }),
+      ]),
+    );
+  }, 300000);
+
+  it('fails the step when the from handle is not a verified alias', async () => {
+    const subject = `IMAP/SMTP workflow rejected sender ${randomUUID()}`;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'IMAP/SMTP rejected sender send email workflow',
+      stepType: 'SEND_EMAIL',
+      input: {
+        connectedAccountId,
+        fromHandle: 'not-my-alias@acme.test',
+        recipients: { to: HANDLE, cc: '', bcc: '' },
+        subject,
+        body: '<p>SMTP workflow rejected body</p>',
+      },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'FAILED',
+      stepStatus: 'FAILED',
+      stepError: expect.stringContaining(
+        'is not the connected account handle nor one of its verified aliases',
+      ),
+    });
+    expect(
+      await findRecordNodesByFilter<{ id: string }>(
+        'message',
+        'messages',
+        'id',
+        { subject: { eq: subject } },
+      ),
+    ).toEqual([]);
+  }, 300000);
+});

packages/twenty-server/test/integration/workflow-actions/send-email/drivers/microsoft.integration-spec.ts

@@ -0,0 +1,176 @@
+import { randomUUID } from 'node:crypto';
+
+import { ConnectedAccountProvider } from 'twenty-shared/types';
+
+import { runWorkflowActionStep } from 'test/integration/graphql/suites/workflow/utils/run-workflow-action-step.util';
+import { setupMicrosoftMock } from 'test/integration/microsoft/mocks/setup-microsoft-mock.util';
+import { connectMessagingAccount } from 'test/integration/utils/connect-messaging-account.util';
+import { findRecordNodesByFilter } from 'test/integration/utils/find-records-by-filter.util';
+import { setTestConnectedAccountHandleAliases } from 'test/integration/utils/set-test-connected-account-handle-aliases.util';
+
+const HANDLE = 'microsoft-send-email-action@apple.dev';
+const ALIAS = 'microsoft-send-email-action-alias@apple.dev';
+const RECIPIENTS = {
+  to: 'to-recipient@example.com',
+  cc: 'cc-recipient@example.com',
+  bcc: 'bcc-recipient@example.com',
+};
+
+describe('SEND_EMAIL workflow action on Microsoft (integration)', () => {
+  const microsoft = setupMicrosoftMock({ handle: HANDLE });
+
+  let channel: Awaited<ReturnType<typeof connectMessagingAccount>>;
+
+  beforeAll(async () => {
+    channel = await connectMessagingAccount({
+      provider: ConnectedAccountProvider.MICROSOFT,
+      handle: HANDLE,
+    });
+    await setTestConnectedAccountHandleAliases({
+      connectedAccountId: channel.connectedAccountId,
+      handleAliases: [ALIAS],
+    });
+  }, 60000);
+
+  afterAll(async () => {
+    await channel?.cleanup().catch(() => undefined);
+  });
+
+  it('sends an email with recipients resolved from the trigger payload', async () => {
+    const subject = `Microsoft workflow send ${randomUUID()}`;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'Microsoft send email workflow',
+      stepType: 'SEND_EMAIL',
+      input: {
+        connectedAccountId: channel.connectedAccountId,
+        recipients: {
+          to: '{{trigger.to}}',
+          cc: '{{trigger.cc}}',
+          bcc: '{{trigger.bcc}}',
+        },
+        subject: '{{trigger.subject}}',
+        body: '<p>Microsoft workflow body</p>',
+      },
+      payload: { ...RECIPIENTS, subject },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'COMPLETED',
+      stepStatus: 'SUCCESS',
+    });
+    expect(workflowRun.stepResult).toMatchObject({
+      recipients: [RECIPIENTS.to],
+      ccRecipients: [RECIPIENTS.cc],
+      bccRecipients: [RECIPIENTS.bcc],
+      subject,
+      connectedAccountId: channel.connectedAccountId,
+      messageId: expect.any(String),
+      messageThreadId: expect.any(String),
+    });
+    expect(microsoft.createdMessages).toEqual([
+      expect.objectContaining({
+        subject,
+        toRecipients: [{ emailAddress: { address: RECIPIENTS.to } }],
+        ccRecipients: [{ emailAddress: { address: RECIPIENTS.cc } }],
+        bccRecipients: [{ emailAddress: { address: RECIPIENTS.bcc } }],
+      }),
+    ]);
+    expect(microsoft.sentMessageIds).toEqual(['microsoft-message-1']);
+
+    const [message] = await findRecordNodesByFilter<{
+      id: string;
+      isDraft: boolean;
+      text: string | null;
+    }>('message', 'messages', 'id isDraft text', {
+      subject: { eq: subject },
+    });
+
+    expect(message).toMatchObject({
+      isDraft: false,
+      text: 'Microsoft workflow body',
+    });
+    expect(
+      await findRecordNodesByFilter<{
+        messageChannelId: string;
+        messageExternalId: string;
+      }>(
+        'messageChannelMessageAssociation',
+        'messageChannelMessageAssociations',
+        'messageChannelId messageExternalId',
+        { messageId: { eq: message.id } },
+      ),
+    ).toEqual([
+      expect.objectContaining({
+        messageChannelId: channel.channelId,
+        messageExternalId: 'microsoft-message-1',
+      }),
+    ]);
+    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 from a verified alias configured on the step', async () => {
+    const subject = `Microsoft workflow alias send ${randomUUID()}`;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'Microsoft alias send email workflow',
+      stepType: 'SEND_EMAIL',
+      input: {
+        connectedAccountId: channel.connectedAccountId,
+        fromHandle: ALIAS,
+        recipients: { to: RECIPIENTS.to, cc: '', bcc: '' },
+        subject,
+        body: '<p>Microsoft workflow alias body</p>',
+      },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'COMPLETED',
+      stepStatus: 'SUCCESS',
+    });
+    const [lastCreatedMessage] = microsoft.createdMessages.slice(-1);
+
+    expect(lastCreatedMessage).toMatchObject({
+      subject,
+      from: { emailAddress: { address: ALIAS } },
+    });
+  }, 60000);
+
+  it('fails the step when the from handle is not a verified alias', async () => {
+    const createdMessageCount = microsoft.createdMessages.length;
+
+    const workflowRun = await runWorkflowActionStep({
+      name: 'Microsoft rejected sender send email workflow',
+      stepType: 'SEND_EMAIL',
+      input: {
+        connectedAccountId: channel.connectedAccountId,
+        fromHandle: 'not-my-alias@apple.dev',
+        recipients: { to: RECIPIENTS.to, cc: '', bcc: '' },
+        subject: `Microsoft workflow rejected sender ${randomUUID()}`,
+        body: '<p>Microsoft workflow rejected body</p>',
+      },
+    });
+
+    expect(workflowRun).toMatchObject({
+      status: 'FAILED',
+      stepStatus: 'FAILED',
+      stepError: expect.stringContaining(
+        'is not the connected account handle nor one of its verified aliases',
+      ),
+    });
+    expect(microsoft.createdMessages).toHaveLength(createdMessageCount);
+  }, 60000);
+});