@reactionary/source 0.0.37 → 0.0.39

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

@@ -0,0 +1,119 @@
+import 'dotenv/config';
+import { CartSchema, CategorySchema, IdentitySchema, NoOpCache, ProductSchema, Session } from '@reactionary/core';
+import { createAnonymousTestSession, getCommercetoolsTestConfiguration } from './test-utils';
+import { CommercetoolsCartProvider } from '../providers/cart.provider';
+import { CommercetoolsIdentityProvider } from '../providers/identity.provider';
+describe('Commercetools Cart Provider', () => {
+  let provider: CommercetoolsCartProvider;
+  let identityProvider: CommercetoolsIdentityProvider;
+  let session: Session;
+
+  beforeAll( () => {
+    provider = new CommercetoolsCartProvider(getCommercetoolsTestConfiguration(), CartSchema, new NoOpCache());
+    identityProvider = new CommercetoolsIdentityProvider(getCommercetoolsTestConfiguration(), IdentitySchema, new NoOpCache());
+  });
+
+  beforeEach( () => {
+    session = createAnonymousTestSession()
+  });
+
+  describe('anonymous sessions', () => {
+    it('should be able to get an empty cart', async () => {
+      const cart = await provider.getById({
+        cart: { key: '' },
+      }, session);
+
+      expect(cart.identifier.key).toBeFalsy();
+      expect(cart.items.length).toBe(0);
+      expect(cart.meta?.placeholder).toBe(true);
+
+    });
+
+    it('should be able to add an item to a cart', async () => {
+      const cart = await provider.add({
+          cart: { key: '' },
+          product: {
+            key: '4d28f98d-c446-446e-b59a-d9f718e5b98a',
+          },
+          quantity: 1
+      }, session);
+
+      expect(cart.identifier.key).toBeDefined();
+      expect(cart.items.length).toBe(1);
+      expect(cart.items[0].product.key).toBe('4d28f98d-c446-446e-b59a-d9f718e5b98a');
+      expect(cart.items[0].quantity).toBe(1);
+
+      expect(cart.items[0].price.totalPrice.value).toBeGreaterThan(0);
+      expect(cart.items[0].price.totalPrice.currency).toBe(session.languageContext.currencyCode);
+
+      expect(cart.price.grandTotal.value).toBeGreaterThan(0);
+      expect(cart.price.grandTotal.currency).toBe(session.languageContext.currencyCode);
+
+      expect(cart.price.grandTotal.value).toBe(cart.items[0].price.totalPrice.value);
+
+
+      expect(cart.meta?.placeholder).toBeFalsy();
+
+    });
+
+
+    it('should be able to change quantity of an item in a cart', async () => {
+
+      const cart = await provider.add({
+          cart: { key: '' },
+          product: {
+            key: '4d28f98d-c446-446e-b59a-d9f718e5b98a',
+          },
+          quantity: 1
+      }, session);
+
+      const updatedCart = await provider.changeQuantity({
+        cart: cart.identifier,
+        item: cart.items[0].identifier,
+        quantity: 3
+      }, session);
+
+      expect(updatedCart.identifier.key).toBe(cart.identifier.key);
+      expect(updatedCart.items.length).toBe(1);
+      expect(updatedCart.items[0].product.key).toBe('4d28f98d-c446-446e-b59a-d9f718e5b98a');
+      expect(updatedCart.items[0].quantity).toBe(3);
+
+      expect(updatedCart.items[0].price.totalPrice.value).toBe(cart.items[0].price.totalPrice.value * 3);
+      expect(updatedCart.items[0].price.unitPrice.value).toBe(cart.items[0].price.unitPrice.value);
+
+
+    });
+
+    it('should be able to remove an item from a cart', async () => {
+
+      const cart = await provider.add({
+          cart: { key: '' },
+          product: {
+            key: '4d28f98d-c446-446e-b59a-d9f718e5b98a',
+          },
+          quantity: 1
+      }, session);
+
+      const updatedCart = await provider.remove({
+        cart: cart.identifier,
+        item: cart.items[0].identifier,
+      }, session);
+      expect(updatedCart.identifier.key).toBe(cart.identifier.key);
+      expect(updatedCart.items.length).toBe(0);
+    });
+
+    /**
+    it('should be able to create a cart for an anonymous user, then login and merge the cart', async () => {
+    });
+
+    it('should be able to create a cart for an anonymous user, then register and merge the cart', async () => {
+    });
+
+    it('should be able to clear the cart', async () => { });
+
+    it('should be able to check out the cart', async () => { });
+    */
+
+  });
+
+});

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

