@reactionary/source 0.0.52 → 0.2.16

package/providers/medusa/src/test/checkout.spec.ts

@@ -0,0 +1,349 @@
+import type { Cart, Checkout, RequestContext, ShippingInstruction } from '@reactionary/core';
+import {
+  ClientBuilder,
+  createInitialRequestContext,
+  NoOpCache,
+  PaymentInstructionSchema,
+  ShippingInstructionSchema,
+  unwrapValue,
+} from '@reactionary/core';
+import 'dotenv/config';
+import { assert, beforeEach, describe, expect, it } from 'vitest';
+import { withMedusaCapabilities } from '../core/initialize.js';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+import { getMedusaTestConfiguration } from './test-utils.js';
+
+const testData = {
+  skuWithoutTiers: '0766623301831',
+  skuWithTiers: '0766623360203',
+};
+
+function createMedusaClient(config: MedusaConfiguration, reqCtx: RequestContext) {
+  const builder = new ClientBuilder(reqCtx)
+    .withCache(new NoOpCache())
+    .withCapability(
+      withMedusaCapabilities(config, {
+        cart: true,
+        product: true,
+        category: true,
+        checkout: true,
+        identity: true,
+        inventory: true,
+        order: true,
+        price: true,
+        productSearch: true,
+      })
+    );
+
+    return builder.build();
+}
+
+describe.each(['Medusa'])('Checkout Capability - %s', (provider) => {
+  let client: ReturnType<typeof createMedusaClient>;
+
+  beforeEach(() => {
+      const reqCtx = createInitialRequestContext();
+      const config = getMedusaTestConfiguration();
+      client = createMedusaClient(config, reqCtx);
+  });
+
+  describe('anonymous sessions', () => {
+    let cart: Cart;
+
+    beforeEach(async () => {
+      cart = unwrapValue(await client.cart.add(
+        {
+          variant: {
+            sku: testData.skuWithoutTiers,
+          },
+          quantity: 1,
+        },
+      ));
+    });
+
+    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 client.checkout.initiateCheckoutForCart(
+        {
+          cart: cart,
+          billingAddress: {
+            countryCode: 'DK',
+            firstName: 'John',
+            lastName: 'Doe',
+            streetAddress: '123 Main St',
+            streetNumber: '1A',
+            postalCode: '12345',
+            city: 'Anytown',
+            region: '',
+          },
+          notificationEmail: 'sample@example.com',
+          notificationPhone: '+4512345678',
+        }
+      );
+
+      if (!checkout.success) {
+        assert.fail();
+      }
+
+      expect(checkout.value.identifier.key).toBeDefined();
+      expect(checkout.value.originalCartReference.key).toBe(cart.identifier.key);
+      expect(checkout.value.billingAddress?.firstName).toBe('John');
+      expect(checkout.value.items.length).toBe(1);
+      expect(checkout.value.items[0].variant.sku).toBe(testData.skuWithoutTiers);
+    });
+
+    describe('checkout actions', () => {
+      let checkout: Checkout;
+      beforeEach(async () => {
+        checkout = unwrapValue(await client.checkout.initiateCheckoutForCart(
+          {
+            cart: cart,
+            billingAddress: {
+              countryCode: 'DK',
+              firstName: 'John',
+              lastName: 'Doe',
+              streetAddress: '123 Main St',
+              streetNumber: '1A',
+              postalCode: '12345',
+              city: 'Anytown',
+              region: '',
+            },
+            notificationEmail: 'sample@example.com',
+            notificationPhone: '+4512345678',
+          }
+        ));
+      });
+
+      it('can list payment methods', async () => {
+        const paymentMethods = await client.checkout.getAvailablePaymentMethods(
+          {
+            checkout: checkout.identifier,
+          }
+        );
+
+        if (!paymentMethods.success) {
+          assert.fail();
+        }
+
+        expect(paymentMethods.value.length).toBeGreaterThan(0);
+        expect(
+          paymentMethods.value.find((x) => x.identifier.method === 'pp_stripe_stripe')
+        ).toBeDefined();
+      });
+
+      it('can list shipping methods', async () => {
+        const shippingMethods = await client.checkout.getAvailableShippingMethods(
+          {
+            checkout: checkout.identifier,
+          }
+        );
+
+        if (!shippingMethods.success) {
+          assert.fail();
+        }
+
+        expect(shippingMethods.value.length).toBeGreaterThan(0);
+        expect(
+          shippingMethods.value.find((x) => x.name === 'Standard Shipping')
+        ).toBeDefined();
+      });
+
+      it('can add a payment instruction', async () => {
+        const paymentMethods = await client.checkout.getAvailablePaymentMethods(
+          {
+            checkout: checkout.identifier,
+          }
+        );
+
+        if (!paymentMethods.success) {
+          assert.fail();
+        }
+
+        const pm = paymentMethods.value.find((x) => x.identifier.method === 'pp_stripe_stripe');
+        expect(pm).toBeDefined();
+
+        const checkoutWithPi = await client.checkout.addPaymentInstruction(
+          {
+            checkout: checkout.identifier,
+            paymentInstruction: {
+              paymentMethod: pm!.identifier,
+              amount: checkout.price.grandTotal,
+              protocolData: [{ key: 'test-key', value: 'test-value' }],
+            },
+          }
+        );
+
+        if (!checkoutWithPi.success) {
+          assert.fail();
+        }
+
+        expect(checkoutWithPi.value.paymentInstructions.length).toBe(1);
+        expect(checkoutWithPi.value.paymentInstructions[0].paymentMethod.method).toBe(
+          'pp_stripe_stripe'
+        );
+        expect(checkoutWithPi.value.paymentInstructions[0].protocolData.find(x => x.key === 'client_secret')?.value).toBeDefined();
+
+      });
+
+      it.skip('can cancel an in-progress payment', async () => {
+        const paymentMethods = await client.checkout.getAvailablePaymentMethods(
+          {
+            checkout: checkout.identifier,
+          }
+        );
+
+        if (!paymentMethods.success) {
+          assert.fail();
+        }
+
+        const pm = paymentMethods.value.find((x) => x.identifier.method === 'pp_stripe_stripe');
+        expect(pm).toBeDefined();
+
+        const checkoutWithPi = await client.checkout.addPaymentInstruction(
+          {
+            checkout: checkout.identifier,
+            paymentInstruction: {
+              paymentMethod: pm!.identifier,
+              amount: checkout.price.grandTotal,
+              protocolData: [{ key: 'test-key', value: 'test-value' }],
+            },
+          }
+        );
+
+        if (!checkoutWithPi.success) {
+          assert.fail();
+        }
+
+        expect(checkoutWithPi.value.paymentInstructions.length).toBe(1);
+
+        const checkoutAfterCancel = await client.checkout.removePaymentInstruction(
+          {
+            checkout: checkout.identifier,
+            paymentInstruction:
+              checkoutWithPi.value.paymentInstructions[0].identifier,
+          }
+        );
+
+        if (!checkoutAfterCancel.success) {
+          assert.fail();
+        }
+
+        expect(checkoutAfterCancel.value.paymentInstructions.length).toBe(0);
+      });
+
+      it('can set shipping address', async () => {
+        const checkoutWithShipping = await client.checkout.setShippingAddress(
+          {
+            checkout: checkout.identifier,
+            shippingAddress: {
+              countryCode: 'DK',
+              firstName: 'Jane',
+              lastName: 'Doe',
+              streetAddress: '456 Other St',
+              streetNumber: '2B',
+              postalCode: '54321',
+              city: 'Othertown',
+              region: '',
+            },
+          }
+        );
+
+        if (!checkoutWithShipping.success) {
+          assert.fail();
+        }
+
+        expect(checkoutWithShipping.value.shippingAddress).toBeDefined();
+        expect(checkoutWithShipping.value.shippingAddress?.firstName).toBe('Jane');
+      });
+
+      it('can set shipping instructions', async () => {
+        const shippingMethods = await client.checkout.getAvailableShippingMethods(
+          {
+            checkout: checkout.identifier,
+          }
+        );
+
+        if (!shippingMethods.success) {
+          assert.fail();
+        }
+
+        const sm = shippingMethods.value.find((x) => x.name === 'Standard Shipping');
+        expect(sm).toBeDefined();
+
+        const shippingInstruction: ShippingInstruction = {
+          shippingMethod: sm?.identifier || { key: '' },
+          instructions: 'Leave at front door if not home',
+          consentForUnattendedDelivery: true,
+          pickupPoint: '4190asx141',
+        };
+
+        const checkoutWithShipping = await client.checkout.setShippingInstruction(
+          {
+            checkout: checkout.identifier,
+            shippingInstruction,
+          }
+        );
+
+        if (!checkoutWithShipping.success) {
+          assert.fail();
+        }
+
+        expect(checkout.price.totalShipping.value).toBe(0);
+        expect(checkoutWithShipping.value.price.totalShipping.value).toBeGreaterThan(0);
+        expect(checkoutWithShipping.value.shippingInstruction).toBeDefined();
+        expect(
+          checkoutWithShipping.value.shippingInstruction?.shippingMethod.key
+        ).toBe(sm?.identifier.key);
+        expect(checkoutWithShipping.value.shippingInstruction?.instructions).toBe(
+          'Leave at front door if not home'
+        );
+        expect(checkoutWithShipping.value.shippingInstruction?.pickupPoint).toBe(
+          '4190asx141'
+        );
+        expect(
+          checkoutWithShipping.value.shippingInstruction?.consentForUnattendedDelivery
+        ).toBe(true);
+      });
+
+      it.skip('wont report it finalizable until everything is paid/authorized', async () => {
+        expect(checkout.readyForFinalization).toBe(false);
+        const pm = unwrapValue(
+          await client.checkout.getAvailablePaymentMethods(
+            {
+              checkout: checkout.identifier,
+            }
+          )
+        ).find((x) => x.identifier.method === 'stripe');
+
+        
+        expect(pm).toBeDefined();
+
+        const checkoutWithPi = await client.checkout.addPaymentInstruction(
+          {
+            checkout: checkout.identifier,
+            paymentInstruction: {
+              paymentMethod: pm!.identifier,
+              amount: checkout.price.grandTotal,
+              protocolData: [{ key: 'test-key', value: 'test-value' }],
+            },
+          }
+        );
+        
+        if (!checkoutWithPi.success) {
+          assert.fail();
+        }
+
+        // do something to simulate payment authorization ?
+        const checkoutReady = await client.checkout.getById(
+          { identifier: checkoutWithPi.value.identifier },
+        );
+        if (!checkoutReady.success || !checkoutReady) {
+          expect.fail('checkout not found');
+        }
+        expect(checkoutReady.value.readyForFinalization).toBe(true);
+      });
+    });
+  });
+});

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

