Files
accounted/app/api/reports/kpi/__tests__/route.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

424 lines
15 KiB
TypeScript

import { describe, it, expect, vi, beforeEach } from 'vitest'
import { NextResponse } from 'next/server'
import { createQueuedMockSupabase, createMockRequest, parseJsonResponse } from '@/tests/helpers'
import type { KPIReport } from '@/types'
const { supabase, enqueue, reset } = createQueuedMockSupabase()
const requireAuthMock = vi.fn()
vi.mock('@/lib/auth/require-auth', () => ({
requireAuth: (...args: unknown[]) => requireAuthMock(...args),
}))
vi.mock('@/lib/company/context', () => ({
getActiveCompanyId: vi.fn().mockResolvedValue('company-1'),
requireCompanyId: vi.fn().mockResolvedValue('company-1'),
}))
// Legacy generators are mocked as spies: the no-dimension hot path must never
// call them, the dimension path must still route through them. The pure
// builders (buildIncomeStatementFromRows, assembleMonthlyBreakdown) stay real
// so the happy path asserts the full KPI JSON end to end.
vi.mock('@/lib/reports/trial-balance', () => ({
generateTrialBalance: vi.fn(),
}))
vi.mock('@/lib/reports/ar-ledger', () => ({
generateARLedger: vi.fn(),
}))
vi.mock('@/lib/reports/income-statement', async (importOriginal) => {
const actual = await importOriginal<typeof import('@/lib/reports/income-statement')>()
return { ...actual, generateIncomeStatement: vi.fn() }
})
vi.mock('@/lib/reports/monthly-breakdown', async (importOriginal) => {
const actual = await importOriginal<typeof import('@/lib/reports/monthly-breakdown')>()
return { ...actual, generateMonthlyBreakdown: vi.fn() }
})
import { GET } from '../route'
import { generateTrialBalance } from '@/lib/reports/trial-balance'
import { generateARLedger } from '@/lib/reports/ar-ledger'
import { generateIncomeStatement } from '@/lib/reports/income-statement'
import { generateMonthlyBreakdown } from '@/lib/reports/monthly-breakdown'
const mockTrialBalance = vi.mocked(generateTrialBalance)
const mockARLedger = vi.mocked(generateARLedger)
const mockIncomeStatement = vi.mocked(generateIncomeStatement)
const mockMonthlyBreakdown = vi.mocked(generateMonthlyBreakdown)
const noParams = { params: Promise.resolve({}) }
function authed() {
requireAuthMock.mockResolvedValue({ user: { id: 'user-1' }, supabase, error: null })
}
function unauthed() {
requireAuthMock.mockResolvedValue({
user: null,
supabase,
error: NextResponse.json({ error: 'Unauthorized' }, { status: 401 }),
})
}
function makePeriod(overrides: Record<string, unknown> = {}) {
return {
id: 'period-1',
company_id: 'company-1',
period_start: '2026-01-01',
period_end: '2026-03-31',
is_closed: false,
opening_balance_entry_id: null,
...overrides,
}
}
/** Wire payload as returned by the get_kpi_report_aggregates RPC. */
function aggPayload() {
return {
tb: [
{ account_number: '1930', debit: 12500, credit: 0 },
{ account_number: '2611', debit: 0, credit: 2500 },
{ account_number: '3001', debit: 0, credit: 10000 },
{ account_number: '5010', debit: 3000, credit: 0 },
],
tb_ex_year_end: [
{ account_number: '1930', debit: 12500, credit: 0 },
{ account_number: '2611', debit: 0, credit: 2500 },
{ account_number: '3001', debit: 0, credit: 10000 },
{ account_number: '5010', debit: 3000, credit: 0 },
],
ob: [],
monthly: [
{ year: 2026, month: 1, income: 10000, expenses: 0 },
{ year: 2026, month: 2, income: 0, expenses: 3000 },
],
}
}
const CHART = [
{ account_number: '1930', account_name: 'Företagskonto', account_class: 1 },
{ account_number: '3001', account_name: 'Försäljning 25%', account_class: 3 },
{ account_number: '5010', account_name: 'Lokalhyra', account_class: 5 },
]
const PAID_INVOICES = Array.from({ length: 5 }, () => ({
invoice_date: '2026-01-01',
paid_at: '2026-01-11',
}))
function supplierRow(
overrides: Partial<{
supplier_id: string
total: number
total_sek: number | null
currency: string
exchange_rate: number | null
supplier: { id: string; name: string }
}> = {}
) {
const supplierId = overrides.supplier_id ?? 'sup-1'
return {
supplier_id: supplierId,
total: 100,
total_sek: null,
currency: 'SEK',
exchange_rate: null,
supplier: { id: supplierId, name: 'Leverantören AB' },
...overrides,
}
}
const SUPPLIER_ROWS = [
supplierRow({ supplier_id: 'sup-1', total: 400, total_sek: 400 }),
supplierRow({ supplier_id: 'sup-1', total: 100, total_sek: 100 }),
supplierRow({
supplier_id: 'sup-2',
total: 200,
total_sek: 200,
supplier: { id: 'sup-2', name: 'Andra AB' },
}),
]
/**
* The realistic shape of an ordinary Swedish supplier invoice: currency SEK,
* no exchange rate, and `total_sek` NULL because no conversion ever ran.
*/
const SEK_ONLY_ROWS = [
supplierRow({ supplier_id: 'sup-1', total: 1250, supplier: { id: 'sup-1', name: 'Städbolaget AB' } }),
supplierRow({ supplier_id: 'sup-1', total: 750.5, supplier: { id: 'sup-1', name: 'Städbolaget AB' } }),
supplierRow({
supplier_id: 'sup-2',
total: 400,
supplier: { id: 'sup-2', name: 'Kontorsvaror AB' },
}),
]
/** Queue the six responses the hot path consumes after the fiscal period. */
function enqueueHotPath(supplierRows: unknown[]) {
enqueue({ data: aggPayload() }) // rpc get_kpi_report_aggregates
enqueue({ data: [] }) // rpc compute_prior_opening_balances
enqueue({ data: CHART }) // chart_of_accounts
enqueue({ data: null }) // extension_data prefs
enqueue({ data: [] }) // invoices
enqueue({ data: supplierRows }) // supplier_invoices
}
function kpiRequest(searchParams: Record<string, string> = { period_id: 'period-1' }) {
return createMockRequest('/api/reports/kpi', { searchParams })
}
beforeEach(() => {
vi.clearAllMocks()
reset()
authed()
mockARLedger.mockResolvedValue({ total_outstanding: 1500, total_overdue: 500 } as never)
})
describe('GET /api/reports/kpi', () => {
it('returns 401 when not authenticated', async () => {
unauthed()
const res = await GET(kpiRequest(), noParams)
expect(res.status).toBe(401)
expect(supabase.rpc).not.toHaveBeenCalled()
})
it('returns 400 when period_id is missing', async () => {
const res = await GET(kpiRequest({}), noParams)
expect(res.status).toBe(400)
})
it('returns 404 for an unknown fiscal period', async () => {
enqueue({ data: null, error: { message: 'not found' } })
const res = await GET(kpiRequest(), noParams)
expect(res.status).toBe(404)
})
it('returns 400 for a half-provided dimension pair', async () => {
enqueue({ data: makePeriod() })
const res = await GET(kpiRequest({ period_id: 'period-1', dim_no: '6' }), noParams)
expect(res.status).toBe(400)
})
it('happy path: builds the full KPI report from one aggregate round trip', async () => {
enqueue({ data: makePeriod() }) // fiscal_periods
enqueue({ data: aggPayload() }) // rpc get_kpi_report_aggregates
enqueue({ data: [{ account_number: '1930', debit: 5000, credit: 0 }] }) // rpc compute_prior_opening_balances
enqueue({ data: CHART }) // chart_of_accounts
enqueue({ data: null }) // extension_data prefs (no row)
enqueue({ data: PAID_INVOICES }) // invoices
enqueue({ data: SUPPLIER_ROWS }) // supplier_invoices
const res = await GET(kpiRequest(), noParams)
const { status, body } = await parseJsonResponse<{ data: KPIReport }>(res)
expect(status).toBe(200)
expect(body.data).toEqual({
netResult: 7000,
cashPosition: 17500, // 5000 IB + 12500 period debit on 1930
outstandingReceivables: 1500,
overdueReceivables: 500,
vatLiability: 2500,
totalRevenue: 10000,
totalExpenses: 3000,
grossMargin: 100,
expenseRatio: 30,
avgPaymentDays: 10,
periodComplete: false,
months: [
{ label: 'Jan', income: 10000, expenses: 0, net: 10000 },
{ label: 'Feb', income: 0, expenses: 3000, net: -3000 },
{ label: 'Mar', income: 0, expenses: 0, net: 0 },
],
period: { start: '2026-01-01', end: '2026-03-31' },
expenseComposition: { class4: 0, class5: 3000, class6: 0, class7: 0 },
topExpenseAccounts: [
{ account_number: '5010', account_name: 'Lokalhyra', total: 3000 },
],
topSuppliers: [
{ supplier_id: 'sup-1', supplier_name: 'Leverantören AB', total: 500 },
{ supplier_id: 'sup-2', supplier_name: 'Andra AB', total: 200 },
],
topSuppliersUnconvertedFxCount: 0,
})
expect(supabase.rpc).toHaveBeenCalledWith('get_kpi_report_aggregates', {
p_company_id: 'company-1',
p_fiscal_period_id: 'period-1',
p_ob_entry_id: null,
})
expect(supabase.rpc).toHaveBeenCalledWith('compute_prior_opening_balances', {
p_company_id: 'company-1',
p_period_start: '2026-01-01',
})
// The hot path must not touch the legacy line-scanning generators.
expect(mockTrialBalance).not.toHaveBeenCalled()
expect(mockIncomeStatement).not.toHaveBeenCalled()
expect(mockMonthlyBreakdown).not.toHaveBeenCalled()
})
it('skips the prior-balance RPC when the period has an opening balance entry', async () => {
enqueue({ data: makePeriod({ opening_balance_entry_id: 'ob-1' }) }) // fiscal_periods
enqueue({
data: {
...aggPayload(),
ob: [
{ account_number: '1930', debit: 5000, credit: 0 },
{ account_number: '2081', debit: 0, credit: 5000 },
],
},
}) // rpc get_kpi_report_aggregates (no prior RPC follows)
enqueue({ data: CHART }) // chart_of_accounts
enqueue({ data: null }) // extension_data prefs
enqueue({ data: [] }) // invoices
enqueue({ data: [] }) // supplier_invoices
const res = await GET(kpiRequest(), noParams)
const { status, body } = await parseJsonResponse<{ data: KPIReport }>(res)
expect(status).toBe(200)
expect(body.data.cashPosition).toBe(17500) // OB 5000 + period 12500 on 1930
expect(supabase.rpc).toHaveBeenCalledTimes(1)
expect(supabase.rpc).toHaveBeenCalledWith('get_kpi_report_aggregates', {
p_company_id: 'company-1',
p_fiscal_period_id: 'period-1',
p_ob_entry_id: 'ob-1',
})
})
it('dimension-filtered path still uses the legacy generators and never the RPC', async () => {
enqueue({ data: makePeriod() }) // fiscal_periods
enqueue({ data: null }) // extension_data prefs
enqueue({ data: [] }) // invoices
enqueue({ data: [] }) // supplier_invoices
mockIncomeStatement.mockResolvedValue({
revenue_sections: [],
total_revenue: 0,
expense_sections: [],
total_expenses: 0,
financial_sections: [],
total_financial: 0,
net_result: 0,
period: { start: '', end: '' },
})
mockTrialBalance.mockResolvedValue({
rows: [],
totalDebit: 0,
totalCredit: 0,
isBalanced: true,
})
mockMonthlyBreakdown.mockResolvedValue({ months: [] })
const res = await GET(
kpiRequest({ period_id: 'period-1', dim_no: '6', dim_code: 'P001' }),
noParams
)
expect(res.status).toBe(200)
const dimensions = { '6': 'P001' }
expect(mockIncomeStatement).toHaveBeenCalledWith(supabase, 'company-1', 'period-1', {
dimensions,
})
expect(mockMonthlyBreakdown).toHaveBeenCalledWith(supabase, 'company-1', 'period-1', {
dimensions,
})
// Unfiltered TB for balance-side KPIs + dimension-scoped TB for the
// expense composition.
expect(mockTrialBalance).toHaveBeenCalledTimes(2)
expect(mockTrialBalance).toHaveBeenNthCalledWith(1, supabase, 'company-1', 'period-1', {
closingEntry: 'include',
})
expect(mockTrialBalance).toHaveBeenNthCalledWith(2, supabase, 'company-1', 'period-1', {
closingEntry: 'include',
dimensions,
})
expect(supabase.rpc).not.toHaveBeenCalled()
})
it('populates Största leverantörer for a SEK-only company whose total_sek is NULL', async () => {
// Headline regression: total_sek is only written when a conversion runs,
// so an ordinary Swedish supplier invoice has it NULL. Reading total_sek
// alone left the panel permanently empty for these companies.
enqueue({ data: makePeriod() }) // fiscal_periods
enqueueHotPath(SEK_ONLY_ROWS)
const res = await GET(kpiRequest(), noParams)
const { status, body } = await parseJsonResponse<{ data: KPIReport }>(res)
expect(status).toBe(200)
expect(body.data.topSuppliers).toEqual([
{ supplier_id: 'sup-1', supplier_name: 'Städbolaget AB', total: 2000.5 },
{ supplier_id: 'sup-2', supplier_name: 'Kontorsvaror AB', total: 400 },
])
expect(body.data.topSuppliersUnconvertedFxCount).toBe(0)
})
it('aggregates a mixed SEK/EUR company in SEK', async () => {
enqueue({ data: makePeriod() }) // fiscal_periods
enqueueHotPath([
// SEK invoice: total is the SEK total, exactly.
supplierRow({ supplier_id: 'sup-1', total: 1000, supplier: { id: 'sup-1', name: 'Svensk Lev AB' } }),
// EUR invoice with a rate: converted at 100 * 11.4567 = 1145.67.
supplierRow({
supplier_id: 'sup-1',
total: 100,
currency: 'EUR',
exchange_rate: 11.4567,
supplier: { id: 'sup-1', name: 'Svensk Lev AB' },
}),
// EUR invoice with a stored SEK total: that value wins.
supplierRow({
supplier_id: 'sup-2',
total: 200,
total_sek: 2300,
currency: 'EUR',
exchange_rate: 11.5,
supplier: { id: 'sup-2', name: 'Euro Supplier GmbH' },
}),
])
const res = await GET(kpiRequest(), noParams)
const { status, body } = await parseJsonResponse<{ data: KPIReport }>(res)
expect(status).toBe(200)
expect(body.data.topSuppliers).toEqual([
{ supplier_id: 'sup-2', supplier_name: 'Euro Supplier GmbH', total: 2300 },
{ supplier_id: 'sup-1', supplier_name: 'Svensk Lev AB', total: 2145.67 },
])
expect(body.data.topSuppliersUnconvertedFxCount).toBe(0)
})
it('reports an unconvertible FX invoice instead of silently dropping it', async () => {
enqueue({ data: makePeriod() }) // fiscal_periods
enqueueHotPath([
supplierRow({ supplier_id: 'sup-1', total: 1000, supplier: { id: 'sup-1', name: 'Svensk Lev AB' } }),
// USD, no rate and no SEK total: cannot be expressed in SEK.
supplierRow({
supplier_id: 'sup-2',
total: 500,
currency: 'USD',
supplier: { id: 'sup-2', name: 'US Vendor Inc' },
}),
])
const res = await GET(kpiRequest(), noParams)
const { status, body } = await parseJsonResponse<{ data: KPIReport }>(res)
expect(status).toBe(200)
// The raw 500 USD is neither added as SEK nor hidden: it is counted.
expect(body.data.topSuppliers).toEqual([
{ supplier_id: 'sup-1', supplier_name: 'Svensk Lev AB', total: 1000 },
])
expect(body.data.topSuppliersUnconvertedFxCount).toBe(1)
})
it('returns 500 when the aggregates RPC fails', async () => {
enqueue({ data: makePeriod() }) // fiscal_periods
enqueue({ data: null, error: { message: 'connection reset' } }) // rpc get_kpi_report_aggregates
const res = await GET(kpiRequest(), noParams)
expect(res.status).toBe(500)
const body = (await res.json()) as { error: { code: string } }
expect(body.error).toBeDefined()
})
})