@reactionary/source 0.0.52 → 0.2.16

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

@@ -1,122 +1,173 @@
 import 'dotenv/config';
 import type { RequestContext } from '@reactionary/core';
-import { CategorySchema, MemoryCache , createInitialRequestContext,} from '@reactionary/core';
+import {
+  CategorySchema,
+  MemoryCache,
+  createInitialRequestContext,
+} from '@reactionary/core';
 import { FakeCategoryProvider } from '../providers/index.js';
 import { getFakerTestConfiguration } from './test-utils.js';
+import { describe, expect, it, beforeAll, beforeEach, assert } from 'vitest';
 
 describe('Faker Category Provider', () => {
   let provider: FakeCategoryProvider;
   let reqCtx: RequestContext;
   const cache = new MemoryCache();
 
-  beforeAll(() => {
+  beforeEach(() => {
+    reqCtx = createInitialRequestContext();
+    cache.clear();
+
     provider = new FakeCategoryProvider(
       getFakerTestConfiguration(),
-      CategorySchema,
-      cache
+      cache,
+      reqCtx
     );
   });
 
-  beforeEach( () => {
-    reqCtx = createInitialRequestContext();
-    cache.clear();
-  })
-
   it('should be able to get top-categories', async () => {
-    const result = await provider.findTopCategories({ paginationOptions: { pageSize: 10, pageNumber: 1 }}, reqCtx);
+    const result = await provider.findTopCategories({
+      paginationOptions: { pageSize: 10, pageNumber: 1 },
+    });
+
+    if (!result.success) {
+      assert.fail();
+    }
 
-    expect(result.items.length).toBeGreaterThan(0);
-    expect(result.items[0].identifier.key).toBe('grocery');
-    expect(result.items[0].name).toBe('Grocery');
+    expect(result.value.items.length).toBeGreaterThan(0);
+    expect(result.value.items[0].identifier.key).toBe('grocery');
+    expect(result.value.items[0].name).toBe('Grocery');
 
-    expect(result.items[1].identifier.key).toBe('sports');
-    expect(result.items[1].name).toBe('Sports');
+    expect(result.value.items[1].identifier.key).toBe('sports');
+    expect(result.value.items[1].name).toBe('Sports');
   });
 
   it('should be able to get child categories for a category', async () => {
-    const result = await provider.findChildCategories({ parentId: { key: 'grocery' }, paginationOptions: { pageSize: 10, pageNumber: 1 }}, reqCtx);
+    const result = await provider.findChildCategories({
+      parentId: { key: 'grocery' },
+      paginationOptions: { pageSize: 10, pageNumber: 1 },
+    });
+
+    if (!result.success) {
+      assert.fail();
+    }
 
-    expect(result.items.length).toBeGreaterThan(0);
-    expect(result.items[0].identifier.key).toBe('grocery-0');
-    expect(result.items[0].name).toBe('Grocery-0');
+    expect(result.value.items.length).toBeGreaterThan(0);
+    expect(result.value.items[0].identifier.key).toBe('grocery-0');
+    expect(result.value.items[0].name).toBe('Grocery-0');
 
-    expect(result.items[1].identifier.key).toBe('grocery-1');
-    expect(result.items[1].name).toBe('Grocery-1');
+    expect(result.value.items[1].identifier.key).toBe('grocery-1');
+    expect(result.value.items[1].name).toBe('Grocery-1');
   });
 
   it('should be able to get child categories for a category, paged', async () => {
-    let result = await provider.findChildCategories({ parentId: { key: 'grocery' }, paginationOptions: { pageSize: 1, pageNumber: 1 }}, reqCtx);
-
-    expect(result.items.length).toBeGreaterThan(0);
-    expect(result.items[0].identifier.key).toBe('grocery-0');
-    expect(result.items[0].name).toBe('Grocery-0');
-    expect(result.totalCount).toBeGreaterThan(1);
-    expect(result.totalPages).toEqual(result.totalCount);
-    expect(result.pageSize).toBe(1);
-    expect(result.pageNumber).toBe(1);
-
-    result = await provider.findChildCategories({ parentId: { key: 'grocery' }, paginationOptions: { pageSize: 1, pageNumber: 2 }}, reqCtx);
-
-    expect(result.items.length).toBeGreaterThan(0);
-    expect(result.items[0].identifier.key).toBe('grocery-1');
-    expect(result.items[0].name).toBe('Grocery-1');
-    expect(result.totalCount).toBeGreaterThan(1);
-    expect(result.totalPages).toEqual(result.totalCount);
-    expect(result.pageSize).toBe(1);
-    expect(result.pageNumber).toBe(2);
+    let result = await provider.findChildCategories({
+      parentId: { key: 'grocery' },
+      paginationOptions: { pageSize: 1, pageNumber: 1 },
+    });
+
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result.value.items.length).toBeGreaterThan(0);
+    expect(result.value.items[0].identifier.key).toBe('grocery-0');
+    expect(result.value.items[0].name).toBe('Grocery-0');
+    expect(result.value.totalCount).toBeGreaterThan(1);
+    expect(result.value.totalPages).toEqual(result.value.totalCount);
+    expect(result.value.pageSize).toBe(1);
+    expect(result.value.pageNumber).toBe(1);
+
+    result = await provider.findChildCategories({
+      parentId: { key: 'grocery' },
+      paginationOptions: { pageSize: 1, pageNumber: 2 },
+    });
+
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result.value.items.length).toBeGreaterThan(0);
+    expect(result.value.items[0].identifier.key).toBe('grocery-1');
+    expect(result.value.items[0].name).toBe('Grocery-1');
+    expect(result.value.totalCount).toBeGreaterThan(1);
+    expect(result.value.totalPages).toEqual(result.value.totalCount);
+    expect(result.value.pageSize).toBe(1);
+    expect(result.value.pageNumber).toBe(2);
   });
 
   it('can load all breadcrumbs for a category', async () => {
-    const result = await provider.getBreadcrumbPathToCategory({ id: { key: 'grocery-0-0' } }, reqCtx);
+    const result = await provider.getBreadcrumbPathToCategory({
+      id: { key: 'grocery-0-0' },
+    });
+
+    if (!result.success) {
+      assert.fail();
+    }
 
-    expect(result.length).toBeGreaterThan(2);
-    expect(result[0].identifier.key).toBe('grocery');
-    expect(result[0].name).toBe('Grocery');
-    expect(result[0].slug).toBe('grocery-slug');
+    expect(result.value.length).toBeGreaterThan(2);
+    expect(result.value[0].identifier.key).toBe('grocery');
+    expect(result.value[0].name).toBe('Grocery');
+    expect(result.value[0].slug).toBe('grocery-slug');
 
-    expect(result[1].identifier.key).toBe('grocery-0');
-    expect(result[1].name).toBe('Grocery-0');
-    expect(result[1].slug).toBe('grocery-0-slug');
+    expect(result.value[1].identifier.key).toBe('grocery-0');
+    expect(result.value[1].name).toBe('Grocery-0');
+    expect(result.value[1].slug).toBe('grocery-0-slug');
 
-    expect(result[2].identifier.key).toBe('grocery-0-0');
-    expect(result[2].name).toBe('Grocery-0-0');
-    expect(result[2].slug).toBe('grocery-0-0-slug');
+    expect(result.value[2].identifier.key).toBe('grocery-0-0');
+    expect(result.value[2].name).toBe('Grocery-0-0');
+    expect(result.value[2].slug).toBe('grocery-0-0-slug');
   });
 
   it('should be able to get a category by slug', async () => {
-    const result = await provider.getBySlug({ slug: 'grocery-slug' }, reqCtx);
-    expect(result).toBeTruthy();
-    if (result) {
-      expect(result.identifier.key).toBe('grocery');
-      expect(result.name).toBe('Grocery');
-      expect(result.slug).toBe('grocery-slug');
-      expect(result.parentCategory).toBeUndefined();
-      expect(result.text).not.toBe('');
-      expect(result.meta.placeholder).toBe(false);
+    const result = await provider.getBySlug({ slug: 'grocery-slug' });
+
+    if (!result.success) {
+      assert.fail();
     }
+
+    expect(result.value.identifier.key).toBe('grocery');
+    expect(result.value.name).toBe('Grocery');
+    expect(result.value.slug).toBe('grocery-slug');
+    expect(result.value.parentCategory).toBeUndefined();
+    expect(result.value.text).not.toBe('');
   });
 
-  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('returns NotFound if looking for slug that does not exist', async () => {
+    const result = await provider.getBySlug({ slug: 'non-existent-slug' });
+    
+    if (result.success) {
+      assert.fail();
+    }
+
+    expect(result.error.type).toBe('NotFound');
   });
 
   it('should be able to get a category by id', async () => {
-    const result = await provider.getById({ id: { key: 'grocery'}}, reqCtx);
+    const result = await provider.getById({ id: { key: 'grocery' } });
+    
+    if (!result.success) {
+      assert.fail();
+    }
 
-    expect(result.identifier.key).toBe('grocery');
-    expect(result.name).toBe('Grocery');
-    expect(result.slug).toBe('grocery-slug');
-    expect(result.parentCategory).toBeUndefined();
+    expect(result.value.identifier.key).toBe('grocery');
+    expect(result.value.name).toBe('Grocery');
+    expect(result.value.slug).toBe('grocery-slug');
+    expect(result.value.parentCategory).toBeUndefined();
 
-    expect(result.text).not.toBe('');
-    expect(result.meta.placeholder).toBe(false);
+    expect(result.value.text).not.toBe('');
   });
 
   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);
+    const result = await provider.getById({
+      id: { key: 'non-existent-category' },
+    });
+
+    if (!result.success) {
+      assert.fail();
+    }
+    
+    expect(result.value.identifier.key).toBe('non-existent-category');
   });
 
   describe('caching', () => {
@@ -124,27 +175,34 @@ describe('Faker Category Provider', () => {
     // Perhaps as an integration test
 
     it('should cache the results for byId', async () => {
-      const first = await provider.getById({ id: { key: 'grocery' } }, reqCtx);
-      expect(first.meta.cache.hit).toBe(false);
-
-      const second = await provider.getById(
-        { id: { key: 'grocery' } },
-        reqCtx
-      );
-      expect(second.meta.cache.hit).toBe(true);
+      const first = await provider.getById({ id: { key: 'grocery' } });
+
+      if (!first.success) {
+        assert.fail();
+      }
+
+      const second = await provider.getById({ id: { key: 'grocery' } });
+
+      if (!second.success) {
+        assert.fail();
+      }
     });
 
     it('can clear a cache entry by dependency id', async () => {
-      const first = await provider.getById({ id: { key: 'grocery' } }, reqCtx);
+      const first = await provider.getById({ id: { key: 'grocery' } });
+
+      if (!first.success) {
+        assert.fail();
+      }
 
       const dependencyIds = provider.generateDependencyIdsForModel(first);
       await cache.invalidate(dependencyIds);
 
-      const second = await provider.getById(
-        { id: { key: 'grocery' } },
-        reqCtx
-      );
-      expect(second.meta.cache.hit).toBe(false);
+      const second = await provider.getById({ id: { key: 'grocery' } });
+
+      if (!second.success) {
+        assert.fail();
+      }
     });
   });
 });

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

