@reactionary/source 0.0.51 → 0.2.15

package/providers/commercetools/src/test/category.provider.spec.ts

@@ -1,168 +0,0 @@
-import 'dotenv/config'
-import type { RequestContext} from '@reactionary/core';
-import { CategorySchema, NoOpCache, Session , createInitialRequestContext} from '@reactionary/core';
-import { CommercetoolsCategoryProvider } from '../providers/category.provider';
-import { getCommercetoolsTestConfiguration } from './test-utils';
-
-const testData = {
-  topCategories: [
-    {
-      key: 'home-decor', name: 'Home Decor', slug: 'home-decor'
-    },
-    {
-      key: 'furniture', name: 'Furniture'
-    }
-  ],
-
-  childCategoriesOfFirstTopcategory: [
-    { key: 'bedding', name: 'Bedding' },
-    { key: 'room-decor', name: 'Room Decor' }
-  ],
-
-  breadCrumb: [ 'home-decor', 'room-decor', 'home-accents' ],
-}
-
-
-describe('Commercetools Category Provider', () => {
-  let provider: CommercetoolsCategoryProvider;
-  let reqCtx: RequestContext;
-
-  beforeAll( () => {
-    provider = new CommercetoolsCategoryProvider(getCommercetoolsTestConfiguration(), CategorySchema, new NoOpCache());
-  });
-
-  beforeEach( () => {
-    reqCtx = createInitialRequestContext()
-  })
-
-  it('should be able to get top-categories', async () => {
-    const result = await provider.findTopCategories({ paginationOptions: { pageSize: 10, pageNumber: 1 }}, reqCtx);
-
-    expect(result.items.length).toBeGreaterThan(0);
-    expect(result.items[0].identifier.key).toBe(testData.topCategories[0].key);
-    expect(result.items[0].name).toBe(testData.topCategories[0].name);
-
-    expect(result.items[1].identifier.key).toBe(testData.topCategories[1].key);
-    expect(result.items[1].name).toBe(testData.topCategories[1].name);
-  });
-
-  it('should be able to get child categories for a category', async () => {
-    const result = await provider.findChildCategories({ parentId: { key: testData.topCategories[0].key }, paginationOptions: { pageSize: 10, pageNumber: 1 }}, reqCtx);
-
-    expect(result.items.length).toBeGreaterThan(0);
-    expect(result.items[0].identifier.key).toBe(testData.childCategoriesOfFirstTopcategory[0].key);
-    expect(result.items[0].name).toBe(testData.childCategoriesOfFirstTopcategory[0].name);
-
-    expect(result.items[1].identifier.key).toBe(testData.childCategoriesOfFirstTopcategory[1].key);
-    expect(result.items[1].name).toBe(testData.childCategoriesOfFirstTopcategory[1].name);
-
-  });
-
-
-  it('should be able to get child categories for a category, paged', async () => {
-    let result = await provider.findChildCategories({ parentId: { key: testData.topCategories[0].key }, paginationOptions: { pageSize: 1, pageNumber: 1 }}, reqCtx);
-
-    expect(result.items.length).toBeGreaterThan(0);
-    expect(result.items[0].identifier.key).toBe(testData.childCategoriesOfFirstTopcategory[0].key);
-    expect(result.items[0].name).toBe(testData.childCategoriesOfFirstTopcategory[0].name);
-    expect(result.totalCount).toBe(2);
-    expect(result.totalPages).toBe(2);
-    expect(result.pageSize).toBe(1);
-    expect(result.pageNumber).toBe(1);
-
-    result = await provider.findChildCategories({ parentId: { key: testData.topCategories[0].key }, paginationOptions: { pageSize: 1, pageNumber: 2 }}, reqCtx);
-
-    expect(result.items.length).toBeGreaterThan(0);
-    expect(result.items[0].identifier.key).toBe(testData.childCategoriesOfFirstTopcategory[1].key);
-    expect(result.items[0].name).toBe(testData.childCategoriesOfFirstTopcategory[1].name);
-    expect(result.totalCount).toBe(2);
-    expect(result.totalPages).toBe(2);
-    expect(result.pageSize).toBe(1);
-    expect(result.pageNumber).toBe(2);
-  });
-
-
-  it('can load all breadcrumbs for a category', async () => {
-    const leaf = testData.breadCrumb[testData.breadCrumb.length -1];
-    const result = await provider.getBreadcrumbPathToCategory({ id: { key: leaf! } }, reqCtx);
-
-    expect(result.length).toBe(testData.breadCrumb.length);
-    for(let i = 0 ; i < testData.breadCrumb.length; i++) {
-      expect(result[i].identifier.key).toBe(testData.breadCrumb[i]);
-    }
-  });
-
-
-  it('should be able to get a category by slug', async () => {
-
-    const result = await provider.getBySlug({ slug: testData.topCategories[0].slug! }, reqCtx);
-    expect(result).toBeTruthy();
-    if (result) {
-      expect(result.identifier.key).toBe(testData.topCategories[0].key);
-      expect(result.name).toBe(testData.topCategories[0].name);
-      expect(result.slug).toBe(testData.topCategories[0].slug);
-      expect(result.parentCategory).toBeUndefined();
-      expect(result.text).not.toBe("");
-      expect(result.meta.placeholder).toBe(false);
-    }
-  });
-
-  it('returns null if looking for slug that does not exist', async () => {
-    const result = await provider.getBySlug({ slug: 'non-existent-slug' }, reqCtx);
-    expect(result).toBeNull();
-  });
-
-
-
-  it('should be able to get a category by id', async () => {
-    const result = await provider.getById({ id: { key: 'home-decor'}}, reqCtx);
-
-    expect(result.identifier.key).toBe('home-decor');
-    expect(result.name).toBe('Home Decor');
-    expect(result.slug).toBe('home-decor');
-    expect(result.parentCategory).toBeUndefined();
-
-    expect(result.text).toBe('A test description');
-    expect(result.meta.placeholder).toBe(false);
-
-  });
-
- it('should be able to get a category by id in alternate language', async () => {
-
-    reqCtx.languageContext.locale = 'de-DE';
-    const result = await provider.getById({ id: { key: 'home-decor'}}, reqCtx);
-
-    expect(result.identifier.key).toBe('home-decor');
-    expect(result.name).toBe('Dekoration');
-    expect(result.slug).toBe('home-decor');
-    expect(result.parentCategory).toBeUndefined();
-
-    expect(result.text).toBe('Eine Testbeschreibung');
-    expect(result.meta.placeholder).toBe(false);
-
-  });
-
-
-  it('returns empty values if you choose a language that is not available', async () => {
-
-    reqCtx.languageContext.locale = 'fr-FR';
-    const result = await provider.getById({ id: { key: 'home-decor'}}, reqCtx);
-
-    expect(result.identifier.key).toBe('home-decor');
-    expect(result.name).toBe('No Name');
-    expect(result.slug).toBe('');
-    expect(result.parentCategory).toBeUndefined();
-
-    expect(result.meta.placeholder).toBe(false);
-
-  });
-
-
-
-  it('returns a placeholder if you search for a category that does not exist', async () => {
-    const result = await provider.getById({ id: { key: 'non-existent-category'}}, reqCtx);
-    expect(result.identifier.key).toBe('non-existent-category');
-    expect(result.meta.placeholder).toBe(true);
-
-  });
-});

