@stamhoofd/backend 2.137.4 → 2.138.0

package/src/services/EmailSendService.test.ts

@@ -0,0 +1,1218 @@
+import type { LimitedFilteredRequest } from '@stamhoofd/structures';
+import { BalanceItemType, EmailRecipientFilter, EmailRecipientsStatus, EmailRecipient as EmailRecipientStruct, EmailRecipientSubfilter, EmailStatus, OrganizationMetaData, PaginatedResponse } from '@stamhoofd/structures';
+import { EmailMocker } from '@stamhoofd/email';
+import { STExpect, TestUtils } from '@stamhoofd/test-utils';
+import { BalanceItemFactory, CachedBalance, Email, EmailRecipient, MemberFactory, OrganizationFactory, Platform, UserFactory } from '@stamhoofd/models';
+import { EmailSendService } from './EmailSendService.js';
+import { Formatter } from '@stamhoofd/utility';
+import { EmailRecipientFilterType } from '@stamhoofd/structures/email/EmailRecipientFilterType.js';
+
+async function buildEmail(data: {
+    recipients: EmailRecipientStruct[];
+} & Partial<Email>) {
+    Email.recipientLoaders.set(EmailRecipientFilterType.Members, {
+        fetch: async (query: LimitedFilteredRequest) => {
+            return Promise.resolve(
+                new PaginatedResponse<EmailRecipientStruct[], LimitedFilteredRequest>({
+                    results: data.recipients,
+                    next: undefined,
+                }),
+            );
+        },
+
+        count: async (query: LimitedFilteredRequest) => {
+            return data.recipients.length;
+        },
+    });
+
+    const model = new Email();
+    model.userId = null;
+    model.organizationId = data.organizationId ?? null;
+    model.recipientFilter = EmailRecipientFilter.create({
+        filters: [
+            EmailRecipientSubfilter.create({
+                type: EmailRecipientFilterType.Members,
+                filter: { id: { $in: ['test'] } },
+            }),
+        ],
+    });
+
+    model.subject = data.subject ?? 'This is a test email';
+    model.html = data.html ?? '<p>This is a test email</p> {{unsubscribeUrl}}';
+    model.text = data.text ?? 'This is a test email {{unsubscribeUrl}}';
+    model.json = data.json ?? {};
+    model.status = data.status ?? EmailStatus.Draft;
+    model.attachments = [];
+    model.fromAddress = data.fromAddress ?? 'test@stamhoofd.be';
+    model.fromName = data.fromName ?? null;
+    model.emailType = data.emailType ?? null;
+
+    await model.save();
+
+    return model;
+}
+
+/**
+ * An email that won't be able to fetch recipients
+ */
+async function buildFailEmail(data: {
+    recipients: EmailRecipientStruct[];
+} & Partial<Email>) {
+    Email.recipientLoaders.set(EmailRecipientFilterType.Members, {
+        fetch: async (query: LimitedFilteredRequest) => {
+            throw new Error('This is a simulated error while fetching recipients');
+        },
+
+        count: async (query: LimitedFilteredRequest) => {
+            return data.recipients.length;
+        },
+    });
+
+    const model = new Email();
+    model.userId = null;
+    model.organizationId = data.organizationId ?? null;
+    model.recipientFilter = EmailRecipientFilter.create({
+        filters: [
+            EmailRecipientSubfilter.create({
+                type: EmailRecipientFilterType.Members,
+                filter: { id: { $in: ['test'] } },
+            }),
+        ],
+    });
+
+    model.subject = data.subject ?? 'This is a test email';
+    model.html = data.html ?? '<p>This is a test email</p> {{unsubscribeUrl}}';
+    model.text = data.text ?? 'This is a test email {{unsubscribeUrl}}';
+    model.json = data.json ?? {};
+    model.status = data.status ?? EmailStatus.Draft;
+    model.attachments = [];
+    model.fromAddress = data.fromAddress ?? 'test@stamhoofd.be';
+    model.fromName = data.fromName ?? null;
+    model.emailType = data.emailType ?? null;
+
+    await model.save();
+
+    return model;
+}
+
+describe('EmailSendService', () => {
+    it('Correctly whitelists email recipients', async () => {
+        TestUtils.setEnvironment('WHITELISTED_EMAIL_DESTINATIONS', ['*@stamhoofd-allowed-domain-tests.be']);
+        const model = await buildEmail({
+            recipients: [
+                EmailRecipientStruct.create({
+                    firstName: 'Test',
+                    lastName: 'Test',
+                    email: 'example@not-whitelisted-domain.be',
+                }),
+                EmailRecipientStruct.create({
+                    firstName: 'Test',
+                    lastName: 'Test',
+                    email: 'example2@stamhoofd-allowed-domain-tests.be',
+                }),
+            ],
+        });
+        await EmailSendService.queueForSending(model, true);
+        await model.refresh();
+
+        // Check if it was sent correctly
+        expect(model.recipientsStatus).toBe(EmailRecipientsStatus.Created);
+        expect(model.emailRecipientsCount).toBe(2);
+        expect(model.succeededCount).toBe(1);
+        expect(model.failedCount).toBe(1);
+        expect(model.emailErrors).toBe(null);
+        expect(model.recipientsErrors).toBe(null);
+        expect(model.status).toBe(EmailStatus.Sent);
+        expect(await EmailMocker.getSucceededCount()).toBe(1);
+        expect(await EmailMocker.getFailedCount()).toBe(0); // never tried to send any failed emails (whitelist)
+
+        // Load recipietns
+        const recipients = await EmailRecipient.select().where('emailId', model.id).fetch();
+        expect(recipients).toIncludeSameMembers([
+            expect.objectContaining({
+                email: 'example2@stamhoofd-allowed-domain-tests.be',
+                sentAt: expect.any(Date),
+                failCount: 0,
+                failErrorMessage: null,
+                firstFailedAt: null,
+                lastFailedAt: null,
+            }),
+            expect.objectContaining({
+                email: 'example@not-whitelisted-domain.be',
+                sentAt: null,
+                failCount: 1,
+                failErrorMessage: 'All recipients are filtered due to environment',
+                firstFailedAt: expect.any(Date),
+                lastFailedAt: expect.any(Date),
+            }),
+        ]);
+    }, 15_000);
+
+    it('Retries emails on network errors', async () => {
+        const model = await buildEmail({
+            recipients: [
+                EmailRecipientStruct.create({
+                    firstName: 'Test',
+                    lastName: 'Test',
+                    email: 'example@domain.be',
+                }),
+                EmailRecipientStruct.create({
+                    firstName: 'Test',
+                    lastName: 'Test',
+                    email: 'example2@domain.be',
+                }),
+            ],
+        });
+
+        // Only one failure (the first email)
+        // It should automatically retry to send the email
+        EmailMocker.broadcast.failNext(new Error('This is a simulated network error'));
+
+        await EmailSendService.queueForSending(model, true);
+        await model.refresh();
+
+        // Check if it was sent correctly
+        expect(model.recipientsStatus).toBe(EmailRecipientsStatus.Created);
+        expect(model.emailRecipientsCount).toBe(2);
+        expect(model.status).toBe(EmailStatus.Sent);
+        expect(model.succeededCount).toBe(2);
+        expect(model.failedCount).toBe(0);
+        expect(model.softFailedCount).toBe(0);
+
+        // Both have succeeded
+        expect(await EmailMocker.getSucceededCount()).toBe(2);
+        expect(await EmailMocker.getFailedCount()).toBe(1); // One retry
+
+        // Load recipietns
+        const recipients = await EmailRecipient.select().where('emailId', model.id).fetch();
+        expect(recipients).toIncludeSameMembers([
+            expect.objectContaining({
+                email: 'example@domain.be',
+                sentAt: expect.any(Date),
+                failCount: 0,
+            }),
+            expect.objectContaining({
+                email: 'example2@domain.be',
+                sentAt: expect.any(Date),
+                failCount: 0,
+            }),
+        ]);
+    }, 15_000);
+
+    it('Email changes to failed state if email recipients fails to build', async () => {
+        const model = await buildFailEmail({
+            recipients: [
+                EmailRecipientStruct.create({
+                    firstName: 'Test',
+                    lastName: 'Test',
+                    email: 'example@domain.be',
+                }),
+                EmailRecipientStruct.create({
+                    firstName: 'Test',
+                    lastName: 'Test',
+                    email: 'example2@domain.be',
+                }),
+            ],
+        });
+
+        await expect(EmailSendService.queueForSending(model, true)).rejects.toThrow();
+        await model.refresh();
+
+        // Check if it was sent correctly
+        expect(model.recipientsStatus).toBe(EmailRecipientsStatus.NotCreated);
+        expect(model.recipientsErrors).toEqual(STExpect.simpleErrors([{
+            code: 'unknown_error',
+            message: 'This is a simulated error while fetching recipients',
+        }]));
+
+        expect(model.emailRecipientsCount).toBe(null);
+        expect(model.status).toBe(EmailStatus.Failed);
+        expect(model.succeededCount).toBe(0);
+        expect(model.failedCount).toBe(0);
+        expect(model.softFailedCount).toBe(0);
+
+        // Both have succeeded
+        expect(await EmailMocker.getSucceededCount()).toBe(0);
+        expect(await EmailMocker.getFailedCount()).toBe(0); // One retry
+    }, 15_000);
+
+    it('Marks email recipient as failed if fails three times', async () => {
+        const model = await buildEmail({
+            recipients: [
+                EmailRecipientStruct.create({
+                    firstName: 'Test',
+                    lastName: 'Test',
+                    email: 'example@domain.be',
+                }),
+                EmailRecipientStruct.create({
+                    firstName: 'Test',
+                    lastName: 'Test',
+                    email: 'example2@domain.be',
+                }),
+            ],
+        });
+
+        EmailMocker.broadcast.failNext(new Error('This is a simulated network error 1'));
+        EmailMocker.broadcast.failNext(new Error('This is a simulated network error 2'));
+        EmailMocker.broadcast.failNext(new Error('This is a simulated network error 3'));
+        EmailMocker.broadcast.failNext(new Error('This is a simulated network error 4'));
+        EmailMocker.broadcast.failNext(new Error('This is a simulated network error 5'));
+        EmailMocker.broadcast.failNext(new Error('This is a simulated network error 6'));
+
+        await EmailSendService.queueForSending(model, true);
+        await model.refresh();
+
+        // Check if it was sent correctly
+        expect(model.recipientsStatus).toBe(EmailRecipientsStatus.Created);
+        expect(model.emailRecipientsCount).toBe(2);
+        expect(model.status).toBe(EmailStatus.Sent);
+        expect(model.succeededCount).toBe(0);
+        expect(model.failedCount).toBe(2);
+        expect(model.softFailedCount).toBe(0);
+
+        // Both have succeeded
+        expect(await EmailMocker.getSucceededCount()).toBe(0);
+        expect(await EmailMocker.getFailedCount()).toBe(6); // Two retries for each recipient
+
+        // Load recipietns
+        const recipients = await EmailRecipient.select().where('emailId', model.id).fetch();
+        expect(recipients).toIncludeSameMembers([
+            expect.objectContaining({
+                email: 'example@domain.be',
+                sentAt: null,
+                failCount: 1,
+                failError: STExpect.simpleErrors([{
+                    message: /This is a simulated network error ([3-6])/,
+                }]),
+                firstFailedAt: expect.any(Date),
+                lastFailedAt: expect.any(Date),
+            }),
+            expect.objectContaining({
+                email: 'example2@domain.be',
+                sentAt: null,
+                failCount: 1,
+                failError: STExpect.simpleErrors([{
+                    message: /This is a simulated network error ([3-6])/,
+                }]),
+                firstFailedAt: expect.any(Date),
+                lastFailedAt: expect.any(Date),
+            }),
+        ]);
+    }, 15_000);
+
+    it('Can handle recipients without name', async () => {
+        const model = await buildEmail({
+            recipients: [
+                EmailRecipientStruct.create({
+                    email: 'example@domain.be',
+                }),
+            ],
+        });
+
+        await EmailSendService.queueForSending(model, true);
+        await model.refresh();
+
+        // Check if it was sent correctly
+        expect(model.recipientsStatus).toBe(EmailRecipientsStatus.Created);
+        expect(model.emailRecipientsCount).toBe(1);
+        expect(model.status).toBe(EmailStatus.Sent);
+        expect(model.succeededCount).toBe(1);
+        expect(model.failedCount).toBe(0);
+        expect(model.softFailedCount).toBe(0);
+
+        // Both have succeeded
+        expect(await EmailMocker.getSucceededCount()).toBe(1);
+        expect(await EmailMocker.getFailedCount()).toBe(0);
+
+        // Load recipietns
+        const recipients = await EmailRecipient.select().where('emailId', model.id).fetch();
+        expect(recipients).toIncludeSameMembers([
+            expect.objectContaining({
+                email: 'example@domain.be',
+                sentAt: expect.any(Date),
+                failCount: 0,
+            }),
+        ]);
+
+        // Check to header
+        expect(EmailMocker.getSucceededEmail(0).to).toEqual('example@domain.be');
+    }, 15_000);
+
+    it('Includes recipient names in mail header', async () => {
+        const model = await buildEmail({
+            recipients: [
+                EmailRecipientStruct.create({
+                    firstName: 'John',
+                    lastName: 'Von Doe',
+                    email: 'example@domain.be',
+                }),
+            ],
+        });
+
+        await EmailSendService.queueForSending(model, true);
+        await model.refresh();
+
+        // Check if it was sent correctly
+        expect(model.recipientsStatus).toBe(EmailRecipientsStatus.Created);
+        expect(model.emailRecipientsCount).toBe(1);
+        expect(model.status).toBe(EmailStatus.Sent);
+        expect(model.succeededCount).toBe(1);
+        expect(model.failedCount).toBe(0);
+        expect(model.softFailedCount).toBe(0);
+
+        // Both have succeeded
+        expect(await EmailMocker.getSucceededCount()).toBe(1);
+        expect(await EmailMocker.getFailedCount()).toBe(0);
+
+        // Load recipietns
+        const recipients = await EmailRecipient.select().where('emailId', model.id).fetch();
+        expect(recipients).toIncludeSameMembers([
+            expect.objectContaining({
+                firstName: 'John',
+                lastName: 'Von Doe',
+                email: 'example@domain.be',
+                sentAt: expect.any(Date),
+                failCount: 0,
+            }),
+        ]);
+
+        // Check to header
+        expect(EmailMocker.getSucceededEmail(0).to).toEqual('"John Von Doe" <example@domain.be>');
+    }, 15_000);
+
+    it('Skips invalid email addresses', async () => {
+        const model = await buildEmail({
+            recipients: [
+                EmailRecipientStruct.create({
+                    firstName: 'John',
+                    lastName: 'Von Doe',
+                    email: 'invalid',
+                }),
+            ],
+        });
+
+        await EmailSendService.queueForSending(model, true);
+        await model.refresh();
+
+        // Check if it was sent correctly
+        expect(model.recipientsStatus).toBe(EmailRecipientsStatus.Created);
+        expect(model.emailRecipientsCount).toBe(1);
+        expect(model.status).toBe(EmailStatus.Sent);
+        expect(model.succeededCount).toBe(0);
+        expect(model.failedCount).toBe(1);
+        expect(model.softFailedCount).toBe(0);
+
+        // Both have succeeded
+        expect(await EmailMocker.getSucceededCount()).toBe(0);
+        expect(await EmailMocker.getFailedCount()).toBe(0);
+
+        // Load recipietns
+        const recipients = await EmailRecipient.select().where('emailId', model.id).fetch();
+        expect(recipients).toIncludeSameMembers([
+            expect.objectContaining({
+                firstName: 'John',
+                lastName: 'Von Doe',
+                email: 'invalid',
+                failCount: 1,
+                failError: STExpect.simpleErrors([{
+                    code: 'invalid_email_address',
+                    message: 'Invalid email address',
+                }]),
+                firstFailedAt: expect.any(Date),
+                lastFailedAt: expect.any(Date),
+            }),
+        ]);
+    }, 15_000);
+
+    it('Skips empty email addresses while creating recipients', async () => {
+        const model = await buildEmail({
+            recipients: [
+                EmailRecipientStruct.create({
+                    firstName: '',
+                    lastName: '',
+                    email: '',
+                }),
+                EmailRecipientStruct.create({
+                    firstName: '',
+                    lastName: '',
+                    email: 'valid@example.com',
+                }),
+            ],
+        });
+
+        await EmailSendService.queueForSending(model, true);
+        await model.refresh();
+
+        // Check if it was sent correctly
+        expect(model.recipientsStatus).toBe(EmailRecipientsStatus.Created);
+        expect(model.emailRecipientsCount).toBe(1);
+        expect(model.status).toBe(EmailStatus.Sent);
+        expect(model.succeededCount).toBe(1);
+        expect(model.failedCount).toBe(0);
+        expect(model.softFailedCount).toBe(0);
+
+        // Both have succeeded
+        expect(await EmailMocker.getSucceededCount()).toBe(1);
+        expect(await EmailMocker.getFailedCount()).toBe(0);
+
+        // Load recipietns
+        const recipients = await EmailRecipient.select().where('emailId', model.id).fetch();
+        expect(recipients).toIncludeSameMembers([
+            expect.objectContaining({
+                email: 'valid@example.com',
+                sentAt: expect.any(Date),
+                failError: null,
+            }),
+        ]);
+    }, 15_000);
+
+    it('Platform can send from default domain', async () => {
+        TestUtils.setEnvironment('domains', {
+            ...STAMHOOFD.domains,
+            defaultTransactionalEmail: {
+                '': 'my-platform.com',
+            },
+            defaultBroadcastEmail: {
+                '': 'broadcast.my-platform.com',
+            },
+        });
+
+        const model = await buildEmail({
+            recipients: [
+                EmailRecipientStruct.create({
+                    email: 'example@domain.be',
+                }),
+            ],
+            fromAddress: 'info@my-platform.com',
+            fromName: 'My Platform',
+        });
+
+        await EmailSendService.queueForSending(model, true);
+        await model.refresh();
+
+        // Check if it was sent correctly
+        expect(model.recipientsStatus).toBe(EmailRecipientsStatus.Created);
+        expect(model.emailRecipientsCount).toBe(1);
+        expect(model.status).toBe(EmailStatus.Sent);
+        expect(model.succeededCount).toBe(1);
+        expect(model.failedCount).toBe(0);
+        expect(model.softFailedCount).toBe(0);
+
+        // Both have succeeded
+        expect(await EmailMocker.getSucceededCount()).toBe(1);
+        expect(await EmailMocker.getFailedCount()).toBe(0);
+
+        // Check to header
+        expect(EmailMocker.getSucceededEmail(0)).toMatchObject({
+            to: 'example@domain.be',
+            from: '"My Platform" <info@my-platform.com>',
+            replyTo: undefined,
+        });
+    }, 15_000);
+
+    it('Platform cannot send from unsupported domain', async () => {
+        TestUtils.setEnvironment('domains', {
+            ...STAMHOOFD.domains,
+            defaultTransactionalEmail: {
+                '': 'my-platform.com',
+            },
+            defaultBroadcastEmail: {
+                '': 'broadcast.my-platform.com',
+            },
+        });
+
+        const model = await buildEmail({
+            recipients: [
+                EmailRecipientStruct.create({
+                    email: 'example@domain.be',
+                }),
+            ],
+            fromAddress: 'info@other-platform.com',
+            fromName: 'My Platform',
+        });
+
+        await EmailSendService.queueForSending(model, true);
+        await model.refresh();
+
+        // Check if it was sent correctly
+        expect(model.recipientsStatus).toBe(EmailRecipientsStatus.Created);
+        expect(model.emailRecipientsCount).toBe(1);
+        expect(model.status).toBe(EmailStatus.Sent);
+        expect(model.succeededCount).toBe(1);
+        expect(model.failedCount).toBe(0);
+        expect(model.softFailedCount).toBe(0);
+
+        // Both have succeeded
+        expect(await EmailMocker.getSucceededCount()).toBe(1);
+        expect(await EmailMocker.getFailedCount()).toBe(0);
+
+        // Check to header
+        expect(EmailMocker.getSucceededEmail(0)).toMatchObject({
+            to: 'example@domain.be',
+            from: '"My Platform" <noreply@broadcast.my-platform.com>', // domain has changed here
+            replyTo: '"My Platform" <info@other-platform.com>', // Reply to should be set
+        });
+    }, 15_000);
+
+    it('Organization cannot send from platform domain', async () => {
+        TestUtils.setEnvironment('domains', {
+            ...STAMHOOFD.domains,
+            defaultTransactionalEmail: {
+                '': 'my-platform.com',
+            },
+            defaultBroadcastEmail: {
+                '': 'broadcast.my-platform.com',
+            },
+        });
+
+        const organization = await new OrganizationFactory({
+            uri: 'uritest',
+        }).create();
+
+        const model = await buildEmail({
+            organizationId: organization.id,
+            recipients: [
+                EmailRecipientStruct.create({
+                    email: 'example@domain.be',
+                }),
+            ],
+            fromAddress: 'info@my-platform.com',
+            fromName: 'My Platform',
+        });
+
+        await EmailSendService.queueForSending(model, true);
+        await model.refresh();
+
+        // Check if it was sent correctly
+        expect(model.recipientsStatus).toBe(EmailRecipientsStatus.Created);
+        expect(model.emailRecipientsCount).toBe(1);
+        expect(model.status).toBe(EmailStatus.Sent);
+        expect(model.succeededCount).toBe(1);
+        expect(model.failedCount).toBe(0);
+        expect(model.softFailedCount).toBe(0);
+
+        // Both have succeeded
+        expect(await EmailMocker.getSucceededCount()).toBe(1);
+        expect(await EmailMocker.getFailedCount()).toBe(0);
+
+        // Check to header
+        expect(EmailMocker.getSucceededEmail(0)).toMatchObject({
+            to: 'example@domain.be',
+            from: '"My Platform" <noreply-uritest@broadcast.my-platform.com>', // domain has changed here
+            replyTo: '"My Platform" <info@my-platform.com>', // Reply to should be set
+        });
+    }, 15_000);
+
+    it('Organization can send from platform domain if default membership organization', async () => {
+        TestUtils.setEnvironment('domains', {
+            ...STAMHOOFD.domains,
+            defaultTransactionalEmail: {
+                '': 'my-platform.com',
+            },
+            defaultBroadcastEmail: {
+                '': 'broadcast.my-platform.com',
+            },
+        });
+
+        const organization = await new OrganizationFactory({}).create();
+
+        const platform = await Platform.getForEditing();
+        platform.membershipOrganizationId = organization.id;
+        await platform.save();
+
+        const model = await buildEmail({
+            organizationId: organization.id,
+            recipients: [
+                EmailRecipientStruct.create({
+                    email: 'example@domain.be',
+                }),
+            ],
+            fromAddress: 'info@my-platform.com',
+            fromName: 'My Platform',
+        });
+
+        await EmailSendService.queueForSending(model, true);
+        await model.refresh();
+
+        // Check if it was sent correctly
+        expect(model.recipientsStatus).toBe(EmailRecipientsStatus.Created);
+        expect(model.emailRecipientsCount).toBe(1);
+        expect(model.status).toBe(EmailStatus.Sent);
+        expect(model.succeededCount).toBe(1);
+        expect(model.failedCount).toBe(0);
+        expect(model.softFailedCount).toBe(0);
+
+        // Both have succeeded
+        expect(await EmailMocker.getSucceededCount()).toBe(1);
+        expect(await EmailMocker.getFailedCount()).toBe(0);
+
+        // Check to header
+        expect(EmailMocker.getSucceededEmail(0)).toMatchObject({
+            to: 'example@domain.be',
+            from: '"My Platform" <info@my-platform.com>', // domain has changed here
+            replyTo: undefined,
+        });
+    }, 15_000);
+
+    describe('Replacements', () => {
+        it('[Regression] When sending an email the organization fromAddress is replaced to the reply-to if it is not allowed to be sent from', async () => {
+            TestUtils.setEnvironment('domains', {
+                ...STAMHOOFD.domains,
+                defaultTransactionalEmail: {
+                    '': 'my-platform.com',
+                },
+                defaultBroadcastEmail: {
+                    '': 'broadcast.my-platform.com',
+                },
+            });
+
+            const organization = await new OrganizationFactory({}).create();
+
+            const model = await buildEmail({
+                organizationId: organization.id,
+                recipients: [
+                    EmailRecipientStruct.create({
+                        email: 'example@domain.be',
+                    }),
+                ],
+                fromAddress: 'custom@customdomain.com',
+                fromName: 'Custom Name',
+                html: '{{fromAddress}}',
+                text: '{{fromAddress}}',
+                subject: '{{fromAddress}}',
+                emailType: 'system-test', // Makes sure we don't need to include unsubscribeUrl
+            });
+
+            await EmailSendService.queueForSending(model, true);
+            await model.refresh();
+
+            // Check if it was sent correctly
+            expect(model.recipientsStatus).toBe(EmailRecipientsStatus.Created);
+            expect(model.emailRecipientsCount).toBe(1);
+            expect(model.status).toBe(EmailStatus.Sent);
+
+            // Both have succeeded
+            expect(await EmailMocker.getSucceededCount()).toBe(1);
+            expect(await EmailMocker.getFailedCount()).toBe(0);
+
+            // Check to header
+            expect(EmailMocker.getSucceededEmail(0)).toMatchObject({
+                to: 'example@domain.be',
+                from: '"Custom Name" <noreply-' + organization.uri + '@broadcast.my-platform.com>',
+                replyTo: '"Custom Name" <custom@customdomain.com>', // domain has changed here
+                subject: 'custom@customdomain.com',
+                html: 'custom@customdomain.com',
+                text: 'custom@customdomain.com',
+            });
+        }, 15_000);
+
+        it('Default organization replacements work as expected', async () => {
+            TestUtils.setEnvironment('domains', {
+                ...STAMHOOFD.domains,
+                defaultTransactionalEmail: {
+                    '': 'my-platform.com',
+                },
+                defaultBroadcastEmail: {
+                    '': 'broadcast.my-platform.com',
+                },
+            });
+
+            const brightYellow = '#FFD700';
+            const expectedContrastColor = '#000'; // black
+
+            const organization = await new OrganizationFactory({
+                meta: OrganizationMetaData.create({
+                    color: brightYellow,
+                }),
+            }).create();
+
+            const model = await buildEmail({
+                organizationId: organization.id,
+                recipients: [
+                    EmailRecipientStruct.create({
+                        email: 'example@domain.be',
+                    }),
+                ],
+                fromAddress: 'custom@customdomain.com',
+                html: '{{primaryColor}};{{primaryColorContrast}};{{organizationName}};{{fromName}}',
+                text: '{{primaryColor}};{{primaryColorContrast}};{{organizationName}};{{fromName}}',
+                subject: '{{primaryColor}};{{primaryColorContrast}};{{organizationName}};{{fromName}}',
+                emailType: 'system-test', // Makes sure we don't need to include unsubscribeUrl
+            });
+
+            await EmailSendService.queueForSending(model, true);
+            await model.refresh();
+
+            // Check if it was sent correctly
+            expect(model.recipientsStatus).toBe(EmailRecipientsStatus.Created);
+            expect(model.emailRecipientsCount).toBe(1);
+            expect(model.status).toBe(EmailStatus.Sent);
+
+            // Both have succeeded
+            expect(await EmailMocker.getSucceededCount()).toBe(1);
+            expect(await EmailMocker.getFailedCount()).toBe(0);
+
+            // Check to header
+            expect(EmailMocker.getSucceededEmail(0)).toMatchObject({
+                subject: `${brightYellow};${expectedContrastColor};${organization.name};${organization.name}`,
+                html: `${brightYellow};${expectedContrastColor};${organization.name};${organization.name}`,
+                text: `${brightYellow};${expectedContrastColor};${organization.name};${organization.name}`,
+            });
+        }, 15_000);
+
+        it('Organization replacements default to platform replacements if not set', async () => {
+            TestUtils.setEnvironment('domains', {
+                ...STAMHOOFD.domains,
+                defaultTransactionalEmail: {
+                    '': 'my-platform.com',
+                },
+                defaultBroadcastEmail: {
+                    '': 'broadcast.my-platform.com',
+                },
+            });
+
+            const brightBlue = '#0000FF';
+            const expectedContrastColor = '#fff'; // white
+
+            const platform = await Platform.getForEditing();
+            platform.config.color = brightBlue;
+            await platform.save();
+
+            const organization = await new OrganizationFactory({
+                meta: OrganizationMetaData.create({
+                    color: null,
+                }),
+            }).create();
+
+            const model = await buildEmail({
+                organizationId: organization.id,
+                recipients: [
+                    EmailRecipientStruct.create({
+                        email: 'example@domain.be',
+                    }),
+                ],
+                fromAddress: 'custom@customdomain.com',
+                fromName: 'Custom Name',
+                html: '{{primaryColor}};{{primaryColorContrast}};{{organizationName}};{{fromName}}',
+                text: '{{primaryColor}};{{primaryColorContrast}};{{organizationName}};{{fromName}}',
+                subject: '{{primaryColor}};{{primaryColorContrast}};{{organizationName}};{{fromName}}',
+                emailType: 'system-test', // Makes sure we don't need to include unsubscribeUrl
+            });
+
+            await EmailSendService.queueForSending(model, true);
+            await model.refresh();
+
+            // Check if it was sent correctly
+            expect(model.recipientsStatus).toBe(EmailRecipientsStatus.Created);
+            expect(model.emailRecipientsCount).toBe(1);
+            expect(model.status).toBe(EmailStatus.Sent);
+
+            // Both have succeeded
+            expect(await EmailMocker.getSucceededCount()).toBe(1);
+            expect(await EmailMocker.getFailedCount()).toBe(0);
+
+            // Check to header
+            expect(EmailMocker.getSucceededEmail(0)).toMatchObject({
+                subject: `${brightBlue};${expectedContrastColor};${organization.name};Custom Name`,
+                html: `${brightBlue};${expectedContrastColor};${organization.name};Custom Name`,
+                text: `${brightBlue};${expectedContrastColor};${organization.name};Custom Name`,
+            });
+        }, 15_000);
+
+        it('Platform replacements are used for platform level emails', async () => {
+            TestUtils.setEnvironment('domains', {
+                ...STAMHOOFD.domains,
+                defaultTransactionalEmail: {
+                    '': 'my-platform.com',
+                },
+                defaultBroadcastEmail: {
+                    '': 'broadcast.my-platform.com',
+                },
+            });
+
+            const darkRed = '#8B0000';
+            const expectedContrastColor = '#fff'; // white
+
+            const platform = await Platform.getForEditing();
+            platform.config.color = darkRed;
+            await platform.save();
+
+            const model = await buildEmail({
+                recipients: [
+                    EmailRecipientStruct.create({
+                        email: 'example@domain.be',
+                    }),
+                ],
+                fromAddress: 'custom@customdomain.com',
+                html: '{{primaryColor}};{{primaryColorContrast}};{{organizationName}};{{fromName}}',
+                text: '{{primaryColor}};{{primaryColorContrast}};{{organizationName}};{{fromName}}',
+                subject: '{{primaryColor}};{{primaryColorContrast}};{{organizationName}};{{fromName}}',
+                emailType: 'system-test', // Makes sure we don't need to include unsubscribeUrl
+            });
+
+            await EmailSendService.queueForSending(model, true);
+            await model.refresh();
+
+            // Check if it was sent correctly
+            expect(model.recipientsStatus).toBe(EmailRecipientsStatus.Created);
+            expect(model.emailRecipientsCount).toBe(1);
+            expect(model.status).toBe(EmailStatus.Sent);
+
+            // Both have succeeded
+            expect(await EmailMocker.getSucceededCount()).toBe(1);
+            expect(await EmailMocker.getFailedCount()).toBe(0);
+
+            // Check to header
+            expect(EmailMocker.getSucceededEmail(0)).toMatchObject({
+                subject: `${darkRed};${expectedContrastColor};${platform.config.name};${platform.config.name}`,
+                html: `${darkRed};${expectedContrastColor};${platform.config.name};${platform.config.name}`,
+                text: `${darkRed};${expectedContrastColor};${platform.config.name};${platform.config.name}`,
+            });
+        }, 15_000);
+
+        describe('User based replacements', () => {
+            it('The balance is added for existing users', async () => {
+                TestUtils.setEnvironment('domains', {
+                    ...STAMHOOFD.domains,
+                    defaultTransactionalEmail: {
+                        '': 'my-platform.com',
+                    },
+                    defaultBroadcastEmail: {
+                        '': 'broadcast.my-platform.com',
+                    },
+                });
+
+                const organization = await new OrganizationFactory({}).create();
+                const existingUser = await new UserFactory({
+                    organization,
+                }).create();
+
+                // Add outstanding balance items for this user
+                const balanceItem = await new BalanceItemFactory({
+                    userId: existingUser.id,
+                    organizationId: organization.id,
+                    type: BalanceItemType.Other,
+                    amount: 2,
+                    unitPrice: 12_99_00,
+                    description: 'Test balance item',
+                }).create();
+                await CachedBalance.updateForUsers(organization.id, [existingUser.id]);
+
+                const model = await buildEmail({
+                    organizationId: organization.id,
+                    recipients: [
+                        EmailRecipientStruct.create({
+                            email: existingUser.email,
+                            userId: existingUser.id,
+                        }),
+                    ],
+                    fromAddress: 'custom@customdomain.com',
+                    html: '<p>{{outstandingBalance}}</p>{{balanceTable}}',
+                    subject: '{{outstandingBalance}}',
+                    emailType: 'system-test', // Makes sure we don't need to include unsubscribeUrl
+                });
+
+                await EmailSendService.queueForSending(model, true);
+                await model.refresh();
+
+                // Check if it was sent correctly
+                expect(model.recipientsStatus).toBe(EmailRecipientsStatus.Created);
+                expect(model.emailRecipientsCount).toBe(1);
+                expect(model.status).toBe(EmailStatus.Sent);
+
+                // Both have succeeded
+                expect(await EmailMocker.getSucceededCount()).toBe(1);
+                expect(await EmailMocker.getFailedCount()).toBe(0);
+
+                const expectedAmount = Formatter.price(balanceItem.unitPrice * balanceItem.amount);
+
+                // Check to header
+                expect(EmailMocker.getSucceededEmail(0)).toMatchObject({
+                    subject: `${expectedAmount}`,
+                });
+
+                expect(EmailMocker.getSucceededEmail(0).html).toMatch('<p>' + expectedAmount + '</p>');
+                expect(EmailMocker.getSucceededEmail(0).text).toMatch(expectedAmount);
+
+                // Check if the table is correct
+                expect(EmailMocker.getSucceededEmail(0).html).toMatch('<table');
+                expect(EmailMocker.getSucceededEmail(0).html).toMatch('2 x '); // amount
+                expect(EmailMocker.getSucceededEmail(0).html).toMatch(Formatter.price(12_99_00)); // unit price
+                expect(EmailMocker.getSucceededEmail(0).html).toMatch('<td>' + expectedAmount); // total price in table
+                expect(EmailMocker.getSucceededEmail(0).html).toMatch('Test balance item'); // description
+
+                expect(EmailMocker.getSucceededEmail(0).text).toMatch('2 x '); // amount
+                expect(EmailMocker.getSucceededEmail(0).text).toMatch(Formatter.price(12_99_00)); // unit price
+                expect(EmailMocker.getSucceededEmail(0).text).toMatch(expectedAmount); // total price in table
+                expect(EmailMocker.getSucceededEmail(0).text?.toLowerCase()).toMatch('test balance item'); // description
+            }, 15_000);
+
+            it('The balance is zero for unknown users', async () => {
+                TestUtils.setEnvironment('domains', {
+                    ...STAMHOOFD.domains,
+                    defaultTransactionalEmail: {
+                        '': 'my-platform.com',
+                    },
+                    defaultBroadcastEmail: {
+                        '': 'broadcast.my-platform.com',
+                    },
+                });
+
+                const organization = await new OrganizationFactory({}).create();
+
+                const model = await buildEmail({
+                    organizationId: organization.id,
+                    recipients: [
+                        EmailRecipientStruct.create({
+                            email: 'unknown-user@example.com',
+                        }),
+                    ],
+                    fromAddress: 'custom@customdomain.com',
+                    html: '<p>{{outstandingBalance}}</p>{{balanceTable}}',
+                    subject: '{{outstandingBalance}}',
+                    emailType: 'system-test', // Makes sure we don't need to include unsubscribeUrl
+                });
+
+                await EmailSendService.queueForSending(model, true);
+                await model.refresh();
+
+                // Check if it was sent correctly
+                expect(model.recipientsStatus).toBe(EmailRecipientsStatus.Created);
+                expect(model.emailRecipientsCount).toBe(1);
+                expect(model.status).toBe(EmailStatus.Sent);
+
+                // Both have succeeded
+                expect(await EmailMocker.getSucceededCount()).toBe(1);
+                expect(await EmailMocker.getFailedCount()).toBe(0);
+
+                const expectedAmount = Formatter.price(0);
+
+                // Check to header
+                expect(EmailMocker.getSucceededEmail(0)).toMatchObject({
+                    subject: `${expectedAmount}`,
+                });
+
+                expect(EmailMocker.getSucceededEmail(0).html).toMatch('<p>' + expectedAmount + '</p>');
+                expect(EmailMocker.getSucceededEmail(0).text).toMatch(expectedAmount);
+
+                // Check if the table is correct
+                expect(EmailMocker.getSucceededEmail(0).html).not.toMatch('<table');
+                expect(EmailMocker.getSucceededEmail(0).html).not.toMatch(' x '); // amount
+                expect(EmailMocker.getSucceededEmail(0).html).toMatch('<p class="description">' + $t('%hX') + '</p>');
+
+                expect(EmailMocker.getSucceededEmail(0).text).not.toMatch(' x '); // amount
+                expect(EmailMocker.getSucceededEmail(0).text?.toLowerCase()).toMatch($t('%hX').toLowerCase());
+            }, 15_000);
+
+            it('loginDetails are added for existing users without password', async () => {
+                TestUtils.setEnvironment('domains', {
+                    ...STAMHOOFD.domains,
+                    defaultTransactionalEmail: {
+                        '': 'my-platform.com',
+                    },
+                    defaultBroadcastEmail: {
+                        '': 'broadcast.my-platform.com',
+                    },
+                });
+
+                const organization = await new OrganizationFactory({}).create();
+                const existingUser = await new UserFactory({
+                    organization,
+                    password: null,
+                }).create();
+
+                const model = await buildEmail({
+                    organizationId: organization.id,
+                    recipients: [
+                        EmailRecipientStruct.create({
+                            email: existingUser.email,
+                            userId: existingUser.id,
+                        }),
+                    ],
+                    fromAddress: 'custom@customdomain.com',
+                    html: '{{loginDetails}}',
+                    emailType: 'system-test', // Makes sure we don't need to include unsubscribeUrl
+                });
+
+                await EmailSendService.queueForSending(model, true);
+                await model.refresh();
+
+                // Check if it was sent correctly
+                expect(model.recipientsStatus).toBe(EmailRecipientsStatus.Created);
+                expect(model.emailRecipientsCount).toBe(1);
+                expect(model.status).toBe(EmailStatus.Sent);
+
+                // Both have succeeded
+                expect(await EmailMocker.getSucceededCount()).toBe(1);
+                expect(await EmailMocker.getFailedCount()).toBe(0);
+
+                expect(EmailMocker.getSucceededEmail(0).html).toMatch(
+                    $t('%1EB', { email: `<strong>${Formatter.escapeHtml(existingUser.email)}</strong>` }),
+                );
+                expect(EmailMocker.getSucceededEmail(0).text).toMatch(
+                    $t('%1EB', { email: existingUser.email }),
+                );
+            }, 15_000);
+
+            it('loginDetails are added for inexisting users', async () => {
+                TestUtils.setEnvironment('domains', {
+                    ...STAMHOOFD.domains,
+                    defaultTransactionalEmail: {
+                        '': 'my-platform.com',
+                    },
+                    defaultBroadcastEmail: {
+                        '': 'broadcast.my-platform.com',
+                    },
+                });
+
+                const organization = await new OrganizationFactory({}).create();
+
+                const model = await buildEmail({
+                    organizationId: organization.id,
+                    recipients: [
+                        EmailRecipientStruct.create({
+                            email: 'unknown@example.com',
+                        }),
+                    ],
+                    fromAddress: 'custom@customdomain.com',
+                    html: '{{loginDetails}}',
+                    emailType: 'system-test', // Makes sure we don't need to include unsubscribeUrl
+                });
+
+                await EmailSendService.queueForSending(model, true);
+                await model.refresh();
+
+                // Check if it was sent correctly
+                expect(model.recipientsStatus).toBe(EmailRecipientsStatus.Created);
+                expect(model.emailRecipientsCount).toBe(1);
+                expect(model.status).toBe(EmailStatus.Sent);
+
+                // Both have succeeded
+                expect(await EmailMocker.getSucceededCount()).toBe(1);
+                expect(await EmailMocker.getFailedCount()).toBe(0);
+
+                expect(EmailMocker.getSucceededEmail(0).html).toMatch(
+                    $t('%1EB', { email: '<strong>unknown@example.com</strong>' }),
+                );
+                expect(EmailMocker.getSucceededEmail(0).text).toMatch(
+                    $t('%1EB', { email: 'unknown@example.com' }),
+                );
+            }, 15_000);
+
+            it('loginDetails are added for existing users with password', async () => {
+                TestUtils.setEnvironment('domains', {
+                    ...STAMHOOFD.domains,
+                    defaultTransactionalEmail: {
+                        '': 'my-platform.com',
+                    },
+                    defaultBroadcastEmail: {
+                        '': 'broadcast.my-platform.com',
+                    },
+                });
+
+                const organization = await new OrganizationFactory({}).create();
+                const existingUser = await new UserFactory({
+                    organization,
+                    password: 'existing',
+                }).create();
+
+                const model = await buildEmail({
+                    organizationId: organization.id,
+                    recipients: [
+                        EmailRecipientStruct.create({
+                            email: existingUser.email,
+                            userId: existingUser.id,
+                        }),
+                    ],
+                    fromAddress: 'custom@customdomain.com',
+                    html: '{{loginDetails}}',
+                    emailType: 'system-test', // Makes sure we don't need to include unsubscribeUrl
+                });
+
+                await EmailSendService.queueForSending(model, true);
+                await model.refresh();
+
+                // Check if it was sent correctly
+                expect(model.recipientsStatus).toBe(EmailRecipientsStatus.Created);
+                expect(model.emailRecipientsCount).toBe(1);
+                expect(model.status).toBe(EmailStatus.Sent);
+
+                // Both have succeeded
+                expect(await EmailMocker.getSucceededCount()).toBe(1);
+                expect(await EmailMocker.getFailedCount()).toBe(0);
+
+                expect(EmailMocker.getSucceededEmail(0).html).toMatch(
+                    $t('%1EA', { email: `<strong>${Formatter.escapeHtml(existingUser.email)}</strong>` }),
+                );
+                expect(EmailMocker.getSucceededEmail(0).text).toMatch(
+                    $t('%1EA', { email: existingUser.email }),
+                );
+            }, 15_000);
+
+            it('loginDetails include member security keys for existing users without password', async () => {
+                TestUtils.setEnvironment('userMode', 'platform');
+                TestUtils.setEnvironment('domains', {
+                    ...STAMHOOFD.domains,
+                    defaultTransactionalEmail: {
+                        '': 'my-platform.com',
+                    },
+                    defaultBroadcastEmail: {
+                        '': 'broadcast.my-platform.com',
+                    },
+                });
+
+                const organization = await new OrganizationFactory({}).create();
+                const existingUser = await new UserFactory({
+                    organization,
+                    password: null,
+                }).create();
+                const member = await new MemberFactory({
+                    organization,
+                    user: existingUser,
+                }).create();
+                member.details.securityCode = '123456790123456'; // 16 chars
+                await member.save();
+
+                // Add a linked member
+
+                const model = await buildEmail({
+                    organizationId: organization.id,
+                    recipients: [
+                        EmailRecipientStruct.create({
+                            email: existingUser.email,
+                            userId: existingUser.id,
+                        }),
+                    ],
+                    fromAddress: 'custom@customdomain.com',
+                    html: '{{loginDetails}}',
+                    emailType: 'system-test', // Makes sure we don't need to include unsubscribeUrl
+                });
+
+                await EmailSendService.queueForSending(model, true);
+                await model.refresh();
+
+                // Check if it was sent correctly
+                expect(model.recipientsStatus).toBe(EmailRecipientsStatus.Created);
+                expect(model.emailRecipientsCount).toBe(1);
+                expect(model.status).toBe(EmailStatus.Sent);
+
+                // Both have succeeded
+                expect(await EmailMocker.getSucceededCount()).toBe(1);
+                expect(await EmailMocker.getFailedCount()).toBe(0);
+
+                expect(EmailMocker.getSucceededEmail(0).html).toMatch(
+                    $t('%1EC', {
+                        firstName: Formatter.escapeHtml(member.firstName),
+                        securityCode: `<span class="style-inline-code">${Formatter.escapeHtml(Formatter.spaceString(member.details.securityCode ?? '', 4, '-'))}</span>`,
+                    }),
+                );
+                expect(EmailMocker.getSucceededEmail(0).text).toMatch(
+                    $t('%1EC', {
+                        firstName: member.firstName,
+                        securityCode: Formatter.spaceString(member.details.securityCode ?? '', 4, '-'),
+                    }),
+                );
+            }, 15_000);
+        });
+    });
+});