@stamhoofd/backend 2.39.1 → 2.40.1

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

@@ -1,14 +1,11 @@
-/* eslint-disable jest/expect-expect */
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-/* eslint-disable jest/no-standalone-expect */
-import { Request, Response } from "@simonbackx/simple-endpoints";
-import { Organization, OrganizationFactory, StripeAccount, Token, User,UserFactory, Webshop, WebshopFactory } from "@stamhoofd/models";
-import { Address, Cart, CartItem, CartItemOption, Country, Customer, Option, OptionMenu, OrderData, OrderResponse, PaymentConfiguration, PaymentMethod, PermissionLevel, Permissions, PrivatePaymentConfiguration, Product, ProductPrice, ProductType, SeatingPlan, SeatingPlanRow, SeatingPlanSeat, SeatingPlanSection, TransferSettings, WebshopDeliveryMethod, WebshopMetaData, WebshopOnSiteMethod, WebshopPrivateMetaData, WebshopTakeoutMethod, WebshopTimeSlot } from "@stamhoofd/structures";
+import { Request, Response } from '@simonbackx/simple-endpoints';
+import { Organization, OrganizationFactory, StripeAccount, Token, User, UserFactory, Webshop, WebshopFactory } from '@stamhoofd/models';
+import { Address, Cart, CartItem, CartItemOption, Country, Customer, Option, OptionMenu, OrderData, OrderResponse, PaymentConfiguration, PaymentMethod, PermissionLevel, Permissions, PrivatePaymentConfiguration, Product, ProductPrice, ProductType, SeatingPlan, SeatingPlanRow, SeatingPlanSeat, SeatingPlanSection, TransferSettings, WebshopDeliveryMethod, WebshopMetaData, WebshopOnSiteMethod, WebshopPrivateMetaData, WebshopTakeoutMethod, WebshopTimeSlot } from '@stamhoofd/structures';
 import sinon from 'sinon';
 
-import { StripeMocker } from "../../../../tests/helpers/StripeMocker";
-import { testServer } from "../../../../tests/helpers/TestServer";
-import { PatchWebshopOrdersEndpoint } from "../dashboard/webshops/PatchWebshopOrdersEndpoint";
+import { StripeMocker } from '../../../../tests/helpers/StripeMocker';
+import { testServer } from '../../../../tests/helpers/TestServer';
+import { PatchWebshopOrdersEndpoint } from '../dashboard/webshops/PatchWebshopOrdersEndpoint';
 import { PlaceOrderEndpoint } from './PlaceOrderEndpoint';
 
 const address = Address.create({
@@ -16,17 +13,17 @@ const address = Address.create({
     number: '15',
     postalCode: '9000',
     city: 'Gent',
-    country: Country.Belgium
-})
+    country: Country.Belgium,
+});
 
 const customer = Customer.create({
     firstName: 'John',
     lastName: 'Doe',
     email: 'john@example.com',
-    phone: '+32412345678'
+    phone: '+32412345678',
 });
 
