@stamhoofd/structures 2.106.1 → 2.107.0

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

@@ -30,7 +30,7 @@ function createTestPeriod() {
     });
     return { period, organizationRegistrationPeriod, organization };
 }
-function createTestGroups(organization, period, prices = [5000, 4000], names) {
+function createTestGroups(organization, period, prices = [500000, 400000], names) {
     return prices.map((price, index) => {
         return Group_js_1.Group.create({
             organizationId: organization.id,
@@ -49,8 +49,8 @@ function createTestGroups(organization, period, prices = [5000, 4000], names) {
     });
 }
 function createBundleDiscount({ name = 'Bundle discount', countWholeFamily = true, countPerGroup = false, discounts = [
-    { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed },
-    { value: 1500, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed },
+    { 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),
@@ -83,7 +83,7 @@ function createTestFamily(memberCount = 3) {
     });
     return PlatformMember_js_1.PlatformFamily.create(blob, { platform: Platform_js_1.Platform.create({}) });
 }
-function setupDiscountTest({ memberCount = 3, groupPrices = [5000, 4000], groupNames, bundleDiscount, } = {}) {
+function setupDiscountTest({ memberCount = 3, groupPrices = [500000, 400000], groupNames, bundleDiscount, } = {}) {
     const { period, organizationRegistrationPeriod, organization } = createTestPeriod();
     const groups = createTestGroups(organization, period, groupPrices, groupNames);
     organizationRegistrationPeriod.groups = groups;
@@ -135,8 +135,8 @@ describe('Unit.RegisterCart', () => {
                 bundleDiscount: createBundleDiscount({
                     name: 'Bundle discount',
                     discounts: [
-                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed },
-                        { value: 1500, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed },
+                        { value: 100000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed },
+                        { value: 150000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed },
                     ],
                 }),
             });
@@ -153,33 +153,33 @@ describe('Unit.RegisterCart', () => {
             cart.add(itemC);
             cart.calculatePrices();
             // Check price for item A is 50.00
-            expect(itemA.calculatedPrice).toEqual(5000);
+            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(4000);
+            expect(itemB.calculatedPrice).toEqual(400000);
             expect(itemB.calculatedRefund).toEqual(0);
             expect(itemB.calculatedPriceDueLater).toEqual(0);
-            expect(itemC.calculatedPrice).toEqual(4000);
+            expect(itemC.calculatedPrice).toEqual(400000);
             expect(itemC.calculatedRefund).toEqual(0);
             expect(itemC.calculatedPriceDueLater).toEqual(0);
-            // Check calculated discount is 10_00 + 15_00 = 25_00
+            // Check calculated discount is 10_0000 + 15_0000 = 25_0000
             expect(cart.bundleDiscounts).toHaveLength(1);
-            expect(cart.bundleDiscounts[0].total).toEqual(2500);
+            expect(cart.bundleDiscounts[0].total).toEqual(250000);
             expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(0);
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(2500);
-            expect(cart.price).toEqual(5000 + 4000 + 4000);
-            expect(checkout.totalPrice).toEqual(5000 + 4000 + 4000 - 2500);
+            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: 13000,
+                    price: 1300000,
                 }),
                 {
                     name: 'Bundle discount',
-                    price: -2500,
+                    price: -250000,
                 },
                 expect.objectContaining({
-                    price: 13000 - 2500,
+                    price: 1300000 - 250000,
                 }),
             ]);
         });
@@ -206,26 +206,72 @@ describe('Unit.RegisterCart', () => {
             cart.add(itemC);
             cart.calculatePrices();
             // Check price for items
-            expect(itemA.calculatedPrice).toEqual(5000);
-            expect(itemB.calculatedPrice).toEqual(4000);
-            expect(itemC.calculatedPrice).toEqual(4000);
+            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_00 * 0.15 + 40_00 * 0.10 = 7_50 + 4_00 = 11_50
+            // 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(1150);
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(1150);
-            expect(cart.price).toEqual(5000 + 4000 + 4000);
-            expect(checkout.totalPrice).toEqual(5000 + 4000 + 4000 - 1150);
+            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: 13000,
+                    price: 1300000,
                 }),
                 {
                     name: 'Bundle discount',
-                    price: -1150,
+                    price: -12000,
                 },
                 expect.objectContaining({
-                    price: 13000 - 1150,
+                    price: 1300000 - 12000,
                 }),
             ]);
         });
