@zoxllc/shopify-checkout-extensions 0.0.1

package/tests/Qualifier.test.ts

@@ -0,0 +1,193 @@
+import { describe, it, expect } from 'vitest';
+import {
+  NumericalComparisonType,
+  Qualifier,
+} from '../src/common/Qualifier';
+import type { DiscountCart } from '../src/common/DiscountCart';
+import type { CartLine } from '../src/generated/api';
+import type { Selector } from '../src/common/Selector';
+
+export class MockTruthyQualifier extends Qualifier {
+  match(
+    subject: DiscountCart | CartLine,
+    selector?: Selector | undefined
+  ): boolean {
+    return true;
+  }
+}
+
+export class MockFalseyQualifier extends Qualifier {
+  match(
+    subject: DiscountCart | CartLine,
+    selector?: Selector | undefined
+  ): boolean {
+    return false;
+  }
+}
+
+describe('Qualifier', () => {
+  const qualifier = new Qualifier();
+  it('Contains a root compareAmounts method', () => {
+    expect(qualifier.compareAmounts).toBeDefined();
+  });
+
+  it('Compares amounts properly for all cases', () => {
+    // EQUAL_TO
+    expect(
+      qualifier.compareAmounts(
+        10,
+        NumericalComparisonType.EQUAL_TO,
+        10
+      ),
+      'Must be TRUE when 10 EQUAL_TO 10'
+    ).toEqual(true);
+    expect(
+      qualifier.compareAmounts(
+        1,
+        NumericalComparisonType.EQUAL_TO,
+        10
+      ),
+      'Must be FALSE when 1 EQUAL_TO 10'
+    ).toEqual(false);
+    expect(
+      qualifier.compareAmounts(
+        10,
+        NumericalComparisonType.EQUAL_TO,
+        1
+      ),
+      'Must be FALSE when 10 EQUAL_TO 1'
+    ).toEqual(false);
+
+    // GREATER_THAN
+    expect(
+      qualifier.compareAmounts(
+        11,
+        NumericalComparisonType.GREATER_THAN,
+        10
+      ),
+      'Must be TRUE when 11 GREATER_THAN 10'
+    ).toEqual(true);
+    expect(
+      qualifier.compareAmounts(
+        1,
+        NumericalComparisonType.GREATER_THAN,
+        10
+      ),
+      'Must be FALSE when 1 GREATER_THAN 10'
+    ).toEqual(false);
+    expect(
+      qualifier.compareAmounts(
+        10,
+        NumericalComparisonType.GREATER_THAN,
+        1
+      ),
+      'Must be TRUE when 10 GREATER_THAN 1'
+    ).toEqual(true);
+
+    // GREATER_THAN_OR_EQUAL
+    expect(
+      qualifier.compareAmounts(
+        11,
+        NumericalComparisonType.GREATER_THAN_OR_EQUAL,
+        10
+      ),
+      'Must be TRUE when 11 GREATER_THAN_OR_EQUAL 10'
+    ).toEqual(true);
+    expect(
+      qualifier.compareAmounts(
+        10,
+        NumericalComparisonType.GREATER_THAN_OR_EQUAL,
+        10
+      ),
+      'Must be TRUE when 10 GREATER_THAN_OR_EQUAL 10'
+    ).toEqual(true);
+    expect(
+      qualifier.compareAmounts(
+        1,
+        NumericalComparisonType.GREATER_THAN_OR_EQUAL,
+        10
+      ),
+      'Must be FALSE when 1 GREATER_THAN_OR_EQUAL 10'
+    ).toEqual(false);
+    expect(
+      qualifier.compareAmounts(
+        10,
+        NumericalComparisonType.GREATER_THAN_OR_EQUAL,
+        1
+      ),
+      'Must be TRUE when 10 GREATER_THAN_OR_EQUAL 1'
+    ).toEqual(true);
+
+    // LESS_THAN
+    expect(
+      qualifier.compareAmounts(
+        11,
+        NumericalComparisonType.LESS_THAN,
+        10
+      ),
+      'Must be FALSE when 11 LESS_THAN 10'
+    ).toEqual(false);
+    expect(
+      qualifier.compareAmounts(
+        1,
+        NumericalComparisonType.LESS_THAN,
+        10
+      ),
+      'Must be TRUE when 1 LESS_THAN 10'
+    ).toEqual(true);
+    expect(
+      qualifier.compareAmounts(
+        10,
+        NumericalComparisonType.LESS_THAN,
+        1
+      ),
+      'Must be FALSE when 10 LESS_THAN 1'
+    ).toEqual(false);
+    expect(
+      qualifier.compareAmounts(
+        1,
+        NumericalComparisonType.LESS_THAN,
+        1
+      ),
+      'Must be FALSE when 1 LESS_THAN 1'
+    ).toEqual(false);
+
+    // LESS_THAN_OR_EQUAL
+    expect(
+      qualifier.compareAmounts(
+        11,
+        NumericalComparisonType.LESS_THAN_OR_EQUAL,
+        10
+      ),
+      'Must be FALSE when 11 LESS_THAN_OR_EQUAL 10'
+    ).toEqual(false);
+    expect(
+      qualifier.compareAmounts(
+        10,
+        NumericalComparisonType.LESS_THAN_OR_EQUAL,
+        10
+      ),
+      'Must be TRUE when 10 LESS_THAN_OR_EQUAL 10'
+    ).toEqual(true);
+    expect(
+      qualifier.compareAmounts(
+        1,
+        NumericalComparisonType.LESS_THAN_OR_EQUAL,
+        10
+      ),
+      'Must be TRUE when 1 LESS_THAN_OR_EQUAL 10'
+    ).toEqual(true);
+    expect(
+      qualifier.compareAmounts(
+        10,
+        NumericalComparisonType.LESS_THAN_OR_EQUAL,
+        1
+      ),
+      'Must be FALSE when 10 LESS_THAN_OR_EQUAL 1'
+    ).toEqual(false);
+  });
+
+  it('Will always return false when calling match()', () => {
+    expect(qualifier.match({} as DiscountCart)).toBeFalsy();
+  });
+});

