@merchi/sdk 1.40.2

package/src/pricing/matrix.test.ts

@@ -0,0 +1,553 @@
+import { buildPriceMatrix } from './matrix.js';
+import { PricingField, PricingRules } from './types.js';
+
+function field(partial: Partial<PricingField> & { id: number }): PricingField {
+  return {
+    originalId: partial.id,
+    position: 0,
+    fieldType: 2,
+    independent: true,
+    isSelectable: true,
+    selectedBy: [],
+    variationCost: 0,
+    variationUnitCost: 0,
+    variationCostDiscountGroup: null,
+    variationUnitCostDiscountGroup: null,
+    options: [],
+    ...partial,
+  };
+}
+
+const base: PricingRules = {
+  currency: 'AUD',
+  taxPercent: 10,
+  product: { unitPrice: 10, minimumPrice: null, discountGroup: null },
+  fields: [],
+  groupFields: [],
+  hasGroups: false,
+};
+
+test('unsupported rules yield no matrix', () => {
+  expect(
+    buildPriceMatrix({ ...base, unsupported: 'group_buy_product' })
+  ).toBeNull();
+});
+
+test('no quantity breaks yield no matrix', () => {
+  expect(buildPriceMatrix(base, { quantity: 1, fieldValues: {} })).toBeNull();
+});
+
+test('product quantity breaks become columns', () => {
+  const rules: PricingRules = {
+    ...base,
+    product: {
+      unitPrice: 10,
+      minimumPrice: null,
+      discountGroup: {
+        groupRestricted: false,
+        discounts: [
+          { lowerLimit: 100, amount: 10 },
+          { lowerLimit: 500, amount: 20 },
+        ],
+      },
+    },
+  };
+  const matrix = buildPriceMatrix(rules);
+  expect(matrix).toMatchObject({
+    currency: 'AUD',
+    taxPercent: 10,
+    bands: [
+      { quantity: 1, upperLimit: 99, label: '1–99' },
+      { quantity: 100, upperLimit: 499, label: '100–499' },
+      { quantity: 500, upperLimit: null, label: '500+' },
+    ],
+  });
+  expect(matrix!.cells.map((c) => c.costPerUnit)).toEqual([10, 9, 8]);
+  expect(matrix!.cells[0].unitPrice).toBe(10);
+  expect(matrix!.cells[1].cost).toBe(900);
+  expect(matrix!.cells[1].taxAmount).toBe(90);
+  expect(matrix!.cells[1].totalCost).toBe(990);
+});
+
+test('minQuantity floors the first band and ignores lower breaks', () => {
+  const rules: PricingRules = {
+    ...base,
+    product: {
+      unitPrice: 10,
+      minimumPrice: null,
+      discountGroup: {
+        groupRestricted: false,
+        discounts: [
+          { lowerLimit: 25, amount: 5 },
+          { lowerLimit: 100, amount: 10 },
+        ],
+      },
+    },
+  };
+  const matrix = buildPriceMatrix(rules, { fieldValues: {} }, { minQuantity: 50 });
+  expect(matrix!.bands.map((b) => b.quantity)).toEqual([50, 100]);
+  expect(matrix!.bands[0].label).toBe('50–99');
+});
+
+test('minQuantity below 1 is treated as 1', () => {
+  const rules: PricingRules = {
+    ...base,
+    product: {
+      unitPrice: 10,
+      minimumPrice: null,
+      discountGroup: {
+        groupRestricted: false,
+        discounts: [{ lowerLimit: 10, amount: 10 }],
+      },
+    },
+  };
+  const matrix = buildPriceMatrix(rules, { fieldValues: {} }, { minQuantity: 0 });
+  expect(matrix!.bands[0].quantity).toBe(1);
+});
+
+test('invalid discount limits are ignored', () => {
+  const rules: PricingRules = {
+    ...base,
+    product: {
+      unitPrice: 10,
+      minimumPrice: null,
+      discountGroup: {
+        groupRestricted: false,
+        discounts: [
+          { lowerLimit: Number.NaN, amount: 10 },
+          { lowerLimit: 20, amount: 10 },
+        ],
+      },
+    },
+  };
+  expect(buildPriceMatrix(rules)!.bands.map((b) => b.quantity)).toEqual([1, 20]);
+});
+
+test('field and option discount groups contribute breaks', () => {
+  const rules: PricingRules = {
+    ...base,
+    fields: [
+      field({
+        id: 2,
+        fieldType: 5,
+        isSelectable: false,
+        variationUnitCost: 2,
+        variationUnitCostDiscountGroup: {
+          groupRestricted: false,
+          discounts: [{ lowerLimit: 50, amount: 50 }],
+        },
+      }),
+      field({
+        id: 1,
+        options: [
+          {
+            id: 101,
+            originalId: 101,
+            position: 0,
+            default: true,
+            variationCost: 20,
+            variationUnitCost: 0,
+            variationCostDiscountGroup: {
+              groupRestricted: false,
+              discounts: [{ lowerLimit: 80, amount: 50 }],
+            },
+            variationUnitCostDiscountGroup: null,
+            selectedBy: [],
+          },
+        ],
+      }),
+    ],
+  };
+  const matrix = buildPriceMatrix(rules, {
+    quantity: 1,
+    fieldValues: {
+      1: { selectedOptionIds: [101] },
+      2: { value: 'yes' },
+    },
+  });
+  expect(matrix!.bands.map((b) => b.quantity)).toEqual([1, 50, 80]);
+});
+
+test('area edge discount groups contribute breaks', () => {
+  const rules: PricingRules = {
+    ...base,
+    fields: [
+      field({
+        id: 14,
+        fieldType: 14,
+        isSelectable: false,
+        heightVariationCost: 2,
+        widthVariationCost: 2,
+        heightVariationUnitCost: 1,
+        widthVariationUnitCost: 1,
+        heightVariationCostDiscountGroup: {
+          groupRestricted: false,
+          discounts: [{ lowerLimit: 12, amount: 10 }],
+        },
+        heightVariationUnitCostDiscountGroup: {
+          groupRestricted: false,
+          discounts: [{ lowerLimit: 13, amount: 10 }],
+        },
+        widthVariationCostDiscountGroup: {
+          groupRestricted: false,
+          discounts: [{ lowerLimit: 14, amount: 10 }],
+        },
+        widthVariationUnitCostDiscountGroup: {
+          groupRestricted: false,
+          discounts: [{ lowerLimit: 15, amount: 10 }],
+        },
+      }),
+    ],
+  };
+  const matrix = buildPriceMatrix(rules, {
+    quantity: 1,
+    fieldValues: { 14: { value: '100,200' } },
+  });
+  expect(matrix!.bands.map((b) => b.quantity)).toEqual([1, 12, 13, 14, 15]);
+});
+
+test('unused option breaks that do not change price are collapsed', () => {
+  const rules: PricingRules = {
+    ...base,
+    fields: [
+      field({
+        id: 1,
+        options: [
+          {
+            id: 101,
+            originalId: 101,
+            position: 0,
+            default: false,
+            variationCost: 0,
+            variationUnitCost: 5,
+            variationCostDiscountGroup: null,
+            variationUnitCostDiscountGroup: {
+              groupRestricted: false,
+              discounts: [{ lowerLimit: 100, amount: 50 }],
+            },
+            selectedBy: [],
+          },
+        ],
+      }),
+    ],
+  };
+  expect(
+    buildPriceMatrix(rules, { quantity: 1, fieldValues: {} })
+  ).toBeNull();
+});
+
+test('adjacent quantities use a single-number label', () => {
+  const rules: PricingRules = {
+    ...base,
+    product: {
+      unitPrice: 10,
+      minimumPrice: null,
+      discountGroup: {
+        groupRestricted: false,
+        discounts: [{ lowerLimit: 2, amount: 10 }],
+      },
+    },
+  };
+  expect(buildPriceMatrix(rules)!.bands[0]).toMatchObject({
+    quantity: 1,
+    upperLimit: 1,
+    label: '1',
+  });
+});
+
+test('empty discount groups and missing field arrays are skipped', () => {
+  const rules: PricingRules = {
+    ...base,
+    product: {
+      unitPrice: 10,
+      minimumPrice: null,
+      discountGroup: { groupRestricted: false, discounts: [] },
+    },
+    fields: undefined as any,
+    groupFields: undefined as any,
+  };
+  expect(buildPriceMatrix(rules)).toBeNull();
+});
+
+test('null discount group on a field is skipped', () => {
+  const rules: PricingRules = {
+    ...base,
+    fields: [
+      field({
+        id: 1,
+        options: undefined as any,
+        variationCostDiscountGroup: { groupRestricted: false } as any,
+      }),
+    ],
+    product: {
+      unitPrice: 10,
+      minimumPrice: null,
+      discountGroup: {
+        groupRestricted: false,
+        discounts: [{ lowerLimit: 25, amount: 10 }],
+      },
+    },
+  };
+  expect(buildPriceMatrix(rules)!.bands.map((b) => b.quantity)).toEqual([1, 25]);
+});
+
+test('group products scale the current mix to each band', () => {
+  const rules: PricingRules = {
+    ...base,
+    hasGroups: true,
+    product: {
+      unitPrice: 10,
+      minimumPrice: null,
+      discountGroup: {
+        groupRestricted: false,
+        discounts: [{ lowerLimit: 100, amount: 10 }],
+      },
+    },
+    groupFields: [
+      field({
+        id: 4,
+        independent: false,
+        options: [
+          {
+            id: 201,
+            originalId: 201,
+            position: 0,
+            default: false,
+            variationCost: 0,
+            variationUnitCost: 1,
+            variationCostDiscountGroup: null,
+            variationUnitCostDiscountGroup: null,
+            selectedBy: [],
+          },
+        ],
+      }),
+    ],
+  };
+  const matrix = buildPriceMatrix(rules, {
+    fieldValues: {},
+    groups: [
+      { quantity: 10, fieldValues: { 4: { selectedOptionIds: [201] } } },
+      { quantity: 10, fieldValues: {} },
+    ],
+  });
+  expect(matrix!.cells[1].quantity).toBe(100);
+  expect(matrix!.cells[1].cost).toBe(950);
+});
+
+test('empty group quantities use the group that has values', () => {
+  const rules: PricingRules = {
+    ...base,
+    hasGroups: true,
+    product: {
+      unitPrice: 10,
+      minimumPrice: null,
+      discountGroup: {
+        groupRestricted: false,
+        discounts: [{ lowerLimit: 20, amount: 10 }],
+      },
+    },
+    groupFields: [
+      field({
+        id: 4,
+        independent: false,
+        options: [
+          {
+            id: 201,
+            originalId: 201,
+            position: 0,
+            default: false,
+            variationCost: 0,
+            variationUnitCost: 2,
+            variationCostDiscountGroup: null,
+            variationUnitCostDiscountGroup: null,
+            selectedBy: [],
+          },
+        ],
+      }),
+    ],
+  };
+  const matrix = buildPriceMatrix(rules, {
+    fieldValues: {},
+    groups: [
+      { quantity: 0, fieldValues: {} },
+      { quantity: 0, fieldValues: { 4: { selectedOptionIds: [201] } } },
+    ],
+  });
+  expect(matrix!.cells[0].unitPrice).toBe(12);
+});
+
+test('empty group values fall back to the first group', () => {
+  const rules: PricingRules = {
+    ...base,
+    hasGroups: true,
+    product: {
+      unitPrice: 10,
+      minimumPrice: null,
+      discountGroup: {
+        groupRestricted: false,
+        discounts: [{ lowerLimit: 20, amount: 10 }],
+      },
+    },
+  };
+  const matrix = buildPriceMatrix(rules, {
+    fieldValues: {},
+    groups: [
+      { quantity: 0, fieldValues: { 1: { selectedOptionIds: [] }, 3: undefined as any } },
+      { quantity: 0, fieldValues: { 2: { value: 0 } } },
+    ],
+  });
+  expect(matrix!.cells[0].costPerUnit).toBe(10);
+});
+
+test('single group receives the full band quantity', () => {
+  const rules: PricingRules = {
+    ...base,
+    hasGroups: true,
+    product: {
+      unitPrice: 10,
+      minimumPrice: null,
+      discountGroup: {
+        groupRestricted: false,
+        discounts: [{ lowerLimit: 10, amount: 10 }],
+      },
+    },
+  };
+  const matrix = buildPriceMatrix(rules, {
+    fieldValues: {},
+    groups: [{ quantity: 4, fieldValues: { 9: { value: 'logo' } } }],
+  });
+  expect(matrix!.cells[1].cost).toBe(90);
+});
+
+test('scaled groups never assign a negative remainder', () => {
+  const rules: PricingRules = {
+    ...base,
+    hasGroups: true,
+    product: {
+      unitPrice: 10,
+      minimumPrice: null,
+      discountGroup: {
+        groupRestricted: false,
+        discounts: [{ lowerLimit: 1, amount: 0 }, { lowerLimit: 2, amount: 10 }],
+      },
+    },
+  };
+  const matrix = buildPriceMatrix(
+    rules,
+    {
+      fieldValues: {},
+      groups: [
+        { quantity: 99, fieldValues: {} },
+        { quantity: 1, fieldValues: {} },
+      ],
+    },
+    { minQuantity: 1 }
+  );
+  expect(matrix!.cells[0].quantity).toBe(1);
+});
+
+test('missing fieldValues on selections defaults to empty', () => {
+  const rules: PricingRules = {
+    ...base,
+    product: {
+      unitPrice: 10,
+      minimumPrice: null,
+      discountGroup: {
+        groupRestricted: false,
+        discounts: [{ lowerLimit: 10, amount: 10 }],
+      },
+    },
+  };
+  expect(
+    buildPriceMatrix(rules, { groups: [{ quantity: 0, fieldValues: undefined as any }] } as any)!.cells[0].cost
+  ).toBe(10);
+  expect(
+    buildPriceMatrix(rules, {
+      groups: [
+        { quantity: 3, fieldValues: {} },
+        { quantity: 3, fieldValues: {} },
+      ],
+    } as any)!.cells[0].cost
+  ).toBe(10);
+});
+
+test('group fields with missing options still quote', () => {
+  const rules: PricingRules = {
+    ...base,
+    hasGroups: true,
+    groupFields: [field({ id: 4, independent: false, options: undefined as any })],
+    product: {
+      unitPrice: 10,
+      minimumPrice: null,
+      discountGroup: {
+        groupRestricted: false,
+        discounts: [{ lowerLimit: 10, amount: 10 }],
+      },
+    },
+  };
+  expect(
+    buildPriceMatrix(rules, {
+      fieldValues: {},
+      groups: [{ quantity: 5, fieldValues: { 4: { value: 'custom' } } }],
+    })!.cells[1].cost
+  ).toBe(90);
+});
+
+test('setup amortization keeps bands when unit price changes', () => {
+  const rules: PricingRules = {
+    ...base,
+    product: {
+      unitPrice: 10,
+      minimumPrice: null,
+      setupPrice: 50,
+      discountGroup: {
+        groupRestricted: false,
+        discounts: [{ lowerLimit: 100, amount: 0 }],
+      },
+    },
+  };
+  const matrix = buildPriceMatrix(rules);
+  expect(matrix!.cells.map((c) => c.quantity)).toEqual([1, 100]);
+  expect(matrix!.cells[0].costPerUnit).toBe(10);
+  expect(matrix!.cells[1].costPerUnit).toBe(10);
+});
+
+test('empty groups array quotes as a non-group job', () => {
+  const rules: PricingRules = {
+    ...base,
+    product: {
+      unitPrice: 10,
+      minimumPrice: null,
+      discountGroup: {
+        groupRestricted: false,
+        discounts: [{ lowerLimit: 10, amount: 10 }],
+      },
+    },
+  };
+  expect(
+    buildPriceMatrix(rules, { groups: [] } as any)!.cells[1].cost
+  ).toBe(90);
+});
+
+test('non-numeric group quantity is treated as zero', () => {
+  const rules: PricingRules = {
+    ...base,
+    hasGroups: true,
+    product: {
+      unitPrice: 10,
+      minimumPrice: null,
+      discountGroup: {
+        groupRestricted: false,
+        discounts: [{ lowerLimit: 10, amount: 10 }],
+      },
+    },
+  };
+  const matrix = buildPriceMatrix(rules, {
+    fieldValues: {},
+    groups: [
+      { quantity: 'nope' as any, fieldValues: { 1: { value: null } } },
+      { quantity: undefined as any, fieldValues: { 2: { value: '' } } },
+    ],
+  });
+  expect(matrix!.cells[0].costPerUnit).toBe(10);
+});