package/providers/commercetools/src/test/checkout.provider.spec.ts

@@ -1,312 +0,0 @@
-import 'dotenv/config';
-import type { Cart, Checkout, RequestContext } from '@reactionary/core';
-import {
-  CartSchema,
-  CheckoutSchema,
-  IdentitySchema,
-  NoOpCache,
-  PaymentInstructionSchema,
-  ShippingInstructionSchema,
-  createInitialRequestContext,
-} from '@reactionary/core';
-import { getCommercetoolsTestConfiguration } from './test-utils';
-import { CommercetoolsCartProvider } from '../providers/cart.provider';
-import { CommercetoolsIdentityProvider } from '../providers/identity.provider';
-import { CommercetoolsCheckoutProvider } from '../providers/checkout.provider';
-
-const testData = {
-  skuWithoutTiers: 'SGB-01',
-  skuWithTiers: 'GMCT-01',
-};
-
-describe('Commercetools Checkout Provider', () => {
-  let provider: CommercetoolsCheckoutProvider;
-  let cartProvider: CommercetoolsCartProvider;
-  let identityProvider: CommercetoolsIdentityProvider;
-  let reqCtx: RequestContext;
-
-  beforeAll(() => {
-    provider = new CommercetoolsCheckoutProvider(
-      getCommercetoolsTestConfiguration(),
-      CheckoutSchema,
-      new NoOpCache()
-    );
-    cartProvider = new CommercetoolsCartProvider(
-      getCommercetoolsTestConfiguration(),
-      CartSchema,
-      new NoOpCache()
-    );
-    identityProvider = new CommercetoolsIdentityProvider(
-      getCommercetoolsTestConfiguration(),
-      IdentitySchema,
-      new NoOpCache()
-    );
-  });
-
-  beforeEach(() => {
-    reqCtx = createInitialRequestContext();
-  });
-
-  describe('anonymous sessions', () => {
-    let cart: Cart;
-
-    beforeEach(async () => {
-      cart = await cartProvider.add(
-        {
-          cart: { key: '', version: 0 },
-          sku: {
-            key: testData.skuWithoutTiers,
-          },
-          quantity: 1,
-        },
-        reqCtx
-      );
-    });
-
-    it('can create a checkout session from a cart', async () => {
-      //  we have either an anonymous user, or an authenticated user.
-      // if it is anonymous, we assume you will have collected some basic info by now ?
-
-      const checkout = await provider.initiateCheckoutForCart(
-        {
-          cart: cart.identifier,
-          billingAddress: {
-            countryCode: 'US',
-            firstName: 'John',
-            lastName: 'Doe',
-            streetAddress: '123 Main St',
-            streetNumber: '1A',
-            postalCode: '12345',
-            city: 'Anytown',
-            region: '',
-          },
-          notificationEmail: 'sample@example.com',
-          notificationPhone: '+4512345678',
-        },
-        reqCtx
-      );
-
-      expect(checkout.identifier.key).toBeDefined();
-      expect(checkout.originalCartReference.key).toBe(cart.identifier.key);
-      expect(checkout.billingAddress?.firstName).toBe('John');
-      expect(checkout.items.length).toBe(1);
-      expect(checkout.items[0].sku.key).toBe(testData.skuWithoutTiers);
-    });
-
-    describe('checkout actions', () => {
-      let checkout: Checkout;
-      beforeEach(async () => {
-        checkout = await provider.initiateCheckoutForCart(
-          {
-            cart: cart.identifier,
-            billingAddress: {
-              countryCode: 'US',
-              firstName: 'John',
-              lastName: 'Doe',
-              streetAddress: '123 Main St',
-              streetNumber: '1A',
-              postalCode: '12345',
-              city: 'Anytown',
-              region: '',
-            },
-            notificationEmail: 'sample@example.com',
-            notificationPhone: '+4512345678',
-          },
-          reqCtx
-        );
-      });
-
-      it('can list payment methods', async () => {
-        const paymentMethods = await provider.getAvailablePaymentMethods(
-          {
-            checkout: checkout.identifier,
-          },
-          reqCtx
-        );
-        expect(paymentMethods.length).toBeGreaterThan(0);
-        expect(
-          paymentMethods.find((x) => x.identifier.method === 'stripe')
-        ).toBeDefined();
-      });
-
-      it('can list shipping methods', async () => {
-        const shippingMethods = await provider.getAvailableShippingMethods(
-          {
-            checkout: checkout.identifier,
-          },
-          reqCtx
-        );
-        expect(shippingMethods.length).toBeGreaterThan(0);
-        expect(
-          shippingMethods.find((x) => x.identifier.key === 'us-delivery')
-        ).toBeDefined();
-      });
-
-      it('can add a payment instruction', async () => {
-        const paymentMethods = await provider.getAvailablePaymentMethods(
-          {
-            checkout: checkout.identifier,
-          },
-          reqCtx
-        );
-        const pm = paymentMethods.find((x) => x.identifier.method === 'stripe');
-        expect(pm).toBeDefined();
-
-        const checkoutWithPi = await provider.addPaymentInstruction(
-          {
-            checkout: checkout.identifier,
-            paymentInstruction: PaymentInstructionSchema.parse({
-              paymentMethod: pm?.identifier,
-              amount: checkout.price.grandTotal,
-              protocolData: [{ key: 'test-key', value: 'test-value' }],
-            }),
-          },
-          reqCtx
-        );
-
-        expect(checkoutWithPi.paymentInstructions.length).toBe(1);
-        expect(checkoutWithPi.paymentInstructions[0].paymentMethod.method).toBe(
-          'stripe'
-        );
-        expect(checkoutWithPi.paymentInstructions[0].protocolData.find(x => x.key === 'stripe_clientSecret')?.value).toBeDefined();
-
-      });
-
-      xit('can cancel an in-progress payment', async () => {
-        const paymentMethods = await provider.getAvailablePaymentMethods(
-          {
-            checkout: checkout.identifier,
-          },
-          reqCtx
-        );
-        const pm = paymentMethods.find((x) => x.identifier.method === 'stripe');
-        expect(pm).toBeDefined();
-
-        const checkoutWithPi = await provider.addPaymentInstruction(
-          {
-            checkout: checkout.identifier,
-            paymentInstruction: PaymentInstructionSchema.parse({
-              paymentMethod: pm?.identifier,
-              amount: checkout.price.grandTotal,
-              protocolData: [{ key: 'test-key', value: 'test-value' }],
-            }),
-          },
-          reqCtx
-        );
-
-        expect(checkoutWithPi.paymentInstructions.length).toBe(1);
-
-        const checkoutAfterCancel = await provider.removePaymentInstruction(
-          {
-            checkout: checkout.identifier,
-            paymentInstruction:
-              checkoutWithPi.paymentInstructions[0].identifier,
-          },
-          reqCtx
-        );
-
-        expect(checkoutAfterCancel.paymentInstructions.length).toBe(0);
-      });
-
-      it('can set shipping address', async () => {
-        const checkoutWithShipping = await provider.setShippingAddress(
-          {
-            checkout: checkout.identifier,
-            shippingAddress: {
-              countryCode: 'US',
-              firstName: 'Jane',
-              lastName: 'Doe',
-              streetAddress: '456 Other St',
-              streetNumber: '2B',
-              postalCode: '54321',
-              city: 'Othertown',
-              region: '',
-            },
-          },
-          reqCtx
-        );
-
-        expect(checkoutWithShipping.shippingAddress).toBeDefined();
-        expect(checkoutWithShipping.shippingAddress?.firstName).toBe('Jane');
-      });
-
-      it('can set shipping instructions', async () => {
-        const shippingMethods = await provider.getAvailableShippingMethods(
-          {
-            checkout: checkout.identifier,
-          },
-          reqCtx
-        );
-        const sm = shippingMethods.find((x) => x.identifier.key === 'us-delivery');
-        expect(sm).toBeDefined();
-
-        const shippingInstruction = ShippingInstructionSchema.parse({
-          shippingMethod: sm?.identifier || { key: '' },
-          amount: checkout.price.totalShipping,
-          instructions: 'Leave at front door if not home',
-          consentForUnattendedDelivery: true,
-          pickupPoint: '4190asx141', // this would be a real pickup point ID in a real scenario
-        });
-
-        const checkoutWithShipping = await provider.setShippingInstruction(
-          {
-            checkout: checkout.identifier,
-            shippingInstruction,
-          },
-          reqCtx
-        );
-
-        expect(checkout.price.totalShipping.value).toBe(0);
-        expect(checkoutWithShipping.price.totalShipping.value).toBeGreaterThan(0);
-        expect(checkoutWithShipping.shippingInstruction).toBeDefined();
-        expect(
-          checkoutWithShipping.shippingInstruction?.shippingMethod.key
-        ).toBe('us-delivery');
-        expect(checkoutWithShipping.shippingInstruction?.instructions).toBe(
-          'Leave at front door if not home'
-        );
-        expect(checkoutWithShipping.shippingInstruction?.pickupPoint).toBe(
-          '4190asx141'
-        );
-        expect(
-          checkoutWithShipping.shippingInstruction?.consentForUnattendedDelivery
-        ).toBe(true);
-      });
-
-      xit('wont report it finalizable until everything is paid/authorized', async () => {
-        expect(checkout.readyForFinalization).toBe(false);
-        const pm = (
-          await provider.getAvailablePaymentMethods(
-            {
-              checkout: checkout.identifier,
-            },
-            reqCtx
-          )
-        ).find((x) => x.identifier.method === 'stripe');
-        expect(pm).toBeDefined();
-
-        const checkoutWithPi = await provider.addPaymentInstruction(
-          {
-            checkout: checkout.identifier,
-            paymentInstruction: PaymentInstructionSchema.parse({
-              paymentMethod: pm?.identifier,
-              amount: checkout.price.grandTotal,
-              protocolData: [{ key: 'test-key', value: 'test-value' }],
-            }),
-          },
-          reqCtx
-        );
-
-        // do something to simulate payment authorization ?
-        const checkoutReady = await provider.getById(
-          { identifier: checkoutWithPi.identifier },
-          reqCtx
-        );
-        if (!checkoutReady) {
-          fail('checkout not found');
-        }
-        expect(checkoutReady.readyForFinalization).toBe(true);
-      });
-    });
-  });
-});

