@zoxllc/shopify-checkout-extensions 0.0.1

package/tests/CartQuantityQualifier.test.ts

@@ -0,0 +1,381 @@
+import { describe, it, expect } from 'vitest';
+import { DiscountCart } from '../src/common/DiscountCart';
+import { RunInput } from '../src/generated/api';
+import _ from 'lodash';
+import { NumericalComparisonType } from '../src/common/Qualifier';
+import {
+  CartQuantityBehavior,
+  CartQuantityQualifier,
+} from '../src/common/CartQuantityQualifier';
+
+describe('CartQuantityQualifier', () => {
+  it('calculates :CART and :EQUAL_TO correctly', () => {
+    qualifier = new CartQuantityQualifier(
+      CartQuantityBehavior.CART,
+      NumericalComparisonType.EQUAL_TO,
+      14
+    );
+    matchResult = qualifier.match(cart);
+    expect(matchResult).toBe(true);
+
+    qualifier = new CartQuantityQualifier(
+      CartQuantityBehavior.CART,
+      NumericalComparisonType.EQUAL_TO,
+      10
+    );
+    matchResult = qualifier.match(cart);
+    expect(matchResult).toBe(false);
+
+    qualifier = new CartQuantityQualifier(
+      CartQuantityBehavior.CART,
+      NumericalComparisonType.EQUAL_TO,
+      100
+    );
+    matchResult = qualifier.match(cart);
+    expect(matchResult).toBe(false);
+  });
+
+  it('calculates :CART and :LESS_THAN correctly', () => {
+    qualifier = new CartQuantityQualifier(
+      CartQuantityBehavior.CART,
+      NumericalComparisonType.LESS_THAN,
+      14
+    );
+    matchResult = qualifier.match(cart);
+    expect(matchResult).toBe(false);
+
+    qualifier = new CartQuantityQualifier(
+      CartQuantityBehavior.CART,
+      NumericalComparisonType.LESS_THAN,
+      13
+    );
+    matchResult = qualifier.match(cart);
+    expect(matchResult).toBe(false);
+
+    qualifier = new CartQuantityQualifier(
+      CartQuantityBehavior.CART,
+      NumericalComparisonType.LESS_THAN,
+      15
+    );
+    matchResult = qualifier.match(cart);
+    expect(matchResult).toBe(true);
+  });
+
+  it('calculates :CART and :LESS_THAN_OR_EQUAL correctly', () => {
+    qualifier = new CartQuantityQualifier(
+      CartQuantityBehavior.CART,
+      NumericalComparisonType.LESS_THAN_OR_EQUAL,
+      14
+    );
+    matchResult = qualifier.match(cart);
+    expect(matchResult).toBe(true);
+
+    qualifier = new CartQuantityQualifier(
+      CartQuantityBehavior.CART,
+      NumericalComparisonType.LESS_THAN_OR_EQUAL,
+      13
+    );
+    matchResult = qualifier.match(cart);
+    expect(matchResult).toBe(false);
+
+    qualifier = new CartQuantityQualifier(
+      CartQuantityBehavior.CART,
+      NumericalComparisonType.LESS_THAN_OR_EQUAL,
+      15
+    );
+    matchResult = qualifier.match(cart);
+    expect(matchResult).toBe(true);
+  });
+
+  it('calculates :CART and :GREATER_THAN correctly', () => {
+    qualifier = new CartQuantityQualifier(
+      CartQuantityBehavior.CART,
+      NumericalComparisonType.GREATER_THAN,
+      14
+    );
+    matchResult = qualifier.match(cart);
+    expect(matchResult).toBe(false);
+
+    qualifier = new CartQuantityQualifier(
+      CartQuantityBehavior.CART,
+      NumericalComparisonType.GREATER_THAN,
+      13
+    );
+    matchResult = qualifier.match(cart);
+    expect(matchResult).toBe(true);
+
+    qualifier = new CartQuantityQualifier(
+      CartQuantityBehavior.CART,
+      NumericalComparisonType.GREATER_THAN,
+      15
+    );
+    matchResult = qualifier.match(cart);
+    expect(matchResult).toBe(false);
+  });
+
+  it('calculates :CART and :GREATER_THAN_OR_EQUAL correctly', () => {
+    qualifier = new CartQuantityQualifier(
+      CartQuantityBehavior.CART,
+      NumericalComparisonType.GREATER_THAN_OR_EQUAL,
+      14
+    );
+    matchResult = qualifier.match(cart);
+    expect(matchResult).toBe(true);
+
+    qualifier = new CartQuantityQualifier(
+      CartQuantityBehavior.CART,
+      NumericalComparisonType.GREATER_THAN_OR_EQUAL,
+      13
+    );
+    matchResult = qualifier.match(cart);
+    expect(matchResult).toBe(true);
+
+    qualifier = new CartQuantityQualifier(
+      CartQuantityBehavior.CART,
+      NumericalComparisonType.GREATER_THAN_OR_EQUAL,
+      15
+    );
+    matchResult = qualifier.match(cart);
+    expect(matchResult).toBe(false);
+  });
+
+  it('calculates :ITEM and :EQUAL_TO correctly', () => {
+    qualifier = new CartQuantityQualifier(
+      CartQuantityBehavior.ITEM,
+      NumericalComparisonType.EQUAL_TO,
+      14
+    );
+    matchResult = qualifier.match(cart);
+    expect(matchResult).toBe(true);
+
+    qualifier = new CartQuantityQualifier(
+      CartQuantityBehavior.ITEM,
+      NumericalComparisonType.EQUAL_TO,
+      10
+    );
+    matchResult = qualifier.match(cart);
+    expect(matchResult).toBe(false);
+
+    qualifier = new CartQuantityQualifier(
+      CartQuantityBehavior.ITEM,
+      NumericalComparisonType.EQUAL_TO,
+      100
+    );
+    matchResult = qualifier.match(cart);
+    expect(matchResult).toBe(false);
+  });
+
+  it('calculates :ITEM and :LESS_THAN correctly', () => {
+    qualifier = new CartQuantityQualifier(
+      CartQuantityBehavior.ITEM,
+      NumericalComparisonType.LESS_THAN,
+      14
+    );
+    matchResult = qualifier.match(cart);
+    expect(matchResult).toBe(false);
+
+    qualifier = new CartQuantityQualifier(
+      CartQuantityBehavior.ITEM,
+      NumericalComparisonType.LESS_THAN,
+      13
+    );
+    matchResult = qualifier.match(cart);
+    expect(matchResult).toBe(false);
+
+    qualifier = new CartQuantityQualifier(
+      CartQuantityBehavior.ITEM,
+      NumericalComparisonType.LESS_THAN,
+      15
+    );
+    matchResult = qualifier.match(cart);
+    expect(matchResult).toBe(true);
+  });
+
+  it('calculates :ITEM and :LESS_THAN_OR_EQUAL correctly', () => {
+    qualifier = new CartQuantityQualifier(
+      CartQuantityBehavior.ITEM,
+      NumericalComparisonType.LESS_THAN_OR_EQUAL,
+      14
+    );
+    matchResult = qualifier.match(cart);
+    expect(matchResult).toBe(true);
+
+    qualifier = new CartQuantityQualifier(
+      CartQuantityBehavior.ITEM,
+      NumericalComparisonType.LESS_THAN_OR_EQUAL,
+      13
+    );
+    matchResult = qualifier.match(cart);
+    expect(matchResult).toBe(false);
+
+    qualifier = new CartQuantityQualifier(
+      CartQuantityBehavior.ITEM,
+      NumericalComparisonType.LESS_THAN_OR_EQUAL,
+      15
+    );
+    matchResult = qualifier.match(cart);
+    expect(matchResult).toBe(true);
+  });
+
+  it('calculates :ITEM and :GREATER_THAN correctly', () => {
+    qualifier = new CartQuantityQualifier(
+      CartQuantityBehavior.ITEM,
+      NumericalComparisonType.GREATER_THAN,
+      14
+    );
+    matchResult = qualifier.match(cart);
+    expect(matchResult).toBe(false);
+
+    qualifier = new CartQuantityQualifier(
+      CartQuantityBehavior.ITEM,
+      NumericalComparisonType.GREATER_THAN,
+      13
+    );
+    matchResult = qualifier.match(cart);
+    expect(matchResult).toBe(true);
+
+    qualifier = new CartQuantityQualifier(
+      CartQuantityBehavior.ITEM,
+      NumericalComparisonType.GREATER_THAN,
+      15
+    );
+    matchResult = qualifier.match(cart);
+    expect(matchResult).toBe(false);
+  });
+
+  it('calculates :ITEM and :GREATER_THAN_OR_EQUAL correctly', () => {
+    qualifier = new CartQuantityQualifier(
+      CartQuantityBehavior.ITEM,
+      NumericalComparisonType.GREATER_THAN_OR_EQUAL,
+      14
+    );
+    matchResult = qualifier.match(cart);
+    expect(matchResult).toBe(true);
+
+    qualifier = new CartQuantityQualifier(
+      CartQuantityBehavior.ITEM,
+      NumericalComparisonType.GREATER_THAN_OR_EQUAL,
+      13
+    );
+    matchResult = qualifier.match(cart);
+    expect(matchResult).toBe(true);
+
+    qualifier = new CartQuantityQualifier(
+      CartQuantityBehavior.ITEM,
+      NumericalComparisonType.GREATER_THAN_OR_EQUAL,
+      15
+    );
+    matchResult = qualifier.match(cart);
+    expect(matchResult).toBe(false);
+  });
+
+  const withSubscription: RunInput['cart'] = {
+    __typename: 'Cart',
+    cost: {
+      subtotalAmount: {
+        amount: '112.0',
+      },
+      totalAmount: {
+        amount: '112.0',
+      },
+    },
+    lines: [
+      {
+        cost: {
+          amountPerQuantity: {
+            amount: '8.0',
+          },
+          subtotalAmount: {
+            amount: '64.0',
+          },
+          totalAmount: {
+            amount: '64.0',
+          },
+          compareAtAmountPerQuantity: null,
+        },
+        quantity: 8,
+        merchandise: {
+          __typename: 'ProductVariant',
+          id: 'gid://shopify/ProductVariant/Single',
+          product: {
+            id: 'gid://shopify/Product/Single',
+            productType: 'Wristband - Single',
+            hasTags: [
+              {
+                tag: 'meta-exclude-gift',
+                hasTag: false,
+              },
+              {
+                tag: 'mystery-3-pack',
+                hasTag: false,
+              },
+            ],
+          },
+        },
+      },
+      {
+        cost: {
+          amountPerQuantity: {
+            amount: '8.0',
+          },
+          subtotalAmount: {
+            amount: '48.0',
+          },
+          totalAmount: {
+            amount: '48.0',
+          },
+          compareAtAmountPerQuantity: null,
+        },
+        quantity: 6,
+        merchandise: {
+          __typename: 'ProductVariant',
+          id: 'gid://shopify/ProductVariant/Strap',
+          product: {
+            id: 'gid://shopify/Product/Strap',
+            productType: 'Wristband - Strap',
+            hasTags: [
+              {
+                tag: 'meta-exclude-gift',
+                hasTag: false,
+              },
+              {
+                tag: 'mystery-3-pack',
+                hasTag: false,
+              },
+            ],
+          },
+        },
+      },
+    ],
+    buyerIdentity: {
+      customer: {
+        isActiveSubscriber: true,
+        hasTags: [
+          {
+            tag: 'Active product subscription',
+            hasTag: true,
+          },
+        ],
+      },
+    },
+  };
+
+  const withoutSubscription = _.cloneDeep(withSubscription);
+  _.merge(withoutSubscription, {
+    buyerIdentity: {
+      customer: {
+        isActiveSubscriber: false,
+        hasTags: [
+          {
+            hasTag: false,
+            tag: 'Active product subscription',
+          },
+        ],
+      },
+    },
+  } as RunInput['cart']);
+
+  const cart = new DiscountCart(withSubscription);
+  let qualifier: CartQuantityQualifier;
+  let matchResult: boolean;
+});

