@darkpos/pricing 1.0.79 → 1.0.81

package/__TEST__/modifier.test.js

@@ -1,6 +1,12 @@
 const usePricing = require('../index');
 
-const pricingService = usePricing();
+const mockStores = require('./mocks/stores');
+
+const session = {
+  store: mockStores[0],
+};
+
+const pricingService = usePricing(session);
 
 describe('Modifier actions', () => {
   test('CU-86dv8hzxg modifier.isGroup fn', () => {
@@ -874,7 +880,7 @@ describe('Modifier actions', () => {
     });
   });
 
-  test('CU-86dve295v Should throw error when adding a modifier more times than the ones specified in properties.limits.maxAppliesItem', () => {
+  test('CU-86dve295v Should throw error when adding a modifier more times than the ones specified in properties.limits.maxItemUse', () => {
     const order = {
       id: 'ord-123',
       items: [],
@@ -889,7 +895,7 @@ describe('Modifier actions', () => {
       },
       properties: {
         isQuantityMultiplier: true,
-        limits: { maxAppliesItem: 1 },
+        limits: { maxItemUse: 1 },
       },
     };
     order.items.push({
@@ -929,18 +935,26 @@ describe('Modifier actions', () => {
 
     expect(conditionsBag).toEqual([]);
     expect(error).toEqual('modifier.has.reached.the.maximum.amount.of.applies');
-    expect(updatedOrder2.items).toEqual([
+    expect(updatedOrder2.items[0].modifiers.length).toBe(1);
+    expect(updatedOrder2.items[0].modifiers).toMatchObject([
       {
-        itemId: '123',
-        modifiers: [],
-        price: 100,
-        properties: { basePrice: 100 },
-        quantity: 2,
+        compute: {
+          action: 'subtract',
+          amount: 10,
+          type: 'fixed',
+        },
+        modifierId: 1,
+        properties: {
+          isQuantityMultiplier: true,
+          limits: {
+            maxItemUse: 1,
+          },
+        },
       },
     ]);
   });
 
-  test('CU-86dve295v Should not throw error when adding a modifier less times than the ones specified in properties.limits.maxAppliesItem=5 and isQuantityMultiplier=false', () => {
+  test('CU-86dve295v Should not throw error when adding a modifier less times than the ones specified in properties.limits.maxItemUse=5 and isQuantityMultiplier=false', () => {
     const order = {
       id: 'ord-123',
       items: [],
@@ -955,7 +969,7 @@ describe('Modifier actions', () => {
       },
       properties: {
         isQuantityMultiplier: false,
-        limits: { maxAppliesItem: 5 },
+        limits: { maxItemUse: 5 },
       },
     };
     order.items.push({
@@ -993,7 +1007,116 @@ describe('Modifier actions', () => {
     expect(currentOrder.items[0].modifiers.length).toBe(5);
   });
 
-  test('CU-86dve295v Should not throw error when adding a modifier if  properties.limits.isUnlimitedAppliesItem=true and isQuantityMultiplier=false', () => {
+  test('CU-86dve295v Should not throw error when adding a modifier less times than the ones specified in properties.limits.maxItemUse=5 and isQuantityMultiplier=false. Considering also the quantity', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      properties: {
+        isQuantityMultiplier: false,
+        limits: { maxItemUse: 5 },
+      },
+      direct: true,
+    };
+    order.items.push({
+      quantity: 2,
+      itemId: '123',
+      price: 100,
+      modifiers: [],
+    });
+
+    const conditionsBag = [];
+
+    let error = '';
+    let currentOrder = { ...order };
+
+    for (let i = 0; i < 10; i += 1) {
+      currentOrder = pricingService.order.addItemModifier({
+        order: currentOrder,
+        modifier,
+        itemIndex: 0,
+        onConditionsNotMet: bag => {
+          bag.forEach(condition => {
+            conditionsBag.push(condition);
+          });
+        },
+        // eslint-disable-next-line no-loop-func
+        onError: errorMessage => {
+          error = errorMessage;
+        },
+      });
+    }
+
+    expect(conditionsBag).toEqual([]);
+    expect(error).toEqual('');
+
+    const calculatedOrder = pricingService.order.calculate(currentOrder);
+
+    expect(calculatedOrder.items[0].modifiers.length).toBe(10);
+  });
+
+  test('CU-86dve295v Should throw error when adding a modifier 11 times to an item with quantity=2 and modifier.properties.limits.maxItemUse=5', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      properties: {
+        isQuantityMultiplier: false,
+        limits: { maxItemUse: 5 },
+      },
+    };
+    order.items.push({
+      quantity: 2,
+      itemId: '123',
+      price: 100,
+      modifiers: [],
+    });
+
+    const conditionsBag = [];
+
+    let error = '';
+    let currentOrder = { ...order };
+
+    for (let i = 0; i < 11; i += 1) {
+      currentOrder = pricingService.order.addItemModifier({
+        order: currentOrder,
+        modifier,
+        itemIndex: 0,
+        onConditionsNotMet: bag => {
+          bag.forEach(condition => {
+            conditionsBag.push(condition);
+          });
+        },
+        // eslint-disable-next-line no-loop-func
+        onError: errorMessage => {
+          error = errorMessage;
+        },
+      });
+    }
+
+    expect(conditionsBag).toEqual([]);
+    expect(error).toEqual('modifier.has.reached.the.maximum.amount.of.applies');
+
+    expect(currentOrder.items[0].modifiers.length).toBe(10);
+  });
+
+  test('CU-86dve295v Should not throw error when adding a modifier if  properties.limits.maxItemUse=-1 and isQuantityMultiplier=false', () => {
     const order = {
       id: 'ord-123',
       items: [],
@@ -1008,7 +1131,7 @@ describe('Modifier actions', () => {
       },
       properties: {
         isQuantityMultiplier: false,
-        limits: { isUnlimitedAppliesItem: true },
+        limits: { maxItemUse: -1 },
       },
     };
     order.items.push({
@@ -1046,7 +1169,7 @@ describe('Modifier actions', () => {
     expect(currentOrder.items[0].modifiers.length).toBe(5);
   });
 
-  test('CU-86dve295v Should not add the modifiers more times than item.quantity if  modifier.properties.limits.isUnlimitedAppliesItem=false and modifier.properties.limits.maxAppliesItem is not set', () => {
+  test('CU-86dve295v Should not add the modifiers more times than item.quantity if modifier.properties.limits.maxItemUse is not set', () => {
     const order = {
       id: 'ord-123',
       items: [],
@@ -1061,7 +1184,7 @@ describe('Modifier actions', () => {
       },
       properties: {
         isQuantityMultiplier: false,
-        limits: { isUnlimitedAppliesItem: false },
+        limits: { maxItemUse: 0 },
       },
     };
     order.items.push({
@@ -1098,4 +1221,450 @@ describe('Modifier actions', () => {
 
     expect(currentOrder.items[0].modifiers.length).toBe(2);
   });
+
+  test('CU-86dve295v Should add the modifier as many times as permitted by properties.limits.maxOrderUse', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      properties: {
+        isQuantityMultiplier: false,
+        limits: { maxOrderUse: 3 },
+      },
+    };
+    order.items.push({
+      quantity: 1,
+      itemId: '111',
+      price: 100,
+      modifiers: [],
+    });
+    order.items.push({
+      quantity: 1,
+      itemId: '222',
+      price: 100,
+      modifiers: [],
+    });
+    order.items.push({
+      quantity: 1,
+      itemId: '333',
+      price: 100,
+      modifiers: [],
+    });
+
+    order.items.push({
+      quantity: 1,
+      itemId: '444',
+      price: 100,
+      modifiers: [],
+    });
+
+    const conditionsBag = [];
+
+    let error = '';
+    let currentOrder = { ...order };
+
+    currentOrder = pricingService.order.addItemModifier({
+      order: currentOrder,
+      modifier,
+      itemIndex: 0,
+      onConditionsNotMet: bag => {
+        bag.forEach(condition => {
+          conditionsBag.push(condition);
+        });
+      },
+      onError: errorMessage => {
+        error = errorMessage;
+      },
+    });
+
+    currentOrder = pricingService.order.addItemModifier({
+      order: currentOrder,
+      modifier,
+      itemIndex: 1,
+      onConditionsNotMet: bag => {
+        bag.forEach(condition => {
+          conditionsBag.push(condition);
+        });
+      },
+      onError: errorMessage => {
+        error = errorMessage;
+      },
+    });
+
+    currentOrder = pricingService.order.addItemModifier({
+      order: currentOrder,
+      modifier,
+      itemIndex: 2,
+      onConditionsNotMet: bag => {
+        bag.forEach(condition => {
+          conditionsBag.push(condition);
+        });
+      },
+      onError: errorMessage => {
+        error = errorMessage;
+      },
+    });
+
+    expect(conditionsBag).toEqual([]);
+    expect(error).toEqual('');
+    expect(currentOrder.items[0].modifiers.length).toBe(1);
+    expect(currentOrder.items[1].modifiers.length).toBe(1);
+    expect(currentOrder.items[2].modifiers.length).toBe(1);
+    expect(currentOrder.items[3].modifiers.length).toBe(0);
+
+    expect(currentOrder.items.length).toBe(4);
+
+    currentOrder = pricingService.order.addItemModifier({
+      order: currentOrder,
+      modifier,
+      itemIndex: 3,
+      onConditionsNotMet: bag => {
+        bag.forEach(condition => {
+          conditionsBag.push(condition);
+        });
+      },
+      onError: errorMessage => {
+        error = errorMessage;
+      },
+    });
+
+    expect(conditionsBag).toEqual([]);
+    expect(error).toEqual('modifier.has.reached.the.maximum.amount.of.applies');
+    expect(currentOrder.items[3].modifiers.length).toBe(0);
+  });
+  test('CU-86dve295v should split item based on modifier.maxItemQuantity', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      properties: {
+        limits: { maxItemQuantity: 1 },
+      },
+      modifierId: 'aaa',
+    };
+
+    order.items.push({
+      quantity: 10,
+      itemId: '111',
+      price: 100,
+      modifiers: [],
+    });
+
+    let currentOrder = { ...order };
+
+    currentOrder = pricingService.order.addItemModifier({
+      order: currentOrder,
+      modifier,
+      itemIndex: 0,
+    });
+
+    expect(currentOrder.items.length).toEqual(1);
+
+    currentOrder = pricingService.order.splitItems({
+      order: currentOrder,
+    });
+
+    expect(currentOrder.items.length).toEqual(10);
+  });
+
+  test('CU-86dve295v should split item based on modifier.maxItemQuantity, and spread modifiers accordingly 1', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      properties: {
+        limits: { maxItemQuantity: 1 },
+      },
+      modifierId: 'aaa',
+    };
+
+    let currentOrder = { ...order };
+
+    currentOrder = pricingService.order.addItem({
+      order,
+      item: {
+        quantity: 10,
+        itemId: '111',
+        price: 100,
+        modifiers: [],
+        subTotals: {},
+      },
+    }).updatedOrder;
+
+    currentOrder = pricingService.order.addItemModifier({
+      order: currentOrder,
+      modifier,
+      itemIndex: 0,
+    });
+
+    expect(currentOrder.items.length).toEqual(1);
+
+    currentOrder = pricingService.order.calculate(currentOrder);
+
+    currentOrder = pricingService.order.splitItems({
+      order: currentOrder,
+    });
+
+    expect(currentOrder.items.length).toEqual(10);
+    expect(currentOrder.total).toEqual(990);
+
+    expect(currentOrder.items[0].total).toEqual(99);
+    expect(currentOrder.items[0].modifiers[0]._computed.amount).toEqual(-1);
+    expect(currentOrder.items[1].total).toEqual(99);
+    expect(currentOrder.items[1].modifiers[0]._computed.amount).toEqual(-1);
+    expect(currentOrder.items[2].total).toEqual(99);
+    expect(currentOrder.items[2].modifiers[0]._computed.amount).toEqual(-1);
+    expect(currentOrder.items[3].total).toEqual(99);
+    expect(currentOrder.items[3].modifiers[0]._computed.amount).toEqual(-1);
+    expect(currentOrder.items[4].total).toEqual(99);
+    expect(currentOrder.items[4].modifiers[0]._computed.amount).toEqual(-1);
+    expect(currentOrder.items[5].total).toEqual(99);
+    expect(currentOrder.items[5].modifiers[0]._computed.amount).toEqual(-1);
+    expect(currentOrder.items[6].total).toEqual(99);
+    expect(currentOrder.items[6].modifiers[0]._computed.amount).toEqual(-1);
+    expect(currentOrder.items[7].total).toEqual(99);
+    expect(currentOrder.items[7].modifiers[0]._computed.amount).toEqual(-1);
+    expect(currentOrder.items[8].total).toEqual(99);
+    expect(currentOrder.items[8].modifiers[0]._computed.amount).toEqual(-1);
+    expect(currentOrder.items[9].total).toEqual(99);
+    expect(currentOrder.items[9].modifiers[0]._computed.amount).toEqual(-1);
+  });
+
+  test('CU-86dve295v should split item based on modifier.maxItemQuantity=2, and spread modifiers accordingly 2', () => {
+    const order = {
+      id: 'ord-456',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 2,
+      compute: {
+        amount: 5,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      properties: {
+        limits: { maxItemQuantity: 2 },
+      },
+      modifierId: 'bbb',
+    };
+
+    let currentOrder = { ...order };
+
+    currentOrder = pricingService.order.addItem({
+      order,
+      item: {
+        quantity: 8,
+        itemId: '222',
+        price: 50,
+        modifiers: [],
+        subTotals: {},
+      },
+    }).updatedOrder;
+
+    currentOrder = pricingService.order.addItemModifier({
+      order: currentOrder,
+      modifier,
+      itemIndex: 0,
+    });
+
+    currentOrder = pricingService.order.calculate(currentOrder);
+
+    expect(currentOrder.items.length).toEqual(1);
+
+    expect(currentOrder.total).toEqual(395);
+
+    currentOrder = pricingService.order.splitItems({
+      order: currentOrder,
+    });
+
+    expect(currentOrder.items.length).toEqual(4);
+    expect(currentOrder.total).toEqual(395);
+
+    currentOrder.items.forEach(item => {
+      expect(item.quantity).toEqual(2);
+      expect(item.total).toEqual(98.75);
+      expect(item.modifiers[0]._computed.amount).toEqual(-1.25);
+    });
+  });
+
+  test('CU-86dve295v should split 1 item  and left other untouched.', () => {
+    const order = {
+      id: 'ord-456',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 2,
+      compute: {
+        amount: 5,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      properties: {
+        limits: { maxItemQuantity: 2 },
+      },
+      modifierId: 'bbb',
+    };
+
+    const redModifier = {
+      _id: 3,
+      modifierId: 'red-ccc',
+      name: 'red',
+    };
+
+    let currentOrder = { ...order };
+
+    currentOrder = pricingService.order.addItem({
+      order,
+      item: {
+        quantity: 8,
+        itemId: '222',
+        price: 50,
+        modifiers: [],
+        subTotals: {},
+      },
+    }).updatedOrder;
+
+    currentOrder = pricingService.order.addItemModifier({
+      order: currentOrder,
+      modifier,
+      itemIndex: 0,
+    });
+
+    currentOrder = pricingService.order.addItemModifier({
+      order: currentOrder,
+      modifier: redModifier,
+      itemIndex: 0,
+    });
+
+    currentOrder = pricingService.order.addItem({
+      order: currentOrder,
+      item: {
+        quantity: 1,
+        itemId: '333',
+        price: 100,
+        modifiers: [],
+        subTotals: {},
+      },
+    }).updatedOrder;
+
+    currentOrder = pricingService.order.calculate(currentOrder);
+
+    expect(currentOrder.items.length).toEqual(2);
+
+    expect(currentOrder.total).toEqual(495);
+
+    currentOrder = pricingService.order.splitItems({
+      order: currentOrder,
+    });
+
+    expect(currentOrder.items.length).toEqual(5);
+    expect(currentOrder.total).toEqual(495);
+
+    expect(currentOrder.items[0].total).toEqual(100);
+    expect(currentOrder.items[0].modifiers.length).toBe(0);
+
+    expect(currentOrder.items[1].total).toEqual(98.75);
+    expect(currentOrder.items[1].modifiers[0].name).toBe('red');
+    expect(currentOrder.items[1].modifiers[1]._computed.amount).toBe(-1.25);
+
+    expect(currentOrder.items[2].total).toEqual(98.75);
+    expect(currentOrder.items[2].modifiers[0].name).toBe('red');
+    expect(currentOrder.items[2].modifiers[1]._computed.amount).toBe(-1.25);
+
+    expect(currentOrder.items[3].total).toEqual(98.75);
+    expect(currentOrder.items[3].modifiers[0].name).toBe('red');
+    expect(currentOrder.items[3].modifiers[1]._computed.amount).toBe(-1.25);
+
+    expect(currentOrder.items[4].total).toEqual(98.75);
+    expect(currentOrder.items[4].modifiers[0].name).toBe('red');
+    expect(currentOrder.items[4].modifiers[1]._computed.amount).toBe(-1.25);
+  });
+
+  test('CU-86dve295v should split item based on modifier.maxItemQuantity=4, and spread modifiers accordingly', () => {
+    const order = {
+      id: 'ord-456',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 2,
+      compute: {
+        amount: 5,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      properties: {
+        limits: { maxItemQuantity: 4 },
+      },
+      modifierId: 'bbb',
+    };
+
+    let currentOrder = { ...order };
+
+    currentOrder = pricingService.order.addItem({
+      order,
+      item: {
+        quantity: 10,
+        itemId: '222',
+        price: 50,
+        modifiers: [],
+        subTotals: {},
+      },
+    }).updatedOrder;
+
+    currentOrder = pricingService.order.addItemModifier({
+      order: currentOrder,
+      modifier,
+      itemIndex: 0,
+    });
+
+    currentOrder = pricingService.order.calculate(currentOrder);
+
+    expect(currentOrder.items.length).toEqual(1);
+
+    expect(currentOrder.total).toEqual(495);
+
+    currentOrder = pricingService.order.splitItems({
+      order: currentOrder,
+    });
+
+    expect(currentOrder.items.length).toEqual(3);
+
+    expect(currentOrder.items[0].quantity).toEqual(4);
+    expect(currentOrder.items[0].modifiers[0]._computed.amount).toEqual(-2);
+
+    expect(currentOrder.items[1].quantity).toEqual(4);
+    expect(currentOrder.items[1].modifiers[0]._computed.amount).toEqual(-2);
+
+    expect(currentOrder.items[2].quantity).toEqual(2);
+    expect(currentOrder.items[2].modifiers[0]._computed.amount).toEqual(-1);
+
+    expect(currentOrder.total).toEqual(495);
+  });
 });