MattssonandClaude Opus 4.7
8ed943198f
The enforce_period_start_day trigger and its sie-import pre-validation rejected any non-first-of-month period_start whenever *any other* fiscal period existed for the company. That blocked a real user flow: after onboarding creates a default period (e.g. current year, day 1), importing an SIE for an older förlängt första räkenskapsår (e.g. 2017-07-28 – 2018-12-31) failed with "Non-first fiscal period must start on the 1st of a month". Per BFL 3 kap., the chronologically first fiscal year is the one that may be 6–18 months and start mid-month — which is a property of *when* the period starts relative to others, not of insert order. The trigger and pre-validation now allow mid-month start iff no existing period starts earlier. Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
445 lines
14 KiB
TypeScript
445 lines
14 KiB
TypeScript
import { describe, it, expect } from 'vitest'
|
||
import {
|
||
generateImportPreview,
|
||
validateIBBalance,
|
||
isBalanceSheetAccount,
|
||
ensureFiscalPeriod,
|
||
} from '../sie-import'
|
||
import { createQueuedMockSupabase } from '@/tests/helpers'
|
||
import type { ParsedSIEFile, AccountMapping } from '../types'
|
||
|
||
// --- Helpers ---
|
||
|
||
function makeParsedFile(overrides?: Partial<ParsedSIEFile>): ParsedSIEFile {
|
||
return {
|
||
header: {
|
||
sieType: 4,
|
||
flagga: 0,
|
||
program: 'TestProg',
|
||
programVersion: '1.0',
|
||
generatedDate: '2024-01-01',
|
||
format: 'PC8',
|
||
companyName: 'Test AB',
|
||
orgNumber: '5566778899',
|
||
address: null,
|
||
fiscalYears: [{ yearIndex: 0, start: '2024-01-01', end: '2024-12-31' }],
|
||
currency: 'SEK',
|
||
kontoPlanType: null,
|
||
},
|
||
accounts: [
|
||
{ number: '1510', name: 'Kundfordringar' },
|
||
{ number: '1930', name: 'Företagskonto' },
|
||
{ number: '2440', name: 'Leverantörsskulder' },
|
||
],
|
||
openingBalances: [
|
||
{ yearIndex: 0, account: '1510', amount: 50000 },
|
||
{ yearIndex: 0, account: '1930', amount: 100000 },
|
||
{ yearIndex: 0, account: '2440', amount: -150000 },
|
||
],
|
||
closingBalances: [],
|
||
resultBalances: [],
|
||
vouchers: [
|
||
{
|
||
series: 'A',
|
||
number: 1,
|
||
date: new Date(2024, 0, 15),
|
||
description: 'Faktura 1001',
|
||
lines: [
|
||
{ account: '1510', amount: 12500 },
|
||
{ account: '3001', amount: -10000 },
|
||
{ account: '2611', amount: -2500 },
|
||
],
|
||
},
|
||
],
|
||
issues: [],
|
||
stats: {
|
||
totalAccounts: 3,
|
||
totalVouchers: 1,
|
||
totalTransactionLines: 3,
|
||
fiscalYearStart: '2024-01-01',
|
||
fiscalYearEnd: '2024-12-31',
|
||
},
|
||
...overrides,
|
||
}
|
||
}
|
||
|
||
function makeMapping(source: string, target: string, confidence: number = 1.0): AccountMapping {
|
||
return {
|
||
sourceAccount: source,
|
||
sourceName: `Account ${source}`,
|
||
targetAccount: target,
|
||
targetName: `Target ${target}`,
|
||
confidence,
|
||
matchType: target ? 'exact' : 'manual',
|
||
isOverride: false,
|
||
}
|
||
}
|
||
|
||
// --- Tests ---
|
||
|
||
describe('generateImportPreview', () => {
|
||
describe('trial balance from IB', () => {
|
||
it('calculates debit totals from positive IB amounts', () => {
|
||
const parsed = makeParsedFile()
|
||
const mappings = [
|
||
makeMapping('1510', '1510'),
|
||
makeMapping('1930', '1930'),
|
||
makeMapping('2440', '2440'),
|
||
]
|
||
const preview = generateImportPreview(parsed, mappings)
|
||
|
||
// Positive amounts: 50000 + 100000 = 150000
|
||
expect(preview.trialBalance.totalDebit).toBe(150000)
|
||
})
|
||
|
||
it('calculates credit totals from negative IB amounts', () => {
|
||
const parsed = makeParsedFile()
|
||
const mappings = [
|
||
makeMapping('1510', '1510'),
|
||
makeMapping('1930', '1930'),
|
||
makeMapping('2440', '2440'),
|
||
]
|
||
const preview = generateImportPreview(parsed, mappings)
|
||
|
||
// Negative amounts: |-150000| = 150000
|
||
expect(preview.trialBalance.totalCredit).toBe(150000)
|
||
})
|
||
|
||
it('detects balanced trial balance', () => {
|
||
const parsed = makeParsedFile()
|
||
const mappings = [makeMapping('1510', '1510')]
|
||
const preview = generateImportPreview(parsed, mappings)
|
||
|
||
// 150000 debit = 150000 credit
|
||
expect(preview.trialBalance.isBalanced).toBe(true)
|
||
})
|
||
|
||
it('detects unbalanced trial balance', () => {
|
||
const parsed = makeParsedFile({
|
||
openingBalances: [
|
||
{ yearIndex: 0, account: '1510', amount: 50000 },
|
||
{ yearIndex: 0, account: '1930', amount: 100000 },
|
||
// Missing credit side — only 150000 debit, 0 credit
|
||
],
|
||
})
|
||
const mappings = [makeMapping('1510', '1510')]
|
||
const preview = generateImportPreview(parsed, mappings)
|
||
|
||
expect(preview.trialBalance.isBalanced).toBe(false)
|
||
})
|
||
|
||
it('handles zero opening balances', () => {
|
||
const parsed = makeParsedFile({ openingBalances: [] })
|
||
const mappings: AccountMapping[] = []
|
||
const preview = generateImportPreview(parsed, mappings)
|
||
|
||
expect(preview.trialBalance.totalDebit).toBe(0)
|
||
expect(preview.trialBalance.totalCredit).toBe(0)
|
||
expect(preview.trialBalance.isBalanced).toBe(true)
|
||
})
|
||
})
|
||
|
||
describe('company info passthrough', () => {
|
||
it('passes company name', () => {
|
||
const parsed = makeParsedFile()
|
||
const preview = generateImportPreview(parsed, [])
|
||
expect(preview.companyName).toBe('Test AB')
|
||
})
|
||
|
||
it('passes org number', () => {
|
||
const parsed = makeParsedFile()
|
||
const preview = generateImportPreview(parsed, [])
|
||
expect(preview.orgNumber).toBe('5566778899')
|
||
})
|
||
|
||
it('handles null company info', () => {
|
||
const parsed = makeParsedFile({
|
||
header: {
|
||
...makeParsedFile().header,
|
||
companyName: null,
|
||
orgNumber: null,
|
||
},
|
||
})
|
||
const preview = generateImportPreview(parsed, [])
|
||
expect(preview.companyName).toBeNull()
|
||
expect(preview.orgNumber).toBeNull()
|
||
})
|
||
})
|
||
|
||
describe('mapping status', () => {
|
||
it('reflects mapper output counts', () => {
|
||
const parsed = makeParsedFile()
|
||
const mappings = [
|
||
makeMapping('1510', '1510'), // mapped
|
||
makeMapping('1930', '1930'), // mapped
|
||
makeMapping('2440', '', 0), // unmapped
|
||
]
|
||
const preview = generateImportPreview(parsed, mappings)
|
||
|
||
expect(preview.mappingStatus.total).toBe(3)
|
||
expect(preview.mappingStatus.mapped).toBe(2)
|
||
expect(preview.mappingStatus.unmapped).toBe(1)
|
||
})
|
||
|
||
it('reports low confidence mappings', () => {
|
||
const mappings = [
|
||
makeMapping('1510', '1510', 1.0),
|
||
makeMapping('3400', '3001', 0.3), // low confidence
|
||
]
|
||
const parsed = makeParsedFile()
|
||
const preview = generateImportPreview(parsed, mappings)
|
||
|
||
expect(preview.mappingStatus.lowConfidence).toBe(1)
|
||
})
|
||
})
|
||
|
||
describe('statistics', () => {
|
||
it('passes account count', () => {
|
||
const parsed = makeParsedFile()
|
||
const preview = generateImportPreview(parsed, [])
|
||
expect(preview.accountCount).toBe(3)
|
||
})
|
||
|
||
it('passes voucher count', () => {
|
||
const parsed = makeParsedFile()
|
||
const preview = generateImportPreview(parsed, [])
|
||
expect(preview.voucherCount).toBe(1)
|
||
})
|
||
|
||
it('passes transaction line count', () => {
|
||
const parsed = makeParsedFile()
|
||
const preview = generateImportPreview(parsed, [])
|
||
expect(preview.transactionLineCount).toBe(3)
|
||
})
|
||
})
|
||
|
||
describe('issues passthrough', () => {
|
||
it('passes parse issues to preview', () => {
|
||
const parsed = makeParsedFile({
|
||
issues: [
|
||
{ severity: 'warning', line: 5, message: 'Okänd tagg: #FOO — ignoreras', tag: 'FOO' },
|
||
{ severity: 'error', line: 10, message: 'Invalid voucher', tag: 'VER' },
|
||
],
|
||
})
|
||
const preview = generateImportPreview(parsed, [])
|
||
|
||
expect(preview.issues).toHaveLength(2)
|
||
expect(preview.issues[0].severity).toBe('warning')
|
||
expect(preview.issues[1].severity).toBe('error')
|
||
})
|
||
})
|
||
})
|
||
|
||
describe('validateIBBalance', () => {
|
||
it('returns 0 roundingAdjustment when IB is balanced', () => {
|
||
const parsed = makeParsedFile({
|
||
openingBalances: [
|
||
{ yearIndex: 0, account: '1510', amount: 50000 },
|
||
{ yearIndex: 0, account: '2440', amount: -50000 },
|
||
],
|
||
})
|
||
const accountMap = new Map([['1510', '1510'], ['2440', '2440']])
|
||
const result = validateIBBalance(parsed, accountMap)
|
||
|
||
expect(result.roundingAdjustment).toBe(0)
|
||
expect(result.fileImbalance).toBe(0)
|
||
expect(result.excludedAccountsTotal).toBe(0)
|
||
expect(result.lines).toHaveLength(2)
|
||
})
|
||
|
||
it('returns rounding adjustment for imbalance <= 1 SEK', () => {
|
||
const parsed = makeParsedFile({
|
||
openingBalances: [
|
||
{ yearIndex: 0, account: '1510', amount: 50000.50 },
|
||
{ yearIndex: 0, account: '2440', amount: -50000 },
|
||
],
|
||
})
|
||
const accountMap = new Map([['1510', '1510'], ['2440', '2440']])
|
||
const result = validateIBBalance(parsed, accountMap)
|
||
|
||
expect(result.roundingAdjustment).toBe(0.5)
|
||
expect(result.fileImbalance).toBe(0.5)
|
||
})
|
||
|
||
it('returns large adjustment for file-level imbalance (unallocated årets resultat)', () => {
|
||
// Simulates a Fortnox export where previous year result hasn't been allocated
|
||
// to equity — BS accounts don't balance because årets resultat is implicit
|
||
const parsed = makeParsedFile({
|
||
openingBalances: [
|
||
{ yearIndex: 0, account: '1510', amount: 50100 },
|
||
{ yearIndex: 0, account: '2440', amount: -50000 },
|
||
],
|
||
})
|
||
const accountMap = new Map([['1510', '1510'], ['2440', '2440']])
|
||
const result = validateIBBalance(parsed, accountMap)
|
||
|
||
// The adjustment is 100 SEK — caller should book to 2099, never reject
|
||
expect(result.roundingAdjustment).toBe(100)
|
||
expect(result.fileImbalance).toBe(100)
|
||
expect(result.excludedAccountsTotal).toBe(0)
|
||
})
|
||
|
||
it('tracks excluded accounts separately from file imbalance (Fortnox system accounts)', () => {
|
||
// Simulates Fortnox 0099 carrying IB balance — file is balanced,
|
||
// but mapped accounts are not because 0099 is excluded from mapping
|
||
const parsed = makeParsedFile({
|
||
openingBalances: [
|
||
{ yearIndex: 0, account: '1510', amount: 50000 },
|
||
{ yearIndex: 0, account: '2440', amount: -150000 },
|
||
{ yearIndex: 0, account: '0099', amount: 100000 }, // System account, not mapped
|
||
],
|
||
})
|
||
const accountMap = new Map([['1510', '1510'], ['2440', '2440']])
|
||
const result = validateIBBalance(parsed, accountMap)
|
||
|
||
// File-level: 50000 + (-150000) + 100000 = 0, balanced
|
||
expect(result.fileImbalance).toBe(0)
|
||
// Mapped-level: 50000 debit, 150000 credit = -100000 diff
|
||
expect(result.roundingAdjustment).toBe(-100000)
|
||
// The excluded 0099 accounts for the entire difference
|
||
expect(result.excludedAccountsTotal).toBe(100000)
|
||
// Only 2 lines (0099 excluded)
|
||
expect(result.lines).toHaveLength(2)
|
||
})
|
||
|
||
it('ignores non-current-year balances', () => {
|
||
const parsed = makeParsedFile({
|
||
openingBalances: [
|
||
{ yearIndex: 0, account: '1510', amount: 50000 },
|
||
{ yearIndex: 0, account: '2440', amount: -50000 },
|
||
{ yearIndex: -1, account: '1510', amount: 99999 }, // Previous year — ignored
|
||
],
|
||
})
|
||
const accountMap = new Map([['1510', '1510'], ['2440', '2440']])
|
||
const result = validateIBBalance(parsed, accountMap)
|
||
|
||
expect(result.roundingAdjustment).toBe(0)
|
||
expect(result.lines).toHaveLength(2)
|
||
})
|
||
})
|
||
|
||
describe('ensureFiscalPeriod validation', () => {
|
||
// Mirrors the `enforce_period_start_day` DB trigger so users get an
|
||
// actionable Swedish error instead of a raw Postgres message.
|
||
type Supabase = Parameters<typeof ensureFiscalPeriod>[0]
|
||
|
||
it('rejects mid-month start when an earlier period already exists', async () => {
|
||
const { supabase, enqueueMany } = createQueuedMockSupabase()
|
||
enqueueMany([
|
||
{ data: null, error: null }, // containing check — no match
|
||
{ data: [], error: null }, // overlapping check — none
|
||
{ data: [{ id: 'earlier' }], error: null }, // earlier period exists
|
||
])
|
||
|
||
await expect(
|
||
ensureFiscalPeriod(
|
||
supabase as unknown as Supabase,
|
||
'company-id',
|
||
'2026-04-16',
|
||
'2026-12-31',
|
||
),
|
||
).rejects.toThrow(/kronologiskt första räkenskapsår får börja mitt i månaden/)
|
||
})
|
||
|
||
it('rejects end date that is not the last day of the month', async () => {
|
||
const { supabase, enqueueMany } = createQueuedMockSupabase()
|
||
enqueueMany([
|
||
{ data: null, error: null },
|
||
{ data: [], error: null },
|
||
{ data: [], error: null }, // no earlier period
|
||
])
|
||
|
||
await expect(
|
||
ensureFiscalPeriod(
|
||
supabase as unknown as Supabase,
|
||
'company-id',
|
||
'2026-01-01',
|
||
'2026-12-30', // not the last day of December
|
||
),
|
||
).rejects.toThrow(/måste sluta på månadens sista dag/)
|
||
})
|
||
|
||
it('allows mid-month start for the company first fiscal period', async () => {
|
||
const { supabase, enqueueMany } = createQueuedMockSupabase()
|
||
enqueueMany([
|
||
{ data: null, error: null },
|
||
{ data: [], error: null },
|
||
{ data: [], error: null }, // no earlier period
|
||
{ data: { id: 'new-period-id' }, error: null }, // insert result
|
||
])
|
||
|
||
const id = await ensureFiscalPeriod(
|
||
supabase as unknown as Supabase,
|
||
'company-id',
|
||
'2026-04-16',
|
||
'2026-12-31',
|
||
)
|
||
|
||
expect(id).toBe('new-period-id')
|
||
})
|
||
|
||
it('allows mid-month start when importing a retroactive earliest period', async () => {
|
||
// Scenario: onboarding created a 2026 fiscal period, user now imports
|
||
// an SIE for their förlängt första räkenskapsår 2017-07-28 – 2018-12-31.
|
||
// The 2017 period is chronologically earliest, so mid-month start is
|
||
// legal under BFL 3 kap.
|
||
const { supabase, enqueueMany } = createQueuedMockSupabase()
|
||
enqueueMany([
|
||
{ data: null, error: null }, // containing check — no match
|
||
{ data: [], error: null }, // overlapping check — none (2017 vs 2026)
|
||
{ data: [], error: null }, // no earlier period than 2017-07-28
|
||
{ data: { id: 'retro-first-year-id' }, error: null }, // insert
|
||
])
|
||
|
||
const id = await ensureFiscalPeriod(
|
||
supabase as unknown as Supabase,
|
||
'company-id',
|
||
'2017-07-28',
|
||
'2018-12-31',
|
||
)
|
||
|
||
expect(id).toBe('retro-first-year-id')
|
||
})
|
||
|
||
it('reuses an existing period that contains the range (no validation needed)', async () => {
|
||
const { supabase, enqueueMany } = createQueuedMockSupabase()
|
||
enqueueMany([
|
||
{ data: { id: 'existing-period-id' }, error: null }, // containing match
|
||
])
|
||
|
||
const id = await ensureFiscalPeriod(
|
||
supabase as unknown as Supabase,
|
||
'company-id',
|
||
'2026-04-16',
|
||
'2026-12-31',
|
||
)
|
||
|
||
expect(id).toBe('existing-period-id')
|
||
})
|
||
})
|
||
|
||
describe('isBalanceSheetAccount', () => {
|
||
it('returns true for class 1 (assets)', () => {
|
||
expect(isBalanceSheetAccount('1510')).toBe(true)
|
||
expect(isBalanceSheetAccount('1930')).toBe(true)
|
||
})
|
||
|
||
it('returns true for class 2 (liabilities/equity)', () => {
|
||
expect(isBalanceSheetAccount('2099')).toBe(true)
|
||
expect(isBalanceSheetAccount('2440')).toBe(true)
|
||
})
|
||
|
||
it('returns false for class 3 (revenue)', () => {
|
||
expect(isBalanceSheetAccount('3001')).toBe(false)
|
||
expect(isBalanceSheetAccount('3740')).toBe(false)
|
||
})
|
||
|
||
it('returns false for class 4-8 (expenses)', () => {
|
||
expect(isBalanceSheetAccount('4010')).toBe(false)
|
||
expect(isBalanceSheetAccount('5010')).toBe(false)
|
||
expect(isBalanceSheetAccount('6211')).toBe(false)
|
||
expect(isBalanceSheetAccount('7210')).toBe(false)
|
||
expect(isBalanceSheetAccount('8999')).toBe(false)
|
||
})
|
||
})
|