@@ -0,0 +1,222 @@
+import 'dotenv/config';
+import type { RequestContext } from '@reactionary/core';
+import {
+  CartSchema,
+  IdentitySchema,
+  NoOpCache,
+  createInitialRequestContext,
+} from '@reactionary/core';
+import { getFakerTestConfiguration } from './test-utils.js';
+import { FakeCartProvider } from '../providers/cart.provider.js';
+import { FakeIdentityProvider } from '../providers/index.js';
+import { describe, expect, it, beforeAll, beforeEach, assert } from 'vitest';
+import { FakeCheckoutProvider } from '../providers/checkout.provider.js';
+
+describe('Fake Checkout Provider', () => {
+  let provider: FakeCheckoutProvider;
+  let reqCtx: RequestContext;
+
+  beforeEach(() => {
+    reqCtx = createInitialRequestContext();
+    provider = new FakeCheckoutProvider(
+      getFakerTestConfiguration(),
+      new NoOpCache(),
+      reqCtx
+    );
+  });
+
+  describe('should have operations return structurally valid data', () => {
+    it('for getById', async () => {
+      const result = await provider.getById({
+        identifier: {
+          key: '1234',
+        },
+      });
+
+      if (!result.success) {
+        assert.fail();
+      }
+
+      expect(result.value.identifier.key).toBe('1234');
+    });
+
+    it('for addPaymentInstruction', async () => {
+      const result = await provider.addPaymentInstruction({
+        checkout: {
+          key: '1234',
+        },
+        paymentInstruction: {
+          amount: {
+            currency: 'USD',
+            value: 500,
+          },
+          paymentMethod: {
+            method: 'PayLater',
+            name: 'PayLater',
+            paymentProcessor: 'Fake',
+          },
+          protocolData: [],
+        },
+      });
+
+      if (!result.success) {
+        assert.fail();
+      }
+
+      expect(result.value.identifier.key).toBe('1234');
+    });
+  });
+
+  it('for removePaymentInstruction', async () => {
+    const result = await provider.removePaymentInstruction({
+      checkout: {
+        key: '1234',
+      },
+      paymentInstruction: {
+        key: '1234',
+      },
+    });
+
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result.value.identifier.key).toBe('1234');
+  });
+
+  it('for finalizeCheckout', async () => {
+    const result = await provider.finalizeCheckout({
+      checkout: {
+        key: '1234',
+      },
+    });
+
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result.value.identifier.key).toBe('1234');
+  });
+
+  it('for setShippingAddress', async () => {
+    const result = await provider.setShippingAddress({
+        checkout: {
+            key: '1234'
+        },
+        shippingAddress: {
+            city: 'City',
+            countryCode: 'DK',
+            firstName: 'FirstName',
+            lastName: 'LastName',
+            postalCode: '2300',
+            region: 'Region',
+            streetAddress: 'StreetAddress',
+            streetNumber: '42'
+        }
+    });
+
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result.value.identifier.key).toBe('1234');
+  });
+
+  it('for setShippingInstruction', async () => {
+    const result = await provider.setShippingInstruction({
+        checkout: {
+            key: '1234'
+        },
+        shippingInstruction: {
+            consentForUnattendedDelivery: false,
+            instructions: 'Fake Instructions',
+            pickupPoint: '',
+            shippingMethod: {
+                key: 'Fake Shipping'
+            }
+        }
+    });
+
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result.value.identifier.key).toBe('1234');
+  });
+
+  it('for initiateCheckoutForCart', async () => {
+    const result = await provider.initiateCheckoutForCart({
+      cart: {
+        identifier: {
+            key: '1234'
+        },
+        description: 'Fake Cart',
+        items: [],
+        name: 'Fake Cart',
+        price: {
+            grandTotal: {
+                currency: 'USD',
+                value: 1500
+            },
+            totalDiscount: {
+                currency: 'USD',
+                value: 500
+            },
+            totalProductPrice: {
+                currency: 'USD',
+                value: 1500
+            },
+            totalShipping: {
+                currency: 'USD',
+                value: 500
+            },
+            totalSurcharge: {
+                currency: 'USD',
+                value: 0
+            },
+            totalTax: {
+                currency: 'USD',
+                value: 0
+            }
+        },
+        userId: {
+            userId: 'Fake'
+        }
+      },
+    });
+
+    if (!result.success) {
+      assert.fail(JSON.stringify(result.error));
+    }
+
+    expect(result.value.identifier.key).toBe('1234');
+  });
+
+  it('for getAvailablePaymentMethods', async () => {
+    const result = await provider.getAvailablePaymentMethods({
+      checkout: {
+        key: '1234',
+      },
+    });
+
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result.value.length).toBeGreaterThan(0);
+  });
+
+  it('for getAvailableShippingMethods', async () => {
+    const result = await provider.getAvailableShippingMethods({
+      checkout: {
+        key: '1234',
+      },
+    });
+
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result.value.length).toBeGreaterThan(0);
+  });
+});