-describe("Endpoint.PlaceOrderEndpoint", () => {
+describe('Endpoint.PlaceOrderEndpoint', () => {
     // Test endpoint
     const endpoint = new PlaceOrderEndpoint();
     const patchWebshopOrdersEndpoint = new PatchWebshopOrdersEndpoint();
@@ -57,8 +54,8 @@ describe("Endpoint.PlaceOrderEndpoint", () => {
     let checkboxOption2: Option;
     let radioOption1: Option;
     let radioOption2: Option;
-    let stripeMocker: StripeMocker
-    let stripeAccount: StripeAccount
+    let stripeMocker: StripeMocker;
+    let stripeAccount: StripeAccount;
     let token: Token;
 
     async function refreshAll() {
@@ -91,7 +88,7 @@ describe("Endpoint.PlaceOrderEndpoint", () => {
     async function saveChanges() {
         // Set products
         webshop = (await Webshop.getByID(webshop.id))!;
-        webshop.products = [product, seatProduct, personProduct]
+        webshop.products = [product, seatProduct, personProduct];
         await webshop.save();
         await refreshAll();
     }
@@ -99,16 +96,16 @@ describe("Endpoint.PlaceOrderEndpoint", () => {
     beforeAll(async () => {
         stripeMocker = new StripeMocker();
         stripeMocker.start();
-        organization = await new OrganizationFactory({}).create()
+        organization = await new OrganizationFactory({}).create();
         stripeAccount = await stripeMocker.createStripeAccount(organization.id);
 
         const user = await new UserFactory({
             organization,
             permissions: Permissions.create({
-                level: PermissionLevel.Full
-            })
-        }).create()
-        token = await Token.createToken(user)
+                level: PermissionLevel.Full,
+            }),
+        }).create();
+        token = await Token.createToken(user);
     });
 
     afterAll(() => {
@@ -126,70 +123,70 @@ describe("Endpoint.PlaceOrderEndpoint", () => {
         productPrice1 = ProductPrice.create({
             name: 'productPrice1',
             price: 100,
-            stock: 100
-        })
+            stock: 100,
+        });
 
         productPrice2 = ProductPrice.create({
             name: 'productPrice2',
             price: 150,
-            stock: 100
-        })
+            stock: 100,
+        });
 
         freeProductPrice = ProductPrice.create({
             name: 'freeProductPrice',
             price: 0,
-            stock: 100
-        })
+            stock: 100,
+        });
 
         checkboxOption1 = Option.create({
             name: 'checkboxOption1',
             price: 10,
-            stock: 100
-        })
+            stock: 100,
+        });
 
         checkboxOption2 = Option.create({
             name: 'checkboxOption2',
             price: 0,
-            stock: 100
-        })
+            stock: 100,
+        });
 
         radioOption1 = Option.create({
             name: 'radioOption1',
             price: 10,
-            stock: 100
-        })
+            stock: 100,
+        });
 
         radioOption2 = Option.create({
             name: 'radioOption2',
             price: 0,
-            stock: 100
-        })
+            stock: 100,
+        });
 
         multipleChoiceOptionMenu = OptionMenu.create({
             name: 'multipleChoiceOptionMenu',
             multipleChoice: true,
-            options: [checkboxOption1, checkboxOption2]
-        })
+            options: [checkboxOption1, checkboxOption2],
+        });
 
         chooseOneOptionMenu = OptionMenu.create({
             name: 'chooseOneOptionMenu',
             multipleChoice: false,
-            options: [radioOption1, radioOption2]
-        })
+            options: [radioOption1, radioOption2],
+        });
 
         product = Product.create({
             name: 'product',
             stock: 100,
             prices: [productPrice1, productPrice2, freeProductPrice],
-            optionMenus: [multipleChoiceOptionMenu, chooseOneOptionMenu]
-        })
+            optionMenus: [multipleChoiceOptionMenu, chooseOneOptionMenu],
+        });
 
         personProduct = Product.create({
             name: 'personProduct',
             type: ProductType.Person,
-            stock: 100
-        })
-        personProductPrice = personProduct.prices[0]
+            stock: 100,
+        });
+        personProductPrice = personProduct.prices[0];
 
         seatingPlan = SeatingPlan.create({
             name: 'Testzaal',
@@ -200,137 +197,136 @@ describe("Endpoint.PlaceOrderEndpoint", () => {
                             label: 'A',
                             seats: [
                                 SeatingPlanSeat.create({
-                                    label: '1'
+                                    label: '1',
                                 }),
                                 SeatingPlanSeat.create({
-                                    label: '2'
+                                    label: '2',
                                 }),
                                 SeatingPlanSeat.create({
-                                    label: '3'
+                                    label: '3',
                                 }),
                                 SeatingPlanSeat.create({
-                                    label: '4'
-                                })
-                            ]
+                                    label: '4',
+                                }),
+                            ],
                         }),
                         SeatingPlanRow.create({
                             label: 'B',
                             seats: [
                                 SeatingPlanSeat.create({
-                                    label: '1'
+                                    label: '1',
                                 }),
                                 SeatingPlanSeat.create({
-                                    label: '2'
+                                    label: '2',
                                 }),
                                 SeatingPlanSeat.create({
-                                    label: '3'
+                                    label: '3',
                                 }),
                                 SeatingPlanSeat.create({
-                                    label: '4'
-                                })
-                            ]
-                        })
-                    ]
-                })
-            ]
-        })
-        meta.seatingPlans.addPut(seatingPlan)
+                                    label: '4',
+                                }),
+                            ],
+                        }),
+                    ],
+                }),
+            ],
+        });
+        meta.seatingPlans.addPut(seatingPlan);
 
         seatProduct = Product.create({
             name: 'seatProduct',
             type: ProductType.Ticket,
-            seatingPlanId: seatingPlan.id
-        })
-        seatProductPrice = seatProduct.prices[0]
+            seatingPlanId: seatingPlan.id,
+        });
+        seatProductPrice = seatProduct.prices[0];
 
         // Takeout
         takeoutMethod = WebshopTakeoutMethod.create({
             name: 'Bakkerij Test',
-            address
-        })
+            address,
+        });
 
         slot1 = WebshopTimeSlot.create({
             date: new Date(),
             maxPersons: 100,
-            maxOrders: 100
+            maxOrders: 100,
         });
