Files
accounted/lib/reports/__tests__/kpi-aggregates.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

205 lines
7.1 KiB
TypeScript

import { describe, it, expect, vi } from 'vitest'
import {
fetchKpiAggregates,
buildOpeningBalances,
buildTrialBalanceRows,
type KpiAggregates,
} from '../kpi-aggregates'
function emptyAgg(overrides: Partial<KpiAggregates> = {}): KpiAggregates {
return { tb: [], tb_ex_year_end: [], ob: [], monthly: [], ...overrides }
}
describe('fetchKpiAggregates', () => {
it('calls the RPC with the expected args and coerces numbers', async () => {
const rpc = vi.fn().mockResolvedValue({
data: {
tb: [{ account_number: '1930', debit: '125.5', credit: 0 }],
tb_ex_year_end: [{ account_number: '3001', debit: null, credit: 100 }],
ob: [],
monthly: [{ year: 2026, month: '2', income: '10.25', expenses: undefined }],
},
error: null,
})
const supabase = { rpc } as never
const agg = await fetchKpiAggregates(supabase, 'company-1', 'period-1', 'ob-1')
expect(rpc).toHaveBeenCalledWith('get_kpi_report_aggregates', {
p_company_id: 'company-1',
p_fiscal_period_id: 'period-1',
p_ob_entry_id: 'ob-1',
})
expect(agg.tb).toEqual([{ account_number: '1930', debit: 125.5, credit: 0 }])
expect(agg.tb_ex_year_end).toEqual([{ account_number: '3001', debit: 0, credit: 100 }])
expect(agg.ob).toEqual([])
expect(agg.monthly).toEqual([{ year: 2026, month: 2, income: 10.25, expenses: 0 }])
})
it('defaults missing sections to empty arrays', async () => {
const rpc = vi.fn().mockResolvedValue({ data: {}, error: null })
const supabase = { rpc } as never
const agg = await fetchKpiAggregates(supabase, 'company-1', 'period-1', null)
expect(agg).toEqual(emptyAgg())
expect(rpc).toHaveBeenCalledWith('get_kpi_report_aggregates', {
p_company_id: 'company-1',
p_fiscal_period_id: 'period-1',
p_ob_entry_id: null,
})
})
it('throws a prefixed error when the RPC fails', async () => {
const rpc = vi.fn().mockResolvedValue({ data: null, error: { message: 'boom' } })
const supabase = { rpc } as never
await expect(
fetchKpiAggregates(supabase, 'company-1', 'period-1', null)
).rejects.toThrow('get_kpi_report_aggregates failed: boom')
})
})
describe('buildOpeningBalances', () => {
it('OB-entry path (priorRows null): additive accumulation with Number coercion', () => {
const agg = emptyAgg({
ob: [
{ account_number: '1930', debit: 5000, credit: 0 },
// A duplicate account accumulates additively, mirroring the
// per-line loop in opening-balances.ts lines 57-62.
{ account_number: '1930', debit: 250.5, credit: 0 },
{ account_number: '2010', debit: 0, credit: 5250.5 },
],
})
const balances = buildOpeningBalances(agg, null)
expect(balances.get('1930')).toEqual({ debit: 5250.5, credit: 0 })
expect(balances.get('2010')).toEqual({ debit: 0, credit: 5250.5 })
expect(balances.size).toBe(2)
})
it('fallback path: uses priorRows with Number()||0 coercion, ignoring the ob section', () => {
const agg = emptyAgg({
ob: [{ account_number: '9999', debit: 1, credit: 1 }],
})
// compute_prior_opening_balances returns numerics that may arrive as
// strings through PostgREST: mirrors opening-balances.ts lines 77-86.
const balances = buildOpeningBalances(agg, [
{ account_number: '1930', debit: '1500.25', credit: '0' },
{ account_number: '2440', debit: 'not-a-number', credit: 300 },
])
expect(balances.get('1930')).toEqual({ debit: 1500.25, credit: 0 })
expect(balances.get('2440')).toEqual({ debit: 0, credit: 300 })
expect(balances.has('9999')).toBe(false)
})
it('empty inputs produce an empty map in both shapes', () => {
expect(buildOpeningBalances(emptyAgg(), null).size).toBe(0)
expect(buildOpeningBalances(emptyAgg(), []).size).toBe(0)
})
})
describe('buildTrialBalanceRows', () => {
const accountMap = new Map<string, { name: string; class: number }>([
['1930', { name: 'Företagskonto', class: 1 }],
['3001', { name: 'Försäljning 25%', class: 3 }],
])
it('merges opening and period accounts and computes IB + period = UB', () => {
const opening = new Map([
['1930', { debit: 5000, credit: 0 }],
// Account only in opening: must still get a row.
['2081', { debit: 0, credit: 25000 }],
])
const periodSums = [
{ account_number: '1930', debit: 12500, credit: 3000 },
// Account only in period: must still get a row.
{ account_number: '3001', debit: 0, credit: 10000 },
]
const rows = buildTrialBalanceRows(opening, periodSums, accountMap)
expect(rows.map((r) => r.account_number)).toEqual(['1930', '2081', '3001'])
expect(rows[0]).toEqual({
account_number: '1930',
account_name: 'Företagskonto',
account_class: 1,
opening_debit: 5000,
opening_credit: 0,
period_debit: 12500,
period_credit: 3000,
closing_debit: 17500,
closing_credit: 3000,
})
expect(rows[1]).toMatchObject({
account_number: '2081',
opening_credit: 25000,
period_debit: 0,
period_credit: 0,
closing_credit: 25000,
})
expect(rows[2]).toMatchObject({
account_number: '3001',
account_name: 'Försäljning 25%',
account_class: 3,
opening_debit: 0,
period_credit: 10000,
closing_credit: 10000,
})
})
it('falls back to "Konto <n>" naming and first-digit class for unknown accounts', () => {
const rows = buildTrialBalanceRows(
new Map(),
[
{ account_number: '2611', debit: 0, credit: 2500 },
{ account_number: 'X99', debit: 1, credit: 0 },
],
accountMap
)
const unknown = rows.find((r) => r.account_number === '2611')!
expect(unknown.account_name).toBe('Konto 2611')
expect(unknown.account_class).toBe(2)
// parseInt(n[0]) || 0 fallback: non-numeric first char lands class 0,
// same as trial-balance.ts line 306.
const weird = rows.find((r) => r.account_number === 'X99')!
expect(weird.account_name).toBe('Konto X99')
expect(weird.account_class).toBe(0)
})
it('rounds all six amount fields with Math.round(x * 100) / 100', () => {
const opening = new Map([['1930', { debit: 0.1, credit: 0 }]])
const rows = buildTrialBalanceRows(
opening,
[{ account_number: '1930', debit: 0.2, credit: 0.005 }],
accountMap
)
// 0.1 + 0.2 = 0.30000000000000004 raw: closing must land on 0.3 exactly.
expect(rows[0].opening_debit).toBe(0.1)
expect(rows[0].period_debit).toBe(0.2)
expect(rows[0].closing_debit).toBe(0.3)
expect(rows[0].period_credit).toBe(0.01)
expect(rows[0].closing_credit).toBe(0.01)
})
it('sorts rows by account_number with localeCompare', () => {
const rows = buildTrialBalanceRows(
new Map(),
[
{ account_number: '8999', debit: 1, credit: 0 },
{ account_number: '1510', debit: 1, credit: 0 },
{ account_number: '2440', debit: 1, credit: 0 },
],
accountMap
)
expect(rows.map((r) => r.account_number)).toEqual(['1510', '2440', '8999'])
})
it('returns no rows when both inputs are empty', () => {
expect(buildTrialBalanceRows(new Map(), [], accountMap)).toEqual([])
})
})