Files
accounted/lib/import/opening-balance/__tests__/cascade.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

458 lines
16 KiB
TypeScript

import { describe, it, expect, vi, beforeEach } from 'vitest'
import { createQueuedMockSupabase } from '@/tests/helpers'
import { createTestLogger } from '@/lib/logger'
const { supabase: mockSupabase, enqueue, reset } = createQueuedMockSupabase()
const mockReplaceOpeningBalanceEntry = vi.fn()
vi.mock('@/lib/bookkeeping/engine', () => ({
replaceOpeningBalanceEntry: (...args: unknown[]) => mockReplaceOpeningBalanceEntry(...args),
}))
const mockFetchEntryLines = vi.fn()
vi.mock('@/lib/bookkeeping/entry-lines', () => ({
fetchEntryLines: (...args: unknown[]) => mockFetchEntryLines(...args),
}))
import {
computeAccountDeltas,
buildCascadedLines,
cascadeOpeningBalanceCorrection,
type CascadeSourceLine,
} from '../cascade'
import type { SupabaseClient } from '@supabase/supabase-js'
const D = (account_number: string, debit_amount: number) => ({
account_number,
debit_amount,
credit_amount: 0,
})
const K = (account_number: string, credit_amount: number) => ({
account_number,
debit_amount: 0,
credit_amount,
})
const src = (
line: { account_number: string; debit_amount: number; credit_amount: number },
extra: Partial<CascadeSourceLine> = {},
): CascadeSourceLine => ({
line_description: null,
dimensions: null,
...line,
...extra,
})
describe('computeAccountDeltas', () => {
it('returns the per-account net change, omitting unchanged accounts', () => {
const oldLines = [D('1930', 50000), K('2099', 50000)]
const newLines = [D('1930', 40000), D('1630', 10000), K('2099', 50000)]
const deltas = computeAccountDeltas(oldLines, newLines)
expect(deltas.get('1930')).toBe(-10000)
expect(deltas.get('1630')).toBe(10000)
expect(deltas.has('2099')).toBe(false)
expect(deltas.size).toBe(2)
})
it('handles accounts removed entirely from the corrected entry', () => {
const oldLines = [D('1930', 30000), D('1630', 20000), K('2099', 50000)]
const newLines = [D('1930', 50000), K('2099', 50000)]
const deltas = computeAccountDeltas(oldLines, newLines)
expect(deltas.get('1630')).toBe(-20000)
expect(deltas.get('1930')).toBe(20000)
})
it('rounds öre correctly (no floating point drift)', () => {
const oldLines = [D('1930', 100.1), K('2099', 100.1)]
const newLines = [D('1930', 100.3), K('2099', 100.3)]
const deltas = computeAccountDeltas(oldLines, newLines)
expect(deltas.get('1930')).toBe(0.2)
expect(deltas.get('2099')).toBe(-0.2)
})
})
describe('buildCascadedLines', () => {
it('keeps original lines verbatim (descriptions and dimensions) and appends sorted adjustment lines', () => {
const existing = [
src(D('1930', 80000), { line_description: 'IB 1930', dimensions: { '1': 'STHLM' } }),
src(K('2099', 80000), { line_description: 'IB 2099' }),
]
const deltas = new Map([
['1930', -10000],
['1630', 10000],
])
const result = buildCascadedLines(existing, deltas)
expect(result).toEqual([
{
account_number: '1930',
debit_amount: 80000,
credit_amount: 0,
line_description: 'IB 1930',
dimensions: { '1': 'STHLM' },
},
{
account_number: '2099',
debit_amount: 0,
credit_amount: 80000,
line_description: 'IB 2099',
dimensions: undefined,
},
{
account_number: '1630',
debit_amount: 10000,
credit_amount: 0,
line_description: 'IB-rättelse 1630',
},
{
account_number: '1930',
debit_amount: 0,
credit_amount: 10000,
line_description: 'IB-rättelse 1930',
},
])
const totalDebit = result.reduce((s, l) => s + l.debit_amount, 0)
const totalCredit = result.reduce((s, l) => s + l.credit_amount, 0)
expect(totalDebit).toBe(totalCredit)
})
it('emits a credit adjustment line for a negative delta and drops zero-amount source rows', () => {
const existing = [
src(D('1930', 5000)),
src(K('2099', 5000)),
src({ account_number: '1510', debit_amount: 0, credit_amount: 0 }),
]
const deltas = new Map([
['1930', -8000],
['2099', 8000],
])
const result = buildCascadedLines(existing, deltas)
expect(result.map((l) => l.account_number)).toEqual(['1930', '2099', '1930', '2099'])
expect(result[2]).toEqual({
account_number: '1930',
debit_amount: 0,
credit_amount: 8000,
line_description: 'IB-rättelse 1930',
})
expect(result[3]).toEqual({
account_number: '2099',
debit_amount: 8000,
credit_amount: 0,
line_description: 'IB-rättelse 2099',
})
})
})
describe('cascadeOpeningBalanceCorrection', () => {
const sink: Parameters<typeof createTestLogger>[1] = []
const log = createTestLogger('cascade-test', sink)
const supabase = mockSupabase as unknown as SupabaseClient
const DELTAS = new Map([
['1930', -10000],
['1630', 10000],
])
const periodRow = (overrides: Record<string, unknown> = {}) => ({
id: 'period-2020',
name: '2020',
period_start: '2020-01-01',
is_closed: false,
locked_at: null,
opening_balance_entry_id: 'ib-2020',
opening_balance_entry: { voucher_series: 'A', voucher_number: 4 },
...overrides,
})
beforeEach(() => {
vi.clearAllMocks()
reset()
sink.length = 0
mockFetchEntryLines.mockResolvedValue([
{ id: 'l1', account_number: '1930', debit_amount: 80000, credit_amount: 0, line_description: 'IB 1930', dimensions: null },
{ id: 'l2', account_number: '2099', debit_amount: 0, credit_amount: 80000, line_description: 'IB 2099', dimensions: null },
])
mockReplaceOpeningBalanceEntry.mockResolvedValue({
newEntryId: 'ib-new',
stornoEntryId: 'ib-storno',
newVoucherNumber: 9,
stornoVoucherNumber: 10,
})
})
it('returns immediately without queries when there are no deltas', async () => {
const result = await cascadeOpeningBalanceCorrection(supabase, 'company-1', 'user-1', {
basePeriodStart: '2019-01-01',
deltas: new Map(),
lockDate: null,
log,
})
expect(result).toEqual({ corrected: [], skipped: [] })
expect(mockSupabase.from).not.toHaveBeenCalled()
})
it('replaces an open later period atomically and skips a closed one', async () => {
enqueue({
data: [
periodRow(),
periodRow({ id: 'period-2021', name: '2021', period_start: '2021-01-01', is_closed: true, opening_balance_entry_id: 'ib-2021' }),
],
}) // subsequent periods
enqueue({ count: 0 }) // year-end check for period-2020
const result = await cascadeOpeningBalanceCorrection(supabase, 'company-1', 'user-1', {
basePeriodStart: '2019-01-01',
deltas: DELTAS,
lockDate: null,
log,
})
expect(result.corrected).toEqual([
{
fiscal_period_id: 'period-2020',
period_name: '2020',
journal_entry_id: 'ib-new',
reversed_entry_id: 'ib-2020',
},
])
expect(result.skipped).toEqual([
{ fiscal_period_id: 'period-2021', period_name: '2021', reason: 'closed' },
])
// One atomic engine replacement, CAS-guarded on the old entry, carrying
// the original lines verbatim plus labelled adjustment lines and the BFL
// reference to the verifikat being rättat.
expect(mockReplaceOpeningBalanceEntry).toHaveBeenCalledTimes(1)
expect(mockReplaceOpeningBalanceEntry).toHaveBeenCalledWith(
expect.anything(),
'company-1',
'user-1',
'ib-2020',
expect.objectContaining({
fiscal_period_id: 'period-2020',
entry_date: '2020-01-01',
source_type: 'opening_balance',
voucher_series: 'A',
description: 'Ingående balanser (korrigerade, rättelse av A4)',
lines: [
expect.objectContaining({ account_number: '1930', debit_amount: 80000, line_description: 'IB 1930' }),
expect.objectContaining({ account_number: '2099', credit_amount: 80000 }),
expect.objectContaining({ account_number: '1630', debit_amount: 10000, line_description: 'IB-rättelse 1630' }),
expect.objectContaining({ account_number: '1930', credit_amount: 10000, line_description: 'IB-rättelse 1930' }),
],
}),
)
})
it('skips locked, lock-dated, and bokslut periods without touching them', async () => {
enqueue({
data: [
periodRow({ id: 'p-locked', name: '2020', locked_at: '2021-05-01T00:00:00Z' }),
periodRow({ id: 'p-lockdate', name: '2021', period_start: '2021-01-01' }),
periodRow({ id: 'p-yearend', name: '2022', period_start: '2022-01-01' }),
],
})
// p-lockdate: period_start 2021-01-01 <= lockDate 2021-12-31 → skipped
// before any further query. p-yearend reaches the year-end check:
enqueue({ count: 2 }) // year-end check for p-yearend
const result = await cascadeOpeningBalanceCorrection(supabase, 'company-1', 'user-1', {
basePeriodStart: '2019-01-01',
deltas: DELTAS,
lockDate: '2021-12-31',
log,
})
expect(result.corrected).toEqual([])
expect(result.skipped).toEqual([
{ fiscal_period_id: 'p-locked', period_name: '2020', reason: 'locked' },
{ fiscal_period_id: 'p-lockdate', period_name: '2021', reason: 'lock_date' },
{ fiscal_period_id: 'p-yearend', period_name: '2022', reason: 'year_end' },
])
expect(mockReplaceOpeningBalanceEntry).not.toHaveBeenCalled()
})
it('fails CLOSED when the year-end lookup errors: the period is skipped, not rewritten', async () => {
enqueue({ data: [periodRow()] })
enqueue({ count: null, error: { message: 'transient boom' } }) // year-end check fails
const result = await cascadeOpeningBalanceCorrection(supabase, 'company-1', 'user-1', {
basePeriodStart: '2019-01-01',
deltas: DELTAS,
lockDate: null,
log,
})
expect(result.corrected).toEqual([])
expect(result.skipped).toEqual([
{ fiscal_period_id: 'period-2020', period_name: '2020', reason: 'correction_failed' },
])
expect(mockReplaceOpeningBalanceEntry).not.toHaveBeenCalled()
const audit = sink.filter((r) => String(r.msg).includes('cascade correction failed'))
expect(audit.length).toBeGreaterThan(0)
})
it('reports a period without a linked IB verifikat as skipped', async () => {
enqueue({ data: [periodRow({ opening_balance_entry_id: null, opening_balance_entry: null })] })
const result = await cascadeOpeningBalanceCorrection(supabase, 'company-1', 'user-1', {
basePeriodStart: '2019-01-01',
deltas: DELTAS,
lockDate: null,
log,
})
expect(result.skipped).toEqual([
{ fiscal_period_id: 'period-2020', period_name: '2020', reason: 'no_opening_balance' },
])
expect(mockReplaceOpeningBalanceEntry).not.toHaveBeenCalled()
})
it('reports a failed replacement as skipped and continues with the next year', async () => {
enqueue({
data: [
periodRow(),
periodRow({ id: 'period-2021', name: '2021', period_start: '2021-01-01', opening_balance_entry_id: 'ib-2021' }),
],
})
enqueue({ count: 0 }) // year-end check period-2020
enqueue({ count: 0 }) // year-end check period-2021
mockReplaceOpeningBalanceEntry
.mockRejectedValueOnce(new Error('replacement boom')) // period-2020
.mockResolvedValueOnce({
newEntryId: 'ib-2021-new',
stornoEntryId: 'ib-2021-storno',
newVoucherNumber: 12,
stornoVoucherNumber: 13,
})
const result = await cascadeOpeningBalanceCorrection(supabase, 'company-1', 'user-1', {
basePeriodStart: '2019-01-01',
deltas: DELTAS,
lockDate: null,
log,
})
expect(result.skipped).toEqual([
{ fiscal_period_id: 'period-2020', period_name: '2020', reason: 'correction_failed' },
])
expect(result.corrected).toEqual([
expect.objectContaining({ fiscal_period_id: 'period-2021', journal_entry_id: 'ib-2021-new' }),
])
// The failed period got exactly one atomic attempt (RPC rolls back all of
// it); no compensation writes exist in this design.
expect(mockReplaceOpeningBalanceEntry).toHaveBeenCalledTimes(2)
expect(mockReplaceOpeningBalanceEntry).toHaveBeenNthCalledWith(
1, expect.anything(), 'company-1', 'user-1', 'ib-2020', expect.anything(),
)
expect(mockReplaceOpeningBalanceEntry).toHaveBeenNthCalledWith(
2, expect.anything(), 'company-1', 'user-1', 'ib-2021', expect.anything(),
)
const audit = sink.filter((r) => String(r.msg).includes('cascade correction failed'))
expect(audit.length).toBeGreaterThan(0)
})
it('inline mode: appends adjustment lines in the same verifikat, no storno, no line fetch', async () => {
enqueue({ data: [periodRow()] }) // subsequent periods
enqueue({ count: 0 }) // year-end check
enqueue({ data: { log_id: 'log-1', struck_count: 0, added_count: 2 } }) // inline RPC
const result = await cascadeOpeningBalanceCorrection(supabase, 'company-1', 'user-1', {
basePeriodStart: '2019-01-01',
deltas: DELTAS,
lockDate: null,
mode: 'inline',
log,
})
expect(result.corrected).toEqual([
{
fiscal_period_id: 'period-2020',
period_name: '2020',
journal_entry_id: 'ib-2020',
reversed_entry_id: null,
},
])
expect(result.skipped).toEqual([])
expect(mockSupabase.rpc).toHaveBeenCalledWith(
'correct_entry_lines_inline',
expect.objectContaining({
p_company_id: 'company-1',
p_entry_id: 'ib-2020',
p_strike_line_ids: [],
p_new_lines: [
expect.objectContaining({ account_number: '1630', debit_amount: 10000, line_description: 'IB-rättelse 1630' }),
expect.objectContaining({ account_number: '1930', credit_amount: 10000, line_description: 'IB-rättelse 1930' }),
],
p_user_id: 'user-1',
}),
)
expect(mockReplaceOpeningBalanceEntry).not.toHaveBeenCalled()
expect(mockFetchEntryLines).not.toHaveBeenCalled()
})
it('inline mode: a refused rättelse skips the year and is audited', async () => {
enqueue({ data: [periodRow()] })
enqueue({ count: 0 }) // year-end check
enqueue({ data: null, error: { message: 'Perioden är stängd eller låst: använd rättelseverifikat (storno).' } })
const result = await cascadeOpeningBalanceCorrection(supabase, 'company-1', 'user-1', {
basePeriodStart: '2019-01-01',
deltas: DELTAS,
lockDate: null,
mode: 'inline',
log,
})
expect(result.corrected).toEqual([])
expect(result.skipped).toEqual([
{ fiscal_period_id: 'period-2020', period_name: '2020', reason: 'correction_failed' },
])
const audit = sink.filter((r) => String(r.msg).includes('cascade correction failed'))
expect(audit.length).toBeGreaterThan(0)
})
it('skips a period whose shifted lines no longer validate', async () => {
// The period's IB is a single line pair that the delta exactly cancels,
// leaving zero-amount adjustments only... construct instead the <2 lines
// case: the source entry is empty (all rows zero), so kept+adjustment
// lines fail the P&L/two-line validation via a P&L delta account.
mockFetchEntryLines.mockResolvedValue([
{ id: 'l1', account_number: '1930', debit_amount: 10000, credit_amount: 0, line_description: null, dimensions: null },
{ id: 'l2', account_number: '1630', debit_amount: 0, credit_amount: 10000, line_description: null, dimensions: null },
])
enqueue({ data: [periodRow()] })
enqueue({ count: 0 }) // year-end check
const result = await cascadeOpeningBalanceCorrection(supabase, 'company-1', 'user-1', {
basePeriodStart: '2019-01-01',
deltas: new Map([
['3001', 10000],
['1930', -10000],
]),
lockDate: null,
log,
})
expect(result.skipped).toEqual([
{ fiscal_period_id: 'period-2020', period_name: '2020', reason: 'validation_failed' },
])
expect(mockReplaceOpeningBalanceEntry).not.toHaveBeenCalled()
})
})