@@ -0,0 +1,180 @@
+import 'dotenv/config'
+
+    import { diag, DiagConsoleLogger, DiagLogLevel } from '@opentelemetry/api';
+
+import { CategorySchema, NoOpCache, ProductSchema, Session } from '@reactionary/core';
+import { CommercetoolsCategoryProvider } from '../providers/category.provider';
+import { createAnonymousTestSession, getCommercetoolsTestConfiguration } from './test-utils';
+import { getTracer, shutdownOtel } from '@reactionary/otel';
+
+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 session: Session;
+
+  beforeAll( () => {
+    provider = new CommercetoolsCategoryProvider(getCommercetoolsTestConfiguration(), CategorySchema, new NoOpCache());
+  });
+
+  beforeEach( () => {
+    session = createAnonymousTestSession()
+  })
+
+  it('should be able to get top-categories', async () => {
+    const result = await provider.findTopCategories({ paginationOptions: { pageSize: 10, pageNumber: 1 }}, session);
+
+    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 }}, session);
+
+    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 }}, session);
+
+    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 }}, session);
+
+    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! } }, session);
+
+    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! }, session);
+    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' }, session);
+    expect(result).toBeNull();
+  });
+
+
+
+  it('should be able to get a category by id', async () => {
+    const result = await provider.getById({ id: { key: 'home-decor'}}, session);
+
+    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 () => {
+
+    session.languageContext.locale = 'de-DE';
+    const result = await provider.getById({ id: { key: 'home-decor'}}, session);
+
+    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 () => {
+
+    session.languageContext.locale = 'fr-FR';
+    const result = await provider.getById({ id: { key: 'home-decor'}}, session);
+
+    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'}}, session);
+    expect(result.identifier.key).toBe('non-existent-category');
+    expect(result.meta.placeholder).toBe(true);
+
+  });
+
+  it('traces execution of getById', async () => {
+    const tracer = getTracer();
+    const span = tracer.startSpan('test-span');
+    const result = await provider.getById({ id: { key: 'home-decor'}}, session);
+    span.end();
+    await shutdownOtel();
+  });
+
+});

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

@@ -0,0 +1,80 @@
+import 'dotenv/config';
+
+
+import { NoOpCache, PriceSchema, Session } from '@reactionary/core';
+import { createAnonymousTestSession, 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 session: Session;
+
+
+
+  beforeAll( () => {
+    provider = new CommercetoolsPriceProvider(getCommercetoolsTestConfiguration(), PriceSchema, new NoOpCache());
+  });
+
+  beforeEach( () => {
+    session = createAnonymousTestSession()
+  })
+
+  it('should be able to get prices for a product without tiers', async () => {
+    const result = await provider.getBySKU({ sku: { key: testData.skuWithoutTiers }}, session);
+
+    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);
+    }
+  });
+
+  it('should be able to get prices for a product with tiers', async () => {
+    const result = await provider.getBySKU({ sku: { key: testData.skuWithTiers }}, session);
+
+    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' }}, session);
+
+    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 }}, session)));
+
+    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');
+  });
+});

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

@@ -1,20 +1,35 @@
-import { ProductSchema } from '@reactionary/core';
+import 'dotenv/config';
+import { NoOpCache, ProductSchema, Session } from '@reactionary/core';
 import { CommercetoolsProductProvider } from '../providers/product.provider';
