@thorprovider/medusa-extended 1.3.0 → 1.5.0

package/src/dropshipper.live-smoke.test.ts

@@ -0,0 +1,685 @@
+/**
+ * @fileoverview Dropshipper Order Creation — Live Integration Tests
+ *
+ * Exercises the DropshipperClient against a real Medusa backend to verify
+ * that orders are created correctly based on payment method, address,
+ * shipping options, and geozone parameters.
+ *
+ * Guarded by DROPSHIPPER_SMOKE_TEST=1 environment variable.
+ *
+ * Environment variables (all required when DROPSHIPPER_SMOKE_TEST=1):
+ *   MEDUSA_BACKEND_URL       - Backend URL (e.g. https://dev.erpthor.com)
+ *   TEST_EMAIL               - Dropshipper admin email
+ *   TEST_PASSWORD            - Dropshipper admin password
+ *
+ * These tests CREATE real orders on the backend and then CANCEL them.
+ * Run against a staging/test environment, NOT production.
+ */
+
+import { describe, expect, it, beforeAll, afterAll } from 'vitest'
+import { server } from '../stelorder/client.test-helpers'
+import { DropshipperClient } from './dropshipper'
+import type {
+  ExtendedCreateDropshipperOrderBody,
+  GetDropshipperProductsResponse,
+  GetDropshipperCustomersResponse,
+  GetDropshipperShippingOptionsResponse,
+  GetDropshipperAccountResponse,
+} from '@thorprovider/types'
+
+const runLive = process.env.DROPSHIPPER_SMOKE_TEST === '1'
+
+function requiredEnv(name: string): string {
+  const value = process.env[name]
+  if (!value) throw new Error(`Missing required env var: ${name}`)
+  return value
+}
+
+if (!runLive) {
+  describe('Dropshipper order creation live smoke', () => {
+    it.skip('disabled unless DROPSHIPPER_SMOKE_TEST=1', () => {})
+  })
+} else {
+  const baseUrl = requiredEnv('MEDUSA_BACKEND_URL')
+  const email = requiredEnv('TEST_EMAIL')
+  const password = requiredEnv('TEST_PASSWORD')
+
+  // --------------------------------------------------------------------------
+  // Helpers
+  // --------------------------------------------------------------------------
+
+  let jwtToken: string
+  let client: DropshipperClient
+
+  /** Login and obtain a JWT token for the dropshipper */
+  const login = async (): Promise<string> => {
+    const res = await fetch(`${baseUrl}/auth/user/emailpass`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ email, password }),
+    })
+    if (!res.ok) {
+      const text = await res.text()
+      throw new Error(`Login failed (${res.status}): ${text}`)
+    }
+    const data = (await res.json()) as { token: string }
+    if (!data.token) throw new Error('Login succeeded but no token returned')
+    return data.token
+  }
+
+  /** Cancel a test order to clean up */
+  const cancelOrder = async (orderId: string): Promise<void> => {
+    try {
+      await client.cancelOrder(orderId)
+    } catch {
+      // Best-effort cleanup — ignore failures
+    }
+  }
+
+  beforeAll(async () => {
+    // Stop MSW so real HTTP requests reach the backend
+    server.close()
+    jwtToken = await login()
+    client = new DropshipperClient({ baseUrl, token: jwtToken })
+  })
+
+  afterAll(() => {
+    // Restore MSW for other tests
+    server.listen({ onUnhandledRequest: 'error' })
+  })
+
+  // --------------------------------------------------------------------------
+  // Test Data Discovery
+  // --------------------------------------------------------------------------
+
+  describe('Test data discovery', () => {
+    let products: GetDropshipperProductsResponse['products']
+    let customers: GetDropshipperCustomersResponse['customers']
+    let shippingOptions: GetDropshipperShippingOptionsResponse['shipping_options']
+    let account: GetDropshipperAccountResponse['account']
+
+    it('fetches products to find valid variant IDs', async () => {
+      const res = await client.getProducts({ limit: 5 })
+      expect(res.products.length).toBeGreaterThan(0)
+      products = res.products
+    })
+
+    it('fetches customers to find a valid customer ID', async () => {
+      const res = await client.getCustomers({ limit: 5 })
+      expect(res.customers.length).toBeGreaterThan(0)
+      customers = res.customers
+    })
+
+    it('fetches account to find payment method configs', async () => {
+      const res = await client.getAccount()
+      expect(res.account.payment_method_configs?.length).toBeGreaterThan(0)
+      account = res.account
+    })
+
+    it('fetches shipping options for the account currency', async () => {
+      const res = await client.getOrderShippingOptions({
+        currency_code: account.currency_code,
+      })
+      expect(res.shipping_options.length).toBeGreaterThan(0)
+      shippingOptions = res.shipping_options
+    })
+
+    it('fetches shipping options with country code (geozone filter)', async () => {
+      // Use the customer's default shipping address country if available
+      const customerDetail = await client.getCustomer(customers[0].id)
+      const addr = customerDetail.customer?.default_shipping_address
+      if (!addr?.country_code) {
+        console.log('Skipping: customer has no default shipping address with country_code')
+        return
+      }
+
+      const res = await client.getOrderShippingOptions({
+        currency_code: account.currency_code,
+        country_code: addr.country_code,
+        province: addr.province ?? undefined,
+        city: addr.city ?? undefined,
+      })
+      expect(res.shipping_options).toBeInstanceOf(Array)
+      console.log(
+        `Shipping options for ${addr.country_code}/${addr.province ?? 'any'}/${addr.city ?? 'any'}: ${res.shipping_options.length} found`,
+      )
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // Order Creation
+  // --------------------------------------------------------------------------
+
+  describe('Order creation', () => {
+    let products: GetDropshipperProductsResponse['products']
+    let customers: GetDropshipperCustomersResponse['customers']
+    let account: GetDropshipperAccountResponse['account']
+    let shippingOptions: GetDropshipperShippingOptionsResponse['shipping_options']
+    let createdOrderIds: string[] = []
+
+    beforeAll(async () => {
+      const [productsRes, customersRes, accountRes] = await Promise.all([
+        client.getProducts({ limit: 5 }),
+        client.getCustomers({ limit: 5 }),
+        client.getAccount(),
+      ])
+      products = productsRes.products
+      customers = customersRes.customers
+      account = accountRes.account
+
+      const shippingRes = await client.getOrderShippingOptions({
+        currency_code: account.currency_code,
+      })
+      shippingOptions = shippingRes.shipping_options
+    })
+
+    afterAll(async () => {
+      // Clean up all created orders
+      for (const orderId of createdOrderIds) {
+        await cancelOrder(orderId)
+      }
+    })
+
+    function getFirstVariantId(): string {
+      for (const product of products) {
+        if (product.variants && product.variants.length > 0) {
+          return product.variants[0].id
+        }
+      }
+      throw new Error('No products with variants found')
+    }
+
+    function buildOrderBody(overrides?: Partial<ExtendedCreateDropshipperOrderBody>): ExtendedCreateDropshipperOrderBody {
+      const variantId = getFirstVariantId()
+      const paymentMethodId = account.payment_method_configs?.find((c) => c.is_enabled)?.payment_provider_id
+      if (!paymentMethodId) throw new Error('No enabled payment method configs found')
+
+      return {
+        customer_id: customers[0].id,
+        currency_code: account.currency_code.toLowerCase(),
+        items: [{ variant_id: variantId, quantity: 1 }],
+        shipping_address: {
+          full_name: `${customers[0].first_name ?? 'Test'} ${customers[0].last_name ?? 'User'}`,
+          address_1: '123 Test Street',
+          city: 'Test City',
+          province: '',
+          postal_code: '00000',
+          country_code: 'mx',
+          phone: undefined,
+        },
+        payment_method_id: paymentMethodId,
+        ...overrides,
+      }
+    }
+
+    it('creates an order with default settings', async () => {
+      const body = buildOrderBody()
+      const res = await client.createOrder(body)
+      expect(res.order).toBeDefined()
+      expect(res.order.id).toBeTruthy()
+      expect(res.order.display_id).toBeGreaterThan(0)
+      expect(res.order.status).toBe('pending')
+      expect(res.order.total).toBeGreaterThan(0)
+      expect(res.order.created_at).toBeTruthy()
+
+      createdOrderIds.push(res.order.id)
+      console.log(`Created order ${res.order.display_id} (${res.order.id}) — total: ${res.order.total}`)
+    })
+
+    it('creates an order with shipping_method_id', async () => {
+      if (shippingOptions.length === 0) {
+        console.log('Skipping: no shipping options available')
+        return
+      }
+
+      const body = buildOrderBody({ shipping_method_id: shippingOptions[0].id })
+      const res = await client.createOrder(body)
+      expect(res.order.id).toBeTruthy()
+      expect(res.order.status).toBe('pending')
+
+      createdOrderIds.push(res.order.id)
+      console.log(`Created order with shipping method: ${shippingOptions[0].name}`)
+    })
+
+    it('creates an order with billing_address', async () => {
+      const body = buildOrderBody({
+        billing_address: {
+          full_name: 'Billing User',
+          address_1: '456 Billing Ave',
+          city: 'Billing City',
+          province: '',
+          postal_code: '11111',
+          country_code: 'mx',
+          phone: undefined,
+        },
+      })
+      const res = await client.createOrder(body)
+      expect(res.order.id).toBeTruthy()
+
+      createdOrderIds.push(res.order.id)
+    })
+
+    it('creates an order with province and city in shipping address (geozone match)', async () => {
+      const body = buildOrderBody({
+        shipping_address: {
+          full_name: `${customers[0].first_name ?? 'Test'} ${customers[0].last_name ?? 'User'}`,
+          address_1: 'Av. Revolucion 123',
+          city: 'Monterrey',
+          province: 'Nuevo Leon',
+          postal_code: '64000',
+          country_code: 'mx',
+          phone: undefined,
+        },
+      })
+      const res = await client.createOrder(body)
+      expect(res.order.id).toBeTruthy()
+
+      createdOrderIds.push(res.order.id)
+      console.log(`Created order with geozone address: Monterrey, Nuevo Leon`)
+    })
+
+    it('creates an order with dropshipper-collected payment method', async () => {
+      const dropshipperPayment = account.payment_method_configs?.find(
+        (c) => c.is_enabled && c.collected_by === 'dropshipper',
+      )
+      if (!dropshipperPayment) {
+        console.log('Skipping: no dropshipper-collected payment method available')
+        return
+      }
+
+      const body = buildOrderBody({ payment_method_id: dropshipperPayment.payment_provider_id })
+      const res = await client.createOrder(body)
+      expect(res.order.id).toBeTruthy()
+
+      createdOrderIds.push(res.order.id)
+      console.log(`Created order with dropshipper-collected payment: ${dropshipperPayment.label}`)
+    })
+
+    it('creates an order with provider-collected payment method', async () => {
+      const providerPayment = account.payment_method_configs?.find(
+        (c) => c.is_enabled && c.collected_by === 'provider',
+      )
+      if (!providerPayment) {
+        console.log('Skipping: no provider-collected payment method available')
+        return
+      }
+
+      const body = buildOrderBody({ payment_method_id: providerPayment.payment_provider_id })
+      const res = await client.createOrder(body)
+      expect(res.order.id).toBeTruthy()
+
+      createdOrderIds.push(res.order.id)
+      console.log(`Created order with provider-collected payment: ${providerPayment.label}`)
+    })
+
+    it('creates an order with promo_codes', async () => {
+      // Try to find a valid promotion first
+      let promoCode: string | undefined
+      try {
+        const promos = await client.getPromotions({ limit: 1 })
+        if (promos.promotions && promos.promotions.length > 0) {
+          promoCode = promos.promotions[0].code
+        }
+      } catch {
+        // Ignore — promotions may not exist
+      }
+
+      if (!promoCode) {
+        console.log('Skipping: no promotions available')
+        return
+      }
+
+      const body = buildOrderBody({ promo_codes: [promoCode] })
+      const res = await client.createOrder(body)
+      expect(res.order.id).toBeTruthy()
+
+      createdOrderIds.push(res.order.id)
+      console.log(`Created order with promo code: ${promoCode}`)
+    })
+
+    it('creates an order with multiple items', async () => {
+      const variantIds: string[] = []
+      for (const product of products) {
+        if (product.variants && product.variants.length > 0) {
+          variantIds.push(product.variants[0].id)
+          if (variantIds.length >= 2) break
+        }
+      }
+
+      if (variantIds.length < 2) {
+        console.log('Skipping: need at least 2 variants for multi-item test')
+        return
+      }
+
+      const paymentMethodId = account.payment_method_configs?.find((c) => c.is_enabled)?.payment_provider_id
+      if (!paymentMethodId) throw new Error('No enabled payment method configs found')
+
+      const body: ExtendedCreateDropshipperOrderBody = {
+        customer_id: customers[0].id,
+        currency_code: account.currency_code.toLowerCase(),
+        items: [
+          { variant_id: variantIds[0], quantity: 2 },
+          { variant_id: variantIds[1], quantity: 1 },
+        ],
+        shipping_address: {
+          full_name: `${customers[0].first_name ?? 'Test'} ${customers[0].last_name ?? 'User'}`,
+          address_1: '789 Multi Item St',
+          city: 'Multi City',
+          province: '',
+          postal_code: '22222',
+          country_code: 'mx',
+          phone: undefined,
+        },
+        payment_method_id: paymentMethodId,
+      }
+
+      const res = await client.createOrder(body)
+      expect(res.order.id).toBeTruthy()
+      expect(res.order.total).toBeGreaterThan(0)
+
+      createdOrderIds.push(res.order.id)
+      console.log(`Created multi-item order: ${res.order.display_id} — total: ${res.order.total}`)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // Order Verification
+  // --------------------------------------------------------------------------
+
+  describe('Order verification', () => {
+    let products: GetDropshipperProductsResponse['products']
+    let customers: GetDropshipperCustomersResponse['customers']
+    let account: GetDropshipperAccountResponse['account']
+    let createdOrderId: string
+
+    beforeAll(async () => {
+      const [productsRes, customersRes, accountRes] = await Promise.all([
+        client.getProducts({ limit: 5 }),
+        client.getCustomers({ limit: 5 }),
+        client.getAccount(),
+      ])
+      products = productsRes.products
+      customers = customersRes.customers
+      account = accountRes.account
+
+      // Create a single order to verify
+      const variantId = (() => {
+        for (const product of products) {
+          if (product.variants && product.variants.length > 0) {
+            return product.variants[0].id
+          }
+        }
+        throw new Error('No products with variants found')
+      })()
+
+      const paymentMethodId = account.payment_method_configs?.find((c) => c.is_enabled)?.payment_provider_id
+      if (!paymentMethodId) throw new Error('No enabled payment method configs found')
+
+      const res = await client.createOrder({
+        customer_id: customers[0].id,
+        currency_code: account.currency_code.toLowerCase(),
+        items: [{ variant_id: variantId, quantity: 1 }],
+        shipping_address: {
+          full_name: `${customers[0].first_name ?? 'Test'} ${customers[0].last_name ?? 'User'}`,
+          address_1: '123 Verification St',
+          city: 'Verification City',
+          province: '',
+          postal_code: '33333',
+          country_code: 'mx',
+          phone: undefined,
+        },
+        payment_method_id: paymentMethodId,
+      })
+      createdOrderId = res.order.id
+    })
+
+    afterAll(async () => {
+      if (createdOrderId) {
+        await cancelOrder(createdOrderId)
+      }
+    })
+
+    it('retrieves the created order by ID', async () => {
+      const res = await client.getOrder(createdOrderId)
+      expect(res.order.id).toBe(createdOrderId)
+      expect(res.order.display_id).toBeGreaterThan(0)
+      expect(res.order.status).toBe('pending')
+      expect(res.order.totals).toBeDefined()
+      expect(res.order.totals.total).toBeGreaterThan(0)
+      console.log(
+        `Verified order ${res.order.display_id}: subtotal=${res.order.totals.subtotal}, total=${res.order.totals.total}, profit=${res.order.totals.profit}`,
+      )
+    })
+
+    it('includes the order in the orders list', async () => {
+      const res = await client.getOrders({ limit: 20 })
+      const found = res.orders.find((o) => o.id === createdOrderId)
+      expect(found).toBeDefined()
+      expect(found!.status).toBe('pending')
+    })
+
+    it('cancels the order successfully', async () => {
+      const res = await client.cancelOrder(createdOrderId)
+      expect(res.order.status).toBeDefined()
+
+      // Verify it's cancelled
+      const detail = await client.getOrder(createdOrderId)
+      expect(detail.order.status).toBe('canceled')
+      console.log(`Order ${createdOrderId} cancelled successfully`)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // Error Handling
+  // --------------------------------------------------------------------------
+
+  describe('Error handling', () => {
+    let products: GetDropshipperProductsResponse['products']
+    let customers: GetDropshipperCustomersResponse['customers']
+    let account: GetDropshipperAccountResponse['account']
+
+    beforeAll(async () => {
+      const [productsRes, customersRes, accountRes] = await Promise.all([
+        client.getProducts({ limit: 5 }),
+        client.getCustomers({ limit: 5 }),
+        client.getAccount(),
+      ])
+      products = productsRes.products
+      customers = customersRes.customers
+      account = accountRes.account
+    })
+
+    it('rejects order creation with invalid variant ID', async () => {
+      const paymentMethodId = account.payment_method_configs?.find((c) => c.is_enabled)?.payment_provider_id
+      if (!paymentMethodId) throw new Error('No enabled payment method configs found')
+
+      await expect(
+        client.createOrder({
+          customer_id: customers[0].id,
+          currency_code: account.currency_code.toLowerCase(),
+          items: [{ variant_id: 'variant_does_not_exist_xyz', quantity: 1 }],
+          shipping_address: {
+            full_name: 'Test User',
+            address_1: '123 Test St',
+            city: 'Test City',
+            province: '',
+            postal_code: '00000',
+            country_code: 'mx',
+          },
+          payment_method_id: paymentMethodId,
+        }),
+      ).rejects.toThrow()
+    })
+
+    it('rejects order creation with empty items array', async () => {
+      const paymentMethodId = account.payment_method_configs?.find((c) => c.is_enabled)?.payment_provider_id
+      if (!paymentMethodId) throw new Error('No enabled payment method configs found')
+
+      await expect(
+        client.createOrder({
+          customer_id: customers[0].id,
+          currency_code: account.currency_code.toLowerCase(),
+          items: [],
+          shipping_address: {
+            full_name: 'Test User',
+            address_1: '123 Test St',
+            city: 'Test City',
+            province: '',
+            postal_code: '00000',
+            country_code: 'mx',
+          },
+          payment_method_id: paymentMethodId,
+        }),
+      ).rejects.toThrow()
+    })
+
+    it('rejects order creation with invalid customer ID', async () => {
+      const paymentMethodId = account.payment_method_configs?.find((c) => c.is_enabled)?.payment_provider_id
+      if (!paymentMethodId) throw new Error('No enabled payment method configs found')
+
+      const variantId = (() => {
+        for (const product of products) {
+          if (product.variants && product.variants.length > 0) {
+            return product.variants[0].id
+          }
+        }
+        throw new Error('No products with variants found')
+      })()
+
+      await expect(
+        client.createOrder({
+          customer_id: 'customer_does_not_exist_xyz',
+          currency_code: account.currency_code.toLowerCase(),
+          items: [{ variant_id: variantId, quantity: 1 }],
+          shipping_address: {
+            full_name: 'Test User',
+            address_1: '123 Test St',
+            city: 'Test City',
+            province: '',
+            postal_code: '00000',
+            country_code: 'mx',
+          },
+          payment_method_id: paymentMethodId,
+        }),
+      ).rejects.toThrow()
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // Shipping Options with Geozone Parameters
+  // --------------------------------------------------------------------------
+
+  describe('Shipping options with geozone parameters', () => {
+    let account: GetDropshipperAccountResponse['account']
+
+    beforeAll(async () => {
+      const res = await client.getAccount()
+      account = res.account
+    })
+
+    it('returns shipping options with currency_code only', async () => {
+      const res = await client.getOrderShippingOptions({
+        currency_code: account.currency_code,
+      })
+      expect(res.shipping_options).toBeInstanceOf(Array)
+      console.log(`Shipping options (currency only): ${res.shipping_options.length} found`)
+      if (res.shipping_options.length > 0) {
+        expect(res.shipping_options[0]).toHaveProperty('id')
+        expect(res.shipping_options[0]).toHaveProperty('name')
+        expect(res.shipping_options[0]).toHaveProperty('amount')
+      }
+    })
+
+    it('returns shipping options filtered by country_code', async () => {
+      const res = await client.getOrderShippingOptions({
+        currency_code: account.currency_code,
+        country_code: 'mx',
+      })
+      expect(res.shipping_options).toBeInstanceOf(Array)
+      console.log(`Shipping options (MX): ${res.shipping_options.length} found`)
+    })
+
+    it('returns shipping options filtered by country_code and province', async () => {
+      const res = await client.getOrderShippingOptions({
+        currency_code: account.currency_code,
+        country_code: 'mx',
+        province: 'Nuevo Leon',
+      })
+      expect(res.shipping_options).toBeInstanceOf(Array)
+      console.log(`Shipping options (MX/Nuevo Leon): ${res.shipping_options.length} found`)
+    })
+
+    it('returns shipping options filtered by country_code, province, and city', async () => {
+      const res = await client.getOrderShippingOptions({
+        currency_code: account.currency_code,
+        country_code: 'mx',
+        province: 'Nuevo Leon',
+        city: 'Monterrey',
+      })
+      expect(res.shipping_options).toBeInstanceOf(Array)
+      console.log(`Shipping options (MX/Nuevo Leon/Monterrey): ${res.shipping_options.length} found`)
+    })
+
+    it('returns different results for different countries (geozone differentiation)', async () => {
+      const [mxOptions, usOptions] = await Promise.all([
+        client.getOrderShippingOptions({
+          currency_code: account.currency_code,
+          country_code: 'mx',
+        }),
+        client.getOrderShippingOptions({
+          currency_code: account.currency_code,
+          country_code: 'us',
+        }),
+      ])
+
+      console.log(`MX options: ${mxOptions.shipping_options.length}, US options: ${usOptions.shipping_options.length}`)
+
+      // The options MAY differ by country — log the difference
+      const mxNames = mxOptions.shipping_options.map((o) => o.name).join(', ')
+      const usNames = usOptions.shipping_options.map((o) => o.name).join(', ')
+      console.log(`MX: [${mxNames}]`)
+      console.log(`US: [${usNames}]`)
+    })
+  })
+
+  // --------------------------------------------------------------------------
+  // Payment Methods
+  // --------------------------------------------------------------------------
+
+  describe('Payment methods from account', () => {
+    it('returns payment method configs from account', async () => {
+      const res = await client.getAccount()
+      expect(res.account.payment_method_configs).toBeInstanceOf(Array)
+
+      const configs = res.account.payment_method_configs!
+      console.log(`Payment method configs: ${configs.length} found`)
+
+      for (const config of configs) {
+        console.log(`  - ${config.label} (${config.payment_provider_id}): collected_by=${config.collected_by}, enabled=${config.is_enabled}`)
+        expect(config).toHaveProperty('payment_provider_id')
+        expect(config).toHaveProperty('label')
+        expect(config).toHaveProperty('collected_by')
+        expect(config).toHaveProperty('is_enabled')
+        expect(['dropshipper', 'provider']).toContain(config.collected_by)
+      }
+
+      const enabled = configs.filter((c) => c.is_enabled)
+      expect(enabled.length).toBeGreaterThan(0)
+      console.log(`Enabled payment methods: ${enabled.length}`)
+    })
+
+    it('has at least one dropshipper-collected or provider-collected method', async () => {
+      const res = await client.getAccount()
+      const configs = res.account.payment_method_configs ?? []
+
+      const dropshipperMethods = configs.filter((c) => c.collected_by === 'dropshipper' && c.is_enabled)
+      const providerMethods = configs.filter((c) => c.collected_by === 'provider' && c.is_enabled)
+
+      console.log(`Dropshipper-collected enabled: ${dropshipperMethods.length}`)
+      console.log(`Provider-collected enabled: ${providerMethods.length}`)
+
+      // At least one type should be available
+      expect(dropshipperMethods.length + providerMethods.length).toBeGreaterThan(0)
+    })
+  })
+}