@darkpos/pricing 1.0.6 → 1.0.7

package/__TEST__/modifier/calculate.test.js

@@ -0,0 +1,73 @@
+const usePricing = require('../../index');
+
+const pricingService = usePricing();
+
+describe('Calculate Function', () => {
+  test('calculate with fix amount and add action', () => {
+    const modifier = {
+      compute: {
+        type: 'fixed',
+        action: 'add',
+        amount: 10,
+      },
+      name: 'someModifier',
+    };
+    const orderItem = { price: 30, quantity: 1 };
+    const computedModifier = pricingService.modifier.calculate(modifier, orderItem);
+    expect(computedModifier._computed).toMatchObject({
+      amount: 10,
+      description: 'someModifier ($10.00)',
+    });
+  });
+
+  test('calculate with fix amount and subtract action', () => {
+    const modifier = {
+      compute: {
+        type: 'fixed',
+        action: 'subtract',
+        amount: 10,
+      },
+      name: 'someModifier',
+    };
+    const orderItem = { price: 30, quantity: 1 };
+    const computedModifier = pricingService.modifier.calculate(modifier, orderItem);
+    expect(computedModifier._computed).toMatchObject({
+      amount: -10,
+      description: 'someModifier (-$10.00)',
+    });
+  });
+
+  test('calculate with percentage amount and subtract action', () => {
+    const modifier = {
+      compute: {
+        amount: 20,
+        type: 'percentage',
+        action: 'subtract',
+      },
+      name: 'someModifier',
+    };
+    const orderItem = { price: 30, quantity: 1 };
+    const computedModifier = pricingService.modifier.calculate(modifier, orderItem);
+    expect(computedModifier._computed).toMatchObject({
+      amount: -6,
+      description: 'someModifier (-$6.00)',
+    });
+  });
+
+  test('calculate with percentage amount and add action', () => {
+    const modifier = {
+      compute: {
+        amount: 20,
+        type: 'percentage',
+        action: 'add',
+      },
+      name: 'someModifier',
+    };
+    const orderItem = { price: 30, quantity: 1 };
+    const computedModifier = pricingService.modifier.calculate(modifier, orderItem);
+    expect(computedModifier._computed).toMatchObject({
+      amount: 6,
+      description: 'someModifier ($6.00)',
+    });
+  });
+});

package/__TEST__/modifier/getAvailablePromotionsOrSubscriptions.test.js

@@ -0,0 +1,81 @@
+const usePricing = require('../../index');
+
+const pricingService = usePricing();
+
+describe('GetAvailablePromotionsOrSubscriptions Function', () => {
+  test('usecases', () => {
+    const today = new Date();
+    expect(
+      pricingService.modifier.getAvailablePromotionsOrSubscriptions()
+    ).toStrictEqual([]);
+
+    const modifier = { attributes: ['promotion'] };
+    expect(
+      pricingService.modifier.getAvailablePromotionsOrSubscriptions([modifier])
+    ).toStrictEqual([modifier]);
+
+    modifier.properties = {
+      promotion: { numberOfUsesLimit: 4, numberOfUses: 3 },
+    };
+    expect(
+      pricingService.modifier.getAvailablePromotionsOrSubscriptions([modifier])
+    ).toStrictEqual([modifier]);
+
+    modifier.properties.promotion.numberOfUses = 4;
+    expect(
+      pricingService.modifier.getAvailablePromotionsOrSubscriptions([modifier])
+    ).toStrictEqual([]);
+
+    modifier.properties.promotion.numberOfUses = 5;
+    expect(
+      pricingService.modifier.getAvailablePromotionsOrSubscriptions([modifier])
+    ).toStrictEqual([]);
+
+    modifier.properties = {
+      promotion: { dateLimit: { from: today.toISOString(), to: '' } },
+    };
+    expect(
+      pricingService.modifier.getAvailablePromotionsOrSubscriptions([modifier])
+    ).toStrictEqual([modifier]);
+
+    const tomorrow = new Date(today);
+    tomorrow.setDate(tomorrow.getDate() + 1);
+    modifier.properties.promotion.dateLimit.from = tomorrow.toISOString();
+    expect(
+      pricingService.modifier.getAvailablePromotionsOrSubscriptions([modifier])
+    ).toStrictEqual([]);
+
+    const yesterday = new Date(today);
+    yesterday.setDate(yesterday.getDate() - 1);
+    modifier.properties.promotion.dateLimit.from = yesterday.toISOString();
+    expect(
+      pricingService.modifier.getAvailablePromotionsOrSubscriptions([modifier])
+    ).toStrictEqual([modifier]);
+
+    modifier.properties.promotion.dateLimit.to = yesterday.toISOString();
+    expect(
+      pricingService.modifier.getAvailablePromotionsOrSubscriptions([modifier])
+    ).toStrictEqual([]);
+
+    modifier.properties.promotion.dateLimit.to = today.toISOString();
+    expect(
+      pricingService.modifier.getAvailablePromotionsOrSubscriptions([modifier])
+    ).toStrictEqual([modifier]);
+
+    modifier.properties.promotion.dateLimit.to = tomorrow.toISOString();
+    expect(
+      pricingService.modifier.getAvailablePromotionsOrSubscriptions([modifier])
+    ).toStrictEqual([modifier]);
+
+    modifier.attributes = ['subscription'];
+    modifier.properties.subscription = modifier.properties.promotion;
+    expect(
+      pricingService.modifier.getAvailablePromotionsOrSubscriptions([modifier])
+    ).toStrictEqual([modifier]);
+
+    delete modifier.properties;
+    expect(
+      pricingService.modifier.getAvailablePromotionsOrSubscriptions([modifier])
+    ).toStrictEqual([]);
+  });
+});

