@unchainedshop/plugins 4.0.0-rc.16 → 4.0.0-rc.18

package/src/payment/saferpay/handler-fastify.ts

@@ -4,7 +4,7 @@ import { buildSignature } from './buildSignature.js';
 import { SaferpayTransactionsModule } from './module.js';
 import { FastifyRequest, RouteHandlerMethod } from 'fastify';
 
-const logger = createLogger('unchained:core-payment:saferpay:handler');
+const logger = createLogger('unchained:saferpay:handler');
 
 export const saferpayHandler: RouteHandlerMethod = async (
   request: FastifyRequest & {
@@ -52,6 +52,9 @@ export const saferpayHandler: RouteHandlerMethod = async (
         transactionId,
       },
     });
+
+    if (!order) throw new Error(`Order with id ${orderPayment.orderId} not found`);
+
     logger.info(`checkout successful`, {
       orderPaymentId,
       orderId: order._id,

package/src/payment/stripe/handler-express.ts

@@ -2,7 +2,7 @@ import { Context } from '@unchainedshop/api';
 import { createLogger } from '@unchainedshop/logger';
 import stripeClient from './stripe.js';
 
-const logger = createLogger('unchained:core-payment:stripe:handler');
+const logger = createLogger('unchained:stripe:handler');
 
 export const WebhookEventTypes = {
   PAYMENT_INTENT_SUCCEEDED: 'payment_intent.succeeded',
@@ -18,6 +18,12 @@ export const stripeHandler = async (request, response) => {
   try {
     const stripe = stripeClient();
     const sig = request.headers['stripe-signature'];
+    if (!sig) {
+      throw new Error('stripe-signature header was not provided for webhook');
+    }
+    if (!process.env.STRIPE_ENDPOINT_SECRET) {
+      throw new Error('env STRIPE_ENDPOINT_SECRET is required for webhook handling');
+    }
     event = stripe.webhooks.constructEvent(request.body, sig, process.env.STRIPE_ENDPOINT_SECRET);
   } catch (err) {
     logger.error(`Error constructing event: ${err.message}`);
@@ -80,6 +86,8 @@ export const stripeHandler = async (request, response) => {
         },
       });
 
+      if (!order) throw new Error(`Order with id ${orderPayment.orderId} not found`);
+
       logger.info(`checkout successful`, {
         orderPaymentId,
         orderId: order._id,

package/src/payment/stripe/handler-fastify.ts

@@ -3,7 +3,7 @@ import { createLogger } from '@unchainedshop/logger';
 import stripeClient from './stripe.js';
 import { FastifyRequest, RouteHandlerMethod } from 'fastify';
 
-const logger = createLogger('unchained:core-payment:stripe:handler');
+const logger = createLogger('unchained:stripe:handler');
 
 export const WebhookEventTypes = {
   PAYMENT_INTENT_SUCCEEDED: 'payment_intent.succeeded',
@@ -24,6 +24,12 @@ export const stripeHandler: RouteHandlerMethod = async (
   try {
     const stripe = stripeClient();
     const sig = req.headers['stripe-signature'];
+    if (!process.env.STRIPE_ENDPOINT_SECRET) {
+      throw new Error('env STRIPE_ENDPOINT_SECRET is required for webhook handling');
+    }
+    if (!sig) {
+      throw new Error('stripe-signature header was not provided for webhook');
+    }
     event = stripe.webhooks.constructEvent(req.body as string, sig, process.env.STRIPE_ENDPOINT_SECRET);
   } catch (err) {
     logger.error(`Error constructing event: ${err.message}`);
@@ -91,6 +97,8 @@ export const stripeHandler: RouteHandlerMethod = async (
         },
       });
 
+      if (!order) throw new Error(`Order with id ${orderPayment.orderId} not found`);
+
       logger.info(`checkout successful`, {
         orderPaymentId,
         orderId: order._id,

package/src/payment/stripe/index.ts

@@ -8,7 +8,7 @@ import {
   PaymentError,
 } from '@unchainedshop/core';
 
-const logger = createLogger('unchained:core-payment:stripe');
+const logger = createLogger('unchained:stripe');
 
 const Stripe: IPaymentAdapter = {
   ...PaymentAdapter,
@@ -24,13 +24,14 @@ const Stripe: IPaymentAdapter = {
   actions: (config, context) => {
     const { modules } = context;
 
-    const descriptorPrefix = config.find(({ key }) => key === 'descriptorPrefix')?.value;
+    const descriptorPrefix = config.find(({ key }) => key === 'descriptorPrefix')?.value || '';
 
-    const getUserData = async (forcedUserId) => {
+    const assertUserData = async (forcedUserId) => {
       const userId = forcedUserId || context?.userId;
       const user = await modules.users.findUserById(userId);
+      if (!user) throw new Error('User not found');
       const email = modules.users.primaryEmail(user)?.address;
-      const name = user.profile.displayName || user.username || email;
+      const name = user.profile?.displayName || user.username || email;
       return {
         email,
         name,
@@ -41,8 +42,9 @@ const Stripe: IPaymentAdapter = {
       ...PaymentAdapter.actions(config, context),
 
       configurationError() {
-        const stripe = stripeClient();
-        if (!stripe) {
+        try {
+          stripeClient();
+        } catch {
           return PaymentError.INCOMPLETE_CONFIGURATION;
         }
         return null;
@@ -86,13 +88,15 @@ const Stripe: IPaymentAdapter = {
 
       sign: async (transactionContext = {}) => {
         const { orderPayment, order, paymentProviderId } = context;
+        const { userId, name, email } = await assertUserData(order?.userId);
+
+        if (!order) throw new Error('order not found in context');
 
         if (orderPayment) {
           const pricing = OrderPricingSheet({
             calculation: order.calculation,
             currencyCode: order.currencyCode,
           });
-          const { userId, name, email } = await getUserData(order?.userId);
           const paymentIntent = await createOrderPaymentIntent(
             { userId, name, email, order, orderPayment, pricing, descriptorPrefix },
             transactionContext,
@@ -100,7 +104,6 @@ const Stripe: IPaymentAdapter = {
           return paymentIntent.client_secret;
         }
 
-        const { userId, name, email } = await getUserData(order?.userId);
         const paymentIntent = await createRegistrationIntent(
           { userId, name, email, paymentProviderId, descriptorPrefix },
           transactionContext,
@@ -114,11 +117,12 @@ const Stripe: IPaymentAdapter = {
           throw new Error('You have to provide paymentIntentId or paymentCredentials');
         }
 
-        const { order } = context;
-        const orderPayment = await modules.orders.payments.findOrderPayment({
-          orderPaymentId: order.paymentId,
-        });
-        const { userId, name, email } = await getUserData(order?.userId);
+        const { order, orderPayment } = context;
+
+        if (!order) throw new Error('order not found in context');
+        if (!orderPayment) throw new Error('orderPayment not found in context');
+
+        const { userId, name, email } = await assertUserData(order?.userId);
         const pricing = OrderPricingSheet({
           calculation: order.calculation,
           currencyCode: order.currencyCode,

package/src/payment/stripe/stripe.ts

@@ -3,29 +3,32 @@ import { Order, OrderPayment } from '@unchainedshop/core-orders';
 import { createLogger } from '@unchainedshop/logger';
 import { Stripe as StripeType } from 'stripe';
 
-const logger = createLogger('unchained:plugins:payment:stripe');
+const logger = createLogger('unchained:stripe');
 
 const { STRIPE_SECRET, STRIPE_WEBHOOK_ENVIRONMENT, EMAIL_WEBSITE_NAME } = process.env;
 
 let stripe: Awaited<ReturnType<typeof initStripeClient>> | null;
 
-export const initStripeClient = async (): Promise<StripeType> => {
+export const initStripeClient = async (): Promise<StripeType | null> => {
   if (!STRIPE_SECRET) {
     logger.warn('STRIPE_SECRET is not set, skipping initialization');
-    return null;
+    return Promise.resolve(null);
   }
   // eslint-disable-next-line
   // @ts-ignore
   const { default: Stripe } = await import('stripe');
   stripe = new Stripe(STRIPE_SECRET, {
-    apiVersion: '2025-08-27.basil',
+    apiVersion: '2025-09-30.clover',
   });
   return stripe;
 };
 
 initStripeClient().catch(logger.warn);
 
-export default function () {
+export default function getStripe() {
+  if (!stripe) {
+    throw new Error('Stripe client not initialized');
+  }
   return stripe;
 }
 
@@ -33,7 +36,7 @@ const environment = STRIPE_WEBHOOK_ENVIRONMENT ?? null;
 
 export const upsertCustomer = async ({ userId, name, email }): Promise<string> => {
   try {
-    const { data } = await stripe.customers.search({ query: `metadata["userId"]:"${userId}"` });
+    const { data } = await getStripe().customers.search({ query: `metadata["userId"]:"${userId}"` });
     const existingCustomer = data[0];
 
     if (
@@ -41,7 +44,7 @@ export const upsertCustomer = async ({ userId, name, email }): Promise<string> =
       existingCustomer.email !== email ||
       existingCustomer.metadata.environment !== environment
     ) {
-      const updatedCustomer = await stripe.customers.update(existingCustomer.id, {
+      const updatedCustomer = await getStripe().customers.update(existingCustomer.id, {
         metadata: {
           userId,
           environment,
@@ -54,7 +57,7 @@ export const upsertCustomer = async ({ userId, name, email }): Promise<string> =
 
     return existingCustomer.id;
   } catch {
-    const customer = await stripe.customers.create({
+    const customer = await getStripe().customers.create({
       metadata: {
         userId,
         environment: STRIPE_WEBHOOK_ENVIRONMENT ?? null,
@@ -83,9 +86,10 @@ export const createRegistrationIntent = async (
   options: Record<string, any> = {},
 ) => {
   const customer = options?.customer || (await upsertCustomer({ userId, name, email }));
-  const description = `${descriptorPrefix || EMAIL_WEBSITE_NAME || 'Unchained'}`.trim();
+  const description =
+    `${options?.description || descriptorPrefix || EMAIL_WEBSITE_NAME || 'Unchained'}`.trim();
 
-  const setupIntent = await stripe.setupIntents.create({
+  const setupIntent = await getStripe().setupIntents.create({
     description,
     customer,
     metadata: {
@@ -119,12 +123,13 @@ export const createOrderPaymentIntent = async (
   },
   options: Record<string, any> = {},
 ) => {
-  const description = `${descriptorPrefix || EMAIL_WEBSITE_NAME || 'Unchained'}`.trim();
+  const description =
+    `${options?.description || descriptorPrefix || EMAIL_WEBSITE_NAME || 'Unchained'}`.trim();
   const customer = options?.customer || (await upsertCustomer({ userId, name, email }));
 
   const { currencyCode, amount } = pricing.total({ useNetPrice: false });
 
-  const paymentIntent = await stripe.paymentIntents.create({
+  const paymentIntent = await getStripe().paymentIntents.create({
     amount: Math.round(amount),
     currency: currencyCode.toLowerCase(),
     description,

package/src/pricing/delivery-swiss-tax.ts

@@ -7,7 +7,7 @@ import {
 
 import { Order } from '@unchainedshop/core-orders';
 import { DeliveryProvider } from '@unchainedshop/core-delivery';
-import { SwissTaxCategories } from './tax/ch.js';
+import { isDeliveryAddressInSwitzerland, SwissTaxCategories } from './tax/ch.js';
 
 const getTaxRate = ({ order, provider }: { order?: Order; provider?: DeliveryProvider }) => {
   const taxCategoryFromProvider = provider?.configuration?.find(({ key }) => {
@@ -15,26 +15,12 @@ const getTaxRate = ({ order, provider }: { order?: Order; provider?: DeliveryPro
     return null;
   })?.value;
 
-  const taxCategory = SwissTaxCategories[taxCategoryFromProvider] || SwissTaxCategories.DEFAULT;
+  const taxCategory = taxCategoryFromProvider
+    ? SwissTaxCategories[taxCategoryFromProvider] || SwissTaxCategories.DEFAULT
+    : SwissTaxCategories.DEFAULT;
   return taxCategory.rate(order?.ordered);
 };
 
-const isDeliveryAddressInSwitzerland = ({
-  orderDelivery,
-  order,
-  countryCode: forceCountryCode = null,
-}) => {
-  let countryCode = forceCountryCode?.toUpperCase().trim() || order.countryCode;
-
-  const address = orderDelivery?.context?.address || order?.billingAddress;
-
-  if (address?.countryCode > '') {
-    countryCode = address.countryCode?.toUpperCase().trim();
-  }
-
-  return countryCode === 'CH' || countryCode === 'LI';
-};
-
 export const DeliverySwissTax: IDeliveryPricingAdapter = {
   ...DeliveryPricingAdapter,
 
@@ -44,7 +30,13 @@ export const DeliverySwissTax: IDeliveryPricingAdapter = {
   orderIndex: 80,
 
   isActivatedFor: (context) => {
-    return isDeliveryAddressInSwitzerland(context);
+    if (!context.order) return false;
+    if (!context.orderDelivery) return false;
+    return isDeliveryAddressInSwitzerland({
+      order: context.order,
+      orderDelivery: context.orderDelivery,
+      countryCode: context.countryCode,
+    });
   },
 
   actions: (params) => {

package/src/pricing/order-discount.ts

@@ -31,6 +31,8 @@ export const OrderDiscount: IOrderPricingAdapter<OrderDiscountConfiguration> = {
       ...pricingAdapter,
 
       calculate: async () => {
+        if (!order) return pricingAdapter.calculate();
+
         const totalAmountOfItems = params.calculationSheet.total({
           category: OrderPricingRowCategory.Items,
           useNetPrice: false,
@@ -57,7 +59,7 @@ export const OrderDiscount: IOrderPricingAdapter<OrderDiscountConfiguration> = {
 
         const deliveryShare = resolveRatioAndTaxDivisorForPricingSheet(
           DeliveryPricingSheet({
-            calculation: orderDelivery.calculation || [],
+            calculation: orderDelivery?.calculation || [],
             currencyCode: order.currencyCode,
           }),
           totalAmountOfPaymentAndDelivery,
@@ -65,7 +67,7 @@ export const OrderDiscount: IOrderPricingAdapter<OrderDiscountConfiguration> = {
 
         const paymentShare = resolveRatioAndTaxDivisorForPricingSheet(
           PaymentPricingSheet({
-            calculation: orderPayment.calculation || [],
+            calculation: orderPayment?.calculation || [],
             currencyCode: order.currencyCode,
           }),
           totalAmountOfPaymentAndDelivery,
@@ -86,8 +88,8 @@ export const OrderDiscount: IOrderPricingAdapter<OrderDiscountConfiguration> = {
           // If it's a fixed rate we need to deduct the already deducted amount from the fixed rate
           // before we hand it over to the split calculation
           const fixedRate =
-            configuration.fixedRate > 0
-              ? Math.max(0, configuration.fixedRate - itemsDiscountAmount)
+            Number(configuration.fixedRate) > 0
+              ? Math.max(0, configuration.fixedRate! - itemsDiscountAmount)
               : undefined;
           const leftInFeesToSplit = calcUtils.calculateAmountToSplit(
             { ...configuration, fixedRate },

package/src/pricing/order-round.ts

@@ -54,6 +54,8 @@ export const OrderPriceRound: IOrderPricingAdapter & {
       calculate: async () => {
         const { currencyCode } = params.context;
 
+        if (!currencyCode) return pricingAdapter.calculate();
+
         const { amount: deliveryAmount } = params.calculationSheet.total({
           category: OrderPricingRowCategory.Delivery,
           useNetPrice: true,
@@ -73,13 +75,12 @@ export const OrderPriceRound: IOrderPricingAdapter & {
           useNetPrice: true,
         });
         if (discountAmount) {
-          pricingAdapter.resultSheet().addDiscount({
+          pricingAdapter.resultSheet().calculation.push({
+            category: OrderPricingRowCategory.Discounts,
             amount: calculateDifference(discountAmount, currencyCode),
-            taxAmount: 0,
             meta: {
               adapter: OrderPriceRound.key,
             },
-            discountId: null,
           });
         }
 
@@ -126,7 +127,7 @@ export const OrderPriceRound: IOrderPricingAdapter & {
           // WORKAROUND BECAUSE ORDER TOTAL GROSS PRICE IS CALCULATED WITH A SUM OF EVERYTHING EXCEPT TAXES
           // AS OF UNCHAINED <= 2.6
           pricingAdapter.resultSheet().calculation.push({
-            category: null,
+            category: null as any as string,
             amount: taxDifference,
             meta: {
               adapter: OrderPriceRound.key,

package/src/pricing/product-catalog-price.ts

@@ -34,8 +34,8 @@ export const ProductPrice: IProductPricingAdapter = {
           const itemTotal = price.amount * quantity;
           pricingAdapter.resultSheet().addItem({
             amount: itemTotal,
-            isTaxable: price.isTaxable,
-            isNetPrice: price.isNetPrice,
+            isTaxable: Boolean(price.isTaxable),
+            isNetPrice: Boolean(price.isNetPrice),
             meta: { adapter: ProductPrice.key },
           });
         } else if (product.type === ProductTypes.BundleProduct) {
@@ -53,8 +53,8 @@ export const ProductPrice: IProductPricingAdapter = {
                 const bundleItemTotal = bundleItemPrice.amount * bundleItem.quantity * quantity;
                 pricingAdapter.resultSheet().addItem({
                   amount: bundleItemTotal,
-                  isTaxable: bundleItemPrice.isTaxable,
-                  isNetPrice: bundleItemPrice.isNetPrice,
+                  isTaxable: Boolean(bundleItemPrice.isTaxable),
+                  isNetPrice: Boolean(bundleItemPrice.isNetPrice),
                   meta: { adapter: ProductPrice.key },
                 });
               }

package/src/pricing/product-price-rateconversion.ts

@@ -54,13 +54,13 @@ export const ProductPriceRateConversion: IProductPricingAdapter = {
 
         const rateData = await modules.products.prices.rates.getRate(fromCurrencyObj, targetCurrencyObj);
 
-        if (rateData?.rate > 0) {
+        if (rateData && rateData.rate > 0) {
           const convertedAmount = Math.round(productPrice.amount * rateData.rate);
           pricingAdapter.resultSheet().resetCalculation(params.calculationSheet);
           pricingAdapter.resultSheet().addItem({
             amount: convertedAmount * quantity,
-            isTaxable: productPrice?.isTaxable,
-            isNetPrice: productPrice?.isNetPrice,
+            isTaxable: Boolean(productPrice?.isTaxable),
+            isNetPrice: Boolean(productPrice?.isNetPrice),
             meta: { adapter: ProductPriceRateConversion.key, rate: rateData.rate },
           });
         }

package/src/pricing/product-swiss-tax.test.ts

@@ -1,7 +1,7 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert';
 
-import { getTaxRate, isDeliveryAddressInSwitzerland } from './product-swiss-tax.js';
+import { getTaxRate } from './product-swiss-tax.js';
 
 describe('ProductSwissTax', () => {
   describe('getTaxRate', () => {
@@ -51,89 +51,4 @@ describe('ProductSwissTax', () => {
       );
     });
   });
-
-  describe('isDeliveryAddressInSwitzerland', () => {
-    const context = {
-      modules: {
-        orders: {
-          deliveries: {
-            findDelivery: async ({ orderDeliveryId }) => {
-              if (orderDeliveryId === 'CH' || orderDeliveryId === 'LI')
-                return { context: { address: { countryCode: 'CH' } } };
-              if (orderDeliveryId === null) return { context: { address: null } };
-              return { context: { address: { countryCode: 'RT' } } };
-            },
-          },
-        },
-      },
-      order: {
-        deliveryId: 'CH',
-        billingAddress: { countryCode: 'LI' },
-      },
-      countryCode: 'CH',
-    };
-    it('Should return true when passed country code CH', async () => {
-      assert.strictEqual(
-        await isDeliveryAddressInSwitzerland({ ...context, countryCode: 'ch', order: null } as any),
-        true,
-      );
-    });
-
-    it('Should return true when passed country code LI', async () => {
-      assert.strictEqual(
-        await isDeliveryAddressInSwitzerland({ ...context, countryCode: 'LI', order: null } as any),
-        true,
-      );
-    });
-
-    it('Should return false when country is neither CH nor LI and order is null', async () => {
-      assert.strictEqual(
-        await isDeliveryAddressInSwitzerland({ ...context, countryCode: 'ET', order: null } as any),
-        false,
-      );
-    });
-
-    it('Order should take precedence over country parameter', async () => {
-      // not CH or LI order so returns false
-      assert.strictEqual(
-        await isDeliveryAddressInSwitzerland({
-          ...context,
-          countryCode: 'CH',
-          order: {
-            deliveryId: 'ET',
-            billingAddress: { countryCode: 'ET' },
-          },
-        } as any),
-        false,
-      );
-    });
-
-    it('If order is not from CH and LI but billingAddress is, it should take precedence over country ', async () => {
-      assert.strictEqual(
-        await isDeliveryAddressInSwitzerland({
-          ...context,
-          countryCode: 'IT',
-          order: {
-            deliveryId: null,
-            billingAddress: { countryCode: 'CH' },
-          },
-        } as any),
-        true,
-      );
-    });
-
-    it('Should return false if billingAddress is neither CH or LI and order does not have address', async () => {
-      assert.strictEqual(
-        await isDeliveryAddressInSwitzerland({
-          ...context,
-          country: null,
-          order: {
-            deliveryId: null,
-            billingAddress: { countryCode: 'HH' },
-          },
-        } as any),
-        false,
-      );
-    });
-  });
 });

package/src/pricing/product-swiss-tax.ts

@@ -4,9 +4,8 @@ import {
   ProductPricingAdapterContext,
   IProductPricingAdapter,
   ProductPricingRowCategory,
-  UnchainedCore,
 } from '@unchainedshop/core';
-import { SwissTaxCategories } from './tax/ch.js';
+import { isDeliveryAddressInSwitzerland, SwissTaxCategories } from './tax/ch.js';
 
 export const getTaxRate = (context: ProductPricingAdapterContext) => {
   const { product, order } = context;
@@ -22,27 +21,6 @@ export const getTaxRate = (context: ProductPricingAdapterContext) => {
   return taxCategory.rate(order?.ordered);
 };
 
-export const isDeliveryAddressInSwitzerland = async ({
-  order,
-  countryCode: forceCountryCode,
-  modules,
-}: ProductPricingAdapterContext & { modules: UnchainedCore['modules'] }) => {
-  let countryCode = forceCountryCode?.toUpperCase().trim() || order.countryCode;
-
-  if (order) {
-    const orderDelivery = await modules.orders.deliveries.findDelivery({
-      orderDeliveryId: order.deliveryId,
-    });
-    const address = orderDelivery?.context?.address || order.billingAddress;
-
-    if (address?.countryCode > '') {
-      countryCode = address.countryCode?.toUpperCase().trim();
-    }
-  }
-
-  return countryCode === 'CH' || countryCode === 'LI';
-};
-
 export const ProductSwissTax: IProductPricingAdapter = {
   ...ProductPricingAdapter,
 
@@ -63,7 +41,16 @@ export const ProductSwissTax: IProductPricingAdapter = {
       ...pricingAdapter,
 
       calculate: async () => {
-        if (!(await isDeliveryAddressInSwitzerland(context))) {
+        if (
+          !isDeliveryAddressInSwitzerland({
+            ...context,
+            orderDelivery: context.order?.deliveryId
+              ? await context.modules.orders.deliveries.findDelivery({
+                  orderDeliveryId: context.order?.deliveryId,
+                })
+              : null,
+          })
+        ) {
           return pricingAdapter.calculate();
         }
         const taxRate = getTaxRate(context);

package/src/pricing/tax/ch.test.ts

@@ -1,6 +1,6 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert';
-import { SwissTaxCategories } from './ch';
+import { SwissTaxCategories, isDeliveryAddressInSwitzerland } from './ch';
 
 describe('SwissTaxCategories', () => {
   it('DEFAULT rate', () => {
@@ -18,3 +18,88 @@ describe('SwissTaxCategories', () => {
     assert.strictEqual(SwissTaxCategories.SPECIAL.rate(new Date(2024, 1, 1)), 0.038);
   });
 });
+
+describe('isDeliveryAddressInSwitzerland', () => {
+  const context = {
+    modules: {
+      orders: {
+        deliveries: {
+          findDelivery: async ({ orderDeliveryId }: any) => {
+            if (orderDeliveryId === 'CH' || orderDeliveryId === 'LI')
+              return { context: { address: { countryCode: 'CH' } } };
+            if (orderDeliveryId === null) return { context: { address: null } };
+            return { context: { address: { countryCode: 'RT' } } };
+          },
+        },
+      },
+    },
+    order: {
+      deliveryId: 'CH',
+      billingAddress: { countryCode: 'LI' },
+    },
+    countryCode: 'CH',
+  };
+  it('Should return true when passed country code CH', async () => {
+    assert.strictEqual(
+      await isDeliveryAddressInSwitzerland({ ...context, countryCode: 'ch', order: null } as any),
+      true,
+    );
+  });
+
+  it('Should return true when passed country code LI', async () => {
+    assert.strictEqual(
+      await isDeliveryAddressInSwitzerland({ ...context, countryCode: 'LI', order: null } as any),
+      true,
+    );
+  });
+
+  it('Should return false when country is neither CH nor LI and order is null', async () => {
+    assert.strictEqual(
+      await isDeliveryAddressInSwitzerland({ ...context, countryCode: 'ET', order: null } as any),
+      false,
+    );
+  });
+
+  it('Order should take precedence over country parameter', async () => {
+    // not CH or LI order so returns false
+    assert.strictEqual(
+      await isDeliveryAddressInSwitzerland({
+        ...context,
+        countryCode: 'CH',
+        order: {
+          deliveryId: 'ET',
+          billingAddress: { countryCode: 'ET' },
+        },
+      } as any),
+      false,
+    );
+  });
+
+  it('If order is not from CH and LI but billingAddress is, it should take precedence over country ', async () => {
+    assert.strictEqual(
+      await isDeliveryAddressInSwitzerland({
+        ...context,
+        countryCode: 'IT',
+        order: {
+          deliveryId: null,
+          billingAddress: { countryCode: 'CH' },
+        },
+      } as any),
+      true,
+    );
+  });
+
+  it('Should return false if billingAddress is neither CH or LI and order does not have address', async () => {
+    assert.strictEqual(
+      await isDeliveryAddressInSwitzerland({
+        ...context,
+        country: null,
+        order: {
+          deliveryId: null,
+          billingAddress: { countryCode: 'HH' },
+        },
+      } as any),
+      false,
+    );
+  });
+});