@darkpos/pricing 1.0.41 → 1.0.44

package/__TEST__/modifier/hasMatchTags.test.js

@@ -8,49 +8,71 @@ describe('Has Match Tags Function', () => {
     const customer = {};
     const modifier = {};
     expect(pricingService.modifier.hasMatchTags(customer)).toBe(true);
-    expect(pricingService.modifier.hasMatchTags(undefined, modifier)).toBe(true);
+    expect(pricingService.modifier.hasMatchTags(undefined, modifier)).toBe(
+      true
+    );
     customer.tags = [];
     modifier.tags = [];
     expect(pricingService.modifier.hasMatchTags(customer)).toBe(true);
-    expect(pricingService.modifier.hasMatchTags(undefined, modifier)).toBe(true);
+    expect(pricingService.modifier.hasMatchTags(undefined, modifier)).toBe(
+      true
+    );
     customer.tags = ['all'];
     modifier.tags = ['all'];
     expect(pricingService.modifier.hasMatchTags(customer)).toBe(true);
-    expect(pricingService.modifier.hasMatchTags(undefined, modifier)).toBe(true);
+    expect(pricingService.modifier.hasMatchTags(undefined, modifier)).toBe(
+      true
+    );
     customer.tags = ['All'];
     modifier.tags = ['All'];
     expect(pricingService.modifier.hasMatchTags(customer)).toBe(true);
-    expect(pricingService.modifier.hasMatchTags(undefined, modifier)).toBe(true);
+    expect(pricingService.modifier.hasMatchTags(undefined, modifier)).toBe(
+      true
+    );
     customer.tags = ['test'];
     modifier.tags = ['test'];
     expect(pricingService.modifier.hasMatchTags(customer)).toBe(false);
-    expect(pricingService.modifier.hasMatchTags(undefined, modifier)).toBe(false);
+    expect(pricingService.modifier.hasMatchTags(undefined, modifier)).toBe(
+      false
+    );
     customer.tags = ['test'];
     modifier.tags = ['all'];
-    expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(false);
+    expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(
+      false
+    );
     customer.tags = ['all'];
     modifier.tags = ['test'];
-    expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(false);
+    expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(
+      false
+    );
     customer.tags = ['all'];
     modifier.tags = ['all'];
     expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(true);
     customer.tags = ['test'];
     modifier.tags = ['test2'];
-    expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(false);
+    expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(
+      false
+    );
     customer.tags = ['test'];
     modifier.tags = ['test'];
     expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(true);
     customer.tags = ['test11', 'test12', 'test13', 'test14'];
     modifier.tags = ['test'];
-    expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(false);
+    expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(
+      false
+    );
     customer.tags = ['test11', 'test12', 'test13', 'test14'];
     modifier.tags = ['test21', 'test22', 'test23', 'test24'];
-    expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(false);
+    expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(
+      false
+    );
     customer.tags = ['test11', 'test12', 'test13', 'test14', 'match'];
     modifier.tags = ['test21', 'test22', 'test23', 'test24', 'match'];
     expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(true);
     customer.tags = ['test11', 'test12', 'test13', 'test14', 'Match'];
     modifier.tags = ['test21', 'test22', 'test23', 'test24', 'match'];
-    expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(false);
+    expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(
+      false
+    );
   });
 });

package/__TEST__/modifier/isOptionsOverride.test.js

@@ -0,0 +1,46 @@
+const isOptionsOverrideFunction = require('../../lib/modifier/isOptionsOverride');
+
+describe('isOptionsOverride Function', () => {
+  const isOptionsOverride = isOptionsOverrideFunction();
+
+  test('should return false when no modifier is provided', () => {
+    const result = isOptionsOverride(null);
+    expect(result).toBe(false);
+  });
+
+  test('should return false when modifier does not have properties', () => {
+    const modifier = { someKey: 'someValue' };
+    const result = isOptionsOverride(modifier);
+    expect(result).toBe(false);
+  });
+
+  test('should return false when modifier properties do not have override', () => {
+    const modifier = { properties: {} };
+    const result = isOptionsOverride(modifier);
+    expect(result).toBe(false);
+  });
+
+  test('should return false when override has no options', () => {
+    const modifier = {
+      properties: {
+        override: {
+          options: [],
+        },
+      },
+    };
+    const result = isOptionsOverride(modifier);
+    expect(result).toBe(false);
+  });
+
+  test('should return true when override has options', () => {
+    const modifier = {
+      properties: {
+        override: {
+          options: ['option1', 'option2'],
+        },
+      },
+    };
+    const result = isOptionsOverride(modifier);
+    expect(result).toBe(true);
+  });
+});

package/__TEST__/modifier/sort.test.js

@@ -35,7 +35,7 @@ describe('Sort Function', () => {
       },
     ];
     const sortedModifiers = pricingService.modifier.sort(modifiers);
-    const ids = sortedModifiers.map((mob) => mob._id);
+    const ids = sortedModifiers.map(mob => mob._id);
     expect(ids).toMatchObject([1, 3, 2]);
   });
 });

package/__TEST__/order/conditionsNotMet.test.js

