@unchainedshop/plugins 4.0.0-rc.2 → 4.0.0-rc.21

package/src/worker/bulkgate.ts

@@ -0,0 +1,138 @@
+import { IWorkerAdapter, WorkerAdapter, WorkerDirector } from '@unchainedshop/core';
+
+const { BULKGATE_APPLICATION_ID, BULKGATE_APPLICATION_TOKEN } = process.env;
+
+// BulkGate Simple API for SMS (transactional by default, promotional via boolean)
+const BulkGateWorker: IWorkerAdapter<
+  {
+    from?: string;
+    to?: string;
+    text?: string;
+    unicode?: boolean;
+    country?: string;
+    schedule?: string | number; // ISO 8601 format or Unix timestamp
+    promotional?: boolean; // Set to true for promotional SMS, defaults to transactional
+    [key: string]: any;
+  },
+  any
+> = {
+  ...WorkerAdapter,
+
+  key: 'shop.unchained.worker-plugin.bulkgate',
+  label: 'Send SMS through BulkGate',
+  version: '1.0.0',
+
+  type: 'BULKGATE',
+
+  doWork: async ({
+    from,
+    to,
+    text,
+    unicode = false,
+    country,
+    schedule,
+    promotional = false,
+    ...params
+  }) => {
+    try {
+      // Choose API endpoint based on promotional flag
+      const url = promotional
+        ? 'https://portal.bulkgate.com/api/1.0/simple/promotional'
+        : 'https://portal.bulkgate.com/api/1.0/simple/transactional';
+
+      // Prepare the request body
+      const requestBody = {
+        application_id: BULKGATE_APPLICATION_ID,
+        application_token: BULKGATE_APPLICATION_TOKEN,
+        number: to, // Phone number in international format (or semicolon-separated for promotional)
+        text: text || '',
+        unicode: unicode, // Boolean value for unicode support
+        sender_id: from ? 'gText' : 'gSystem', // Use text sender if 'from' is provided
+        sender_id_value: from || '', // Custom sender name if using gText
+        ...(country && { country }), // Optional country code
+        ...(schedule && { schedule }), // Optional scheduled time
+        ...params, // Any additional parameters
+      };
+
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Cache-Control': 'no-cache',
+        },
+        body: JSON.stringify(requestBody),
+      });
+
+      const responseData = await response.json();
+
+      // Check if we have an error response
+      if (responseData.error || responseData.type) {
+        return {
+          success: false,
+          error: {
+            name: 'BULKGATE_ERROR',
+            message:
+              responseData.error ||
+              `Failed to send ${promotional ? 'promotional' : 'transactional'} SMS`,
+            type: responseData.type || null,
+            code: responseData.code || response.status,
+            detail: responseData.detail || null,
+          },
+        };
+      }
+
+      // Success response (transactional has specific structure, promotional might vary)
+      if (responseData.data) {
+        // For transactional SMS, check for specific accepted status
+        if (!promotional && responseData.data.status === 'accepted') {
+          return {
+            success: true,
+            result: {
+              sms_id: responseData.data.sms_id,
+              price: responseData.data.price,
+              credit: responseData.data.credit,
+              number: responseData.data.number,
+              status: responseData.data.status,
+            },
+            error: null,
+          };
+        }
+
+        // For promotional SMS or other successful responses
+        if (promotional || responseData.data.status) {
+          return {
+            success: true,
+            result: responseData.data,
+            error: null,
+          };
+        }
+      }
+
+      // Unexpected response format
+      return {
+        success: false,
+        error: {
+          name: 'BULKGATE_ERROR',
+          message: 'Unexpected response format from BulkGate API',
+          response: responseData,
+        },
+      };
+    } catch (err) {
+      return {
+        success: false,
+        error: {
+          name: err.name,
+          message: err.message,
+          stack: err.stack,
+        },
+      };
+    }
+  },
+};
+
+// Register the plugin
+WorkerDirector.registerAdapter(BulkGateWorker);
+
+// Environment variables needed:
+// BULKGATE_APPLICATION_ID=your_application_id
+// BULKGATE_APPLICATION_TOKEN=your_application_token

package/src/worker/email.ts

@@ -1,5 +1,9 @@
 import { WorkerDirector, WorkerAdapter, IWorkerAdapter } from '@unchainedshop/core';
 import nodemailer from 'nodemailer';