@@ -252,25 +298,25 @@ describe('Unit.RegisterCart', () => {
             cart.add(itemC);
             cart.calculatePrices();
             // Check price for items
-            expect(itemB.calculatedPrice).toEqual(4000);
-            expect(itemC.calculatedPrice).toEqual(4000);
+            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_00 * 0.15 + 40_00 * 0.10 = 7_50 + 4_00 = 11_50
+            // 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(1150);
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(1150);
-            expect(cart.price).toEqual(4000 + 4000);
-            expect(checkout.totalPrice).toEqual(4000 + 4000 - 1150);
+            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: 8000,
+                    price: 800000,
                 }),
                 {
                     name: 'Bundle discount',
-                    price: -1150,
+                    price: -115000,
                 },
                 expect.objectContaining({
-                    price: 8000 - 1150,
+                    price: 800000 - 115000,
                 }),
             ]);
         });
@@ -291,7 +337,7 @@ describe('Unit.RegisterCart', () => {
                         { value: 1500, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
                     ],
                 }),
-                groupPrices: [10000, 4000],
+                groupPrices: [1000000, 400000],
             });
             const [groupA, groupB] = groups;
             const [memberA, memberB] = family.members;
@@ -301,7 +347,7 @@ describe('Unit.RegisterCart', () => {
                     discount.id,
                     AppliedRegistrationDiscount_js_1.AppliedRegistrationDiscount.create({
                         name: discount.name,
-                        amount: 1000, // 10% discount on 100_00 = 10_00
+                        amount: 100000, // 10% discount on 100_0000 = 10_0000
                     }),
                 ],
             ]));
@@ -314,13 +360,13 @@ describe('Unit.RegisterCart', () => {
             }));
             cart.calculatePrices();
             expect(cart.bundleDiscounts).toHaveLength(0);
-            expect(checkout.totalPrice).toEqual(-3000);
+            expect(checkout.totalPrice).toEqual(-300000);
             expect(checkout.priceBreakown).toEqual([
                 expect.objectContaining({
-                    price: -4000 + 1000,
+                    price: -400000 + 100000,
                 }),
                 expect.objectContaining({
-                    price: -4000 + 1000,
+                    price: -400000 + 100000,
                 }),
             ]);
             // Now readd the registration
@@ -336,19 +382,19 @@ describe('Unit.RegisterCart', () => {
             cart.calculatePrices();
             expect(cart.bundleDiscounts).toHaveLength(1);
             expect(cart.bundleDiscounts[0].total).toEqual(0);
-            expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(1000); // The previous discount
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(-1000);
-            expect(checkout.totalPrice).toEqual(-9000);
+            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([
-                expect.objectContaining({
-                    price: -10000, // Reeds aangerekend
-                }),
                 {
                     name: '766a39be-a4af-4a04-baf0-1f064d2fed16 (Multiple family members discount)',
-                    price: 1000,
+                    price: 100000,
                 },
                 expect.objectContaining({
-                    price: -9000,
+                    price: -1000000, // Reeds aangerekend
+                }),
+                expect.objectContaining({
+                    price: -900000,
                 }),
             ]);
         });
@@ -369,7 +415,7 @@ describe('Unit.RegisterCart', () => {
                         { value: 1500, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
                     ],
                 }),
-                groupPrices: [10000, 4000],
+                groupPrices: [1000000, 400000],
             });
             const [groupA, groupB] = groups;
             const [memberA, memberB] = family.members;
@@ -379,7 +425,7 @@ describe('Unit.RegisterCart', () => {
                     discount.id,
                     AppliedRegistrationDiscount_js_1.AppliedRegistrationDiscount.create({
                         name: discount.name,
-                        amount: 1000, // 10% discount on 100_00 = 10_00
+                        amount: 100000, // 10% discount on 1_0000 = 10_00
                     }),
                 ],
             ]));
@@ -393,17 +439,17 @@ describe('Unit.RegisterCart', () => {
             }));
             cart.calculatePrices();
             expect(cart.bundleDiscounts).toHaveLength(0);
-            expect(checkout.totalPrice).toEqual(-1500);
+            expect(checkout.totalPrice).toEqual(-150000);
             expect(checkout.priceBreakown).toEqual([
                 expect.objectContaining({
-                    price: -4000 + 1000, // Already charged amount
+                    price: -400000 + 100000, // Already charged amount
                 }),
-                // Cancellation fee = 50% of the balance total, 30_00 = 15_00
+                // Cancellation fee = 50% of the balance total, 30_0000 = 15_0000
                 expect.objectContaining({
-                    price: 1500,
+                    price: 150000,
                 }),
                 expect.objectContaining({
-                    price: -1500,
+                    price: -150000,
                 }),
             ]);
             // Now readd the registration