package/tests/CustomerSubscriberQualifier.test.ts

@@ -0,0 +1,101 @@
+import { describe, it, expect } from 'vitest';
+import { DiscountCart } from '../src/common/DiscountCart';
+import { RunInput } from '../src/generated/api';
+import _ from 'lodash';
+import { CustomerSubscriberQualifier } from '../src/common/CustomerSubscriberQualifier';
+import { QualifierMatchType } from '../src/common/Qualifier';
+
+describe('CustomerSubscriberQualifier', () => {
+  it('is true when a customer contains a subscription', () => {
+    const cart = new DiscountCart(withSubscription);
+
+    const qualifier = new CustomerSubscriberQualifier(
+      QualifierMatchType.DOES
+    );
+    const matchResult = qualifier.match(cart);
+    expect(matchResult).toEqual(true);
+  });
+
+  it('is true when a customer does NOT contain an active subscription', () => {
+    const cart = new DiscountCart(withoutSubscription);
+
+    const qualifier = new CustomerSubscriberQualifier(
+      QualifierMatchType.DOES_NOT
+    );
+    const matchResult = qualifier.match(cart);
+    expect(matchResult).toEqual(true);
+  });
+
+  const withSubscription: RunInput['cart'] = {
+    __typename: 'Cart',
+    cost: {
+      subtotalAmount: {
+        amount: '164.0',
+      },
+      totalAmount: {
+        amount: '164.0',
+      },
+    },
+    lines: [
+      {
+        cost: {
+          amountPerQuantity: {
+            amount: '8.0',
+          },
+          subtotalAmount: {
+            amount: '64.0',
+          },
+          totalAmount: {
+            amount: '64.0',
+          },
+          compareAtAmountPerQuantity: null,
+        },
+        quantity: 8,
+        merchandise: {
+          __typename: 'ProductVariant',
+          id: 'gid://shopify/ProductVariant/43900890579178',
+          product: {
+            id: 'gid://shopify/Product/8069766840554',
+            productType: 'Wristband - Single',
+            hasTags: [
+              {
+                tag: 'meta-exclude-gift',
+                hasTag: false,
+              },
+              {
+                tag: 'mystery-3-pack',
+                hasTag: false,
+              },
+            ],
+          },
+        },
+      },
+    ],
+    buyerIdentity: {
+      customer: {
+        isActiveSubscriber: true,
+        hasTags: [
+          {
+            tag: 'Active product subscription',
+            hasTag: true,
+          },
+        ],
+      },
+    },
+  };
+
+  const withoutSubscription = _.cloneDeep(withSubscription);
+  _.merge(withoutSubscription, {
+    buyerIdentity: {
+      customer: {
+        isActiveSubscriber: false,
+        hasTags: [
+          {
+            hasTag: false,
+            tag: 'Active product subscription',
+          },
+        ],
+      },
+    },
+  } as RunInput['cart']);
+});