package/providers/commercetools/src/test/identity.provider.spec.ts

@@ -1,88 +0,0 @@
-import 'dotenv/config';
-import type { RequestContext } from '@reactionary/core';
-import {
-  CartSchema,
-  IdentitySchema,
-  NoOpCache,
-  createInitialRequestContext,
-} from '@reactionary/core';
-import { getCommercetoolsTestConfiguration } from './test-utils';
-import { CommercetoolsIdentityProvider } from '../providers/identity.provider';
-import { CommercetoolsCartProvider } from '../providers/cart.provider';
-
-describe('Commercetools Identity Provider', () => {
-  let provider: CommercetoolsIdentityProvider;
-  let cartProvider: CommercetoolsCartProvider;
-  let reqCtx: RequestContext;
-
-  beforeAll(() => {
-    provider = new CommercetoolsIdentityProvider(
-      getCommercetoolsTestConfiguration(),
-      IdentitySchema,
-      new NoOpCache()
-    );
-
-    cartProvider = new CommercetoolsCartProvider(
-      getCommercetoolsTestConfiguration(),
-      CartSchema,
-      new NoOpCache()
-    );
-  });
-
-  beforeEach(async () => {
-    reqCtx = createInitialRequestContext();
-  });
-
-  it('should default to an anonymous identity if no operations have been performed', async () => {
-    const identity = await provider.getSelf({}, reqCtx);
-
-    expect(identity.type).toBe('Anonymous');
-  });
-
-  it('should automatically upgrade to guest the moment an operation is performed', async () => {
-    const cart = await cartProvider.getActiveCartId(reqCtx);
-    const updatedCart = await cartProvider.add(
-      {
-        cart,
-        quantity: 1,
-        sku: {
-          key: 'SGB-01',
-        },
-      },
-      reqCtx
-    );
-
-    const identity = await provider.getSelf({}, reqCtx);
-
-    expect(identity.type).toBe('Guest');
-  });
-
-  it('should be able to register a new customer', async () => {
-    const time = new Date().getTime();
-    const identity = await provider.register(
-      {
-        username: `test-user+${time}@example.com`,
-        password: 'love2test',
-      },
-      reqCtx
-    );
-
-    expect(identity.type).toBe('Registered');
-  });
-
-  it('should be able to log out from a Registered identity', async () => {
-    const time = new Date().getTime();
-    const identity = await provider.register(
-      {
-        username: `test-user+${time}@example.com`,
-        password: 'love2test',
-      },
-      reqCtx
-    );
-
-    expect(identity.type).toBe('Registered');
-
-    const loggedOutIdentity = await provider.logout({}, reqCtx);
-    expect(loggedOutIdentity.type).toBe('Anonymous');
-  });
-});