@@ -419,24 +465,24 @@ describe('Unit.RegisterCart', () => {
             cart.calculatePrices();
             expect(cart.bundleDiscounts).toHaveLength(1);
             expect(cart.bundleDiscounts[0].total).toEqual(0);
-            expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(1000); // The previous discount
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(-1000);
-            expect(checkout.totalPrice).toEqual(-4000);
+            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([
-                expect.objectContaining({
-                    price: -10000, // Already charged for registration A that is being deleted
-                }),
-                // Cancellation fee = 50% of the balance total, 100_00 = 50_00
-                expect.objectContaining({
-                    price: 5000,
-                }),
                 {
                     // Side effect in registration B
                     name: '766a39be-a4af-4a04-baf0-1f064d2fed16 (Multiple family members discount)',
-                    price: 1000,
+                    price: 100000,
                 },
                 expect.objectContaining({
-                    price: -4000,
+                    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,
                 }),
             ]);
         });
@@ -456,7 +502,7 @@ describe('Unit.RegisterCart', () => {
                         { value: 1500, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
                     ],
                 }),
-                groupPrices: [10000, 4000],
+                groupPrices: [1000000, 400000],
             });
             const [groupA, groupB] = groups;
             const [memberA, memberB] = family.members;
@@ -466,13 +512,13 @@ describe('Unit.RegisterCart', () => {
                     discount.id,
                     AppliedRegistrationDiscount_js_1.AppliedRegistrationDiscount.create({
                         name: discount.name,
-                        amount: 1000, // 10% discount on 100_00 = 10_00
+                        amount: 100000, // 10% discount on 100_0000 = 10_0000
                     }),
                 ],
             ]));
             const groupCPrice = GroupSettings_js_1.GroupPrice.create({
                 price: ReduceablePrice_js_1.ReduceablePrice.create({
-                    price: 5000,
+                    price: 500000,
                 }),
             });
             const groupC = Group_js_1.Group.create({
@@ -497,30 +543,30 @@ describe('Unit.RegisterCart', () => {
             cart.add(itemA);
             cart.calculatePrices();
             // Check price for items
-            expect(itemA.calculatedPrice).toEqual(5000);
-            expect(itemA.calculatedRefund).toEqual(10000);
+            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(1000); // The previous discount
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(-1000);
-            expect(checkout.totalPrice).toEqual(5000 - 10000 + 1000);
+            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: 5000,
-                }),
-                expect.objectContaining({
-                    // Refund for the previous registration
-                    price: -10000,
+                    price: 500000,
                 }),
                 {
                     name: '766a39be-a4af-4a04-baf0-1f064d2fed16 (Multiple family members discount)',
-                    price: 1000,
+                    price: 100000,
                 },
                 expect.objectContaining({
-                    price: -5000 + 1000,
+                    // 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?
@@ -530,7 +576,7 @@ describe('Unit.RegisterCart', () => {
                     // Custom discount for this price
                     GroupPriceDiscount_js_1.GroupPriceDiscount.create({
                         value: ReduceablePrice_js_1.ReduceablePrice.create({
-                            price: 2500,
+                            price: 250000,
                         }),
                         type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed,
                     }),
@@ -540,25 +586,25 @@ describe('Unit.RegisterCart', () => {
             cart.calculatePrices();
             // Check discount should be given back
             expect(cart.bundleDiscounts).toHaveLength(1);
-            expect(cart.bundleDiscounts[0].total).toEqual(2500);
-            expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(1000); // The previous discount
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(1500);
-            expect(checkout.totalPrice).toEqual(5000 - 10000 - 1500);
+            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: 5000,
-                }),
-                expect.objectContaining({
-                    // Refund for the previous registration
-                    price: -10000,
+                    price: 500000,
                 }),
                 {
                     name: 'Multiple family members discount',
-                    price: -1500,
+                    price: -150000,
                 },
                 expect.objectContaining({
-                    price: -5000 - 1500,
+                    // Refund for the previous registration
+                    price: -1000000,
+                }),
+                expect.objectContaining({
+                    price: -500000 - 150000,
                 }),
             ]);
         });
@@ -574,7 +620,7 @@ describe('Unit.RegisterCart', () => {
                         { value: 1500, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
                     ],
                 }),
-                groupPrices: [10000, 4000],
+                groupPrices: [1000000, 400000],
             });
             const [groupA, groupB] = groups;
             const [memberA, memberB] = family.members;