package/tests/SaleItemSelector.test.ts

@@ -0,0 +1,113 @@
+import { describe, it, expect } from 'vitest';
+import {
+  CartLine,
+  CurrencyCode,
+  WeightUnit,
+} from '../src/generated/api';
+import _ from 'lodash';
+import {
+  SaleItemSelector,
+  SaleItemSelectorMatchType,
+} from '../src/common/SaleItemSelector';
+
+describe('SaleItemSelector', () => {
+  it('returns true when item is on sale and we pass :IS', () => {
+    const isSelector = new SaleItemSelector(
+      SaleItemSelectorMatchType.IS
+    );
+    const isResult = isSelector.match(lineItemOnSale);
+    expect(isResult).toEqual(true);
+  });
+
+  it('returns false when item is on sale and we pass :NOT', () => {
+    const notSelector = new SaleItemSelector(
+      SaleItemSelectorMatchType.NOT
+    );
+    const notResult = notSelector.match(lineItemOnSale);
+    expect(notResult).toEqual(false);
+  });
+
+  it('returns false when item is NOT on sale and we pass :IS', () => {
+    const isSelector = new SaleItemSelector(
+      SaleItemSelectorMatchType.IS
+    );
+    const isResult = isSelector.match(lineItemNotOnSale);
+    expect(isResult).toEqual(false);
+  });
+
+  it('returns true when :NOT matchtype passed and item is NOT on sale', () => {
+    const notSelector = new SaleItemSelector(
+      SaleItemSelectorMatchType.NOT
+    );
+    const notResult = notSelector.match(lineItemNotOnSale);
+    expect(notResult).toEqual(true);
+  });
+
+  const lineItemOnSale: CartLine = {
+    id: 'gid://shopify/CartLine/111111',
+    cost: {
+      amountPerQuantity: {
+        amount: '8.0',
+        currencyCode: CurrencyCode.Usd,
+      },
+      subtotalAmount: {
+        amount: '64.0',
+        currencyCode: CurrencyCode.Usd,
+      },
+      totalAmount: {
+        amount: '64.0',
+        currencyCode: CurrencyCode.Usd,
+      },
+      compareAtAmountPerQuantity: {
+        amount: '10.0',
+        currencyCode: CurrencyCode.Usd,
+      },
+    },
+    quantity: 8,
+    merchandise: {
+      __typename: 'ProductVariant',
+      id: 'gid://shopify/ProductVariant/43900890579178',
+      product: {
+        title: 'Wristband Product',
+        handle: 'wristband-product',
+        id: 'gid://shopify/Product/8069766840554',
+        productType: 'Wristband - Single',
+        inAnyCollection: false,
+        inCollections: [],
+        hasAnyTag: false,
+        isGiftCard: false,
+        hasTags: [
+          {
+            tag: 'meta-exclude-gift',
+            hasTag: false,
+          },
+          {
+            tag: 'feel-good-mystery-3-pack',
+            hasTag: true,
+          },
+        ],
+      },
+      requiresShipping: false,
+      weightUnit: WeightUnit.Pounds,
+    },
+  };
+
+  const lineItemNotOnSale = _.cloneDeep(lineItemOnSale);
+  _.merge(lineItemNotOnSale, {
+    cost: {
+      amountPerQuantity: {
+        amount: '8.0',
+        currencyCode: CurrencyCode.Usd,
+      },
+      subtotalAmount: {
+        amount: '64.0',
+        currencyCode: CurrencyCode.Usd,
+      },
+      totalAmount: {
+        amount: '64.0',
+        currencyCode: CurrencyCode.Usd,
+      },
+      compareAtAmountPerQuantity: null,
+    },
+  } as CartLine);
+});

