@darkpos/pricing 1.0.78 → 1.0.80

package/__TEST__/modifier.test.js

@@ -873,4 +873,465 @@ describe('Modifier actions', () => {
       ]);
     });
   });
+
+  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: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      properties: {
+        isQuantityMultiplier: true,
+        limits: { maxItemUse: 1 },
+      },
+    };
+    order.items.push({
+      quantity: 2,
+      itemId: '123',
+      price: 100,
+      modifiers: [],
+    });
+
+    const conditionsBag = [];
+
+    const updatedOrder = pricingService.order.addItemModifier({
+      order,
+      modifier,
+      itemIndex: 0,
+      onConditionsNotMet: bag => {
+        bag.forEach(condition => {
+          conditionsBag.push(condition);
+        });
+      },
+    });
+
+    let error = '';
+    const updatedOrder2 = pricingService.order.addItemModifier({
+      order: { ...updatedOrder },
+      modifier,
+      itemIndex: 0,
+      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(updatedOrder2.items[0].modifiers.length).toBe(1);
+    expect(updatedOrder2.items[0].modifiers).toMatchObject([
+      {
+        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.maxItemUse=5 and isQuantityMultiplier=false', () => {
+    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 < 5; 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('');
+
+    expect(currentOrder.items[0].modifiers.length).toBe(5);
+  });
+
+  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: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      properties: {
+        isQuantityMultiplier: false,
+        limits: { maxItemUse: -1 },
+      },
+    };
+    order.items.push({
+      quantity: 2,
+      itemId: '123',
+      price: 100,
+      modifiers: [],
+    });
+
+    const conditionsBag = [];
+
+    let error = '';
+    let currentOrder = { ...order };
+
+    for (let i = 0; i < 5; 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('');
+
+    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.maxItemUse is not set', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const modifier = {
+      _id: 1,
+      compute: {
+        amount: 10,
+        action: 'subtract',
+        type: 'fixed',
+      },
+      properties: {
+        isQuantityMultiplier: false,
+        limits: { maxItemUse: 0 },
+      },
+    };
+    order.items.push({
+      quantity: 2,
+      itemId: '123',
+      price: 100,
+      modifiers: [],
+    });
+
+    const conditionsBag = [];
+
+    let error = '';
+    let currentOrder = { ...order };
+
+    for (let i = 0; i < 5; 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('');
+
+    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);
+  });
 });