@@ -583,14 +629,14 @@ describe('Unit.RegisterCart', () => {
                     discount.id,
                     AppliedRegistrationDiscount_js_1.AppliedRegistrationDiscount.create({
                         name: discount.name,
-                        amount: 1000, // 10% discount on 100_00 = 10_00
+                        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: 5000,
+                    price: 500000,
                 }),
             });
             const groupC = Group_js_1.Group.create({
@@ -615,23 +661,23 @@ describe('Unit.RegisterCart', () => {
             cart.add(itemA);
             cart.calculatePrices();
             // Check price for items
-            expect(itemA.calculatedPrice).toEqual(5000);
-            expect(itemA.calculatedRefund).toEqual(9000);
+            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(5000 - 9000);
+            expect(checkout.totalPrice).toEqual(500000 - 900000);
             expect(checkout.priceBreakown).toEqual([
                 expect.objectContaining({
                     // Subtotal (normal price)
-                    price: 5000,
+                    price: 500000,
                 }),
                 expect.objectContaining({
                     // Refund for the previous registration, without the discount that was granted
-                    price: -9000,
+                    price: -900000,
                 }),
                 expect.objectContaining({
-                    price: 5000 - 9000,
+                    price: 500000 - 900000,
                 }),
             ]);
             // Now, what if groupC does have a higher discount instead of no discount?
@@ -641,7 +687,7 @@ describe('Unit.RegisterCart', () => {
                     // Custom discount for this price
                     GroupPriceDiscount_js_1.GroupPriceDiscount.create({
                         value: ReduceablePrice_js_1.ReduceablePrice.create({
-                            price: 2500,
+                            price: 250000,
                         }),
                         type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed,
                     }),
@@ -651,25 +697,25 @@ describe('Unit.RegisterCart', () => {
             cart.calculatePrices();
             // Check discount should be given back
             expect(cart.bundleDiscounts).toHaveLength(1);
-            expect(cart.bundleDiscounts[0].total).toEqual(2500);
+            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(2500);
-            expect(checkout.totalPrice).toEqual(5000 - 9000 - 2500);
+            expect(cart.bundleDiscounts[0].netTotal).toEqual(250000);
+            expect(checkout.totalPrice).toEqual(500000 - 900000 - 250000);
             expect(checkout.priceBreakown).toEqual([
                 expect.objectContaining({
                     // Subtotal (normal price)
-                    price: 5000,
-                }),
-                expect.objectContaining({
-                    // Refund for the previous registration
-                    price: -9000,
+                    price: 500000,
                 }),
                 {
                     name: 'Multiple family members discount',
-                    price: -2500,
+                    price: -250000,
                 },
                 expect.objectContaining({
-                    price: 5000 - 9000 - 2500,
+                    // Refund for the previous registration
+                    price: -900000,
+                }),
+                expect.objectContaining({
+                    price: 500000 - 900000 - 250000,
                 }),
             ]);
         });
@@ -678,7 +724,7 @@ describe('Unit.RegisterCart', () => {
             // 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: [5000, 4000],
+                groupPrices: [500000, 400000],
                 groupNames: ['Group A', 'Group B'],
                 bundleDiscount: createBundleDiscount({
                     name: 'Bundle discount',
@@ -700,39 +746,39 @@ describe('Unit.RegisterCart', () => {
             cart.add(itemC);
             cart.calculatePrices();
             // Check price for items
-            expect(itemA.calculatedPrice).toEqual(5000);
+            expect(itemA.calculatedPrice).toEqual(500000);
             expect(itemA.calculatedRefund).toEqual(0);
             expect(itemA.calculatedPriceDueLater).toEqual(0);
-            expect(itemB.calculatedPrice).toEqual(4000);
+            expect(itemB.calculatedPrice).toEqual(400000);
             expect(itemB.calculatedRefund).toEqual(0);
             expect(itemB.calculatedPriceDueLater).toEqual(0);
-            expect(itemC.calculatedPrice).toEqual(4000);
+            expect(itemC.calculatedPrice).toEqual(400000);
             expect(itemC.calculatedRefund).toEqual(0);
             expect(itemC.calculatedPriceDueLater).toEqual(0);
-            // Check calculated discount is 50_00 * 0.10 + 40_00 * 0.10 = 5_00 + 4_00 = 9_00
+            // 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(900);
+            expect(cart.bundleDiscounts[0].total).toEqual(90000);
             expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(0);
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(900);
-            expect(cart.price).toEqual(5000 + 4000 + 4000);
-            expect(checkout.totalPrice).toEqual(5000 + 4000 + 4000 - 900);
+            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: 13000,
+                    price: 1300000,
                 }),
                 {
                     name: 'Bundle discount',
-                    price: -900,
+                    price: -90000,
                 },
                 expect.objectContaining({
-                    price: 13000 - 900,
+                    price: 1300000 - 90000,
                 }),
             ]);
         });
         test('The highest possible discount is granted', () => {
             const { organization, groups, family, discount } = setupDiscountTest({
                 memberCount: 3,
-                groupPrices: [5000, 4000],
+                groupPrices: [500000, 400000],
                 groupNames: ['Group A', 'Group B'],
                 bundleDiscount: createBundleDiscount({
                     name: 'Bundle discount',
@@ -752,7 +798,7 @@ describe('Unit.RegisterCart', () => {
                 customDiscounts: [
                     GroupPriceDiscount_js_1.GroupPriceDiscount.create({
                         value: ReduceablePrice_js_1.ReduceablePrice.create({
-                            price: 2000,
+                            price: 200000,
                         }),
                         type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed,
                     }),
@@ -772,32 +818,32 @@ describe('Unit.RegisterCart', () => {
             cart.add(itemC);
             cart.calculatePrices();
             // Check price for items
-            expect(itemA.calculatedPrice).toEqual(5000);
+            expect(itemA.calculatedPrice).toEqual(500000);
             expect(itemA.calculatedRefund).toEqual(0);
             expect(itemA.calculatedPriceDueLater).toEqual(0);
-            expect(itemB.calculatedPrice).toEqual(4000);
+            expect(itemB.calculatedPrice).toEqual(400000);
             expect(itemB.calculatedRefund).toEqual(0);
             expect(itemB.calculatedPriceDueLater).toEqual(0);
-            expect(itemC.calculatedPrice).toEqual(4000);
+            expect(itemC.calculatedPrice).toEqual(400000);
             expect(itemC.calculatedRefund).toEqual(0);
             expect(itemC.calculatedPriceDueLater).toEqual(0);
-            // Check calculated discount is 50_00 * 0.10 + 20_00 fixed + 0 = 5_00 + 20_00 + 0 = 25_00
+            // 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(2500);
+            expect(cart.bundleDiscounts[0].total).toEqual(250000);
             expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(0);
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(2500);
-            expect(cart.price).toEqual(5000 + 4000 + 4000);
-            expect(checkout.totalPrice).toEqual(5000 + 4000 + 4000 - 2500);
+            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: 13000,
+                    price: 1300000,
                 }),
                 {
                     name: 'Bundle discount',
-                    price: -2500,
+                    price: -250000,
                 },
                 expect.objectContaining({
-                    price: 13000 - 2500,
+                    price: 1300000 - 250000,
                 }),
             ]);
         });
@@ -808,12 +854,12 @@ describe('Unit.RegisterCart', () => {
             // 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: [10000, 15000],
+                groupPrices: [1000000, 1500000],
                 groupNames: ['Camp A', 'Camp B'],
                 bundleDiscount: createBundleDiscount({
                     name: 'All camp discount',
                     discounts: [
-                        { value: 1000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed },
+                        { value: 100000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed },
                     ],
                 }),
             });
@@ -822,7 +868,7 @@ describe('Unit.RegisterCart', () => {
             const expensiveCampDiscount = createBundleDiscount({
                 name: 'Expensive camp discount',
                 discounts: [
-                    { value: 500, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed },
+                    { value: 50000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed },
                 ],
             });
             // Add discount to organizationRegistrationPeriod
@@ -835,10 +881,10 @@ describe('Unit.RegisterCart', () => {
             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_00 discount
-            const itemC = RegisterItem_js_1.RegisterItem.defaultFor(memberC, campB, organization); // +10_00 discount and +5_00 discount
-            const itemD = RegisterItem_js_1.RegisterItem.defaultFor(memberD, campA, organization); // +10_00 discount
-            const itemE = RegisterItem_js_1.RegisterItem.defaultFor(memberE, campB, organization); // +10_00 discount and +5_00 discount
+            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);
@@ -855,29 +901,29 @@ describe('Unit.RegisterCart', () => {
             })).toEqual([
                 {
                     name: 'All camp discount',
-                    total: 1000 * 4,
-                    netTotal: 1000 * 4,
+                    total: 100000 * 4,
+                    netTotal: 100000 * 4,
                 },
                 {
                     name: 'Expensive camp discount',
-                    total: 500 * 2,
-                    netTotal: 500 * 2,
+                    total: 50000 * 2,
+                    netTotal: 50000 * 2,
                 },
             ]);
             expect(checkout.priceBreakown).toEqual([
                 expect.objectContaining({
-                    price: 10000 * 2 + 15000 * 3,
+                    price: 1000000 * 2 + 1500000 * 3,
                 }),
                 {
                     name: 'All camp discount',
-                    price: -1000 * 4,
+                    price: -100000 * 4,
                 },
                 {
                     name: 'Expensive camp discount',
-                    price: -500 * 2,
+                    price: -50000 * 2,
                 },
                 expect.objectContaining({
-                    price: 10000 * 2 + 15000 * 3 - 1000 * 4 - 500 * 2,
+                    price: 1000000 * 2 + 1500000 * 3 - 100000 * 4 - 50000 * 2,
                 }),
             ]);
         });
@@ -898,7 +944,7 @@ describe('Unit.RegisterCart', () => {
                         { value: 1500, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Percentage },
                     ],
                 }),
-                groupPrices: [10000, 4000],
+                groupPrices: [1000000, 400000],
             });
             const [groupA, groupB] = groups;
             const [memberA, memberB] = family.members;
@@ -906,7 +952,7 @@ describe('Unit.RegisterCart', () => {
             const registrationB = addHistoricRegistration(memberB, groupB, organization);
             registrationA.discounts.set(discount.id, AppliedRegistrationDiscount_js_1.AppliedRegistrationDiscount.create({
                 name: discount.name,
-                amount: 1000, // 10% discount on 100_00 = 10_00
+                amount: 100000, // 10% discount on 100_0000 = 10_0000
             }));
             // Now create itemC
             const itemC = RegisterItem_js_1.RegisterItem.defaultFor(memberA, groupB, organization);
@@ -916,26 +962,26 @@ describe('Unit.RegisterCart', () => {
             cart.add(itemC);
             cart.calculatePrices();
             // Check price for items
-            expect(itemC.calculatedPrice).toEqual(4000);
+            expect(itemC.calculatedPrice).toEqual(400000);
             expect(itemC.calculatedRefund).toEqual(0);
             expect(itemC.calculatedPriceDueLater).toEqual(0);
-            // Check calculated discount is 100_00 * 0.15 + 40_00 * 0.10 = 15_00 + 4_00 = 19_00
+            // 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(1900);
-            expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(1000); // The previous discount
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(900);
-            expect(cart.price).toEqual(4000);
-            expect(checkout.totalPrice).toEqual(4000 - 900);
+            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: 4000,
+                    price: 400000,
                 }),
                 {
                     name: 'Multiple family members discount',
-                    price: -900,
+                    price: -90000,
                 },
                 expect.objectContaining({
-                    price: 4000 - 900,
+                    price: 400000 - 90000,
                 }),
             ]);
         });
@@ -944,7 +990,7 @@ describe('Unit.RegisterCart', () => {
             // 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: [5000, 4000],
+                groupPrices: [500000, 400000],
                 groupNames: ['Group A', 'Group B'],
                 bundleDiscount: createBundleDiscount({
                     name: 'Bundle discount',
@@ -967,32 +1013,32 @@ describe('Unit.RegisterCart', () => {
             cart.add(itemC);
             cart.calculatePrices();
             // Check price for items
-            expect(itemA.calculatedPrice).toEqual(5000);
+            expect(itemA.calculatedPrice).toEqual(500000);
             expect(itemA.calculatedRefund).toEqual(0);
             expect(itemA.calculatedPriceDueLater).toEqual(0);
-            expect(itemB.calculatedPrice).toEqual(4000);
+            expect(itemB.calculatedPrice).toEqual(400000);
             expect(itemB.calculatedRefund).toEqual(0);
             expect(itemB.calculatedPriceDueLater).toEqual(0);
-            expect(itemC.calculatedPrice).toEqual(4000);
+            expect(itemC.calculatedPrice).toEqual(400000);
             expect(itemC.calculatedRefund).toEqual(0);
             expect(itemC.calculatedPriceDueLater).toEqual(0);
-            // Check calculated discount is 50_00 * 0.10 = 5_00
+            // Check calculated discount is 50_0000 * 0.10 = 5_0000
             expect(cart.bundleDiscounts).toHaveLength(1);
-            expect(cart.bundleDiscounts[0].total).toEqual(500);
+            expect(cart.bundleDiscounts[0].total).toEqual(50000);
             expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(0);
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(500);
-            expect(cart.price).toEqual(5000 + 4000 + 4000);
-            expect(checkout.totalPrice).toEqual(5000 + 4000 + 4000 - 500);
+            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: 13000,
+                    price: 1300000,
                 }),
                 {
                     name: 'Bundle discount',
-                    price: -500,
+                    price: -50000,
                 },
                 expect.objectContaining({
-                    price: 13000 - 500,
+                    price: 1300000 - 50000,
                 }),
             ]);
         });
@@ -1003,7 +1049,7 @@ describe('Unit.RegisterCart', () => {
             // 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: [5000, 4000],
+                groupPrices: [500000, 400000],
                 groupNames: ['Group A', 'Group B'],
                 bundleDiscount: createBundleDiscount({
                     name: 'Bundle discount',
@@ -1028,42 +1074,42 @@ describe('Unit.RegisterCart', () => {
             cart.add(itemC);
             cart.calculatePrices();
             // Check price for items
-            expect(itemA.calculatedPrice).toEqual(5000);
-            expect(itemB.calculatedPrice).toEqual(4000);
-            expect(itemC.calculatedPrice).toEqual(4000);
-            // Check calculated discount is 40_00 * 1 + 50_00 * 5% = 40_00 + 2_50 = 42_50
+            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(4250);
+            expect(cart.bundleDiscounts[0].total).toEqual(425000);
             expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(0);
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(4250);
-            expect(cart.price).toEqual(5000 + 4000 + 4000);
-            expect(checkout.totalPrice).toEqual(5000 + 4000 + 4000 - 4250);
+            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: 13000,
+                    price: 1300000,
                 }),
                 {
                     name: 'Bundle discount',
-                    price: -4250,
+                    price: -425000,
                 },
                 expect.objectContaining({
-                    price: 13000 - 4250,
+                    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_00 + 5% on 40_00 = 5_00 + 2_00 = 7_00
+            // 10% on 50_0000 + 5% on 40_0000 = 5_0000 + 2_0000 = 7_0000
             expect(checkout.priceBreakown).toEqual([
                 expect.objectContaining({
-                    price: 13000,
+                    price: 1300000,
                 }),
                 {
                     name: 'Bundle discount',
-                    price: -700,
+                    price: -70000,
                 },
                 expect.objectContaining({
-                    price: 13000 - 700,
+                    price: 1300000 - 70000,
                 }),
             ]);
         });
@@ -1095,25 +1141,25 @@ describe('Unit.RegisterCart', () => {
             cart.add(itemC);
             cart.calculatePrices();
             // Check price for items
-            expect(itemA.calculatedPrice).toEqual(5000);
-            expect(itemB.calculatedPrice).toEqual(4000);
-            expect(itemC.calculatedPrice).toEqual(5000);
-            // Check calculated discount is 50_00 * 0.10 = 5_00
+            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(500);
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(500);
-            expect(cart.price).toEqual(5000 + 4000 + 5000);
-            expect(checkout.totalPrice).toEqual(5000 + 4000 + 5000 - 500);
+            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: 5000 + 4000 + 5000,
+                    price: 500000 + 400000 + 500000,
                 }),
                 {
                     name: 'Multiple lessons discount (John)',
-                    price: -500,
+                    price: -50000,
                 },
                 expect.objectContaining({
-                    price: 5000 + 4000 + 5000 - 500,
+                    price: 500000 + 400000 + 500000 - 50000,
                 }),
             ]);
             // Add a historic registration for member B, so it also gets a discount
@@ -1121,18 +1167,18 @@ describe('Unit.RegisterCart', () => {
             cart.calculatePrices();
             expect(checkout.priceBreakown).toEqual([
                 expect.objectContaining({
-                    price: 5000 + 4000 + 5000, // no change
+                    price: 500000 + 400000 + 500000, // no change
                 }),
                 {
                     name: 'Multiple lessons discount (John)',
-                    price: -500,
+                    price: -50000,
                 },
                 {
                     name: 'Multiple lessons discount (Jane)',
-                    price: -500,
+                    price: -50000,
                 },
                 expect.objectContaining({
-                    price: 5000 + 4000 + 5000 - 500 - 500,
+                    price: 500000 + 400000 + 500000 - 50000 - 50000,
                 }),
             ]);
         });
@@ -1162,27 +1208,27 @@ describe('Unit.RegisterCart', () => {
             cart.calculatePrices();
             // No discount should be applied yet (need at least 2 different groups)
             expect(cart.bundleDiscounts).toHaveLength(0);
-            expect(checkout.totalPrice).toEqual(5000 + 4000);
+            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(400); // 10% of 40_00 (not 50_00)
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(400);
-            expect(cart.price).toEqual(5000 + 4000 + 4000);
-            expect(checkout.totalPrice).toEqual(5000 + 4000 + 4000 - 400);
+            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: 5000 + 4000 + 4000,
+                    price: 500000 + 400000 + 400000,
                 }),
                 {
                     name: 'Multiple family members discount (Group B)',
-                    price: -400,
+                    price: -40000,
                 },
                 expect.objectContaining({
-                    price: 5000 + 4000 + 4000 - 400,
+                    price: 500000 + 400000 + 400000 - 40000,
                 }),
             ]);
             // Change calculation to count across groups
@@ -1191,14 +1237,14 @@ describe('Unit.RegisterCart', () => {
             // Now we should get a discount for both groups
             expect(checkout.priceBreakown).toEqual([
                 expect.objectContaining({
-                    price: 5000 + 4000 + 4000,
+                    price: 500000 + 400000 + 400000,
                 }),
                 {
                     name: 'Multiple family members discount',
-                    price: -900,
+                    price: -90000,
                 },
                 expect.objectContaining({
-                    price: 5000 + 4000 + 4000 - 900,
+                    price: 500000 + 400000 + 400000 - 90000,
                 }),
             ]);
         });
@@ -1230,25 +1276,25 @@ describe('Unit.RegisterCart', () => {
             cart.add(itemC);
             cart.calculatePrices();
             // Check price for items
-            expect(itemA.calculatedPrice).toEqual(5000);
-            expect(itemB.calculatedPrice).toEqual(4000);
-            expect(itemC.calculatedPrice).toEqual(5000);
+            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(500); // 10% of 50_00 (we always apply discounts to highest price first)
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(500);
-            expect(cart.price).toEqual(5000 + 4000 + 5000);
-            expect(checkout.totalPrice).toEqual(5000 + 4000 + 5000 - 500);
+            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: 5000 + 4000 + 5000,
+                    price: 500000 + 400000 + 500000,
                 }),
                 {
                     name: 'Multiple lessons discount (John)',
-                    price: -500,
+                    price: -50000,
                 },
                 expect.objectContaining({
-                    price: 5000 + 4000 + 5000 - 500,
+                    price: 500000 + 400000 + 500000 - 50000,
                 }),
             ]);
             // Now explicitly turn on countPerGroup and set countWholeFamily to true
@@ -1259,14 +1305,14 @@ describe('Unit.RegisterCart', () => {
             // Now we should get a discount for group A (since two members are registered for it)
             expect(checkout.priceBreakown).toEqual([
                 expect.objectContaining({
-                    price: 5000 + 4000 + 5000,
+                    price: 500000 + 400000 + 500000,
                 }),
                 {
                     name: 'Multiple lessons discount (Group A)',
-                    price: -500, // 10% of the second 50_00
+                    price: -50000, // 10% of the second 50_0000
                 },
                 expect.objectContaining({
-                    price: 5000 + 4000 + 5000 - 500,
+                    price: 500000 + 400000 + 500000 - 50000,
                 }),
             ]);
         });
@@ -1275,7 +1321,7 @@ describe('Unit.RegisterCart', () => {
             // 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: [5000, 4000],
+                groupPrices: [500000, 400000],
                 groupNames: ['Group A', 'Group B'],
                 bundleDiscount: createBundleDiscount({
                     name: 'Multiple family members discount',
@@ -1291,19 +1337,19 @@ describe('Unit.RegisterCart', () => {
             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, [3000], ['Group C']);
+            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(3000);
+            expect(itemC.calculatedPrice).toEqual(300000);
             expect(cart.bundleDiscounts).toHaveLength(0);
-            expect(checkout.totalPrice).toEqual(3000);
+            expect(checkout.totalPrice).toEqual(300000);
             expect(checkout.priceBreakown).toEqual([
                 expect.objectContaining({
-                    price: 3000,
+                    price: 300000,
                 }),
             ]);
             // Now also register memberB for group A and add it to the cart
@@ -1311,26 +1357,26 @@ describe('Unit.RegisterCart', () => {
             cart.add(itemD);
             cart.calculatePrices();
             // Check price for items
-            expect(itemD.calculatedPrice).toEqual(5000);
-            expect(itemC.calculatedPrice).toEqual(3000);
+            expect(itemD.calculatedPrice).toEqual(500000);
+            expect(itemC.calculatedPrice).toEqual(300000);
             // Check calculated discount: should also take old registrations into account
-            // 50_00 * 10% + 50_00 * 10% = 5_00 + 5_00 = 10_00
+            // 50_0000 * 10% + 50_0000 * 10% = 5_0000 + 5_0000 = 10_0000
             expect(cart.bundleDiscounts).toHaveLength(1);
-            expect(cart.bundleDiscounts[0].total).toEqual(1000);
+            expect(cart.bundleDiscounts[0].total).toEqual(100000);
             expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(0);
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(1000);
-            expect(cart.price).toEqual(5000 + 3000);
-            expect(checkout.totalPrice).toEqual(5000 + 3000 - 1000);
+            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: 5000 + 3000,
+                    price: 500000 + 300000,
                 }),
                 {
                     name: 'Multiple family members discount',
-                    price: -1000,
+                    price: -100000,
                 },
                 expect.objectContaining({
-                    price: 5000 + 3000 - 1000,
+                    price: 500000 + 300000 - 100000,
                 }),
             ]);
         });
@@ -1343,7 +1389,7 @@ describe('Unit.RegisterCart', () => {
                     countWholeFamily: true,
                     countPerGroup: false,
                     discounts: [
-                        { value: 100000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed },
+                        { value: 10000000, type: GroupPriceDiscount_js_1.GroupPriceDiscountType.Fixed },
                     ],
                 }),
             });
@@ -1358,21 +1404,21 @@ describe('Unit.RegisterCart', () => {
             cart.add(itemB);
             cart.calculatePrices();
             expect(cart.bundleDiscounts).toHaveLength(1);
-            expect(cart.bundleDiscounts[0].total).toEqual(5000);
+            expect(cart.bundleDiscounts[0].total).toEqual(500000);
             expect(cart.bundleDiscounts[0].totalAlreadyApplied).toEqual(0);
-            expect(cart.bundleDiscounts[0].netTotal).toEqual(5000);
-            expect(cart.price).toEqual(5000 + 4000);
-            expect(checkout.totalPrice).toEqual(4000);
+            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: 5000 + 4000,
+                    price: 500000 + 400000,
                 }),
                 {
                     name: 'Multiple family members discount',
-                    price: -5000,
+                    price: -500000,
                 },
                 expect.objectContaining({
-                    price: 4000,
+                    price: 400000,
                 }),
             ]);
         });