package/tests/Selector.test.ts

@@ -0,0 +1,83 @@
+import { describe, it, expect } from 'vitest';
+import type { CartLine } from '../src/generated/api';
+import { Selector } from '../src/common/Selector';
+import { StringComparisonType } from '../src/common/Qualifier';
+
+export enum MatchType {
+  'ALL' = ':all',
+  'IS_ONE' = ':is_one',
+  'NOT_ONE' = ':not_one',
+}
+
+describe('Selector', () => {
+  it('always returns true when calling match method', () => {
+    const selector = new Selector();
+    expect(selector.match({} as CartLine)).toBeTruthy();
+  });
+
+  it('is true when part of the string is present', () => {
+    const selector = new Selector();
+    const result = selector.partialMatch(
+      StringComparisonType.CONTAINS,
+      ['tag1', 'tag3'],
+      ['ag', 'a']
+    );
+
+    expect(result).toEqual(true);
+  });
+
+  it('is false when part of the string is not present', () => {
+    const selector = new Selector();
+    const result = selector.partialMatch(
+      StringComparisonType.CONTAINS,
+      ['tag1', 'tag3'],
+      ['sandwich', 'marshmallow']
+    );
+
+    expect(result).toEqual(false);
+  });
+
+  it('is true when it starts with a string', () => {
+    const selector = new Selector();
+    const result = selector.partialMatch(
+      StringComparisonType.START_WITH,
+      ['tag1', 'tag3'],
+      ['ta', 'tag']
+    );
+
+    expect(result).toEqual(true);
+  });
+
+  it('is false when it does NOT start with that string', () => {
+    const selector = new Selector();
+    const result = selector.partialMatch(
+      StringComparisonType.START_WITH,
+      ['tag1', 'tag3'],
+      ['ag1', 'ag3']
+    );
+
+    expect(result).toEqual(false);
+  });
+
+  it('is true when it ends with a string', () => {
+    const selector = new Selector();
+    const result = selector.partialMatch(
+      StringComparisonType.END_WITH,
+      ['tag1', 'tag3'],
+      ['ag3', 'coconuts']
+    );
+
+    expect(result).toEqual(true);
+  });
+
+  it('is false when it does NOT end with that string', () => {
+    const selector = new Selector();
+    const result = selector.partialMatch(
+      StringComparisonType.END_WITH,
+      ['tag1', 'tag3'],
+      ['ta', 'tag']
+    );
+
+    expect(result).toEqual(false);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "include": ["**/*.ts", "**/*.tsx"],
+  "compilerOptions": {
+    "lib": ["DOM", "DOM.Iterable", "ES2019"],
+    "strict": true,
+    "skipLibCheck": true,
+    "isolatedModules": true,
+    "allowSyntheticDefaultImports": true,
+    "removeComments": false,
+    "forceConsistentCasingInFileNames": true,
+    "noEmit": true,
+    "allowJs": true,
+    "jsx": "react-jsx",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "target": "ES2019",
+    "baseUrl": ".",
+    "paths": {
+      "~/*": ["./src/*"]
+    },
+    "types": [
+      "node", "@shopify/app-bridge-types"
+    ]
+  }
+}