package/tests/DiscountCart.test.ts

@@ -0,0 +1,115 @@
+import { describe, it, expect } from 'vitest';
+import { DiscountCart } from '../src/common/DiscountCart';
+import { RunInput } from '../src/generated/api';
+
+describe('DiscountCart', () => {
+  const discountCart = new DiscountCart(
+    ONE_GWP_BULK_DISCOUNT_8_PLUS.cart as RunInput['cart']
+  );
+
+  it('Contains correct amounts', () => {
+    expect(discountCart.discounts.length).toBe(0);
+    expect(discountCart.subtotalAmount).toBe(64);
+    expect(discountCart.appliedDiscountTotal).toBe(0);
+
+    discountCart.addDiscount({
+      targets: [
+        {
+          productVariant: {
+            id: 'gid://shopify/ProductVariant/43900890579178',
+          },
+        },
+      ],
+      value: {
+        fixedAmount: {
+          amount: 2,
+          appliesToEachItem: true,
+        },
+      },
+    });
+
+    expect(discountCart.discounts.length).toBe(1);
+    expect(discountCart.appliedDiscountTotal).toBe(16);
+  });
+});
+
+const ONE_GWP_BULK_DISCOUNT_8_PLUS = {
+  cart: {
+    cost: {
+      subtotalAmount: {
+        amount: '164.0',
+      },
+      totalAmount: {
+        amount: '164.0',
+      },
+    },
+    lines: [
+      {
+        gwp: null,
+        cost: {
+          amountPerQuantity: {
+            amount: '8.0',
+          },
+          subtotalAmount: {
+            amount: '64.0',
+          },
+          totalAmount: {
+            amount: '64.0',
+          },
+          compareAtAmountPerQuantity: null,
+        },
+        quantity: 8,
+        merchandise: {
+          __typename: 'ProductVariant',
+          id: 'gid://shopify/ProductVariant/43900890579178',
+          product: {
+            id: 'gid://shopify/Product/8069766840554',
+            productType: 'Wristband - Single',
+            hasTags: [
+              {
+                tag: 'meta-exclude-gift',
+                hasTag: false,
+              },
+            ],
+          },
+        },
+      },
+      {
+        gwp: null,
+        cost: {
+          amountPerQuantity: {
+            amount: '100.0',
+          },
+          subtotalAmount: {
+            amount: '100.0',
+          },
+          totalAmount: {
+            amount: '100.0',
+          },
+          compareAtAmountPerQuantity: null,
+        },
+        quantity: 1,
+        merchandise: {
+          __typename: 'ProductVariant',
+          id: 'gid://shopify/ProductVariant/43137443692778',
+          product: {
+            id: 'gid://shopify/Product/7803814379754',
+            productType: 'Gift',
+            hasTags: [
+              {
+                tag: 'meta-exclude-gift',
+                hasTag: true,
+              },
+            ],
+          },
+        },
+      },
+    ],
+  },
+  discountNode: {
+    metafield: {
+      value:
+        '{"campaigns":[{"__type":"BuyXGetY","inputs":[":all",[],{"__type":"FixedItemDiscount","inputs":[2,true,"Bulky functions discount!"]},{"__type":"ProductTypeSelector","inputs":[":is_one",["Wristband - Single","Wristband - Strap"]]},{"__type":"ProductTypeSelector","inputs":[":is_one",["Wristband - Single","Wristband - Strap"]]},8,null,null]},{"__type":"ConditionalDiscount","inputs":[":all",[{"__type":"AndSelector","inputs":[{"__type":"PostCartAmountQualifier","inputs":[":greater_than_or_equal",50]},{"__type":"CartAmountQualifier","inputs":[":cart",":greater_than_or_equal",50]}]}],{"__type":"PercentageDiscount","inputs":[100,"Now you\'re family! :)"]},{"__type":"ProductIdSelector","inputs":[":is_one",["gid://shopify/Product/7803814379754"]]}]}], "discountApplicationStrategy": "ALL"}',
+    },
+  },
+};

