@thorprovider/medusa-extended 1.0.0 → 1.1.0

package/src/dropshipper.test.ts

@@ -0,0 +1,1072 @@
+/**
+ * @fileoverview Tests for DropshipperClient
+ *
+ * Uses msw to intercept fetch calls and verify that each method:
+ * - Hits the correct URL and HTTP method
+ * - Sends `Authorization: Bearer <token>`
+ * - Forwards query-string options correctly
+ * - Returns the parsed response body
+ * - Throws ProviderAPIError on non-2xx responses
+ */
+
+import { describe, expect, it } from 'vitest'
+import { http, HttpResponse } from 'msw'
+import { server } from '../stelorder/client.test-helpers'
+import { DropshipperClient } from './dropshipper'
+
+const BASE = 'https://medusa.example.com'
+const TOKEN = 'test-jwt-token'
+
+function client() {
+  return new DropshipperClient({ baseUrl: BASE, token: TOKEN })
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function requireBearerToken(request: Request) {
+  expect(request.headers.get('Authorization')).toBe(`Bearer ${TOKEN}`)
+}
+
+// ---------------------------------------------------------------------------
+// Onboarding (Solo X)
+// ---------------------------------------------------------------------------
+
+describe('DropshipperClient.onboardDropshipper', () => {
+  it('POST /admin/thor/dropshipper/onboard', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/dropshipper/onboard`, async ({ request }) => {
+        requireBearerToken(request)
+        const body = await request.json() as any
+        expect(body.business_name).toBe('Acme Drops')
+        return HttpResponse.json({
+          dropshipper: {
+            user_id: 'usr_1',
+            email: 'acme@drops.com',
+            sales_channel_id: 'sc_01',
+            sales_channel_name: 'Acme Drops',
+            account_id: 'acc_01',
+            price_list_id: 'pl_01',
+            publishable_key_token: 'pk_live_xxx',
+            role: 'Dropshipper',
+          },
+        })
+      }),
+    )
+
+    const result = await client().onboardDropshipper({
+      business_name: 'Acme Drops',
+      email: 'acme@drops.com',
+      password: 'secret',
+    })
+    expect(result.dropshipper.account_id).toBe('acc_01')
+    expect(result.dropshipper.role).toBe('Dropshipper')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Variant Costs (Solo X)
+// ---------------------------------------------------------------------------
+
+describe('DropshipperClient.getVariantCosts', () => {
+  it('GET /admin/thor/dropshipper/variant-costs with defaults', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/dropshipper/variant-costs`, ({ request }) => {
+        requireBearerToken(request)
+        const url = new URL(request.url)
+        expect(url.searchParams.get('limit')).toBe('20')
+        expect(url.searchParams.get('offset')).toBe('0')
+        return HttpResponse.json({ variant_costs: [], count: 0, offset: 0, limit: 20 })
+      }),
+    )
+
+    const result = await client().getVariantCosts()
+    expect(result.count).toBe(0)
+  })
+
+  it('forwards account_id and currency_code filters', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/dropshipper/variant-costs`, ({ request }) => {
+        const url = new URL(request.url)
+        expect(url.searchParams.get('account_id')).toBe('acc_01')
+        expect(url.searchParams.get('currency_code')).toBe('usd')
+        return HttpResponse.json({ variant_costs: [], count: 0, offset: 0, limit: 20 })
+      }),
+    )
+
+    await client().getVariantCosts({ account_id: 'acc_01', currency_code: 'usd' })
+  })
+})
+
+describe('DropshipperClient.createVariantCost', () => {
+  it('POST /admin/thor/dropshipper/variant-costs', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/dropshipper/variant-costs`, async ({ request }) => {
+        requireBearerToken(request)
+        const body = await request.json() as any
+        expect(body.variant_id).toBe('var_1')
+        return HttpResponse.json({
+          variant_cost: {
+            id: 'vc_1',
+            account_id: 'acc_01',
+            variant_id: 'var_1',
+            cost_amount: 1000,
+            currency_code: 'usd',
+            updated_at: '2026-01-01T00:00:00Z',
+          },
+        })
+      }),
+    )
+
+    const result = await client().createVariantCost({
+      account_id: 'acc_01',
+      variant_id: 'var_1',
+      cost_amount: 1000,
+      currency_code: 'usd',
+    })
+    expect(result.variant_cost.id).toBe('vc_1')
+  })
+})
+
+describe('DropshipperClient.batchVariantCosts', () => {
+  it('POST /admin/thor/dropshipper/variant-costs/batch', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/dropshipper/variant-costs/batch`, async ({ request }) => {
+        requireBearerToken(request)
+        const body = await request.json() as any
+        expect(body.costs).toHaveLength(2)
+        return HttpResponse.json({ updated: 2, errors: [] })
+      }),
+    )
+
+    const result = await client().batchVariantCosts({
+      account_id: 'acc_01',
+      currency_code: 'usd',
+      costs: [
+        { variant_id: 'var_1', cost_amount: 1000 },
+        { variant_id: 'var_2', cost_amount: 2000 },
+      ],
+    })
+    expect(result.updated).toBe(2)
+    expect(result.errors).toHaveLength(0)
+  })
+})
+
+describe('DropshipperClient.deleteVariantCost', () => {
+  it('DELETE /admin/thor/dropshipper/variant-costs/:id', async () => {
+    server.use(
+      http.delete(`${BASE}/admin/thor/dropshipper/variant-costs/vc_1`, ({ request }) => {
+        requireBearerToken(request)
+        return HttpResponse.json({ deleted: true, id: 'vc_1' })
+      }),
+    )
+
+    const result = await client().deleteVariantCost('vc_1')
+    expect(result.deleted).toBe(true)
+    expect(result.id).toBe('vc_1')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Products (Solo Y)
+// ---------------------------------------------------------------------------
+
+describe('DropshipperClient.getProducts', () => {
+  it('GET /admin/thor/dropshipper/products with defaults', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/dropshipper/products`, ({ request }) => {
+        requireBearerToken(request)
+        const url = new URL(request.url)
+        expect(url.searchParams.get('limit')).toBe('20')
+        return HttpResponse.json({ products: [], count: 0, offset: 0, limit: 20 })
+      }),
+    )
+
+    const result = await client().getProducts()
+    expect(result.products).toHaveLength(0)
+  })
+
+  it('forwards search and category filters', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/dropshipper/products`, ({ request }) => {
+        const url = new URL(request.url)
+        expect(url.searchParams.get('q')).toBe('shirt')
+        expect(url.searchParams.get('category_id')).toBe('cat_1')
+        return HttpResponse.json({ products: [], count: 0, offset: 0, limit: 20 })
+      }),
+    )
+
+    await client().getProducts({ q: 'shirt', category_id: 'cat_1' })
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Prices (Solo Y)
+// ---------------------------------------------------------------------------
+
+describe('DropshipperClient.updatePrices', () => {
+  it('PUT /admin/thor/dropshipper/prices', async () => {
+    server.use(
+      http.put(`${BASE}/admin/thor/dropshipper/prices`, async ({ request }) => {
+        requireBearerToken(request)
+        const body = await request.json() as any
+        expect(body.currency_code).toBe('usd')
+        expect(body.prices).toHaveLength(1)
+        return HttpResponse.json({ updated: 1, price_list_id: 'pl_01' })
+      }),
+    )
+
+    const result = await client().updatePrices({
+      currency_code: 'usd',
+      prices: [{ variant_id: 'var_1', amount: 5000 }],
+    })
+    expect(result.updated).toBe(1)
+    expect(result.price_list_id).toBe('pl_01')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Orders (Y + X)
+// ---------------------------------------------------------------------------
+
+describe('DropshipperClient.getOrders', () => {
+  it('GET /admin/thor/dropshipper/orders with defaults', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/dropshipper/orders`, ({ request }) => {
+        requireBearerToken(request)
+        return HttpResponse.json({ orders: [], count: 0, offset: 0, limit: 20 })
+      }),
+    )
+
+    const result = await client().getOrders()
+    expect(result.orders).toHaveLength(0)
+  })
+
+  it('forwards status and settlement_status filters', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/dropshipper/orders`, ({ request }) => {
+        const url = new URL(request.url)
+        expect(url.searchParams.get('status')).toBe('completed')
+        expect(url.searchParams.get('settlement_status')).toBe('unsettled')
+        return HttpResponse.json({ orders: [], count: 0, offset: 0, limit: 20 })
+      }),
+    )
+
+    await client().getOrders({ status: 'completed', settlement_status: 'unsettled' })
+  })
+})
+
+describe('DropshipperClient.getOrder', () => {
+  it('GET /admin/thor/dropshipper/orders/:id', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/dropshipper/orders/ord_1`, ({ request }) => {
+        requireBearerToken(request)
+        return HttpResponse.json({
+          order: {
+            id: 'ord_1',
+            display_id: 42,
+            status: 'completed',
+            fulfillment_status: 'fulfilled',
+            created_at: '2026-01-01T00:00:00Z',
+            currency_code: 'usd',
+            customer: { id: 'cus_1', full_name: 'John Doe', email: 'john@doe.com' },
+            shipping_address: { full_name: 'John Doe', address_1: '123 Main', city: 'NY', province: null, postal_code: '10001', country_code: 'us' },
+            items: [],
+            totals: { subtotal: 5000, shipping_total: 0, discount_total: 0, total: 5000, cost_total: 2000, profit: 3000, margin_percent: 60 },
+            payment_collected_by: 'dropshipper',
+            settlement_status: 'unsettled',
+            timeline: [],
+          },
+        })
+      }),
+    )
+
+    const result = await client().getOrder('ord_1')
+    expect(result.order.id).toBe('ord_1')
+    expect(result.order.totals.profit).toBe(3000)
+  })
+})
+
+describe('DropshipperClient.createOrder', () => {
+  it('POST /admin/thor/dropshipper/orders', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/dropshipper/orders`, async ({ request }) => {
+        requireBearerToken(request)
+        const body = await request.json() as any
+        expect(body.customer_id).toBe('cus_1')
+        return HttpResponse.json({
+          order: { id: 'ord_new', display_id: 43, status: 'pending', total: 5000, profit: 2000, created_at: '2026-01-01T00:00:00Z' },
+        })
+      }),
+    )
+
+    const result = await client().createOrder({
+      customer_id: 'cus_1',
+      currency_code: 'usd',
+      items: [{ variant_id: 'var_1', quantity: 1 }],
+      shipping_address: { full_name: 'John', address_1: '123 Main', city: 'NY', province: null, postal_code: '10001', country_code: 'us' },
+    })
+    expect(result.order.id).toBe('ord_new')
+  })
+})
+
+describe('DropshipperClient.setPaymentCollector', () => {
+  it('POST /admin/thor/dropshipper/orders/:id/set-payment-collector', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/dropshipper/orders/ord_1/set-payment-collector`, async ({ request }) => {
+        requireBearerToken(request)
+        const body = await request.json() as any
+        expect(body.payment_collected_by).toBe('provider')
+        return HttpResponse.json({ order_id: 'ord_1', payment_collected_by: 'provider', updated_at: '2026-01-02T00:00:00Z' })
+      }),
+    )
+
+    const result = await client().setPaymentCollector('ord_1', { payment_collected_by: 'provider' })
+    expect(result.payment_collected_by).toBe('provider')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Orders — Cancel/Edit (Y + X)
+// ---------------------------------------------------------------------------
+
+
+// ---------------------------------------------------------------------------
+// Order Notes
+// ---------------------------------------------------------------------------
+
+describe('DropshipperClient.getOrderNotes', () => {
+  it('GET /admin/thor/dropshipper/orders/:id/notes', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/dropshipper/orders/ord_1/notes`, ({ request }) => {
+        requireBearerToken(request)
+        return HttpResponse.json({
+          notes: [
+            {
+              id: 'note_1',
+              order_id: 'ord_1',
+              author_id: 'usr_1',
+              text: 'Customer requested expedited shipping',
+              created_at: '2026-01-01T10:00:00Z',
+            },
+            {
+              id: 'note_2',
+              order_id: 'ord_1',
+              author_id: 'usr_2',
+              text: 'Order confirmed and ready to ship',
+              created_at: '2026-01-01T11:00:00Z',
+            },
+          ],
+        })
+      }),
+    )
+
+    const result = await client().getOrderNotes('ord_1')
+    expect(result.notes).toHaveLength(2)
+    expect(result.notes[0].id).toBe('note_1')
+    expect(result.notes[0].text).toBe('Customer requested expedited shipping')
+    expect(result.notes[1].id).toBe('note_2')
+  })
+
+  it('GET /admin/thor/dropshipper/orders/:id/notes returns empty list', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/dropshipper/orders/ord_2/notes`, ({ request }) => {
+        requireBearerToken(request)
+        return HttpResponse.json({ notes: [] })
+      }),
+    )
+
+    const result = await client().getOrderNotes('ord_2')
+    expect(result.notes).toHaveLength(0)
+  })
+})
+
+describe('DropshipperClient.createOrderNote', () => {
+  it('POST /admin/thor/dropshipper/orders/:id/notes', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/dropshipper/orders/ord_1/notes`, async ({ request }) => {
+        requireBearerToken(request)
+        const body = await request.json() as any
+        expect(body.text).toBe('Shipped via FedEx')
+        return HttpResponse.json({
+          id: 'note_3',
+          order_id: 'ord_1',
+          author_id: 'usr_1',
+          text: 'Shipped via FedEx',
+          created_at: '2026-01-02T09:00:00Z',
+        })
+      }),
+    )
+
+    const result = await client().createOrderNote('ord_1', { text: 'Shipped via FedEx' })
+    expect(result.id).toBe('note_3')
+    expect(result.order_id).toBe('ord_1')
+    expect(result.text).toBe('Shipped via FedEx')
+    expect(result.author_id).toBe('usr_1')
+  })
+
+  it('POST /admin/thor/dropshipper/orders/:id/notes with multiline text', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/dropshipper/orders/ord_1/notes`, async ({ request }) => {
+        requireBearerToken(request)
+        const body = await request.json() as any
+        expect(body.text).toContain('Line 1')
+        expect(body.text).toContain('Line 2')
+        return HttpResponse.json({
+          id: 'note_4',
+          order_id: 'ord_1',
+          author_id: 'usr_2',
+          text: body.text,
+          created_at: '2026-01-02T10:00:00Z',
+        })
+      }),
+    )
+
+    const result = await client().createOrderNote('ord_1', { text: 'Line 1\nLine 2' })
+    expect(result.id).toBe('note_4')
+  })
+})
+
+describe('DropshipperClient.deleteOrderNote', () => {
+  it('DELETE /admin/thor/dropshipper/orders/:id/notes/:noteId', async () => {
+    server.use(
+      http.delete(`${BASE}/admin/thor/dropshipper/orders/ord_1/notes/note_1`, ({ request }) => {
+        requireBearerToken(request)
+        return HttpResponse.json({ id: 'note_1', deleted: true })
+      }),
+    )
+
+    const result = await client().deleteOrderNote('ord_1', 'note_1')
+    expect(result.deleted).toBe(true)
+    expect(result.id).toBe('note_1')
+  })
+
+  it('DELETE /admin/thor/dropshipper/orders/:id/notes/:noteId throws on 404', async () => {
+    server.use(
+      http.delete(`${BASE}/admin/thor/dropshipper/orders/ord_1/notes/note_missing`, () =>
+        HttpResponse.json({ message: 'Note not found' }, { status: 404 }),
+      ),
+    )
+
+    await expect(client().deleteOrderNote('ord_1', 'note_missing')).rejects.toMatchObject({
+      name: 'ProviderAPIError',
+      provider: 'DROPSHIPPER_API_404',
+    })
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Categories (Solo Y)
+// ---------------------------------------------------------------------------
+
+describe('DropshipperClient.getCategories', () => {
+  it('GET /admin/thor/dropshipper/categories', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/dropshipper/categories`, ({ request }) => {
+        requireBearerToken(request)
+        return HttpResponse.json({ categories: [] })
+      }),
+    )
+
+    const result = await client().getCategories()
+    expect(result.categories).toHaveLength(0)
+  })
+
+  it('forwards parent_id and include_children', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/dropshipper/categories`, ({ request }) => {
+        const url = new URL(request.url)
+        expect(url.searchParams.get('parent_id')).toBe('cat_root')
+        expect(url.searchParams.get('include_children')).toBe('true')
+        return HttpResponse.json({ categories: [] })
+      }),
+    )
+
+    await client().getCategories({ parent_id: 'cat_root', include_children: true })
+  })
+})
+
+describe('DropshipperClient.createCategory', () => {
+  it('POST /admin/thor/dropshipper/categories', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/dropshipper/categories`, async ({ request }) => {
+        requireBearerToken(request)
+        const body = await request.json() as any
+        expect(body.name).toBe('Summer')
+        return HttpResponse.json({ id: 'cat_1', name: 'Summer', handle: 'summer', position: 0, parent_id: null })
+      }),
+    )
+
+    const result = await client().createCategory({ name: 'Summer' })
+    expect(result.id).toBe('cat_1')
+  })
+})
+
+describe('DropshipperClient.deleteCategory', () => {
+  it('DELETE /admin/thor/dropshipper/categories/:id', async () => {
+    server.use(
+      http.delete(`${BASE}/admin/thor/dropshipper/categories/cat_1`, ({ request }) => {
+        requireBearerToken(request)
+        return HttpResponse.json({ deleted: true, id: 'cat_1', unmapped_products: 3 })
+      }),
+    )
+
+    const result = await client().deleteCategory('cat_1')
+    expect(result.deleted).toBe(true)
+    expect(result.unmapped_products).toBe(3)
+  })
+})
+
+describe('DropshipperClient.createCategoryMapping', () => {
+  it('POST /admin/thor/dropshipper/category-mappings', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/dropshipper/category-mappings`, async ({ request }) => {
+        requireBearerToken(request)
+        const body = await request.json() as any
+        expect(body.category_id).toBe('cat_1')
+        expect(body.product_id).toBe('prod_1')
+        return HttpResponse.json({
+          mapping: { id: 'map_1', category_id: 'cat_1', product_id: 'prod_1', created_at: '2026-01-01T00:00:00Z' },
+        })
+      }),
+    )
+
+    const result = await client().createCategoryMapping({ category_id: 'cat_1', product_id: 'prod_1' })
+    expect(result.mapping.id).toBe('map_1')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Customers (Solo Y)
+// ---------------------------------------------------------------------------
+
+describe('DropshipperClient.getCustomers', () => {
+  it('GET /admin/thor/dropshipper/customers with defaults', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/dropshipper/customers`, ({ request }) => {
+        requireBearerToken(request)
+        const url = new URL(request.url)
+        expect(url.searchParams.get('limit')).toBe('20')
+        return HttpResponse.json({ customers: [], count: 0, offset: 0, limit: 20 })
+      }),
+    )
+
+    const result = await client().getCustomers()
+    expect(result.count).toBe(0)
+  })
+})
+
+describe('DropshipperClient.createCustomer', () => {
+  it('POST /admin/thor/dropshipper/customers', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/dropshipper/customers`, async ({ request }) => {
+        requireBearerToken(request)
+        const body = await request.json() as any
+        expect(body.email).toBe('customer@example.com')
+        return HttpResponse.json({
+          customer: { id: 'cus_new', email: 'customer@example.com', first_name: null, last_name: null, sales_channel_id: 'sc_01', created_at: '2026-01-01T00:00:00Z' },
+        })
+      }),
+    )
+
+    const result = await client().createCustomer({ email: 'customer@example.com', password: 'pass' })
+    expect(result.customer.id).toBe('cus_new')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Customer Addresses (Solo Y)
+// ---------------------------------------------------------------------------
+
+
+// ---------------------------------------------------------------------------
+// Account & Settlements (Y)
+// ---------------------------------------------------------------------------
+
+describe('DropshipperClient.getAccount', () => {
+  it('GET /admin/thor/dropshipper/account', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/dropshipper/account`, ({ request }) => {
+        requireBearerToken(request)
+        return HttpResponse.json({
+          account: {
+            id: 'acc_01',
+            provider_name: 'Acme',
+            currency_code: 'usd',
+            payment_terms_days: 15,
+            balance: { payable_to_provider: 10000, receivable_from_provider: 5000, net_balance: -5000, net_balance_label: 'You owe' },
+            pending_orders: { payable_count: 2, payable_total: 10000, receivable_count: 1, receivable_total: 5000 },
+          },
+        })
+      }),
+    )
+
+    const result = await client().getAccount()
+    expect(result.account.id).toBe('acc_01')
+    expect(result.account.balance.net_balance).toBe(-5000)
+  })
+})
+
+describe('DropshipperClient.getSettlements', () => {
+  it('GET /admin/thor/dropshipper/settlements with defaults', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/dropshipper/settlements`, ({ request }) => {
+        requireBearerToken(request)
+        const url = new URL(request.url)
+        expect(url.searchParams.get('limit')).toBe('20')
+        return HttpResponse.json({ settlements: [], count: 0, offset: 0, limit: 20 })
+      }),
+    )
+
+    const result = await client().getSettlements()
+    expect(result.settlements).toHaveLength(0)
+  })
+
+  it('forwards status and account_id filters', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/dropshipper/settlements`, ({ request }) => {
+        const url = new URL(request.url)
+        expect(url.searchParams.get('status')).toBe('pending')
+        expect(url.searchParams.get('account_id')).toBe('acc_01')
+        return HttpResponse.json({ settlements: [], count: 0, offset: 0, limit: 20 })
+      }),
+    )
+
+    await client().getSettlements({ status: 'pending', account_id: 'acc_01' })
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Admin Settlements (Solo X)
+// ---------------------------------------------------------------------------
+
+describe('DropshipperClient.createSettlement', () => {
+  it('POST /admin/thor/dropshipper/admin/settlements', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/dropshipper/admin/settlements`, async ({ request }) => {
+        requireBearerToken(request)
+        const body = await request.json() as any
+        expect(body.account_id).toBe('acc_01')
+        expect(body.order_ids).toHaveLength(2)
+        return HttpResponse.json({
+          settlement: { id: 'stl_1', type: 'payment_to_provider', amount: 5000, status: 'pending', notes: null, created_at: '2026-01-01T00:00:00Z', settled_at: null, confirmed_by: null },
+        })
+      }),
+    )
+
+    const result = await client().createSettlement({
+      account_id: 'acc_01',
+      type: 'payment_to_provider',
+      order_ids: ['ord_1', 'ord_2'],
+      amount: 5000,
+    })
+    expect(result.settlement.id).toBe('stl_1')
+  })
+})
+
+describe('DropshipperClient.confirmSettlement', () => {
+  it('POST /admin/thor/dropshipper/admin/settlements/:id/confirm', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/dropshipper/admin/settlements/stl_1/confirm`, async ({ request }) => {
+        requireBearerToken(request)
+        return HttpResponse.json({
+          settlement: { id: 'stl_1', type: 'payment_to_provider', amount: 5000, status: 'confirmed', notes: 'done', created_at: '2026-01-01T00:00:00Z', settled_at: '2026-01-02T00:00:00Z', confirmed_by: 'usr_admin' },
+        })
+      }),
+    )
+
+    const result = await client().confirmSettlement('stl_1', { notes: 'done' })
+    expect(result.settlement.status).toBe('confirmed')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Admin Settlements list (Solo X)
+// ---------------------------------------------------------------------------
+
+describe('DropshipperClient.getAdminSettlements', () => {
+  it('GET /admin/thor/dropshipper/admin/settlements with defaults', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/dropshipper/admin/settlements`, ({ request }) => {
+        requireBearerToken(request)
+        const url = new URL(request.url)
+        expect(url.searchParams.get('limit')).toBe('20')
+        expect(url.searchParams.get('offset')).toBe('0')
+        return HttpResponse.json({ settlements: [], count: 0, offset: 0, limit: 20 })
+      }),
+    )
+
+    const result = await client().getAdminSettlements()
+    expect(result.settlements).toHaveLength(0)
+  })
+
+  it('forwards status and account_id filters', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/dropshipper/admin/settlements`, ({ request }) => {
+        const url = new URL(request.url)
+        expect(url.searchParams.get('status')).toBe('pending')
+        expect(url.searchParams.get('account_id')).toBe('acc_01')
+        return HttpResponse.json({ settlements: [], count: 0, offset: 0, limit: 20 })
+      }),
+    )
+
+    await client().getAdminSettlements({ status: 'pending', account_id: 'acc_01' })
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Admin Account Management (Solo X)
+// ---------------------------------------------------------------------------
+
+describe('DropshipperClient.getAdminAccounts', () => {
+  it('GET /admin/thor/dropshipper/admin/accounts', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/dropshipper/admin/accounts`, ({ request }) => {
+        requireBearerToken(request)
+        return HttpResponse.json({ accounts: [{ id: 'acc_01', provider_name: 'Acme', sales_channel_id: 'sc_01', sales_channel_name: 'Acme', currency_code: 'usd', payment_terms_days: 15 }] })
+      }),
+    )
+
+    const result = await client().getAdminAccounts()
+    expect(result.accounts).toHaveLength(1)
+    expect(result.accounts[0].id).toBe('acc_01')
+  })
+})
+
+describe('DropshipperClient.getAdminAccountBalance', () => {
+  it('GET /admin/thor/dropshipper/admin/accounts/:id/balance', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/dropshipper/admin/accounts/acc_01/balance`, ({ request }) => {
+        requireBearerToken(request)
+        return HttpResponse.json({
+          account: { id: 'acc_01', provider_name: 'Acme', currency_code: 'usd', payment_terms_days: 15, sales_channel_id: 'sc_01' },
+          balance: {
+            payable_to_provider: 10000, receivable_from_provider: 0, net_balance: -10000, net_balance_label: 'Owes',
+            payable_count: 2, payable_order_ids: ['ord_1', 'ord_2'], payable_orders: [],
+            receivable_count: 0, receivable_order_ids: [], receivable_orders: [],
+            unclassified_orders: 0,
+          },
+        })
+      }),
+    )
+
+    const result = await client().getAdminAccountBalance('acc_01')
+    expect(result.balance.payable_count).toBe(2)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Promotions (Solo Y)
+// ---------------------------------------------------------------------------
+
+describe('DropshipperClient.getPromotions', () => {
+  it('GET /admin/thor/dropshipper/promotions with defaults', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/dropshipper/promotions`, ({ request }) => {
+        requireBearerToken(request)
+        const url = new URL(request.url)
+        expect(url.searchParams.get('limit')).toBe('20')
+        return HttpResponse.json({ promotions: [], count: 0, offset: 0, limit: 20 })
+      }),
+    )
+
+    const result = await client().getPromotions()
+    expect(result.promotions).toHaveLength(0)
+  })
+})
+
+describe('DropshipperClient.createPromotion', () => {
+  it('POST /admin/thor/dropshipper/promotions', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/dropshipper/promotions`, async ({ request }) => {
+        requireBearerToken(request)
+        const body = await request.json() as any
+        expect(body.code).toBe('SUMMER10')
+        expect(body.type).toBe('percentage')
+        return HttpResponse.json({
+          id: 'promo_1', code: 'SUMMER10', type: 'percentage', value: 10,
+          status: 'active', usage_limit: null, usage_count: 0, starts_at: null, ends_at: null,
+        })
+      }),
+    )
+
+    const result = await client().createPromotion({ code: 'SUMMER10', type: 'percentage', value: 10 })
+    expect(result.id).toBe('promo_1')
+  })
+})
+
+describe('DropshipperClient.getPromotion', () => {
+  it('GET /admin/thor/dropshipper/promotions/:id', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/dropshipper/promotions/promo_1`, ({ request }) => {
+        requireBearerToken(request)
+        return HttpResponse.json({
+          id: 'promo_1', code: 'SUMMER10', type: 'percentage', value: 10,
+          status: 'active', usage_limit: null, usage_count: 5, starts_at: null, ends_at: null,
+        })
+      }),
+    )
+
+    const result = await client().getPromotion('promo_1')
+    expect(result.id).toBe('promo_1')
+    expect(result.usage_count).toBe(5)
+  })
+})
+
+describe('DropshipperClient.deletePromotion', () => {
+  it('DELETE /admin/thor/dropshipper/promotions/:id', async () => {
+    server.use(
+      http.delete(`${BASE}/admin/thor/dropshipper/promotions/promo_1`, ({ request }) => {
+        requireBearerToken(request)
+        return HttpResponse.json({ deleted: true, id: 'promo_1' })
+      }),
+    )
+
+    const result = await client().deletePromotion('promo_1')
+    expect(result.deleted).toBe(true)
+    expect(result.id).toBe('promo_1')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Dashboard (Solo Y)
+// ---------------------------------------------------------------------------
+
+describe('DropshipperClient.getDashboardStats', () => {
+  it('GET /admin/thor/dropshipper/dashboard/stats with defaults', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/dropshipper/dashboard/stats`, ({ request }) => {
+        requireBearerToken(request)
+        return HttpResponse.json({
+          stats: {
+            period: { from: '2026-04-21', to: '2026-05-21', label: '30d' },
+            current: { orders_count: 5, revenue_total: 25000, profit_total: 10000, avg_margin_percent: 40, avg_order_value: 5000, currency_code: 'usd' },
+            previous: { orders_count: 3, revenue_total: 15000, profit_total: 6000, avg_margin_percent: 40, avg_order_value: 5000, currency_code: 'usd' },
+            changes: { orders_count_pct: 66, revenue_total_pct: 66, profit_total_pct: 66, avg_margin_percent_pct: 0 },
+            orders_by_status: { completed: 4, pending: 1 },
+            settlement_summary: { payable_to_provider: 5000, receivable_from_provider: 0, net_balance: -5000, net_balance_label: 'Owes', pending_settlement_records: 1, currency_code: 'usd' },
+            recent_orders: [],
+            top_products_by_profit: [],
+          },
+        })
+      }),
+    )
+
+    const result = await client().getDashboardStats()
+    expect(result.stats?.current.orders_count).toBe(5)
+  })
+
+  it('forwards period and currency_code', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/dropshipper/dashboard/stats`, ({ request }) => {
+        const url = new URL(request.url)
+        expect(url.searchParams.get('period')).toBe('7d')
+        expect(url.searchParams.get('currency_code')).toBe('mxn')
+        return HttpResponse.json({ stats: undefined })
+      }),
+    )
+
+    await client().getDashboardStats({ period: '7d', currency_code: 'mxn' })
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Error handling
+// ---------------------------------------------------------------------------
+
+describe('DropshipperClient error handling', () => {
+  it('throws ProviderAPIError on 401', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/dropshipper/account`, () =>
+        HttpResponse.json({ message: 'Unauthorized' }, { status: 401 }),
+      ),
+    )
+
+    await expect(client().getAccount()).rejects.toMatchObject({
+      name: 'ProviderAPIError',
+      provider: 'DROPSHIPPER_API_401',
+    })
+  })
+
+  it('throws ProviderAPIError on 403', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/dropshipper/onboard`, () =>
+        HttpResponse.json({ message: 'Forbidden' }, { status: 403 }),
+      ),
+    )
+
+    await expect(
+      client().onboardDropshipper({ business_name: 'X', email: 'x@x.com', password: 'x' }),
+    ).rejects.toMatchObject({
+      name: 'ProviderAPIError',
+      provider: 'DROPSHIPPER_API_403',
+    })
+  })
+
+  it('throws ProviderAPIError on 404', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/dropshipper/orders/ord_missing`, () =>
+        HttpResponse.json({ message: 'Order not found' }, { status: 404 }),
+      ),
+    )
+
+    await expect(client().getOrder('ord_missing')).rejects.toMatchObject({
+      name: 'ProviderAPIError',
+      provider: 'DROPSHIPPER_API_404',
+    })
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Order Cancel & Edits — B-04
+// ---------------------------------------------------------------------------
+
+describe('DropshipperClient.cancelOrder', () => {
+  it('POST /admin/thor/dropshipper/orders/:id/cancel', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/dropshipper/orders/ord_1/cancel`, ({ request }) => {
+        requireBearerToken(request)
+        return HttpResponse.json({ order: { id: 'ord_1', status: 'canceled' } })
+      }),
+    )
+
+    const result = await client().cancelOrder('ord_1')
+    expect(result.order.id).toBe('ord_1')
+    expect(result.order.status).toBe('canceled')
+  })
+})
+
+describe('DropshipperClient.createOrderEdit', () => {
+  it('POST /admin/thor/dropshipper/orders/:id/edit', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/dropshipper/orders/ord_1/edit`, async ({ request }) => {
+        requireBearerToken(request)
+        const body = await request.json() as any
+        expect(body.internal_note).toBe('Fix quantity')
+        return HttpResponse.json({
+          order_edit: { id: 'oe_1', order_id: 'ord_1', status: 'created' },
+        })
+      }),
+    )
+
+    const result = await client().createOrderEdit('ord_1', { internal_note: 'Fix quantity' })
+    expect(result.order_edit.id).toBe('oe_1')
+    expect(result.order_edit.order_id).toBe('ord_1')
+  })
+})
+
+describe('DropshipperClient.addOrderEditItem', () => {
+  it('POST /admin/thor/dropshipper/orders/:id/edit/items', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/dropshipper/orders/ord_1/edit/items`, async ({ request }) => {
+        requireBearerToken(request)
+        const body = await request.json() as any
+        expect(body.variant_id).toBe('var_99')
+        expect(body.quantity).toBe(2)
+        return HttpResponse.json({ order_edit: { id: 'oe_1' } })
+      }),
+    )
+
+    const result = await client().addOrderEditItem('ord_1', {
+      variant_id: 'var_99',
+      quantity: 2,
+    })
+    expect(result.order_edit.id).toBe('oe_1')
+  })
+})
+
+describe('DropshipperClient.confirmOrderEdit', () => {
+  it('POST /admin/thor/dropshipper/orders/:id/edit/confirm', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/dropshipper/orders/ord_1/edit/confirm`, ({ request }) => {
+        requireBearerToken(request)
+        return HttpResponse.json({ order: { id: 'ord_1' } })
+      }),
+    )
+
+    const result = await client().confirmOrderEdit('ord_1')
+    expect(result.order.id).toBe('ord_1')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Customer Addresses — B-06
+// ---------------------------------------------------------------------------
+
+describe('DropshipperClient.getCustomerAddresses', () => {
+  it('GET /admin/thor/dropshipper/customers/:id/addresses', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/dropshipper/customers/cus_1/addresses`, ({ request }) => {
+        requireBearerToken(request)
+        return HttpResponse.json({
+          addresses: [{ id: 'addr_1', first_name: 'John', sales_channel_id: 'sc_01' }],
+        })
+      }),
+    )
+
+    const result = await client().getCustomerAddresses('cus_1')
+    expect(result.addresses).toHaveLength(1)
+    expect(result.addresses[0].id).toBe('addr_1')
+  })
+})
+
+describe('DropshipperClient.createCustomerAddress', () => {
+  it('POST /admin/thor/dropshipper/customers/:id/addresses', async () => {
+    const body = {
+      first_name: 'John',
+      last_name: 'Doe',
+      address_1: '123 Main St',
+      city: 'Bogota',
+      postal_code: '110111',
+      country_code: 'co',
+    }
+    server.use(
+      http.post(`${BASE}/admin/thor/dropshipper/customers/cus_1/addresses`, async ({ request }) => {
+        requireBearerToken(request)
+        const reqBody = await request.json() as any
+        expect(reqBody.first_name).toBe('John')
+        return HttpResponse.json({
+          address: { id: 'addr_new', ...reqBody, sales_channel_id: 'sc_01' },
+        })
+      }),
+    )
+
+    const result = await client().createCustomerAddress('cus_1', body)
+    expect(result.address.id).toBe('addr_new')
+    expect(result.address.sales_channel_id).toBe('sc_01')
+  })
+})
+
+describe('DropshipperClient.updateCustomerAddress', () => {
+  it('PUT /admin/thor/dropshipper/customers/:id/addresses/:addressId', async () => {
+    server.use(
+      http.put(`${BASE}/admin/thor/dropshipper/customers/cus_1/addresses/addr_1`, async ({ request }) => {
+        requireBearerToken(request)
+        const body = await request.json() as any
+        expect(body.city).toBe('Medellin')
+        return HttpResponse.json({
+          address: { id: 'addr_1', city: 'Medellin', sales_channel_id: 'sc_01' },
+        })
+      }),
+    )
+
+    const result = await client().updateCustomerAddress('cus_1', 'addr_1', { city: 'Medellin' })
+    expect(result.address.city).toBe('Medellin')
+  })
+})
+
+describe('DropshipperClient.deleteCustomerAddress', () => {
+  it('DELETE /admin/thor/dropshipper/customers/:id/addresses/:addressId', async () => {
+    server.use(
+      http.delete(`${BASE}/admin/thor/dropshipper/customers/cus_1/addresses/addr_1`, ({ request }) => {
+        requireBearerToken(request)
+        return HttpResponse.json({ deleted: true, id: 'addr_1' })
+      }),
+    )
+
+    const result = await client().deleteCustomerAddress('cus_1', 'addr_1')
+    expect(result.deleted).toBe(true)
+    expect(result.id).toBe('addr_1')
+  })
+})