package/providers/fake/src/test/order-search.provider.spec.ts

@@ -0,0 +1,50 @@
+import 'dotenv/config';
+import type { RequestContext } from '@reactionary/core';
+import {
+  CartSchema,
+  IdentitySchema,
+  NoOpCache,
+  createInitialRequestContext,
+} from '@reactionary/core';
+import { getFakerTestConfiguration } from './test-utils.js';
+import { FakeCartProvider } from '../providers/cart.provider.js';
+import { FakeIdentityProvider } from '../providers/index.js';
+import { describe, expect, it, beforeAll, beforeEach, assert } from 'vitest';
+import { FakeCheckoutProvider } from '../providers/checkout.provider.js';
+import { FakeOrderProvider } from '../providers/order.provider.js';
+import { FakeOrderSearchProvider } from '../providers/order-search.provider.js';
+
+describe('Fake Order Search Provider', () => {
+  let provider: FakeOrderSearchProvider;
+  let reqCtx: RequestContext;
+
+  beforeEach(() => {
+    reqCtx = createInitialRequestContext();
+    provider = new FakeOrderSearchProvider(
+      getFakerTestConfiguration(),
+      new NoOpCache(),
+      reqCtx
+    );
+  });
+
+  describe('should have operations return structurally valid data', () => {
+    it('for queryByTerm', async () => {
+      const result = await provider.queryByTerm({
+        search: {
+          term: '1234',
+          filters: [],
+          paginationOptions: {
+            pageNumber: 1,
+            pageSize: 12,
+          },
+        },
+      });
+
+      if (!result.success) {
+        assert.fail();
+      }
+
+      expect(result.value.identifier).toBeDefined();
+    });
+  });
+});