package/providers/commercetools/src/test/inventory.provider.spec.ts

@@ -1,41 +0,0 @@
-import 'dotenv/config';
-import type { RequestContext } from '@reactionary/core';
-import {
-  InventorySchema,
-  NoOpCache,
-  createInitialRequestContext,
-} from '@reactionary/core';
-import { getCommercetoolsTestConfiguration } from './test-utils';
-import { CommercetoolsInventoryProvider } from '../providers/inventory.provider';
-
-describe('Commercetools Inventory Provider', () => {
-  let provider: CommercetoolsInventoryProvider;
-  let reqCtx: RequestContext;
-
-  beforeAll(() => {
-    provider = new CommercetoolsInventoryProvider(
-      getCommercetoolsTestConfiguration(),
-      InventorySchema,
-      new NoOpCache()
-    );
-  });
-
-  beforeEach(() => {
-    reqCtx = createInitialRequestContext();
-  });
-
-  it('should be able to fetch inventory for a given SKU and Fulfillment Center', async () => {
-    const inventory = await provider.getBySKU({
-        sku: {
-            key: 'GMCT-01'
-        },
-        fulfilmentCenter: {
-            key: 'solteqPhysicalStore'
-        }
-    }, reqCtx);
-
-    expect(inventory.identifier.sku.key).toBe('GMCT-01');
-    expect(inventory.identifier.fulfillmentCenter.key).toBe('solteqPhysicalStore');
-    expect(inventory.quantity).toBe(42);
-  });
-});