package/__TEST__/modifier/getMatchTagsModifiers.test.js

@@ -0,0 +1,109 @@
+const usePricing = require('../../index');
+
+const pricingService = usePricing();
+
+describe('GetMatchTagsModifiers Function', () => {
+  test('usecases', () => {
+    expect(
+      pricingService.modifier.getMatchTagsModifiers({ modifiers: [] })
+    ).toHaveLength(0);
+    const customer = {};
+    let modifiers = [];
+    expect(
+      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+    ).toHaveLength(0);
+    customer.tags = [];
+    modifiers = [{ tags: [] }];
+    expect(
+      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+    ).toHaveLength(1);
+    customer.tags = ['all'];
+    expect(
+      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+    ).toHaveLength(1);
+    modifiers = [{ tags: ['test'] }];
+    expect(
+      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+    ).toHaveLength(0);
+    modifiers = [{ tags: ['all'] }, { tags: ['test'] }];
+    expect(
+      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+    ).toHaveLength(1);
+    modifiers = [{ tags: ['all'] }, { tags: ['test'] }, { tags: [] }];
+    expect(
+      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+    ).toHaveLength(2);
+    customer.tags = ['test'];
+    modifiers = [{ tags: [] }];
+    expect(
+      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+    ).toHaveLength(0);
+    modifiers = [{ tags: ['test'] }];
+    expect(
+      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+    ).toHaveLength(1);
+    modifiers = [{ tags: ['all'] }, { tags: ['test'] }];
+    expect(
+      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+    ).toHaveLength(1);
+    modifiers = [{ tags: ['all'] }, { tags: ['test'] }, { tags: [] }];
+    expect(
+      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+    ).toHaveLength(1);
+    modifiers = [
+      { tags: ['all'] },
+      { tags: ['test'] },
+      { tags: [] },
+      { tags: ['Test'] },
+    ];
+    expect(
+      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+    ).toHaveLength(1);
+    modifiers = [
+      { tags: ['all'] },
+      { tags: ['test'] },
+      { tags: [] },
+      { tags: ['Test'] },
+      { tags: ['test', 'Test'] },
+    ];
+    expect(
+      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+    ).toHaveLength(2);
+    modifiers = [{ tags: ['all'] }];
+    expect(
+      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+    ).toHaveLength(0);
+    modifiers = [{ tags: ['all'] }, { tags: ['test'] }];
+    expect(
+      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+    ).toHaveLength(1);
+    modifiers = [
+      { tags: ['all'] },
+      { tags: ['test'] },
+      { tags: ['test'], attributes: ['hidden'] },
+      {},
+    ];
+    expect(
+      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+    ).toHaveLength(2);
+    customer.tags = ['all'];
+    expect(
+      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+    ).toHaveLength(2);
+    modifiers = [
+      { tags: ['all'] },
+      { tags: ['test'] },
+      { tags: ['all'], attributes: ['hidden'] },
+      { tags: ['all'], attributes: ['default'] },
+      { tags: ['all'], attributes: ['required'] },
+      {},
+    ];
+    expect(
+      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+    ).toHaveLength(5);
+    customer.tags = undefined;
+    expect(
+      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+    ).toHaveLength(5);
+  });
+});

