Files
accounted/lib/invoices/__tests__/editor-payload.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

506 lines
16 KiB
TypeScript

import { describe, it, expect } from 'vitest'
import {
buildInvoiceWritePayload,
buildSelfBilledPayload,
hasDimensionValues,
pruneItemDimensions,
sanitizeDeductionItems,
stripSelfBillingFields,
} from '@/lib/invoices/editor-payload'
/**
* Payload-parity ratchet for the invoice editor rebuild.
*
* The "legacy" builders below are verbatim re-implementations of the three
* inline payload builders that lived in InvoiceEditor.tsx (handleConfirm,
* saveDraftData, saveEdit) and the inline self-billed body mapper, before the
* extraction into lib/invoices/editor-payload.ts. Every combination in the
* matrix asserts JSON.stringify equality between the extracted builder and
* the legacy recipe: what goes over the wire may not change by a byte.
*/
type Item = {
line_type?: 'product' | 'text'
description: string
quantity: number
unit: string
unit_price: number
vat_rate: number
article_id?: string | null
revenue_account?: string | null
deduction_type?: 'rot' | 'rut' | null
labor_hours?: number | null
work_type?: string | null
housing_designation?: string | null
apartment_number?: string | null
brf_org_number?: string | null
accrual_period_start?: string | null
accrual_period_end?: string | null
accrual_balance_account?: string | null
dimensions?: Record<string, string> | null
}
type FormData = {
customer_id: string
invoice_date: string
due_date: string
delivery_date?: string
currency: string
document_type: 'invoice' | 'proforma' | 'delivery_note'
your_reference?: string
our_reference?: string
notes?: string
payment_link_url?: string
payment_link_auto?: boolean
external_invoice_number?: string
self_billing_agreement_ref?: string
received_date?: string
deduction_personnummer?: string
deduction_housing_designation?: string
items: Item[]
}
// ---------------------------------------------------------------------------
// Legacy recipes (verbatim from InvoiceEditor.tsx before the extraction)
// ---------------------------------------------------------------------------
function legacyHasDimensionValues(dims: Record<string, string> | null | undefined): boolean {
return !!dims && Object.keys(dims).length > 0
}
function legacyPruneItemDimensions<T extends { dimensions?: Record<string, string> | null }>(
items: T[],
): T[] {
return items.map((item) =>
legacyHasDimensionValues(item.dimensions) ? item : { ...item, dimensions: undefined },
)
}
function legacyStripSelfBillingFields(data: FormData): Omit<
FormData,
'external_invoice_number' | 'self_billing_agreement_ref' | 'received_date'
> {
const {
external_invoice_number: _ein,
self_billing_agreement_ref: _sbar,
received_date: _rd,
...rest
} = data
return rest
}
function legacySanitizedItems(items: Item[]) {
return legacyPruneItemDimensions(items).map((item) => {
if (item.deduction_type) return item
const {
deduction_type: _dt,
labor_hours: _lh,
work_type: _wt,
housing_designation: _hd,
apartment_number: _an,
brf_org_number: _bn,
...rest
} = item
return rest
})
}
/** handleConfirm's inline body (create with review). */
function legacyCreatePayload(
data: FormData,
oreRounding: boolean,
defaultDims: Record<string, string>,
) {
const anyDeduction = data.items.some((i) => i.deduction_type)
return {
...legacyStripSelfBillingFields(data),
ore_rounding: oreRounding,
default_dimensions: defaultDims,
items: legacySanitizedItems(data.items),
...(anyDeduction
? {}
: { deduction_personnummer: undefined, deduction_housing_designation: undefined }),
}
}
/** saveDraftData's inline body (create + save_as_draft). */
function legacyDraftPayload(
data: FormData,
oreRounding: boolean,
defaultDims: Record<string, string>,
) {
const anyDeduction = data.items.some((i) => i.deduction_type)
return {
...legacyStripSelfBillingFields(data),
save_as_draft: true,
ore_rounding: oreRounding,
default_dimensions: defaultDims,
items: legacySanitizedItems(data.items),
...(anyDeduction
? {}
: { deduction_personnummer: undefined, deduction_housing_designation: undefined }),
}
}
/** saveEdit's inline body (PATCH). Identical recipe to create. */
const legacyEditPayload = legacyCreatePayload
/** handleSelfBilledSubmit's inline body. */
function legacySelfBilledPayload(data: FormData) {
return {
customer_id: data.customer_id,
external_invoice_number: data.external_invoice_number,
self_billing_agreement_ref: data.self_billing_agreement_ref || undefined,
invoice_date: data.invoice_date,
received_date: data.received_date,
due_date: data.due_date,
currency: data.currency,
notes: data.notes,
items: data.items.map((i) => ({
description: i.description,
quantity: i.quantity,
unit: i.unit,
unit_price: i.unit_price,
vat_rate: i.vat_rate,
})),
}
}
// ---------------------------------------------------------------------------
// Fixtures
// ---------------------------------------------------------------------------
function plainItem(overrides: Partial<Item> = {}): Item {
return {
line_type: 'product',
description: 'Konsulttid',
quantity: 10,
unit: 'tim',
unit_price: 1200,
vat_rate: 25,
article_id: null,
revenue_account: null,
deduction_type: null,
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: null,
...overrides,
}
}
function rotItem(overrides: Partial<Item> = {}): Item {
return plainItem({
description: 'Målning av fasad',
deduction_type: 'rot',
labor_hours: 12,
work_type: 'malning',
housing_designation: 'Stockholm Vasastan 1:23',
...overrides,
})
}
function textItem(overrides: Partial<Item> = {}): Item {
return plainItem({
line_type: 'text',
description: 'Enligt offert 2026-14',
quantity: 0,
unit: '',
unit_price: 0,
vat_rate: 0,
...overrides,
})
}
function form(overrides: Partial<FormData> = {}): FormData {
return {
customer_id: 'cust-1',
invoice_date: '2026-08-17',
due_date: '2026-09-16',
delivery_date: '',
currency: 'SEK',
document_type: 'invoice',
your_reference: 'Anna',
our_reference: 'Jakob',
notes: 'Tack för samarbetet',
payment_link_url: '',
payment_link_auto: true,
external_invoice_number: '',
self_billing_agreement_ref: '',
received_date: '',
deduction_personnummer: '',
deduction_housing_designation: '',
items: [plainItem()],
...overrides,
}
}
const jsonOf = (v: unknown) => JSON.stringify(v)
// ---------------------------------------------------------------------------
// Parity matrix: create / draft / edit x deduction x dimensions x text rows
// ---------------------------------------------------------------------------
describe('buildInvoiceWritePayload parity with the legacy inline builders', () => {
const itemVariants: Array<[string, Item[]]> = [
['plain single line', [plainItem()]],
['ROT deduction line', [rotItem()]],
['mixed rot + plain + text', [rotItem(), plainItem(), textItem()]],
[
'dimensions: empty bag pruned, non-empty kept',
[
plainItem({ dimensions: {} }),
plainItem({ dimensions: { '1': 'KS01', '6': 'P001' } }),
],
],
[
'accrual line without deduction keeps accrual fields',
[
plainItem({
accrual_period_start: '2026-09-01',
accrual_period_end: '2026-12-31',
accrual_balance_account: '2990',
}),
],
],
[
'RUT with per-item override account and dims',
[
rotItem({
deduction_type: 'rut',
work_type: 'stadning',
revenue_account: '3041',
dimensions: { '6': 'P002' },
}),
],
],
]
const formVariants: Array<[string, Partial<FormData>]> = [
['default create form', {}],
[
'claim fields filled',
{ deduction_personnummer: '19800101-1234', deduction_housing_designation: 'Berga 2:11' },
],
[
'self-billing carriers accidentally non-empty are stripped',
{ external_invoice_number: 'K-99', self_billing_agreement_ref: 'AVT-1', received_date: '2026-08-01' },
],
['EUR proforma with payment link', { currency: 'EUR', document_type: 'proforma', payment_link_url: 'https://buy.stripe.com/x' }],
]
for (const [itemLabel, items] of itemVariants) {
for (const [formLabel, formOverrides] of formVariants) {
const data = form({ ...formOverrides, items })
const dimsVariants: Array<Record<string, string>> = [{}, { '1': 'KS01' }]
for (const oreRounding of [true, false]) {
for (const defaultDims of dimsVariants) {
it(`create: ${itemLabel} / ${formLabel} / ore=${oreRounding} / dims=${jsonOf(defaultDims)}`, () => {
expect(
jsonOf(buildInvoiceWritePayload(data, { oreRounding, defaultDims })),
).toBe(jsonOf(legacyCreatePayload(data, oreRounding, defaultDims)))
})
it(`draft: ${itemLabel} / ${formLabel} / ore=${oreRounding} / dims=${jsonOf(defaultDims)}`, () => {
expect(
jsonOf(
buildInvoiceWritePayload(data, { saveAsDraft: true, oreRounding, defaultDims }),
),
).toBe(jsonOf(legacyDraftPayload(data, oreRounding, defaultDims)))
})
it(`edit: ${itemLabel} / ${formLabel} / ore=${oreRounding} / dims=${jsonOf(defaultDims)}`, () => {
expect(
jsonOf(buildInvoiceWritePayload(data, { oreRounding, defaultDims })),
).toBe(jsonOf(legacyEditPayload(data, oreRounding, defaultDims)))
})
}
}
}
}
})
describe('buildInvoiceWritePayload semantics', () => {
it('drops the self-billing carriers from the wire body', () => {
const body = JSON.parse(
jsonOf(
buildInvoiceWritePayload(
form({ external_invoice_number: 'X', self_billing_agreement_ref: 'Y', received_date: '2026-01-01' }),
{ oreRounding: true, defaultDims: {} },
),
),
)
expect(body).not.toHaveProperty('external_invoice_number')
expect(body).not.toHaveProperty('self_billing_agreement_ref')
expect(body).not.toHaveProperty('received_date')
})
it('omits save_as_draft entirely unless requested', () => {
const noDraft = buildInvoiceWritePayload(form(), { oreRounding: true, defaultDims: {} })
expect('save_as_draft' in noDraft).toBe(false)
const draft = buildInvoiceWritePayload(form(), {
saveAsDraft: true,
oreRounding: true,
defaultDims: {},
})
expect(draft.save_as_draft).toBe(true)
})
it('strips invoice-level personnummer/housing when no line claims a deduction', () => {
const body = JSON.parse(
jsonOf(
buildInvoiceWritePayload(
form({
deduction_personnummer: '19800101-1234',
deduction_housing_designation: 'Berga 2:11',
items: [plainItem()],
}),
{ oreRounding: true, defaultDims: {} },
),
),
)
expect(body).not.toHaveProperty('deduction_personnummer')
expect(body).not.toHaveProperty('deduction_housing_designation')
})
it('keeps invoice-level personnummer/housing when any line claims a deduction', () => {
const body = JSON.parse(
jsonOf(
buildInvoiceWritePayload(
form({
deduction_personnummer: '19800101-1234',
deduction_housing_designation: 'Berga 2:11',
items: [rotItem(), plainItem()],
}),
{ oreRounding: true, defaultDims: {} },
),
),
)
expect(body.deduction_personnummer).toBe('19800101-1234')
expect(body.deduction_housing_designation).toBe('Berga 2:11')
})
it('privacy-strips the six ROT/RUT fields only from non-deduction lines', () => {
const body = JSON.parse(
jsonOf(
buildInvoiceWritePayload(form({ items: [rotItem(), plainItem()] }), {
oreRounding: false,
defaultDims: {},
}),
),
)
expect(body.items[0].deduction_type).toBe('rot')
expect(body.items[0].labor_hours).toBe(12)
expect(body.items[0].work_type).toBe('malning')
for (const key of [
'deduction_type',
'labor_hours',
'work_type',
'housing_designation',
'apartment_number',
'brf_org_number',
]) {
expect(body.items[1]).not.toHaveProperty(key)
}
// Non-personal fields survive the strip.
expect(body.items[1].description).toBe('Konsulttid')
expect(body.items[1].accrual_period_start).toBeNull()
})
it('always sends ore_rounding and default_dimensions ({} clears)', () => {
const body = JSON.parse(
jsonOf(buildInvoiceWritePayload(form(), { oreRounding: false, defaultDims: {} })),
)
expect(body.ore_rounding).toBe(false)
expect(body.default_dimensions).toEqual({})
})
})
describe('pruneItemDimensions', () => {
it('turns empty and null bags into undefined (inherit) and keeps valued bags', () => {
const [a, b, c] = pruneItemDimensions([
plainItem({ dimensions: {} }),
plainItem({ dimensions: null }),
plainItem({ dimensions: { '1': 'KS01' } }),
])
expect(a.dimensions).toBeUndefined()
expect(b.dimensions).toBeUndefined()
expect(c.dimensions).toEqual({ '1': 'KS01' })
})
})
describe('hasDimensionValues', () => {
it('is false for null/undefined/empty and true for a valued bag', () => {
expect(hasDimensionValues(null)).toBe(false)
expect(hasDimensionValues(undefined)).toBe(false)
expect(hasDimensionValues({})).toBe(false)
expect(hasDimensionValues({ '6': 'P001' })).toBe(true)
})
})
describe('stripSelfBillingFields / sanitizeDeductionItems', () => {
it('stripSelfBillingFields removes exactly the three carriers', () => {
const out = stripSelfBillingFields(form()) as Record<string, unknown>
expect(out).not.toHaveProperty('external_invoice_number')
expect(out).not.toHaveProperty('self_billing_agreement_ref')
expect(out).not.toHaveProperty('received_date')
expect(out.customer_id).toBe('cust-1')
expect(out.items).toHaveLength(1)
})
it('sanitizeDeductionItems leaves deduction lines untouched (same reference)', () => {
const rot = rotItem()
const out = sanitizeDeductionItems([rot])
expect(out[0]).toBe(rot)
})
})
describe('buildSelfBilledPayload parity and semantics', () => {
const selfBilledForm = form({
external_invoice_number: 'K-2026-17',
self_billing_agreement_ref: '',
received_date: '2026-08-15',
notes: 'Mottagen självfaktura',
items: [
plainItem({ article_id: 'art-1', revenue_account: '3001', dimensions: { '1': 'KS01' } }),
plainItem({ description: 'Frakt', quantity: 1, unit: 'st', unit_price: 120, vat_rate: 25 }),
],
})
it('matches the legacy inline body byte for byte', () => {
expect(jsonOf(buildSelfBilledPayload(selfBilledForm))).toBe(
jsonOf(legacySelfBilledPayload(selfBilledForm)),
)
})
it('reduces items to the five wire fields', () => {
const body = JSON.parse(jsonOf(buildSelfBilledPayload(selfBilledForm)))
expect(Object.keys(body.items[0]).sort()).toEqual([
'description',
'quantity',
'unit',
'unit_price',
'vat_rate',
])
})
it("coerces an empty agreement ref to undefined so it drops off the wire", () => {
const body = JSON.parse(jsonOf(buildSelfBilledPayload(selfBilledForm)))
expect(body).not.toHaveProperty('self_billing_agreement_ref')
const withRef = JSON.parse(
jsonOf(buildSelfBilledPayload({ ...selfBilledForm, self_billing_agreement_ref: 'AVT-9' })),
)
expect(withRef.self_billing_agreement_ref).toBe('AVT-9')
})
it('never sends document_type, ROT/RUT or payment-link fields', () => {
const body = JSON.parse(jsonOf(buildSelfBilledPayload(selfBilledForm)))
for (const key of ['document_type', 'payment_link_url', 'payment_link_auto', 'ore_rounding', 'deduction_personnummer']) {
expect(body).not.toHaveProperty(key)
}
})
})