@@ -0,0 +1,122 @@
+import { describe, it, expect, beforeEach, assert } from 'vitest';
+import { MedusaIdentityProvider } from '../providers/identity.provider.js';
+import { IdentitySchema, NoOpCache, createInitialRequestContext, type RequestContext } from '@reactionary/core';
+import { getMedusaTestConfiguration } from './test-utils.js';
+import { MedusaAPI } from '../core/client.js';
+
+const testData = {
+  testEmail: 'test@example.com',
+  testPassword: 'TestPassword123!',
+  testFirstName: 'Test',
+  testLastName: 'User'
+};
+
+describe('Medusa Identity Provider', () => {
+  let provider: MedusaIdentityProvider;
+  let reqCtx: RequestContext;
+
+  beforeEach(() => {
+    reqCtx = createInitialRequestContext();
+    const config = getMedusaTestConfiguration();
+    const client = new MedusaAPI(config, reqCtx);
+
+    provider = new MedusaIdentityProvider(config, new NoOpCache(), reqCtx, client);
+  });
+
+  it('should return anonymous identity when not authenticated', async () => {
+    const result = await provider.getSelf({});
+
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result.value).toBeTruthy();
+    expect(result.value.type).toBe('Anonymous');
+  });
+
+  it('should be able to register a new user', async () => {
+    const testEmail = `test-user+${new Date().getTime()}@example.com`;
+    const result = await provider.register({
+      username: testEmail,
+      password: testData.testPassword,
+    });
+
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result).toBeTruthy();
+    // Registration should auto-login and return Registered identity
+    expect(['Registered', 'Anonymous']).toContain(result.value.type);
+  });
+
+  it('should be able to login with valid credentials', async () => {
+    try {
+      const result = await provider.register({
+        username: testData.testEmail,
+        password: testData.testPassword,
+      });
+      await provider.logout({});
+
+    } catch (err) {
+      // already exists, its fine
+    }
+
+    const result = await provider.login({
+      username: testData.testEmail,
+      password: testData.testPassword,
+    });
+
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result).toBeTruthy();
+    expect(['Registered', 'Anonymous']).toContain(result.value.type);
+  });
+
+  it('should be able to logout', async () => {
+    // First login
+    await provider.login({
+      username: testData.testEmail,
+      password: testData.testPassword,
+    });
+
+    // Then logout
+    const result = await provider.logout({});
+
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result).toBeTruthy();
+    expect(result.value.type).toBe('Anonymous');
+  });
+
+  it('should return registered identity when authenticated', async () => {
+    // Login first
+    await provider.login({
+      username: testData.testEmail,
+      password: testData.testPassword,
+    });
+
+    // Check identity
+    const result = await provider.getSelf({});
+
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result).toBeTruthy();
+    expect(['Registered', 'Anonymous']).toContain(result.value.type);
+  });
+
+  it('should handle login errors gracefully', async () => {
+    await expect(async () => {
+      await provider.login({
+        username: 'nonexistent@example.com',
+        password: 'wrongpassword',
+      });
+    }).rejects.toThrow();
+  });
+});

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