package/tests/OrSelector.test.ts

@@ -0,0 +1,27 @@
+import { describe, it, expect } from 'vitest';
+import { OrSelector } from '../src/common/OrSelector';
+import { CartLine } from '../src/generated/api';
+import {
+  MockFalseyQualifier,
+  MockTruthyQualifier,
+} from './Qualifier.test';
+
+describe('OrSelector', () => {
+  it('Returns true if any conditions are met', () => {
+    const selector = new OrSelector([
+      new MockFalseyQualifier(),
+      new MockTruthyQualifier(),
+    ]);
+
+    expect(selector.match({} as CartLine)).toBeTruthy();
+  });
+
+  it('Returns false if all conditions are not met', () => {
+    const selector = new OrSelector([
+      new MockFalseyQualifier(),
+      new MockFalseyQualifier(),
+    ]);
+
+    expect(selector.match({} as CartLine)).toBeFalsy();
+  });
+});

package/tests/ProductTagSelector.test.ts

@@ -0,0 +1,75 @@
+import { describe, it, expect } from 'vitest';
+import _ from 'lodash';
+import { ProductTagSelector } from '../src/common/ProductTagSelector';
+import { CartLine } from '../src/generated/api';
+import {
+  QualifierMatchType,
+  StringComparisonType,
+} from '../src/common/Qualifier';
+
+describe('ProductTagSelector', () => {
+  it('is true when it matches one of', () => {
+    const selector = new ProductTagSelector(
+      QualifierMatchType.DOES,
+      StringComparisonType.MATCH,
+      ['tag1', 'tag2', 'tag3', 'TAG4']
+    );
+    const result = selector.match(lineItem);
+    expect(result).toEqual(true);
+  });
+
+  it('is false when it does NOT match one of', () => {
+    const selector = new ProductTagSelector(
+      QualifierMatchType.DOES,
+      StringComparisonType.MATCH,
+      ['tag6', 'tag7', 'tag8', 'tag9']
+    );
+    const result = selector.match(lineItem);
+    expect(result).toEqual(false);
+  });
+
+  it('is true when it contains one of', () => {
+    const selector = new ProductTagSelector(
+      QualifierMatchType.DOES,
+      StringComparisonType.CONTAINS,
+      ['ag', 'a']
+    );
+    const result = selector.match(lineItem);
+    expect(result).toEqual(true);
+  });
+
+  it('is false when it does NOT contain one of', () => {
+    const selector = new ProductTagSelector(
+      QualifierMatchType.DOES,
+      StringComparisonType.CONTAINS,
+      ['sandwich', 'choir']
+    );
+    const result = selector.match(lineItem);
+    expect(result).toEqual(false);
+  });
+
+  const lineItem = {
+    merchandise: {
+      product: {
+        hasTags: [
+          {
+            tag: 'tag1',
+            hasTag: true,
+          },
+          {
+            tag: 'tag2',
+            hasTag: true,
+          },
+          {
+            tag: 'tag3',
+            hasTag: true,
+          },
+          {
+            tag: 'tag4',
+            hasTag: true,
+          },
+        ],
+      },
+    },
+  } as CartLine;
+});