@stamhoofd/structures 2.119.0 → 2.120.0

package/dist/src/members/checkout/RegisterCart.test.js

@@ -1,1430 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const BundleDiscountGroupPriceSettings_js_1 = require("../../BundleDiscountGroupPriceSettings.js");
-const Group_js_1 = require("../../Group.js");
-const GroupPriceDiscount_js_1 = require("../../GroupPriceDiscount.js");
-const GroupSettings_js_1 = require("../../GroupSettings.js");
-const Organization_js_1 = require("../../Organization.js");
-const Platform_js_1 = require("../../Platform.js");
-const ReduceablePrice_js_1 = require("../../ReduceablePrice.js");
-const RegistrationPeriod_js_1 = require("../../RegistrationPeriod.js");
-const TranslatedString_js_1 = require("../../TranslatedString.js");
-const MemberDetails_js_1 = require("../MemberDetails.js");
-const PlatformMember_js_1 = require("../PlatformMember.js");
-const RegisterItem_js_1 = require("./RegisterItem.js");
-const MemberWithRegistrationsBlob_js_1 = require("../MemberWithRegistrationsBlob.js");
-// Should be last because of circular dependencies
-const BundleDiscount_js_1 = require("../../BundleDiscount.js");
-const Registration_js_1 = require("../Registration.js");
-const AppliedRegistrationDiscount_js_1 = require("../../AppliedRegistrationDiscount.js");
-const RegistrationWithPlatformMember_js_1 = require("./RegistrationWithPlatformMember.js");
-const GenericBalance_js_1 = require("../../GenericBalance.js");
-// Helper functions to reduce code duplication
-function createTestPeriod() {
-    const period = RegistrationPeriod_js_1.RegistrationPeriod.create({});
-    const organizationRegistrationPeriod = RegistrationPeriod_js_1.OrganizationRegistrationPeriod.create({
-        period,
-    });
-    const organization = Organization_js_1.Organization.create({
-        period: organizationRegistrationPeriod,
-    });
-    return { period, organizationRegistrationPeriod, organization };
-}
-function createTestGroups(organization, period, prices = [500000, 400000], names) {
-    return prices.map((price, index) => {
-        return Group_js_1.Group.create({
-            organizationId: organization.id,
-            periodId: period.id,
-            settings: GroupSettings_js_1.GroupSettings.create({
-                name: names ? new TranslatedString_js_1.TranslatedString(names[index]) : undefined,
-                prices: [
-                    GroupSettings_js_1.GroupPrice.create({
-                        price: ReduceablePrice_js_1.ReduceablePrice.create({
-                            price,
-                        }),
-                    }),
-                ],
-            }),
-        });
-    });
-}
-function createBundleDiscount({ name = 'Bundle discount', countWholeFamily = true, countPerGroup = false, discounts = [
-    { value: 100000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed },
-    { value: 150000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed },
-], } = {}) {
-    return BundleDiscount_js_1.BundleDiscount.create({
-        name: new TranslatedString_js_1.TranslatedString(name),
-        countWholeFamily,
-        countPerGroup,
-        discounts: discounts.map(d => {
-            var _a;
-            return GroupPriceDiscount_js_1.GroupPriceDiscount.create({
-                value: ReduceablePrice_js_1.ReduceablePrice.create({
-                    price: d.value,
-                    reducedPrice: (_a = d.reducedValue) !== null && _a !== void 0 ? _a : null,
-                }),
-                type: d.type,
-            });
-        }),
-    });
-}
-function createTestFamily(memberCount = 3) {
-    const members = Array(memberCount).fill(null).map((_, i) => {
-        const names = ['John', 'Jane', 'Jack'];
-        return MemberWithRegistrationsBlob_js_1.MemberWithRegistrationsBlob.create({
-            details: MemberDetails_js_1.MemberDetails.create({
-                firstName: names[i] || `Member${i + 1}`,
-                lastName: 'Doe',
-            }),
-        });
-    });
-    const blob = MemberWithRegistrationsBlob_js_1.MembersBlob.create({
-        members,
-    });
-    return PlatformMember_js_1.PlatformFamily.create(blob, { platform: Platform_js_1.Platform.create({}) });
-}
-function setupDiscountTest({ memberCount = 3, groupPrices = [500000, 400000], groupNames, bundleDiscount, } = {}) {
-    const { period, organizationRegistrationPeriod, organization } = createTestPeriod();
-    const groups = createTestGroups(organization, period, groupPrices, groupNames);
-    organizationRegistrationPeriod.groups = groups;
-    const discount = bundleDiscount || createBundleDiscount();
-    organizationRegistrationPeriod.settings.bundleDiscounts.push(discount);
-    // Setup bundle discounts on all groups
-    groups.forEach((group) => {
-        group.settings.prices[0].bundleDiscounts.set(discount.id, BundleDiscountGroupPriceSettings_js_1.BundleDiscountGroupPriceSettings.create({
-            name: discount.name,
-        }));
-    });
-    const family = createTestFamily(memberCount);
-    return {
-        period,
-        organizationRegistrationPeriod,
-        organization,
-        groups,
-        discount,
-        family,
-    };
-}
-function addHistoricRegistration(member, group, organization, appliedDiscounts = new Map()) {
-    const registration = Registration_js_1.Registration.create({
-        group: group,
-        groupPrice: group.settings.prices[0],
-        memberId: member.id,
-        organizationId: group.organizationId,
-        registeredAt: new Date('2023-01-01'),
-        startDate: new Date('2023-01-01'),
-        price: group.settings.prices[0].price.price,
-        balances: [
-            GenericBalance_js_1.GenericBalance.create({
-                organizationId: organization.id,
-                amountPaid: 0,
-                amountOpen: group.settings.prices[0].price.price - [...appliedDiscounts.values()].reduce((acc, d) => acc + d.amount, 0),
-                amountPending: 0,
-            }),
-        ],
-        discounts: appliedDiscounts,
-    });
-    member.member.registrations.push(registration);
-    member.family.insertOrganization(organization);
-    return registration;
-}
-describe('Unit.RegisterCart', () => {
-    describe('Bundle Discounts', () => {
-        it('A fixed discount is granted for the second and third registration in a bundle', () => {
-            const { organization, groups, family } = setupDiscountTest({
-                bundleDiscount: createBundleDiscount({
-                    name: 'Bundle discount',
-                    discounts: [
-                        { value: 100000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed },
-                        { value: 150000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed },
-                    ],
-                }),
-            });
-            const [groupA, groupB] = groups;
-            const [memberA, memberB, memberC] = family.members;
-            const itemA = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupA, organization);
-            const itemB = RegisterItem_js_1.RegisterItem.defaultFor(memberB, groupB, organization);
-            const itemC = RegisterItem_js_1.RegisterItem.defaultFor(memberC, groupB, organization);
-            // Add to a single cart
-            const checkout = family.checkout;
-            const cart = checkout.cart;
-            cart.add(itemA);
-            cart.add(itemB);
-            cart.add(itemC);
-            cart.calculatePrices();
-            // Check price for item A is 50.00
-            expect(itemA.calculatedPrice).toEqual(500000);
-            expect(itemA.calculatedRefund).toEqual(0);
-            expect(itemA.calculatedPriceDueLater).toEqual(0);
-            // Check price for items B and C
-            expect(itemB.calculatedPrice).toEqual(400000);
-            expect(itemB.calculatedRefund).toEqual(0);
-            expect(itemB.calculatedPriceDueLater).toEqual(0);
-            expect(itemC.calculatedPrice).toEqual(400000);
-            expect(itemC.calculatedRefund).toEqual(0);
-            expect(itemC.calculatedPriceDueLater).toEqual(0);
-            // Check calculated discount is 10_0000 + 15_0000 = 25_0000
-            expect(cart.bundleDiscounts).toHaveLength(1);
-            expect(cart.bundleDiscounts[0].total).toEqual(250000);
-            expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(0);
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(250000);
-            expect(cart.price).toEqual(500000 + 400000 + 400000);
-            expect(checkout.totalPrice).toEqual(500000 + 400000 + 400000 - 250000);
-            expect(checkout.priceBreakown).toEqual([
-                expect.objectContaining({
-                    price: 1300000,
-                }),
-                {
-                    name: 'Bundle discount',
-                    price: -250000,
-                },
-                expect.objectContaining({
-                    price: 1300000 - 250000,
-                }),
-            ]);
-        });
-        test('A percentage discount is granted for the second and third registration in a bundle', () => {
-            const { organization, groups, family } = setupDiscountTest({
-                bundleDiscount: createBundleDiscount({
-                    name: 'Bundle discount',
-                    discounts: [
-                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
-                        { value: 1500, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
-                    ],
-                }),
-            });
-            const [groupA, groupB] = groups;
-            const [memberA, memberB, memberC] = family.members;
-            const itemA = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupA, organization);
-            const itemB = RegisterItem_js_1.RegisterItem.defaultFor(memberB, groupB, organization);
-            const itemC = RegisterItem_js_1.RegisterItem.defaultFor(memberC, groupB, organization);
-            // Add to a single cart
-            const checkout = family.checkout;
-            const cart = checkout.cart;
-            cart.add(itemA);
-            cart.add(itemB);
-            cart.add(itemC);
-            cart.calculatePrices();
-            // Check price for items
-            expect(itemA.calculatedPrice).toEqual(500000);
-            expect(itemB.calculatedPrice).toEqual(400000);
-            expect(itemC.calculatedPrice).toEqual(400000);
-            // 15% will be applied to 50 euro (max), and 10% to one of the 40 euros
-            // Check calculated discount is 50_0000 * 0.15 + 40_0000 * 0.10 = 7_5000 + 4_0000 = 11_5000
-            expect(cart.bundleDiscounts).toHaveLength(1);
-            expect(cart.bundleDiscounts[0].total).toEqual(115000);
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(115000);
-            expect(cart.price).toEqual(500000 + 400000 + 400000);
-            expect(checkout.totalPrice).toEqual(500000 + 400000 + 400000 - 115000);
-            expect(checkout.priceBreakown).toEqual([
-                expect.objectContaining({
-                    price: 1300000,
-                }),
-                {
-                    name: 'Bundle discount',
-                    price: -115000,
-                },
-                expect.objectContaining({
-                    price: 1300000 - 115000,
-                }),
-            ]);
-        });
-        test('Percentage discounts are rounded to 1 cent', () => {
-            const { organization, groups, family } = setupDiscountTest({
-                bundleDiscount: createBundleDiscount({
-                    name: 'Bundle discount',
-                    discounts: [
-                        { value: 111, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
-                        { value: 152, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
-                    ],
-                }),
-            });
-            const [groupA, groupB] = groups;
-            const [memberA, memberB, memberC] = family.members;
-            const itemA = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupA, organization);
-            const itemB = RegisterItem_js_1.RegisterItem.defaultFor(memberB, groupB, organization);
-            const itemC = RegisterItem_js_1.RegisterItem.defaultFor(memberC, groupB, organization);
-            // Add to a single cart
-            const checkout = family.checkout;
-            const cart = checkout.cart;
-            cart.add(itemA);
-            cart.add(itemB);
-            cart.add(itemC);
-            cart.calculatePrices();
-            // Check price for items
-            expect(itemA.calculatedPrice).toEqual(500000);
-            expect(itemB.calculatedPrice).toEqual(400000);
-            expect(itemC.calculatedPrice).toEqual(400000);
-            // 1,5% will be applied to 50 euro (max), and 1% to one of the 40 euros
-            // Check calculated discount is 50_0000 * 0.0152 + 40_0000 * 0.0111 = 7500 + 4000 = 1_2040 normally, but not allowed, rounded to 1_2000
-            expect(cart.bundleDiscounts).toHaveLength(1);
-            expect(cart.bundleDiscounts[0].total).toEqual(12000);
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(12000);
-            expect(cart.price).toEqual(500000 + 400000 + 400000);
-            expect(checkout.totalPrice).toEqual(500000 + 400000 + 400000 - 12000);
-            expect(checkout.priceBreakown).toEqual([
-                expect.objectContaining({
-                    price: 1300000,
-                }),
-                {
-                    name: 'Bundle discount',
-                    price: -12000,
-                },
-                expect.objectContaining({
-                    price: 1300000 - 12000,
-                }),
-            ]);
-        });
-        test('Historic registrations are included in the calculation', () => {
-            const { organization, groups, family } = setupDiscountTest({
-                bundleDiscount: createBundleDiscount({
-                    name: 'Bundle discount',
-                    discounts: [
-                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
-                        { value: 1500, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
-                    ],
-                }),
-            });
-            const [groupA, groupB] = groups;
-            const [memberA, memberB, memberC] = family.members;
-            // Member A is already registered for group A in the past
-            addHistoricRegistration(memberA, groupA, organization);
-            const itemB = RegisterItem_js_1.RegisterItem.defaultFor(memberB, groupB, organization);
-            const itemC = RegisterItem_js_1.RegisterItem.defaultFor(memberC, groupB, organization);
-            // Add to a single cart
-            const checkout = family.checkout;
-            const cart = checkout.cart;
-            cart.add(itemB);
-            cart.add(itemC);
-            cart.calculatePrices();
-            // Check price for items
-            expect(itemB.calculatedPrice).toEqual(400000);
-            expect(itemC.calculatedPrice).toEqual(400000);
-            // 15% will be applied to 50 euro (max), and 10% to one of the 40 euros
-            // Check calculated discount is 50_0000 * 0.15 + 40_0000 * 0.10 = 7_5000 + 4_0000 = 11_5000
-            expect(cart.bundleDiscounts).toHaveLength(1);
-            expect(cart.bundleDiscounts[0].total).toEqual(115000);
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(115000);
-            expect(cart.price).toEqual(400000 + 400000);
-            expect(checkout.totalPrice).toEqual(400000 + 400000 - 115000);
-            expect(checkout.priceBreakown).toEqual([
-                expect.objectContaining({
-                    price: 800000,
-                }),
-                {
-                    name: 'Bundle discount',
-                    price: -115000,
-                },
-                expect.objectContaining({
-                    price: 800000 - 115000,
-                }),
-            ]);
-        });
-        test('Deleting a registration also removes the attached discount', () => {
-            // We have two family members with existing registrations.
-            // One of those registrations received a discount earlier.
-            // But since we are adding a new registration in our cart, a more optimal discount
-            // would be if that registration would get the newly higher discount instead
-            // (because it is percentage based)
-            const { organization, groups, family, discount } = setupDiscountTest({
-                memberCount: 2,
-                bundleDiscount: createBundleDiscount({
-                    name: 'Multiple family members discount',
-                    countWholeFamily: true,
-                    countPerGroup: false,
-                    discounts: [
-                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
-                        { value: 1500, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
-                    ],
-                }),
-                groupPrices: [1000000, 400000],
-            });
-            const [groupA, groupB] = groups;
-            const [memberA, memberB] = family.members;
-            const registrationA = addHistoricRegistration(memberA, groupA, organization);
-            const registrationB = addHistoricRegistration(memberB, groupB, organization, new Map([
-                [
-                    discount.id,
-                    AppliedRegistrationDiscount_js_1.AppliedRegistrationDiscount.create({
-                        name: discount.name,
-                        amount: 100000, // 10% discount on 100_0000 = 10_0000
-                    }),
-                ],
-            ]));
-            // If we delete registration B, the discount won't be visible in the cart because it is included in the registration
-            const checkout = family.checkout;
-            const cart = checkout.cart;
-            cart.removeRegistration(new RegistrationWithPlatformMember_js_1.RegistrationWithPlatformMember({
-                registration: registrationB,
-                member: memberB,
-            }));
-            cart.calculatePrices();
-            expect(cart.bundleDiscounts).toHaveLength(0);
-            expect(checkout.totalPrice).toEqual(-300000);
-            expect(checkout.priceBreakown).toEqual([
-                expect.objectContaining({
-                    price: -400000 + 100000,
-                }),
-                expect.objectContaining({
-                    price: -400000 + 100000,
-                }),
-            ]);
-            // Now readd the registration
-            cart.unremoveRegistration(new RegistrationWithPlatformMember_js_1.RegistrationWithPlatformMember({
-                registration: registrationB,
-                member: memberB,
-            }));
-            // Remove registration A, this should show the discount because it is a side effect of deleting the registration
-            cart.removeRegistration(new RegistrationWithPlatformMember_js_1.RegistrationWithPlatformMember({
-                registration: registrationA,
-                member: memberA,
-            }));
-            cart.calculatePrices();
-            expect(cart.bundleDiscounts).toHaveLength(1);
-            expect(cart.bundleDiscounts[0].total).toEqual(0);
-            expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(100000); // The previous discount
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(-100000);
-            expect(checkout.totalPrice).toEqual(-900000);
-            expect(checkout.priceBreakown).toEqual([
-                {
-                    name: '%175 (Multiple family members discount)',
-                    price: 100000,
-                },
-                expect.objectContaining({
-                    price: -1000000, // Reeds aangerekend
-                }),
-                expect.objectContaining({
-                    price: -900000,
-                }),
-            ]);
-        });
-        test('Deleting a registration with cancellation fees', () => {
-            // We have two family members with existing registrations.
-            // One of those registrations received a discount earlier.
-            // But since we are adding a new registration in our cart, a more optimal discount
-            // would be if that registration would get the newly higher discount instead
-            // (because it is percentage based)
-            const { organization, groups, family, discount } = setupDiscountTest({
-                memberCount: 2,
-                bundleDiscount: createBundleDiscount({
-                    name: 'Multiple family members discount',
-                    countWholeFamily: true,
-                    countPerGroup: false,
-                    discounts: [
-                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
-                        { value: 1500, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
-                    ],
-                }),
-                groupPrices: [1000000, 400000],
-            });
-            const [groupA, groupB] = groups;
-            const [memberA, memberB] = family.members;
-            const registrationA = addHistoricRegistration(memberA, groupA, organization);
-            const registrationB = addHistoricRegistration(memberB, groupB, organization, new Map([
-                [
-                    discount.id,
-                    AppliedRegistrationDiscount_js_1.AppliedRegistrationDiscount.create({
-                        name: discount.name,
-                        amount: 100000, // 10% discount on 1_0000 = 10_00
-                    }),
-                ],
-            ]));
-            // If we delete registration B, the discount won't be visible in the cart because it is included in the registration
-            const checkout = family.checkout;
-            checkout.cancellationFeePercentage = 5000;
-            const cart = checkout.cart;
-            cart.removeRegistration(new RegistrationWithPlatformMember_js_1.RegistrationWithPlatformMember({
-                registration: registrationB,
-                member: memberB,
-            }));
-            cart.calculatePrices();
-            expect(cart.bundleDiscounts).toHaveLength(0);
-            expect(checkout.totalPrice).toEqual(-150000);
-            expect(checkout.priceBreakown).toEqual([
-                expect.objectContaining({
-                    price: -400000 + 100000, // Already charged amount
-                }),
-                // Cancellation fee = 50% of the balance total, 30_0000 = 15_0000
-                expect.objectContaining({
-                    price: 150000,
-                }),
-                expect.objectContaining({
-                    price: -150000,
-                }),
-            ]);
-            // Now readd the registration
-            cart.unremoveRegistration(new RegistrationWithPlatformMember_js_1.RegistrationWithPlatformMember({
-                registration: registrationB,
-                member: memberB,
-            }));
-            // Remove registration A, this should show the discount because it is a side effect of deleting the registration
-            cart.removeRegistration(new RegistrationWithPlatformMember_js_1.RegistrationWithPlatformMember({
-                registration: registrationA,
-                member: memberA,
-            }));
-            cart.calculatePrices();
-            expect(cart.bundleDiscounts).toHaveLength(1);
-            expect(cart.bundleDiscounts[0].total).toEqual(0);
-            expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(100000); // The previous discount
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(-100000);
-            expect(checkout.totalPrice).toEqual(-400000);
-            expect(checkout.priceBreakown).toEqual([
-                {
-                    // Side effect in registration B
-                    name: '%175 (Multiple family members discount)',
-                    price: 100000,
-                },
-                expect.objectContaining({
-                    price: -1000000, // Already charged for registration A that is being deleted
-                }),
-                // Cancellation fee = 50% of the balance total, 100_0000 = 50_0000
-                expect.objectContaining({
-                    price: 500000,
-                }),
-                expect.objectContaining({
-                    price: -400000,
-                }),
-            ]);
-        });
-        test('Replacing a registration without discount also removes the attached discount in another registration if the new registration in not elegible', () => {
-            // Create a family with two members, each with a registration
-            // Add a discount to one of the registrations (like it should have been calculated at the time)
-            // Next, move one of the registrations to a different group that does not have the discount
-            // The previously given discount should be added as an extra price on the cart as an adjustment for the discount that should have been given
-            const { organization, groups, family, discount } = setupDiscountTest({
-                memberCount: 2,
-                bundleDiscount: createBundleDiscount({
-                    name: 'Multiple family members discount',
-                    countWholeFamily: true,
-                    countPerGroup: false,
-                    discounts: [
-                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
-                        { value: 1500, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
-                    ],
-                }),
-                groupPrices: [1000000, 400000],
-            });
-            const [groupA, groupB] = groups;
-            const [memberA, memberB] = family.members;
-            const registrationA = addHistoricRegistration(memberA, groupA, organization);
-            addHistoricRegistration(memberB, groupB, organization, new Map([
-                [
-                    discount.id,
-                    AppliedRegistrationDiscount_js_1.AppliedRegistrationDiscount.create({
-                        name: discount.name,
-                        amount: 100000, // 10% discount on 100_0000 = 10_0000
-                    }),
-                ],
-            ]));
-            const groupCPrice = GroupSettings_js_1.GroupPrice.create({
-                price: ReduceablePrice_js_1.ReduceablePrice.create({
-                    price: 500000,
-                }),
-            });
-            const groupC = Group_js_1.Group.create({
-                organizationId: organization.id,
-                periodId: organization.period.id,
-                settings: GroupSettings_js_1.GroupSettings.create({
-                    name: new TranslatedString_js_1.TranslatedString('Group C'),
-                    prices: [
-                        groupCPrice,
-                    ],
-                }),
-            });
-            const checkout = family.checkout;
-            const cart = checkout.cart;
-            const itemA = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupC, organization);
-            itemA.replaceRegistrations = [
-                new RegistrationWithPlatformMember_js_1.RegistrationWithPlatformMember({
-                    registration: registrationA,
-                    member: memberA,
-                }),
-            ];
-            cart.add(itemA);
-            cart.calculatePrices();
-            // Check price for items
-            expect(itemA.calculatedPrice).toEqual(500000);
-            expect(itemA.calculatedRefund).toEqual(1000000);
-            expect(itemA.calculatedPriceDueLater).toEqual(0);
-            // Check discount should be given back
-            expect(cart.bundleDiscounts).toHaveLength(1);
-            expect(cart.bundleDiscounts[0].total).toEqual(0);
-            expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(100000); // The previous discount
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(-100000);
-            expect(checkout.totalPrice).toEqual(500000 - 1000000 + 100000);
-            expect(checkout.priceBreakown).toEqual([
-                expect.objectContaining({
-                    // Subtotal (normal price)
-                    price: 500000,
-                }),
-                {
-                    name: '%175 (Multiple family members discount)',
-                    price: 100000,
-                },
-                expect.objectContaining({
-                    // Refund for the previous registration
-                    price: -1000000,
-                }),
-                expect.objectContaining({
-                    price: -500000 + 100000,
-                }),
-            ]);
-            // Now, what if groupC does have a higher discount instead of no discount?
-            groupCPrice.bundleDiscounts.set(discount.id, BundleDiscountGroupPriceSettings_js_1.BundleDiscountGroupPriceSettings.create({
-                name: discount.name,
-                customDiscounts: [
-                    // Custom discount for this price
-                    GroupPriceDiscount_js_1.GroupPriceDiscount.create({
-                        value: ReduceablePrice_js_1.ReduceablePrice.create({
-                            price: 250000,
-                        }),
-                        type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed,
-                    }),
-                ],
-            }));
-            // Recalculate
-            cart.calculatePrices();
-            // Check discount should be given back
-            expect(cart.bundleDiscounts).toHaveLength(1);
-            expect(cart.bundleDiscounts[0].total).toEqual(250000);
-            expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(100000); // The previous discount
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(150000);
-            expect(checkout.totalPrice).toEqual(500000 - 1000000 - 150000);
-            expect(checkout.priceBreakown).toEqual([
-                expect.objectContaining({
-                    // Subtotal (normal price)
-                    price: 500000,
-                }),
-                {
-                    name: 'Multiple family members discount',
-                    price: -150000,
-                },
-                expect.objectContaining({
-                    // Refund for the previous registration
-                    price: -1000000,
-                }),
-                expect.objectContaining({
-                    price: -500000 - 150000,
-                }),
-            ]);
-        });
-        test('Replacing a registration with discount also removes the attached discount registration if the new registration in not elegible', () => {
-            const { organization, groups, family, discount } = setupDiscountTest({
-                memberCount: 2,
-                bundleDiscount: createBundleDiscount({
-                    name: 'Multiple family members discount',
-                    countWholeFamily: true,
-                    countPerGroup: false,
-                    discounts: [
-                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
-                        { value: 1500, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
-                    ],
-                }),
-                groupPrices: [1000000, 400000],
-            });
-            const [groupA, groupB] = groups;
-            const [memberA, memberB] = family.members;
-            const registrationA = addHistoricRegistration(memberA, groupA, organization, new Map([
-                [
-                    discount.id,
-                    AppliedRegistrationDiscount_js_1.AppliedRegistrationDiscount.create({
-                        name: discount.name,
-                        amount: 100000, // 10% discount on 100_0000 = 10_0000
-                    }),
-                ],
-            ]));
-            addHistoricRegistration(memberB, groupB, organization);
-            const groupCPrice = GroupSettings_js_1.GroupPrice.create({
-                price: ReduceablePrice_js_1.ReduceablePrice.create({
-                    price: 500000,
-                }),
-            });
-            const groupC = Group_js_1.Group.create({
-                organizationId: organization.id,
-                periodId: organization.period.id,
-                settings: GroupSettings_js_1.GroupSettings.create({
-                    name: new TranslatedString_js_1.TranslatedString('Group C'),
-                    prices: [
-                        groupCPrice,
-                    ],
-                }),
-            });
-            const checkout = family.checkout;
-            const cart = checkout.cart;
-            const itemA = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupC, organization);
-            itemA.replaceRegistrations = [
-                new RegistrationWithPlatformMember_js_1.RegistrationWithPlatformMember({
-                    registration: registrationA,
-                    member: memberA,
-                }),
-            ];
-            cart.add(itemA);
-            cart.calculatePrices();
-            // Check price for items
-            expect(itemA.calculatedPrice).toEqual(500000);
-            expect(itemA.calculatedRefund).toEqual(900000);
-            expect(itemA.calculatedPriceDueLater).toEqual(0);
-            // No discounts anymore
-            expect(cart.bundleDiscounts).toHaveLength(0);
-            expect(checkout.totalPrice).toEqual(500000 - 900000);
-            expect(checkout.priceBreakown).toEqual([
-                expect.objectContaining({
-                    // Subtotal (normal price)
-                    price: 500000,
-                }),
-                expect.objectContaining({
-                    // Refund for the previous registration, without the discount that was granted
-                    price: -900000,
-                }),
-                expect.objectContaining({
-                    price: 500000 - 900000,
-                }),
-            ]);
-            // Now, what if groupC does have a higher discount instead of no discount?
-            groupCPrice.bundleDiscounts.set(discount.id, BundleDiscountGroupPriceSettings_js_1.BundleDiscountGroupPriceSettings.create({
-                name: discount.name,
-                customDiscounts: [
-                    // Custom discount for this price
-                    GroupPriceDiscount_js_1.GroupPriceDiscount.create({
-                        value: ReduceablePrice_js_1.ReduceablePrice.create({
-                            price: 250000,
-                        }),
-                        type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed,
-                    }),
-                ],
-            }));
-            // Recalculate
-            cart.calculatePrices();
-            // Check discount should be given back
-            expect(cart.bundleDiscounts).toHaveLength(1);
-            expect(cart.bundleDiscounts[0].total).toEqual(250000);
-            expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(0); // Not included here, because the registration will be removed including the applied discount
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(250000);
-            expect(checkout.totalPrice).toEqual(500000 - 900000 - 250000);
-            expect(checkout.priceBreakown).toEqual([
-                expect.objectContaining({
-                    // Subtotal (normal price)
-                    price: 500000,
-                }),
-                {
-                    name: 'Multiple family members discount',
-                    price: -250000,
-                },
-                expect.objectContaining({
-                    // Refund for the previous registration
-                    price: -900000,
-                }),
-                expect.objectContaining({
-                    price: 500000 - 900000 - 250000,
-                }),
-            ]);
-        });
-        test('The last discount is repeated', () => {
-            // Create a family with 3 members. Add 3 items to the cart.
-            // The bundle discount only defined one discount, but that should be repated for the second and third item
-            const { organization, groups, family, discount } = setupDiscountTest({
-                memberCount: 3,
-                groupPrices: [500000, 400000],
-                groupNames: ['Group A', 'Group B'],
-                bundleDiscount: createBundleDiscount({
-                    name: 'Bundle discount',
-                    discounts: [
-                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
-                    ],
-                }),
-            });
-            const [groupA, groupB] = groups;
-            const [memberA, memberB, memberC] = family.members;
-            const itemA = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupA, organization);
-            const itemB = RegisterItem_js_1.RegisterItem.defaultFor(memberB, groupB, organization);
-            const itemC = RegisterItem_js_1.RegisterItem.defaultFor(memberC, groupB, organization);
-            // Add to a single cart
-            const checkout = family.checkout;
-            const cart = checkout.cart;
-            cart.add(itemA);
-            cart.add(itemB);
-            cart.add(itemC);
-            cart.calculatePrices();
-            // Check price for items
-            expect(itemA.calculatedPrice).toEqual(500000);
-            expect(itemA.calculatedRefund).toEqual(0);
-            expect(itemA.calculatedPriceDueLater).toEqual(0);
-            expect(itemB.calculatedPrice).toEqual(400000);
-            expect(itemB.calculatedRefund).toEqual(0);
-            expect(itemB.calculatedPriceDueLater).toEqual(0);
-            expect(itemC.calculatedPrice).toEqual(400000);
-            expect(itemC.calculatedRefund).toEqual(0);
-            expect(itemC.calculatedPriceDueLater).toEqual(0);
-            // Check calculated discount is 50_0000 * 0.10 + 40_0000 * 0.10 = 5_0000 + 4_0000 = 9_0000
-            expect(cart.bundleDiscounts).toHaveLength(1);
-            expect(cart.bundleDiscounts[0].total).toEqual(90000);
-            expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(0);
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(90000);
-            expect(cart.price).toEqual(500000 + 400000 + 400000);
-            expect(checkout.totalPrice).toEqual(500000 + 400000 + 400000 - 90000);
-            expect(checkout.priceBreakown).toEqual([
-                expect.objectContaining({
-                    price: 1300000,
-                }),
-                {
-                    name: 'Bundle discount',
-                    price: -90000,
-                },
-                expect.objectContaining({
-                    price: 1300000 - 90000,
-                }),
-            ]);
-        });
-        test('The highest possible discount is granted', () => {
-            const { organization, groups, family, discount } = setupDiscountTest({
-                memberCount: 3,
-                groupPrices: [500000, 400000],
-                groupNames: ['Group A', 'Group B'],
-                bundleDiscount: createBundleDiscount({
-                    name: 'Bundle discount',
-                    discounts: [
-                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
-                    ],
-                }),
-            });
-            const [groupA, groupB] = groups;
-            const [memberA, memberB, memberC] = family.members;
-            const itemA = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupA, organization);
-            const itemB = RegisterItem_js_1.RegisterItem.defaultFor(memberB, groupB, organization);
-            const itemC = RegisterItem_js_1.RegisterItem.defaultFor(memberC, groupB, organization);
-            // Change group B to give 20 euro for the second item, and 0 for the third item
-            groupB.settings.prices[0].bundleDiscounts.set(discount.id, BundleDiscountGroupPriceSettings_js_1.BundleDiscountGroupPriceSettings.create({
-                name: discount.name,
-                customDiscounts: [
-                    GroupPriceDiscount_js_1.GroupPriceDiscount.create({
-                        value: ReduceablePrice_js_1.ReduceablePrice.create({
-                            price: 200000,
-                        }),
-                        type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed,
-                    }),
-                    GroupPriceDiscount_js_1.GroupPriceDiscount.create({
-                        value: ReduceablePrice_js_1.ReduceablePrice.create({
-                            price: 0,
-                        }),
-                        type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed,
-                    }),
-                ],
-            }));
-            // Add to a single cart
-            const checkout = family.checkout;
-            const cart = checkout.cart;
-            cart.add(itemA);
-            cart.add(itemB);
-            cart.add(itemC);
-            cart.calculatePrices();
-            // Check price for items
-            expect(itemA.calculatedPrice).toEqual(500000);
-            expect(itemA.calculatedRefund).toEqual(0);
-            expect(itemA.calculatedPriceDueLater).toEqual(0);
-            expect(itemB.calculatedPrice).toEqual(400000);
-            expect(itemB.calculatedRefund).toEqual(0);
-            expect(itemB.calculatedPriceDueLater).toEqual(0);
-            expect(itemC.calculatedPrice).toEqual(400000);
-            expect(itemC.calculatedRefund).toEqual(0);
-            expect(itemC.calculatedPriceDueLater).toEqual(0);
-            // Check calculated discount is 50_0000 * 0.10 + 20_0000 fixed + 0 = 5_0000 + 20_0000 + 0 = 25_0000
-            expect(cart.bundleDiscounts).toHaveLength(1);
-            expect(cart.bundleDiscounts[0].total).toEqual(250000);
-            expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(0);
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(250000);
-            expect(cart.price).toEqual(500000 + 400000 + 400000);
-            expect(checkout.totalPrice).toEqual(500000 + 400000 + 400000 - 250000);
-            expect(checkout.priceBreakown).toEqual([
-                expect.objectContaining({
-                    price: 1300000,
-                }),
-                {
-                    name: 'Bundle discount',
-                    price: -250000,
-                },
-                expect.objectContaining({
-                    price: 1300000 - 250000,
-                }),
-            ]);
-        });
-        test('Multiple bundles can be combined', () => {
-            // Situation: Camp A costs 100 euro
-            // Camp B costs 150 euro
-            // Camp A and/or campB gives a discount of 10, 20, 30... (all camp discount)
-            // On top of that there is an extra discount if you combine multiple expensive camps (camp B) of 5 euro, 10 ...
-            const { organization, groups, family, organizationRegistrationPeriod } = setupDiscountTest({
-                memberCount: 5,
-                groupPrices: [1000000, 1500000],
-                groupNames: ['Camp A', 'Camp B'],
-                bundleDiscount: createBundleDiscount({
-                    name: 'All camp discount',
-                    discounts: [
-                        { value: 100000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed },
-                    ],
-                }),
-            });
-            const [campA, campB] = groups;
-            const [memberA, memberB, memberC, memberD, memberE] = family.members;
-            const expensiveCampDiscount = createBundleDiscount({
-                name: 'Expensive camp discount',
-                discounts: [
-                    { value: 50000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed },
-                ],
-            });
-            // Add discount to organizationRegistrationPeriod
-            organizationRegistrationPeriod.settings.bundleDiscounts.push(expensiveCampDiscount);
-            // Add camp B to the expensive camp discount
-            campB.settings.prices[0].bundleDiscounts.set(expensiveCampDiscount.id, BundleDiscountGroupPriceSettings_js_1.BundleDiscountGroupPriceSettings.create({
-                name: expensiveCampDiscount.name,
-            }));
-            // Add to a single cart
-            const checkout = family.checkout;
-            const cart = checkout.cart;
-            const itemA = RegisterItem_js_1.RegisterItem.defaultFor(memberA, campA, organization);
-            const itemB = RegisterItem_js_1.RegisterItem.defaultFor(memberB, campB, organization); // +10_0000 discount
-            const itemC = RegisterItem_js_1.RegisterItem.defaultFor(memberC, campB, organization); // +10_0000 discount and +5_0000 discount
-            const itemD = RegisterItem_js_1.RegisterItem.defaultFor(memberD, campA, organization); // +10_0000 discount
-            const itemE = RegisterItem_js_1.RegisterItem.defaultFor(memberE, campB, organization); // +10_0000 discount and +5_0000 discount
-            cart.add(itemA);
-            cart.add(itemB);
-            cart.add(itemC);
-            cart.add(itemD);
-            cart.add(itemE);
-            cart.calculatePrices();
-            expect(cart.bundleDiscounts).toHaveLength(2);
-            expect(cart.bundleDiscounts.map((d) => {
-                return {
-                    name: d.name,
-                    total: d.total,
-                    netTotal: d.netTotal,
-                };
-            })).toEqual([
-                {
-                    name: 'All camp discount',
-                    total: 100000 * 4,
-                    netTotal: 100000 * 4,
-                },
-                {
-                    name: 'Expensive camp discount',
-                    total: 50000 * 2,
-                    netTotal: 50000 * 2,
-                },
-            ]);
-            expect(checkout.priceBreakown).toEqual([
-                expect.objectContaining({
-                    price: 1000000 * 2 + 1500000 * 3,
-                }),
-                {
-                    name: 'All camp discount',
-                    price: -100000 * 4,
-                },
-                {
-                    name: 'Expensive camp discount',
-                    price: -50000 * 2,
-                },
-                expect.objectContaining({
-                    price: 1000000 * 2 + 1500000 * 3 - 100000 * 4 - 50000 * 2,
-                }),
-            ]);
-        });
-        test('Previous discounts can be altered if a better optimum is found later', () => {
-            // We have two family members with existing registrations.
-            // One of those registrations received a discount earlier.
-            // But since we are adding a new registration in our cart, a more optimal discount
-            // would be if that registration would get the newly higher discount instead
-            // (because it is percentage based)
-            const { organization, groups, family, discount } = setupDiscountTest({
-                memberCount: 2,
-                bundleDiscount: createBundleDiscount({
-                    name: 'Multiple family members discount',
-                    countWholeFamily: true,
-                    countPerGroup: false,
-                    discounts: [
-                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
-                        { value: 1500, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
-                    ],
-                }),
-                groupPrices: [1000000, 400000],
-            });
-            const [groupA, groupB] = groups;
-            const [memberA, memberB] = family.members;
-            const registrationA = addHistoricRegistration(memberA, groupA, organization);
-            const registrationB = addHistoricRegistration(memberB, groupB, organization);
-            registrationA.discounts.set(discount.id, AppliedRegistrationDiscount_js_1.AppliedRegistrationDiscount.create({
-                name: discount.name,
-                amount: 100000, // 10% discount on 100_0000 = 10_0000
-            }));
-            // Now create itemC
-            const itemC = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupB, organization);
-            // Add to a single cart
-            const checkout = family.checkout;
-            const cart = checkout.cart;
-            cart.add(itemC);
-            cart.calculatePrices();
-            // Check price for items
-            expect(itemC.calculatedPrice).toEqual(400000);
-            expect(itemC.calculatedRefund).toEqual(0);
-            expect(itemC.calculatedPriceDueLater).toEqual(0);
-            // Check calculated discount is 100_0000 * 0.15 + 40_0000 * 0.10 = 15_0000 + 4_0000 = 19_0000
-            expect(cart.bundleDiscounts).toHaveLength(1);
-            expect(cart.bundleDiscounts[0].total).toEqual(190000);
-            expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(100000); // The previous discount
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(90000);
-            expect(cart.price).toEqual(400000);
-            expect(checkout.totalPrice).toEqual(400000 - 90000);
-            expect(checkout.priceBreakown).toEqual([
-                expect.objectContaining({
-                    price: 400000,
-                }),
-                {
-                    name: 'Multiple family members discount',
-                    price: -90000,
-                },
-                expect.objectContaining({
-                    price: 400000 - 90000,
-                }),
-            ]);
-        });
-        test('The repeating behaviour can be stopped by setting the last discount to zero', () => {
-            // Create a family with 3 members. Add 3 items to the cart.
-            // The bundle discount only defined one discount, but that should be repated for the second and third item
-            const { organization, groups, family, discount } = setupDiscountTest({
-                memberCount: 3,
-                groupPrices: [500000, 400000],
-                groupNames: ['Group A', 'Group B'],
-                bundleDiscount: createBundleDiscount({
-                    name: 'Bundle discount',
-                    discounts: [
-                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
-                        { value: 0, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage }, // This should stop the repeating behaviour
-                    ],
-                }),
-            });
-            const [groupA, groupB] = groups;
-            const [memberA, memberB, memberC] = family.members;
-            const itemA = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupA, organization);
-            const itemB = RegisterItem_js_1.RegisterItem.defaultFor(memberB, groupB, organization);
-            const itemC = RegisterItem_js_1.RegisterItem.defaultFor(memberC, groupB, organization);
-            // Add to a single cart
-            const checkout = family.checkout;
-            const cart = checkout.cart;
-            cart.add(itemA);
-            cart.add(itemB);
-            cart.add(itemC);
-            cart.calculatePrices();
-            // Check price for items
-            expect(itemA.calculatedPrice).toEqual(500000);
-            expect(itemA.calculatedRefund).toEqual(0);
-            expect(itemA.calculatedPriceDueLater).toEqual(0);
-            expect(itemB.calculatedPrice).toEqual(400000);
-            expect(itemB.calculatedRefund).toEqual(0);
-            expect(itemB.calculatedPriceDueLater).toEqual(0);
-            expect(itemC.calculatedPrice).toEqual(400000);
-            expect(itemC.calculatedRefund).toEqual(0);
-            expect(itemC.calculatedPriceDueLater).toEqual(0);
-            // Check calculated discount is 50_0000 * 0.10 = 5_0000
-            expect(cart.bundleDiscounts).toHaveLength(1);
-            expect(cart.bundleDiscounts[0].total).toEqual(50000);
-            expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(0);
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(50000);
-            expect(cart.price).toEqual(500000 + 400000 + 400000);
-            expect(checkout.totalPrice).toEqual(500000 + 400000 + 400000 - 50000);
-            expect(checkout.priceBreakown).toEqual([
-                expect.objectContaining({
-                    price: 1300000,
-                }),
-                {
-                    name: 'Bundle discount',
-                    price: -50000,
-                },
-                expect.objectContaining({
-                    price: 1300000 - 50000,
-                }),
-            ]);
-        });
-        test('Gives different discount for members with reduced price', () => {
-            // Create familuy with 3 members.
-            // One member has a reduced price.
-            // The other two members have a normal price.
-            // Create a 50%, 100% discount for the reduced price in a bundle discount (so it should be free in a family with 3 members)
-            const { organization, groups, family } = setupDiscountTest({
-                memberCount: 3,
-                groupPrices: [500000, 400000],
-                groupNames: ['Group A', 'Group B'],
-                bundleDiscount: createBundleDiscount({
-                    name: 'Bundle discount',
-                    discounts: [
-                        { value: 500, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage, reducedValue: 5000 },
-                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage, reducedValue: 10000 },
-                    ],
-                }),
-            });
-            const [groupA, groupB] = groups;
-            const [memberA, memberB, memberC] = family.members;
-            // Make sure the last member has a reduced price
-            memberC.member.details.requiresFinancialSupport = MemberDetails_js_1.BooleanStatus.create({ value: true });
-            const itemA = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupA, organization);
-            const itemB = RegisterItem_js_1.RegisterItem.defaultFor(memberB, groupB, organization);
-            const itemC = RegisterItem_js_1.RegisterItem.defaultFor(memberC, groupB, organization);
-            // Add to a single cart
-            const checkout = family.checkout;
-            const cart = checkout.cart;
-            cart.add(itemA);
-            cart.add(itemB);
-            cart.add(itemC);
-            cart.calculatePrices();
-            // Check price for items
-            expect(itemA.calculatedPrice).toEqual(500000);
-            expect(itemB.calculatedPrice).toEqual(400000);
-            expect(itemC.calculatedPrice).toEqual(400000);
-            // Check calculated discount is 40_0000 * 1 + 50_0000 * 5% = 40_0000 + 2_5000 = 42_5000
-            expect(cart.bundleDiscounts).toHaveLength(1);
-            expect(cart.bundleDiscounts[0].total).toEqual(425000);
-            expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(0);
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(425000);
-            expect(cart.price).toEqual(500000 + 400000 + 400000);
-            expect(checkout.totalPrice).toEqual(500000 + 400000 + 400000 - 425000);
-            expect(checkout.priceBreakown).toEqual([
-                expect.objectContaining({
-                    price: 1300000,
-                }),
-                {
-                    name: 'Bundle discount',
-                    price: -425000,
-                },
-                expect.objectContaining({
-                    price: 1300000 - 425000,
-                }),
-            ]);
-            // Remove requires financial support, then recalculate
-            memberC.member.details.requiresFinancialSupport = MemberDetails_js_1.BooleanStatus.create({ value: false });
-            cart.calculatePrices();
-            // 10% on 50_0000 + 5% on 40_0000 = 5_0000 + 2_0000 = 7_0000
-            expect(checkout.priceBreakown).toEqual([
-                expect.objectContaining({
-                    price: 1300000,
-                }),
-                {
-                    name: 'Bundle discount',
-                    price: -70000,
-                },
-                expect.objectContaining({
-                    price: 1300000 - 70000,
-                }),
-            ]);
-        });
-        test('Bundles without countWholeFamily only count per unique member', () => {
-            // Register member A for both group A and group B
-            // while member B is only registered for group A
-            // Only member A should get the discount for either A or B (if the order matters)
-            const { organization, groups, family } = setupDiscountTest({
-                memberCount: 2,
-                bundleDiscount: createBundleDiscount({
-                    name: 'Multiple lessons discount',
-                    countWholeFamily: false,
-                    countPerGroup: false,
-                    discounts: [
-                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
-                    ],
-                }),
-            });
-            const [groupA, groupB] = groups;
-            const [memberA, memberB] = family.members;
-            const itemA = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupA, organization);
-            const itemB = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupB, organization);
-            const itemC = RegisterItem_js_1.RegisterItem.defaultFor(memberB, groupA, organization);
-            // Add to a single cart
-            const checkout = family.checkout;
-            const cart = checkout.cart;
-            cart.add(itemA);
-            cart.add(itemB);
-            cart.add(itemC);
-            cart.calculatePrices();
-            // Check price for items
-            expect(itemA.calculatedPrice).toEqual(500000);
-            expect(itemB.calculatedPrice).toEqual(400000);
-            expect(itemC.calculatedPrice).toEqual(500000);
-            // Check calculated discount is 50_0000 * 0.10 = 5_0000
-            expect(cart.bundleDiscounts.map(c => c.netTotal)).toHaveLength(1);
-            expect(cart.bundleDiscounts[0].total).toEqual(50000);
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(50000);
-            expect(cart.price).toEqual(500000 + 400000 + 500000);
-            expect(checkout.totalPrice).toEqual(500000 + 400000 + 500000 - 50000);
-            expect(checkout.priceBreakown).toEqual([
-                expect.objectContaining({
-                    price: 500000 + 400000 + 500000,
-                }),
-                {
-                    name: 'Multiple lessons discount (John)',
-                    price: -50000,
-                },
-                expect.objectContaining({
-                    price: 500000 + 400000 + 500000 - 50000,
-                }),
-            ]);
-            // Add a historic registration for member B, so it also gets a discount
-            addHistoricRegistration(memberB, groupB, organization);
-            cart.calculatePrices();
-            expect(checkout.priceBreakown).toEqual([
-                expect.objectContaining({
-                    price: 500000 + 400000 + 500000, // no change
-                }),
-                {
-                    name: 'Multiple lessons discount (John)',
-                    price: -50000,
-                },
-                {
-                    name: 'Multiple lessons discount (Jane)',
-                    price: -50000,
-                },
-                expect.objectContaining({
-                    price: 500000 + 400000 + 500000 - 50000 - 50000,
-                }),
-            ]);
-        });
-        test('Bundles with countPerGroup only count per unique group', () => {
-            const { organization, groups, family, discount } = setupDiscountTest({
-                memberCount: 2,
-                groupNames: ['Group A', 'Group B'],
-                bundleDiscount: createBundleDiscount({
-                    name: 'Multiple family members discount',
-                    countWholeFamily: true,
-                    countPerGroup: true,
-                    discounts: [
-                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
-                    ],
-                }),
-            });
-            const [groupA, groupB] = groups;
-            const [memberA, memberB] = family.members;
-            // Both members register for the different groups, does not give the discount
-            const itemA = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupA, organization);
-            const itemB = RegisterItem_js_1.RegisterItem.defaultFor(memberB, groupB, organization);
-            // Add to a single cart
-            const checkout = family.checkout;
-            const cart = checkout.cart;
-            cart.add(itemA);
-            cart.add(itemB);
-            cart.calculatePrices();
-            // No discount should be applied yet (need at least 2 different groups)
-            expect(cart.bundleDiscounts).toHaveLength(0);
-            expect(checkout.totalPrice).toEqual(500000 + 400000);
-            // Now register one member for group B as well
-            const itemC = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupB, organization);
-            cart.add(itemC);
-            cart.calculatePrices();
-            // Now we should get a discount
-            expect(cart.bundleDiscounts).toHaveLength(1);
-            expect(cart.bundleDiscounts[0].total).toEqual(40000); // 10% of 40_0000 (not 50_0000)
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(40000);
-            expect(cart.price).toEqual(500000 + 400000 + 400000);
-            expect(checkout.totalPrice).toEqual(500000 + 400000 + 400000 - 40000);
-            expect(checkout.priceBreakown).toEqual([
-                expect.objectContaining({
-                    price: 500000 + 400000 + 400000,
-                }),
-                {
-                    name: 'Multiple family members discount (Group B)',
-                    price: -40000,
-                },
-                expect.objectContaining({
-                    price: 500000 + 400000 + 400000 - 40000,
-                }),
-            ]);
-            // Change calculation to count across groups
-            discount.countPerGroup = false;
-            cart.calculatePrices();
-            // Now we should get a discount for both groups
-            expect(checkout.priceBreakown).toEqual([
-                expect.objectContaining({
-                    price: 500000 + 400000 + 400000,
-                }),
-                {
-                    name: 'Multiple family members discount',
-                    price: -90000,
-                },
-                expect.objectContaining({
-                    price: 500000 + 400000 + 400000 - 90000,
-                }),
-            ]);
-        });
-        test('countPerGroup = true is ignored if countWholeFamily is false', () => {
-            const { organization, groups, family, discount } = setupDiscountTest({
-                memberCount: 2,
-                groupNames: ['Group A', 'Group B'],
-                bundleDiscount: createBundleDiscount({
-                    name: 'Multiple lessons discount',
-                    countWholeFamily: false, // This means only count per unique member
-                    countPerGroup: true, // This should be ignored since countWholeFamily is false
-                    discounts: [
-                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
-                    ],
-                }),
-            });
-            const [groupA, groupB] = groups;
-            const [memberA, memberB] = family.members;
-            // Register member A for both group A and B
-            // Register member B for group A
-            const itemA = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupA, organization);
-            const itemB = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupB, organization);
-            const itemC = RegisterItem_js_1.RegisterItem.defaultFor(memberB, groupA, organization);
-            // Add to a single cart
-            const checkout = family.checkout;
-            const cart = checkout.cart;
-            cart.add(itemA);
-            cart.add(itemB);
-            cart.add(itemC);
-            cart.calculatePrices();
-            // Check price for items
-            expect(itemA.calculatedPrice).toEqual(500000);
-            expect(itemB.calculatedPrice).toEqual(400000);
-            expect(itemC.calculatedPrice).toEqual(500000);
-            // Check calculated discount - should only apply to member A (who has multiple registrations)
-            expect(cart.bundleDiscounts).toHaveLength(1);
-            expect(cart.bundleDiscounts[0].total).toEqual(50000); // 10% of 50_0000 (we always apply discounts to highest price first)
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(50000);
-            expect(cart.price).toEqual(500000 + 400000 + 500000);
-            expect(checkout.totalPrice).toEqual(500000 + 400000 + 500000 - 50000);
-            expect(checkout.priceBreakown).toEqual([
-                expect.objectContaining({
-                    price: 500000 + 400000 + 500000,
-                }),
-                {
-                    name: 'Multiple lessons discount (John)',
-                    price: -50000,
-                },
-                expect.objectContaining({
-                    price: 500000 + 400000 + 500000 - 50000,
-                }),
-            ]);
-            // Now explicitly turn on countPerGroup and set countWholeFamily to true
-            // to verify it behaves differently (proving that countPerGroup was indeed ignored before)
-            discount.countWholeFamily = true;
-            discount.countPerGroup = true;
-            cart.calculatePrices();
-            // Now we should get a discount for group A (since two members are registered for it)
-            expect(checkout.priceBreakown).toEqual([
-                expect.objectContaining({
-                    price: 500000 + 400000 + 500000,
-                }),
-                {
-                    name: 'Multiple lessons discount (Group A)',
-                    price: -50000, // 10% of the second 50_0000
-                },
-                expect.objectContaining({
-                    price: 500000 + 400000 + 500000 - 50000,
-                }),
-            ]);
-        });
-        test('Past discounts are only altered if a related registration is added or removed', () => {
-            // Create two historic registrations that didn't get an existing discount (= error)
-            // now, add a new registration to the cart that is not applicable to the discount - the old discount should not be altered
-            const { organization, groups, family, period, discount } = setupDiscountTest({
-                memberCount: 2,
-                groupPrices: [500000, 400000],
-                groupNames: ['Group A', 'Group B'],
-                bundleDiscount: createBundleDiscount({
-                    name: 'Multiple family members discount',
-                    countWholeFamily: true,
-                    countPerGroup: false,
-                    discounts: [
-                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
-                    ],
-                }),
-            });
-            const [groupA, groupB] = groups;
-            const [memberA, memberB] = family.members;
-            const registrationA = addHistoricRegistration(memberA, groupA, organization);
-            const registrationB = addHistoricRegistration(memberB, groupB, organization);
-            // Create a new group that is not applicable to the discount
-            const [groupC] = createTestGroups(organization, period, [300000], ['Group C']);
-            const itemC = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupC, organization);
-            // Add to a single cart
-            const checkout = family.checkout;
-            const cart = checkout.cart;
-            cart.add(itemC);
-            cart.calculatePrices();
-            expect(itemC.calculatedPrice).toEqual(300000);
-            expect(cart.bundleDiscounts).toHaveLength(0);
-            expect(checkout.totalPrice).toEqual(300000);
-            expect(checkout.priceBreakown).toEqual([
-                expect.objectContaining({
-                    price: 300000,
-                }),
-            ]);
-            // Now also register memberB for group A and add it to the cart
-            const itemD = RegisterItem_js_1.RegisterItem.defaultFor(memberB, groupA, organization);
-            cart.add(itemD);
-            cart.calculatePrices();
-            // Check price for items
-            expect(itemD.calculatedPrice).toEqual(500000);
-            expect(itemC.calculatedPrice).toEqual(300000);
-            // Check calculated discount: should also take old registrations into account
-            // 50_0000 * 10% + 50_0000 * 10% = 5_0000 + 5_0000 = 10_0000
-            expect(cart.bundleDiscounts).toHaveLength(1);
-            expect(cart.bundleDiscounts[0].total).toEqual(100000);
-            expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(0);
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(100000);
-            expect(cart.price).toEqual(500000 + 300000);
-            expect(checkout.totalPrice).toEqual(500000 + 300000 - 100000);
-            expect(checkout.priceBreakown).toEqual([
-                expect.objectContaining({
-                    price: 500000 + 300000,
-                }),
-                {
-                    name: 'Multiple family members discount',
-                    price: -100000,
-                },
-                expect.objectContaining({
-                    price: 500000 + 300000 - 100000,
-                }),
-            ]);
-        });
-        test('Fixed discounts are limited to the group price', () => {
-            const { organization, groups, family, discount } = setupDiscountTest({
-                memberCount: 2,
-                groupNames: ['Group A', 'Group B'],
-                bundleDiscount: createBundleDiscount({
-                    name: 'Multiple family members discount',
-                    countWholeFamily: true,
-                    countPerGroup: false,
-                    discounts: [
-                        { value: 10000000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed },
-                    ],
-                }),
-            });
-            const [groupA, groupB] = groups;
-            const [memberA, memberB] = family.members;
-            const itemA = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupA, organization);
-            const itemB = RegisterItem_js_1.RegisterItem.defaultFor(memberB, groupB, organization);
-            // Add to a single cart
-            const checkout = family.checkout;
-            const cart = checkout.cart;
-            cart.add(itemA);
-            cart.add(itemB);
-            cart.calculatePrices();
-            expect(cart.bundleDiscounts).toHaveLength(1);
-            expect(cart.bundleDiscounts[0].total).toEqual(500000);
-            expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(0);
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(500000);
-            expect(cart.price).toEqual(500000 + 400000);
-            expect(checkout.totalPrice).toEqual(400000);
-            expect(checkout.priceBreakown).toEqual([
-                expect.objectContaining({
-                    price: 500000 + 400000,
-                }),
-                {
-                    name: 'Multiple family members discount',
-                    price: -500000,
-                },
-                expect.objectContaining({
-                    price: 400000,
-                }),
-            ]);
-        });
-        test.todo('Can handle bundle discounts for a future period');
-        test.todo('Families should be calculated correctly for admins');
-        test.todo('The price per item can never be negative');
-    });
-});
-//# sourceMappingURL=RegisterCart.test.js.map