@unchainedshop/core 3.1.1 → 3.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unchainedshop/core",
-  "version": "3.1.1",
+  "version": "3.1.2",
   "main": "lib/core-index.js",
   "types": "lib/core-index.d.ts",
   "type": "module",
@@ -9,8 +9,8 @@
     "build": "tsc -b",
     "prepublishOnly": "npm run clean && npm run build",
     "watch": "tsc -w ",
-    "test": "NODE_OPTIONS=--experimental-vm-modules jest --detectOpenHandles --forceExit",
-    "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch --detectOpenHandles --forceExit"
+    "test": "tsx --test",
+    "test:watch": "tsx --test --watch"
   },
   "repository": {
     "type": "git",
@@ -54,8 +54,7 @@
   },
   "devDependencies": {
     "@types/node": "^22.13.4",
-    "jest": "^29.7.0",
-    "ts-jest": "^29.2.5",
+    "tsx": "^4.19.2",
     "typescript": "^5.7.3"
   }
 }

package/src/directors/BaseDiscountAdapter.test.ts

@@ -1,49 +1,52 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
 import { BaseDiscountAdapter } from './BaseDiscountAdapter.js';
 
 describe('BaseDiscountAdapter instantiation', () => {
   const adapter = BaseDiscountAdapter;
   const context = null as any;
   it('should initialize with default values', async () => {
-    expect(adapter.orderIndex).toEqual(0);
-    expect(adapter.log).toEqual(expect.any(Function));
-    expect(await adapter.isManualAdditionAllowed('')).toEqual(false);
-    expect(await adapter.isManualRemovalAllowed()).toEqual(false);
-    expect(await adapter.actions(context)).toEqual({
-      isValidForSystemTriggering: expect.any(Function),
-      reserve: expect.any(Function),
-      release: expect.any(Function),
-      isValidForCodeTriggering: expect.any(Function),
-      discountForPricingAdapterKey: expect.any(Function),
-    });
+    assert.equal(adapter.orderIndex, 0);
+    assert.equal(typeof adapter.log, 'function');
+    assert.equal(await adapter.isManualAdditionAllowed(''), false);
+    assert.equal(await adapter.isManualRemovalAllowed(), false);
+    assert.deepStrictEqual(Object.keys(await adapter.actions(context)), [
+      'isValidForSystemTriggering',
+      'reserve',
+      'release',
+      'isValidForCodeTriggering',
+      'discountForPricingAdapterKey',
+    ]);
   });
 
   describe('actions', () => {
     it('isValidForSystemTriggering', async () => {
       const result = await adapter.actions(context);
-      expect(await result.isValidForSystemTriggering()).toEqual(false);
+      assert.equal(await result.isValidForSystemTriggering(), false);
     });
 
     it('reserve', async () => {
       const result = await adapter.actions(context);
-      expect(await result.reserve({ code: '' })).toEqual({});
+      assert.deepEqual(await result.reserve({ code: '' }), {});
     });
 
     it('release', async () => {
       const result = await adapter.actions(context);
-      expect(await result.release()).toEqual(null);
+      assert.equal(await result.release(), null);
     });
 
     it('isValidForCodeTriggering', async () => {
       const result = await adapter.actions(context);
-      expect(await result.isValidForCodeTriggering({ code: '' })).toEqual(false);
+      assert.equal(await result.isValidForCodeTriggering({ code: '' }), false);
     });
 
     it('discountForPricingAdapterKey', async () => {
       const result = await adapter.actions(context);
       const calculationSheet = {};
-      expect(
+      assert.equal(
         await result.discountForPricingAdapterKey({ calculationSheet, pricingAdapterKey: 'key' } as any),
-      ).toEqual(null);
+        null,
+      );
     });
   });
 });

package/src/directors/BasePricingSheet.test.ts

@@ -1,4 +1,6 @@
+import { describe, it } from 'node:test';
 import { resolveRatioAndTaxDivisorForPricingSheet } from './BasePricingSheet';
