@thorprovider/medusa-extended 1.0.0

package/src/admin.test.ts

@@ -0,0 +1,404 @@
+/**
+ * @fileoverview Tests for MedusaAdminClient
+ *
+ * Uses msw to intercept fetch calls and verify that each method:
+ * - Hits the correct URL and HTTP method
+ * - Sends `x-medusa-access-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 { MedusaAdminClient } from './admin'
+
+const BASE = 'https://medusa.example.com'
+const API_KEY = 'test-admin-key'
+
+function client() {
+  return new MedusaAdminClient({ baseUrl: BASE, apiKey: API_KEY })
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function requireAdminKey(request: Request) {
+  expect(request.headers.get('x-medusa-access-token')).toBe(API_KEY)
+}
+
+// ---------------------------------------------------------------------------
+// Sales Channel — Customers
+// ---------------------------------------------------------------------------
+
+describe('MedusaAdminClient.getChannelCustomers', () => {
+  it('GET /admin/thor/sales-channels/:id/customers with defaults', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/sales-channels/sc_01/customers`, ({ request }) => {
+        requireAdminKey(request)
+        const url = new URL(request.url)
+        expect(url.searchParams.get('limit')).toBe('20')
+        expect(url.searchParams.get('offset')).toBe('0')
+        return HttpResponse.json({ customers: [{ id: 'cus_1', email: 'a@b.com', sales_channel_ids: ['sc_01'] }], count: 1 })
+      }),
+    )
+
+    const result = await client().getChannelCustomers('sc_01')
+    expect(result.customers).toHaveLength(1)
+    expect(result.count).toBe(1)
+  })
+
+  it('forwards custom limit/offset', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/sales-channels/sc_01/customers`, ({ request }) => {
+        const url = new URL(request.url)
+        expect(url.searchParams.get('limit')).toBe('5')
+        expect(url.searchParams.get('offset')).toBe('10')
+        return HttpResponse.json({ customers: [], count: 0 })
+      }),
+    )
+
+    await client().getChannelCustomers('sc_01', { limit: 5, offset: 10 })
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Sales Channel — API Keys
+// ---------------------------------------------------------------------------
+
+describe('MedusaAdminClient.getChannelApiKeys', () => {
+  it('GET /admin/thor/sales-channels/:id/api-keys', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/sales-channels/sc_01/api-keys`, ({ request }) => {
+        requireAdminKey(request)
+        return HttpResponse.json({ api_keys: [{ id: 'apk_1', token: 'pk_live_xxx', sales_channel_id: 'sc_01' }] })
+      }),
+    )
+
+    const result = await client().getChannelApiKeys('sc_01')
+    expect(result.api_keys).toHaveLength(1)
+    expect(result.api_keys[0].id).toBe('apk_1')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Sales Channel — Categories
+// ---------------------------------------------------------------------------
+
+describe('MedusaAdminClient.getChannelCategories', () => {
+  it('GET /admin/thor/sales-channels/:id/categories with include_descendants', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/sales-channels/sc_01/categories`, ({ request }) => {
+        const url = new URL(request.url)
+        expect(url.searchParams.get('include_descendants')).toBe('true')
+        return HttpResponse.json({ categories: [], count: 0 })
+      }),
+    )
+
+    const result = await client().getChannelCategories('sc_01', { include_descendants: true })
+    expect(result.categories).toHaveLength(0)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Category — Sales Channels
+// ---------------------------------------------------------------------------
+
+describe('MedusaAdminClient.getCategorySalesChannels', () => {
+  it('GET /admin/thor/categories/:id/sales-channels', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/categories/cat_01/sales-channels`, ({ request }) => {
+        requireAdminKey(request)
+        return HttpResponse.json({ sales_channels: [{ id: 'sc_01', name: 'Main' }] })
+      }),
+    )
+
+    const result = await client().getCategorySalesChannels('cat_01')
+    expect(result.sales_channels).toHaveLength(1)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Category — Assign / Unassign
+// ---------------------------------------------------------------------------
+
+describe('MedusaAdminClient.assignCategoryToChannels', () => {
+  it('POST /admin/thor/categories/:id/sales-channels', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/categories/cat_01/sales-channels`, async ({ request }) => {
+        requireAdminKey(request)
+        const body = await request.clone().json() as any
+        expect(body.sales_channel_ids).toEqual(['sc_01'])
+        return HttpResponse.json({ message: 'ok', linked: 1 })
+      }),
+    )
+
+    const result = await client().assignCategoryToChannels('cat_01', { sales_channel_ids: ['sc_01'] })
+    expect(result.linked).toBe(1)
+  })
+})
+
+describe('MedusaAdminClient.unassignCategoryFromChannels', () => {
+  it('DELETE /admin/thor/categories/:id/sales-channels with body', async () => {
+    server.use(
+      http.delete(`${BASE}/admin/thor/categories/cat_01/sales-channels`, async ({ request }) => {
+        requireAdminKey(request)
+        const body = await request.clone().json() as any
+        expect(body.sales_channel_ids).toEqual(['sc_01'])
+        return HttpResponse.json({ message: 'ok', dismissed: 1 })
+      }),
+    )
+
+    const result = await client().unassignCategoryFromChannels('cat_01', { sales_channel_ids: ['sc_01'] })
+    expect(result.dismissed).toBe(1)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Collection — Sales Channels
+// ---------------------------------------------------------------------------
+
+describe('MedusaAdminClient.getCollectionSalesChannels', () => {
+  it('GET /admin/thor/collections/:id/sales-channels', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/collections/col_01/sales-channels`, ({ request }) => {
+        requireAdminKey(request)
+        return HttpResponse.json({ sales_channels: [{ id: 'sc_01', name: 'Main' }] })
+      }),
+    )
+
+    const result = await client().getCollectionSalesChannels('col_01')
+    expect(result.sales_channels).toHaveLength(1)
+  })
+})
+
+describe('MedusaAdminClient.assignCollectionToChannels', () => {
+  it('POST /admin/thor/collections/:id/sales-channels', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/collections/col_01/sales-channels`, async ({ request }) => {
+        const body = await request.clone().json() as any
+        expect(body.sales_channel_ids).toEqual(['sc_01'])
+        return HttpResponse.json({ message: 'ok', linked: 1 })
+      }),
+    )
+
+    const result = await client().assignCollectionToChannels('col_01', { sales_channel_ids: ['sc_01'] })
+    expect(result.linked).toBe(1)
+  })
+})
+
+describe('MedusaAdminClient.unassignCollectionFromChannels', () => {
+  it('DELETE /admin/thor/collections/:id/sales-channels', async () => {
+    server.use(
+      http.delete(`${BASE}/admin/thor/collections/col_01/sales-channels`, async ({ request }) => {
+        const body = await request.clone().json() as any
+        expect(body.sales_channel_ids).toEqual(['sc_01'])
+        return HttpResponse.json({ message: 'ok', dismissed: 1 })
+      }),
+    )
+
+    const result = await client().unassignCollectionFromChannels('col_01', { sales_channel_ids: ['sc_01'] })
+    expect(result.dismissed).toBe(1)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Storefront Config
+// ---------------------------------------------------------------------------
+
+describe('MedusaAdminClient.getStorefrontConfig', () => {
+  it('GET /admin/thor/storefront-config/:id', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/storefront-config/sc_01`, ({ request }) => {
+        requireAdminKey(request)
+        return HttpResponse.json({
+          storefront_config: {
+            id: 'scfg_01',
+            sales_channel_id: 'sc_01',
+            theme_accent_color: '#000',
+            logo_url: '',
+            currency_code: 'USD',
+            seo_defaults: { title: 'Store', description: '' },
+            created_at: '2026-01-01T00:00:00Z',
+            updated_at: '2026-01-01T00:00:00Z',
+          },
+        })
+      }),
+    )
+
+    const result = await client().getStorefrontConfig('sc_01')
+    expect(result.storefront_config.id).toBe('scfg_01')
+  })
+})
+
+describe('MedusaAdminClient.updateStorefrontConfig', () => {
+  it('PUT /admin/thor/storefront-config/:id', async () => {
+    server.use(
+      http.put(`${BASE}/admin/thor/storefront-config/sc_01`, async ({ request }) => {
+        const body = await request.clone().json() as any
+        expect(body.theme_accent_color).toBe('#ff0000')
+        return HttpResponse.json({
+          storefront_config: {
+            id: 'scfg_01',
+            sales_channel_id: 'sc_01',
+            theme_accent_color: '#ff0000',
+            logo_url: '',
+            currency_code: 'USD',
+            seo_defaults: { title: 'Store', description: '' },
+            created_at: '2026-01-01T00:00:00Z',
+            updated_at: '2026-01-02T00:00:00Z',
+          },
+        })
+      }),
+    )
+
+    const result = await client().updateStorefrontConfig('sc_01', {
+      theme_accent_color: '#ff0000',
+      logo_url: '',
+      currency_code: 'USD',
+      seo_defaults: { title: 'Store', description: '' },
+    })
+    expect(result.storefront_config.theme_accent_color).toBe('#ff0000')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Site Config
+// ---------------------------------------------------------------------------
+
+describe('MedusaAdminClient.getSiteConfig', () => {
+  it('GET /admin/thor/site-config/:sales_channel_id', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/site-config/sc_01`, ({ request }) => {
+        requireAdminKey(request)
+        return HttpResponse.json({
+          site_config: {
+            id: 'scfg_01',
+            sales_channel_id: 'sc_01',
+            version: 'v1',
+            config: { theme: 'dark' },
+            created_at: '2026-01-01T00:00:00Z',
+            updated_at: '2026-01-01T00:00:00Z',
+            history: [],
+          },
+        })
+      }),
+    )
+
+    const result = await client().getSiteConfig('sc_01')
+    expect(result.site_config.id).toBe('scfg_01')
+  })
+})
+
+describe('MedusaAdminClient.updateSiteConfig', () => {
+  it('PUT /admin/thor/site-config/:sales_channel_id', async () => {
+    server.use(
+      http.put(`${BASE}/admin/thor/site-config/sc_01`, async ({ request }) => {
+        const body = await request.json() as any
+        expect(body.config).toEqual({ theme: 'light' })
+        return HttpResponse.json({
+          site_config: {
+            id: 'scfg_02',
+            sales_channel_id: 'sc_01',
+            version: 'v2',
+            config: { theme: 'light' },
+            created_at: '2026-01-01T00:00:00Z',
+            updated_at: '2026-01-02T00:00:00Z',
+            history: [],
+          },
+        })
+      }),
+    )
+
+    const result = await client().updateSiteConfig('sc_01', { config: { theme: 'light' } })
+    expect(result.site_config.version).toBe('v2')
+  })
+})
+
+describe('MedusaAdminClient.getSiteConfigHistory', () => {
+  it('GET /admin/thor/site-config/:id/history with defaults', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/site-config/sc_01/history`, ({ request }) => {
+        requireAdminKey(request)
+        const url = new URL(request.url)
+        expect(url.searchParams.get('limit')).toBe('20')
+        expect(url.searchParams.get('offset')).toBe('0')
+        return HttpResponse.json({ history: [], count: 0 })
+      }),
+    )
+
+    const result = await client().getSiteConfigHistory('sc_01')
+    expect(result.count).toBe(0)
+  })
+
+  it('forwards custom limit/offset', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/site-config/sc_01/history`, ({ request }) => {
+        const url = new URL(request.url)
+        expect(url.searchParams.get('limit')).toBe('5')
+        expect(url.searchParams.get('offset')).toBe('10')
+        return HttpResponse.json({ history: [], count: 0 })
+      }),
+    )
+
+    await client().getSiteConfigHistory('sc_01', { limit: 5, offset: 10 })
+  })
+})
+
+describe('MedusaAdminClient.restoreSiteConfig', () => {
+  it('POST /admin/thor/site-config/:id/restore/:version', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/site-config/sc_01/restore/v1`, ({ request }) => {
+        requireAdminKey(request)
+        return HttpResponse.json({
+          site_config: {
+            id: 'scfg_03',
+            sales_channel_id: 'sc_01',
+            version: 'v3',
+            config: { theme: 'dark' },
+            created_at: '2026-01-01T00:00:00Z',
+            updated_at: '2026-01-03T00:00:00Z',
+            history: [],
+          },
+        })
+      }),
+    )
+
+    const result = await client().restoreSiteConfig('sc_01', 'v1')
+    expect(result.site_config.version).toBe('v3')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Error handling
+// ---------------------------------------------------------------------------
+
+describe('MedusaAdminClient error handling', () => {
+  it('throws ProviderAPIError on 404', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/sales-channels/sc_missing/customers`, () =>
+        HttpResponse.json({ message: 'Sales channel not found' }, { status: 404 }),
+      ),
+    )
+
+    await expect(client().getChannelCustomers('sc_missing')).rejects.toMatchObject({
+      name: 'ProviderAPIError',
+      provider: 'ADMIN_API_404',
+    })
+  })
+
+  it('throws ProviderAPIError on 401', async () => {
+    server.use(
+      http.get(`${BASE}/admin/thor/sales-channels/sc_01/api-keys`, () =>
+        HttpResponse.json({ message: 'Unauthorized' }, { status: 401 }),
+      ),
+    )
+
+    await expect(client().getChannelApiKeys('sc_01')).rejects.toMatchObject({
+      name: 'ProviderAPIError',
+      provider: 'ADMIN_API_401',
+    })
+  })
+})