@stamhoofd/backend 2.133.0 → 2.135.0

package/src/endpoints/organization/dashboard/balance-items/GetBalanceItemsEndpoint.test.ts

@@ -0,0 +1,183 @@
+import { Request } from '@simonbackx/simple-endpoints';
+import type { Organization, User } from '@stamhoofd/models';
+import { BalanceItemFactory, GroupFactory, MemberFactory, OrderFactory, OrganizationFactory, RegistrationFactory, Token, UserFactory, WebshopFactory } from '@stamhoofd/models';
+import type { BalanceItem as BalanceItemStruct, PaginatedResponse, StamhoofdFilter } from '@stamhoofd/structures';
+import { BalanceItemRelation, BalanceItemRelationType, BalanceItemType, LimitedFilteredRequest, PermissionLevel, Permissions, TranslatedString } from '@stamhoofd/structures';
+import { testServer } from '../../../../../tests/helpers/TestServer.js';
+import { GetBalanceItemsEndpoint } from './GetBalanceItemsEndpoint.js';
+
+describe('Endpoint.GetBalanceItemsEndpoint', () => {
+    const endpoint = new GetBalanceItemsEndpoint();
+
+    const getBalanceItems = async ({ filter, organization, user }: { filter: StamhoofdFilter | null; organization: Organization; user: User }) => {
+        const token = await Token.createToken(user);
+
+        const request = Request.get({
+            path: '/balance-items',
+            host: organization.getApiHost(),
+            query: new LimitedFilteredRequest({
+                filter,
+                limit: 100,
+            }),
+            headers: {
+                authorization: 'Bearer ' + token.accessToken,
+            },
+        });
+
+        return testServer.test<PaginatedResponse<BalanceItemStruct[], LimitedFilteredRequest>>(endpoint, request);
+    };
+
+    const createFinanceUser = async (organization: Organization) => {
+        return await new UserFactory({
+            organization,
+            permissions: Permissions.create({ level: PermissionLevel.Full }),
+        }).create();
+    };
+
+    describe('Filtering on the associated webshop', () => {
+        test('only returns balance items linked to an order of the given webshop', async () => {
+            const organization = await new OrganizationFactory({}).create();
+            const user = await createFinanceUser(organization);
+
+            const webshop = await new WebshopFactory({ organizationId: organization.id }).create();
+            const otherWebshop = await new WebshopFactory({ organizationId: organization.id }).create();
+
+            const order = await new OrderFactory({ webshop }).create();
+            const otherOrder = await new OrderFactory({ webshop: otherWebshop }).create();
+
+            const matchingItem = await new BalanceItemFactory({
+                organizationId: organization.id,
+                orderId: order.id,
+                type: BalanceItemType.Order,
+                amount: 1,
+                unitPrice: 10_00,
+            }).create();
+
+            // Negative controls: an order of another webshop and an item without an order
+            await new BalanceItemFactory({
+                organizationId: organization.id,
+                orderId: otherOrder.id,
+                type: BalanceItemType.Order,
+                amount: 1,
+                unitPrice: 10_00,
+            }).create();
+            await new BalanceItemFactory({
+                organizationId: organization.id,
+                type: BalanceItemType.Other,
+                amount: 1,
+                unitPrice: 10_00,
+            }).create();
+
+            const response = await getBalanceItems({
+                filter: {
+                    order: {
+                        webshopId: {
+                            $in: [webshop.id],
+                        },
+                    },
+                },
+                organization,
+                user,
+            });
+
+            expect(response.status).toBe(200);
+            expect(response.body.results.map(r => r.id)).toEqual([matchingItem.id]);
+        });
+    });
+
+    describe('Filtering on the associated group', () => {
+        test('only returns balance items linked to a registration of the given group', async () => {
+            const organization = await new OrganizationFactory({}).create();
+            const user = await createFinanceUser(organization);
+
+            const member = await new MemberFactory({}).create();
+            const group = await new GroupFactory({ organization }).create();
+            const otherGroup = await new GroupFactory({ organization }).create();
+
+            const registration = await new RegistrationFactory({ member, group }).create();
+            const otherRegistration = await new RegistrationFactory({ member, group: otherGroup }).create();
+
+            const matchingItem = await new BalanceItemFactory({
+                organizationId: organization.id,
+                registrationId: registration.id,
+                type: BalanceItemType.Registration,
+                amount: 1,
+                unitPrice: 10_00,
+            }).create();
+
+            // Negative control: a registration for another group
+            await new BalanceItemFactory({
+                organizationId: organization.id,
+                registrationId: otherRegistration.id,
+                type: BalanceItemType.Registration,
+                amount: 1,
+                unitPrice: 10_00,
+            }).create();
+
+            const response = await getBalanceItems({
+                filter: {
+                    registration: {
+                        groupId: {
+                            $in: [group.id],
+                        },
+                    },
+                },
+                organization,
+                user,
+            });
+
+            expect(response.status).toBe(200);
+            expect(response.body.results.map(r => r.id)).toEqual([matchingItem.id]);
+        });
+    });
+
+    describe('Filtering on the membership type', () => {
+        const createMembershipItem = async ({ organization, membershipTypeId }: { organization: Organization; membershipTypeId: string }) => {
+            return await new BalanceItemFactory({
+                organizationId: organization.id,
+                type: BalanceItemType.PlatformMembership,
+                amount: 1,
+                unitPrice: 10_00,
+                relations: new Map([
+                    [
+                        BalanceItemRelationType.MembershipType,
+                        BalanceItemRelation.create({
+                            id: membershipTypeId,
+                            name: new TranslatedString('Membership type'),
+                        }),
+                    ],
+                ]),
+            }).create();
+        };
+
+        test('only returns balance items whose membership type relation matches', async () => {
+            const organization = await new OrganizationFactory({}).create();
+            const user = await createFinanceUser(organization);
+
+            const membershipTypeId = 'membership-type-a';
+            const matchingItem = await createMembershipItem({ organization, membershipTypeId });
+
+            // Negative controls: a different membership type and an item without any relation
+            await createMembershipItem({ organization, membershipTypeId: 'membership-type-b' });
+            await new BalanceItemFactory({
+                organizationId: organization.id,
+                type: BalanceItemType.Other,
+                amount: 1,
+                unitPrice: 10_00,
+            }).create();
+
+            const response = await getBalanceItems({
+                filter: {
+                    membershipType: {
+                        $in: [membershipTypeId],
+                    },
+                },
+                organization,
+                user,
+            });
+
+            expect(response.status).toBe(200);
+            expect(response.body.results.map(r => r.id)).toEqual([matchingItem.id]);
+        });
+    });
+});