-        takeoutMethod.timeSlots.timeSlots.push(slot1)
+        takeoutMethod.timeSlots.timeSlots.push(slot1);
 
         slot2 = WebshopTimeSlot.create({
             date: new Date(),
             maxPersons: 100,
             maxOrders: 100,
-            startTime: 14*60,
-            endTime: 15*60
-        })
-        takeoutMethod.timeSlots.timeSlots.push(slot2)
-        meta.checkoutMethods.addPut(takeoutMethod)
-
+            startTime: 14 * 60,
+            endTime: 15 * 60,
+        });
+        takeoutMethod.timeSlots.timeSlots.push(slot2);
+        meta.checkoutMethods.addPut(takeoutMethod);
 
         // Delivery
         deliveryMethod = WebshopDeliveryMethod.create({
             name: 'Delivery',
-            countries: [Country.Belgium]
-        })
+            countries: [Country.Belgium],
+        });
 
         slot3 = WebshopTimeSlot.create({
             date: new Date(),
             maxPersons: 100,
-            maxOrders: 100
+            maxOrders: 100,
         });
 
-        deliveryMethod.timeSlots.timeSlots.push(slot3)
-        meta.checkoutMethods.addPut(deliveryMethod)
+        deliveryMethod.timeSlots.timeSlots.push(slot3);
+        meta.checkoutMethods.addPut(deliveryMethod);
 
         // OnSite
         onSiteMethod = WebshopOnSiteMethod.create({
             name: 'Onsite',
-            address
-        })
+            address,
+        });
 
         slot4 = WebshopTimeSlot.create({
             date: new Date(),
             maxPersons: 100,
-            maxOrders: 100
+            maxOrders: 100,
         });
 
-        onSiteMethod.timeSlots.timeSlots.push(slot4)
-        meta.checkoutMethods.addPut(onSiteMethod)
-        
+        onSiteMethod.timeSlots.timeSlots.push(slot4);
+        meta.checkoutMethods.addPut(onSiteMethod);
+
         const paymentConfigurationPatch = PaymentConfiguration.patch({
             transferSettings: TransferSettings.create({
-                iban: 'BE56587127952688' // = random IBAN
+                iban: 'BE56587127952688', // = random IBAN
             }),
-        })
-        paymentConfigurationPatch.paymentMethods.addPut(PaymentMethod.PointOfSale)
-        paymentConfigurationPatch.paymentMethods.addPut(PaymentMethod.Transfer)
-        paymentConfigurationPatch.paymentMethods.addPut(PaymentMethod.Bancontact)
+        });
+        paymentConfigurationPatch.paymentMethods.addPut(PaymentMethod.PointOfSale);
+        paymentConfigurationPatch.paymentMethods.addPut(PaymentMethod.Transfer);
+        paymentConfigurationPatch.paymentMethods.addPut(PaymentMethod.Bancontact);
 
         const privatePaymentConfiguration = PrivatePaymentConfiguration.patch({
-            stripeAccountId: stripeAccount.id
-        })
+            stripeAccountId: stripeAccount.id,
+        });
 
         meta = meta.patch({
-            paymentConfiguration: paymentConfigurationPatch
-        })
+            paymentConfiguration: paymentConfigurationPatch,
+        });
 
         const privateMeta = WebshopPrivateMetaData.patch({
-            paymentConfiguration: privatePaymentConfiguration
-        })
+            paymentConfiguration: privatePaymentConfiguration,
+        });
 
         webshop = await new WebshopFactory({
             organizationId: organization.id,
             name: 'Test webshop',
             meta,
             privateMeta,
-            products: [product, seatProduct, personProduct]
-        }).create()
+            products: [product, seatProduct, personProduct],
+        }).create();
     });
 
     describe('User authentication', () => {
-        test("Placing an order with a signed in user overrides the order customer", async () => {
-            const user = await new UserFactory({ organization, firstName: 'User', lastName: 'Tester' }).create()
-            const token = await Token.createToken(user)
+        test('Placing an order with a signed in user overrides the order customer', async () => {
+            const user = await new UserFactory({ organization, firstName: 'User', lastName: 'Tester' }).create();
+            const token = await Token.createToken(user);
 
             const orderData = OrderData.create({
                 paymentMethod: PaymentMethod.Unknown,
@@ -345,21 +341,21 @@ describe("Endpoint.PlaceOrderEndpoint", () => {
                             options: [
                                 CartItemOption.create({
                                     optionMenu: multipleChoiceOptionMenu,
-                                    option: checkboxOption2
+                                    option: checkboxOption2,
                                 }),
                                 CartItemOption.create({
                                     optionMenu: chooseOneOptionMenu,
-                                    option: radioOption2
-                                })
-                            ]
-                        })
-                    ]
+                                    option: radioOption2,
+                                }),
+                            ],
+                        }),
+                    ],
                 }),
