Files
accounted/lib/transactions/__tests__/purchases-without-underlag.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

111 lines
4.0 KiB
TypeScript

/**
* What counts as a purchase still missing its underlag.
*
* The interesting cases are the ones the column filter cannot see. A bank
* transaction can be booked three ways, and only one of them sets
* `journal_entry_id`: bulk-booking many transactions onto one verifikat records
* it in transaction_voucher_links, and a payment split across invoices records
* it in the payment tables. Both leave the column null.
*
* The receipt hunt tolerates those false candidates because the worst case is a
* proposal nobody accepts. This list is shown to a person, where the same rows
* would sit under "saknar underlag" forever, already booked, with nothing the
* user could do to clear them.
*/
import { describe, it, expect, vi, beforeEach } from 'vitest'
import { fetchPurchasesWithoutUnderlag } from '../purchases-without-underlag'
const rows = vi.fn()
vi.mock('@/lib/supabase/fetch-all', () => ({
fetchAllRows: async () => rows(),
}))
function tx(over: Record<string, unknown> = {}) {
return {
id: 'tx-1',
company_id: 'company-1',
date: '2026-08-04',
description: 'Elgiganten',
merchant_name: 'Elgiganten',
amount: -21639,
currency: 'SEK',
amount_sek: null,
exchange_rate: null,
journal_entry_id: null,
...over,
}
}
/** Supabase double whose link tables answer per table name. */
function db(links: { voucher?: string[]; invoice?: string[]; supplier?: string[] } = {}) {
const calls: string[] = []
return {
calls,
from(table: string) {
calls.push(table)
const ids =
table === 'transaction_voucher_links'
? links.voucher
: table === 'invoice_payments'
? links.invoice
: links.supplier
const data = (ids ?? []).map((id) => ({ transaction_id: id }))
const chain = { select: () => chain, in: async () => ({ data }) }
return chain
},
} as never
}
beforeEach(() => vi.clearAllMocks())
describe('fetchPurchasesWithoutUnderlag', () => {
it('returns purchases nothing has booked', async () => {
rows.mockReturnValue([tx()])
const out = await fetchPurchasesWithoutUnderlag(db(), 'company-1')
expect(out).toHaveLength(1)
expect(out[0].id).toBe('tx-1')
})
it('skips the link-table lookups when there is nothing to check', async () => {
rows.mockReturnValue([])
const supabase = db()
const out = await fetchPurchasesWithoutUnderlag(supabase, 'company-1')
expect(out).toEqual([])
expect((supabase as unknown as { calls: string[] }).calls).toEqual([])
})
it('excludes a transaction bulk-booked through a voucher link', async () => {
// Many transactions, one verifikat: journal_entry_id stays null on every
// one of them, so the column filter lets them all through.
rows.mockReturnValue([tx({ id: 'tx-bulk' })])
const out = await fetchPurchasesWithoutUnderlag(db({ voucher: ['tx-bulk'] }), 'company-1')
expect(out).toEqual([])
})
it('excludes a transaction that paid a customer invoice', async () => {
rows.mockReturnValue([tx({ id: 'tx-pay' })])
const out = await fetchPurchasesWithoutUnderlag(db({ invoice: ['tx-pay'] }), 'company-1')
expect(out).toEqual([])
})
it('excludes a transaction that paid a supplier invoice', async () => {
rows.mockReturnValue([tx({ id: 'tx-sup' })])
const out = await fetchPurchasesWithoutUnderlag(db({ supplier: ['tx-sup'] }), 'company-1')
expect(out).toEqual([])
})
it('keeps the unbooked ones when only some of a batch are booked', async () => {
rows.mockReturnValue([tx({ id: 'a' }), tx({ id: 'b' }), tx({ id: 'c' })])
const out = await fetchPurchasesWithoutUnderlag(db({ voucher: ['b'] }), 'company-1')
expect(out.map((p) => p.id)).toEqual(['a', 'c'])
})
it('excludes a row that already carries a journal entry', async () => {
// Belt and braces: the query filters this out, but the predicate is what
// the page trusts and it must agree.
rows.mockReturnValue([tx({ journal_entry_id: 'je-1' })])
const out = await fetchPurchasesWithoutUnderlag(db(), 'company-1')
expect(out).toEqual([])
})
})