Files
accounted/lib/webshop-orders/__tests__/ingest.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

413 lines
14 KiB
TypeScript

import { describe, it, expect, vi, beforeEach } from 'vitest'
import { createQueuedMockSupabase } from '@/tests/helpers'
import { removeWebshopOrders, upsertWebshopOrders } from '../ingest'
import type { WebshopOrderUpsert } from '../types'
import type { SupabaseClient } from '@supabase/supabase-js'
vi.mock('@/lib/currency/riksbanken', () => ({
fetchExchangeRate: vi.fn(async (currency: string) =>
currency === 'SEK'
? { currency, rate: 1, date: '2026-08-01' }
: currency === 'EUR'
? { currency, rate: 11.5, date: '2026-08-01' }
: null,
),
}))
const COMPANY = 'company-1'
const USER = 'user-1'
function makeUpsert(overrides: Partial<WebshopOrderUpsert> = {}): WebshopOrderUpsert {
return {
platform: 'woocommerce',
store_scope: 'butik.example.se',
store_label: 'Butiken',
connection_id: 'conn-1',
row_type: 'order',
parent_external_id: null,
external_id: 'woo_butik.example.se_order_1001',
platform_order_id: '1001',
order_number: '1001',
status: 'processing',
is_paid: true,
order_date: '2026-08-01',
paid_date: '2026-08-01',
currency: 'SEK',
total: 500,
total_tax: 100,
vat_breakdown: [{ rate: 25, net: 400, tax: 100 }],
line_items: [],
customer_name: 'Test Person',
customer_company: null,
customer_email: 'test@example.se',
customer_orgnr: null,
customer_country: 'SE',
payment_method: 'swish',
payment_method_title: 'Swish',
gateway_reference: null,
refunded_total: 0,
...overrides,
}
}
function existingRow(overrides: Record<string, unknown> = {}) {
return {
id: 'row-1',
external_id: 'woo_butik.example.se_order_1001',
journal_entry_id: null,
invoice_id: null,
manually_booked_at: null,
legacy_transaction_id: null,
remote_changed_after_freeze: false,
total: 500,
total_tax: 100,
total_sek: 500,
exchange_rate: 1,
currency: 'SEK',
order_date: '2026-08-01',
paid_date: '2026-08-01',
is_paid: true,
payment_method: 'swish',
payment_method_title: 'Swish',
gateway_reference: null,
order_number: '1001',
status: 'processing',
refunded_total: 0,
store_label: 'Butiken',
connection_id: 'conn-1',
customer_name: 'Test Person',
customer_company: null,
customer_email: 'test@example.se',
customer_orgnr: null,
customer_country: 'SE',
vat_breakdown: [{ rate: 25, net: 400, tax: 100 }],
line_items: [],
...overrides,
}
}
describe('upsertWebshopOrders', () => {
let mock: ReturnType<typeof createQueuedMockSupabase>
const supabase = () => mock.supabase as unknown as SupabaseClient
beforeEach(() => {
vi.clearAllMocks()
mock = createQueuedMockSupabase()
})
it('inserts a new SEK order with resolved FX and no legacy link', async () => {
mock.enqueueMany([
{ data: [] }, // existing webshop_orders
{ data: [] }, // legacy transactions
{ data: [{ id: 'new-1', external_id: 'woo_butik.example.se_order_1001' }] }, // insert
])
const result = await upsertWebshopOrders(supabase(), COMPANY, USER, [makeUpsert()])
expect(result).toMatchObject({ inserted: 1, updated: 0, errors: 0, crossMarked: 0 })
const insertArgs = mock.findCall('webshop_orders', 'insert')
expect(insertArgs).toBeDefined()
const payload = (insertArgs![0] as Record<string, unknown>[])[0]
expect(payload).toMatchObject({
company_id: COMPANY,
user_id: USER,
external_id: 'woo_butik.example.se_order_1001',
total_sek: 500,
exchange_rate: 1,
legacy_transaction_id: null,
})
})
it('parents a refund to an order inserted in the same call', async () => {
mock.enqueueMany([
{ data: [] }, // existing (order phase)
{ data: [] }, // legacy (order phase)
{ data: [{ id: 'order-id-1', external_id: 'woo_butik.example.se_order_1001' }] },
{ data: [] }, // existing (refund phase; parent already known via knownIds)
{ data: [] }, // legacy (refund phase)
{ data: [{ id: 'refund-id-1', external_id: 'woo_butik.example.se_refund_77' }] },
])
const refund = makeUpsert({
row_type: 'refund',
parent_external_id: 'woo_butik.example.se_order_1001',
external_id: 'woo_butik.example.se_refund_77',
platform_order_id: '77',
total: -500,
total_tax: -100,
refunded_total: 0,
})
const result = await upsertWebshopOrders(supabase(), COMPANY, USER, [
refund,
makeUpsert(),
])
expect(result.inserted).toBe(2)
const inserts = mock.findCalls('webshop_orders', 'insert')
expect(inserts).toHaveLength(2)
const refundPayload = (inserts[1][0] as Record<string, unknown>[])[0]
expect(refundPayload).toMatchObject({
row_type: 'refund',
parent_order_id: 'order-id-1',
})
})
it('cross-marks rows whose external_id already exists in the transactions feed', async () => {
mock.enqueueMany([
{ data: [] },
{ data: [{ id: 'txn-9', external_id: 'woo_butik.example.se_order_1001' }] },
{ data: [{ id: 'new-1', external_id: 'woo_butik.example.se_order_1001' }] },
])
const result = await upsertWebshopOrders(supabase(), COMPANY, USER, [makeUpsert()])
expect(result.crossMarked).toBe(1)
const payload = (mock.findCall('webshop_orders', 'insert')![0] as Record<string, unknown>[])[0]
expect(payload.legacy_transaction_id).toBe('txn-9')
})
it('updates an unfrozen existing row when status moves', async () => {
mock.enqueueMany([
{ data: [existingRow()] },
{ data: [] },
{ data: null }, // update
])
const result = await upsertWebshopOrders(supabase(), COMPANY, USER, [
makeUpsert({ status: 'completed' }),
])
expect(result).toMatchObject({ inserted: 0, updated: 1, unchanged: 0 })
const updateArgs = mock.findCall('webshop_orders', 'update')
expect(updateArgs).toBeDefined()
expect((updateArgs![0] as Record<string, unknown>).status).toBe('completed')
})
it('counts an identical re-poll as unchanged without writing', async () => {
mock.enqueueMany([{ data: [existingRow()] }, { data: [] }])
const result = await upsertWebshopOrders(supabase(), COMPANY, USER, [makeUpsert()])
expect(result).toMatchObject({ inserted: 0, updated: 0, unchanged: 1 })
expect(mock.findCall('webshop_orders', 'update')).toBeUndefined()
expect(mock.findCall('webshop_orders', 'insert')).toBeUndefined()
})
it('treats jsonb-reordered keys as unchanged (Postgres does not preserve key order)', async () => {
// What PostgREST returns: same VALUES, different object key order than
// what the sync inserts. JSON.stringify comparison falsely flagged every
// such row as changed (and every booked row as remote-drifted).
mock.enqueueMany([
{
data: [
existingRow({
vat_breakdown: [{ net: 400, tax: 100, rate: 25 }],
line_items: [],
}),
],
},
{ data: [] },
])
const result = await upsertWebshopOrders(supabase(), COMPANY, USER, [makeUpsert()])
expect(result).toMatchObject({ unchanged: 1, updated: 0, frozenFlagged: 0 })
expect(mock.findCall('webshop_orders', 'update')).toBeUndefined()
})
it('does not flag a booked row when only key order differs', async () => {
mock.enqueueMany([
{
data: [
existingRow({
journal_entry_id: 'je-1',
vat_breakdown: [{ tax: 100, rate: 25, net: 400 }],
}),
],
},
{ data: [] },
])
const result = await upsertWebshopOrders(supabase(), COMPANY, USER, [makeUpsert()])
expect(result.frozenFlagged).toBe(0)
expect(mock.findCall('webshop_orders', 'update')).toBeUndefined()
})
it('flags a booked row whose financials drifted instead of updating them', async () => {
mock.enqueueMany([
{ data: [existingRow({ journal_entry_id: 'je-1' })] },
{ data: [] },
{ data: null }, // safe-field update
])
const result = await upsertWebshopOrders(supabase(), COMPANY, USER, [
makeUpsert({ total: 600, status: 'completed' }),
])
expect(result.frozenFlagged).toBe(1)
const update = mock.findCall('webshop_orders', 'update')![0] as Record<string, unknown>
expect(update.remote_changed_after_freeze).toBe(true)
expect(update.status).toBe('completed')
expect(update).not.toHaveProperty('total')
expect(update).not.toHaveProperty('total_sek')
expect(update).not.toHaveProperty('paid_date')
})
it('flags a manually marked row whose financials drifted instead of updating them (#1879)', async () => {
mock.enqueueMany([
{ data: [existingRow({ manually_booked_at: '2026-08-10T00:00:00Z' })] },
{ data: [] },
{ data: null }, // safe-field update
])
const result = await upsertWebshopOrders(supabase(), COMPANY, USER, [
makeUpsert({ total: 600, status: 'completed' }),
])
expect(result.frozenFlagged).toBe(1)
const update = mock.findCall('webshop_orders', 'update')![0] as Record<string, unknown>
expect(update.remote_changed_after_freeze).toBe(true)
expect(update).not.toHaveProperty('total')
expect(update).not.toHaveProperty('line_items')
})
it('leaves total_sek null when the exchange rate cannot resolve', async () => {
mock.enqueueMany([
{ data: [] },
{ data: [] },
{ data: [{ id: 'new-1', external_id: 'woo_butik.example.se_order_1001' }] },
])
await upsertWebshopOrders(supabase(), COMPANY, USER, [
makeUpsert({ currency: 'ISK', total: 900 }),
])
const payload = (mock.findCall('webshop_orders', 'insert')![0] as Record<string, unknown>[])[0]
expect(payload.total_sek).toBeNull()
expect(payload.exchange_rate).toBeNull()
})
it('converts non-SEK totals with the fetched rate', async () => {
mock.enqueueMany([
{ data: [] },
{ data: [] },
{ data: [{ id: 'new-1', external_id: 'woo_butik.example.se_order_1001' }] },
])
await upsertWebshopOrders(supabase(), COMPANY, USER, [
makeUpsert({ currency: 'EUR', total: 100, total_tax: 20 }),
])
const payload = (mock.findCall('webshop_orders', 'insert')![0] as Record<string, unknown>[])[0]
expect(payload.total_sek).toBe(1150)
expect(payload.exchange_rate).toBe(11.5)
})
it('surfaces select errors without throwing', async () => {
mock.enqueueMany([{ data: null, error: { message: 'boom', code: '500' } }])
const result = await upsertWebshopOrders(supabase(), COMPANY, USER, [makeUpsert()])
expect(result.errors).toBe(1)
expect(result.firstError?.message).toBe('boom')
})
})
describe('removeWebshopOrders', () => {
let mock: ReturnType<typeof createQueuedMockSupabase>
const supabase = () => mock.supabase as unknown as SupabaseClient
beforeEach(() => {
vi.clearAllMocks()
mock = createQueuedMockSupabase()
})
it('deletes unfrozen rows and reports the count', async () => {
mock.enqueueMany([
{ data: [{ id: 'row-1' }, { id: 'row-2' }] }, // unfrozen candidates
{ data: [] }, // no frozen refund children
{ data: [{ id: 'row-1' }, { id: 'row-2' }] }, // delete
])
const result = await removeWebshopOrders(supabase(), COMPANY, [
'woo_butik.example.se_order_1001',
'woo_butik.example.se_order_1002',
])
expect(result).toEqual({ removed: 2, errors: 0 })
expect(mock.findCall('webshop_orders', 'delete')).toBeDefined()
// The freeze guards run on the candidate select AND are repeated on the
// delete statement itself: a row frozen between the two round trips must
// survive (TOCTOU skeptic finding).
const guardColumns = [
'journal_entry_id',
'invoice_id',
'manually_booked_at',
'legacy_transaction_id',
]
expect(mock.findCalls('webshop_orders', 'is').map((args) => args[0])).toEqual([
...guardColumns,
...guardColumns,
])
// Paid rows are never deleted, on both statements.
expect(
mock.findCalls('webshop_orders', 'eq').filter((args) => args[0] === 'is_paid'),
).toEqual([
['is_paid', false],
['is_paid', false],
])
})
it('does nothing when no unfrozen row matches', async () => {
mock.enqueueMany([{ data: [] }])
const result = await removeWebshopOrders(supabase(), COMPANY, [
'woo_butik.example.se_order_1001',
])
expect(result).toEqual({ removed: 0, errors: 0 })
expect(mock.findCall('webshop_orders', 'delete')).toBeUndefined()
})
it('spares a parent whose refund child is frozen (delete would cascade)', async () => {
mock.enqueueMany([
{ data: [{ id: 'row-1' }, { id: 'row-2' }] },
{ data: [{ parent_order_id: 'row-1' }] }, // row-1 has a booked refund
{ data: [{ id: 'row-2' }] },
])
const result = await removeWebshopOrders(supabase(), COMPANY, [
'woo_butik.example.se_order_1001',
'woo_butik.example.se_order_1002',
])
expect(result).toEqual({ removed: 1, errors: 0 })
const deleteIn = mock
.findCalls('webshop_orders', 'in')
.find((args) => args[0] === 'id')
expect(deleteIn?.[1]).toEqual(['row-2'])
})
it('surfaces delete errors without throwing', async () => {
mock.enqueueMany([
{ data: [{ id: 'row-1' }] },
{ data: [] },
{ data: null, error: { message: 'boom', code: '500' } },
])
const result = await removeWebshopOrders(supabase(), COMPANY, [
'woo_butik.example.se_order_1001',
])
expect(result.removed).toBe(0)
expect(result.errors).toBe(1)
expect(result.firstError?.message).toBe('boom')
})
it('returns immediately on an empty id list', async () => {
const result = await removeWebshopOrders(supabase(), COMPANY, [])
expect(result).toEqual({ removed: 0, errors: 0 })
})
})