Files
accounted/lib/bookkeeping/__tests__/currency-utils.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

207 lines
7.2 KiB
TypeScript

import { describe, it, expect } from 'vitest'
import {
resolveSekAmount,
resolveSekAmountOrNull,
buildCurrencyMetadata,
} from '../currency-utils'
/**
* The strict ladder. Booking code must use this one: it answers "no SEK value
* can be established" with null instead of handing back the foreign amount.
*/
describe('resolveSekAmountOrNull', () => {
it('returns amount as-is for SEK currency', () => {
expect(resolveSekAmountOrNull(1000, null, 'SEK', null)).toBe(1000)
})
it('returns amount as-is when currency is null (legacy data means SEK)', () => {
expect(resolveSekAmountOrNull(1000, null, null, null)).toBe(1000)
})
it('returns amount as-is when currency is undefined', () => {
expect(resolveSekAmountOrNull(1000, null, undefined, null)).toBe(1000)
})
it('returns amountSek when populated for foreign currency', () => {
expect(resolveSekAmountOrNull(100, 1150, 'EUR', 11.5)).toBe(1150)
})
it('rounds amountSek to öre', () => {
expect(resolveSekAmountOrNull(100, 1150.456, 'EUR', 11.5)).toBe(1150.46)
})
it('computes via exchangeRate when amountSek is null', () => {
expect(resolveSekAmountOrNull(100, null, 'EUR', 11.5)).toBe(1150)
})
it('rounds the computed amount to öre', () => {
// 100.33 * 11.5 = 1153.795 -> 1153.8
expect(resolveSekAmountOrNull(100.33, null, 'EUR', 11.5)).toBe(1153.8)
})
it('prefers amountSek over exchangeRate computation', () => {
expect(resolveSekAmountOrNull(100, 1200, 'EUR', 11.5)).toBe(1200)
})
it('handles negative amounts', () => {
expect(resolveSekAmountOrNull(-100, null, 'EUR', 11.5)).toBe(-1150)
})
it('handles zero amount', () => {
expect(resolveSekAmountOrNull(0, null, 'EUR', 11.5)).toBe(0)
})
// The whole point of the strict sibling: a foreign amount with no SEK value
// and no rate is refused, never relabelled as kronor. 100 EUR is not 100 SEK.
it('returns null when a foreign amount has neither amountSek nor exchangeRate', () => {
expect(resolveSekAmountOrNull(100, null, 'EUR', null)).toBeNull()
})
it('returns null when exchangeRate is 0', () => {
expect(resolveSekAmountOrNull(100, null, 'EUR', 0)).toBeNull()
})
it('returns null when exchangeRate is negative', () => {
expect(resolveSekAmountOrNull(100, null, 'EUR', -11.5)).toBeNull()
})
it('returns null when exchangeRate is undefined', () => {
expect(resolveSekAmountOrNull(100, null, 'EUR', undefined)).toBeNull()
})
it('never returns null for SEK, whatever the rate looks like', () => {
expect(resolveSekAmountOrNull(100, null, 'SEK', null)).toBe(100)
expect(resolveSekAmountOrNull(100, null, 'SEK', 0)).toBe(100)
})
})
/**
* The lenient wrapper, kept for read-only callers over legacy pre-FX rows.
*
* Its fallback behaviour is UNCHANGED and deliberately still pinned below: the
* root fix added `resolveSekAmountOrNull()` as a strict sibling rather than
* flipping this function's return type, so no unread call site could shift. The
* two "falls back to the original amount" cases therefore still pass, and they
* now assert that the lenient contract is intact rather than that guessing is
* acceptable: the matching strict cases above assert the refusal.
*/
describe('resolveSekAmount', () => {
it('returns amount as-is for SEK currency', () => {
expect(resolveSekAmount(1000, null, 'SEK', null)).toBe(1000)
})
it('returns amount as-is when currency is null (legacy data)', () => {
expect(resolveSekAmount(1000, null, null, null)).toBe(1000)
})
it('returns amount as-is when currency is undefined', () => {
expect(resolveSekAmount(1000, null, undefined, null)).toBe(1000)
})
it('returns amountSek when populated for foreign currency', () => {
expect(resolveSekAmount(100, 1150, 'EUR', 11.5)).toBe(1150)
})
it('rounds amountSek to 2 decimals', () => {
expect(resolveSekAmount(100, 1150.456, 'EUR', 11.5)).toBe(1150.46)
})
it('computes via exchangeRate when amountSek is null', () => {
expect(resolveSekAmount(100, null, 'EUR', 11.5)).toBe(1150)
})
it('rounds computed amount to 2 decimals', () => {
// 100.33 * 11.5 = 1153.795 → rounds to 1153.8
expect(resolveSekAmount(100.33, null, 'EUR', 11.5)).toBe(1153.8)
})
// These two are the legacy-reader contract, NOT a statement that 100 EUR may
// be booked as 100 SEK. Booking code must call resolveSekAmountOrNull(), which
// returns null for exactly these inputs (see the strict block above).
it('falls back to original amount when both amountSek and exchangeRate are null (legacy readers only)', () => {
expect(resolveSekAmount(100, null, 'EUR', null)).toBe(100)
expect(resolveSekAmountOrNull(100, null, 'EUR', null)).toBeNull()
})
it('falls back when exchangeRate is 0 (legacy readers only)', () => {
expect(resolveSekAmount(100, null, 'EUR', 0)).toBe(100)
expect(resolveSekAmountOrNull(100, null, 'EUR', 0)).toBeNull()
})
// The lenient function is a thin wrapper: everything except the last resort
// must be byte-identical to the strict ladder, so the two can never drift.
it('delegates every resolvable case to resolveSekAmountOrNull', () => {
const cases: Array<[number, number | null, string | null, number | null]> = [
[1000, null, 'SEK', null],
[1000, null, null, null],
[100, 1150, 'EUR', 11.5],
[100, 1150.456, 'EUR', 11.5],
[100.33, null, 'EUR', 11.5],
[-100, null, 'EUR', 11.5],
[0, null, 'EUR', 11.5],
[100, 1200, 'EUR', 11.5],
]
for (const [amount, amountSek, currency, rate] of cases) {
expect(resolveSekAmount(amount, amountSek, currency, rate)).toBe(
resolveSekAmountOrNull(amount, amountSek, currency, rate)
)
}
})
it('handles negative amounts correctly', () => {
expect(resolveSekAmount(-100, null, 'EUR', 11.5)).toBe(-1150)
})
it('prefers amountSek over exchangeRate computation', () => {
// amountSek = 1200, but exchangeRate would give 1150
expect(resolveSekAmount(100, 1200, 'EUR', 11.5)).toBe(1200)
})
it('handles zero amount', () => {
expect(resolveSekAmount(0, null, 'EUR', 11.5)).toBe(0)
})
})
describe('buildCurrencyMetadata', () => {
it('returns empty object for SEK', () => {
expect(buildCurrencyMetadata('SEK', 1000, null)).toEqual({})
})
it('returns empty object for null currency', () => {
expect(buildCurrencyMetadata(null, 1000, null)).toEqual({})
})
it('returns empty object for undefined currency', () => {
expect(buildCurrencyMetadata(undefined, 1000, null)).toEqual({})
})
it('returns currency metadata for foreign currency', () => {
expect(buildCurrencyMetadata('EUR', 100, 11.5)).toEqual({
currency: 'EUR',
amount_in_currency: 100,
exchange_rate: 11.5,
})
})
it('omits amount_in_currency when null', () => {
expect(buildCurrencyMetadata('EUR', null, 11.5)).toEqual({
currency: 'EUR',
exchange_rate: 11.5,
})
})
it('omits exchange_rate when null', () => {
expect(buildCurrencyMetadata('EUR', 100, null)).toEqual({
currency: 'EUR',
amount_in_currency: 100,
})
})
it('omits exchange_rate when 0', () => {
expect(buildCurrencyMetadata('EUR', 100, 0)).toEqual({
currency: 'EUR',
amount_in_currency: 100,
})
})
})