@@ -0,0 +1,133 @@
+const usePricing = require('../../index');
+
+const pricingService = usePricing();
+
+describe('Conditions not met for the item', () => {
+  test('#1: Item pieces condition is not met, errors bag populated', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const item = { pieces: 1, itemId: '123', price: 100, modifiers: [] };
+    order.items.push(item);
+    const modifier = {
+      conditions: {
+        rules: [
+          {
+            key: 'itemPieces',
+            value: 5,
+            operand: '$gt',
+          },
+        ],
+      },
+    };
+    const conditionsBag = [];
+    const { addItemModifier } = pricingService.order;
+    addItemModifier({
+      order,
+      modifier,
+      itemIndex: 0,
+      onConditionsNotMet: bag => {
+        bag.forEach(condition => {
+          conditionsBag.push(condition);
+        });
+      },
+    });
+    expect(conditionsBag).toEqual([
+      {
+        current: 1,
+        name: '$gt.itemPieces',
+        value: 5,
+      },
+    ]);
+  });
+  // Write two more tests for the other conditions
+  test('#2: Item quantity condition is not met, errors bag populated', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const item = { quantity: 1, itemId: '123', price: 100, modifiers: [] };
+    order.items.push(item);
+    const modifier = {
+      conditions: {
+        rules: [
+          {
+            key: 'itemQuantity',
+            value: 5,
+            operand: '$gt',
+          },
+        ],
+      },
+    };
+    const conditionsBag = [];
+    const { addItemModifier } = pricingService.order;
+    addItemModifier({
+      order,
+      modifier,
+      itemIndex: 0,
+      onConditionsNotMet: bag => {
+        bag.forEach(condition => {
+          conditionsBag.push(condition);
+        });
+      },
+    });
+    expect(conditionsBag).toEqual([
+      {
+        current: 1,
+        name: '$gt.itemQuantity',
+        value: 5,
+      },
+    ]);
+  });
+  test('#3: Required modifiers condition is not met, errors bag populated', () => {
+    const order = {
+      id: 'ord-123',
+      items: [],
+      modifiers: [],
+    };
+    const item = {
+      quantity: 1,
+      itemId: '123',
+      price: 100,
+      modifiers: [],
+    };
+    order.items.push(item);
+    const modifier = {
+      conditions: {
+        rules: [
+          {
+            key: 'modifiers',
+            value: [{ modifierId: 'mod-1' }],
+            operand: '$in',
+          },
+        ],
+      },
+    };
+    const conditionsBag = [];
+    const { addItemModifier } = pricingService.order;
+    addItemModifier({
+      order,
+      modifier,
+      itemIndex: 0,
+      onConditionsNotMet: bag => {
+        bag.forEach(condition => {
+          conditionsBag.push(condition);
+        });
+      },
+    });
+    expect(conditionsBag).toEqual([
+      {
+        current: [],
+        name: '$in.modifiers',
+        value: [
+          {
+            modifierId: 'mod-1',
+          },
+        ],
+      },
+    ]);
+  });
+});

package/__TEST__/order/order.test.js

@@ -119,7 +119,9 @@ describe('Order actions', () => {
 
     const order = { items: [item1, item2], modifiers: [modifier1] };
 
-    const newOrder = pricingService.order.calculate(order);
+    const newOrder = pricingService.order.calculate(order, {
+      paymentMethod: 'cash',
+    });
     expect(newOrder).toHaveProperty('total', 68);
     expect(newOrder).toHaveProperty('subTotal', 70);
     expect(newOrder).toHaveProperty('subTotals', {
@@ -1603,8 +1605,8 @@ describe('Order actions', () => {
       modifiers: paymentModifiers,
       order,
     });
-
-    const newOrder = pricingService.order.calculate(order);
+    const paymentMethod = { type: 'cash' };
+    const newOrder = pricingService.order.calculate(order, { paymentMethod });
 
     expect(newOrder).toHaveProperty('total', 34.45);
     expect(newOrder).toHaveProperty('subTotal', 42.45);
@@ -1631,8 +1633,8 @@ describe('Order actions', () => {
       modifiers: paymentModifiers,
       order,
     });
-
-    const newOrder = pricingService.order.calculate(order);
+    const paymentMethod = { type: 'cash' };
+    const newOrder = pricingService.order.calculate(order, { paymentMethod });
 
     expect(newOrder).toHaveProperty('total', 36.45);
     expect(newOrder).toHaveProperty('subTotal', 42.45);

package/__TEST__/order/pickEndDate.test.js

@@ -1,6 +1,6 @@
 const moment = require('moment-timezone');
 const _ = require('lodash');
-const pickEndDateFunction = require('../../lib/order/pickEndDate');
+const pickEndDateFunction = require('../../lib/store/pickEndDate');
 
 describe('pickEndDate function', () => {
   test('Get calculated Order, one item', () => {
@@ -56,8 +56,8 @@ describe('pickEndDate function', () => {
 
     const expectedDate = now
       .clone()
-      .add(2, 'days')
-      .set({ hour: 17, minute: 0, second: 0 })
+      .add(3, 'days')
+      .set({ hour: 0, minute: 0, second: 0 })
       .utc()
       .format();
 
@@ -113,7 +113,7 @@ describe('pickEndDate function', () => {
     const expectedDate = now
       .clone()
       .add(2, 'days') // Skips the closed Wednesday, goes to Thursday
-      .set({ hour: 17, minute: 0, second: 0 })
+      .set({ hour: 0, minute: 0, second: 0 })
       .utc()
       .format();