+import assert from 'node:assert';
 
 describe('resolveRatioAndTaxDivisorForPricingSheet', () => {
   it('total is 0 and pricing is provided', () => {
@@ -8,7 +10,7 @@ describe('resolveRatioAndTaxDivisorForPricingSheet', () => {
       net: () => 10,
     };
     const result = resolveRatioAndTaxDivisorForPricingSheet(pricing, 0);
-    expect(result).toEqual({ ratio: 1, taxDivisor: 1 });
+    assert.deepStrictEqual(result, { ratio: 1, taxDivisor: 1 });
   });
 
   it('gross - tax is 0', () => {
@@ -18,7 +20,7 @@ describe('resolveRatioAndTaxDivisorForPricingSheet', () => {
       net: () => 0,
     };
     const result = resolveRatioAndTaxDivisorForPricingSheet(pricing, 20);
-    expect(result).toEqual({ ratio: 0, taxDivisor: 0 });
+    assert.deepStrictEqual(result, { ratio: 0, taxDivisor: 0 });
   });
 
   it('gross - tax is not 0', () => {
@@ -28,7 +30,7 @@ describe('resolveRatioAndTaxDivisorForPricingSheet', () => {
       net: () => 10,
     };
     const result = resolveRatioAndTaxDivisorForPricingSheet(pricing, 20);
-    expect(result).toEqual({ ratio: 1, taxDivisor: 2 });
+    assert.deepStrictEqual(result, { ratio: 1, taxDivisor: 2 });
   });
 
   it('taxSum is 0', () => {
@@ -38,6 +40,6 @@ describe('resolveRatioAndTaxDivisorForPricingSheet', () => {
       net: () => 20,
     };
     const result = resolveRatioAndTaxDivisorForPricingSheet(pricing, 20);
-    expect(result).toEqual({ ratio: 1, taxDivisor: 1 });
+    assert.deepStrictEqual(result, { ratio: 1, taxDivisor: 1 });
   });
 });

package/src/directors/MessagingDirector.test.ts

@@ -1,5 +1,8 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+
 describe('MessagingDirector', () => {
   it('Stub', () => {
-    expect(true).toBe(true);
+    assert(true);
   });
 });

package/src/directors/ProductPricingSheet.test.ts

@@ -1,3 +1,5 @@
+import { beforeEach, describe, it } from 'node:test';
+import assert from 'node:assert';
 import { ProductPricingSheet } from './ProductPricingSheet.js';
 
 const TAX = { category: 'TAX', amount: 50, isNetPrice: false, isTaxable: false };
@@ -40,90 +42,90 @@ describe('ProductPricingSheet', () => {
   });
 
   it('should return an object that implements the IProductPricingSheet interface', () => {
-    expect(pricingSheet).toBeDefined();
-    expect(pricingSheet.quantity).toEqual(2);
-    expect(pricingSheet.currency).toEqual('CHF');
-    expect(typeof pricingSheet.addItem).toBe('function');
-    expect(typeof pricingSheet.addDiscount).toBe('function');
-    expect(typeof pricingSheet.addTax).toBe('function');
-    expect(typeof pricingSheet.taxSum).toBe('function');
-    expect(typeof pricingSheet.unitPrice).toBe('function');
-    expect(typeof pricingSheet.discountPrices).toBe('function');
+    assert(pricingSheet);
+    assert.equal(pricingSheet.quantity, 2);
+    assert.equal(pricingSheet.currency, 'CHF');
+    assert.equal(typeof pricingSheet.addItem, 'function');
+    assert.equal(typeof pricingSheet.addDiscount, 'function');
+    assert.equal(typeof pricingSheet.addTax, 'function');
+    assert.equal(typeof pricingSheet.taxSum, 'function');
+    assert.equal(typeof pricingSheet.unitPrice, 'function');
+    assert.equal(typeof pricingSheet.discountPrices, 'function');
   });
 
   it('gross() should return the GROSS sum of all ProductPricingCalculation', () => {
-    expect(pricingSheet.gross()).toEqual(535);
+    assert.equal(pricingSheet.gross(), 535);
   });
 
   it('net() should return the NET sum of all ProductPricingCalculation (i.e before TAX)', () => {
-    expect(pricingSheet.net()).toEqual(460);
+    assert.equal(pricingSheet.net(), 460);
   });
 
   describe('total()', () => {
     it('should return sum of all ProductPricingCalculations ', () => {
-      expect(pricingSheet.total()).toEqual({ amount: 535, currency: 'CHF' });
-      expect(pricingSheet.total()).toEqual({ amount: pricingSheet.gross(), currency: 'CHF' });
+      assert.deepEqual(pricingSheet.total(), { amount: 535, currency: 'CHF' });
+      assert.deepEqual(pricingSheet.total(), { amount: pricingSheet.gross(), currency: 'CHF' });
     });
 
     it('should return sum of all ProductPricingCalculations ', () => {
-      expect(pricingSheet.total({ useNetPrice: true })).toEqual({ amount: 460, currency: 'CHF' });
-      expect(pricingSheet.total({ useNetPrice: true })).toEqual({
+      assert.deepEqual(pricingSheet.total({ useNetPrice: true }), { amount: 460, currency: 'CHF' });
+      assert.deepEqual(pricingSheet.total({ useNetPrice: true }), {
         amount: pricingSheet.net(),
         currency: 'CHF',
       });
     });
 
     it('should return sum of all ProductPricingCalculations for the provided category ', () => {
-      expect(pricingSheet.total({ category: 'ITEM' })).toEqual({ amount: 400, currency: 'CHF' });
-      expect(pricingSheet.total({ category: 'DISCOUNT' })).toEqual({ amount: 60, currency: 'CHF' });
-      expect(pricingSheet.total({ category: 'TAX' })).toEqual({ amount: 75, currency: 'CHF' });
+      assert.deepEqual(pricingSheet.total({ category: 'ITEM' }), { amount: 400, currency: 'CHF' });
+      assert.deepEqual(pricingSheet.total({ category: 'DISCOUNT' }), { amount: 60, currency: 'CHF' });
+      assert.deepEqual(pricingSheet.total({ category: 'TAX' }), { amount: 75, currency: 'CHF' });
     });
   });
 
   describe('isValid()', () => {
     it('should return true if there is at least 1 registered ProductPricingCalculation ', () => {
-      expect(pricingSheet.isValid()).toEqual(true);
+      assert.equal(pricingSheet.isValid(), true);
     });
     it('should return false if there is no registered ProductPricingCalculation ', () => {
       const sheet = ProductPricingSheet({ ...pricingSheetParams, calculation: [] });
-      expect(sheet.isValid()).toEqual(false);
+      assert.equal(sheet.isValid(), false);
     });
   });
 
   describe('getRawPricingSheet', () => {
     it('should return all registered ProductPricingCalculation', () => {
-      expect(pricingSheet.getRawPricingSheet()).toEqual(calculations);
+      assert.deepEqual(pricingSheet.getRawPricingSheet(), calculations);
     });
   });
 
   describe('taxSum', () => {
     it('should return the sum of TAX calculation registered on the adapter', () => {
-      expect(pricingSheet.taxSum()).toEqual(75);
+      assert.equal(pricingSheet.taxSum(), 75);
     });
   });
 
   describe('unitPrice', () => {
     it('should return the GROSS sum for a  product price useNetPrice:false', () => {
-      expect(pricingSheet.unitPrice({ useNetPrice: false })).toEqual({ amount: 268, currency: 'CHF' });
+      assert.deepEqual(pricingSheet.unitPrice({ useNetPrice: false }), { amount: 268, currency: 'CHF' });
     });
 
     it('should return the NET sum for a product price when useNetPrice:true', () => {
-      expect(pricingSheet.unitPrice({ useNetPrice: true })).toEqual({ amount: 230, currency: 'CHF' });
+      assert.deepEqual(pricingSheet.unitPrice({ useNetPrice: true }), { amount: 230, currency: 'CHF' });
     });
   });
 
   describe('discountPrices', () => {
     it('should return the sum of all discounts registered on the price sheet based on discountId', () => {
-      expect(pricingSheet.discountPrices('for-all')).toEqual([
+      assert.deepEqual(pricingSheet.discountPrices('for-all'), [
         { amount: 40, currency: 'CHF', discountId: 'for-all' },
       ]);
-      expect(pricingSheet.discountPrices('special')).toEqual([
+      assert.deepEqual(pricingSheet.discountPrices('special'), [
         { amount: 20, currency: 'CHF', discountId: 'special' },
       ]);
     });
 
     it('should return empty array if discount with the provided discountId is not found', () => {
-      expect(pricingSheet.discountPrices('non-existing')).toEqual([]);
+      assert.deepEqual(pricingSheet.discountPrices('non-existing'), []);
     });
   });
 });

package/src/directors/periodForReferenceDate.test.ts

@@ -1,21 +1,23 @@
+import { describe, it } from 'node:test';
 import { periodForReferenceDate } from './EnrollmentAdapter.js';
+import assert from 'node:assert';
 
 describe('periodForReferenceDate', () => {
   it('Should return 1 week interval from When passed a given date', () => {
-    expect(periodForReferenceDate(new Date('2022-12-03T17:00:00.000Z'))).toEqual({
+    assert.deepStrictEqual(periodForReferenceDate(new Date('2022-12-03T17:00:00.000Z')), {
       start: new Date('2022-12-03T17:00:00.000Z'),
       end: new Date('2022-12-10T17:00:00.000Z'),
     });
   });
   it('Should return 2 week interval from When passed 2 as interval', () => {
-    expect(periodForReferenceDate(new Date('2022-12-03T17:00:00.000Z'), 2)).toEqual({
+    assert.deepStrictEqual(periodForReferenceDate(new Date('2022-12-03T17:00:00.000Z'), 2), {
       start: new Date('2022-12-03T17:00:00.000Z'),
       end: new Date('2022-12-17T17:00:00.000Z'),
     });
   });
 
   it('Should return 2 HOURS when interval is set to HOURS', () => {
-    expect(periodForReferenceDate(new Date('2022-12-03T17:00:00.000Z'), 2, 'HOURS')).toEqual({
+    assert.deepStrictEqual(periodForReferenceDate(new Date('2022-12-03T17:00:00.000Z'), 2, 'HOURS'), {
       start: new Date('2022-12-03T17:00:00.000Z'),
       end: new Date('2022-12-03T19:00:00.000Z'),
     });

package/jest.config.js

@@ -1,17 +0,0 @@
-/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
-export default {
-  preset: 'ts-jest/presets/default-esm', // or other ESM presets
-  testEnvironment: 'node',
-  extensionsToTreatAsEsm: ['.ts'],
-  transform: {
-    '^.+\\.tsx?$': [
-      'ts-jest',
-      {
-        useESM: true,
-      },
-    ],
-  },
-  moduleNameMapper: {
-    '^(\\.{1,2}/.*)\\.js$': '$1',
-  },
-};

package/tests/core.test.ts

@@ -1,5 +0,0 @@
-describe('Bookmark', () => {
-  it('Check Bookmarks module', () => {
-    expect(true).toBeTruthy();
-  });
-});