@zoxllc/shopify-checkout-extensions 0.0.2 → 0.0.4

package/tests/AndSelector.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { AndSelector } from '../src/common/AndSelector';
-import { CartLine } from '../src/generated/api';
+import { CartLine } from '../src/lineItem/api';
 import {
   MockFalseyQualifier,
   MockTruthyQualifier,

package/tests/CartQuantityQualifier.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { DiscountCart } from '../src/common/DiscountCart';
-import { RunInput } from '../src/generated/api';
+import { RunInput } from '../src/lineItem/api';
 import _ from 'lodash';
 import { NumericalComparisonType } from '../src/common/Qualifier';
 import {

package/tests/CountryCodeQualifier.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect } from 'vitest';
+import _ from 'lodash';
+import { CountryCodeQualifier } from '../src/common/CountryCodeQualifier';
+import { QualifierMatchType } from '../src/common/Qualifier';
+import { DiscountCart } from '../src/common/DiscountCart';
+
+describe('CountryCodeQualifier', () => {
+  it('is true when it matches one of', () => {
+    const qualifier = new CountryCodeQualifier(
+      QualifierMatchType.DOES,
+      ['UK', 'AR', 'CA', 'US']
+    );
+    const result = qualifier.match(discountCart);
+    expect(result).toEqual(true);
+  });
+
+  it('is false when subject not found when expected', () => {
+    const qualifier = new CountryCodeQualifier(
+      QualifierMatchType.DOES,
+      ['UK', 'AR', 'CA', 'BR']
+    );
+    const result = qualifier.match(discountCart);
+    expect(result).toEqual(false);
+  });
+
+  it('is true when it does not exist', () => {
+    const qualifier = new CountryCodeQualifier(
+      QualifierMatchType.DOES_NOT,
+      ['UK', 'CA']
+    );
+    const result = qualifier.match(discountCart);
+    expect(result).toEqual(true);
+  });
+
+  it('is false when it does exist and was expected not to', () => {
+    const qualifier = new CountryCodeQualifier(
+      QualifierMatchType.DOES_NOT,
+      ['CA', 'AR', 'US', 'BR']
+    );
+    const result = qualifier.match(discountCart);
+    expect(result).toEqual(false);
+  });
+
+  // @ts-ignore
+  const discountCart = {
+    cart: {
+      deliveryGroups: [
+        {
+          deliveryAddress: {
+            countryCode: 'US',
+          },
+        },
+      ],
+    },
+  } as DiscountCart;
+});

package/tests/CustomerSubscriberQualifier.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { DiscountCart } from '../src/common/DiscountCart';
-import { RunInput } from '../src/generated/api';
+import { RunInput } from '../src/lineItem/api';
 import _ from 'lodash';
 import { CustomerSubscriberQualifier } from '../src/common/CustomerSubscriberQualifier';
 import { QualifierMatchType } from '../src/common/Qualifier';

package/tests/CustomerTagQualifier.test.ts

@@ -0,0 +1,71 @@
+import { describe, it, expect } from 'vitest';
+import _ from 'lodash';
+import { CustomerTagQualifier } from '../src/common/CustomerTagQualifier';
+import {
+  QualifierMatchType,
+  StringComparisonType,
+} from '../src/common/Qualifier';
+import { DiscountCart } from '../src/common/DiscountCart';
+
+describe('CustomerTagQualifier', () => {
+  it('is true when it matches one of', () => {
+    const qualifier = new CustomerTagQualifier(
+      QualifierMatchType.DOES,
+      StringComparisonType.MATCH,
+      [
+        'tag1',
+        'tag2',
+        'Active product subscription',
+        'TAG4',
+      ]
+    );
+    const result = qualifier.match(discountCart);
+    expect(result).toEqual(true);
+  });
+
+  it('is false when it does NOT match one of', () => {
+    const qualifier = new CustomerTagQualifier(
+      QualifierMatchType.DOES,
+      StringComparisonType.MATCH,
+      ['tag6', 'tag7', 'tag8', 'tag9']
+    );
+    const result = qualifier.match(discountCart);
+    expect(result).toEqual(false);
+  });
+
+  it('is true when it contains one of', () => {
+    const qualifier = new CustomerTagQualifier(
+      QualifierMatchType.DOES,
+      StringComparisonType.CONTAINS,
+      ['ag', 'product']
+    );
+    const result = qualifier.match(discountCart);
+    expect(result).toEqual(true);
+  });
+
+  it('is false when it does NOT contain one of', () => {
+    const qualifier = new CustomerTagQualifier(
+      QualifierMatchType.DOES,
+      StringComparisonType.CONTAINS,
+      ['sandwich', 'choir']
+    );
+    const result = qualifier.match(discountCart);
+    expect(result).toEqual(false);
+  });
+
+  const discountCart = {
+    cart: {
+      buyerIdentity: {
+        customer: {
+          hasTags: [
+            {
+              tag: 'Active product subscription',
+              hasTag: true,
+            },
+            { tag: 'dev', hasTag: false },
+          ],
+        },
+      },
+    },
+  } as DiscountCart;
+});

package/tests/DiscountCart.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { DiscountCart } from '../src/common/DiscountCart';
-import { RunInput } from '../src/generated/api';
+import { RunInput } from '../src/lineItem/api';
 
 describe('DiscountCart', () => {
   const discountCart = new DiscountCart(

package/tests/OrSelector.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { OrSelector } from '../src/common/OrSelector';
-import { CartLine } from '../src/generated/api';
+import { CartLine } from '../src/lineItem/api';
 import {
   MockFalseyQualifier,
   MockTruthyQualifier,

package/tests/ProductIdSelector.test.ts

@@ -0,0 +1,83 @@
+import { describe, it, expect } from 'vitest';
+import _ from 'lodash';
+import { ProductIdSelector } from '../src/common/ProductIdSelector';
+import { CartLine } from '../src/lineItem/api';
+import {
+  QualifierMatchType,
+  StringComparisonType,
+} from '../src/common/Qualifier';
+import { MatchType } from '../src/common/Selector';
+
+describe('ProductIdSelector', () => {
+  it('is true when it matches one of', () => {
+    const selector = new ProductIdSelector(
+      MatchType.IS_ONE,
+      [
+        'tag1',
+        'gid://shopify/Product/1234567890',
+        'tag3',
+        'TAG4',
+      ]
+    );
+    const result = selector.match(lineItem);
+    expect(result).toEqual(true);
+  });
+
+  it('is true when it does NOT match one of', () => {
+    const selector = new ProductIdSelector(
+      MatchType.NOT_ONE,
+      [
+        'gid://shopify/Product/1111',
+        'gid://shopify/Product/2222',
+        'gid://shopify/Product/3333',
+        'gid://shopify/Product/4444',
+      ]
+    );
+    const result = selector.match(lineItem);
+    expect(result).toEqual(true);
+  });
+
+  it('is false when it is not found', () => {
+    const selector = new ProductIdSelector(
+      MatchType.IS_ONE,
+      ['gid://shopify/Product/111111', 'a']
+    );
+    const result = selector.match(lineItem);
+    expect(result).toEqual(false);
+  });
+
+  it('is false when it is present but it is not expected to', () => {
+    const selector = new ProductIdSelector(
+      MatchType.NOT_ONE,
+      ['gid://shopify/Product/1234567890', 'a']
+    );
+    const result = selector.match(lineItem);
+    expect(result).toEqual(false);
+  });
+
+  const lineItem = {
+    merchandise: {
+      product: {
+        id: 'gid://shopify/Product/1234567890',
+        hasTags: [
+          {
+            tag: 'tag1',
+            hasTag: true,
+          },
+          {
+            tag: 'tag2',
+            hasTag: true,
+          },
+          {
+            tag: 'tag3',
+            hasTag: true,
+          },
+          {
+            tag: 'tag4',
+            hasTag: true,
+          },
+        ],
+      },
+    },
+  } as CartLine;
+});

package/tests/ProductTagSelector.test.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect } from 'vitest';
 import _ from 'lodash';
 import { ProductTagSelector } from '../src/common/ProductTagSelector';
-import { CartLine } from '../src/generated/api';
+import { CartLine } from '../src/lineItem/api';
 import {
   QualifierMatchType,
   StringComparisonType,

package/tests/Qualifier.test.ts

@@ -4,7 +4,7 @@ import {
   Qualifier,
 } from '../src/common/Qualifier';
 import type { DiscountCart } from '../src/common/DiscountCart';
-import type { CartLine } from '../src/generated/api';
+import type { CartLine } from '../src/lineItem/api';
 import type { Selector } from '../src/common/Selector';
 
 export class MockTruthyQualifier extends Qualifier {

package/tests/RateNameSelector.test.ts

@@ -0,0 +1,107 @@
+import { describe, it, expect } from 'vitest';
+import _ from 'lodash';
+import {
+  CartDeliveryOption,
+  DeliveryMethod,
+} from '../src/shipping/api';
+import { RateNameSelector } from '../src/shipping/RateNameSelector';
+import { MatchType } from '../src/common/Selector';
+import { StringComparisonType } from '../src/common/Qualifier';
+
+describe('RateNameSelector', () => {
+  it('is true when it matches one of', () => {
+    const selector = new RateNameSelector(
+      MatchType.DOES,
+      StringComparisonType.MATCH,
+      ['Fedex - 10% Shipping', 'UPS - Domestic']
+    );
+    const result = selector.match(cartDeliveryOption);
+    expect(result).toEqual(true);
+  });
+
+  it('is true when it does NOT match one of', () => {
+    const selector = new RateNameSelector(
+      MatchType.DOES_NOT,
+      StringComparisonType.MATCH,
+      ['Fedex', 'UPS']
+    );
+    const result = selector.match(cartDeliveryOption);
+    expect(result).toEqual(true);
+  });
+
+  it('is true when it contains one of', () => {
+    const selector = new RateNameSelector(
+      MatchType.DOES,
+      StringComparisonType.CONTAINS,
+      ['edex']
+    );
+    const result = selector.match(cartDeliveryOption);
+    expect(result).toEqual(true);
+  });
+
+  it('is true when it does NOT contain one of', () => {
+    const selector = new RateNameSelector(
+      MatchType.DOES_NOT,
+      StringComparisonType.CONTAINS,
+      ['Monkey']
+    );
+    const result = selector.match(cartDeliveryOption);
+    expect(result).toEqual(true);
+  });
+
+  it('is false when it does contain one of with DOES_NOT', () => {
+    const selector = new RateNameSelector(
+      MatchType.DOES_NOT,
+      StringComparisonType.CONTAINS,
+      ['Fedex']
+    );
+    const result = selector.match(cartDeliveryOption);
+    expect(result).toEqual(false);
+  });
+
+  it('is true when it starts with', () => {
+    const selector = new RateNameSelector(
+      MatchType.DOES,
+      StringComparisonType.START_WITH,
+      ['Fedex']
+    );
+    const result = selector.match(cartDeliveryOption);
+    expect(result).toEqual(true);
+  });
+
+  it('is true when it does not start with', () => {
+    const selector = new RateNameSelector(
+      MatchType.DOES_NOT,
+      StringComparisonType.START_WITH,
+      ['UPS']
+    );
+    const result = selector.match(cartDeliveryOption);
+    expect(result).toEqual(true);
+  });
+
+  it('is true when it contains one of', () => {
+    const selector = new RateNameSelector(
+      MatchType.DOES,
+      StringComparisonType.END_WITH,
+      ['Shipping']
+    );
+    const result = selector.match(cartDeliveryOption);
+    expect(result).toEqual(true);
+  });
+
+  it('is true when it contains one of', () => {
+    const selector = new RateNameSelector(
+      MatchType.DOES_NOT,
+      StringComparisonType.END_WITH,
+      ['Fedex']
+    );
+    const result = selector.match(cartDeliveryOption);
+    expect(result).toEqual(true);
+  });
+
+  const cartDeliveryOption = {
+    deliveryMethodType: DeliveryMethod.Shipping,
+    handle: 'test-handle',
+    title: 'Fedex - 10% Shipping',
+  } as CartDeliveryOption;
+});

package/tests/SaleItemSelector.test.ts

@@ -3,7 +3,7 @@ import {
   CartLine,
   CurrencyCode,
   WeightUnit,
-} from '../src/generated/api';
+} from '../src/lineItem/api';
 import _ from 'lodash';
 import {
   SaleItemSelector,

package/tests/Selector.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import type { CartLine } from '../src/generated/api';
+import type { CartLine } from '../src/lineItem/api';
 import { Selector } from '../src/common/Selector';
 import { StringComparisonType } from '../src/common/Qualifier';