Å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.
303 lines
10 KiB
TypeScript
303 lines
10 KiB
TypeScript
import { describe, it, expect, vi } from 'vitest'
|
|
import type { SupabaseClient } from '@supabase/supabase-js'
|
|
import { replaceInvoiceItems } from '../replace-invoice-items'
|
|
import type { InvoiceWriteItemRow } from '@/lib/invoices/build-invoice-write'
|
|
|
|
/**
|
|
* Delete + insert over PostgREST is not atomic: an insert failure after a
|
|
* successful delete used to leave the draft with ZERO items (the user's line
|
|
* content gone). These tests pin the snapshot/restore added for that: the
|
|
* pre-delete rows are best-effort reinserted and the result says whether the
|
|
* restore worked.
|
|
*/
|
|
|
|
function makeItem(overrides: Partial<InvoiceWriteItemRow> = {}): InvoiceWriteItemRow {
|
|
return {
|
|
sort_order: 0,
|
|
line_type: 'product',
|
|
description: 'Konsulttimmar',
|
|
quantity: 1,
|
|
unit: 'tim',
|
|
unit_price: 1000,
|
|
discount_percent: 0,
|
|
line_total: 1000,
|
|
vat_rate: 25,
|
|
vat_amount: 250,
|
|
article_id: null,
|
|
revenue_account: null,
|
|
sales_order_item_id: null,
|
|
deduction_type: null,
|
|
deduction_amount: 0,
|
|
labor_hours: null,
|
|
work_type: null,
|
|
housing_designation: null,
|
|
apartment_number: null,
|
|
brf_org_number: null,
|
|
accrual_period_start: null,
|
|
accrual_period_end: null,
|
|
accrual_balance_account: null,
|
|
dimensions: {},
|
|
...overrides,
|
|
}
|
|
}
|
|
|
|
/** A stored invoice_items row as SELECT * returns it (server columns included). */
|
|
function storedRow(overrides: Record<string, unknown> = {}): Record<string, unknown> {
|
|
return {
|
|
id: 'item-old-1',
|
|
invoice_id: 'inv-1',
|
|
created_at: '2026-07-01T00:00:00Z',
|
|
sort_order: 0,
|
|
line_type: 'product',
|
|
description: 'Gammal rad',
|
|
quantity: 2,
|
|
unit: 'st',
|
|
unit_price: 500,
|
|
line_total: 1000,
|
|
vat_rate: 25,
|
|
vat_amount: 250,
|
|
article_id: null,
|
|
revenue_account: null,
|
|
...overrides,
|
|
}
|
|
}
|
|
|
|
function createHarness(opts: {
|
|
/** Snapshot rows; omit for an empty draft, pass null for "no rows came back". */
|
|
snapshot?: unknown[] | null
|
|
snapshotError?: unknown
|
|
deleteError?: unknown
|
|
/** Error returned by the n:th insert call (index 0 = the replace insert). */
|
|
insertErrors?: (unknown | null)[]
|
|
}) {
|
|
const inserts: Record<string, unknown>[][] = []
|
|
const deletes: string[] = []
|
|
let insertCall = 0
|
|
const snapshot = opts.snapshot === undefined ? [] : opts.snapshot
|
|
const supabase = {
|
|
from: vi.fn(() => ({
|
|
select: vi.fn(() => ({
|
|
eq: vi.fn(() => Promise.resolve({ data: snapshot, error: opts.snapshotError ?? null })),
|
|
})),
|
|
delete: vi.fn(() => ({
|
|
eq: vi.fn((_column: string, value: string) => {
|
|
deletes.push(value)
|
|
return Promise.resolve({ error: opts.deleteError ?? null })
|
|
}),
|
|
})),
|
|
insert: vi.fn((rows: Record<string, unknown>[]) => {
|
|
inserts.push(rows)
|
|
const error = opts.insertErrors?.[insertCall] ?? null
|
|
insertCall += 1
|
|
return Promise.resolve({ error })
|
|
}),
|
|
})),
|
|
}
|
|
return { supabase: supabase as unknown as SupabaseClient, inserts, deletes }
|
|
}
|
|
|
|
const insertBoom = { message: 'insert boom', code: '23502' }
|
|
|
|
const ORDER_LINE_1 = 'd1000000-0000-4000-8000-000000000001'
|
|
const ORDER_LINE_2 = 'd1000000-0000-4000-8000-000000000002'
|
|
|
|
const guardResult = {
|
|
ok: false,
|
|
stage: 'guard',
|
|
code: 'INVOICE_UPDATE_DROPS_ORDER_LINK',
|
|
messageSv: expect.stringContaining('kundorder'),
|
|
}
|
|
|
|
describe('replaceInvoiceItems order-link guard', () => {
|
|
it('refuses before deleting when the new lines drop a sales_order_item_id link', async () => {
|
|
const { supabase, inserts, deletes } = createHarness({
|
|
snapshot: [storedRow({ sales_order_item_id: ORDER_LINE_1 })],
|
|
})
|
|
|
|
const result = await replaceInvoiceItems(supabase, 'inv-1', [makeItem({ sales_order_item_id: null })])
|
|
|
|
expect(result).toEqual(guardResult)
|
|
expect(deletes).toHaveLength(0)
|
|
expect(inserts).toHaveLength(0)
|
|
})
|
|
|
|
it('proceeds when every existing link is kept on the new lines', async () => {
|
|
const { supabase, inserts, deletes } = createHarness({
|
|
snapshot: [
|
|
storedRow({ sales_order_item_id: ORDER_LINE_1 }),
|
|
storedRow({ id: 'item-old-2', sort_order: 1, sales_order_item_id: ORDER_LINE_2 }),
|
|
],
|
|
})
|
|
|
|
const result = await replaceInvoiceItems(supabase, 'inv-1', [
|
|
// Reordered and with an extra unlinked line: still covers both links.
|
|
makeItem({ sort_order: 0, sales_order_item_id: ORDER_LINE_2 }),
|
|
makeItem({ sort_order: 1, description: 'Fri rad', sales_order_item_id: null }),
|
|
makeItem({ sort_order: 2, sales_order_item_id: ORDER_LINE_1 }),
|
|
])
|
|
|
|
expect(result).toEqual({ ok: true })
|
|
expect(deletes).toEqual(['inv-1'])
|
|
expect(inserts).toHaveLength(1)
|
|
expect(inserts[0].map((r) => r.sales_order_item_id)).toEqual([ORDER_LINE_2, null, ORDER_LINE_1])
|
|
})
|
|
|
|
it('proceeds when the draft carries no order links at all', async () => {
|
|
const { supabase, inserts, deletes } = createHarness({
|
|
snapshot: [storedRow({ sales_order_item_id: null }), storedRow({ id: 'item-old-2', sort_order: 1 })],
|
|
})
|
|
|
|
const result = await replaceInvoiceItems(supabase, 'inv-1', [makeItem({ description: 'Ny rad' })])
|
|
|
|
expect(result).toEqual({ ok: true })
|
|
expect(deletes).toEqual(['inv-1'])
|
|
expect(inserts).toHaveLength(1)
|
|
})
|
|
|
|
it('compares links as a multiset: two rows on the same order line need two links back', async () => {
|
|
const { supabase, inserts } = createHarness({
|
|
snapshot: [
|
|
storedRow({ sales_order_item_id: ORDER_LINE_1 }),
|
|
storedRow({ id: 'item-old-2', sort_order: 1, sales_order_item_id: ORDER_LINE_1 }),
|
|
],
|
|
})
|
|
|
|
const dropped = await replaceInvoiceItems(supabase, 'inv-1', [makeItem({ sales_order_item_id: ORDER_LINE_1 })])
|
|
expect(dropped).toEqual(guardResult)
|
|
expect(inserts).toHaveLength(0)
|
|
|
|
const kept = await replaceInvoiceItems(supabase, 'inv-1', [
|
|
makeItem({ sales_order_item_id: ORDER_LINE_1 }),
|
|
makeItem({ sort_order: 1, sales_order_item_id: ORDER_LINE_1 }),
|
|
])
|
|
expect(kept).toEqual({ ok: true })
|
|
expect(inserts).toHaveLength(1)
|
|
})
|
|
|
|
it('refuses when a link is swapped for a different order line', async () => {
|
|
const { supabase, inserts } = createHarness({
|
|
snapshot: [storedRow({ sales_order_item_id: ORDER_LINE_1 })],
|
|
})
|
|
|
|
const result = await replaceInvoiceItems(supabase, 'inv-1', [makeItem({ sales_order_item_id: ORDER_LINE_2 })])
|
|
|
|
expect(result).toEqual(guardResult)
|
|
expect(inserts).toHaveLength(0)
|
|
})
|
|
|
|
it('fails closed before deleting when the snapshot could not be read (guard cannot run)', async () => {
|
|
// Without the snapshot the link multiset is unknown: a draft that may
|
|
// carry order links must not be emptied on a guess.
|
|
const selectBoom = { message: 'select boom' }
|
|
const { supabase, inserts, deletes } = createHarness({
|
|
snapshot: null,
|
|
snapshotError: selectBoom,
|
|
})
|
|
|
|
const result = await replaceInvoiceItems(supabase, 'inv-1', [makeItem()])
|
|
|
|
expect(result).toEqual({ ok: false, stage: 'delete', error: selectBoom })
|
|
expect(deletes).toEqual([])
|
|
expect(inserts).toHaveLength(0)
|
|
})
|
|
})
|
|
|
|
describe('replaceInvoiceItems', () => {
|
|
it('replaces the rows and stamps invoice_id on the happy path', async () => {
|
|
const { supabase, inserts } = createHarness({ snapshot: [storedRow()] })
|
|
|
|
const result = await replaceInvoiceItems(supabase, 'inv-1', [
|
|
makeItem({ description: 'Ny rad' }),
|
|
])
|
|
|
|
expect(result).toEqual({ ok: true })
|
|
expect(inserts).toHaveLength(1)
|
|
expect(inserts[0][0]).toMatchObject({ description: 'Ny rad', invoice_id: 'inv-1' })
|
|
})
|
|
|
|
it('restores the snapshotted rows when the insert fails', async () => {
|
|
const { supabase, inserts } = createHarness({
|
|
snapshot: [storedRow(), storedRow({ id: 'item-old-2', sort_order: 1, description: 'Rad 2' })],
|
|
insertErrors: [insertBoom, null],
|
|
})
|
|
|
|
const result = await replaceInvoiceItems(supabase, 'inv-1', [makeItem()])
|
|
|
|
expect(result).toEqual({
|
|
ok: false,
|
|
stage: 'insert',
|
|
error: insertBoom,
|
|
restored: true,
|
|
})
|
|
// Two inserts: the failed replace, then the restore of the snapshot.
|
|
expect(inserts).toHaveLength(2)
|
|
const restore = inserts[1]
|
|
expect(restore).toHaveLength(2)
|
|
expect(restore.map((r) => r.description)).toEqual(['Gammal rad', 'Rad 2'])
|
|
// Server-generated columns stripped, invoice_id re-stamped.
|
|
for (const row of restore) {
|
|
expect(row.id).toBeUndefined()
|
|
expect(row.created_at).toBeUndefined()
|
|
expect(row.invoice_id).toBe('inv-1')
|
|
}
|
|
})
|
|
|
|
it('reports restored: false when the restore insert also fails', async () => {
|
|
const { supabase, inserts } = createHarness({
|
|
snapshot: [storedRow()],
|
|
insertErrors: [insertBoom, { message: 'restore boom' }],
|
|
})
|
|
|
|
const result = await replaceInvoiceItems(supabase, 'inv-1', [makeItem()])
|
|
|
|
expect(result).toMatchObject({ ok: false, stage: 'insert', restored: false })
|
|
expect(inserts).toHaveLength(2)
|
|
})
|
|
|
|
it('refuses at the delete stage when the snapshot read returns no rows at all (null, no error)', async () => {
|
|
// A null snapshot without a driver error still leaves nothing to restore
|
|
// and nothing to guard against: the function stops before the delete
|
|
// instead of proceeding and later reporting restored: false.
|
|
const { supabase, inserts, deletes } = createHarness({
|
|
snapshot: null,
|
|
insertErrors: [insertBoom],
|
|
})
|
|
|
|
const result = await replaceInvoiceItems(supabase, 'inv-1', [makeItem()])
|
|
|
|
expect(result).toMatchObject({
|
|
ok: false,
|
|
stage: 'delete',
|
|
error: { code: 'SNAPSHOT_UNAVAILABLE', message: 'invoice_items snapshot unavailable' },
|
|
})
|
|
expect(deletes).toEqual([])
|
|
expect(inserts).toHaveLength(0)
|
|
})
|
|
|
|
it('reports restored: true when the draft had no items to begin with', async () => {
|
|
const { supabase, inserts } = createHarness({
|
|
snapshot: [],
|
|
insertErrors: [insertBoom],
|
|
})
|
|
|
|
const result = await replaceInvoiceItems(supabase, 'inv-1', [makeItem()])
|
|
|
|
expect(result).toMatchObject({ ok: false, stage: 'insert', restored: true })
|
|
// No restore insert: the prior state (empty) already holds.
|
|
expect(inserts).toHaveLength(1)
|
|
})
|
|
|
|
it('stops at the delete stage without touching inserts when the delete fails', async () => {
|
|
const deleteBoom = { message: 'delete boom' }
|
|
const { supabase, inserts } = createHarness({
|
|
snapshot: [storedRow()],
|
|
deleteError: deleteBoom,
|
|
})
|
|
|
|
const result = await replaceInvoiceItems(supabase, 'inv-1', [makeItem()])
|
|
|
|
expect(result).toEqual({ ok: false, stage: 'delete', error: deleteBoom })
|
|
expect(inserts).toHaveLength(0)
|
|
})
|
|
})
|