@@ -0,0 +1,88 @@
+import { describe, it, expect, beforeEach, assert } from 'vitest';
+import { MedusaInventoryProvider } from '../providers/inventory.provider.js';
+import {
+  InventorySchema,
+  NoOpCache,
+  createInitialRequestContext,
+  type RequestContext,
+} from '@reactionary/core';
+import { getMedusaTestConfiguration } from './test-utils.js';
+import { MedusaAPI } from '../core/client.js';
+
+const testData = {
+  skuInStock: '	4007249524126',
+  skuOutOfStock: '4007249524645',
+  fulfillmentCenter: 'European Warehouse',
+};
+
+// FIXME: Currently broken in terms of actually looking up anything...
+describe('Medusa Inventory Provider', () => {
+  let provider: MedusaInventoryProvider;
+  let reqCtx: RequestContext;
+
+  beforeEach(() => {
+    reqCtx = createInitialRequestContext();
+    const config = getMedusaTestConfiguration();
+    const client = new MedusaAPI(config, reqCtx);
+
+    provider = new MedusaInventoryProvider(
+      config,
+      new NoOpCache(),
+      reqCtx,
+      client
+    );
+  });
+
+  it('should be able to get inventory for a SKU with stock', async () => {
+    const result = await provider.getBySKU({
+      variant: { sku: testData.skuInStock },
+      fulfilmentCenter: { key: testData.fulfillmentCenter },
+    });
+
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result.value.identifier.variant.sku).toBe(testData.skuInStock);
+    expect(result.value.identifier.fulfillmentCenter.key).toBe(
+      testData.fulfillmentCenter
+    );
+    expect(result.value.quantity).toBeGreaterThanOrEqual(0);
+    if (result.value.quantity > 0) {
+      expect(result.value.status).toBe('inStock');
+    }
+  });
+
+  it('should return out of stock for a SKU without inventory', async () => {
+    const result = await provider.getBySKU({
+      variant: { sku: testData.skuOutOfStock },
+      fulfilmentCenter: { key: testData.fulfillmentCenter },
+    });
+
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result.value.identifier.variant.sku).toBe(testData.skuOutOfStock);
+    expect(result.value.identifier.fulfillmentCenter.key).toBe(
+      testData.fulfillmentCenter
+    );
+    expect(result.value.quantity).toBe(0);
+    expect(result.value.status).toBe('outOfStock');
+  });
+
+  it('should return placeholder inventory for an unknown SKU', async () => {
+    const result = await provider.getBySKU({
+      variant: { sku: 'unknown-sku' },
+      fulfilmentCenter: { key: testData.fulfillmentCenter },
+    });
+
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result.value.identifier.variant.sku).toBe('unknown-sku');
+    expect(result.value.quantity).toBe(0);
+    expect(result.value.status).toBe('outOfStock');
+  });
+});

