@darkpos/pricing 1.0.31 → 1.0.33

package/__TEST__/item/addIndirectModifier.test.js

@@ -0,0 +1,192 @@
+const _ = require('lodash');
+const utils = require('@darkpos/utils');
+const addIndirectModifierFunction = require('../../lib/item/addIndirectModifier');
+
+describe('addIndirectModifier Function', () => {
+  const modifierActions = {
+    calculate: jest.fn(),
+    createIndirectModifier: jest.fn(),
+  };
+
+  const getComputeModField = jest.fn();
+  // const modifierActions = makeModifierActions(deps);
+
+  const addIndirectModifier = addIndirectModifierFunction({
+    utils,
+    modifierActions,
+    _,
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('should correctly distribute modifier across items when totals match', () => {
+    const modifier = {
+      modifier: { type: 'non-credit', action: 'add', amount: 50 },
+    };
+    const items = [
+      { _id: 'item1', total: 50, quantity: 2 },
+      { _id: 'item2', total: 50, quantity: 1 },
+    ];
+    const orderTotal = 100;
+    modifierActions.calculate.mockReturnValueOnce({
+      _computed: { amount: 100 },
+    });
+    modifierActions.createIndirectModifier
+      .mockReturnValueOnce({ compute: { amount: 25 }, properties: {} })
+      .mockReturnValueOnce({ compute: { amount: 50 }, properties: {} });
+
+    const result = addIndirectModifier({ orderTotal, items, modifier });
+
+    expect(result).toEqual({
+      item1: {
+        compute: { amount: 25 },
+        properties: {},
+      },
+      item2: {
+        compute: { amount: 50 },
+        properties: {},
+      },
+    });
+  });
+
+  test('should adjust the modifier on one item when totals do not match', () => {
+    const modifier = { modifier: { type: 'non-credit' } };
+    const items = [
+      { _id: 'item1', total: 50, quantity: 2 },
+      { _id: 'item2', total: 50, quantity: 1 },
+    ];
+    const orderTotal = 100;
+
+    modifierActions.calculate.mockReturnValueOnce({
+      _computed: { amount: 100 },
+    });
+    modifierActions.createIndirectModifier
+      .mockReturnValueOnce({ compute: { amount: 20 }, properties: {} })
+      .mockReturnValueOnce({ compute: { amount: 50 }, properties: {} });
+
+    const result = addIndirectModifier({ orderTotal, items, modifier });
+
+    expect(result).toEqual({
+      item1: {
+        compute: { amount: 50 }, // Adjusted amount to fix the total distribution difference
+        properties: { ignoreQuantity: true },
+      },
+      item2: { compute: { amount: 50 }, properties: {} },
+    });
+  });
+
+  test('should not adjust the modifier if compute type is percentage and modifier is not credit', () => {
+    const modifier = {
+      modifier: { type: 'non-credit' },
+    };
+    const items = [
+      {
+        _id: 'item1',
+        total: 50,
+        quantity: 2,
+        compute: { type: 'percentage', amount: 10, action: '' },
+      },
+      {
+        _id: 'item2',
+        total: 50,
+        quantity: 1,
+        compute: { type: 'percentage', amount: 10, action: '' },
+      },
+    ];
+    const orderTotal = 100;
+
+    getComputeModField.mockReturnValueOnce({ type: 'percentage' });
+    modifierActions.calculate
+      .mockReturnValueOnce({
+        compute: { amount: 20 },
+        properties: {},
+        _computed: { amount: 15 },
+      })
+      .mockReturnValueOnce({
+        compute: { amount: 50 },
+        properties: {},
+        _computed: { amount: 20 },
+      });
+    modifierActions.createIndirectModifier
+      .mockReturnValueOnce({
+        compute: { amount: 20 },
+        properties: {},
+        _computed: { amount: 15 },
+      })
+      .mockReturnValueOnce({
+        compute: { amount: 50 },
+        properties: {},
+        _computed: { amount: 20 },
+      });
+
+    const result = addIndirectModifier({ orderTotal, items, modifier });
+
+    expect(result).toEqual({
+      item1: {
+        compute: { amount: -35 },
+        properties: {
+          ignoreQuantity: true,
+        },
+        _computed: { amount: 15 },
+      },
+      item2: {
+        compute: { amount: 50 },
+        properties: {},
+        _computed: { amount: 20 },
+      },
+    });
+  });
+
+  test('should return itemsModifiers as is if totalDistributed equals orderModifierTotal', () => {
+    const modifier = { modifier: { type: 'non-credit' } };
+    const items = [
+      { _id: 'item1', total: 50, quantity: 2 },
+      { _id: 'item2', total: 50, quantity: 1 },
+    ];
+    const orderTotal = 100;
+    modifierActions.calculate.mockReturnValueOnce({
+      _computed: { amount: 100 },
+    });
+
+    modifierActions.createIndirectModifier
+      .mockReturnValueOnce({ compute: { amount: 25 }, properties: {} })
+      .mockReturnValueOnce({ compute: { amount: 50 }, properties: {} });
+
+    const result = addIndirectModifier({ orderTotal, items, modifier });
+
+    expect(result).toEqual({
+      item1: {
+        compute: { amount: -30 },
+        properties: {
+          ignoreQuantity: true,
+        },
+      },
+      item2: { compute: { amount: 50 }, properties: {} },
+    });
+  });
+
+  test('should not modify any items if totalDistributed exceeds orderModifierTotal and no item can cover the difference', () => {
+    const modifier = { modifier: { type: 'non-credit' } };
+    const items = [
+      { _id: 'item1', total: 10, quantity: 1 },
+      { _id: 'item2', total: 10, quantity: 1 },
+    ];
+    const orderTotal = 20;
+
+    modifierActions.calculate.mockReturnValueOnce({
+      _computed: { amount: 100 },
+    });
+    modifierActions.createIndirectModifier
+      .mockReturnValueOnce({ compute: { amount: 40 }, properties: {} })
+      .mockReturnValueOnce({ compute: { amount: 40 }, properties: {} });
+
+    const result = addIndirectModifier({ orderTotal, items, modifier });
+
+    expect(result).toEqual({
+      item1: { compute: { amount: 40 }, properties: {} },
+      item2: { compute: { amount: 40 }, properties: {} },
+    });
+  });
+});

package/__TEST__/modifier/calculate.test.js

@@ -1,5 +1,6 @@
 const usePricing = require('../../index');
 
+const { getComputeModField } = require('../../lib/modifier/utils');
 const pricingService = usePricing();
 
 describe('Calculate Function', () => {
@@ -13,7 +14,10 @@ describe('Calculate Function', () => {
       name: 'someModifier',
     };
     const orderItem = { price: 30, quantity: 1 };
-    const computedModifier = pricingService.modifier.calculate(modifier, orderItem);
+    const computedModifier = pricingService.modifier.calculate(
+      modifier,
+      orderItem
+    );
     expect(computedModifier._computed).toMatchObject({
       amount: 10,
       description: 'someModifier ($10.00)',
@@ -30,7 +34,10 @@ describe('Calculate Function', () => {
       name: 'someModifier',
     };
     const orderItem = { price: 30, quantity: 1 };
-    const computedModifier = pricingService.modifier.calculate(modifier, orderItem);
+    const computedModifier = pricingService.modifier.calculate(
+      modifier,
+      orderItem
+    );
     expect(computedModifier._computed).toMatchObject({
       amount: -10,
       description: 'someModifier (-$10.00)',
@@ -47,7 +54,10 @@ describe('Calculate Function', () => {
       name: 'someModifier',
     };
     const orderItem = { price: 30, quantity: 1 };
-    const computedModifier = pricingService.modifier.calculate(modifier, orderItem);
+    const computedModifier = pricingService.modifier.calculate(
+      modifier,
+      orderItem
+    );
     expect(computedModifier._computed).toMatchObject({
       amount: -6,
       description: 'someModifier (-$6.00)',
@@ -64,10 +74,31 @@ describe('Calculate Function', () => {
       name: 'someModifier',
     };
     const orderItem = { price: 30, quantity: 1 };
-    const computedModifier = pricingService.modifier.calculate(modifier, orderItem);
+    const computedModifier = pricingService.modifier.calculate(
+      modifier,
+      orderItem
+    );
     expect(computedModifier._computed).toMatchObject({
       amount: 6,
       description: 'someModifier ($6.00)',
     });
   });
+
+  test('calculate with a null modifier', () => {
+    const modifier = {
+      compute: null,
+      name: 'someModifier',
+    };
+    const orderItem = { price: 30, quantity: 1 };
+    const computedModifier = pricingService.modifier.calculate(
+      modifier,
+      orderItem
+    );
+    const testCompute = getComputeModField(computedModifier);
+    expect(testCompute).toMatchObject({
+      type: '',
+      amount: 0,
+      action: '',
+    });
+  });
 });

package/__TEST__/modifier/createIndirectModifier.test.js

@@ -0,0 +1,166 @@
+const _ = require('lodash');
+const utils = require('@darkpos/utils');
+const createIndirectModifierFunction = require('../../lib/modifier/createIndirectModifier');
+
+describe('createIndirectModifier Function', () => {
+  test('create indirect modifier with an undefined modifier compute', () => {
+    const constants = {
+      Modifier: {
+        Compute: {
+          Types: {
+            PERCENTAGE: 'percentage',
+            FIXED: 'fixed',
+          },
+          Actions: {
+            SUBTRACT: 'subtract',
+          },
+        },
+      },
+    };
+    const actions = {
+      getProperty: (modifier, prop) => modifier[prop],
+      create: modifier => modifier,
+    };
+    // const getComputeModField = jest.fn().mockReturnValue(null);
+
+    const createIndirectModifier = createIndirectModifierFunction({
+      _,
+      utils,
+      constants,
+      actions,
+    });
+
+    const modifier = {
+      type: 'credit',
+      properties: {},
+    };
+    const options = {
+      orderTotal: 100,
+      itemQuantity: 2,
+      itemTotal: 50,
+    };
+
+    const result = createIndirectModifier(modifier, options);
+
+    expect(result).toEqual({
+      ...modifier,
+      direct: false,
+      compute: {
+        type: 'fixed',
+        amount: 0,
+        action: 'subtract',
+      },
+      properties: {
+        ignoreQuantity: false,
+      },
+    });
+  });
+  test('create indirect modifier with a null modifier compute', () => {
+    const constants = {
+      Modifier: {
+        Compute: {
+          Types: {
+            PERCENTAGE: 'percentage',
+            FIXED: 'fixed',
+          },
+          Actions: {
+            SUBTRACT: 'subtract',
+          },
+        },
+      },
+    };
+    const actions = {
+      getProperty: (modifier, prop) => modifier[prop],
+      create: modifier => modifier,
+    };
+
+    const createIndirectModifier = createIndirectModifierFunction({
+      _,
+      utils,
+      constants,
+      actions,
+    });
+
+    const modifier = {
+      type: 'credit',
+      properties: {},
+      compute: null,
+    };
+    const options = {
+      orderTotal: 100,
+      itemQuantity: 2,
+      itemTotal: 50,
+    };
+
+    const result = createIndirectModifier(modifier, options);
+
+    expect(result).toEqual({
+      ...modifier,
+      direct: false,
+      compute: {
+        type: 'fixed',
+        amount: 0,
+        action: 'subtract',
+      },
+      properties: {
+        ignoreQuantity: false,
+      },
+    });
+  });
+  test('create indirect modifier regular modifier', () => {
+    const constants = {
+      Modifier: {
+        Compute: {
+          Types: {
+            PERCENTAGE: 'percentage',
+            FIXED: 'fixed',
+          },
+          Actions: {
+            SUBTRACT: 'subtract',
+          },
+        },
+      },
+    };
+    const actions = {
+      getProperty: (modifier, prop) => modifier[prop],
+      create: modifier => modifier,
+    };
+
+    const createIndirectModifier = createIndirectModifierFunction({
+      _,
+      utils,
+      constants,
+      actions,
+    });
+
+    const modifier = {
+      type: 'credit',
+      properties: {},
+      compute: {
+        type: 'fixed',
+        action: 'add',
+        amount: 10,
+      },
+    };
+    const options = {
+      orderTotal: 100,
+      itemQuantity: 2,
+      itemTotal: 50,
+    };
+
+    const result = createIndirectModifier(modifier, options);
+
+    expect(result).toEqual({
+      ...modifier,
+      direct: false,
+      compute: {
+        type: 'fixed',
+        action: 'add',
+        amount: 2.5,
+      },
+      properties: {
+        ignoreQuantity: false,
+      },
+    });
+  });
+});

package/__TEST__/modifier/getFixedModifiersTotal.test.js

@@ -0,0 +1,52 @@
+const utils = require('@darkpos/utils');
+const getFixedModifiersTotalFunction = require('../../lib/modifier/getFixedModifiersTotal');
+
+describe('getFixedModifiersTotal Function', () => {
+  const getComputeModField = jest.fn();
+
+  const getFixedModifiersTotal = getFixedModifiersTotalFunction({
+    utils,
+  });
+
+  test('should return 0 if modifiers is not an array', () => {
+    const result = getFixedModifiersTotal(null);
+    expect(result).toBe(0);
+  });
+
+  test('should return 0 if there are no fixed modifiers', () => {
+    getComputeModField.mockReturnValueOnce({ type: 'percentage' });
+    const modifiers = [{}, {}];
+
+    const result = getFixedModifiersTotal(modifiers);
+    expect(result).toBe(0);
+  });
+
+  test('should correctly sum fixed modifiers even with a compute null', () => {
+    const modifiers = [
+      {
+        compute: { type: 'fixed', amount: 10 },
+      },
+      { compute: { type: 'fixed', amount: 20 } },
+      { compute: { type: 'fixed', amount: 30 } },
+      { compute: null },
+    ];
+
+    const result = getFixedModifiersTotal(modifiers);
+    expect(result).toBe(60);
+  });
+
+  test('should correctly handle a fixed modifier with no amount', () => {
+    const modifiers = [
+      { compute: { type: 'fixed', amount: undefined } },
+      { compute: { type: 'fixed', amount: 15 } },
+    ];
+
+    const result = getFixedModifiersTotal(modifiers);
+    expect(result).toBe(15);
+  });
+
+  test('should correctly handle an empty array of modifiers', () => {
+    const result = getFixedModifiersTotal([]);
+    expect(result).toBe(0);
+  });
+});

package/__TEST__/modifier/getSplittedModifiers.test.js

@@ -0,0 +1,134 @@
+const utils = require('@darkpos/utils');
+const getSplittedModifiersFunction = require('../../lib/modifier/getSplittedModifiers');
+
+describe('getSplittedModifiers Function', () => {
+  const getSplittedModifiers = getSplittedModifiersFunction({
+    utils,
+  });
+
+  test('should return split credit modifier with divided maxAmount', () => {
+    const modifiers = [
+      {
+        type: 'credit',
+        properties: { maxAmount: 100 },
+      },
+    ];
+    const totalOriginOrder = 200;
+    const totalSplitedOrder = 50;
+
+    const result = getSplittedModifiers(
+      modifiers,
+      totalOriginOrder,
+      totalSplitedOrder
+    );
+
+    expect(result).toEqual([
+      {
+        type: 'credit',
+        properties: { maxAmount: 25 }, // 100 * (50 / 200)
+        compute: {
+          type: '',
+          amount: 0,
+          action: '',
+        },
+      },
+    ]);
+  });
+
+  test('should return split fixed modifier with divided amount', () => {
+    const modifiers = [
+      {
+        compute: { amount: 80, type: 'fixed' },
+      },
+    ];
+    const totalOriginOrder = 160;
+    const totalSplitedOrder = 40;
+
+    const result = getSplittedModifiers(
+      modifiers,
+      totalOriginOrder,
+      totalSplitedOrder
+    );
+
+    expect(result).toEqual([
+      {
+        compute: { amount: 20, type: 'fixed' }, // 80 * (40 / 160)
+      },
+    ]);
+  });
+
+  test('should return unmodified modifier if type is not credit or fixed', () => {
+    const modifiers = [
+      {
+        type: 'non-fixed',
+        compute: { amount: 10 },
+      },
+    ];
+    const totalOriginOrder = 200;
+    const totalSplitedOrder = 50;
+
+    const result = getSplittedModifiers(
+      modifiers,
+      totalOriginOrder,
+      totalSplitedOrder
+    );
+
+    expect(result).toEqual(modifiers); // should be unchanged
+  });
+
+  test('should return 0 maxAmount if totalOriginOrder is 0 for credit modifier', () => {
+    const modifiers = [
+      {
+        type: 'credit',
+        properties: { maxAmount: 100 },
+      },
+    ];
+    const totalOriginOrder = 0;
+    const totalSplitedOrder = 50;
+
+    const result = getSplittedModifiers(
+      modifiers,
+      totalOriginOrder,
+      totalSplitedOrder
+    );
+
+    expect(result).toEqual([
+      {
+        type: 'credit',
+        properties: { maxAmount: 0 },
+        compute: {
+          action: '',
+          type: '',
+          amount: 0,
+        },
+      },
+    ]);
+  });
+
+  test('should return 0 amount if totalOriginOrder is 0 for fixed modifier', () => {
+    const modifiers = [
+      {
+        compute: { amount: 80, type: 'fixed' },
+      },
+    ];
+    const totalOriginOrder = 0;
+    const totalSplitedOrder = 40;
+
+    const result = getSplittedModifiers(
+      modifiers,
+      totalOriginOrder,
+      totalSplitedOrder
+    );
+
+    expect(result).toEqual([
+      {
+        compute: { amount: 0, type: 'fixed' }, // totalOriginOrder is 0, so amount should be 0
+      },
+    ]);
+  });
+
+  test('should handle empty modifiers array', () => {
+    const result = getSplittedModifiers([], 200, 50);
+    expect(result).toEqual([]); // empty input should return empty output
+  });
+});

package/__TEST__/modifier/isComputedOverride.test.js

@@ -0,0 +1,38 @@
+const isComputedOverrideFunction = require('../../lib/modifier/isComputedOverride');
+
+describe('isComputedOverride Function', () => {
+  const Modifier = {
+    Attributes: {
+      OVERRIDE: 'override',
+    },
+  };
+
+  const isComputedOverride = isComputedOverrideFunction({
+    constants: { Modifier },
+  });
+
+  test('should return false if modifier is null or undefined', () => {
+    expect(isComputedOverride(null)).toBe(false);
+    expect(isComputedOverride(undefined)).toBe(false);
+  });
+
+  test('should return false if modifier does not have compute property', () => {
+    const modifier = {};
+    expect(isComputedOverride(modifier)).toBe(false);
+  });
+
+  test('should return false if compute does not have action property', () => {
+    const modifier = { compute: {} };
+    expect(isComputedOverride(modifier)).toBe(false);
+  });
+
+  test('should return false if compute action is not OVERRIDE', () => {
+    const modifier = { compute: { action: 'other_action' } };
+    expect(isComputedOverride(modifier)).toBe(false);
+  });
+
+  test('should return true if compute action is OVERRIDE', () => {
+    const modifier = { compute: { action: 'override' } };
+    expect(isComputedOverride(modifier)).toBe(true);
+  });
+});