-                customer
-            })
-            
-            const r = Request.buildJson("POST", `/webshop/${webshop.id}/order`, organization.getApiHost(), orderData);
-            r.headers.authorization = "Bearer " + token.accessToken
+                customer,
+            });
+
+            const r = Request.buildJson('POST', `/webshop/${webshop.id}/order`, organization.getApiHost(), orderData);
+            r.headers.authorization = 'Bearer ' + token.accessToken;
 
             const response = await testServer.test(endpoint, r);
             expect(response.body).toBeDefined();
@@ -373,7 +369,7 @@ describe("Endpoint.PlaceOrderEndpoint", () => {
         /**
          * This checks if the authenticated context is passed when multiple orders are executed in a queue
          */
-        test("Authenticated context is guarded with race conditions", async () => {
+        test('Authenticated context is guarded with race conditions', async () => {
             const orderData = OrderData.create({
                 paymentMethod: PaymentMethod.Unknown,
                 checkoutMethod: onSiteMethod,
@@ -387,18 +383,18 @@ describe("Endpoint.PlaceOrderEndpoint", () => {
                             options: [
                                 CartItemOption.create({
                                     optionMenu: multipleChoiceOptionMenu,
-                                    option: checkboxOption2
+                                    option: checkboxOption2,
                                 }),
                                 CartItemOption.create({
                                     optionMenu: chooseOneOptionMenu,
-                                    option: radioOption2
-                                })
-                            ]
-                        })
-                    ]
+                                    option: radioOption2,
+                                }),
+                            ],
+                        }),
+                    ],
                 }),
-                customer
-            })
+                customer,
+            });
 
             let counter = 0;
             let resolve: null | (() => void) = null;
@@ -420,17 +416,17 @@ describe("Endpoint.PlaceOrderEndpoint", () => {
                 return stub.wrappedMethod.apply(this, args);
             });
 
-            const pendingResponses: {promise: Promise<Response<OrderResponse>>, user: User}[] = []
+            const pendingResponses: { promise: Promise<Response<OrderResponse>>; user: User }[] = [];
             for (let i = 0; i < 10; i++) {
-                const user = await new UserFactory({ organization, firstName: 'User', lastName: 'Tester' }).create()
-                const token = await Token.createToken(user)
+                const user = await new UserFactory({ organization, firstName: 'User', lastName: 'Tester' }).create();
+                const token = await Token.createToken(user);
 
-                const r = Request.buildJson("POST", `/webshop/${webshop.id}/order`, organization.getApiHost(), orderData);
-                r.headers.authorization = "Bearer " + token.accessToken
+                const r = Request.buildJson('POST', `/webshop/${webshop.id}/order`, organization.getApiHost(), orderData);
+                r.headers.authorization = 'Bearer ' + token.accessToken;
 
                 pendingResponses.push({
                     promise: testServer.test(endpoint, r),
-                    user
+                    user,
                 });
             }