+import { createAnonymousTestSession, getCommercetoolsTestConfiguration } from './test-utils';
+
+const testData = {
+  product : {
+    id: '4d28f98d-c446-446e-b59a-d9f718e5b98a',
+    name: 'Sunnai Glass Bowl',
+    image: 'https://storage.googleapis.com/merchant-center-europe/sample-data/goodstore/Sunnai_Glass_Bowl-1.1.jpeg'
+  }
+}
 
 describe('Commercetools Product Provider', () => {
+
+    let provider: CommercetoolsProductProvider;
+    let session: Session;
+
+    beforeAll( () => {
+      provider = new CommercetoolsProductProvider(getCommercetoolsTestConfiguration(), ProductSchema, new NoOpCache());
+    });
+
+    beforeEach( () => {
+      session = createAnonymousTestSession()
+    })
+
+
   it('should be able to get a product by id', async () => {
-    const provider = new CommercetoolsProductProvider({
-        apiUrl: process.env['COMMERCETOOLS_API_URL'] || '',
-        authUrl: process.env['COMMERCETOOLS_AUTH_URL'] || '',
-        clientId: process.env['COMMERCETOOLS_CLIENT_ID'] || '',
-        clientSecret: process.env['COMMERCETOOLS_CLIENT_SECRET'] || '',
-        projectKey: process.env['COMMERCETOOLS_PROJECT_KEY'] || ''
-    }, ProductSchema);
-
-    const result = await provider.get({ id: '4d28f98d-c446-446e-b59a-d9f718e5b98a'});
-
-    expect(result.identifier.key).toBe('4d28f98d-c446-446e-b59a-d9f718e5b98a');
-    expect(result.name).toBe('Sunnai Glass Bowl');
-    expect(result.image).toBe('https://storage.googleapis.com/merchant-center-europe/sample-data/goodstore/Sunnai_Glass_Bowl-1.1.jpeg');
+    const result = await provider.getById( { id: testData.product.id }, session);
+
+    expect(result.identifier.key).toBe(testData.product.id);
+    expect(result.name).toBe(testData.product.name);
+    expect(result.image).toBe(testData.product.image);
   });
 });

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

@@ -1,18 +1,60 @@
-import { SearchResultSchema } from '@reactionary/core';
+import 'dotenv/config';
+import { NoOpCache, SearchResultSchema, Session } from '@reactionary/core';
 import { CommercetoolsSearchProvider } from '../providers/search.provider';
+import { getCommercetoolsTestConfiguration, createAnonymousTestSession } from './test-utils';
+
+const testData = {
+  searchTerm: 'bowl'
+}
 
 describe('Commercetools Search Provider', () => {
+
+  let provider: CommercetoolsSearchProvider;
+  let session: Session;
+
+  beforeAll( () => {
+    provider = new CommercetoolsSearchProvider(getCommercetoolsTestConfiguration(), SearchResultSchema, new NoOpCache());
+  });
+
+  beforeEach( () => {
+    session = createAnonymousTestSession()
+  })
+
   it('should be able to get a result by term', async () => {
-    const provider = new CommercetoolsSearchProvider({
-      apiUrl: process.env['COMMERCETOOLS_API_URL'] || '',
-      authUrl: process.env['COMMERCETOOLS_AUTH_URL'] || '',
-      clientId: process.env['COMMERCETOOLS_CLIENT_ID'] || '',
-      clientSecret: process.env['COMMERCETOOLS_CLIENT_SECRET'] || '',
-      projectKey: process.env['COMMERCETOOLS_PROJECT_KEY'] || '',
-    }, SearchResultSchema);
+    const result = await provider.queryByTerm( {
+    search: {
+      term: testData.searchTerm,
+      facets: [],
+      page: 1,
+      pageSize: 10,
+    }}, session);
+
+    expect(result.products.length).toBeGreaterThan(0);
+  });
 
-    const result = await provider.get({ term: 'glass', page: 0, pageSize: 20, facets: [] });
+
+    it('should be able to get a result by term, paged', async () => {
+    const result = await provider.queryByTerm( {
+    search: {
+      term: testData.searchTerm,
+      facets: [],
+      page: 1,
+      pageSize: 1,
+    }}, session);
 
     expect(result.products.length).toBeGreaterThan(0);
+    expect(result.pages).toBeGreaterThan(1);
+
+    const result2 = await provider.queryByTerm( {
+    search: {
+      term: testData.searchTerm,
+      facets: [],
+      page: 2,
+      pageSize: 1,
+    }}, session);
+
+    expect(result2.products.length).toBeGreaterThan(0);
+    expect(result2.pages).toBeGreaterThan(2);
+    expect(result2.products[0].identifier.key).not.toBe(result.products[0].identifier.key);
   });
 });

package/providers/commercetools/src/test/test-utils.ts

