Files
accounted/lib/salary/__tests__/ytd.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

364 lines
11 KiB
TypeScript

/**
* Tests for the payslip YTD ("Ackumulerat") snapshot: which prior runs count
* toward it, how cutover opening balances interact with it, and the refresh
* that keeps it from rotting when runs are calculated out of order.
*/
import { describe, it, expect, beforeEach } from 'vitest'
import { createQueuedMockSupabase } from '@/tests/helpers'
import {
computePriorYtd,
loadOpeningBalances,
refreshRunYtd,
YTD_COUNTED_STATUSES,
} from '../ytd'
const COMPANY = 'company-1'
const makePrior = (overrides: Record<string, unknown> = {}) => ({
employee_id: 'e1',
gross_salary: 25000,
tax_withheld: 4346,
net_salary: 20654,
salary_run: { period_year: 2026, period_month: 6, status: 'booked' },
...overrides,
})
describe('YTD_COUNTED_STATUSES', () => {
it('counts every authorized status but never draft, review or corrected', () => {
// A month in `paid` has left the building; a month in `corrected` is
// superseded by its correction run and would double the month.
expect([...YTD_COUNTED_STATUSES]).toEqual(['approved', 'paid', 'booked'])
})
})
describe('loadOpeningBalances', () => {
let mock: ReturnType<typeof createQueuedMockSupabase>
beforeEach(() => {
mock = createQueuedMockSupabase()
})
it('short-circuits an empty roster without querying', async () => {
expect(await loadOpeningBalances(mock.supabase as never, COMPANY, [])).toEqual([])
expect(mock.calls).toHaveLength(0)
})
it('reads the karens carry-over alongside the YTD columns, ordered for paging', async () => {
mock.enqueue({ data: [] })
await loadOpeningBalances(mock.supabase as never, COMPANY, ['e1'])
// karens_periods_adjustment feeds sjuklön, so it rides along with the YTD
// columns rather than costing a second read of the same row.
expect(mock.findCall('employee_opening_balances', 'select')).toEqual([
'employee_id, cutover_date, ytd_gross, ytd_tax, ytd_net, karens_periods_adjustment',
])
expect(mock.findCall('employee_opening_balances', 'order')).toEqual(['id'])
})
it('throws rather than reporting nobody has a cutover balance', async () => {
mock.enqueue({ error: { message: 'opening down' } })
await expect(
loadOpeningBalances(mock.supabase as never, COMPANY, ['e1']),
).rejects.toThrow('opening down')
})
})
describe('computePriorYtd', () => {
let mock: ReturnType<typeof createQueuedMockSupabase>
beforeEach(() => {
mock = createQueuedMockSupabase()
})
it('returns an empty map without querying when the roster is empty', async () => {
const ytd = await computePriorYtd(mock.supabase as never, {
companyId: COMPANY,
periodYear: 2026,
periodMonth: 8,
employeeIds: [],
})
expect(ytd.size).toBe(0)
expect(mock.calls).toHaveLength(0)
})
it('sums prior months and filters on every authorized status', async () => {
mock.enqueue({ data: [] }) // employee_opening_balances
mock.enqueue({
data: [
makePrior({ salary_run: { period_year: 2026, period_month: 6, status: 'booked' } }),
makePrior({
gross_salary: 35000,
tax_withheld: 6709,
net_salary: 28291,
// The regression: an earlier month approved but not yet booked was
// silently worth 0, so the next payslip understated Ackumulerat.
salary_run: { period_year: 2026, period_month: 7, status: 'approved' },
}),
],
})
const ytd = await computePriorYtd(mock.supabase as never, {
companyId: COMPANY,
periodYear: 2026,
periodMonth: 8,
employeeIds: ['e1'],
})
expect(ytd.get('e1')).toEqual({ gross: 60000, tax: 11055, net: 48945 })
expect(mock.findCalls('salary_run_employees', 'in')).toContainEqual([
'salary_run.status',
YTD_COUNTED_STATUSES,
])
expect(mock.findCall('salary_run_employees', 'lt')).toEqual(['salary_run.period_month', 8])
})
it('lets the opening balance own the pre-cutover months', async () => {
mock.enqueue({
data: [
// Backdated into a month the opening balance already carries: skipped
// so the pre-cutover pay is not counted twice.
makePrior({ salary_run: { period_year: 2026, period_month: 2, status: 'booked' } }),
makePrior({
gross_salary: 30000,
tax_withheld: 6000,
net_salary: 24000,
salary_run: { period_year: 2026, period_month: 5, status: 'booked' },
}),
],
})
const ytd = await computePriorYtd(mock.supabase as never, {
companyId: COMPANY,
periodYear: 2026,
periodMonth: 8,
employeeIds: ['e1'],
openingRows: [
{
employee_id: 'e1',
cutover_date: '2026-04-01',
ytd_gross: 90000,
ytd_tax: 18000,
ytd_net: 72000,
},
],
})
expect(ytd.get('e1')).toEqual({ gross: 120000, tax: 24000, net: 96000 })
})
it('ignores an opening balance from a different year', async () => {
mock.enqueue({ data: [makePrior()] })
const ytd = await computePriorYtd(mock.supabase as never, {
companyId: COMPANY,
periodYear: 2026,
periodMonth: 8,
employeeIds: ['e1'],
openingRows: [
{
employee_id: 'e1',
cutover_date: '2025-04-01',
ytd_gross: 90000,
ytd_tax: 18000,
ytd_net: 72000,
},
],
})
expect(ytd.get('e1')).toEqual({ gross: 25000, tax: 4346, net: 20654 })
})
it('orders the paged prior-run read on the primary key', async () => {
mock.enqueue({ data: [] })
mock.enqueue({ data: [] })
await computePriorYtd(mock.supabase as never, {
companyId: COMPANY,
periodYear: 2026,
periodMonth: 8,
employeeIds: ['e1'],
})
// Without a stable total order, a roster wide enough to page would skip
// or double a month across the page boundary.
expect(mock.findCall('salary_run_employees', 'order')).toEqual(['id'])
})
it('throws rather than reporting an empty carry-in when the read fails', async () => {
mock.enqueue({ data: [] })
mock.enqueue({ error: { message: 'boom' } })
// Returning an empty map here would silently rewrite the snapshot to the
// current month alone, which is the exact failure this module exists to
// prevent.
await expect(
computePriorYtd(mock.supabase as never, {
companyId: COMPANY,
periodYear: 2026,
periodMonth: 8,
employeeIds: ['e1'],
}),
).rejects.toThrow('boom')
})
it('skips the opening-balance query when the caller already loaded them', async () => {
mock.enqueue({ data: [] }) // prior runs
await computePriorYtd(mock.supabase as never, {
companyId: COMPANY,
periodYear: 2026,
periodMonth: 8,
employeeIds: ['e1'],
openingRows: [],
})
expect(mock.calls.some((c) => c.table === 'employee_opening_balances')).toBe(false)
})
})
describe('refreshRunYtd', () => {
let mock: ReturnType<typeof createQueuedMockSupabase>
beforeEach(() => {
mock = createQueuedMockSupabase()
})
const enqueueRun = () =>
mock.enqueue({ data: { id: 'run-1', period_year: 2026, period_month: 8 } })
it('rewrites a snapshot that was frozen before an earlier month was booked', async () => {
enqueueRun()
mock.enqueue({
data: [
{
id: 'sre-1',
employee_id: 'e1',
gross_salary: 35000,
tax_withheld: 6709,
net_salary: 28291,
// Stale: captured when only June (25 000) had been booked.
ytd_gross: 60000,
ytd_tax: 11055,
ytd_net: 48945,
},
],
})
mock.enqueue({ data: [] }) // opening balances
mock.enqueue({
data: [
makePrior({ salary_run: { period_year: 2026, period_month: 6, status: 'booked' } }),
makePrior({
gross_salary: 35000,
tax_withheld: 6709,
net_salary: 28291,
salary_run: { period_year: 2026, period_month: 7, status: 'booked' },
}),
],
})
mock.enqueue({ data: null }) // the update
const result = await refreshRunYtd(mock.supabase as never, {
companyId: COMPANY,
salaryRunId: 'run-1',
})
expect(result).toEqual({ ok: true, updated: 1 })
expect(mock.findCall('salary_run_employees', 'update')).toEqual([
{ ytd_gross: 95000, ytd_tax: 17764, ytd_net: 77236 },
])
})
it('leaves an already-correct snapshot untouched', async () => {
enqueueRun()
mock.enqueue({
data: [
{
id: 'sre-1',
employee_id: 'e1',
gross_salary: 35000,
tax_withheld: 6709,
net_salary: 28291,
ytd_gross: 60000,
ytd_tax: 11055,
ytd_net: 48945,
},
],
})
mock.enqueue({ data: [] })
mock.enqueue({ data: [makePrior()] })
const result = await refreshRunYtd(mock.supabase as never, {
companyId: COMPANY,
salaryRunId: 'run-1',
})
expect(result).toEqual({ ok: true, updated: 0 })
expect(mock.findCall('salary_run_employees', 'update')).toBeUndefined()
})
it('reports a missing run instead of throwing', async () => {
mock.enqueue({ data: null })
const result = await refreshRunYtd(mock.supabase as never, {
companyId: COMPANY,
salaryRunId: 'run-1',
})
expect(result).toEqual({ ok: false, message: 'salary run not found' })
})
it('reports a database error instead of throwing', async () => {
mock.enqueue({ error: { message: 'boom' } })
const result = await refreshRunYtd(mock.supabase as never, {
companyId: COMPANY,
salaryRunId: 'run-1',
})
expect(result).toEqual({ ok: false, message: 'boom' })
})
it('reports a failed prior-run read instead of writing a truncated snapshot', async () => {
enqueueRun()
mock.enqueue({
data: [
{
id: 'sre-1',
employee_id: 'e1',
gross_salary: 35000,
tax_withheld: 6709,
net_salary: 28291,
ytd_gross: 60000,
ytd_tax: 11055,
ytd_net: 48945,
},
],
})
mock.enqueue({ data: [] }) // opening balances
mock.enqueue({ error: { message: 'boom' } }) // prior runs
const result = await refreshRunYtd(mock.supabase as never, {
companyId: COMPANY,
salaryRunId: 'run-1',
})
expect(result).toEqual({ ok: false, message: 'boom' })
expect(mock.findCall('salary_run_employees', 'update')).toBeUndefined()
})
it('is a no-op for a run with no roster', async () => {
enqueueRun()
mock.enqueue({ data: [] })
const result = await refreshRunYtd(mock.supabase as never, {
companyId: COMPANY,
salaryRunId: 'run-1',
})
expect(result).toEqual({ ok: true, updated: 0 })
})
})