@reactionary/source 0.0.41 → 0.0.48

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

@@ -1,12 +1,20 @@
 import 'dotenv/config';
-import { CartSchema, CategorySchema, IdentitySchema, NoOpCache, ProductSchema, Session } from '@reactionary/core';
-import { createAnonymousTestSession, getCommercetoolsTestConfiguration } from './test-utils';
+import type { RequestContext} from '@reactionary/core';
+import { CartSchema, IdentitySchema, NoOpCache, createInitialRequestContext } from '@reactionary/core';
+import { getCommercetoolsTestConfiguration } from './test-utils';
 import { CommercetoolsCartProvider } from '../providers/cart.provider';
 import { CommercetoolsIdentityProvider } from '../providers/identity.provider';
+
+
+const testData = {
+  skuWithoutTiers: 'SGB-01',
+  skuWithTiers: 'GMCT-01'
+}
+
 describe('Commercetools Cart Provider', () => {
   let provider: CommercetoolsCartProvider;
   let identityProvider: CommercetoolsIdentityProvider;
-  let session: Session;
+  let reqCtx: RequestContext;
 
   beforeAll( () => {
     provider = new CommercetoolsCartProvider(getCommercetoolsTestConfiguration(), CartSchema, new NoOpCache());
@@ -14,14 +22,14 @@ describe('Commercetools Cart Provider', () => {
   });
 
   beforeEach( () => {
-    session = createAnonymousTestSession()
+    reqCtx = createInitialRequestContext()
   });
 
   describe('anonymous sessions', () => {
     it('should be able to get an empty cart', async () => {
       const cart = await provider.getById({
         cart: { key: '' },
-      }, session);
+      }, reqCtx);
 
       expect(cart.identifier.key).toBeFalsy();
       expect(cart.items.length).toBe(0);
@@ -32,22 +40,22 @@ describe('Commercetools Cart Provider', () => {
     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',
+          sku: {
+            key: testData.skuWithoutTiers,
           },
           quantity: 1
-      }, session);
+      }, reqCtx);
 
       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].sku.key).toBe(testData.skuWithoutTiers);
       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.items[0].price.totalPrice.currency).toBe(reqCtx.languageContext.currencyCode);
 
       expect(cart.price.grandTotal.value).toBeGreaterThan(0);
-      expect(cart.price.grandTotal.currency).toBe(session.languageContext.currencyCode);
+      expect(cart.price.grandTotal.currency).toBe(reqCtx.languageContext.currencyCode);
 
       expect(cart.price.grandTotal.value).toBe(cart.items[0].price.totalPrice.value);
 
@@ -56,26 +64,51 @@ describe('Commercetools Cart Provider', () => {
 
     });
 
+    it('can add multiple different items to a cart', async () => {
+
+      const cart = await provider.add({
+          cart: { key: '' },
+          sku: {
+            key: testData.skuWithoutTiers,
+          },
+          quantity: 1
+      }, reqCtx);
+
+
+      const updatedCart = await provider.add({
+          cart: cart.identifier,
+          sku: {
+            key: testData.skuWithTiers,
+          },
+          quantity: 2
+      }, reqCtx);
+
+      expect(updatedCart.items.length).toBe(2);
+      expect(updatedCart.items[0].sku.key).toBe(testData.skuWithoutTiers);
+      expect(updatedCart.items[0].quantity).toBe(1);
+      expect(updatedCart.items[1].sku.key).toBe(testData.skuWithTiers);
+      expect(updatedCart.items[1].quantity).toBe(2);
+    });
 
     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',
+          sku: {
+            key: testData.skuWithoutTiers,
           },
           quantity: 1
-      }, session);
+      }, reqCtx);
 
       const updatedCart = await provider.changeQuantity({
         cart: cart.identifier,
         item: cart.items[0].identifier,
         quantity: 3
-      }, session);
+      }, reqCtx);
+
 
-      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].sku.key).toBe(testData.skuWithoutTiers);
       expect(updatedCart.items[0].quantity).toBe(3);
 
       expect(updatedCart.items[0].price.totalPrice.value).toBe(cart.items[0].price.totalPrice.value * 3);