package/providers/fake/src/test/order.provider.spec.ts

@@ -0,0 +1,44 @@
+import 'dotenv/config';
+import type { RequestContext } from '@reactionary/core';
+import {
+  CartSchema,
+  IdentitySchema,
+  NoOpCache,
+  createInitialRequestContext,
+} from '@reactionary/core';
+import { getFakerTestConfiguration } from './test-utils.js';
+import { FakeCartProvider } from '../providers/cart.provider.js';
+import { FakeIdentityProvider } from '../providers/index.js';
+import { describe, expect, it, beforeAll, beforeEach, assert } from 'vitest';
+import { FakeCheckoutProvider } from '../providers/checkout.provider.js';
+import { FakeOrderProvider } from '../providers/order.provider.js';
+
+describe('Fake Order Provider', () => {
+  let provider: FakeOrderProvider;
+  let reqCtx: RequestContext;
+
+  beforeEach(() => {
+    reqCtx = createInitialRequestContext();
+    provider = new FakeOrderProvider(
+      getFakerTestConfiguration(),
+      new NoOpCache(),
+      reqCtx
+    );
+  });
+
+  describe('should have operations return structurally valid data', () => {
+    it('for getById', async () => {
+      const result = await provider.getById({
+        order: {
+          key: '1234'
+        }
+      })
+
+      if (!result.success) {
+        assert.fail();
+      }
+
+      expect(result.value.identifier.key).toBe('1234');
+    });
+  });
+});