Files
accounted/extensions/general/arcim-migration/lib/__tests__/insert-fallback.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

84 lines
3.3 KiB
TypeScript

import { describe, it, expect, vi } from 'vitest'
import type { SupabaseClient } from '@supabase/supabase-js'
import { insertWithPerRowFallback } from '../insert-fallback'
/**
* The chunked migration inserts are one PostgREST statement per chunk, so a
* single bad row used to reject the whole chunk and report every row as
* failed ("300 misslyckades"). The fallback must keep the bulk fast path,
* retry per row only after a bulk failure, and attribute results by index.
*/
type InsertResult = { data: Record<string, unknown>[] | null; error: { message: string } | null }
/** Minimal supabase stand-in: scripted responses per insert call, in order. */
function makeSupabase(script: InsertResult[]) {
let call = 0
const inserted: unknown[] = []
const from = vi.fn(() => ({
insert: (rows: unknown) => {
inserted.push(rows)
const result = script[Math.min(call, script.length - 1)]
call++
return { select: () => Promise.resolve(result) }
},
}))
return { supabase: { from } as unknown as SupabaseClient, inserted, calls: () => call }
}
const row = (n: number) => ({ invoice_number: `F-${n}` })
describe('insertWithPerRowFallback', () => {
it('bulk success: one statement, results paired by index', async () => {
const { supabase, calls } = makeSupabase([
{ data: [{ id: 'a' }, { id: 'b' }], error: null },
])
const outcome = await insertWithPerRowFallback(supabase, 'invoices', [row(1), row(2)], 'id')
expect(calls()).toBe(1)
expect(outcome.failedCount).toBe(0)
expect(outcome.firstError).toBeNull()
expect(outcome.returned).toEqual([{ id: 'a' }, { id: 'b' }])
})
it('bulk failure: retries per row, healthy rows land, offender is counted with its message', async () => {
const dup = 'duplicate key value violates unique constraint "idx_invoices_company_invoice_number"'
const { supabase, calls } = makeSupabase([
{ data: null, error: { message: dup } }, // bulk statement
{ data: [{ id: 'a' }], error: null }, // row 0
{ data: null, error: { message: dup } }, // row 1 (the offender)
{ data: [{ id: 'c' }], error: null }, // row 2
])
const outcome = await insertWithPerRowFallback(supabase, 'invoices', [row(1), row(2), row(3)], 'id')
expect(calls()).toBe(4)
expect(outcome.returned).toEqual([{ id: 'a' }, null, { id: 'c' }])
expect(outcome.failedCount).toBe(1)
expect(outcome.firstError).toBe(dup)
})
it('bulk success with short read-back: never retries (rows are already in the table)', async () => {
const { supabase, calls } = makeSupabase([
{ data: [{ id: 'a' }], error: null }, // succeeded, but returned 1 of 2
])
const outcome = await insertWithPerRowFallback(supabase, 'customers', [row(1), row(2)], 'id')
expect(calls()).toBe(1)
expect(outcome.returned).toEqual([{ id: 'a' }, null])
expect(outcome.failedCount).toBe(1)
expect(outcome.firstError).toMatch(/could not be paired/)
})
it('empty input: no statements at all', async () => {
const { supabase, calls } = makeSupabase([{ data: [], error: null }])
const outcome = await insertWithPerRowFallback(supabase, 'invoices', [], 'id')
expect(calls()).toBe(0)
expect(outcome).toEqual({ returned: [], failedCount: 0, firstError: null })
})
})