package/providers/commercetools/src/test/price.provider.spec.ts

@@ -1,81 +0,0 @@
-import 'dotenv/config';
-
-
-import type { RequestContext} from '@reactionary/core';
-import { NoOpCache, PriceSchema, Session, createInitialRequestContext,} from '@reactionary/core';
-import {   getCommercetoolsTestConfiguration } from './test-utils';
-
-import { CommercetoolsPriceProvider } from '../providers/price.provider';
-
-const testData = {
-  skuWithoutTiers: 'SGB-01',
-  skuWithTiers: 'GMCT-01'
-}
-
-
-describe('Commercetools Price Provider', () => {
-  let provider: CommercetoolsPriceProvider;
-  let reqCtx: RequestContext;
-
-
-
-  beforeAll( () => {
-    provider = new CommercetoolsPriceProvider(getCommercetoolsTestConfiguration(), PriceSchema, new NoOpCache());
-  });
-
-  beforeEach( () => {
-    reqCtx = createInitialRequestContext()
-  })
-
-  it('should be able to get prices for a product without tiers', async () => {
-    const result = await provider.getBySKU({ sku: { key: testData.skuWithoutTiers }}, reqCtx);
-
-    expect(result).toBeTruthy();
-    if (result) {
-      expect(result.identifier.sku.key).toBe(testData.skuWithoutTiers);
-      expect(result.unitPrice.value).toBeGreaterThan(0);
-      expect(result.unitPrice.currency).toBe('USD');
-      expect(result.tieredPrices.length).toBe(0);
-    }
-  });
-
-  xit('should be able to get prices for a product with tiers', async () => {
-    const result = await provider.getBySKU({ sku: { key: testData.skuWithTiers }}, reqCtx);
-
-    expect(result).toBeTruthy();
-    if (result) {
-      expect(result.identifier.sku.key).toBe(testData.skuWithTiers);
-      expect(result.unitPrice.value).toBeGreaterThan(0);
-      expect(result.unitPrice.currency).toBe('USD');
-      expect(result.tieredPrices.length).toBeGreaterThan(0);
-
-      expect(result.tieredPrices[0].minimumQuantity).toBeGreaterThan(0);
-      expect(result.tieredPrices[0].price.value).toBeLessThanOrEqual(result.unitPrice.value);
-      expect(result.tieredPrices[0].price.currency).toBe('USD');
-
-    }
-  });
-
-  it('should return a placeholder price for an unknown SKU', async () => {
-    const result = await provider.getBySKU({ sku: { key: 'unknown-sku' }}, reqCtx);
-
-    expect(result).toBeTruthy();
-    if (result) {
-      expect(result.identifier.sku.key).toBe('unknown-sku');
-      expect(result.unitPrice.value).toBe(-1);
-      expect(result.unitPrice.currency).toBe('USD');
-      expect(result.tieredPrices.length).toBe(0);
-      expect(result.meta?.placeholder).toBe(true);
-    }
-  });
-
-  it('can look up multiple prices at once', async () => {
-    const skus = [testData.skuWithTiers, testData.skuWithoutTiers, 'unknown-sku'];
-    const results = await Promise.all(skus.map( sku => provider.getBySKU({ sku: { key: sku }}, reqCtx)));
-
-    expect(results).toHaveLength(skus.length);
-    expect(results[0].identifier.sku.key).toBe(testData.skuWithTiers);
-    expect(results[1].identifier.sku.key).toBe(testData.skuWithoutTiers);
-    expect(results[2].identifier.sku.key).toBe('unknown-sku');
-  });
-});