Mattsson
387 lines
13 KiB
TypeScript
387 lines
13 KiB
TypeScript
import { describe, it, expect } from 'vitest'
|
||
import {
|
||
calculateGrossMargin,
|
||
calculateCashPosition,
|
||
calculateRevenueGrowth,
|
||
calculateExpenseRatio,
|
||
calculateAvgPaymentDays,
|
||
calculateVatLiability,
|
||
fetchTopSupplierInvoices,
|
||
type KpiSupplierInvoiceRow,
|
||
} from '../kpi'
|
||
import { VAT_INPUT_ACCOUNTS, VAT_OUTPUT_ACCOUNTS } from '../vat-declaration'
|
||
import type { IncomeStatementReport, TrialBalanceRow } from '@/types'
|
||
|
||
function makeIncomeStatement(
|
||
overrides: Partial<IncomeStatementReport> = {}
|
||
): IncomeStatementReport {
|
||
return {
|
||
revenue_sections: [],
|
||
total_revenue: 100000,
|
||
expense_sections: [],
|
||
total_expenses: 60000,
|
||
financial_sections: [],
|
||
total_financial: 0,
|
||
net_result: 40000,
|
||
period: { start: '2025-01-01', end: '2025-12-31' },
|
||
...overrides,
|
||
}
|
||
}
|
||
|
||
function makeTrialBalanceRow(
|
||
overrides: Partial<TrialBalanceRow> = {}
|
||
): TrialBalanceRow {
|
||
return {
|
||
account_number: '1930',
|
||
account_name: 'Företagskonto',
|
||
account_class: 1,
|
||
opening_debit: 0,
|
||
opening_credit: 0,
|
||
period_debit: 0,
|
||
period_credit: 0,
|
||
closing_debit: 0,
|
||
closing_credit: 0,
|
||
...overrides,
|
||
}
|
||
}
|
||
|
||
describe('calculateGrossMargin', () => {
|
||
it('returns margin when revenue and COGS exist', () => {
|
||
const stmt = makeIncomeStatement({
|
||
total_revenue: 200000,
|
||
expense_sections: [
|
||
{
|
||
title: 'Varor och material',
|
||
rows: [{ account_number: '4010', account_name: 'Inköp', amount: 80000 }],
|
||
subtotal: 80000,
|
||
},
|
||
{
|
||
title: 'Lokalkostnader',
|
||
rows: [{ account_number: '5010', account_name: 'Hyra', amount: 20000 }],
|
||
subtotal: 20000,
|
||
},
|
||
],
|
||
})
|
||
// (200000 - 80000) / 200000 * 100 = 60%
|
||
expect(calculateGrossMargin(stmt)).toBe(60)
|
||
})
|
||
|
||
it('returns null when total_revenue is 0', () => {
|
||
const stmt = makeIncomeStatement({ total_revenue: 0 })
|
||
expect(calculateGrossMargin(stmt)).toBeNull()
|
||
})
|
||
|
||
it('returns 100% when no class 4 expenses', () => {
|
||
const stmt = makeIncomeStatement({
|
||
total_revenue: 50000,
|
||
expense_sections: [
|
||
{
|
||
title: 'Lokalkostnader',
|
||
rows: [{ account_number: '5010', account_name: 'Hyra', amount: 10000 }],
|
||
subtotal: 10000,
|
||
},
|
||
],
|
||
})
|
||
expect(calculateGrossMargin(stmt)).toBe(100)
|
||
})
|
||
})
|
||
|
||
describe('calculateCashPosition', () => {
|
||
it('sums closing balances for 19xx accounts', () => {
|
||
const rows = [
|
||
makeTrialBalanceRow({ account_number: '1930', closing_debit: 50000, closing_credit: 0 }),
|
||
makeTrialBalanceRow({ account_number: '1931', closing_debit: 10000, closing_credit: 0 }),
|
||
makeTrialBalanceRow({ account_number: '1510', closing_debit: 25000, closing_credit: 0 }),
|
||
]
|
||
// Only 1930 + 1931 = 60000
|
||
expect(calculateCashPosition(rows)).toBe(60000)
|
||
})
|
||
|
||
it('returns 0 for empty rows', () => {
|
||
expect(calculateCashPosition([])).toBe(0)
|
||
})
|
||
|
||
it('handles credit balances on 19xx accounts', () => {
|
||
const rows = [
|
||
makeTrialBalanceRow({ account_number: '1930', closing_debit: 0, closing_credit: 5000 }),
|
||
]
|
||
expect(calculateCashPosition(rows)).toBe(-5000)
|
||
})
|
||
})
|
||
|
||
describe('calculateVatLiability', () => {
|
||
it('returns positive liability for standard output VAT', () => {
|
||
const rows = [
|
||
makeTrialBalanceRow({ account_number: '2611', closing_credit: 25000 }),
|
||
makeTrialBalanceRow({ account_number: '2641', closing_debit: 10000 }),
|
||
]
|
||
expect(calculateVatLiability(rows)).toBe(15000)
|
||
})
|
||
|
||
it('includes reduced-rate output VAT (12% and 6%) in the liability', () => {
|
||
const rows = [
|
||
makeTrialBalanceRow({ account_number: '2611', closing_credit: 25000 }),
|
||
makeTrialBalanceRow({ account_number: '2621', closing_credit: 1200 }),
|
||
makeTrialBalanceRow({ account_number: '2631', closing_credit: 600 }),
|
||
makeTrialBalanceRow({ account_number: '2641', closing_debit: 10000 }),
|
||
]
|
||
expect(calculateVatLiability(rows)).toBe(16800)
|
||
})
|
||
|
||
it('nets EU reverse charge (2614 + 2645) to zero: issue #715', () => {
|
||
const rows = [
|
||
makeTrialBalanceRow({ account_number: '2614', closing_credit: 2500 }),
|
||
makeTrialBalanceRow({ account_number: '2645', closing_debit: 2500 }),
|
||
]
|
||
expect(calculateVatLiability(rows)).toBe(0)
|
||
})
|
||
|
||
it('nets domestic reverse charge (2614 + 2647) to zero', () => {
|
||
const rows = [
|
||
makeTrialBalanceRow({ account_number: '2614', closing_credit: 1200 }),
|
||
makeTrialBalanceRow({ account_number: '2647', closing_debit: 1200 }),
|
||
]
|
||
expect(calculateVatLiability(rows)).toBe(0)
|
||
})
|
||
|
||
it('nets import VAT (2615 + 2645) to zero', () => {
|
||
const rows = [
|
||
makeTrialBalanceRow({ account_number: '2615', closing_credit: 800 }),
|
||
makeTrialBalanceRow({ account_number: '2645', closing_debit: 800 }),
|
||
]
|
||
expect(calculateVatLiability(rows)).toBe(0)
|
||
})
|
||
|
||
it('reverse charge does not distort the net position alongside regular sales', () => {
|
||
const rows = [
|
||
makeTrialBalanceRow({ account_number: '2611', closing_credit: 5000 }),
|
||
makeTrialBalanceRow({ account_number: '2641', closing_debit: 2000 }),
|
||
makeTrialBalanceRow({ account_number: '2614', closing_credit: 1000 }),
|
||
makeTrialBalanceRow({ account_number: '2645', closing_debit: 1000 }),
|
||
]
|
||
// Old formula gave 5000 − (2000 + 1000) = 2000; correct is 3000
|
||
expect(calculateVatLiability(rows)).toBe(3000)
|
||
})
|
||
|
||
it('returns negative for net VAT receivable', () => {
|
||
const rows = [
|
||
makeTrialBalanceRow({ account_number: '2611', closing_credit: 1000 }),
|
||
makeTrialBalanceRow({ account_number: '2641', closing_debit: 4000 }),
|
||
]
|
||
expect(calculateVatLiability(rows)).toBe(-3000)
|
||
})
|
||
|
||
it('ignores accounts outside the VAT declaration set', () => {
|
||
const rows = [
|
||
makeTrialBalanceRow({ account_number: '2650', closing_credit: 9000 }), // redovisningskonto för moms
|
||
makeTrialBalanceRow({ account_number: '1930', closing_debit: 9000 }),
|
||
]
|
||
expect(calculateVatLiability(rows)).toBe(0)
|
||
})
|
||
|
||
it('respects account overrides, splitting input/output on the 264x prefix', () => {
|
||
const rows = [
|
||
makeTrialBalanceRow({ account_number: '2611', closing_credit: 5000 }),
|
||
makeTrialBalanceRow({ account_number: '2614', closing_credit: 1000 }),
|
||
makeTrialBalanceRow({ account_number: '2641', closing_debit: 2000 }),
|
||
]
|
||
// Override excludes 2614
|
||
expect(calculateVatLiability(rows, ['2611', '2641'])).toBe(3000)
|
||
})
|
||
|
||
it('handles debit balances on output accounts (corrections)', () => {
|
||
const rows = [
|
||
makeTrialBalanceRow({ account_number: '2611', closing_credit: 5000, closing_debit: 500 }),
|
||
]
|
||
expect(calculateVatLiability(rows)).toBe(4500)
|
||
})
|
||
})
|
||
|
||
describe('VAT widget account lists (derived from ACCOUNT_RUTA)', () => {
|
||
// Drift guard: an ACCOUNT_RUTA change that alters these lists changes the
|
||
// dashboard widget's semantics: update this snapshot deliberately.
|
||
it('output accounts cover rutor 10-12, 30-32 and 60-62', () => {
|
||
expect([...VAT_OUTPUT_ACCOUNTS].sort()).toEqual([
|
||
'2610', '2611', '2612', '2613', '2614', '2615', '2616', '2618',
|
||
'2620', '2621', '2622', '2623', '2624', '2625', '2626', '2628',
|
||
'2630', '2631', '2632', '2633', '2634', '2635', '2636', '2638',
|
||
])
|
||
})
|
||
|
||
it('input accounts cover ruta 48', () => {
|
||
expect([...VAT_INPUT_ACCOUNTS].sort()).toEqual([
|
||
'2640', '2641', '2642', '2645', '2646', '2647', '2648', '2649',
|
||
])
|
||
})
|
||
|
||
it('the prefix split used by calculateVatLiability is exact for the defaults', () => {
|
||
for (const account of VAT_OUTPUT_ACCOUNTS) {
|
||
expect(account.startsWith('26')).toBe(true)
|
||
expect(account.startsWith('264')).toBe(false)
|
||
}
|
||
for (const account of VAT_INPUT_ACCOUNTS) {
|
||
expect(account.startsWith('264')).toBe(true)
|
||
}
|
||
})
|
||
})
|
||
|
||
describe('calculateRevenueGrowth', () => {
|
||
it('returns positive growth', () => {
|
||
// (120000 - 100000) / 100000 * 100 = 20%
|
||
expect(calculateRevenueGrowth(120000, 100000)).toBe(20)
|
||
})
|
||
|
||
it('returns negative growth (decline)', () => {
|
||
// (80000 - 100000) / 100000 * 100 = -20%
|
||
expect(calculateRevenueGrowth(80000, 100000)).toBe(-20)
|
||
})
|
||
|
||
it('returns null when previous revenue is null', () => {
|
||
expect(calculateRevenueGrowth(100000, null)).toBeNull()
|
||
})
|
||
|
||
it('returns null when previous revenue is 0', () => {
|
||
expect(calculateRevenueGrowth(100000, 0)).toBeNull()
|
||
})
|
||
})
|
||
|
||
describe('calculateExpenseRatio', () => {
|
||
it('returns ratio for normal data', () => {
|
||
const stmt = makeIncomeStatement({ total_revenue: 200000, total_expenses: 120000 })
|
||
// 120000 / 200000 * 100 = 60%
|
||
expect(calculateExpenseRatio(stmt)).toBe(60)
|
||
})
|
||
|
||
it('returns null when total_revenue is 0', () => {
|
||
const stmt = makeIncomeStatement({ total_revenue: 0, total_expenses: 5000 })
|
||
expect(calculateExpenseRatio(stmt)).toBeNull()
|
||
})
|
||
})
|
||
|
||
describe('fetchTopSupplierInvoices', () => {
|
||
const PAGE_SIZE = 1000 // fetchAllRows page size
|
||
|
||
function makeRow(): KpiSupplierInvoiceRow {
|
||
return {
|
||
supplier_id: 'sup-1',
|
||
total: 1,
|
||
total_sek: null,
|
||
currency: 'SEK',
|
||
exchange_rate: null,
|
||
supplier: { id: 'sup-1', name: 'Leverantören AB' },
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Query-builder double: every filter method chains; `.range(from, to)`
|
||
* resolves to the page registered for `from`. Records order/range calls so
|
||
* the tests can pin the paging contract.
|
||
*/
|
||
function pagedSupabase(
|
||
pagesByFrom: Record<number, unknown[] | { error: { message: string } }>,
|
||
) {
|
||
const orderCalls: unknown[][] = []
|
||
const rangeCalls: Array<[number, number]> = []
|
||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||
const chain: any = {}
|
||
for (const m of ['select', 'eq', 'gte', 'lte', 'neq']) chain[m] = () => chain
|
||
chain.order = (...args: unknown[]) => {
|
||
orderCalls.push(args)
|
||
return chain
|
||
}
|
||
chain.range = (from: number, to: number) => {
|
||
rangeCalls.push([from, to])
|
||
const page = pagesByFrom[from] ?? []
|
||
if (!Array.isArray(page)) {
|
||
return Promise.resolve({ data: null, error: page.error })
|
||
}
|
||
return Promise.resolve({ data: page, error: null })
|
||
}
|
||
return { supabase: { from: () => chain } as never, orderCalls, rangeCalls }
|
||
}
|
||
|
||
it('paginates past the 1000-row PostgREST cap instead of truncating', async () => {
|
||
// A company with 1003 supplier invoices in the period: awaiting the bare
|
||
// query returned only the first 1000 and silently understated the totals.
|
||
const page1 = Array.from({ length: PAGE_SIZE }, () => makeRow())
|
||
const page2 = Array.from({ length: 3 }, () => makeRow())
|
||
const { supabase, rangeCalls } = pagedSupabase({ 0: page1, [PAGE_SIZE]: page2 })
|
||
|
||
const { data, error } = await fetchTopSupplierInvoices(
|
||
supabase,
|
||
'company-1',
|
||
'2026-01-01',
|
||
'2026-12-31',
|
||
)
|
||
|
||
expect(error).toBeNull()
|
||
expect(data).toHaveLength(1003)
|
||
expect(rangeCalls).toEqual([
|
||
[0, PAGE_SIZE - 1],
|
||
[PAGE_SIZE, 2 * PAGE_SIZE - 1],
|
||
])
|
||
})
|
||
|
||
it('orders on the id PK for stable paging', async () => {
|
||
const { supabase, orderCalls } = pagedSupabase({ 0: [makeRow()] })
|
||
|
||
await fetchTopSupplierInvoices(supabase, 'company-1', '2026-01-01', '2026-12-31')
|
||
|
||
// Without a stable total order, .range() paging can duplicate or skip
|
||
// rows on page boundaries, which would double or drop supplier spend.
|
||
expect(orderCalls).toContainEqual(['id', { ascending: true }])
|
||
})
|
||
|
||
it('returns a { data: null, error } value on query failure, never throws', async () => {
|
||
const { supabase } = pagedSupabase({ 0: { error: { message: 'connection reset' } } })
|
||
|
||
const result = await fetchTopSupplierInvoices(
|
||
supabase,
|
||
'company-1',
|
||
'2026-01-01',
|
||
'2026-12-31',
|
||
)
|
||
|
||
expect(result.data).toBeNull()
|
||
expect(result.error?.message).toBe('connection reset')
|
||
})
|
||
})
|
||
|
||
describe('calculateAvgPaymentDays', () => {
|
||
it('returns average for >= 5 invoices', () => {
|
||
const invoices = [
|
||
{ invoice_date: '2025-01-01', paid_at: '2025-01-11' }, // 10 days
|
||
{ invoice_date: '2025-02-01', paid_at: '2025-02-21' }, // 20 days
|
||
{ invoice_date: '2025-03-01', paid_at: '2025-03-16' }, // 15 days
|
||
{ invoice_date: '2025-04-01', paid_at: '2025-04-26' }, // 25 days
|
||
{ invoice_date: '2025-05-01', paid_at: '2025-05-31' }, // 30 days
|
||
]
|
||
// avg = (10+20+15+25+30) / 5 = 20
|
||
expect(calculateAvgPaymentDays(invoices)).toBe(20)
|
||
})
|
||
|
||
it('returns null for fewer than 5 invoices', () => {
|
||
const invoices = [
|
||
{ invoice_date: '2025-01-01', paid_at: '2025-01-11' },
|
||
{ invoice_date: '2025-02-01', paid_at: '2025-02-21' },
|
||
]
|
||
expect(calculateAvgPaymentDays(invoices)).toBeNull()
|
||
})
|
||
|
||
it('returns null for empty array', () => {
|
||
expect(calculateAvgPaymentDays([])).toBeNull()
|
||
})
|
||
|
||
it('clamps negative days to 0', () => {
|
||
const invoices = [
|
||
{ invoice_date: '2025-01-10', paid_at: '2025-01-05' }, // would be -5, clamped to 0
|
||
{ invoice_date: '2025-02-01', paid_at: '2025-02-11' }, // 10
|
||
{ invoice_date: '2025-03-01', paid_at: '2025-03-11' }, // 10
|
||
{ invoice_date: '2025-04-01', paid_at: '2025-04-11' }, // 10
|
||
{ invoice_date: '2025-05-01', paid_at: '2025-05-11' }, // 10
|
||
]
|
||
// avg = (0+10+10+10+10) / 5 = 8
|
||
expect(calculateAvgPaymentDays(invoices)).toBe(8)
|
||
})
|
||
})
|