package/providers/medusa/src/test/large-cart.provider.spec.ts

@@ -0,0 +1,103 @@
+import {
+  CartSchema,
+  NoOpCache,
+  ProductSearchQueryByTermSchema,
+  ProductSearchResultItemSchema,
+  createInitialRequestContext,
+  type ProductSearchQueryByTerm,
+  type RequestContext,
+} from '@reactionary/core';
+import { assert, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+import { MedusaCartProvider } from '../providers/cart.provider.js';
+import { MedusaSearchProvider } from '../providers/product-search.provider.js';
+import { getMedusaTestConfiguration } from './test-utils.js';
+import { MedusaAPI } from '../core/client.js';
+
+/**
+const testData = {
+  skuWithoutTiers: '8719514435254',
+  skuWithTiers: '8719514435377'
+}
+*/
+
+describe('Medusa Cart Provider - Large Scenarios', () => {
+  let provider: MedusaCartProvider;
+  let searchProvider: MedusaSearchProvider;
+  let reqCtx: RequestContext;
+
+  beforeEach(() => {
+    reqCtx = createInitialRequestContext();
+    const client = new MedusaAPI(getMedusaTestConfiguration(), reqCtx);
+    provider = new MedusaCartProvider(
+      getMedusaTestConfiguration(),
+      new NoOpCache(),
+      reqCtx,
+      client
+    );
+    searchProvider = new MedusaSearchProvider(
+      getMedusaTestConfiguration(),
+      new NoOpCache(),
+      reqCtx,
+      client
+    );
+  });
+
+  describe('large carts', () => {
+    it('should be able to add an 50 items to a cart in less than 30 seconds', async () => {
+      const searchResult = await searchProvider.queryByTerm(
+        ProductSearchQueryByTermSchema.parse({
+          search: {
+            term: 'phil',
+            paginationOptions: {
+              pageNumber: 1,
+              pageSize: 50,
+            },
+            filters: [],
+            facets: [],
+          },
+        } satisfies ProductSearchQueryByTerm)
+      );
+
+      if (!searchResult.success) {
+        assert.fail();
+      }
+
+      expect(searchResult.value.items.length).toBeGreaterThanOrEqual(50);
+
+      let cartIdentifier = undefined;
+      let cart;
+      for (const product of searchResult.value.items) {
+        cart = await provider.add({
+          cart: cartIdentifier,
+          variant: {
+            sku: product.variants[0].variant.sku,
+          },
+          quantity: 1,
+        });
+
+        if (!cart.success) {
+          assert.fail();
+        }
+
+        cartIdentifier = cart.value.identifier;
+      }
+
+      if (!cart) {
+        assert.fail();
+      }
+
+      expect(cart.value.identifier.key).toBeDefined();
+      expect(cart.value.items.length).toBe(50);
+
+      expect(cart.value.items[0].price.totalPrice.value).toBeGreaterThan(0);
+      expect(cart.value.items[0].price.totalPrice.currency).toBe(
+        reqCtx.languageContext.currencyCode
+      );
+
+      expect(cart.value.price.grandTotal.value).toBeGreaterThan(0);
+      expect(cart.value.price.grandTotal.currency).toBe(
+        reqCtx.languageContext.currencyCode
+      );
+    }, 30000);
+  });
+});