622 lines
26 KiB
TypeScript
622 lines
26 KiB
TypeScript
/**
|
|
* pg-real test for the link-invoice-voucher feature's DB-side guards.
|
|
*
|
|
* Covers what the TypeScript service can't verify on its own:
|
|
* - The partial unique index idx_invoice_payments_je_inv_unique blocks
|
|
* linking the same voucher to the same invoice twice while still
|
|
* allowing the voucher to settle other invoices.
|
|
* - The link_invoice_voucher operation_type passes the pending_operations
|
|
* CHECK constraint.
|
|
* - Invoice + invoice_payments writes survive RLS for the owning user and
|
|
* are rejected for a different user.
|
|
*
|
|
* Asserts behaviour the migration 20260528120000 introduced.
|
|
*/
|
|
import { describe, it, expect } from 'vitest'
|
|
import { randomUUID } from 'node:crypto'
|
|
import { getPool } from '@/tests/pg/setup'
|
|
import {
|
|
insertAuthUser,
|
|
insertCompany,
|
|
insertCompanyMember,
|
|
insertFiscalPeriod,
|
|
} from '@/tests/pg/fixtures'
|
|
|
|
async function seedCustomer(params: {
|
|
userId: string
|
|
companyId: string
|
|
}): Promise<string> {
|
|
const id = 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')`,
|
|
[id, params.userId, params.companyId],
|
|
)
|
|
return id
|
|
}
|
|
|
|
async function seedInvoice(params: {
|
|
userId: string
|
|
companyId: string
|
|
customerId: string
|
|
total?: number
|
|
status?: 'sent' | 'overdue' | 'partially_paid'
|
|
}): Promise<string> {
|
|
const id = randomUUID()
|
|
const total = params.total ?? 1000
|
|
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-04-01', '2026-05-01', 'SEK',
|
|
$6, 0, $6, 'standard_25', 25, $7, 0, $6)`,
|
|
[id, params.userId, params.companyId, params.customerId, `F-${id.slice(0, 8)}`, total, params.status ?? 'sent'],
|
|
)
|
|
return id
|
|
}
|
|
|
|
async function seedPostedVoucher(params: {
|
|
userId: string
|
|
companyId: string
|
|
fiscalPeriodId: string
|
|
amount?: number
|
|
}): Promise<string> {
|
|
const id = randomUUID()
|
|
const amount = params.amount ?? 1000
|
|
await getPool().query(
|
|
`INSERT INTO public.journal_entries
|
|
(id, user_id, company_id, fiscal_period_id, voucher_number, voucher_series,
|
|
entry_date, description, source_type, status)
|
|
VALUES ($1, $2, $3, $4, $5, 'A', '2026-05-05', 'Inbetalning', 'manual', 'posted')`,
|
|
[id, params.userId, params.companyId, params.fiscalPeriodId, Math.floor(Math.random() * 100000)],
|
|
)
|
|
await getPool().query(
|
|
`INSERT INTO public.journal_entry_lines
|
|
(journal_entry_id, account_number, debit_amount, credit_amount)
|
|
VALUES ($1, '1930', $2, 0),
|
|
($1, '1510', 0, $2)`,
|
|
[id, amount],
|
|
)
|
|
return id
|
|
}
|
|
|
|
/**
|
|
* Seed a posted voucher with one debit line and one credit line (balanced).
|
|
* Lets kontantmetoden tests build a cash-receipt verifikat (debit 1930 /
|
|
* credit 3001: no 1510) and a non-matching one (debit 1510 / credit 3001).
|
|
*/
|
|
async function seedVoucherDebitCredit(params: {
|
|
userId: string
|
|
companyId: string
|
|
fiscalPeriodId: string
|
|
amount?: number
|
|
debitAccount: string
|
|
creditAccount: string
|
|
}): Promise<string> {
|
|
const id = randomUUID()
|
|
const amount = params.amount ?? 1000
|
|
await getPool().query(
|
|
`INSERT INTO public.journal_entries
|
|
(id, user_id, company_id, fiscal_period_id, voucher_number, voucher_series,
|
|
entry_date, description, source_type, status)
|
|
VALUES ($1, $2, $3, $4, $5, 'A', '2026-05-05', 'Inbetalning', 'manual', 'posted')`,
|
|
[id, params.userId, params.companyId, params.fiscalPeriodId, Math.floor(Math.random() * 100000)],
|
|
)
|
|
await getPool().query(
|
|
`INSERT INTO public.journal_entry_lines
|
|
(journal_entry_id, account_number, debit_amount, credit_amount)
|
|
VALUES ($1, $2, $3, 0),
|
|
($1, $4, 0, $3)`,
|
|
[id, params.debitAccount, amount, params.creditAccount],
|
|
)
|
|
return id
|
|
}
|
|
|
|
/** Flip a company onto kontantmetoden so the link RPC keys on the 19xx debit. */
|
|
async function setCashMethod(companyId: string): Promise<void> {
|
|
await getPool().query(
|
|
`INSERT INTO public.company_settings (company_id, accounting_method)
|
|
VALUES ($1, 'cash')
|
|
ON CONFLICT (company_id) DO UPDATE SET accounting_method = 'cash'`,
|
|
[companyId],
|
|
)
|
|
}
|
|
|
|
describe('link_invoice_voucher pg-real guards', () => {
|
|
it('partial unique index blocks linking the same voucher to the same invoice twice', async () => {
|
|
const userId = await insertAuthUser()
|
|
const companyId = await insertCompany({ createdBy: userId })
|
|
await insertCompanyMember({ companyId, userId })
|
|
const fiscalPeriodId = await insertFiscalPeriod({ userId, companyId })
|
|
const customerId = await seedCustomer({ userId, companyId })
|
|
const invoiceId = await seedInvoice({ userId, companyId, customerId })
|
|
const voucherId = await seedPostedVoucher({ userId, companyId, fiscalPeriodId })
|
|
|
|
// First link: should succeed.
|
|
await getPool().query(
|
|
`INSERT INTO public.invoice_payments
|
|
(user_id, company_id, invoice_id, payment_date, amount, currency, journal_entry_id)
|
|
VALUES ($1, $2, $3, '2026-05-05', 1000, 'SEK', $4)`,
|
|
[userId, companyId, invoiceId, voucherId],
|
|
)
|
|
|
|
// Second identical link: should be rejected by the partial unique index.
|
|
await expect(
|
|
getPool().query(
|
|
`INSERT INTO public.invoice_payments
|
|
(user_id, company_id, invoice_id, payment_date, amount, currency, journal_entry_id)
|
|
VALUES ($1, $2, $3, '2026-05-05', 1000, 'SEK', $4)`,
|
|
[userId, companyId, invoiceId, voucherId],
|
|
),
|
|
).rejects.toMatchObject({ code: '23505' })
|
|
})
|
|
|
|
it('one voucher can be linked to multiple distinct invoices', async () => {
|
|
const userId = await insertAuthUser()
|
|
const companyId = await insertCompany({ createdBy: userId })
|
|
await insertCompanyMember({ companyId, userId })
|
|
const fiscalPeriodId = await insertFiscalPeriod({ userId, companyId })
|
|
const customerId = await seedCustomer({ userId, companyId })
|
|
const invoiceAId = await seedInvoice({ userId, companyId, customerId, total: 500 })
|
|
const invoiceBId = await seedInvoice({ userId, companyId, customerId, total: 500 })
|
|
const voucherId = await seedPostedVoucher({ userId, companyId, fiscalPeriodId, amount: 1000 })
|
|
|
|
await getPool().query(
|
|
`INSERT INTO public.invoice_payments
|
|
(user_id, company_id, invoice_id, payment_date, amount, currency, journal_entry_id)
|
|
VALUES ($1, $2, $3, '2026-05-05', 500, 'SEK', $4),
|
|
($1, $2, $5, '2026-05-05', 500, 'SEK', $4)`,
|
|
[userId, companyId, invoiceAId, voucherId, invoiceBId],
|
|
)
|
|
|
|
const { rows } = await getPool().query<{ count: string }>(
|
|
`SELECT COUNT(*) FROM public.invoice_payments WHERE journal_entry_id = $1`,
|
|
[voucherId],
|
|
)
|
|
expect(Number(rows[0].count)).toBe(2)
|
|
})
|
|
|
|
it('partial unique index does NOT collide when journal_entry_id is NULL', async () => {
|
|
const userId = await insertAuthUser()
|
|
const companyId = await insertCompany({ createdBy: userId })
|
|
await insertCompanyMember({ companyId, userId })
|
|
const customerId = await seedCustomer({ userId, companyId })
|
|
const invoiceId = await seedInvoice({ userId, companyId, customerId })
|
|
|
|
// Two transaction-keyed payment rows for the same invoice with NULL JE
|
|
// must coexist (until 2026-05-28 partial index, this would have been a
|
|
// false positive if the index were unconditional).
|
|
const txId1 = randomUUID()
|
|
const txId2 = randomUUID()
|
|
await getPool().query(
|
|
`INSERT INTO public.transactions (id, user_id, company_id, account_id, date, description, amount, currency)
|
|
VALUES ($1, $2, $3, $4, '2026-05-05', 'Payment 1', 500, 'SEK'),
|
|
($5, $2, $3, $4, '2026-05-06', 'Payment 2', 500, 'SEK')`,
|
|
[txId1, userId, companyId, randomUUID(), txId2],
|
|
).catch(async () => {
|
|
// transactions table also requires account_id pointing at bank_connections;
|
|
// skip seeding txs if FK doesn't allow NULL, and assert against the
|
|
// invoice_payments table directly.
|
|
})
|
|
|
|
// Insert two rows with no journal_entry_id and no transaction_id: the
|
|
// partial index excludes them and the (transaction_id, invoice_id) unique
|
|
// index allows NULL transaction_id duplicates.
|
|
await getPool().query(
|
|
`INSERT INTO public.invoice_payments
|
|
(user_id, company_id, invoice_id, payment_date, amount, currency)
|
|
VALUES ($1, $2, $3, '2026-05-05', 500, 'SEK'),
|
|
($1, $2, $3, '2026-05-06', 500, 'SEK')`,
|
|
[userId, companyId, invoiceId],
|
|
)
|
|
|
|
const { rows } = await getPool().query<{ count: string }>(
|
|
`SELECT COUNT(*) FROM public.invoice_payments WHERE invoice_id = $1`,
|
|
[invoiceId],
|
|
)
|
|
expect(Number(rows[0].count)).toBe(2)
|
|
})
|
|
|
|
it('link_invoice_voucher passes the operation_type CHECK constraint', async () => {
|
|
const userId = await insertAuthUser()
|
|
const companyId = await insertCompany({ createdBy: userId })
|
|
await insertCompanyMember({ companyId, userId })
|
|
const fiscalPeriodId = await insertFiscalPeriod({ userId, companyId })
|
|
const customerId = await seedCustomer({ userId, companyId })
|
|
const invoiceId = await seedInvoice({ userId, companyId, customerId })
|
|
const voucherId = await seedPostedVoucher({ userId, companyId, fiscalPeriodId })
|
|
|
|
const opId = randomUUID()
|
|
await getPool().query(
|
|
`INSERT INTO public.pending_operations
|
|
(id, user_id, company_id, operation_type, title, params, preview_data, status, risk_level)
|
|
VALUES ($1, $2, $3, 'link_invoice_voucher', 'test', $4::jsonb, $5::jsonb, 'pending', 'medium')`,
|
|
[
|
|
opId,
|
|
userId,
|
|
companyId,
|
|
JSON.stringify({ invoice_id: invoiceId, journal_entry_id: voucherId }),
|
|
JSON.stringify({ voucher_label: 'A-1' }),
|
|
],
|
|
)
|
|
|
|
const { rows } = await getPool().query<{ status: string }>(
|
|
`SELECT status FROM public.pending_operations WHERE id = $1`,
|
|
[opId],
|
|
)
|
|
expect(rows[0]?.status).toBe('pending')
|
|
})
|
|
|
|
it('linking a voucher whose period is locked does NOT trigger enforce_period_lock', async () => {
|
|
const userId = await insertAuthUser()
|
|
const companyId = await insertCompany({ createdBy: userId })
|
|
await insertCompanyMember({ companyId, userId })
|
|
// Period must be open while we seed the voucher: enforce_period_lock
|
|
// fires on INSERT, so close it only after the JE rows exist.
|
|
const fiscalPeriodId = await insertFiscalPeriod({ userId, companyId })
|
|
const customerId = await seedCustomer({ userId, companyId })
|
|
const invoiceId = await seedInvoice({ userId, companyId, customerId })
|
|
const voucherId = await seedPostedVoucher({ userId, companyId, fiscalPeriodId })
|
|
|
|
await getPool().query(
|
|
`UPDATE public.fiscal_periods
|
|
SET is_closed = true, closed_at = now()
|
|
WHERE id = $1`,
|
|
[fiscalPeriodId],
|
|
)
|
|
|
|
// No journal_entries write happens in the link flow: only
|
|
// invoice_payments + invoices, neither of which is gated by
|
|
// enforce_period_lock. The insert below must succeed even though the
|
|
// voucher's fiscal period is closed.
|
|
await getPool().query(
|
|
`INSERT INTO public.invoice_payments
|
|
(user_id, company_id, invoice_id, payment_date, amount, currency, journal_entry_id)
|
|
VALUES ($1, $2, $3, '2026-05-05', 1000, 'SEK', $4)`,
|
|
[userId, companyId, invoiceId, voucherId],
|
|
)
|
|
|
|
const { rows } = await getPool().query<{ count: string }>(
|
|
`SELECT COUNT(*) FROM public.invoice_payments WHERE invoice_id = $1`,
|
|
[invoiceId],
|
|
)
|
|
expect(Number(rows[0].count)).toBe(1)
|
|
})
|
|
})
|
|
|
|
// ============================================================
|
|
// link_invoice_to_voucher RPC: atomic customer link (audit C2)
|
|
// Mirrors the supplier-side link_supplier_invoice_to_voucher tests: the RPC
|
|
// must lock the invoice FOR UPDATE, validate, and apply UPDATE + INSERT in a
|
|
// single transaction so concurrent linkers serialize instead of clobbering
|
|
// each other (the old TS path's stale-snapshot manual rollback).
|
|
// ============================================================
|
|
|
|
type RpcResult = {
|
|
ok: boolean
|
|
code?: string
|
|
invoice_status?: string
|
|
paid_amount?: number
|
|
remaining_amount?: number
|
|
payment_amount?: number
|
|
details?: Record<string, unknown>
|
|
}
|
|
|
|
async function callLinkRpc(args: {
|
|
invoiceId: string
|
|
voucherId: string
|
|
userId: string
|
|
companyId: string
|
|
}): Promise<RpcResult> {
|
|
const { rows } = await getPool().query<{ result: RpcResult }>(
|
|
`SELECT public.link_invoice_to_voucher($1, $2, $3, $4, NULL) AS result`,
|
|
[args.invoiceId, args.voucherId, args.userId, args.companyId],
|
|
)
|
|
return rows[0].result
|
|
}
|
|
|
|
describe('link_invoice_to_voucher RPC (atomic link: audit C2)', () => {
|
|
it('links a full payment: invoice advanced + payment row, one transaction', async () => {
|
|
const userId = await insertAuthUser()
|
|
const companyId = await insertCompany({ createdBy: userId })
|
|
await insertCompanyMember({ companyId, userId })
|
|
const fiscalPeriodId = await insertFiscalPeriod({ userId, companyId })
|
|
const customerId = await seedCustomer({ userId, companyId })
|
|
const invoiceId = await seedInvoice({ userId, companyId, customerId, total: 1000 })
|
|
const voucherId = await seedPostedVoucher({ userId, companyId, fiscalPeriodId, amount: 1000 })
|
|
|
|
const result = await callLinkRpc({ invoiceId, voucherId, userId, companyId })
|
|
expect(result.ok).toBe(true)
|
|
expect(result.invoice_status).toBe('paid')
|
|
expect(Number(result.paid_amount)).toBe(1000)
|
|
expect(Number(result.remaining_amount)).toBe(0)
|
|
|
|
const { rows: inv } = await getPool().query(
|
|
`SELECT status, paid_amount, remaining_amount,
|
|
paid_at = TIMESTAMPTZ '2026-05-05 12:00:00+00' AS paid_at_matches
|
|
FROM public.invoices WHERE id = $1`,
|
|
[invoiceId],
|
|
)
|
|
expect(inv[0].status).toBe('paid')
|
|
expect(Number(inv[0].paid_amount)).toBe(1000)
|
|
expect(Number(inv[0].remaining_amount)).toBe(0)
|
|
expect(inv[0].paid_at_matches).toBe(true)
|
|
|
|
const { rows: pay } = await getPool().query(
|
|
`SELECT amount, payment_date = DATE '2026-05-05' AS payment_date_matches
|
|
FROM public.invoice_payments WHERE invoice_id = $1 AND journal_entry_id = $2`,
|
|
[invoiceId, voucherId],
|
|
)
|
|
expect(pay).toHaveLength(1)
|
|
expect(Number(pay[0].amount)).toBe(1000)
|
|
expect(pay[0].payment_date_matches).toBe(true)
|
|
})
|
|
|
|
it('links a partial payment as partially_paid with the right remaining', async () => {
|
|
const userId = await insertAuthUser()
|
|
const companyId = await insertCompany({ createdBy: userId })
|
|
await insertCompanyMember({ companyId, userId })
|
|
const fiscalPeriodId = await insertFiscalPeriod({ userId, companyId })
|
|
const customerId = await seedCustomer({ userId, companyId })
|
|
const invoiceId = await seedInvoice({ userId, companyId, customerId, total: 1000 })
|
|
const voucherId = await seedPostedVoucher({ userId, companyId, fiscalPeriodId, amount: 400 })
|
|
|
|
const result = await callLinkRpc({ invoiceId, voucherId, userId, companyId })
|
|
expect(result.ok).toBe(true)
|
|
expect(result.invoice_status).toBe('partially_paid')
|
|
expect(Number(result.paid_amount)).toBe(400)
|
|
expect(Number(result.remaining_amount)).toBe(600)
|
|
})
|
|
|
|
it('rejects overpayment and leaves the invoice completely untouched', async () => {
|
|
const userId = await insertAuthUser()
|
|
const companyId = await insertCompany({ createdBy: userId })
|
|
await insertCompanyMember({ companyId, userId })
|
|
const fiscalPeriodId = await insertFiscalPeriod({ userId, companyId })
|
|
const customerId = await seedCustomer({ userId, companyId })
|
|
const invoiceId = await seedInvoice({ userId, companyId, customerId, total: 1000 })
|
|
const voucherId = await seedPostedVoucher({ userId, companyId, fiscalPeriodId, amount: 1500 })
|
|
|
|
const result = await callLinkRpc({ invoiceId, voucherId, userId, companyId })
|
|
expect(result.ok).toBe(false)
|
|
expect(result.code).toBe('LINK_VOUCHER_AMOUNT_EXCEEDS_REMAINING')
|
|
|
|
const { rows: inv } = await getPool().query(
|
|
`SELECT status, paid_amount, remaining_amount FROM public.invoices WHERE id = $1`,
|
|
[invoiceId],
|
|
)
|
|
expect(inv[0].status).toBe('sent')
|
|
expect(Number(inv[0].paid_amount)).toBe(0)
|
|
expect(Number(inv[0].remaining_amount)).toBe(1000)
|
|
|
|
const { rows: pay } = await getPool().query(
|
|
`SELECT COUNT(*) AS count FROM public.invoice_payments WHERE invoice_id = $1`,
|
|
[invoiceId],
|
|
)
|
|
expect(Number(pay[0].count)).toBe(0)
|
|
})
|
|
|
|
it('rejects re-linking the same voucher to the same invoice (ALREADY_LINKED)', async () => {
|
|
const userId = await insertAuthUser()
|
|
const companyId = await insertCompany({ createdBy: userId })
|
|
await insertCompanyMember({ companyId, userId })
|
|
const fiscalPeriodId = await insertFiscalPeriod({ userId, companyId })
|
|
const customerId = await seedCustomer({ userId, companyId })
|
|
const invoiceId = await seedInvoice({ userId, companyId, customerId, total: 2000 })
|
|
const voucherId = await seedPostedVoucher({ userId, companyId, fiscalPeriodId, amount: 1000 })
|
|
|
|
const first = await callLinkRpc({ invoiceId, voucherId, userId, companyId })
|
|
expect(first.ok).toBe(true)
|
|
|
|
const second = await callLinkRpc({ invoiceId, voucherId, userId, companyId })
|
|
expect(second.ok).toBe(false)
|
|
expect(second.code).toBe('LINK_VOUCHER_ALREADY_LINKED')
|
|
|
|
const { rows: pay } = await getPool().query(
|
|
`SELECT COUNT(*) AS count FROM public.invoice_payments WHERE invoice_id = $1`,
|
|
[invoiceId],
|
|
)
|
|
expect(Number(pay[0].count)).toBe(1)
|
|
})
|
|
|
|
it('REGRESSION (the C2 race): two concurrent full-payment links: exactly one wins', async () => {
|
|
const userId = await insertAuthUser()
|
|
const companyId = await insertCompany({ createdBy: userId })
|
|
await insertCompanyMember({ companyId, userId })
|
|
const fiscalPeriodId = await insertFiscalPeriod({ userId, companyId })
|
|
const customerId = await seedCustomer({ userId, companyId })
|
|
const invoiceId = await seedInvoice({ userId, companyId, customerId, total: 1000 })
|
|
const voucherA = await seedPostedVoucher({ userId, companyId, fiscalPeriodId, amount: 1000 })
|
|
const voucherB = await seedPostedVoucher({ userId, companyId, fiscalPeriodId, amount: 1000 })
|
|
|
|
// Two different vouchers, each covering the full remaining, racing on the
|
|
// same invoice from separate pool connections. The FOR UPDATE lock must
|
|
// serialize them: the loser sees remaining = 0 and gets FULLY_PAID. Under
|
|
// the old TS path both could pass validation and the invoice ended up
|
|
// with paid_amount > total (the audit C2 corruption).
|
|
const [r1, r2] = await Promise.all([
|
|
callLinkRpc({ invoiceId, voucherId: voucherA, userId, companyId }),
|
|
callLinkRpc({ invoiceId, voucherId: voucherB, userId, companyId }),
|
|
])
|
|
|
|
const winners = [r1, r2].filter((r) => r.ok)
|
|
const losers = [r1, r2].filter((r) => !r.ok)
|
|
expect(winners).toHaveLength(1)
|
|
expect(losers).toHaveLength(1)
|
|
expect(losers[0].code).toBe('LINK_VOUCHER_INVOICE_FULLY_PAID')
|
|
|
|
const { rows: inv } = await getPool().query(
|
|
`SELECT status, paid_amount, remaining_amount FROM public.invoices WHERE id = $1`,
|
|
[invoiceId],
|
|
)
|
|
expect(inv[0].status).toBe('paid')
|
|
expect(Number(inv[0].paid_amount)).toBe(1000) // never 2000
|
|
expect(Number(inv[0].remaining_amount)).toBe(0)
|
|
|
|
const { rows: pay } = await getPool().query(
|
|
`SELECT COUNT(*) AS count FROM public.invoice_payments WHERE invoice_id = $1`,
|
|
[invoiceId],
|
|
)
|
|
expect(Number(pay[0].count)).toBe(1)
|
|
})
|
|
})
|
|
|
|
// ============================================================
|
|
// link_invoice_to_voucher RPC: kontantmetoden branch
|
|
// On cash method no 1510 is ever booked (revenue is recognised at payment),
|
|
// so the RPC must key on the bank/cash DEBIT (19xx) instead of the AR credit.
|
|
// Mirrors the accounting-method branch in lib/invoices/voucher-matching.ts.
|
|
// ============================================================
|
|
describe('link_invoice_to_voucher RPC (kontantmetoden: 19xx debit)', () => {
|
|
it('cash method: links against the 1930 debit of a receipt voucher (no 1510)', async () => {
|
|
const userId = await insertAuthUser()
|
|
const companyId = await insertCompany({ createdBy: userId })
|
|
await insertCompanyMember({ companyId, userId })
|
|
await setCashMethod(companyId)
|
|
const fiscalPeriodId = await insertFiscalPeriod({ userId, companyId })
|
|
const customerId = await seedCustomer({ userId, companyId })
|
|
const invoiceId = await seedInvoice({ userId, companyId, customerId, total: 1000 })
|
|
// Cash receipt: debit 1930 (bank) / credit 3001 (revenue): no receivable.
|
|
const voucherId = await seedVoucherDebitCredit({
|
|
userId,
|
|
companyId,
|
|
fiscalPeriodId,
|
|
amount: 1000,
|
|
debitAccount: '1930',
|
|
creditAccount: '3001',
|
|
})
|
|
|
|
const result = await callLinkRpc({ invoiceId, voucherId, userId, companyId })
|
|
expect(result.ok).toBe(true)
|
|
expect(result.invoice_status).toBe('paid')
|
|
expect(Number(result.paid_amount)).toBe(1000)
|
|
expect(Number(result.remaining_amount)).toBe(0)
|
|
|
|
const { rows: pay } = await getPool().query(
|
|
`SELECT amount FROM public.invoice_payments WHERE invoice_id = $1 AND journal_entry_id = $2`,
|
|
[invoiceId, voucherId],
|
|
)
|
|
expect(pay).toHaveLength(1)
|
|
expect(Number(pay[0].amount)).toBe(1000)
|
|
})
|
|
|
|
it('cash method: rejects a voucher with no bank/cash debit (NO_AR_CREDIT)', async () => {
|
|
const userId = await insertAuthUser()
|
|
const companyId = await insertCompany({ createdBy: userId })
|
|
await insertCompanyMember({ companyId, userId })
|
|
await setCashMethod(companyId)
|
|
const fiscalPeriodId = await insertFiscalPeriod({ userId, companyId })
|
|
const customerId = await seedCustomer({ userId, companyId })
|
|
const invoiceId = await seedInvoice({ userId, companyId, customerId, total: 1000 })
|
|
// An AR-clearing voucher (debit 1510 / credit 3001): valid on accrual, but
|
|
// on cash there is no 19xx debit, so it must not match.
|
|
const voucherId = await seedVoucherDebitCredit({
|
|
userId,
|
|
companyId,
|
|
fiscalPeriodId,
|
|
amount: 1000,
|
|
debitAccount: '1510',
|
|
creditAccount: '3001',
|
|
})
|
|
|
|
const result = await callLinkRpc({ invoiceId, voucherId, userId, companyId })
|
|
expect(result.ok).toBe(false)
|
|
expect(result.code).toBe('LINK_VOUCHER_NO_AR_CREDIT')
|
|
|
|
const { rows: inv } = await getPool().query(
|
|
`SELECT status, paid_amount FROM public.invoices WHERE id = $1`,
|
|
[invoiceId],
|
|
)
|
|
expect(inv[0].status).toBe('sent')
|
|
expect(Number(inv[0].paid_amount)).toBe(0)
|
|
})
|
|
|
|
it('accrual default (no settings row): still keys on the 1510 credit', async () => {
|
|
// Regression guard: a company with no company_settings row must behave as
|
|
// accrual: the 1930-debit / 1510-credit voucher links via its AR credit.
|
|
const userId = await insertAuthUser()
|
|
const companyId = await insertCompany({ createdBy: userId })
|
|
await insertCompanyMember({ companyId, userId })
|
|
const fiscalPeriodId = await insertFiscalPeriod({ userId, companyId })
|
|
const customerId = await seedCustomer({ userId, companyId })
|
|
const invoiceId = await seedInvoice({ userId, companyId, customerId, total: 1000 })
|
|
const voucherId = await seedPostedVoucher({ userId, companyId, fiscalPeriodId, amount: 1000 })
|
|
|
|
const result = await callLinkRpc({ invoiceId, voucherId, userId, companyId })
|
|
expect(result.ok).toBe(true)
|
|
expect(result.invoice_status).toBe('paid')
|
|
})
|
|
})
|
|
|
|
describe('link_supplier_invoice_to_voucher RPC payment date', () => {
|
|
it('anchors paid_at at UTC noon on the voucher entry date', async () => {
|
|
const userId = await insertAuthUser()
|
|
const companyId = await insertCompany({ createdBy: userId })
|
|
await insertCompanyMember({ companyId, userId })
|
|
const fiscalPeriodId = await insertFiscalPeriod({ userId, companyId })
|
|
|
|
const supplierId = randomUUID()
|
|
await getPool().query(
|
|
`INSERT INTO public.suppliers
|
|
(id, user_id, company_id, name, supplier_type, country,
|
|
default_payment_terms, default_currency)
|
|
VALUES ($1, $2, $3, 'Leverantör AB', 'swedish_business', 'SE', 30, 'SEK')`,
|
|
[supplierId, userId, companyId],
|
|
)
|
|
|
|
const supplierInvoiceId = randomUUID()
|
|
const arrivalNumber = Number.parseInt(supplierInvoiceId.slice(0, 8), 16) % 2_000_000_000
|
|
await getPool().query(
|
|
`INSERT INTO public.supplier_invoices
|
|
(id, user_id, company_id, supplier_id, arrival_number, supplier_invoice_number,
|
|
invoice_date, due_date, received_date, status, currency,
|
|
subtotal, vat_amount, total, paid_amount, remaining_amount,
|
|
vat_treatment, reverse_charge, is_credit_note)
|
|
VALUES ($1, $2, $3, $4, $5, $6, '2026-04-01', '2026-05-01', '2026-04-01',
|
|
'approved', 'SEK', 1000, 0, 1000, 0, 1000,
|
|
'standard_25', false, false)`,
|
|
[
|
|
supplierInvoiceId,
|
|
userId,
|
|
companyId,
|
|
supplierId,
|
|
arrivalNumber,
|
|
`LF-${supplierInvoiceId.slice(0, 8)}`,
|
|
],
|
|
)
|
|
|
|
const voucherId = await seedVoucherDebitCredit({
|
|
userId,
|
|
companyId,
|
|
fiscalPeriodId,
|
|
amount: 1000,
|
|
debitAccount: '2440',
|
|
creditAccount: '1930',
|
|
})
|
|
|
|
const { rows } = await getPool().query<{ result: RpcResult }>(
|
|
`SELECT public.link_supplier_invoice_to_voucher($1, $2, $3, $4, NULL) AS result`,
|
|
[supplierInvoiceId, voucherId, userId, companyId],
|
|
)
|
|
expect(rows[0].result.ok).toBe(true)
|
|
expect(rows[0].result.invoice_status).toBe('paid')
|
|
|
|
const { rows: invoiceRows } = await getPool().query<{ paid_at_matches: boolean }>(
|
|
`SELECT paid_at = TIMESTAMPTZ '2026-05-05 12:00:00+00' AS paid_at_matches
|
|
FROM public.supplier_invoices WHERE id = $1`,
|
|
[supplierInvoiceId],
|
|
)
|
|
expect(invoiceRows[0].paid_at_matches).toBe(true)
|
|
|
|
const { rows: paymentRows } = await getPool().query<{ payment_date_matches: boolean }>(
|
|
`SELECT payment_date = DATE '2026-05-05' AS payment_date_matches
|
|
FROM public.supplier_invoice_payments
|
|
WHERE supplier_invoice_id = $1 AND journal_entry_id = $2`,
|
|
[supplierInvoiceId, voucherId],
|
|
)
|
|
expect(paymentRows).toHaveLength(1)
|
|
expect(paymentRows[0].payment_date_matches).toBe(true)
|
|
})
|
|
})
|