package/__TEST__/modifier/getModifierIndex.test.js

@@ -0,0 +1,40 @@
+const usePricing = require('../../index');
+
+const pricingService = usePricing();
+
+describe('GetModifierIndex Function', () => {
+  test('usecases', () => {
+    expect(
+      pricingService.modifier.getModifierIndex({
+        entity: undefined,
+        modifier: undefined,
+      })
+    ).toBe(-1);
+    const order = { modifiers: [{ modifierId: '123' }] };
+    expect(
+      pricingService.modifier.getModifierIndex({ entity: order, modifier: undefined })
+    ).toBe(-1);
+    const modifier = { _id: '123' };
+    expect(
+      pricingService.modifier.getModifierIndex({
+        entity: order,
+        modifier,
+      })
+    ).toBe(0);
+    modifier._id = '234';
+    expect(
+      pricingService.modifier.getModifierIndex({
+        entity: order,
+        modifier,
+      })
+    ).toBe(-1);
+    order.modifiers = [{ modifierId: '123' }, { modifierId: '234' }];
+    expect(pricingService.modifier.getModifierIndex({ entity: order, modifier })).toBe(
+      1
+    );
+    modifier._id = '123';
+    expect(pricingService.modifier.getModifierIndex({ entity: order, modifier })).toBe(
+      0
+    );
+  });
+});

package/__TEST__/modifier/getRecommendedModifiers.test.js

@@ -0,0 +1,17 @@
+const usePricing = require('../../index');
+
+const pricingService = usePricing();
+
+describe('GetRecommendedModifiers Function', () => {
+  test('usecases', () => {
+    const modifier = { modifier: { recommended: true } };
+    expect(pricingService.modifier.getRecommendedModifiers([modifier])).toHaveLength(1);
+
+    const modifier2 = {
+      modifier: { modifier: { _id: 1 } },
+    };
+    expect(pricingService.modifier.getRecommendedModifiers([modifier2])).toHaveLength(
+      0
+    );
+  });
+});

package/__TEST__/modifier/hasAllTags.test.js

@@ -0,0 +1,25 @@
+const usePricing = require('../../index');
+
+const pricingService = usePricing();
+
+describe('HasAllTag Function', () => {
+  test('usecases', () => {
+    expect(pricingService.modifier.hasAllTag()).toBe(false);
+    const customer = {};
+    expect(pricingService.modifier.hasAllTag(customer)).toBe(false);
+    customer.tags = [];
+    expect(pricingService.modifier.hasAllTag(customer)).toBe(false);
+    customer.tags = ['default'];
+    expect(pricingService.modifier.hasAllTag(customer)).toBe(false);
+    customer.tags = ['all'];
+    expect(pricingService.modifier.hasAllTag(customer)).toBe(true);
+    customer.tags = ['All'];
+    expect(pricingService.modifier.hasAllTag(customer)).toBe(true);
+    customer.tags = ['All', 'default'];
+    expect(pricingService.modifier.hasAllTag(customer)).toBe(true);
+    customer.tags = ['all', 'test'];
+    expect(pricingService.modifier.hasAllTag(customer)).toBe(true);
+    customer.tags = ['test'];
+    expect(pricingService.modifier.hasAllTag(customer)).toBe(false);
+  });
+});

