@thorprovider/adapters 4.2.1 → 4.2.2

package/src/providers/medusa/index.test.ts

@@ -0,0 +1,392 @@
+/**
+ * Integration tests for MedusaProvider (main storefront provider).
+ *
+ * Uses msw to intercept HTTP requests — no real backend required.
+ * Follows the same pattern as auth.test.ts and admin.test.ts.
+ *
+ * Coverage:
+ *  - Products: getProduct, getProducts (success + 404 + 503)
+ *  - Cart: createCart, getCart (success + 404), addToCart
+ *  - Shipping: getShippingMethods
+ *  - Regions: getRegions
+ *  - Checkout: getPaymentMethods, completeCheckout
+ */
+import { describe, expect, it } from 'vitest'
+import { http, HttpResponse } from 'msw'
+import { server } from '../stelorder/client.test-helpers'
+import { MedusaProvider } from './index'
+
+// ---------------------------------------------------------------------------
+// Test constants
+// ---------------------------------------------------------------------------
+const BASE = 'https://medusa.example.com'
+const PUB_KEY = 'pk_test_abc123'
+const CURRENCY = 'usd'
+
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+function makeProvider() {
+  return new MedusaProvider({
+    baseUrl: BASE,
+    publishableKey: PUB_KEY,
+    currencyCode: CURRENCY,
+    debug: false,
+  })
+}
+
+// ---------------------------------------------------------------------------
+// Minimal Medusa response fixtures
+// ---------------------------------------------------------------------------
+const MEDUSA_PRODUCT = {
+  id: 'prod_01',
+  handle: 'test-product',
+  title: 'Test Product',
+  subtitle: null,
+  description: 'A test product',
+  status: 'published',
+  thumbnail: 'https://example.com/thumb.jpg',
+  images: [{ id: 'img_01', url: 'https://example.com/img.jpg', metadata: null }],
+  tags: [],
+  collection: null,
+  categories: [],
+  options: [{ id: 'opt_01', title: 'Size', product_id: 'prod_01', values: [{ id: 'optval_01', value: 'One Size', option_id: 'opt_01' }] }],
+  variants: [
+    {
+      id: 'variant_01',
+      title: 'Default',
+      product_id: 'prod_01',
+      sku: 'SKU-001',
+      inventory_quantity: 10,
+      prices: [{ id: 'price_01', amount: 2500, currency_code: 'usd' }],
+      calculated_price: { calculated_amount: 2500, currency_code: 'usd' },
+      options: [{ id: 'optval_01', value: 'One Size' }],
+    },
+  ],
+  metadata: null,
+  created_at: '2026-01-01T00:00:00Z',
+  updated_at: '2026-01-01T00:00:00Z',
+}
+
+const MEDUSA_CART = {
+  id: 'cart_01',
+  currency_code: 'usd',
+  region_id: 'reg_01',
+  region: { id: 'reg_01', currency_code: 'usd' },
+  items: [],
+  total: 0,
+  subtotal: 0,
+  tax_total: 0,
+  shipping_total: 0,
+  discount_total: 0,
+  shipping_address: null,
+  billing_address: null,
+  shipping_methods: [],
+  payment_collection: null,
+  metadata: null,
+  created_at: '2026-01-01T00:00:00Z',
+  updated_at: '2026-01-01T00:00:00Z',
+}
+
+const MEDUSA_REGION = {
+  id: 'reg_01',
+  name: 'North America',
+  currency_code: 'usd',
+  countries: [{ iso_2: 'us', display_name: 'United States', name: 'UNITED STATES', iso_3: 'usa', num_code: '840', region_id: 'reg_01', metadata: null, created_at: '2026-01-01T00:00:00Z', updated_at: '2026-01-01T00:00:00Z', deleted_at: null }],
+  created_at: '2026-01-01T00:00:00Z',
+  updated_at: '2026-01-01T00:00:00Z',
+  deleted_at: null,
+  metadata: null,
+}
+
+// ---------------------------------------------------------------------------
+// Products
+// ---------------------------------------------------------------------------
+describe('MedusaProvider — Products', () => {
+  it('getProduct returns transformed product when found', async () => {
+    server.use(
+      http.get(`${BASE}/store/products`, () =>
+        HttpResponse.json({ products: [MEDUSA_PRODUCT], count: 1, offset: 0, limit: 1 }),
+      ),
+    )
+
+    const provider = makeProvider()
+    const product = await provider.getProduct('test-product')
+
+    expect(product).not.toBeUndefined()
+    expect(product!.id).toBe('prod_01')
+    expect(product!.handle).toBe('test-product')
+    expect(product!.title).toBe('Test Product')
+    expect(product!.variants).toHaveLength(1)
+  })
+
+  it('getProduct returns undefined when not found', async () => {
+    server.use(
+      http.get(`${BASE}/store/products`, () =>
+        HttpResponse.json({ products: [], count: 0, offset: 0, limit: 1 }),
+      ),
+    )
+
+    const provider = makeProvider()
+    const product = await provider.getProduct('does-not-exist')
+
+    expect(product).toBeUndefined()
+  })
+
+  it('getProduct throws ProviderAPIError on 503', async () => {
+    server.use(
+      http.get(`${BASE}/store/products`, () =>
+        HttpResponse.json({ message: 'Service unavailable' }, { status: 503 }),
+      ),
+    )
+
+    const provider = makeProvider()
+
+    await expect(provider.getProduct('any-handle')).rejects.toThrow()
+  })
+
+  it('getProducts returns array of transformed products', async () => {
+    server.use(
+      http.get(`${BASE}/store/products`, () =>
+        HttpResponse.json({ products: [MEDUSA_PRODUCT], count: 1, offset: 0, limit: 100 }),
+      ),
+    )
+
+    const provider = makeProvider()
+    const products = await provider.getProducts({ first: 10 })
+
+    expect(Array.isArray(products)).toBe(true)
+    expect(products).toHaveLength(1)
+    expect(products[0].handle).toBe('test-product')
+  })
+
+  it('getProducts returns empty array when backend returns none', async () => {
+    server.use(
+      http.get(`${BASE}/store/products`, () =>
+        HttpResponse.json({ products: [], count: 0, offset: 0, limit: 100 }),
+      ),
+    )
+
+    const provider = makeProvider()
+    const products = await provider.getProducts()
+
+    expect(products).toHaveLength(0)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Cart
+// ---------------------------------------------------------------------------
+describe('MedusaProvider — Cart', () => {
+  it('createCart returns a cart with an id', async () => {
+    server.use(
+      http.post(`${BASE}/store/carts`, () =>
+        HttpResponse.json({ cart: MEDUSA_CART }),
+      ),
+    )
+
+    const provider = makeProvider()
+    const cart = await provider.createCart()
+
+    expect(cart.id).toBe('cart_01')
+  })
+
+  it('createCart with regionId passes region_id in payload', async () => {
+    server.use(
+      http.post(`${BASE}/store/carts`, async ({ request }) => {
+        const body = await request.json() as any
+        expect(body.region_id).toBe('reg_test')
+        return HttpResponse.json({ cart: { ...MEDUSA_CART, region_id: 'reg_test' } })
+      }),
+    )
+
+    const provider = makeProvider()
+    const cart = await provider.createCart({ regionId: 'reg_test' })
+
+    expect(cart.id).toBe('cart_01')
+  })
+
+  it('getCart returns cart when found', async () => {
+    server.use(
+      http.get(`${BASE}/store/carts/cart_01`, () =>
+        HttpResponse.json({ cart: MEDUSA_CART }),
+      ),
+    )
+
+    const provider = makeProvider()
+    const cart = await provider.getCart('cart_01')
+
+    expect(cart).not.toBeUndefined()
+    expect(cart!.id).toBe('cart_01')
+  })
+
+  it('getCart returns undefined when cart not found (404)', async () => {
+    server.use(
+      http.get(`${BASE}/store/carts/cart_missing`, () =>
+        HttpResponse.json({ message: 'Not found' }, { status: 404 }),
+      ),
+    )
+
+    const provider = makeProvider()
+    const cart = await provider.getCart('cart_missing')
+
+    expect(cart).toBeUndefined()
+  })
+
+  it('createCart throws ProviderAPIError on server error', async () => {
+    server.use(
+      http.post(`${BASE}/store/carts`, () =>
+        HttpResponse.json({ message: 'Internal Server Error' }, { status: 500 }),
+      ),
+    )
+
+    const provider = makeProvider()
+
+    await expect(provider.createCart()).rejects.toThrow()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Regions
+// ---------------------------------------------------------------------------
+describe('MedusaProvider — Regions', () => {
+  it('getRegions returns array of regions', async () => {
+    server.use(
+      http.get(`${BASE}/store/regions`, () =>
+        HttpResponse.json({ regions: [MEDUSA_REGION], count: 1, offset: 0, limit: 100 }),
+      ),
+    )
+
+    const provider = makeProvider()
+    const regions = await provider.getRegions()
+
+    expect(Array.isArray(regions)).toBe(true)
+    expect(regions).toHaveLength(1)
+    expect(regions[0].id).toBe('reg_01')
+    expect(regions[0].name).toBe('North America')
+  })
+
+  it('getRegions returns empty array when no regions', async () => {
+    server.use(
+      http.get(`${BASE}/store/regions`, () =>
+        HttpResponse.json({ regions: [], count: 0, offset: 0, limit: 100 }),
+      ),
+    )
+
+    const provider = makeProvider()
+    const regions = await provider.getRegions()
+
+    expect(regions).toHaveLength(0)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Shipping
+// getShippingMethods first retrieves the cart (to get region_id), then fetches
+// shipping options for that cart via GET /store/shipping-options?cart_id=...
+// ---------------------------------------------------------------------------
+describe('MedusaProvider — Shipping', () => {
+  const CART_WITH_REGION = { ...MEDUSA_CART, region_id: 'reg_01' }
+
+  const MEDUSA_SHIPPING_OPTION = {
+    id: 'so_01',
+    name: 'Standard Shipping',
+    amount: 499,
+    price_type: 'flat',
+    provider_id: 'manual',
+    service_zone: { id: 'sz_01', name: 'Default' },
+  }
+
+  it('getShippingMethods returns available methods', async () => {
+    server.use(
+      // Step 1: cart retrieve
+      http.get(`${BASE}/store/carts/cart_01`, () =>
+        HttpResponse.json({ cart: CART_WITH_REGION }),
+      ),
+      // Step 2: shipping options
+      http.get(`${BASE}/store/shipping-options`, () =>
+        HttpResponse.json({ shipping_options: [MEDUSA_SHIPPING_OPTION] }),
+      ),
+    )
+
+    const provider = makeProvider()
+    const methods = await provider.getShippingMethods('cart_01')
+
+    expect(Array.isArray(methods)).toBe(true)
+    expect(methods).toHaveLength(1)
+    expect(methods[0].id).toBe('so_01')
+    expect(methods[0].name).toBe('Standard Shipping')
+  })
+
+  it('getShippingMethods returns empty array when none available', async () => {
+    server.use(
+      http.get(`${BASE}/store/carts/cart_01`, () =>
+        HttpResponse.json({ cart: CART_WITH_REGION }),
+      ),
+      http.get(`${BASE}/store/shipping-options`, () =>
+        HttpResponse.json({ shipping_options: [] }),
+      ),
+    )
+
+    const provider = makeProvider()
+    const methods = await provider.getShippingMethods('cart_01')
+
+    expect(methods).toHaveLength(0)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Payment methods
+// getPaymentMethods fetches the cart first (to get region_id), then calls
+// GET /store/payment-providers?region_id=...
+// ---------------------------------------------------------------------------
+describe('MedusaProvider — Payment', () => {
+  it('getPaymentMethods returns payment providers', async () => {
+    server.use(
+      // Step 1: cart retrieve to get region_id
+      http.get(`${BASE}/store/carts/cart_01`, () =>
+        HttpResponse.json({ cart: { ...MEDUSA_CART, region_id: 'reg_01' } }),
+      ),
+      // Step 2: payment providers
+      http.get(`${BASE}/store/payment-providers`, () =>
+        HttpResponse.json({
+          payment_providers: [{ id: 'pp_manual', name: 'Manual', is_enabled: true }],
+        }),
+      ),
+    )
+
+    const provider = makeProvider()
+    const methods = await provider.getPaymentMethods({ cartId: 'cart_01' })
+
+    expect(Array.isArray(methods)).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Error propagation
+// ---------------------------------------------------------------------------
+describe('MedusaProvider — Error propagation', () => {
+  it('getProducts throws when backend returns 503', async () => {
+    server.use(
+      http.get(`${BASE}/store/products`, () =>
+        HttpResponse.json({ message: 'Service Unavailable' }, { status: 503 }),
+      ),
+    )
+
+    const provider = makeProvider()
+
+    await expect(provider.getProducts()).rejects.toThrow()
+  })
+
+  it('createCart throws when backend returns 500', async () => {
+    server.use(
+      http.post(`${BASE}/store/carts`, () =>
+        HttpResponse.json({ message: 'Internal Server Error' }, { status: 500 }),
+      ),
+    )
+
+    const provider = makeProvider()
+
+    await expect(provider.createCart()).rejects.toThrow()
+  })
+})