Files
accounted/tests/pg/invoice-payments-manual-rows.pg.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

151 lines
6.0 KiB
TypeScript

/**
* pg-real test for the invoice_payments rows written by settleInvoicePayment
* (issue #2019: "Markera som betald" and the Stripe sync now record the
* payment in the AR sub-ledger).
*
* Those rows carry transaction_id NULL because no bank line drives the flow.
* The service relies on three database facts that only a real Postgres can
* pin:
*
* 1. idx_invoice_payments_tx_inv_unique (transaction_id, invoice_id) treats
* NULL as distinct, so several manual partials on one invoice coexist.
* 2. idx_invoice_payments_je_inv_unique still refuses the same voucher
* linked twice to the same invoice (the last line of defence against a
* double settle).
* 3. The authenticated writer can DELETE its own row: the CAS-failure
* branch in settleInvoicePayment removes the row through the user
* client, and a policy gap there would strand rows silently.
*/
import { describe, it, expect } from 'vitest'
import { randomUUID } from 'node:crypto'
import { getPool, withUserContext } from './setup'
import { insertPostedJournalEntry, seedCompany } from './fixtures'
async function seedCustomerInvoice(params: {
userId: string
companyId: string
total?: number
}): Promise<string> {
const customerId = randomUUID()
await getPool().query(
`INSERT INTO public.customers (id, user_id, company_id, name, customer_type)
VALUES ($1, $2, $3, 'Test Kund AB', 'swedish_business')`,
[customerId, params.userId, params.companyId],
)
const id = randomUUID()
const total = params.total ?? 12500
await getPool().query(
`INSERT INTO public.invoices
(id, user_id, company_id, customer_id, invoice_number, invoice_date, due_date,
currency, subtotal, vat_amount, total, vat_treatment, vat_rate, status,
paid_amount, remaining_amount)
VALUES ($1, $2, $3, $4, $5, '2026-08-01', '2026-08-31', 'SEK',
$6, 0, $6, 'standard_25', 25, 'sent', 0, $6)`,
[id, params.userId, params.companyId, customerId, `F-${id.slice(0, 8)}`, total],
)
return id
}
async function setActiveCompany(userId: string, companyId: string) {
await getPool().query(
`INSERT INTO public.user_preferences (user_id, active_company_id)
VALUES ($1, $2)
ON CONFLICT (user_id) DO UPDATE SET active_company_id = EXCLUDED.active_company_id`,
[userId, companyId],
)
}
const INSERT_MANUAL_PAYMENT = `
INSERT INTO public.invoice_payments
(user_id, company_id, invoice_id, payment_date, amount, currency, exchange_rate,
journal_entry_id, transaction_id, notes)
VALUES ($1, $2, $3, $4, $5, 'SEK', NULL, $6, NULL, NULL)
RETURNING id`
async function seedPaymentVoucher(params: {
userId: string
companyId: string
fiscalPeriodId: string
invoiceId: string
amount: number
voucherNumber: number
}): Promise<string> {
return insertPostedJournalEntry({
userId: params.userId,
companyId: params.companyId,
fiscalPeriodId: params.fiscalPeriodId,
entryDate: '2026-08-28',
description: 'Kontantbetalning kundfaktura',
sourceType: 'invoice_cash_payment',
sourceId: params.invoiceId,
voucherNumber: params.voucherNumber,
lines: [
{ accountNumber: '1930', debitAmount: params.amount, creditAmount: 0 },
{ accountNumber: '3001', debitAmount: 0, creditAmount: params.amount },
],
})
}
describe('invoice_payments rows without a bank transaction (#2019)', () => {
it('lets several transaction-less payments coexist on one invoice', async () => {
const seeded = await seedCompany()
const invoiceId = await seedCustomerInvoice(seeded)
const jeA = await seedPaymentVoucher({ ...seeded, invoiceId, amount: 5000, voucherNumber: 31 })
const jeB = await seedPaymentVoucher({ ...seeded, invoiceId, amount: 7500, voucherNumber: 32 })
const first = await getPool().query(INSERT_MANUAL_PAYMENT, [
seeded.userId, seeded.companyId, invoiceId, '2026-08-20', 5000, jeA,
])
const second = await getPool().query(INSERT_MANUAL_PAYMENT, [
seeded.userId, seeded.companyId, invoiceId, '2026-08-28', 7500, jeB,
])
expect(first.rowCount).toBe(1)
expect(second.rowCount).toBe(1)
const rows = await getPool().query<{ n: string; total: string }>(
`SELECT count(*)::text AS n, sum(amount)::text AS total
FROM public.invoice_payments WHERE invoice_id = $1 AND transaction_id IS NULL`,
[invoiceId],
)
expect(rows.rows[0]).toEqual({ n: '2', total: '12500' })
})
it('still refuses the same voucher linked twice to the same invoice', async () => {
const seeded = await seedCompany()
const invoiceId = await seedCustomerInvoice(seeded)
const je = await seedPaymentVoucher({ ...seeded, invoiceId, amount: 12500, voucherNumber: 41 })
await getPool().query(INSERT_MANUAL_PAYMENT, [
seeded.userId, seeded.companyId, invoiceId, '2026-08-28', 12500, je,
])
await expect(
getPool().query(INSERT_MANUAL_PAYMENT, [
seeded.userId, seeded.companyId, invoiceId, '2026-08-28', 12500, je,
]),
).rejects.toThrow(/idx_invoice_payments_je_inv_unique/)
})
it('lets the authenticated writer insert and delete its own row under RLS', async () => {
const seeded = await seedCompany()
await setActiveCompany(seeded.userId, seeded.companyId)
const invoiceId = await seedCustomerInvoice(seeded)
const je = await seedPaymentVoucher({ ...seeded, invoiceId, amount: 12500, voucherNumber: 51 })
const outcome = await withUserContext(seeded.userId, async (client) => {
const inserted = await client.query<{ id: string }>(INSERT_MANUAL_PAYMENT, [
seeded.userId, seeded.companyId, invoiceId, '2026-08-28', 12500, je,
])
const rowId = inserted.rows[0]?.id
// The CAS-failure branch deletes by (id, company_id) through the user
// client: the delete policy must let the row go.
const deleted = await client.query(
`DELETE FROM public.invoice_payments WHERE id = $1 AND company_id = $2`,
[rowId, seeded.companyId],
)
return { inserted: inserted.rowCount, deleted: deleted.rowCount }
})
expect(outcome).toEqual({ inserted: 1, deleted: 1 })
})
})