@@ -88,20 +121,47 @@ describe('Commercetools Cart Provider', () => {
 
       const cart = await provider.add({
           cart: { key: '' },
-          product: {
-            key: '4d28f98d-c446-446e-b59a-d9f718e5b98a',
+          sku: {
+            key: testData.skuWithoutTiers,
           },
           quantity: 1
-      }, session);
+      }, reqCtx);
 
       const updatedCart = await provider.remove({
         cart: cart.identifier,
         item: cart.items[0].identifier,
-      }, session);
-      expect(updatedCart.identifier.key).toBe(cart.identifier.key);
+      }, reqCtx);
+
       expect(updatedCart.items.length).toBe(0);
     });
 
+    it('should be able to delete a cart', async () => {
+
+      const cart = await provider.add({
+          cart: { key: '' },
+          sku: {
+            key: testData.skuWithoutTiers,
+          },
+          quantity: 1
+      }, reqCtx);
+
+      expect(cart.items.length).toBe(1);
+      expect(cart.identifier.key).toBeTruthy();
+
+      const deletedCart = await provider.deleteCart({
+        cart: cart.identifier,
+      }, reqCtx);
+
+      expect(deletedCart.items.length).toBe(0);
+      expect(deletedCart.identifier.key).toBe('');
+
+      const originalCart = await provider.getById({
+        cart: cart.identifier,
+      }, reqCtx);
+
+      expect(originalCart.items.length).toBe(0);
+    });
+
     /**
     it('should be able to create a cart for an anonymous user, then login and merge the cart', async () => {
     });

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

@@ -1,7 +1,8 @@
 import 'dotenv/config'
-import { CategorySchema, NoOpCache, Session } from '@reactionary/core';
+import type { RequestContext} from '@reactionary/core';
+import { CategorySchema, NoOpCache, Session , createInitialRequestContext} from '@reactionary/core';
 import { CommercetoolsCategoryProvider } from '../providers/category.provider';
-import { createAnonymousTestSession, getCommercetoolsTestConfiguration } from './test-utils';
+import { getCommercetoolsTestConfiguration } from './test-utils';
 
 const testData = {
   topCategories: [
@@ -24,18 +25,18 @@ const testData = {
 
 describe('Commercetools Category Provider', () => {
   let provider: CommercetoolsCategoryProvider;
-  let session: Session;
+  let reqCtx: RequestContext;
 
   beforeAll( () => {
     provider = new CommercetoolsCategoryProvider(getCommercetoolsTestConfiguration(), CategorySchema, new NoOpCache());
   });
 
   beforeEach( () => {
-    session = createAnonymousTestSession()
+    reqCtx = createInitialRequestContext()
   })
 
   it('should be able to get top-categories', async () => {
-    const result = await provider.findTopCategories({ paginationOptions: { pageSize: 10, pageNumber: 1 }}, session);
+    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);
@@ -46,7 +47,7 @@ describe('Commercetools Category Provider', () => {
   });
 
   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);
+    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);
@@ -59,7 +60,7 @@ describe('Commercetools Category Provider', () => {
 
 
   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);
+    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);
@@ -69,7 +70,7 @@ describe('Commercetools Category Provider', () => {
     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);
+    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);
@@ -83,7 +84,7 @@ describe('Commercetools Category Provider', () => {
 
   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);
+    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++) {
@@ -94,7 +95,7 @@ describe('Commercetools Category Provider', () => {
 
   it('should be able to get a category by slug', async () => {
 
-    const result = await provider.getBySlug({ slug: testData.topCategories[0].slug! }, session);
+    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);
@@ -107,14 +108,14 @@ describe('Commercetools Category Provider', () => {
   });
 
   it('returns null if looking for slug that does not exist', async () => {
-    const result = await provider.getBySlug({ slug: 'non-existent-slug' }, session);
+    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'}}, session);
+    const result = await provider.getById({ id: { key: 'home-decor'}}, reqCtx);
 
     expect(result.identifier.key).toBe('home-decor');
     expect(result.name).toBe('Home Decor');
@@ -128,8 +129,8 @@ describe('Commercetools Category Provider', () => {
 
  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);
+    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');
@@ -144,8 +145,8 @@ describe('Commercetools Category Provider', () => {
 
   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);
+    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');
@@ -159,7 +160,7 @@ describe('Commercetools Category Provider', () => {
 
 
   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);
+    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/identity.provider.spec.ts

@@ -0,0 +1,88 @@
+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

@@ -0,0 +1,41 @@
+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,8 +1,9 @@
 import 'dotenv/config';
 
 
-import { NoOpCache, PriceSchema, Session } from '@reactionary/core';
-import { createAnonymousTestSession, getCommercetoolsTestConfiguration } from './test-utils';
+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';
 
@@ -14,7 +15,7 @@ const testData = {
 
 describe('Commercetools Price Provider', () => {
   let provider: CommercetoolsPriceProvider;
-  let session: Session;
+  let reqCtx: RequestContext;
 
 
 
@@ -23,11 +24,11 @@ describe('Commercetools Price Provider', () => {
   });
 
   beforeEach( () => {
-    session = createAnonymousTestSession()
+    reqCtx = createInitialRequestContext()
   })
 
   it('should be able to get prices for a product without tiers', async () => {
-    const result = await provider.getBySKU({ sku: { key: testData.skuWithoutTiers }}, session);
+    const result = await provider.getBySKU({ sku: { key: testData.skuWithoutTiers }}, reqCtx);
 
     expect(result).toBeTruthy();
     if (result) {
@@ -39,7 +40,7 @@ describe('Commercetools Price Provider', () => {
   });
 
   it('should be able to get prices for a product with tiers', async () => {
-    const result = await provider.getBySKU({ sku: { key: testData.skuWithTiers }}, session);
+    const result = await provider.getBySKU({ sku: { key: testData.skuWithTiers }}, reqCtx);
 
     expect(result).toBeTruthy();
     if (result) {
@@ -56,7 +57,7 @@ describe('Commercetools Price Provider', () => {
   });
 
   it('should return a placeholder price for an unknown SKU', async () => {
-    const result = await provider.getBySKU({ sku: { key: 'unknown-sku' }}, session);
+    const result = await provider.getBySKU({ sku: { key: 'unknown-sku' }}, reqCtx);
 
     expect(result).toBeTruthy();
     if (result) {
@@ -70,7 +71,7 @@ describe('Commercetools Price Provider', () => {
 
   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)));
+    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);

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

@@ -1,7 +1,8 @@
 import 'dotenv/config';
-import { NoOpCache, ProductSchema, Session } from '@reactionary/core';
+import type { RequestContext} from '@reactionary/core';
+import { NoOpCache, ProductSchema, Session, createInitialRequestContext } from '@reactionary/core';
 import { CommercetoolsProductProvider } from '../providers/product.provider';
-import { createAnonymousTestSession, getCommercetoolsTestConfiguration } from './test-utils';
+import {  getCommercetoolsTestConfiguration } from './test-utils';
 
 const testData = {
   product : {
@@ -14,22 +15,49 @@ const testData = {
 describe('Commercetools Product Provider', () => {
 
     let provider: CommercetoolsProductProvider;
-    let session: Session;
+    let reqCtx: RequestContext;
 
     beforeAll( () => {
       provider = new CommercetoolsProductProvider(getCommercetoolsTestConfiguration(), ProductSchema, new NoOpCache());
     });
 
     beforeEach( () => {
-      session = createAnonymousTestSession()
+      reqCtx = createInitialRequestContext()
     })
 
 
   it('should be able to get a product by id', async () => {
-    const result = await provider.getById( { id: testData.product.id }, session);
+    const result = await provider.getById( { id: testData.product.id }, reqCtx);
 
+    expect(result).toBeTruthy();
     expect(result.identifier.key).toBe(testData.product.id);
+    expect(result.meta.placeholder).toBe(false);
     expect(result.name).toBe(testData.product.name);
     expect(result.image).toBe(testData.product.image);
   });
+
+  it('should be able to get a product by slug', async () => {
+    const result = await provider.getBySlug( { slug: 'sunnai-glass-bowl' }, reqCtx);
+
+    expect(result).toBeTruthy();
+    if (result) {
+      expect(result.meta.placeholder).toBe(false);
+      expect(result.identifier.key).toBe(testData.product.id);
+      expect(result.name).toBe(testData.product.name);
+      expect(result.image).toBe(testData.product.image);
+    }
+  });
+
+  it('should return null for unknown slug', async () => {
+    const result = await provider.getBySlug( { slug: 'unknown-slug' }, reqCtx);
+
+    expect(result).toBeNull();
+  });
+
+  it('should return a placeholder product for unknown id', async () => {
+    const result = await provider.getById( { id: 'unknown-id' }, reqCtx);
+
+    expect(result).toBeTruthy();
+    expect(result.meta.placeholder).toBe(true);
+  });
 });

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

@@ -0,0 +1,49 @@
+import 'dotenv/config';
+import type { RequestContext } from '@reactionary/core';
+import {
+  IdentitySchema,
+  NoOpCache,
+  ProfileSchema,
+  createInitialRequestContext,
+} from '@reactionary/core';
+import { getCommercetoolsTestConfiguration } from './test-utils';
+import { CommercetoolsProfileProvider } from '../providers/profile.provider';
+import { CommercetoolsIdentityProvider } from '../providers/identity.provider';
+
+describe('Commercetools Profile Provider', () => {
+  let provider: CommercetoolsProfileProvider;
+  let identityProvider: CommercetoolsIdentityProvider;
+  let reqCtx: RequestContext;
+
+  beforeAll(() => {
+    provider = new CommercetoolsProfileProvider(
+      getCommercetoolsTestConfiguration(),
+      ProfileSchema,
+      new NoOpCache()
+    );
+
+    identityProvider = new CommercetoolsIdentityProvider(
+      getCommercetoolsTestConfiguration(),
+      IdentitySchema,
+      new NoOpCache()
+    );
+  });
+
+  beforeEach(async () => {
+    reqCtx = createInitialRequestContext();
+
+    const time = new Date().getTime();
+
+    await identityProvider.register({
+        username: `martin.rogne+test-${ time }@solteq.com`,
+        password: 'love2test'
+    }, reqCtx);
+  });
+
+  it('should be able to fetch the profile for the current user', async () => {
+    const profile = await provider.getSelf({}, reqCtx);
+
+    expect(profile).toBeDefined();
+    expect(profile.email).toContain('martin.rogne');
+  });
+});

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

@@ -1,7 +1,8 @@
 import 'dotenv/config';
-import { NoOpCache, SearchResultSchema, Session } from '@reactionary/core';
+import type { RequestContext} from '@reactionary/core';
+import { NoOpCache, SearchResultSchema, createInitialRequestContext } from '@reactionary/core';
 import { CommercetoolsSearchProvider } from '../providers/search.provider';
-import { getCommercetoolsTestConfiguration, createAnonymousTestSession } from './test-utils';
+import { getCommercetoolsTestConfiguration } from './test-utils';
 
 const testData = {
   searchTerm: 'bowl'
@@ -10,14 +11,14 @@ const testData = {
 describe('Commercetools Search Provider', () => {
 
   let provider: CommercetoolsSearchProvider;
-  let session: Session;
+  let reqCtx: RequestContext;
 
   beforeAll( () => {
     provider = new CommercetoolsSearchProvider(getCommercetoolsTestConfiguration(), SearchResultSchema, new NoOpCache());
   });
 
   beforeEach( () => {
-    session = createAnonymousTestSession()
+    reqCtx = createInitialRequestContext()
   })
 
   it('should be able to get a result by term', async () => {
@@ -27,7 +28,7 @@ describe('Commercetools Search Provider', () => {
       facets: [],
       page: 1,
       pageSize: 10,
-    }}, session);
+    }}, reqCtx);
 
     expect(result.products.length).toBeGreaterThan(0);
   });
@@ -40,7 +41,7 @@ describe('Commercetools Search Provider', () => {
       facets: [],
       page: 1,
       pageSize: 1,
-    }}, session);
+    }}, reqCtx);
 
     expect(result.products.length).toBeGreaterThan(0);
     expect(result.pages).toBeGreaterThan(1);
@@ -51,7 +52,7 @@ describe('Commercetools Search Provider', () => {
       facets: [],
       page: 2,
       pageSize: 1,
-    }}, session);
+    }}, reqCtx);
 
     expect(result2.products.length).toBeGreaterThan(0);
     expect(result2.pages).toBeGreaterThan(2);