package/src/endpoints/organization/dashboard/organization/PatchOrganizationEndpoint.ts

@@ -161,6 +161,8 @@ export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, Res
                 }
                 organization.privateMeta.privateKey = request.body.privateMeta.privateKey ?? organization.privateMeta.privateKey;
                 organization.privateMeta.featureFlags = patchObject(organization.privateMeta.featureFlags, request.body.privateMeta.featureFlags);
+                organization.privateMeta.externalSyncData = patchObject(organization.privateMeta.externalSyncData, request.body.privateMeta.externalSyncData);
+                organization.privateMeta.externalGroupNumber = patchObject(organization.privateMeta.externalGroupNumber, request.body.privateMeta.externalGroupNumber);
                 organization.privateMeta.balanceNotificationSettings = patchObject(organization.privateMeta.balanceNotificationSettings, request.body.privateMeta.balanceNotificationSettings);
                 organization.privateMeta.invoiceSettings = patchObject(organization.privateMeta.invoiceSettings, request.body.privateMeta.invoiceSettings);
                 organization.privateMeta.recordAnswers = request.body.privateMeta.recordAnswers.applyTo(organization.privateMeta.recordAnswers);

package/src/endpoints/organization/dashboard/organization/SetUitpasClientCredentialsEndpoint.ts

@@ -84,14 +84,7 @@ export class SetUitpasClientCredentialsEndpoint extends Endpoint<Params, Query,
 
         // store the client credentials and store new status in one operation
         if (!reEvaluation) {
-            const valid = await UitpasService.storeIfValid(organization.id, request.body.clientId, request.body.clientSecret);
-            if (!valid) {
-                throw new SimpleError({
-                    message: 'The provided client credentials are not valid',
-                    code: 'invalid_client_credentials',
-                    human: $t('%1BG'),
-                });
-            }
+            await UitpasService.storeIfValid(organization.id, request.body.clientId, request.body.clientSecret);
         }
         organization.meta.uitpasClientCredentialsStatus = UitpasClientCredentialsStatus.NotChecked;
         await organization.save();

