Files
accounted/lib/reports/__tests__/dimension-pnl.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

291 lines
11 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import { describe, it, expect, vi, beforeEach } from 'vitest'
import type { TrialBalanceRow } from '@/types'
// ============================================================
// Resultat per projekt/kostnadsställe (dimensions PR4).
//
// generateTrialBalance is mocked (post-processor pattern, like
// resultatrapport.test.ts); the registry + tagged-line queries use a
// table-keyed FIFO mock.
// ============================================================
vi.mock('../trial-balance', () => ({
generateTrialBalance: vi.fn(),
}))
type MockResult = { data?: unknown; error?: unknown }
let mockResults: Record<string, MockResult[]>
function makeBuilder(tableName: string) {
const b: Record<string, unknown> = {}
for (const m of ['select', 'eq', 'in', 'lt', 'lte', 'gte', 'neq', 'not', 'contains', 'order', 'range']) {
b[m] = vi.fn().mockReturnValue(b)
}
const consume = (): MockResult => {
const queue = mockResults[tableName]
if (!queue || queue.length === 0) {
// The two-step entry-lines fetch (lib/bookkeeping/entry-lines.ts) reads
// journal_entries before journal_entry_lines. Tests queue line rows
// directly, so default the entries step to one generic entry.
if (tableName === 'journal_entries') {
return { data: [{ id: 'entry-1' }], error: null }
}
return { data: null, error: null }
}
return queue.shift()!
}
b.single = vi.fn().mockImplementation(async () => consume())
b.maybeSingle = vi.fn().mockImplementation(async () => consume())
b.then = (resolve: (v: unknown) => void) => resolve(consume())
return b
}
function makeClient() {
return {
from: vi.fn().mockImplementation((table: string) => makeBuilder(table)),
// eslint-disable-next-line @typescript-eslint/no-explicit-any
} as any
}
import { generateDimensionPnl } from '../dimension-pnl'
import { generateTrialBalance } from '../trial-balance'
const mockTrialBalance = vi.mocked(generateTrialBalance)
function tbRow(partial: Partial<TrialBalanceRow>): TrialBalanceRow {
return {
account_number: '3001',
account_name: 'Försäljning',
account_class: 3,
opening_debit: 0,
opening_credit: 0,
period_debit: 0,
period_credit: 0,
closing_debit: 0,
closing_credit: 0,
...partial,
}
}
function tb(rows: TrialBalanceRow[]) {
return { rows, totalDebit: 0, totalCredit: 0, isBalanced: true }
}
let supabase: ReturnType<typeof makeClient>
beforeEach(() => {
vi.clearAllMocks()
mockResults = {}
supabase = makeClient()
})
const PERIOD = { period_start: '2026-01-01', period_end: '2026-12-31' }
describe('generateDimensionPnl', () => {
it('builds the value-as-column matrix with an untagged residual that reconciles to the trial balance', async () => {
mockResults = {
fiscal_periods: [{ data: PERIOD, error: null }],
dimensions: [
{ data: { id: 'dim-6', sie_dim_no: 6, name: 'Projekt' }, error: null },
],
dimension_values: [
{
data: [
{ code: 'P001', name: 'Villa Almgren' },
{ code: 'P002', name: 'Kontorsbygget' },
],
error: null,
},
],
journal_entry_lines: [
{
data: [
{ id: 'l1', account_number: '3001', debit_amount: 0, credit_amount: 600, dimensions: { '6': 'P001' } },
{ id: 'l2', account_number: '3001', debit_amount: 0, credit_amount: 300, dimensions: { '6': 'P002' } },
{ id: 'l3', account_number: '4010', debit_amount: 400, credit_amount: 0, dimensions: { '6': 'P001' } },
// Balance-account line: outside the P&L scope, must be ignored.
{ id: 'l4', account_number: '1930', debit_amount: 0, credit_amount: 900, dimensions: { '6': 'P001' } },
],
error: null,
},
],
}
mockTrialBalance.mockResolvedValue(
tb([
// 3001: 1000 total credit: only 900 of it is tagged → 100 untagged.
tbRow({ account_number: '3001', account_class: 3, closing_credit: 1000 }),
tbRow({ account_number: '4010', account_name: 'Inköp', account_class: 4, closing_debit: 400 }),
tbRow({ account_number: '1930', account_name: 'Bank', account_class: 1, closing_debit: 900 }),
]),
)
const report = await generateDimensionPnl(supabase, 'company-1', 'period-1', '6')
expect(report.dimension).toEqual({ sie_dim_no: '6', name: 'Projekt' })
expect(report.columns).toEqual([
{ code: 'P001', name: 'Villa Almgren' },
{ code: 'P002', name: 'Kontorsbygget' },
{ code: null, name: null }, // (Utan dimension)
])
const revenue = report.groups.find((g) => g.class === 3)!
expect(revenue.rows).toEqual([
{ account_number: '3001', account_name: 'Försäljning', values: [600, 300, 100], total: 1000 },
])
const costs = report.groups.find((g) => g.class === 4)!
expect(costs.rows).toEqual([
{ account_number: '4010', account_name: 'Inköp', values: [-400, 0, 0], total: -400 },
])
// Every row sums exactly to its Totalt (reconciliation by construction).
for (const g of report.groups) {
for (const r of g.rows) {
expect(r.values.reduce((s, v) => s + v, 0)).toBeCloseTo(r.total, 10)
}
}
expect(report.net_per_column).toEqual([200, 300, 100])
// net_total = resultatrapport semantics over classes 3-8:
// +1000 (3001) − 400 (4010) = 600. 1930 (class 1) excluded.
expect(report.net_total).toBe(600)
expect(report.period).toEqual({ start: '2026-01-01', end: '2026-12-31' })
})
it('lists a booked 8999 in the untagged bucket and nets it into net_total (#2455)', async () => {
mockResults = {
fiscal_periods: [{ data: PERIOD, error: null }],
dimensions: [{ data: { id: 'dim-6', sie_dim_no: 6, name: 'Projekt' }, error: null }],
dimension_values: [{ data: [{ code: 'P001', name: 'Villa Almgren' }], error: null }],
journal_entry_lines: [
{
data: [
{ id: 'l1', account_number: '3001', debit_amount: 0, credit_amount: 1000, dimensions: { '6': 'P001' } },
],
error: null,
},
],
}
mockTrialBalance.mockResolvedValue(
tb([
tbRow({ account_number: '3001', account_class: 3, closing_credit: 1000 }),
// Manual omföring of årets resultat: 8999 debit, never dimension-tagged.
tbRow({ account_number: '8999', account_name: 'Årets resultat', account_class: 8, closing_debit: 1000 }),
]),
)
const report = await generateDimensionPnl(supabase, 'company-1', 'period-1', '6')
const row8999 = report.groups.flatMap((g) => g.rows).find((r) => r.account_number === '8999')
expect(row8999?.total).toBe(-1000)
// Same scope as resultatrapport: the omföring zeroes the result.
expect(report.net_total).toBe(0)
expect(report.net_per_column).toEqual([1000, -1000])
})
it('drops the untagged column when every krona is tagged', async () => {
mockResults = {
fiscal_periods: [{ data: PERIOD, error: null }],
dimensions: [{ data: { id: 'dim-6', sie_dim_no: 6, name: 'Projekt' }, error: null }],
dimension_values: [{ data: [{ code: 'P001', name: 'Villa Almgren' }], error: null }],
journal_entry_lines: [
{
data: [
{ id: 'l1', account_number: '3001', debit_amount: 0, credit_amount: 1000, dimensions: { '6': 'P001' } },
],
error: null,
},
],
}
mockTrialBalance.mockResolvedValue(
tb([tbRow({ account_number: '3001', account_class: 3, closing_credit: 1000 })]),
)
const report = await generateDimensionPnl(supabase, 'company-1', 'period-1', '6')
expect(report.columns).toEqual([{ code: 'P001', name: 'Villa Almgren' }])
expect(report.groups[0].rows[0].values).toEqual([1000])
expect(report.net_per_column).toEqual([1000])
expect(report.net_total).toBe(1000)
})
it('falls back to seeded dimension names when the registry has no row', async () => {
mockResults = {
fiscal_periods: [{ data: PERIOD, error: null }],
dimensions: [{ data: null, error: null }],
journal_entry_lines: [
{
data: [
{ id: 'l1', account_number: '3001', debit_amount: 0, credit_amount: 100, dimensions: { '1': 'KS01' } },
],
error: null,
},
],
}
mockTrialBalance.mockResolvedValue(
tb([tbRow({ account_number: '3001', account_class: 3, closing_credit: 100 })]),
)
const report = await generateDimensionPnl(supabase, 'company-1', 'period-1', '1')
expect(report.dimension.name).toBe('Kostnadsställe')
// Code column without a registry name.
expect(report.columns[0]).toEqual({ code: 'KS01', name: null })
})
it('passes the caller date range to the trial balance (Totalt parity with resultatrapport)', async () => {
mockResults = {
fiscal_periods: [{ data: PERIOD, error: null }],
dimensions: [{ data: null, error: null }],
journal_entry_lines: [{ data: [], error: null }],
}
mockTrialBalance.mockResolvedValue(tb([]))
const report = await generateDimensionPnl(supabase, 'company-1', 'period-1', '6', {
toDate: '2026-06-30',
})
expect(mockTrialBalance).toHaveBeenCalledWith(supabase, 'company-1', 'period-1', {
closingEntry: 'exclude-all-year-end',
toDate: '2026-06-30',
})
// The label reflects actual coverage: cumulative from period_start.
expect(report.period).toEqual({ start: '2026-01-01', end: '2026-06-30' })
})
it('handles fully untagged periods: one residual column carrying the whole result', async () => {
mockResults = {
fiscal_periods: [{ data: PERIOD, error: null }],
dimensions: [{ data: { id: 'dim-6', sie_dim_no: 6, name: 'Projekt' }, error: null }],
dimension_values: [{ data: [], error: null }],
journal_entry_lines: [{ data: [], error: null }],
}
mockTrialBalance.mockResolvedValue(
tb([
tbRow({ account_number: '3001', account_class: 3, closing_credit: 1000 }),
tbRow({ account_number: '4010', account_name: 'Inköp', account_class: 4, closing_debit: 250 }),
]),
)
const report = await generateDimensionPnl(supabase, 'company-1', 'period-1', '6')
expect(report.columns).toEqual([{ code: null, name: null }])
expect(report.groups.find((g) => g.class === 3)?.rows[0].values).toEqual([1000])
expect(report.groups.find((g) => g.class === 4)?.rows[0].values).toEqual([-250])
expect(report.net_per_column).toEqual([750])
expect(report.net_total).toBe(750)
})
it('rejects a non-numeric dimension number (PostgREST path guard)', async () => {
await expect(
generateDimensionPnl(supabase, 'company-1', 'period-1', '6,is.null'),
).rejects.toThrow('positive SIE dimension number')
})
it('throws when the fiscal period does not exist', async () => {
mockResults = { fiscal_periods: [{ data: null, error: null }] }
await expect(generateDimensionPnl(supabase, 'company-1', 'missing', '6')).rejects.toThrow(
'Fiscal period not found',
)
})
})