@@ -0,0 +1,35 @@
+import { Session } from "@reactionary/core";
+
+export function getCommercetoolsTestConfiguration() {
+  return {
+        apiUrl: process.env['COMMERCETOOLS_API_URL'] || '',
+        authUrl: process.env['COMMERCETOOLS_AUTH_URL'] || '',
+        clientId: process.env['COMMERCETOOLS_CLIENT_ID'] || '',
+        clientSecret: process.env['COMMERCETOOLS_CLIENT_SECRET'] || '',
+        projectKey: process.env['COMMERCETOOLS_PROJECT_KEY'] || ''
+    }
+}
+export function createAnonymousTestSession(): Session {
+  return {
+    id: 'test-session-id',
+    identity: {
+      type: 'Anonymous',
+      meta: {
+        cache: { hit: false, key: '' },
+        placeholder: false,
+      },
+      id: '',
+      token: undefined,
+      issued: new Date(),
+      expiry: new Date(new Date().getTime() + 3600 * 1000), // 1 hour from now
+    },
+    languageContext: {
+      locale: 'en-US',
+      currencyCode: 'USD',
+      countryCode: 'US',
+    },
+    storeIdentifier: {
+      key: 'the-good-store',
+    },
+  };
+}

package/providers/commercetools/tsconfig.lib.json

@@ -6,5 +6,5 @@
     "types": ["node"]
   },
   "include": ["src/**/*.ts"],
-  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"]
+  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts", "src/**/test-utils.ts"]
 }

package/providers/fake/jest.config.ts

@@ -0,0 +1,10 @@
+export default {
+  displayName: 'provider-faker',
+  preset: '../../jest.preset.js',
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
+  },
+  moduleFileExtensions: ['ts', 'js', 'html'],
+  coverageDirectory: '../../coverage/providers/fake',
+};

package/providers/fake/src/core/initialize.ts

@@ -1,13 +1,17 @@
-import { ProductSchema, SearchResultSchema, Cache as ReactinaryCache, ProductProvider, SearchProvider, IdentityProvider } from "@reactionary/core";
+import { ProductSchema, SearchResultSchema, Cache as ReactinaryCache, ProductProvider, SearchProvider, IdentityProvider, CategorySchema, CategoryProvider, CartSchema, CartProvider } from "@reactionary/core";
 import { FakeProductProvider } from "../providers/product.provider";
 import { FakeSearchProvider } from "../providers/search.provider";
 import { FakeConfiguration } from "../schema/configuration.schema";
 import { FakeCapabilities } from "../schema/capabilities.schema";
+import { FakeCategoryProvider } from "../providers/category.provider";
+import { FakeCartProvider } from "../providers";
 
 type FakeClient<T extends FakeCapabilities> = Partial<{
+    cart: T['cart'] extends true ? CartProvider : never;
     product: T['product'] extends true ? ProductProvider : never;
     search: T['search'] extends true ? SearchProvider : never;
     identity: T['identity'] extends true ? IdentityProvider : never;
+    category: T['category'] extends true ? CategoryProvider : never;
 }>;
 
 export function withFakeCapabilities<T extends FakeCapabilities>(configuration: FakeConfiguration, capabilities: T) {
@@ -22,6 +26,16 @@ export function withFakeCapabilities<T extends FakeCapabilities>(configuration:
             client.search = new FakeSearchProvider(configuration, SearchResultSchema, cache);
         }
 
+        if (capabilities.category) {
+          client.category = new FakeCategoryProvider(configuration, CategorySchema, cache);
+        }
+
+
+        if (capabilities.cart) {
+          client.cart = new FakeCartProvider(configuration, CartSchema, cache);
+        }
+
+
         return client;
     };
 }

package/providers/fake/src/index.ts

@@ -1,12 +1,5 @@
 export * from './core/initialize';
 
-export * from './providers/analytics.provider';
-export * from './providers/cart.provider';
-export * from './providers/identity.provider';
-export * from './providers/inventory.provider';
-export * from './providers/price.provider';
-export * from './providers/product.provider';
-export * from './providers/search.provider';
-
+export * from './providers/'
 export * from './schema/capabilities.schema';
-export * from './schema/configuration.schema';
+export * from './schema/configuration.schema';