package/src/endpoints/organization/dashboard/payments/GetPaymentsEndpoint.test.ts

@@ -0,0 +1,158 @@
+import { Request } from '@simonbackx/simple-endpoints';
+import type { Organization, User } from '@stamhoofd/models';
+import { BalanceItem, BalanceItemFactory, BalanceItemPayment, OrderFactory, OrganizationFactory, Payment, Token, UserFactory, WebshopFactory } from '@stamhoofd/models';
+import type { PaginatedResponse, PaymentGeneral, StamhoofdFilter } from '@stamhoofd/structures';
+import { BalanceItemRelation, BalanceItemRelationType, BalanceItemType, LimitedFilteredRequest, PaymentMethod, PaymentStatus, PermissionLevel, Permissions, TranslatedString } from '@stamhoofd/structures';
+import { testServer } from '../../../../../tests/helpers/TestServer.js';
+import { GetPaymentsEndpoint } from './GetPaymentsEndpoint.js';
+
+// These tests exercise the balance-item filters reused inside the payments query (balanceItemPayments ->
+// balanceItem -> ...), which is the path where balance_items is joined into another query.
+describe('Endpoint.GetPaymentsEndpoint', () => {
+    const endpoint = new GetPaymentsEndpoint();
+
+    const getPayments = async ({ filter, organization, user }: { filter: StamhoofdFilter | null; organization: Organization; user: User }) => {
+        const token = await Token.createToken(user);
+
+        const request = Request.get({
+            path: '/payments',
+            host: organization.getApiHost(),
+            query: new LimitedFilteredRequest({
+                filter,
+                limit: 100,
+            }),
+            headers: {
+                authorization: 'Bearer ' + token.accessToken,
+            },
+        });
+
+        return testServer.test<PaginatedResponse<PaymentGeneral[], LimitedFilteredRequest>>(endpoint, request);
+    };
+
+    const createFinanceUser = async (organization: Organization) => {
+        return await new UserFactory({
+            organization,
+            permissions: Permissions.create({ level: PermissionLevel.Full }),
+        }).create();
+    };
+
+    const createPaymentForBalanceItem = async (organization: Organization, balanceItem: BalanceItem) => {
+        const payment = new Payment();
+        payment.method = PaymentMethod.Transfer;
+        payment.status = PaymentStatus.Succeeded;
+        payment.organizationId = organization.id;
+        payment.price = 10_00;
+        await payment.save();
+
+        const balanceItemPayment = new BalanceItemPayment();
+        balanceItemPayment.balanceItemId = balanceItem.id;
+        balanceItemPayment.paymentId = payment.id;
+        balanceItemPayment.price = 10_00;
+        balanceItemPayment.organizationId = organization.id;
+        await balanceItemPayment.save();
+
+        return payment;
+    };
+
+    describe('Filtering on the balance item of a payment', () => {
+        test('only returns payments whose balance item is linked to an order of the given webshop', async () => {
+            const organization = await new OrganizationFactory({}).create();
+            const user = await createFinanceUser(organization);
+
+            const webshop = await new WebshopFactory({ organizationId: organization.id }).create();
+            const otherWebshop = await new WebshopFactory({ organizationId: organization.id }).create();
+
+            const order = await new OrderFactory({ webshop }).create();
+            const otherOrder = await new OrderFactory({ webshop: otherWebshop }).create();
+
+            const matchingItem = await new BalanceItemFactory({
+                organizationId: organization.id,
+                orderId: order.id,
+                type: BalanceItemType.Order,
+                amount: 1,
+                unitPrice: 10_00,
+            }).create();
+            const matchingPayment = await createPaymentForBalanceItem(organization, matchingItem);
+
+            // Negative control: a payment for a balance item of another webshop's order
+            const otherItem = await new BalanceItemFactory({
+                organizationId: organization.id,
+                orderId: otherOrder.id,
+                type: BalanceItemType.Order,
+                amount: 1,
+                unitPrice: 10_00,
+            }).create();
+            await createPaymentForBalanceItem(organization, otherItem);
+
+            const response = await getPayments({
+                filter: {
+                    balanceItemPayments: {
+                        $elemMatch: {
+                            balanceItem: {
+                                order: {
+                                    webshopId: {
+                                        $in: [webshop.id],
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+                organization,
+                user,
+            });
+
+            expect(response.status).toBe(200);
+            expect(response.body.results.map(r => r.id)).toEqual([matchingPayment.id]);
+        });
+
+        test('only returns payments whose balance item matches the given membership type', async () => {
+            const organization = await new OrganizationFactory({}).create();
+            const user = await createFinanceUser(organization);
+
+            const createMembershipItem = async (membershipTypeId: string) => {
+                return await new BalanceItemFactory({
+                    organizationId: organization.id,
+                    type: BalanceItemType.PlatformMembership,
+                    amount: 1,
+                    unitPrice: 10_00,
+                    relations: new Map([
+                        [
+                            BalanceItemRelationType.MembershipType,
+                            BalanceItemRelation.create({
+                                id: membershipTypeId,
+                                name: new TranslatedString('Membership type'),
+                            }),
+                        ],
+                    ]),
+                }).create();
+            };
+
+            const matchingItem = await createMembershipItem('membership-type-a');
+            const matchingPayment = await createPaymentForBalanceItem(organization, matchingItem);
+
+            // Negative control: a payment for a balance item with a different membership type
+            const otherItem = await createMembershipItem('membership-type-b');
+            await createPaymentForBalanceItem(organization, otherItem);
+
+            const response = await getPayments({
+                filter: {
+                    balanceItemPayments: {
+                        $elemMatch: {
+                            balanceItem: {
+                                membershipType: {
+                                    $in: ['membership-type-a'],
+                                },
+                            },
+                        },
+                    },
+                },
+                organization,
+                user,
+            });
+
+            expect(response.status).toBe(200);
+            expect(response.body.results.map(r => r.id)).toEqual([matchingPayment.id]);
+        });
+    });
+});

package/src/endpoints/organization/dashboard/webshops/PatchWebshopEndpoint.test.ts

@@ -0,0 +1,49 @@
+import { Request } from '@simonbackx/simple-endpoints';
+import { OrganizationFactory, Token, UserFactory, Webshop, WebshopFactory } from '@stamhoofd/models';
+import { PermissionLevel, Permissions, PrivateWebshop, WebshopMetaData } from '@stamhoofd/structures';
+import { Language } from '@stamhoofd/types/Language';
+import { TestUtils } from '@stamhoofd/test-utils';
+
+import { testServer } from '../../../../../tests/helpers/TestServer.js';
+import { PatchWebshopEndpoint } from './PatchWebshopEndpoint.js';
+
+describe('Endpoint.PatchWebshop', () => {
+    const endpoint = new PatchWebshopEndpoint();
+
+    beforeEach(async () => {
+        TestUtils.setEnvironment('userMode', 'platform');
+    });
+
+    async function createAdminContext() {
+        const organization = await new OrganizationFactory({}).create();
+        const user = await new UserFactory({
+            organization,
+            permissions: Permissions.create({
+                level: PermissionLevel.Full,
+            }),
+        }).create();
+        const token = await Token.createToken(user);
+
+        return { organization, token };
+    }
+
+    test('defaultLanguage can be updated', async () => {
+        const { organization, token } = await createAdminContext();
+        const webshop = await new WebshopFactory({ organizationId: organization.id }).create();
+
+        const patch = PrivateWebshop.patch({
+            meta: WebshopMetaData.patch({
+                defaultLanguage: Language.French,
+            }),
+        });
+        const request = Request.buildJson('PATCH', '/webshop/' + webshop.id, organization.getApiHost(), patch);
+        request.headers.authorization = 'Bearer ' + token.accessToken;
+
+        const response = await testServer.test(endpoint, request);
+        expect(response.body.meta.defaultLanguage).toBe(Language.French);
+
+        // Persisted in the database
+        const reloaded = await Webshop.getByID(webshop.id);
+        expect(reloaded?.meta.defaultLanguage).toBe(Language.French);
+    });
+});

package/src/endpoints/organization/dashboard/webshops/PatchWebshopOrdersEndpoint.test.ts

@@ -0,0 +1,71 @@
+import type { PatchableArrayAutoEncoder } from '@simonbackx/simple-encoding';
+import { PatchableArray } from '@simonbackx/simple-encoding';
+import { Request } from '@simonbackx/simple-endpoints';
+import { Order, OrganizationFactory, Token, UserFactory, WebshopFactory } from '@stamhoofd/models';
+import { Cart, CartItem, Customer, OrderData, PaymentMethod, PermissionLevel, Permissions, PrivateOrder, Product, ProductPrice, WebshopMetaData } from '@stamhoofd/structures';
+import { TestUtils } from '@stamhoofd/test-utils';
+import { Language } from '@stamhoofd/types/Language';
+import { v4 as uuidv4 } from 'uuid';
+
+import { testServer } from '../../../../../tests/helpers/TestServer.js';
+import { PatchWebshopOrdersEndpoint } from './PatchWebshopOrdersEndpoint.js';
+
+describe('Endpoint.PatchWebshopOrders', () => {
+    const endpoint = new PatchWebshopOrdersEndpoint();
+
+    beforeEach(async () => {
+        TestUtils.setEnvironment('userMode', 'platform');
+    });
+
+    test('Manually created orders use the webshop default language', async () => {
+        const organization = await new OrganizationFactory({}).create();
+        const user = await new UserFactory({
+            organization,
+            permissions: Permissions.create({
+                level: PermissionLevel.Full,
+            }),
+        }).create();
+        const token = await Token.createToken(user);
+
+        const freeProductPrice = ProductPrice.create({ name: 'Free', price: 0, stock: 100 });
+        const product = Product.create({ name: 'Product', stock: 100, prices: [freeProductPrice] });
+
+        const webshop = await new WebshopFactory({
+            organizationId: organization.id,
+            meta: WebshopMetaData.patch({ defaultLanguage: Language.French }),
+            products: [product],
+        }).create();
+
+        const orderData = OrderData.create({
+            paymentMethod: PaymentMethod.Unknown,
+            cart: Cart.create({
+                items: [
+                    CartItem.create({ product, productPrice: freeProductPrice, amount: 1 }),
+                ],
+            }),
+            customer: Customer.create({
+                firstName: 'John',
+                lastName: 'Doe',
+                email: 'john@example.com',
+            }),
+        });
+
+        const patchArray: PatchableArrayAutoEncoder<PrivateOrder> = new PatchableArray();
+        patchArray.addPut(PrivateOrder.create({
+            id: uuidv4(),
+            data: orderData,
+            webshopId: webshop.id,
+        }));
+
+        const r = Request.buildJson('PATCH', `/webshop/${webshop.id}/orders`, organization.getApiHost(), patchArray);
+        r.headers.authorization = 'Bearer ' + token.accessToken;
+
+        const response = await testServer.test(endpoint, r);
+        expect(response.body).toHaveLength(1);
+        expect(response.body[0].consumerLanguage).toEqual(Language.French);
+
+        // Persisted in the dedicated column
+        const orderModel = (await Order.getByID(response.body[0].id))!;
+        expect(orderModel.consumerLanguage).toEqual(Language.French);
+    });
+});

package/src/endpoints/organization/dashboard/webshops/PatchWebshopOrdersEndpoint.ts

@@ -123,6 +123,10 @@ export class PatchWebshopOrdersEndpoint extends Endpoint<Params, Query, Body, Re
                 model.status = struct.status;
                 model.data = struct.data;
 
+                // Manually created orders have no customer request language, so use the webshop's
+                // default language for any future emails to this order.
+                model.consumerLanguage = webshop.meta.defaultLanguage;
+
                 // For now, we don't invalidate tickets, because they will get invalidated at scan time (the order status is checked)
                 // This allows you to revalidate a ticket without needing to generate a new one (e.g. when accidentally canceling an order)
                 // -> the user doesn't need to download the ticket again

package/src/endpoints/organization/webshops/GetWebshopEndpoint.test.ts

@@ -1,6 +1,7 @@
 import { Request } from '@simonbackx/simple-endpoints';
 import { OrganizationFactory, Token, UserFactory, WebshopFactory } from '@stamhoofd/models';
 import { PermissionLevel, Permissions, WebshopAuthType, WebshopMetaData } from '@stamhoofd/structures';
+import { Language } from '@stamhoofd/types/Language';
 
 import { STExpect, TestUtils } from '@stamhoofd/test-utils';
 import { testServer } from '../../../../tests/helpers/TestServer.js';
@@ -30,6 +31,16 @@ describe('Endpoint.GetWebshop', () => {
         expect((response.body as any).privateMeta).toBeUndefined();
     });
 
+    test('Webshop defaults to Dutch as its default language', async () => {
+        const organization = await new OrganizationFactory({}).create();
+        const webshop = await new WebshopFactory({ organizationId: organization.id }).create();
+
+        const r = Request.buildJson('GET', '/webshop/' + webshop.id, organization.getApiHost());
+
+        const response = await testServer.test(endpoint, r);
+        expect(response.body.meta.defaultLanguage).toBe(Language.Dutch);
+    });
+
     test('Allow access without organization scope', async () => {
         const organization = await new OrganizationFactory({}).create();
         const webshop = await new WebshopFactory({ organizationId: organization.id }).create();

package/src/endpoints/organization/webshops/OrderConfirmationEmailLanguage.test.ts

@@ -0,0 +1,70 @@
+import { Request } from '@simonbackx/simple-endpoints';
+import { EmailMocker } from '@stamhoofd/email';
+import { EmailTemplateFactory, OrganizationFactory, WebshopFactory } from '@stamhoofd/models';
+import { Cart, CartItem, Customer, EmailTemplateType, OrderData, PaymentMethod, Product, ProductPrice } from '@stamhoofd/structures';
+import { TestUtils } from '@stamhoofd/test-utils';
+import { Country } from '@stamhoofd/types/Country';
+import { Language } from '@stamhoofd/types/Language';
+
+import { testServer } from '../../../../tests/helpers/TestServer.js';
+import { PlaceOrderEndpoint } from './PlaceOrderEndpoint.js';
+
+describe('Order confirmation email language', () => {
+    const endpoint = new PlaceOrderEndpoint();
+
+    test('renders $t in the language the customer used while ordering', async () => {
+        // Make French a valid locale so its real translations (loaded from disk) are actually used.
+        TestUtils.setEnvironment('locales', { [Country.Belgium]: [Language.Dutch, Language.French] });
+
+        const organization = await new OrganizationFactory({}).create();
+        const freeProductPrice = ProductPrice.create({ name: 'Free', price: 0, stock: 100 });
+        const product = Product.create({ name: 'Product', stock: 100, prices: [freeProductPrice] });
+        const webshop = await new WebshopFactory({
+            organizationId: organization.id,
+            products: [product],
+        }).create();
+
+        // Confirmation email template for this webshop (auto-includes {{orderStatus}} etc.)
+        await new EmailTemplateFactory({
+            organization,
+            webshopId: webshop.id,
+            type: EmailTemplateType.OrderConfirmationOnline,
+        }).create();
+
+        // The order status label (OrderStatus.Created) is rendered via $t inside the confirmation
+        // email. These are the translations looked up in shared/locales/dist/locales/digit/{nl,fr}-BE.json,
+        // hardcoded on purpose so we don't verify $t with the same $t machinery we're testing.
+        const dutchStatusName = 'Nieuw';
+        const frenchStatusName = 'Nouveau';
+
+        const placeFreeOrderInLanguage = async (language: string) => {
+            EmailMocker.transactional.reset();
+
+            const orderData = OrderData.create({
+                paymentMethod: PaymentMethod.Unknown,
+                cart: Cart.create({
+                    items: [CartItem.create({ product, productPrice: freeProductPrice, amount: 1 })],
+                }),
+                customer: Customer.create({ firstName: 'John', lastName: 'Doe', email: 'john@example.com', phone: '+32412345678' }),
+            });
+
+            const r = Request.buildJson('POST', `/webshop/${webshop.id}/order`, organization.getApiHost(), orderData);
+            r.headers['accept-language'] = language;
+            await testServer.test(endpoint, r);
+
+            const emails = await EmailMocker.transactional.getSucceededEmails();
+            expect(emails).toHaveLength(1);
+            return emails[0];
+        };
+
+        // French order → the $t status label is rendered in French, without Dutch leaking in
+        const frenchEmail = await placeFreeOrderInLanguage('fr');
+        expect(frenchEmail.html).toContain(frenchStatusName);
+        expect(frenchEmail.html).not.toContain(dutchStatusName);
+
+        // Dutch order → rendered in Dutch, without French leaking in
+        const dutchEmail = await placeFreeOrderInLanguage('nl');
+        expect(dutchEmail.html).toContain(dutchStatusName);
+        expect(dutchEmail.html).not.toContain(frenchStatusName);
+    });
+});