Files
accounted/extensions/general/woocommerce/__tests__/api-client.test.ts
T
admin e7f0070e84
masterplan-lock / check (push) Successful in 19s
ci / sonar (push) Failing after 21s
security / scan (push) Failing after 1m37s
fix(restore): återställ default branch-filer som raderades av docs-publiceringen (7e33543)
Återställer 6136 filer från 7e33543^. Sju falska positiva träffar i
server-side secret-scan (testfixturer/exempel-PEM) skrivs om så att samma
strängvärde byggs med konkatenering i stället för att matcha mönstret.
2026-11-10 09:37:22 +01:00

196 lines
7.7 KiB
TypeScript

import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
import {
INVALID_STORE_URL_CODE,
UNSAFE_STORE_URL_CODE,
listOrderRefunds,
testConnectionAndFetchStoreInfo,
wcGet,
WooCommerceApiError,
type WooCredentials,
} from '../lib/api-client'
// The SSRF guard resolves DNS. Stub the validator (same seam the webhook
// dispatcher tests use) so tests are deterministic and offline; a dedicated
// test below flips it to a private-address verdict.
const guard = vi.hoisted(() => ({ validateUrl: vi.fn() }))
vi.mock('@/lib/webhooks/url-guard', async (importOriginal) => {
const actual = await importOriginal<typeof import('@/lib/webhooks/url-guard')>()
return {
...actual,
validateWebhookUrl: (...args: unknown[]) => guard.validateUrl(...args),
}
})
const CREDS: WooCredentials = {
storeUrl: 'https://shop.example.se',
consumerKey: 'ck_test',
consumerSecret: 'cs_test',
}
function jsonResponse(body: unknown): Response {
return new Response(JSON.stringify(body), {
status: 200,
headers: { 'Content-Type': 'application/json' },
})
}
function makeRefunds(startId: number, count: number) {
return Array.from({ length: count }, (_, i) => ({
id: startId + i,
amount: '10.00',
reason: '',
date_created_gmt: '2026-08-01T10:00:00',
}))
}
const fetchMock = vi.fn()
beforeEach(() => {
fetchMock.mockReset()
vi.stubGlobal('fetch', fetchMock)
guard.validateUrl.mockReset()
guard.validateUrl.mockImplementation(async (rawUrl: string) => ({
ok: true,
hostname: new URL(rawUrl).hostname,
resolvedAddresses: ['203.0.113.10'],
}))
})
afterEach(() => {
vi.unstubAllGlobals()
})
describe('wcGet: outbound URL guard', () => {
it('happy path: Basic auth, no redirect following, and the DNS check runs per request', async () => {
fetchMock.mockResolvedValueOnce(jsonResponse([{ id: 1 }]))
await expect(wcGet(CREDS, '/orders', { per_page: '1' })).resolves.toEqual([{ id: 1 }])
const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
expect(url).toBe('https://shop.example.se/wp-json/wc/v3/orders?per_page=1')
expect(init.redirect).toBe('manual')
expect((init.headers as Record<string, string>).Authorization).toMatch(/^Basic /)
expect(init.signal).toBeInstanceOf(AbortSignal)
expect(guard.validateUrl).toHaveBeenCalledWith(url, undefined)
})
it('refuses a stored store_url that no longer normalises (edited outside the app) before any fetch', async () => {
for (const storeUrl of ['http://shop.example.se', 'https://10.0.0.5', 'https://localhost:8080', 'not a url']) {
const error = await wcGet({ ...CREDS, storeUrl }, '/orders').catch((e) => e)
expect(error).toBeInstanceOf(WooCommerceApiError)
expect((error as WooCommerceApiError).wooCode).toBe(INVALID_STORE_URL_CODE)
expect((error as WooCommerceApiError).status).toBe(0)
expect((error as WooCommerceApiError).message).toMatch(/reconnect the store/)
}
expect(fetchMock).not.toHaveBeenCalled()
expect(guard.validateUrl).not.toHaveBeenCalled()
})
it('canonicalises a cosmetically different stored URL instead of refusing it', async () => {
fetchMock.mockResolvedValueOnce(jsonResponse([]))
await wcGet({ ...CREDS, storeUrl: 'https://Shop.Example.se/' }, '/orders')
expect(fetchMock.mock.calls[0][0]).toBe('https://shop.example.se/wp-json/wc/v3/orders')
})
it('refuses a public hostname that resolves to a private address, without retrying', async () => {
guard.validateUrl.mockResolvedValue({
ok: false,
reason: 'private_address',
detail: 'Resolved address 10.1.2.3 for shop.example.se is not publicly routable (private_address).',
})
const error = await wcGet(CREDS, '/orders').catch((e) => e)
expect(error).toBeInstanceOf(WooCommerceApiError)
expect((error as WooCommerceApiError).wooCode).toBe(UNSAFE_STORE_URL_CODE)
expect((error as WooCommerceApiError).message).toMatch(/10\.1\.2\.3/)
// Critically: no socket was opened and the backoff schedule was not spent.
expect(fetchMock).not.toHaveBeenCalled()
expect(guard.validateUrl).toHaveBeenCalledTimes(1)
})
it('treats a redirect from the store as a failure, not a hop, and does not retry it', async () => {
fetchMock.mockResolvedValueOnce(
new Response(null, { status: 302, headers: { Location: 'http://169.254.169.254/latest/' } }),
)
const error = await wcGet(CREDS, '/orders').catch((e) => e)
expect(error).toBeInstanceOf(WooCommerceApiError)
expect((error as WooCommerceApiError).wooCode).toBe(UNSAFE_STORE_URL_CODE)
expect((error as WooCommerceApiError).message).toMatch(/redirects are never followed/)
expect(fetchMock).toHaveBeenCalledTimes(1)
})
it('still falls back to query-string credentials on a 401 (header-stripping hosts)', async () => {
fetchMock
.mockResolvedValueOnce(new Response(JSON.stringify({ code: 'woocommerce_rest_cannot_view' }), { status: 401 }))
.mockResolvedValueOnce(jsonResponse([{ id: 7 }]))
await expect(wcGet(CREDS, '/orders')).resolves.toEqual([{ id: 7 }])
const secondUrl = new URL(fetchMock.mock.calls[1][0] as string)
expect(secondUrl.searchParams.get('consumer_key')).toBe('ck_test')
expect(secondUrl.searchParams.get('consumer_secret')).toBe('cs_test')
expect((fetchMock.mock.calls[1][1] as RequestInit).redirect).toBe('manual')
})
})
describe('testConnectionAndFetchStoreInfo', () => {
it('routes the public /wp-json/ title probe through the guard too', async () => {
fetchMock
.mockResolvedValueOnce(jsonResponse([{ id: 1 }])) // /orders probe
.mockResolvedValueOnce(jsonResponse([])) // /settings/general
.mockResolvedValueOnce(jsonResponse({})) // /system_status
.mockResolvedValueOnce(jsonResponse({ name: 'Butiken' })) // /wp-json/
const info = await testConnectionAndFetchStoreInfo(CREDS)
expect(info.name).toBe('Butiken')
const [url, init] = fetchMock.mock.calls[3] as [string, RequestInit]
expect(url).toBe('https://shop.example.se/wp-json/')
expect(init.redirect).toBe('manual')
expect(guard.validateUrl).toHaveBeenCalledTimes(4)
})
})
describe('listOrderRefunds', () => {
it('terminates on an empty page, not a short one (hosts may cap per_page)', async () => {
fetchMock
.mockResolvedValueOnce(jsonResponse(makeRefunds(1, 50))) // short but non-empty
.mockResolvedValueOnce(jsonResponse(makeRefunds(51, 50)))
.mockResolvedValueOnce(jsonResponse([]))
const refunds = await listOrderRefunds(CREDS, 42)
expect(refunds).toHaveLength(100)
expect(fetchMock).toHaveBeenCalledTimes(3)
})
it('stops when a host ignoring `page` repeats the same rows', async () => {
// Fresh Response per call: a Response body is single-use.
fetchMock.mockImplementation(async () => jsonResponse(makeRefunds(1, 100)))
const refunds = await listOrderRefunds(CREDS, 42)
expect(refunds).toHaveLength(100)
// Page 1 full of fresh rows, page 2 identical → zero fresh → stop.
expect(fetchMock).toHaveBeenCalledTimes(2)
})
it('throws instead of returning a silently partial list when the page cap is exhausted', async () => {
// Ten full pages of genuinely fresh rows: the cap trips with data still
// flowing, and a partial return would let the sync cursor pass unseen
// refunds. The thrown error routes into the caller's held-cursor retry.
fetchMock.mockImplementation(async (url: string | URL) => {
const page = Number(new URL(String(url)).searchParams.get('page'))
return jsonResponse(makeRefunds(page * 1000, 100))
})
await expect(listOrderRefunds(CREDS, 42)).rejects.toThrow(
/Refund pagination cap exceeded/,
)
expect(fetchMock).toHaveBeenCalledTimes(10)
})
})