package/__TEST__/modifier/hasAttribute.test.js

@@ -0,0 +1,47 @@
+const usePricing = require('../../index');
+
+const pricingService = usePricing();
+
+describe('Has Modifiers Function', () => {
+  test('usecases', () => {
+    expect(pricingService.modifier.hasAttribute()).toBe(false);
+    expect(pricingService.modifier.hasAttribute(undefined, 'test')).toBe(false);
+    expect(pricingService.modifier.hasAttribute({}, undefined)).toBe(false);
+    expect(pricingService.modifier.hasAttribute({ attributes: [] }, undefined)).toBe(
+      false
+    );
+    expect(
+      pricingService.modifier.hasAttribute({ attributes: [undefined] }, undefined)
+    ).toBe(false);
+    expect(
+      pricingService.modifier.hasAttribute({ attributes: ['test'] }, undefined)
+    ).toBe(false);
+    expect(
+      pricingService.modifier.hasAttribute({ attributes: ['undefined'] }, undefined)
+    ).toBe(false);
+    expect(
+      pricingService.modifier.hasAttribute(
+        { attributes: ['undefined', undefined, 'test'] },
+        undefined
+      )
+    ).toBe(false);
+    expect(
+      pricingService.modifier.hasAttribute(
+        { attributes: ['undefined', undefined, 'test'] },
+        'undefined'
+      )
+    ).toBe(true);
+    expect(
+      pricingService.modifier.hasAttribute(
+        { attributes: ['undefined', undefined, 'test'] },
+        'test'
+      )
+    ).toBe(true);
+    expect(
+      pricingService.modifier.hasAttribute(
+        { attributes: ['undefined', undefined, 'test', 'test', 'test'] },
+        'test'
+      )
+    ).toBe(true);
+  });
+});

package/__TEST__/modifier/hasMatchTags.test.js

@@ -0,0 +1,56 @@
+const usePricing = require('../../index');
+
+const pricingService = usePricing();
+
+describe('Has Match Tags Function', () => {
+  test('usecases', () => {
+    expect(pricingService.modifier.hasMatchTags()).toBe(true);
+    const customer = {};
+    const modifier = {};
+    expect(pricingService.modifier.hasMatchTags(customer)).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);
+    customer.tags = ['all'];
+    modifier.tags = ['all'];
+    expect(pricingService.modifier.hasMatchTags(customer)).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);
+    customer.tags = ['test'];
+    modifier.tags = ['test'];
+    expect(pricingService.modifier.hasMatchTags(customer)).toBe(false);
+    expect(pricingService.modifier.hasMatchTags(undefined, modifier)).toBe(false);
+    customer.tags = ['test'];
+    modifier.tags = ['all'];
+    expect(pricingService.modifier.hasMatchTags(customer, modifier)).toBe(false);
+    customer.tags = ['all'];
+    modifier.tags = ['test'];
+    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);
+    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);
+    customer.tags = ['test11', 'test12', 'test13', 'test14'];
+    modifier.tags = ['test21', 'test22', 'test23', 'test24'];
+    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);
+  });
+});

package/__TEST__/modifier/hasNoTags.test.js

@@ -0,0 +1,21 @@
+const usePricing = require('../../index');
+
+const pricingService = usePricing();
+
+describe('Has No Tags Function', () => {
+  test('usecases', () => {
+    expect(pricingService.modifier.hasNoTags()).toBe(true);
+    const customer = {};
+    expect(pricingService.modifier.hasNoTags(customer)).toBe(true);
+    customer.tags = [];
+    expect(pricingService.modifier.hasNoTags(customer)).toBe(true);
+    customer.tags = ['test'];
+    expect(pricingService.modifier.hasNoTags(customer)).toBe(false);
+    customer.tags = ['default'];
+    expect(pricingService.modifier.hasNoTags(customer)).toBe(false);
+    customer.tags = ['all'];
+    expect(pricingService.modifier.hasNoTags(customer)).toBe(false);
+    customer.tags = ['All'];
+    expect(pricingService.modifier.hasNoTags(customer)).toBe(false);
+  });
+});