Å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.
186 lines
5.7 KiB
TypeScript
186 lines
5.7 KiB
TypeScript
import { describe, it, expect } from 'vitest'
|
|
import {
|
|
filterBucketsToRange,
|
|
mergeMonthlySeries,
|
|
periodsInRange,
|
|
pickCurrentPeriod,
|
|
resolvePeriodPreset,
|
|
resultMargin,
|
|
sumBuckets,
|
|
type FiscalPeriodLite,
|
|
type MonthBucket,
|
|
} from '@/lib/byra/kpi-aggregate'
|
|
|
|
const bucket = (
|
|
year: number,
|
|
month0: number,
|
|
income = 0,
|
|
expenses = 0,
|
|
): MonthBucket => ({ year, month0, income, expenses })
|
|
|
|
const period = (
|
|
id: string,
|
|
start: string,
|
|
end: string,
|
|
ob: string | null = null,
|
|
): FiscalPeriodLite => ({
|
|
id,
|
|
company_id: 'c1',
|
|
period_start: start,
|
|
period_end: end,
|
|
opening_balance_entry_id: ob,
|
|
})
|
|
|
|
describe('resolvePeriodPreset', () => {
|
|
const today = new Date(2026, 7, 4) // 2026-08-04
|
|
|
|
it('resolves month to the first of the current month', () => {
|
|
expect(resolvePeriodPreset('month', today).range).toEqual({
|
|
fromDate: '2026-08-01',
|
|
toDate: '2026-08-04',
|
|
})
|
|
})
|
|
|
|
it('resolves quarter to the quarter start', () => {
|
|
expect(resolvePeriodPreset('quarter', today).range).toEqual({
|
|
fromDate: '2026-07-01',
|
|
toDate: '2026-08-04',
|
|
})
|
|
})
|
|
|
|
it('resolves ytd to January 1', () => {
|
|
expect(resolvePeriodPreset('ytd', today).range).toEqual({
|
|
fromDate: '2026-01-01',
|
|
toDate: '2026-08-04',
|
|
})
|
|
})
|
|
|
|
it('resolves 12m across the year boundary', () => {
|
|
expect(resolvePeriodPreset('12m', today).range).toEqual({
|
|
fromDate: '2025-09-01',
|
|
toDate: '2026-08-04',
|
|
})
|
|
})
|
|
|
|
it('falls back to ytd on unknown or missing input', () => {
|
|
expect(resolvePeriodPreset('bogus', today).preset).toBe('ytd')
|
|
expect(resolvePeriodPreset(undefined, today).preset).toBe('ytd')
|
|
})
|
|
|
|
it('handles a January today for quarter and 12m', () => {
|
|
const january = new Date(2026, 0, 15)
|
|
expect(resolvePeriodPreset('quarter', january).range.fromDate).toBe('2026-01-01')
|
|
expect(resolvePeriodPreset('12m', january).range.fromDate).toBe('2025-02-01')
|
|
})
|
|
})
|
|
|
|
describe('pickCurrentPeriod', () => {
|
|
const fy25 = period('p25', '2025-01-01', '2025-12-31')
|
|
const fy26 = period('p26', '2026-01-01', '2026-12-31')
|
|
const fy27 = period('p27', '2027-01-01', '2027-12-31')
|
|
|
|
it('picks the period containing today', () => {
|
|
expect(pickCurrentPeriod([fy25, fy26, fy27], '2026-08-04')?.id).toBe('p26')
|
|
})
|
|
|
|
it('falls back to the most recent past period', () => {
|
|
expect(pickCurrentPeriod([fy25, fy26], '2027-06-01')?.id).toBe('p26')
|
|
})
|
|
|
|
it('falls back to the earliest future period when all are ahead', () => {
|
|
expect(pickCurrentPeriod([fy26, fy27], '2024-06-01')?.id).toBe('p26')
|
|
})
|
|
|
|
it('returns null for no periods', () => {
|
|
expect(pickCurrentPeriod([], '2026-08-04')).toBeNull()
|
|
})
|
|
|
|
it('prefers the latest start when periods overlap today', () => {
|
|
const short = period('pShort', '2026-07-01', '2026-12-31')
|
|
expect(pickCurrentPeriod([fy26, short], '2026-08-04')?.id).toBe('pShort')
|
|
})
|
|
})
|
|
|
|
describe('periodsInRange', () => {
|
|
it('keeps periods overlapping the range and drops the rest', () => {
|
|
const fy25 = period('p25', '2025-01-01', '2025-12-31')
|
|
const fy26 = period('p26', '2026-01-01', '2026-12-31')
|
|
const range = { fromDate: '2025-09-01', toDate: '2026-08-04' }
|
|
expect(periodsInRange([fy25, fy26], range).map((p) => p.id)).toEqual(['p25', 'p26'])
|
|
expect(
|
|
periodsInRange([fy25], { fromDate: '2026-01-01', toDate: '2026-08-04' }),
|
|
).toEqual([])
|
|
})
|
|
})
|
|
|
|
describe('filterBucketsToRange', () => {
|
|
it('keeps whole months inside the range, inclusive of partial edge months', () => {
|
|
const buckets = [
|
|
bucket(2025, 7),
|
|
bucket(2025, 8),
|
|
bucket(2026, 7),
|
|
bucket(2026, 8),
|
|
]
|
|
const range = { fromDate: '2025-09-01', toDate: '2026-08-04' }
|
|
expect(filterBucketsToRange(buckets, range)).toEqual([
|
|
bucket(2025, 8),
|
|
bucket(2026, 7),
|
|
])
|
|
})
|
|
})
|
|
|
|
describe('sumBuckets and resultMargin', () => {
|
|
it('sums revenue, expenses and result with öre rounding', () => {
|
|
const sums = sumBuckets([
|
|
bucket(2026, 0, 100.005, 50.004),
|
|
bucket(2026, 1, 200, 25),
|
|
])
|
|
expect(sums.revenue).toBe(300.01)
|
|
expect(sums.expenses).toBe(75.0)
|
|
expect(sums.result).toBe(225.01)
|
|
})
|
|
|
|
it('returns zeros for no buckets', () => {
|
|
expect(sumBuckets([])).toEqual({ revenue: 0, expenses: 0, result: 0 })
|
|
})
|
|
|
|
it('computes margin in percent and nulls out on zero revenue', () => {
|
|
expect(resultMargin(200, 50)).toBe(25)
|
|
expect(resultMargin(300, 100)).toBe(33.33)
|
|
expect(resultMargin(0, -500)).toBeNull()
|
|
})
|
|
})
|
|
|
|
describe('mergeMonthlySeries', () => {
|
|
it('zero-fills every month of the range and sums across companies', () => {
|
|
const range = { fromDate: '2026-01-01', toDate: '2026-03-31' }
|
|
const months = mergeMonthlySeries(
|
|
[bucket(2026, 0, 100, 40), bucket(2026, 0, 50, 10), bucket(2026, 2, 30, 5)],
|
|
range,
|
|
)
|
|
expect(months).toEqual([
|
|
{ label: 'Jan', income: 150, expenses: 50 },
|
|
{ label: 'Feb', income: 0, expenses: 0 },
|
|
{ label: 'Mar', income: 30, expenses: 5 },
|
|
])
|
|
})
|
|
|
|
it('adds a year suffix when the range spans calendar years', () => {
|
|
const range = { fromDate: '2025-12-01', toDate: '2026-01-31' }
|
|
const months = mergeMonthlySeries([bucket(2025, 11, 10, 0)], range)
|
|
expect(months.map((m) => m.label)).toEqual(['Dec 25', 'Jan 26'])
|
|
})
|
|
|
|
it('ignores buckets outside the range', () => {
|
|
const range = { fromDate: '2026-01-01', toDate: '2026-01-31' }
|
|
const months = mergeMonthlySeries([bucket(2025, 11, 999, 999)], range)
|
|
expect(months).toEqual([{ label: 'Jan', income: 0, expenses: 0 }])
|
|
})
|
|
|
|
it('returns empty for an inverted range', () => {
|
|
expect(
|
|
mergeMonthlySeries([], { fromDate: '2026-03-01', toDate: '2026-01-31' }),
|
|
).toEqual([])
|
|
})
|
|
})
|