+import { spawn } from 'node:child_process';
+import { writeFile, mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 
 export const checkEmailInterceptionEnabled = () => {
   return process.env.NODE_ENV !== 'production' && !process.env.UNCHAINED_DISABLE_EMAIL_INTERCEPTION;
@@ -18,10 +22,16 @@ const buildLink = async ({ filename, content, href, contentType, encoding, path
   return '';
 };
 
-const openInBrowser = async (options) => {
-  // eslint-disable-next-line
-  // @ts-ignore
-  const { default: open, apps } = await import('open');
+const openInBrowser = async (options): Promise<boolean> => {
+  const command = {
+    darwin: 'open',
+    win32: 'explorer.exe',
+    linux: 'xdg-open',
+  }[process.platform];
+
+  if (!command) {
+    return false;
+  }
 
   const messageBody = options.html || options.text.replace(/(\r\n|\n|\r)/gm, '<br/>');
   const attachmentLinks = await Promise.all((options.attachments || []).map(buildLink));
@@ -46,11 +56,23 @@ const openInBrowser = async (options) => {
   </body>
 </html>`;
 
-  const base64 = Buffer.from(content).toString('base64');
-  const dataUri = `data:text/html;base64,${base64}`;
+  // Create a temporary directory and file
+  const tempDir = await mkdtemp(join(tmpdir(), 'unchained-email-'));
+  const tempFile = join(tempDir, 'email-preview.html');
+
+  await writeFile(tempFile, content, 'utf8');
+
+  return new Promise((resolve) => {
+    const child = spawn(command, [tempFile], {
+      detached: true,
+      stdio: 'ignore',
+    });
+
+    child.unref();
 
-  await open(dataUri, { app: [{ name: apps.chrome }, { name: apps.firefox }, { name: apps.browser }] });
-  return true;
+    // Resolve immediately after spawning since process is detached
+    resolve(true);
+  });
 };
 
 const EmailWorkerPlugin: IWorkerAdapter<

package/src/worker/enrollment-order-generator.ts

@@ -1,73 +1,7 @@
-import { Enrollment } from '@unchainedshop/core-enrollments';
-import { OrderPosition } from '@unchainedshop/core-orders';
 import { enrollmentsSettings, EnrollmentStatus } from '@unchainedshop/core-enrollments';
-import {
-  EnrollmentDirector,
-  UnchainedCore,
-  WorkerDirector,
-  WorkerAdapter,
-  IWorkerAdapter,
-} from '@unchainedshop/core';
+import { EnrollmentDirector, WorkerDirector, WorkerAdapter, IWorkerAdapter } from '@unchainedshop/core';
 
-const generateOrder = async (
-  enrollment: Enrollment,
-  params: {
-    orderPositions: OrderPosition[];
-  } & Record<string, any>,
-  unchainedAPI: Pick<UnchainedCore, 'modules' | 'services'>,
-) => {
-  if (!enrollment.payment || !enrollment.delivery) return null;
-
-  const { modules, services } = unchainedAPI;
-  const { orderPositions, ...configuration } = params;
-  let order = await modules.orders.create({
-    userId: enrollment.userId,
-    currencyCode: enrollment.currencyCode,
-    countryCode: enrollment.countryCode,
-    contact: enrollment.contact,
-    billingAddress: enrollment.billingAddress,
-    originEnrollmentId: enrollment._id,
-    ...configuration,
-  });
-  const orderId = order._id;
-
-  if (orderPositions) {
-    await Promise.all(
-      orderPositions.map((orderPosition) => modules.orders.positions.addProductItem(orderPosition)),
-    );
-  } else {
-    const product = await modules.products.findProduct({
-      productId: enrollment.productId,
-    });
-    await modules.orders.positions.addProductItem({
-      quantity: 1,
-      productId: product._id,
-      originalProductId: product._id,
-      orderId: order._id,
-    });
-  }
-
-  const { paymentProviderId, context: paymentContext } = enrollment.payment;
-  if (paymentProviderId) {
-    await modules.orders.setPaymentProvider(orderId, paymentProviderId);
-  }
-
-  const { deliveryProviderId, context: deliveryContext } = enrollment.delivery;
-  if (deliveryProviderId) {
-    await modules.orders.setDeliveryProvider(orderId, deliveryProviderId);
-  }
-
-  await services.orders.updateCalculation(orderId);
-
-  order = await services.orders.checkoutOrder(order._id, {
-    paymentContext,
-    deliveryContext,
-  });
-
-  return order;
-};
-
-const GenerateOrderWorker: IWorkerAdapter<any, any> = {
+const GenerateOrderWorker: IWorkerAdapter<never, any> = {
   ...WorkerAdapter,
 
   key: 'shop.unchained.worker-plugin.generate-enrollment-orders',
@@ -76,7 +10,7 @@ const GenerateOrderWorker: IWorkerAdapter<any, any> = {
   type: 'ENROLLMENT_ORDER_GENERATOR',
 
   doWork: async (input, unchainedAPI) => {
-    const { modules } = unchainedAPI;
+    const { modules, services } = unchainedAPI;
 
     const enrollments = await modules.enrollments.findEnrollments({
       status: [EnrollmentStatus.ACTIVE, EnrollmentStatus.PAUSED],
@@ -86,7 +20,13 @@ const GenerateOrderWorker: IWorkerAdapter<any, any> = {
       await Promise.all(
         enrollments.map(async (enrollment) => {
           try {
-            const director = await EnrollmentDirector.actions({ enrollment }, unchainedAPI);
+            const product = await unchainedAPI.modules.products.findProduct({
+              productId: enrollment.productId,
+            });
+            const director = await EnrollmentDirector.actions(
+              { enrollment, product: product! },
+              unchainedAPI,
+            );
             const period = await director.nextPeriod();
             if (period) {
               if (period.isTrial) {
@@ -96,11 +36,13 @@ const GenerateOrderWorker: IWorkerAdapter<any, any> = {
                 return null;
               }
               const configuration = await director.configurationForOrder({
-                ...input,
                 period,
               });
               if (configuration) {
-                const order = await generateOrder(enrollment, configuration, unchainedAPI);
+                const order = await services.enrollments.generateOrderFromEnrollment(
+                  enrollment,
+                  configuration,
+                );
                 if (order) {
                   await modules.enrollments.addEnrollmentPeriod(enrollment._id, {
                     ...period,

package/src/worker/error-notifications.ts

@@ -1,4 +1,4 @@
-import { WorkStatus } from '@unchainedshop/core-worker';
+import { Work, WorkStatus } from '@unchainedshop/core-worker';
 import { IWorkerAdapter, WorkerDirector, WorkerAdapter } from '@unchainedshop/core';
 import later from '@breejs/later';
 
@@ -22,7 +22,7 @@ export const ErrorNotifications: IWorkerAdapter<Arg, Result> = {
   type: 'ERROR_NOTIFICATIONS',
 
   doWork: async (args, context, workId) => {
-    const work = await context.modules.worker.findWork({ workId });
+    const work = (await context.modules.worker.findWork({ workId })) as Work;
     const secondsPassed = args?.secondsPassed || 60;
     const to = new Date();
     const from = new Date(new Date(work.scheduled).getTime() - secondsPassed * 1000);

package/src/worker/export-token.ts

@@ -21,7 +21,6 @@ export const configureExportToken = (unchainedAPI: UnchainedCore) => {
     if (work.type === 'EXPORT_TOKEN' && work.success) {
       await unchainedAPI.modules.warehousing.updateTokenOwnership({
         tokenId: work.input.token._id,
-        userId: null,
         walletAddress: work.input.recipientWalletAddress,
       });
     }

package/src/worker/heartbeat.ts

@@ -1,12 +1,5 @@
 import { IWorkerAdapter, WorkerAdapter, WorkerDirector } from '@unchainedshop/core';
-
-const wait = async (time: number) => {
-  return new Promise((resolve) => {
-    setTimeout(() => {
-      resolve(true);
-    }, time);
-  });
-};
+import { setTimeout } from 'node:timers/promises';
 
 interface Arg {
   wait?: number;
@@ -26,7 +19,7 @@ const Heartbeat: IWorkerAdapter<Arg, Result> = {
 
   doWork: async (input: Arg): Promise<{ success: boolean; result: Result }> => {
     if (input?.wait) {
-      await wait(input.wait);
+      await setTimeout(input.wait);
     }
     if (input?.fails) {
       return {

package/src/worker/message.ts

@@ -2,7 +2,7 @@ import { MessagingDirector, IWorkerAdapter, WorkerAdapter, WorkerDirector } from
 import { Work } from '@unchainedshop/core-worker';
 
 export const MessageWorker: IWorkerAdapter<
-  { template: string; _id?: string; [x: string]: any },
+  { template: string; _id: string; [x: string]: any },
   { info?: string; forked?: Work[] }
 > = {
   ...WorkerAdapter,
@@ -16,6 +16,8 @@ export const MessageWorker: IWorkerAdapter<
     try {
       const templateResolver = MessagingDirector.getTemplate(template);
 
+      if (!templateResolver) throw new Error(`No template resolver found for template ${template}`);
+
       const workConfigurations = await templateResolver(
         {
           template,
@@ -31,13 +33,13 @@ export const MessageWorker: IWorkerAdapter<
               ...workConfiguration,
               originalWorkId: workId,
             });
-            delete work.input;
+            delete (work as any).input; // Remove input from returned work for privacy
             return work;
           }),
         );
         return { success: true, result: { forked } };
       }
-      return { success: true, result: { info: 'Skipped Message' } };
+      return { success: true, result: { forked: [] } };
     } catch (err) {
       return {
         success: false,

package/src/worker/{sms.ts → twilio.ts}

@@ -5,41 +5,29 @@ const { TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, TWILIO_SMS_FROM } = process.env;
 const SmsWorkerPlugin: IWorkerAdapter<
   {
     from?: string;
-    to?: string;
-    text?: string;
+    to: string;
+    text: string;
+    [key: string]: any; // Allow additional parameters
   },
   any
 > = {
   ...WorkerAdapter,
 
-  key: 'shop.unchained.worker-plugin.sms',
-  label: 'Send a SMS through Twilio',
+  key: 'shop.unchained.worker-plugin.twilio',
+  label: 'Send Messages through Twilio',
   version: '1.0.0',
 
-  type: 'SMS',
+  type: 'TWILIO',
 
-  doWork: async ({ from, to, text }) => {
-    if (!TWILIO_SMS_FROM && !from) {
-      return {
-        success: false,
-        error: {
-          name: 'SENDER_REQUIRED',
-          message: 'SMS requires a from, TWILIO_SMS_FROM not set',
-        },
-      };
-    }
+  doWork: async ({ from, to, text, ...params }) => {
+    try {
+      if (!TWILIO_SMS_FROM && !from)
+        throw new Error(
+          'Missing Twilio "from" number. Set TWILIO_SMS_FROM env var or provide "from" in input',
+        );
 
-    if (!to) {
-      return {
-        success: false,
-        error: {
-          name: 'RECIPIENT_REQUIRED',
-          message: 'SMS requires a to',
-        },
-      };
-    }
+      if (!to) throw new Error('Missing "to" in input');
 
-    try {
       const url = `https://api.twilio.com/2010-04-01/Accounts/${TWILIO_ACCOUNT_SID}/Messages.json`;
       const response = await fetch(url, {
         method: 'POST',
@@ -49,8 +37,9 @@ const SmsWorkerPlugin: IWorkerAdapter<
         },
         body: new URLSearchParams({
           Body: text || '',
-          From: from || TWILIO_SMS_FROM,
+          From: from || TWILIO_SMS_FROM!,
           To: to,
+          ...params, // Include any additional parameters passed
         }),
       });
 

package/lib/payment/cryptopay/de.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=de.d.ts.map

package/lib/payment/cryptopay/de.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"de.d.ts","sourceRoot":"","sources":["../../../src/payment/cryptopay/de.ts"],"names":[],"mappings":""}

package/lib/payment/cryptopay/de.js

@@ -1,10 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert';
-import deriveBtcAddress from './derive-btc-address.js';
-describe('BTC Address Derivation', () => {
-    it('returns a deterministic BIP44 child address', () => {
-        assert.equal(deriveBtcAddress('zpub6qpRm6gMdkrXvVKw7qgayHnqJGJkpE4rnYQdyJfZW87ed4Fk6HjVaThN12hv2rrL3EzfvvBW6ZpbMEe5UxZYEjhgeMigyvAbS5LiXPkKrys', 1), 'bc1qspcam3ntdpvhgz4vnxfdhas6qr8hf8tjfaz5p4');
-        assert.equal(deriveBtcAddress('zpub6qpRm6gMdkrXvVKw7qgayHnqJGJkpE4rnYQdyJfZW87ed4Fk6HjVaThN12hv2rrL3EzfvvBW6ZpbMEe5UxZYEjhgeMigyvAbS5LiXPkKrys', 2), 'bc1qd0a7znq3pz3sc4armthddkyam57ey7qjc4v6vn');
-    });
-});
-//# sourceMappingURL=de.js.map

package/lib/payment/cryptopay/de.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"de.js","sourceRoot":"","sources":["../../../src/payment/cryptopay/de.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,MAAM,MAAM,aAAa,CAAC;AACjC,OAAO,gBAAgB,MAAM,yBAAyB,CAAC;AAEvD,QAAQ,CAAC,wBAAwB,EAAE,GAAG,EAAE;IACtC,EAAE,CAAC,6CAA6C,EAAE,GAAG,EAAE;QACrD,MAAM,CAAC,KAAK,CACV,gBAAgB,CACd,iHAAiH,EACjH,CAAC,CACF,EACD,4CAA4C,CAC7C,CAAC;QACF,MAAM,CAAC,KAAK,CACV,gBAAgB,CACd,iHAAiH,EACjH,CAAC,CACF,EACD,4CAA4C,CAC7C,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/lib/payment/cryptopay/derive-btc-address.test copy.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=derive-btc-address.test%20copy.d.ts.map

package/lib/payment/cryptopay/derive-btc-address.test copy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"derive-btc-address.test copy.d.ts","sourceRoot":"","sources":["../../../src/payment/cryptopay/derive-btc-address.test copy.ts"],"names":[],"mappings":""}

package/lib/payment/cryptopay/derive-btc-address.test copy.js

@@ -1,10 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert';
-import deriveBtcAddress from './derive-btc-address.js';
-describe('BTC Address Derivation', () => {
-    it('returns a deterministic BIP44 child address', () => {
-        assert.equal(deriveBtcAddress('zpub6qpRm6gMdkrXvVKw7qgayHnqJGJkpE4rnYQdyJfZW87ed4Fk6HjVaThN12hv2rrL3EzfvvBW6ZpbMEe5UxZYEjhgeMigyvAbS5LiXPkKrys', 1), 'bc1qspcam3ntdpvhgz4vnxfdhas6qr8hf8tjfaz5p4');
-        assert.equal(deriveBtcAddress('zpub6qpRm6gMdkrXvVKw7qgayHnqJGJkpE4rnYQdyJfZW87ed4Fk6HjVaThN12hv2rrL3EzfvvBW6ZpbMEe5UxZYEjhgeMigyvAbS5LiXPkKrys', 2), 'bc1qd0a7znq3pz3sc4armthddkyam57ey7qjc4v6vn');
-    });
-});
-//# sourceMappingURL=derive-btc-address.test%20copy.js.map

package/lib/payment/cryptopay/derive-btc-address.test copy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"derive-btc-address.test copy.js","sourceRoot":"","sources":["../../../src/payment/cryptopay/derive-btc-address.test copy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,MAAM,MAAM,aAAa,CAAC;AACjC,OAAO,gBAAgB,MAAM,yBAAyB,CAAC;AAEvD,QAAQ,CAAC,wBAAwB,EAAE,GAAG,EAAE;IACtC,EAAE,CAAC,6CAA6C,EAAE,GAAG,EAAE;QACrD,MAAM,CAAC,KAAK,CACV,gBAAgB,CACd,iHAAiH,EACjH,CAAC,CACF,EACD,4CAA4C,CAC7C,CAAC;QACF,MAAM,CAAC,KAAK,CACV,gBAAgB,CACd,iHAAiH,EACjH,CAAC,CACF,EACD,4CAA4C,CAC7C,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

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

@@ -1,139 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert';
-
-import { getTaxRate, isDeliveryAddressInSwitzerland } from './product-swiss-tax.js';
-
-describe('ProductSwissTax', () => {
-  describe('getTaxRate', () => {
-    it('default rate', () => {
-      assert.strictEqual(
-        getTaxRate({
-          product: {} as any,
-          order: {} as any,
-        } as any),
-        0.081,
-      );
-    });
-
-    it('reduced rate', () => {
-      assert.strictEqual(
-        getTaxRate({
-          product: {
-            tags: ['swiss-tax-category:reduced'],
-          },
-          order: {},
-        } as any),
-        0.026,
-      );
-    });
-
-    it('special rate', () => {
-      assert.strictEqual(
-        getTaxRate({
-          product: {
-            tags: ['swiss-tax-category:special'],
-          },
-          order: {},
-        } as any),
-        0.038,
-      );
-    });
-
-    it('default rate', () => {
-      assert.strictEqual(
-        getTaxRate({
-          product: {
-            tags: ['swiss-tax-category:default'],
-          },
-          order: {},
-        } as any),
-        0.081,
-      );
-    });
-  });
-
-  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,
-      );
-    });
-  });
-});