sax3l/accounted
3
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c0ecf2fa3bebd46bdfd0169efd73b89653d1dfed
accounted/lib/reports/__tests__/sie-export.test.ts
T
Jakob Wennberg ddbe9b1379 fix(reports): always emit compulsory #FORMAT PC8 in SIE export (#1466) 
#FORMAT is a compulsory record in every SIE type and PC8 is its only
legal value. We only emitted it when the caller opted into cp437 byte
encoding, so the default UTF-8 download had no #FORMAT line and strict
importers (Visma Spiris) rejected the file with 'Etiketten #FORMAT
saknas i filen'. Cloud exporters (Fortnox, Bokio) ship UTF-8 bytes with
#FORMAT PC8 and importers detect the real encoding from the bytes, so
the tag is now unconditional.

Also formats #ORGNR as nnnnnn-nnnn per spec; company_settings stores
the org number without a hyphen.

Co-authored-by: Jakob Wennberg <311770904+jakobwennberg-oss@users.noreply.github.com>
Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
2026-08-08 15:04:07 +02:00

809 lines
35 KiB
TypeScript
Raw Blame History

import { describe, it, expect, vi, beforeEach } from 'vitest'
// ============================================================
// Mock: sequential result queue
// ============================================================
let resultIdx: number
let results: Array<{ data?: unknown; error?: unknown }>
// `.eq()` args recorded per table so tests can assert on query shape (e.g.
// that the dimension registry fetch does NOT filter is_active: the latent
// undeclared-#OBJEKT bug was exactly such a filter).
let eqCallsByTable: Record<string, Array<[string, unknown]>>
function makeBuilder(table: string) {
const b: Record<string, unknown> = {}
for (const m of ['select', 'in', 'order', 'range', 'lt', 'lte', 'gte', 'gt', 'limit', 'neq']) {
b[m] = vi.fn().mockReturnValue(b)
}
b.eq = vi.fn().mockImplementation((column: string, value: unknown) => {
;(eqCallsByTable[table] ??= []).push([column, value])
return b
})
b.single = vi.fn().mockImplementation(async () => results[resultIdx++] ?? { data: null, error: null })
b.then = (resolve: (v: unknown) => void) => resolve(results[resultIdx++] ?? { data: null, error: null })
return b
}
function makeClient() {
return {
from: vi.fn().mockImplementation((table: string) => makeBuilder(table)),
// `rpc` drains the same queue so tests can intersperse RPC + table fetches.
// SIE export calls `compute_prior_opening_balances` via getOpeningBalances
// whenever `opening_balance_entry_id` is null (the multi-year-import path).
rpc: vi.fn().mockImplementation(async () => results[resultIdx++] ?? { data: null, error: null }),
// eslint-disable-next-line @typescript-eslint/no-explicit-any
} as any
}
import { generateSIEExport } from '../sie-export'
let supabase: ReturnType<typeof makeClient>
beforeEach(() => {
vi.clearAllMocks()
resultIdx = 0
results = []
eqCallsByTable = {}
supabase = makeClient()
})
const baseOptions = {
fiscal_period_id: 'period-1',
company_name: 'Test AB',
org_number: '556677-8899',
program_name: 'ERPBase',
}
// Queue consumption order (dimensions registry replaced cost_centers/projects):
// 0: fiscal_periods.single()
// 1: previous fiscal period .single() (#RAR -1)
// 2: chart_of_accounts (fetchAllRows)
// 3: journal_entries (fetchAllRows)
// 4: journal_entry_lines (fetchLinesByEntryIds; SKIPPED when slot 3
// returned no entries, so empty-period tests queue nothing here)
// 5: dimensions (registry #DIM/#UNDERDIM rows)
// 6: dimension_values (registry #OBJEKT rows)
// 7: opening balances (RPC fallback, or the OB entry ownership check +
// its lines when opening_balance_entry_id is set: two slots)
// Registry fixtures for the system dims (seeded by ensure_company_dimensions).
const dimKostnadsstalle = { id: 'dim-1', sie_dim_no: 1, parent_sie_dim_no: null, name: 'Kostnadsställe' }
const dimProjekt = { id: 'dim-6', sie_dim_no: 6, parent_sie_dim_no: null, name: 'Projekt' }
describe('generateSIEExport', () => {
it('throws when fiscal period not found', async () => {
results = [
// 0: fiscal_periods.single() → null
{ data: null, error: null },
]
await expect(generateSIEExport(supabase, 'company-1', baseOptions))
.rejects.toThrow('Fiscal period not found')
})
it('generates correct header format', async () => {
results = [
{ data: { id: 'period-1', period_start: '2024-01-01', period_end: '2024-12-31' }, error: null },
{ data: null, error: null }, // prevPeriod
{ data: [], error: null }, // accounts
{ data: [], error: null }, // journal_entries (no entries -> line fetch skipped)
{ data: [], error: null }, // dimensions
{ data: [], error: null }, // dimension_values
{ data: [], error: null }, // opening balances RPC
]
const output = await generateSIEExport(supabase, 'company-1', baseOptions)
const lines = output.split('\r\n')
expect(lines[0]).toBe('#FLAGGA 0')
expect(lines[1]).toBe('#FORMAT PC8')
expect(lines[2]).toBe('#SIETYP 4')
expect(lines[3]).toMatch(/^#PROGRAM "ERPBase" "1\.0"$/)
expect(lines[4]).toMatch(/^#GEN \d{8}$/)
expect(lines[5]).toBe('#ORGNR 556677-8899')
expect(lines[6]).toBe('#FNAMN "Test AB"')
expect(lines[7]).toBe('#RAR 0 20240101 20241231')
})
it('hyphenates a bare 10-digit org_number in #ORGNR', async () => {
results = [
{ data: { id: 'period-1', period_start: '2024-01-01', period_end: '2024-12-31' }, error: null },
{ data: null, error: null }, // prevPeriod
{ data: [], error: null }, // accounts
{ data: [], error: null }, // journal_entries (no entries -> line fetch skipped)
{ data: [], error: null }, // dimensions
{ data: [], error: null }, // dimension_values
{ data: [], error: null }, // opening balances RPC
]
const output = await generateSIEExport(supabase, 'company-1', {
...baseOptions,
org_number: '5566778899',
})
expect(output).toContain('#ORGNR 556677-8899')
})
it('omits #ORGNR when org_number is null', async () => {
results = [
{ data: { id: 'period-1', period_start: '2024-01-01', period_end: '2024-12-31' }, error: null },
{ data: null, error: null }, // prevPeriod
{ data: [], error: null }, // accounts
{ data: [], error: null }, // journal_entries (no entries -> line fetch skipped)
{ data: [], error: null }, // dimensions
{ data: [], error: null }, // dimension_values
{ data: [], error: null }, // RPC fallback
]
const output = await generateSIEExport(supabase, 'company-1', {
...baseOptions,
org_number: null,
})
expect(output).not.toContain('#ORGNR')
})
it('generates #KONTO and #SRU for accounts', async () => {
results = [
{ data: { id: 'period-1', period_start: '2024-01-01', period_end: '2024-12-31' }, error: null },
{ data: null, error: null }, // prevPeriod
{
data: [
{ account_number: '1930', account_name: 'Företagskonto', sru_code: '7301', is_active: true },
{ account_number: '3001', account_name: 'Försäljning', sru_code: null, is_active: true },
],
error: null,
},
{ data: [], error: null }, // journal_entries (no entries -> line fetch skipped)
{ data: [], error: null }, // dimensions
{ data: [], error: null }, // dimension_values
{ data: [], error: null }, // RPC fallback
]
const output = await generateSIEExport(supabase, 'company-1', baseOptions)
expect(output).toContain('#KONTO 1930 "Företagskonto"')
expect(output).toContain('#SRU 1930 7301')
expect(output).toContain('#KONTO 3001 "Försäljning"')
// No SRU for 3001 since sru_code is null
expect(output).not.toContain('#SRU 3001')
})
it('generates #VER and #TRANS for journal entries', async () => {
results = [
{ data: { id: 'period-1', period_start: '2024-01-01', period_end: '2024-12-31' }, error: null },
{ data: null, error: null }, // prevPeriod
{ data: [], error: null }, // accounts
{
// journal_entries (no embedded lines: those come from the next slot)
data: [
{ id: 'e1', entry_date: '2024-03-15', voucher_number: 1, voucher_series: 'A', description: 'Sale invoice', status: 'posted' },
],
error: null,
},
{
// journal_entry_lines: each carries journal_entry_id for grouping
data: [
{ journal_entry_id: 'e1', account_number: '1510', debit_amount: 1250, credit_amount: 0, line_description: null, dimensions: {} },
{ journal_entry_id: 'e1', account_number: '3001', debit_amount: 0, credit_amount: 1000, line_description: 'Revenue', dimensions: {} },
{ journal_entry_id: 'e1', account_number: '2611', debit_amount: 0, credit_amount: 250, line_description: null, dimensions: {} },
],
error: null,
},
{ data: [], error: null }, // dimensions
{ data: [], error: null }, // dimension_values
{ data: [], error: null }, // RPC fallback
]
const output = await generateSIEExport(supabase, 'company-1', baseOptions)
expect(output).toContain('#VER "A" 1 20240315 "Sale invoice"')
expect(output).toContain('{')
expect(output).toContain('\t#TRANS 1510 {} 1250.00 20240315')
expect(output).toContain('\t#TRANS 3001 {} -1000.00 20240315 "Revenue"')
expect(output).toContain('\t#TRANS 2611 {} -250.00 20240315')
expect(output).toContain('}')
})
it('generates #DIM and #OBJEKT for registry dimensions', async () => {
results = [
{ data: { id: 'period-1', period_start: '2024-01-01', period_end: '2024-12-31' }, error: null },
{ data: null, error: null }, // prevPeriod
{ data: [], error: null }, // accounts
{ data: [], error: null }, // journal_entries (no entries -> line fetch skipped)
{ data: [dimKostnadsstalle, dimProjekt], error: null }, // dimensions
{
data: [
{ dimension_id: 'dim-1', code: 'CC1', name: 'Avdelning 1' },
{ dimension_id: 'dim-6', code: 'P001', name: 'Projekt Alpha' },
],
error: null,
},
{ data: [], error: null }, // RPC fallback
]
const output = await generateSIEExport(supabase, 'company-1', baseOptions)
expect(output).toContain('#DIM 1 "Kostnadsställe"')
expect(output).toContain('#DIM 6 "Projekt"')
expect(output).toContain('#OBJEKT 1 "CC1" "Avdelning 1"')
expect(output).toContain('#OBJEKT 6 "P001" "Projekt Alpha"')
})
it('includes dimension objects in #TRANS lines from the jsonb map', async () => {
results = [
{ data: { id: 'period-1', period_start: '2024-01-01', period_end: '2024-12-31' }, error: null },
{ data: null, error: null }, // prevPeriod
{ data: [], error: null }, // accounts
{
data: [
{ id: 'e1', entry_date: '2024-03-15', voucher_number: 1, voucher_series: 'A', description: 'With dimensions', status: 'posted' },
],
error: null,
},
{
data: [
{ journal_entry_id: 'e1', account_number: '5010', debit_amount: 8000, credit_amount: 0, line_description: null, dimensions: { '1': 'CC1', '6': 'P001' } },
{ journal_entry_id: 'e1', account_number: '1930', debit_amount: 0, credit_amount: 8000, line_description: null, dimensions: {} },
],
error: null,
},
{ data: [dimKostnadsstalle, dimProjekt], error: null }, // dimensions
{
data: [
{ dimension_id: 'dim-1', code: 'CC1', name: 'Avdelning 1' },
{ dimension_id: 'dim-6', code: 'P001', name: 'Projekt Alpha' },
],
error: null,
},
{ data: [], error: null }, // RPC fallback
]
const output = await generateSIEExport(supabase, 'company-1', baseOptions)
expect(output).toContain('\t#TRANS 5010 {1 "CC1" 6 "P001"} 8000.00 20240315')
expect(output).toContain('\t#TRANS 1930 {} -8000.00 20240315')
})
it('declares INACTIVE registry values as #OBJEKT (undeclared-object regression)', async () => {
// Latent bug in the legacy read path: the registry fetch filtered
// is_active=true, so a line referencing an archived code serialized into
// #TRANS while its #OBJEKT declaration was missing: Visma rejects such
// files. The registry fetch must NOT filter on is_active.
results = [
{ data: { id: 'period-1', period_start: '2024-01-01', period_end: '2024-12-31' }, error: null },
{ data: null, error: null }, // prevPeriod
{ data: [], error: null }, // accounts
{
data: [
{ id: 'e1', entry_date: '2024-05-02', voucher_number: 1, voucher_series: 'A', description: 'Archived code', status: 'posted' },
],
error: null,
},
{
data: [
{ journal_entry_id: 'e1', account_number: '5010', debit_amount: 500, credit_amount: 0, line_description: null, dimensions: { '1': 'CC9' } },
{ journal_entry_id: 'e1', account_number: '1930', debit_amount: 0, credit_amount: 500, line_description: null, dimensions: {} },
],
error: null,
},
{ data: [dimKostnadsstalle], error: null }, // dimensions
// The archived (is_active=false) value row IS returned by the query
// because the export must not filter it out.
{ data: [{ dimension_id: 'dim-1', code: 'CC9', name: 'Nedlagd avdelning', is_active: false }], error: null },
{ data: [], error: null }, // RPC fallback
]
const output = await generateSIEExport(supabase, 'company-1', baseOptions)
// Declared with its registry name (not synthesized code-as-name)
expect(output).toContain('#DIM 1 "Kostnadsställe"')
expect(output).toContain('#OBJEKT 1 "CC9" "Nedlagd avdelning"')
expect(output).toContain('\t#TRANS 5010 {1 "CC9"} 500.00 20240502')
// Query-shape guard: neither registry fetch may filter on is_active:
// that is the exact filter that caused the undeclared-#OBJEKT bug.
expect(eqCallsByTable['dimensions'] ?? []).not.toContainEqual(['is_active', true])
expect(eqCallsByTable['dimension_values'] ?? []).not.toContainEqual(['is_active', true])
})
it('synthesizes #DIM and #OBJEKT for orphan line codes with no registry rows', async () => {
// Free-text writers can still mint dimension numbers/codes until the
// write-path PR: every referenced (dimNo, code) pair must be declared,
// never silently dropped. Dim 6 resolves from the SIE reserved-number
// seed; dim 13 falls back to "Dimension n"; both codes get name = code.
results = [
{ data: { id: 'period-1', period_start: '2024-01-01', period_end: '2024-12-31' }, error: null },
{ data: null, error: null }, // prevPeriod
{ data: [], error: null }, // accounts
{
data: [
{ id: 'e1', entry_date: '2024-02-01', voucher_number: 1, voucher_series: 'A', description: 'Orphans', status: 'posted' },
],
error: null,
},
{
data: [
{ journal_entry_id: 'e1', account_number: '4010', debit_amount: 900, credit_amount: 0, line_description: null, dimensions: { '6': 'GHOST', '13': 'X1' } },
{ journal_entry_id: 'e1', account_number: '1930', debit_amount: 0, credit_amount: 900, line_description: null, dimensions: {} },
],
error: null,
},
{ data: [], error: null }, // dimensions: registry is empty
{ data: [], error: null }, // dimension_values
{ data: [], error: null }, // RPC fallback
]
const output = await generateSIEExport(supabase, 'company-1', baseOptions)
expect(output).toContain('#DIM 6 "Projekt"')
expect(output).toContain('#DIM 13 "Dimension 13"')
expect(output).toContain('#OBJEKT 6 "GHOST" "GHOST"')
expect(output).toContain('#OBJEKT 13 "X1" "X1"')
expect(output).toContain('\t#TRANS 4010 {6 "GHOST" 13 "X1"} 900.00 20240201')
})
it('serializes multi-dimension lines sorted by numeric dimension number', async () => {
results = [
{ data: { id: 'period-1', period_start: '2024-01-01', period_end: '2024-12-31' }, error: null },
{ data: null, error: null }, // prevPeriod
{ data: [], error: null }, // accounts
{
data: [
{ id: 'e1', entry_date: '2024-04-10', voucher_number: 1, voucher_series: 'A', description: 'Multi-dim', status: 'posted' },
],
error: null,
},
{
// Keys deliberately out of order: output must sort 1 < 6 < 7
data: [
{ journal_entry_id: 'e1', account_number: '7010', debit_amount: 30000, credit_amount: 0, line_description: null, dimensions: { '7': 'EMP1', '1': 'KS01', '6': 'P001' } },
{ journal_entry_id: 'e1', account_number: '1930', debit_amount: 0, credit_amount: 30000, line_description: null, dimensions: {} },
],
error: null,
},
{ data: [dimKostnadsstalle, dimProjekt], error: null }, // dimensions
{
data: [
{ dimension_id: 'dim-1', code: 'KS01', name: 'Kontoret' },
{ dimension_id: 'dim-6', code: 'P001', name: 'Projekt Alpha' },
],
error: null,
},
{ data: [], error: null }, // RPC fallback
]
const output = await generateSIEExport(supabase, 'company-1', baseOptions)
expect(output).toContain('\t#TRANS 7010 {1 "KS01" 6 "P001" 7 "EMP1"} 30000.00 20240410')
// Dim 7 has no registry row → synthesized from the SIE reserved seed,
// with the orphan employee code declared.
expect(output).toContain('#DIM 7 "Anställd"')
expect(output).toContain('#OBJEKT 7 "EMP1" "EMP1"')
})
it('emits #UNDERDIM for child dimensions and declares the parent', async () => {
results = [
{ data: { id: 'period-1', period_start: '2024-01-01', period_end: '2024-12-31' }, error: null },
{ data: null, error: null }, // prevPeriod
{ data: [], error: null }, // accounts
{ data: [], error: null }, // journal_entries (no entries -> line fetch skipped)
{
// Kostnadsbärare (2) is a sub-dimension of Kostnadsställe (1); the
// parent has NO values of its own: it must still be declared because
// an #UNDERDIM referencing an undeclared parent is invalid.
data: [
dimKostnadsstalle,
{ id: 'dim-2', sie_dim_no: 2, parent_sie_dim_no: 1, name: 'Kostnadsbärare' },
],
error: null,
},
{ data: [{ dimension_id: 'dim-2', code: 'KB1', name: 'Bärare 1' }], error: null },
{ data: [], error: null }, // RPC fallback
]
const output = await generateSIEExport(supabase, 'company-1', baseOptions)
expect(output).toContain('#DIM 1 "Kostnadsställe"')
expect(output).toContain('#UNDERDIM 2 "Kostnadsbärare" 1')
expect(output).toContain('#OBJEKT 2 "KB1" "Bärare 1"')
// The parent was pulled in as a declaration only, no #UNDERDIM for it
expect(output).not.toContain('#UNDERDIM 1')
})
it('declares a parent #DIM before an #UNDERDIM child with a LOWER number', async () => {
// SIE4 requires the parent to be declared before any #UNDERDIM that
// references it. A registry can hold a child whose sie_dim_no is LOWER
// than its parent's (dim 3 under dim 7 here), so a single numeric sort
// would emit the #UNDERDIM first: the two-pass emit (#DIM roots first,
// then #UNDERDIM) must keep the parent ahead.
results = [
{ data: { id: 'period-1', period_start: '2024-01-01', period_end: '2024-12-31' }, error: null },
{ data: null, error: null }, // prevPeriod
{ data: [], error: null }, // accounts
{
data: [
{ id: 'e1', entry_date: '2024-03-01', voucher_number: 1, voucher_series: 'A', description: 'Child below parent', status: 'posted' },
],
error: null,
},
{
data: [
{ journal_entry_id: 'e1', account_number: '5010', debit_amount: 700, credit_amount: 0, line_description: null, dimensions: { '3': 'UND1', '7': 'EMP1' } },
{ journal_entry_id: 'e1', account_number: '1930', debit_amount: 0, credit_amount: 700, line_description: null, dimensions: {} },
],
error: null,
},
{
// dim 3 is a child of dim 7, numerically BEFORE its parent.
data: [
{ id: 'dim-3', sie_dim_no: 3, parent_sie_dim_no: 7, name: 'Underavdelning' },
{ id: 'dim-7', sie_dim_no: 7, parent_sie_dim_no: null, name: 'Anställd' },
],
error: null,
},
{
data: [
{ dimension_id: 'dim-3', code: 'UND1', name: 'Under 1' },
{ dimension_id: 'dim-7', code: 'EMP1', name: 'Anna' },
],
error: null,
},
{ data: [], error: null }, // RPC fallback
]
const output = await generateSIEExport(supabase, 'company-1', baseOptions)
expect(output).toContain('#DIM 7 "Anställd"')
expect(output).toContain('#UNDERDIM 3 "Underavdelning" 7')
// The parent #DIM must precede the child #UNDERDIM in the file.
expect(output.indexOf('#DIM 7 "Anställd"')).toBeLessThan(
output.indexOf('#UNDERDIM 3 "Underavdelning" 7'),
)
})
it('generates #UB for class 1-2 and #RES for class 3-8', async () => {
results = [
{ data: { id: 'period-1', period_start: '2024-01-01', period_end: '2024-12-31' }, error: null },
{ data: null, error: null }, // prevPeriod
{ data: [], error: null }, // accounts
{
data: [
{ id: 'e1', entry_date: '2024-01-15', voucher_number: 1, voucher_series: 'A', description: 'Sale', status: 'posted' },
],
error: null,
},
{
data: [
{ journal_entry_id: 'e1', account_number: '1510', debit_amount: 1250, credit_amount: 0, line_description: null, dimensions: {} },
{ journal_entry_id: 'e1', account_number: '3001', debit_amount: 0, credit_amount: 1000, line_description: null, dimensions: {} },
{ journal_entry_id: 'e1', account_number: '2611', debit_amount: 0, credit_amount: 250, line_description: null, dimensions: {} },
],
error: null,
},
{ data: [], error: null }, // dimensions
{ data: [], error: null }, // dimension_values
{ data: [], error: null }, // RPC fallback
]
const output = await generateSIEExport(supabase, 'company-1', baseOptions)
// Account 1510 (class 1) → #UB, balance = 1250 - 0 = 1250
expect(output).toContain('#UB 0 1510 1250.00')
// Account 2611 (class 2) → #UB, balance = 0 - 250 = -250
expect(output).toContain('#UB 0 2611 -250.00')
// Account 3001 (class 3) → #RES, balance = 0 - 1000 = -1000
expect(output).toContain('#RES 0 3001 -1000.00')
})
it('escapes quotes in descriptions', async () => {
results = [
{ data: { id: 'period-1', period_start: '2024-01-01', period_end: '2024-12-31' }, error: null },
{ data: null, error: null }, // prevPeriod
{ data: [], error: null }, // accounts
{
data: [
{ id: 'e1', entry_date: '2024-01-15', voucher_number: 1, voucher_series: 'A', description: 'Invoice for "consulting"', status: 'posted' },
],
error: null,
},
{
data: [
{ journal_entry_id: 'e1', account_number: '1930', debit_amount: 100, credit_amount: 0, line_description: null, dimensions: {} },
{ journal_entry_id: 'e1', account_number: '3001', debit_amount: 0, credit_amount: 100, line_description: null, dimensions: {} },
],
error: null,
},
{ data: [], error: null }, // dimensions
{ data: [], error: null }, // dimension_values
{ data: [], error: null }, // RPC fallback
]
const output = await generateSIEExport(supabase, 'company-1', baseOptions)
expect(output).toContain('#VER "A" 1 20240115 "Invoice for \\"consulting\\""')
})
it('uses \\r\\n line endings', async () => {
results = [
{ data: { id: 'period-1', period_start: '2024-01-01', period_end: '2024-12-31' }, error: null },
{ data: null, error: null }, // prevPeriod
{ data: [], error: null }, // accounts
{ data: [], error: null }, // journal_entries (no entries -> line fetch skipped)
{ data: [], error: null }, // dimensions
{ data: [], error: null }, // dimension_values
{ data: [], error: null }, // RPC fallback
]
const output = await generateSIEExport(supabase, 'company-1', baseOptions)
// Every line should end with \r\n
expect(output).toContain('\r\n')
// Should not have bare \n (that isn't preceded by \r)
const lines = output.split('\r\n')
for (const line of lines.slice(0, -1)) {
expect(line).not.toContain('\n')
}
// File should end with \r\n
expect(output.endsWith('\r\n')).toBe(true)
})
it('produces no #VER lines when no entries exist', async () => {
results = [
{ data: { id: 'period-1', period_start: '2024-01-01', period_end: '2024-12-31' }, error: null },
{ data: null, error: null }, // prevPeriod
{ data: [], error: null }, // accounts
{ data: [], error: null }, // journal_entries (no entries -> line fetch skipped)
{ data: [], error: null }, // dimensions
{ data: [], error: null }, // dimension_values
{ data: [], error: null }, // RPC fallback
]
const output = await generateSIEExport(supabase, 'company-1', baseOptions)
expect(output).not.toContain('#VER')
expect(output).not.toContain('#TRANS')
})
it('produces no #DIM lines when no dimensions exist', async () => {
results = [
{ data: { id: 'period-1', period_start: '2024-01-01', period_end: '2024-12-31' }, error: null },
{ data: null, error: null }, // prevPeriod
{ data: [], error: null }, // accounts
{ data: [], error: null }, // journal_entries (no entries -> line fetch skipped)
{ data: [], error: null }, // dimensions
{ data: [], error: null }, // dimension_values
{ data: [], error: null }, // RPC fallback
]
const output = await generateSIEExport(supabase, 'company-1', baseOptions)
expect(output).not.toContain('#DIM')
expect(output).not.toContain('#OBJEKT')
})
it('keeps seeded-but-unused system dimensions silent (no #DIM without values or tagged lines)', async () => {
// ensure_company_dimensions lazily seeds dims 1/6 for any company that
// touches the dimensions UI: a company that merely visited the register
// page must still get a dimension-free file.
results = [
{ data: { id: 'period-1', period_start: '2024-01-01', period_end: '2024-12-31' }, error: null },
{ data: null, error: null }, // prevPeriod
{ data: [], error: null }, // accounts
{ data: [], error: null }, // journal_entries (no entries -> line fetch skipped)
{ data: [dimKostnadsstalle, dimProjekt], error: null }, // dimensions: seeded, valueless
{ data: [], error: null }, // dimension_values
{ data: [], error: null }, // RPC fallback
]
const output = await generateSIEExport(supabase, 'company-1', baseOptions)
expect(output).not.toContain('#DIM')
expect(output).not.toContain('#OBJEKT')
})
it('does not truncate large periods: every voucher and its lines are exported', async () => {
// Regression test for the user-reported bug: the previous nested
// `select('*, lines:journal_entry_lines(*)')` query hit PostgREST's
// embedded-resource row ceiling and silently truncated to ~30 vouchers.
// The pagination fix fetches entries and lines as separate paginated
// queries, so a period far larger than any single page round-trips fully.
const ENTRY_COUNT = 2500 // well past the 1000-row PostgREST page size
const entries = Array.from({ length: ENTRY_COUNT }, (_, i) => ({
id: `e${i + 1}`,
entry_date: '2024-06-01',
voucher_number: i + 1,
voucher_series: 'A',
description: `Voucher ${i + 1}`,
status: 'posted',
}))
const lines = entries.flatMap((e, i) => [
{ id: `l${i * 2 + 1}`, journal_entry_id: e.id, account_number: '1510', debit_amount: 100, credit_amount: 0, line_description: null, dimensions: {} },
{ id: `l${i * 2 + 2}`, journal_entry_id: e.id, account_number: '3001', debit_amount: 0, credit_amount: 100, line_description: null, dimensions: {} },
])
// fetchAllRows paginates at PAGE_SIZE = 1000; chunk the mock data so the
// queue mimics real multi-page round-trips and the loop stops on a short page.
function paginate<T>(rows: T[]): Array<{ data: T[]; error: null }> {
const PAGE = 1000
const pages: Array<{ data: T[]; error: null }> = []
for (let i = 0; i < rows.length; i += PAGE) {
pages.push({ data: rows.slice(i, i + PAGE), error: null })
}
// Ensure a final short page so fetchAllRows terminates when the data is
// an exact multiple of PAGE_SIZE.
if (rows.length % PAGE === 0) pages.push({ data: [], error: null })
return pages
}
results = [
{ data: { id: 'period-1', period_start: '2024-01-01', period_end: '2024-12-31' }, error: null },
{ data: null, error: null }, // prevPeriod
{ data: [], error: null }, // accounts
...paginate(entries), // journal_entries: 3 pages (1000 + 1000 + 500)
...paginate(lines), // journal_entry_lines: 5000 rows → 5 pages
{ data: [], error: null }, // dimensions
{ data: [], error: null }, // dimension_values
{ data: [], error: null }, // RPC fallback
]
const output = await generateSIEExport(supabase, 'company-1', baseOptions)
// Every voucher present: including the first, last, and a middle one
// that the old ~30-row cap would have dropped.
const verCount = (output.match(/#VER /g) || []).length
expect(verCount).toBe(ENTRY_COUNT)
expect(output).toContain('#VER "A" 1 20240601 "Voucher 1"')
expect(output).toContain(`#VER "A" 1500 20240601 "Voucher 1500"`)
expect(output).toContain(`#VER "A" ${ENTRY_COUNT} 20240601 "Voucher ${ENTRY_COUNT}"`)
// Lines were stitched onto their entries (two #TRANS per voucher)
const transCount = (output.match(/#TRANS /g) || []).length
expect(transCount).toBe(ENTRY_COUNT * 2)
})
it('emits #IB from compute_prior_opening_balances RPC fallback when opening_balance_entry_id is null', async () => {
// Reproduces the user-reported bug: after a multi-year SIE import the
// continuation-import guard intentionally leaves opening_balance_entry_id
// NULL, and previously the SIE export silently produced zero #IB records,
// collapsing #UB to current-period movements only. The fix wires SIE
// export to getOpeningBalances() so the RPC backs up the missing link.
results = [
// period: note: no opening_balance_entry_id, so getOpeningBalances
// falls through to the RPC path
{ data: { id: 'period-1', period_start: '2024-01-01', period_end: '2024-12-31', opening_balance_entry_id: null }, error: null },
{ data: null, error: null }, // prevPeriod
{ data: [], error: null }, // accounts
{ data: [], error: null }, // journal_entries (no movements -> line fetch skipped)
{ data: [], error: null }, // dimensions
{ data: [], error: null }, // dimension_values
// RPC fallback returns prior IBs derived from historical journal lines
{
data: [
{ account_number: '1930', debit: 50000, credit: 0 },
{ account_number: '2440', debit: 0, credit: 50000 },
],
error: null,
},
]
const output = await generateSIEExport(supabase, 'company-1', baseOptions)
expect(output).toContain('#IB 0 1930 50000.00')
expect(output).toContain('#IB 0 2440 -50000.00')
// UB = IB + period movements (zero this period), so #UB mirrors #IB
expect(output).toContain('#UB 0 1930 50000.00')
expect(output).toContain('#UB 0 2440 -50000.00')
})
it('reads #IB from explicit opening_balance_entry_id when set', async () => {
// When opening_balance_entry_id is set, getOpeningBalances uses the
// two-step entry-lines path (entry ownership check, then its lines)
// instead of the RPC, so the queue serves those rows rather than RPC rows.
results = [
{ data: { id: 'period-1', period_start: '2024-01-01', period_end: '2024-12-31', opening_balance_entry_id: 'ob-entry-1' }, error: null },
{ data: null, error: null }, // prevPeriod
{ data: [], error: null }, // accounts
{ data: [], error: null }, // journal_entries (no entries -> line fetch skipped)
{ data: [], error: null }, // dimensions
{ data: [], error: null }, // dimension_values
// getOpeningBalances step 1: the OB entry itself (ownership check)
{ data: [{ id: 'ob-entry-1' }], error: null },
// getOpeningBalances step 2: the explicit OB entry lines
{
data: [
{ account_number: '1930', debit_amount: 12000, credit_amount: 0 },
{ account_number: '2440', debit_amount: 0, credit_amount: 12000 },
],
error: null,
},
]
const output = await generateSIEExport(supabase, 'company-1', baseOptions)
expect(output).toContain('#IB 0 1930 12000.00')
expect(output).toContain('#IB 0 2440 -12000.00')
expect(output).toContain('#UB 0 1930 12000.00')
expect(output).toContain('#UB 0 2440 -12000.00')
})
it('excludes the OB entry from #VER output and #UB movement so a zeroed-out account gets #UB 0', async () => {
// Regression: the OB entry was included in both getOpeningBalances (#IB)
// and calculateBalances (movement), so its debit cancelled the real net
// movement and left #UB = #IB for any account zeroed out during the year.
//
// Setup: 1933 opens at 96 466,59 (IB), is swept to 0 via a transfer to
// 1930 during the year. The OB entry (id: 'ob-entry-1') is returned by
// the journal_entries query because it lives in the same fiscal period.
results = [
{ data: { id: 'period-1', period_start: '2024-01-01', period_end: '2024-12-31', opening_balance_entry_id: 'ob-entry-1' }, error: null },
{ data: null, error: null }, // prevPeriod
{ data: [], error: null }, // accounts
{
// journal_entries (fetchAllRows): no embedded lines; stitched below
data: [
// The OB entry itself: must be excluded from movement/VER output
{
id: 'ob-entry-1',
entry_date: '2024-01-01',
voucher_number: 1,
voucher_series: 'A',
description: 'IB 2024',
status: 'posted',
},
// A real transaction: account 1933 swept to 1930
{
id: 'e2',
entry_date: '2024-08-07',
voucher_number: 2,
voucher_series: 'A',
description: 'Stängning Bokio',
status: 'posted',
},
],
error: null,
},
// journal_entry_lines (allLines): fetched by entry id via
// fetchLinesByEntryIds; lines map back to entries by journal_entry_id.
// The OB entry's lines (excluded from movement via obEntryId) and the
// real transfer's lines both flow through here.
{
data: [
{ id: 'l1', journal_entry_id: 'ob-entry-1', account_number: '1933', debit_amount: 96466.59, credit_amount: 0, line_description: 'IB 1933', dimensions: {} },
{ id: 'l2', journal_entry_id: 'ob-entry-1', account_number: '2019', debit_amount: 0, credit_amount: 96466.59, line_description: null, dimensions: {} },
{ id: 'l3', journal_entry_id: 'e2', account_number: '1930', debit_amount: 96466.59, credit_amount: 0, line_description: null, dimensions: {} },
{ id: 'l4', journal_entry_id: 'e2', account_number: '1933', debit_amount: 0, credit_amount: 96466.59, line_description: null, dimensions: {} },
],
error: null,
},
{ data: [], error: null }, // dimensions
{ data: [], error: null }, // dimension_values
// getOpeningBalances step 1: the OB entry itself (ownership check)
{ data: [{ id: 'ob-entry-1' }], error: null },
// getOpeningBalances step 2: the explicit OB entry lines
{
data: [
{ account_number: '1933', debit_amount: 96466.59, credit_amount: 0 },
{ account_number: '2019', debit_amount: 0, credit_amount: 96466.59 },
],
error: null,
},
]
const output = await generateSIEExport(supabase, 'company-1', baseOptions)
// IB recorded correctly
expect(output).toContain('#IB 0 1933 96466.59')
// 1933 was zeroed out: UB must be 0, not a repeat of IB
expect(output).toContain('#UB 0 1933 0.00')
// 1930 received the sweep: UB = 0 + 96466.59
expect(output).toContain('#UB 0 1930 96466.59')
// OB entry must NOT appear as a #VER block
expect(output).not.toContain('"IB 2024"')
// The real transfer entry must appear
expect(output).toContain('"Stängning Bokio"')
})
})
Reference in New Issue View Git Blame Copy Permalink