Jakob WennbergandClaude Opus 4.6
a9bf24ce0b
Expand supplier invoice module with overdue cron job, credit note journal entries, and event emissions on approve/mark-paid/create flows. Add entity type (EF/AB) awareness to transaction categorization UI and category mapping logic. Add comprehensive tests for supplier-invoice-entries, transaction-entries, and expanded API route coverage. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
908 lines
30 KiB
TypeScript
908 lines
30 KiB
TypeScript
import { describe, it, expect, vi, beforeEach } from 'vitest'
|
|
import type { SupplierInvoiceItem, CreateJournalEntryLineInput, CreateJournalEntryInput } from '@/types'
|
|
import { makeSupplierInvoice } from '@/tests/helpers'
|
|
|
|
// Mock engine
|
|
vi.mock('../engine', () => ({
|
|
findFiscalPeriod: vi.fn().mockResolvedValue('period-1'),
|
|
createJournalEntry: vi.fn().mockImplementation(
|
|
async (_supabase: unknown, _userId: string, input: CreateJournalEntryInput) => ({
|
|
id: 'entry-1',
|
|
...input,
|
|
lines: input.lines,
|
|
})
|
|
),
|
|
}))
|
|
|
|
// Mock currency-utils with real logic
|
|
vi.mock('../currency-utils', () => ({
|
|
resolveSekAmount: vi.fn().mockImplementation(
|
|
(amount: number, amountSek: number | null, currency: string | null, exchangeRate: number | null) => {
|
|
if (!currency || currency === 'SEK') return amount
|
|
if (amountSek != null) return Math.round(amountSek * 100) / 100
|
|
if (exchangeRate != null && exchangeRate > 0) return Math.round(amount * exchangeRate * 100) / 100
|
|
return amount
|
|
}
|
|
),
|
|
buildCurrencyMetadata: vi.fn().mockImplementation(
|
|
(currency: string | null, amountInCurrency: number | null | undefined, exchangeRate: number | null) => {
|
|
if (!currency || currency === 'SEK') return {}
|
|
return {
|
|
...(currency ? { currency } : {}),
|
|
...(amountInCurrency != null ? { amount_in_currency: amountInCurrency } : {}),
|
|
...(exchangeRate != null && exchangeRate > 0 ? { exchange_rate: exchangeRate } : {}),
|
|
}
|
|
}
|
|
),
|
|
}))
|
|
|
|
// Mock vat-entries with real reverse charge logic
|
|
vi.mock('../vat-entries', () => ({
|
|
generateReverseChargeLines: vi.fn().mockImplementation(
|
|
(baseAmount: number, vatRate: number = 0.25) => {
|
|
const vatAmount = Math.round(baseAmount * vatRate * 100) / 100
|
|
let outputAccount: string
|
|
switch (vatRate) {
|
|
case 0.12: outputAccount = '2624'; break
|
|
case 0.06: outputAccount = '2634'; break
|
|
default: outputAccount = '2614'; break
|
|
}
|
|
return [
|
|
{ account_number: '2645', debit_amount: vatAmount, credit_amount: 0, line_description: `Fiktiv ingående moms ${vatRate * 100}% (omvänd skattskyldighet)` },
|
|
{ account_number: outputAccount, debit_amount: 0, credit_amount: vatAmount, line_description: `Fiktiv utgående moms ${vatRate * 100}% (omvänd skattskyldighet)` },
|
|
]
|
|
}
|
|
),
|
|
}))
|
|
|
|
const { createJournalEntry, findFiscalPeriod } = await import('../engine')
|
|
const mockedCreateEntry = vi.mocked(createJournalEntry)
|
|
const mockedFindFiscalPeriod = vi.mocked(findFiscalPeriod)
|
|
|
|
const {
|
|
createSupplierInvoiceRegistrationEntry,
|
|
createSupplierInvoicePaymentEntry,
|
|
createSupplierInvoiceCashEntry,
|
|
createSupplierCreditNoteEntry,
|
|
} = await import('../supplier-invoice-entries')
|
|
|
|
function makeItem(overrides: Partial<SupplierInvoiceItem> = {}): SupplierInvoiceItem {
|
|
return {
|
|
id: 'si-item-1',
|
|
supplier_invoice_id: 'si-1',
|
|
sort_order: 0,
|
|
description: 'Consulting services',
|
|
quantity: 1,
|
|
unit: 'st',
|
|
unit_price: 8000,
|
|
line_total: 8000,
|
|
account_number: '6200',
|
|
vat_code: null,
|
|
vat_rate: 0.25,
|
|
vat_amount: 2000,
|
|
created_at: '2024-06-01T00:00:00Z',
|
|
...overrides,
|
|
}
|
|
}
|
|
|
|
function findByAccount(lines: CreateJournalEntryLineInput[], account: string) {
|
|
return lines.filter((l) => l.account_number === account)
|
|
}
|
|
|
|
/** Balance check helper */
|
|
function assertBalanced(input: CreateJournalEntryInput) {
|
|
const totalDebit = input.lines.reduce((sum, l) => sum + l.debit_amount, 0)
|
|
const totalCredit = input.lines.reduce((sum, l) => sum + l.credit_amount, 0)
|
|
expect(Math.round(totalDebit * 100)).toBe(Math.round(totalCredit * 100))
|
|
expect(totalDebit).toBeGreaterThan(0)
|
|
}
|
|
|
|
// ============================================================
|
|
// createSupplierInvoiceRegistrationEntry
|
|
// ============================================================
|
|
|
|
describe('createSupplierInvoiceRegistrationEntry', () => {
|
|
beforeEach(() => {
|
|
vi.clearAllMocks()
|
|
mockedFindFiscalPeriod.mockResolvedValue('period-1')
|
|
})
|
|
|
|
it('returns null when no fiscal period found', async () => {
|
|
mockedFindFiscalPeriod.mockResolvedValue(null)
|
|
const invoice = makeSupplierInvoice()
|
|
const items = [makeItem()]
|
|
|
|
const result = await createSupplierInvoiceRegistrationEntry(
|
|
null as never, 'user-1', invoice, items, 'swedish_business'
|
|
)
|
|
|
|
expect(result).toBeNull()
|
|
expect(mockedCreateEntry).not.toHaveBeenCalled()
|
|
})
|
|
|
|
it('creates domestic entry with VAT (D expense + D 2641 + C 2440)', async () => {
|
|
const invoice = makeSupplierInvoice({
|
|
subtotal: 8000,
|
|
vat_amount: 2000,
|
|
total: 10000,
|
|
})
|
|
const items = [makeItem({ line_total: 8000, account_number: '6200', vat_rate: 0.25 })]
|
|
|
|
await createSupplierInvoiceRegistrationEntry(
|
|
null as never, 'user-1', invoice, items, 'swedish_business'
|
|
)
|
|
|
|
expect(mockedCreateEntry).toHaveBeenCalledOnce()
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
|
|
const debit6200 = findByAccount(input.lines, '6200')
|
|
expect(debit6200).toHaveLength(1)
|
|
expect(debit6200[0].debit_amount).toBe(8000)
|
|
|
|
const debit2641 = findByAccount(input.lines, '2641')
|
|
expect(debit2641).toHaveLength(1)
|
|
expect(debit2641[0].debit_amount).toBe(2000) // 8000 * 0.25
|
|
|
|
const credit2440 = findByAccount(input.lines, '2440')
|
|
expect(credit2440).toHaveLength(1)
|
|
expect(credit2440[0].credit_amount).toBe(10000) // 8000 + 2000
|
|
|
|
assertBalanced(input)
|
|
})
|
|
|
|
it('creates domestic entry with zero VAT (no 2641 line)', async () => {
|
|
const invoice = makeSupplierInvoice({
|
|
subtotal: 5000,
|
|
vat_amount: 0,
|
|
total: 5000,
|
|
})
|
|
const items = [makeItem({ line_total: 5000, account_number: '5410', vat_rate: 0 })]
|
|
|
|
await createSupplierInvoiceRegistrationEntry(
|
|
null as never, 'user-1', invoice, items, 'swedish_business'
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
|
|
const debit5410 = findByAccount(input.lines, '5410')
|
|
expect(debit5410).toHaveLength(1)
|
|
expect(debit5410[0].debit_amount).toBe(5000)
|
|
|
|
const credit2440 = findByAccount(input.lines, '2440')
|
|
expect(credit2440[0].credit_amount).toBe(5000)
|
|
|
|
expect(findByAccount(input.lines, '2641')).toHaveLength(0)
|
|
|
|
assertBalanced(input)
|
|
})
|
|
|
|
it('creates EU reverse charge entry at 25%', async () => {
|
|
const invoice = makeSupplierInvoice({
|
|
subtotal: 10000,
|
|
vat_amount: 0,
|
|
total: 10000,
|
|
reverse_charge: true,
|
|
})
|
|
const items = [makeItem({ line_total: 10000, account_number: '6540', vat_rate: 0.25 })]
|
|
|
|
await createSupplierInvoiceRegistrationEntry(
|
|
null as never, 'user-1', invoice, items, 'eu_business'
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
|
|
const debit6540 = findByAccount(input.lines, '6540')
|
|
expect(debit6540[0].debit_amount).toBe(10000)
|
|
|
|
const debit2645 = findByAccount(input.lines, '2645')
|
|
expect(debit2645).toHaveLength(1)
|
|
expect(debit2645[0].debit_amount).toBe(2500) // 10000 * 0.25
|
|
|
|
const credit2614 = findByAccount(input.lines, '2614')
|
|
expect(credit2614).toHaveLength(1)
|
|
expect(credit2614[0].credit_amount).toBe(2500)
|
|
|
|
const credit2440 = findByAccount(input.lines, '2440')
|
|
// 2440 = totalDebits - totalCredits = (10000 + 2500) - 2500 = 10000
|
|
// The fiktiv moms (D 2645 / C 2614) are offsetting; 2440 only reflects actual supplier debt
|
|
expect(credit2440[0].credit_amount).toBe(10000)
|
|
|
|
assertBalanced(input)
|
|
})
|
|
|
|
it('creates EU reverse charge entry at reduced 12%', async () => {
|
|
const invoice = makeSupplierInvoice({
|
|
subtotal: 5000,
|
|
vat_amount: 0,
|
|
total: 5000,
|
|
reverse_charge: true,
|
|
})
|
|
const items = [makeItem({ line_total: 5000, account_number: '6540', vat_rate: 0.12 })]
|
|
|
|
await createSupplierInvoiceRegistrationEntry(
|
|
null as never, 'user-1', invoice, items, 'eu_business'
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
|
|
const debit2645 = findByAccount(input.lines, '2645')
|
|
expect(debit2645[0].debit_amount).toBe(600) // 5000 * 0.12
|
|
|
|
const credit2624 = findByAccount(input.lines, '2624')
|
|
expect(credit2624).toHaveLength(1)
|
|
expect(credit2624[0].credit_amount).toBe(600)
|
|
|
|
assertBalanced(input)
|
|
})
|
|
|
|
it('handles multi-item with different accounts', async () => {
|
|
const invoice = makeSupplierInvoice({
|
|
subtotal: 8000,
|
|
vat_amount: 2000,
|
|
total: 10000,
|
|
})
|
|
const items = [
|
|
makeItem({ id: 'item-1', line_total: 3000, account_number: '5410', vat_rate: 0.25 }),
|
|
makeItem({ id: 'item-2', line_total: 5000, account_number: '6200', vat_rate: 0.25 }),
|
|
]
|
|
|
|
await createSupplierInvoiceRegistrationEntry(
|
|
null as never, 'user-1', invoice, items, 'swedish_business'
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
|
|
const debit5410 = findByAccount(input.lines, '5410')
|
|
expect(debit5410[0].debit_amount).toBe(3000)
|
|
|
|
const debit6200 = findByAccount(input.lines, '6200')
|
|
expect(debit6200[0].debit_amount).toBe(5000)
|
|
|
|
const debit2641 = findByAccount(input.lines, '2641')
|
|
expect(debit2641[0].debit_amount).toBe(2000) // (3000 + 5000) * 0.25
|
|
|
|
assertBalanced(input)
|
|
})
|
|
|
|
it('aggregates multi-item with same account', async () => {
|
|
const invoice = makeSupplierInvoice({
|
|
subtotal: 5000,
|
|
vat_amount: 1250,
|
|
total: 6250,
|
|
})
|
|
const items = [
|
|
makeItem({ id: 'item-1', line_total: 3000, account_number: '6200', vat_rate: 0.25 }),
|
|
makeItem({ id: 'item-2', line_total: 2000, account_number: '6200', vat_rate: 0.25 }),
|
|
]
|
|
|
|
await createSupplierInvoiceRegistrationEntry(
|
|
null as never, 'user-1', invoice, items, 'swedish_business'
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
|
|
const lines6200 = findByAccount(input.lines, '6200')
|
|
expect(lines6200).toHaveLength(1)
|
|
expect(lines6200[0].debit_amount).toBe(5000) // 3000 + 2000
|
|
|
|
assertBalanced(input)
|
|
})
|
|
|
|
it('creates per-rate 2641 lines for mixed-rate domestic invoice', async () => {
|
|
const invoice = makeSupplierInvoice({
|
|
subtotal: 18000,
|
|
vat_amount: 3280,
|
|
total: 21280,
|
|
})
|
|
const items = [
|
|
makeItem({ id: 'item-1', account_number: '4010', line_total: 10000, vat_rate: 0.25 }),
|
|
makeItem({ id: 'item-2', account_number: '5410', line_total: 5000, vat_rate: 0.12 }),
|
|
makeItem({ id: 'item-3', account_number: '6200', line_total: 3000, vat_rate: 0.06 }),
|
|
]
|
|
|
|
await createSupplierInvoiceRegistrationEntry(
|
|
null as never, 'user-1', invoice, items, 'swedish_business'
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
const vat2641 = findByAccount(input.lines, '2641')
|
|
expect(vat2641).toHaveLength(3)
|
|
|
|
// 25%: 10000 * 0.25 = 2500
|
|
expect(vat2641.find((l) => l.line_description.includes('25%'))?.debit_amount).toBe(2500)
|
|
// 12%: 5000 * 0.12 = 600
|
|
expect(vat2641.find((l) => l.line_description.includes('12%'))?.debit_amount).toBe(600)
|
|
// 6%: 3000 * 0.06 = 180
|
|
expect(vat2641.find((l) => l.line_description.includes('6%'))?.debit_amount).toBe(180)
|
|
|
|
assertBalanced(input)
|
|
})
|
|
|
|
it('adds foreign currency metadata on 2440 line', async () => {
|
|
const invoice = makeSupplierInvoice({
|
|
currency: 'EUR',
|
|
exchange_rate: 11.50,
|
|
subtotal: 800,
|
|
vat_amount: 0,
|
|
total: 800,
|
|
})
|
|
const items = [makeItem({ line_total: 800, account_number: '6200', vat_rate: 0 })]
|
|
|
|
await createSupplierInvoiceRegistrationEntry(
|
|
null as never, 'user-1', invoice, items, 'swedish_business'
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
const credit2440 = findByAccount(input.lines, '2440')[0]
|
|
expect(credit2440.currency).toBe('EUR')
|
|
expect(credit2440.amount_in_currency).toBe(800)
|
|
expect(credit2440.exchange_rate).toBe(11.50)
|
|
})
|
|
|
|
it('sets source_type to supplier_invoice_registered', async () => {
|
|
const invoice = makeSupplierInvoice({ id: 'si-xyz' })
|
|
const items = [makeItem()]
|
|
|
|
await createSupplierInvoiceRegistrationEntry(
|
|
null as never, 'user-1', invoice, items, 'swedish_business'
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
expect(input.source_type).toBe('supplier_invoice_registered')
|
|
expect(input.source_id).toBe('si-xyz')
|
|
})
|
|
|
|
it('description includes invoice number and arrival number', async () => {
|
|
const invoice = makeSupplierInvoice({
|
|
supplier_invoice_number: 'LF-999',
|
|
arrival_number: 42,
|
|
})
|
|
const items = [makeItem()]
|
|
|
|
await createSupplierInvoiceRegistrationEntry(
|
|
null as never, 'user-1', invoice, items, 'swedish_business'
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
expect(input.description).toContain('LF-999')
|
|
expect(input.description).toContain('42')
|
|
})
|
|
|
|
it('handles non-EU reverse charge (services)', async () => {
|
|
const invoice = makeSupplierInvoice({
|
|
subtotal: 5000,
|
|
vat_amount: 0,
|
|
total: 5000,
|
|
reverse_charge: true,
|
|
})
|
|
const items = [makeItem({ line_total: 5000, vat_rate: 0.25, account_number: '6540' })]
|
|
|
|
await createSupplierInvoiceRegistrationEntry(
|
|
null as never, 'user-1', invoice, items, 'non_eu_business'
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
|
|
expect(findByAccount(input.lines, '2645')).toHaveLength(1)
|
|
expect(findByAccount(input.lines, '2614')).toHaveLength(1)
|
|
expect(findByAccount(input.lines, '2641')).toHaveLength(0)
|
|
|
|
assertBalanced(input)
|
|
})
|
|
|
|
it('creates per-rate 2645/26x4 pairs for mixed-rate reverse charge', async () => {
|
|
const invoice = makeSupplierInvoice({
|
|
subtotal: 15000,
|
|
vat_amount: 0,
|
|
total: 15000,
|
|
reverse_charge: true,
|
|
})
|
|
const items = [
|
|
makeItem({ line_total: 10000, vat_rate: 0.25, account_number: '6540' }),
|
|
makeItem({ id: 'item-2', line_total: 5000, vat_rate: 0.12, account_number: '5410' }),
|
|
]
|
|
|
|
await createSupplierInvoiceRegistrationEntry(
|
|
null as never, 'user-1', invoice, items, 'eu_business'
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
|
|
const vat2645 = findByAccount(input.lines, '2645')
|
|
expect(vat2645).toHaveLength(2)
|
|
|
|
// 25%: 2614
|
|
expect(findByAccount(input.lines, '2614')[0].credit_amount).toBe(2500)
|
|
// 12%: 2624
|
|
expect(findByAccount(input.lines, '2624')[0].credit_amount).toBe(600)
|
|
|
|
assertBalanced(input)
|
|
})
|
|
})
|
|
|
|
// ============================================================
|
|
// createSupplierInvoicePaymentEntry
|
|
// ============================================================
|
|
|
|
describe('createSupplierInvoicePaymentEntry', () => {
|
|
beforeEach(() => {
|
|
vi.clearAllMocks()
|
|
mockedFindFiscalPeriod.mockResolvedValue('period-1')
|
|
})
|
|
|
|
it('returns null when no fiscal period found', async () => {
|
|
mockedFindFiscalPeriod.mockResolvedValue(null)
|
|
const invoice = makeSupplierInvoice()
|
|
|
|
const result = await createSupplierInvoicePaymentEntry(
|
|
null as never, 'user-1', invoice, 10000, '2024-07-01'
|
|
)
|
|
|
|
expect(result).toBeNull()
|
|
expect(mockedCreateEntry).not.toHaveBeenCalled()
|
|
})
|
|
|
|
it('creates standard SEK payment (2 lines)', async () => {
|
|
const invoice = makeSupplierInvoice({ total: 10000 })
|
|
|
|
await createSupplierInvoicePaymentEntry(
|
|
null as never, 'user-1', invoice, 10000, '2024-07-01'
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
expect(input.lines).toHaveLength(2)
|
|
|
|
const debit2440 = findByAccount(input.lines, '2440')[0]
|
|
expect(debit2440.debit_amount).toBe(10000)
|
|
|
|
const credit1930 = findByAccount(input.lines, '1930')[0]
|
|
expect(credit1930.credit_amount).toBe(10000)
|
|
|
|
assertBalanced(input)
|
|
})
|
|
|
|
it('creates entry with FX gain (credit 3960)', async () => {
|
|
const invoice = makeSupplierInvoice({ total: 11500, currency: 'EUR' })
|
|
|
|
// paymentAmount = original SEK amount, exchangeRateDifference > 0 = gain
|
|
await createSupplierInvoicePaymentEntry(
|
|
null as never, 'user-1', invoice, 11500, '2024-07-15', 500
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
expect(input.lines).toHaveLength(3)
|
|
|
|
const debit2440 = findByAccount(input.lines, '2440')[0]
|
|
expect(debit2440.debit_amount).toBe(11500)
|
|
|
|
const credit1930 = findByAccount(input.lines, '1930')[0]
|
|
expect(credit1930.credit_amount).toBe(11000) // 11500 - 500
|
|
|
|
const credit3960 = findByAccount(input.lines, '3960')[0]
|
|
expect(credit3960.credit_amount).toBe(500)
|
|
|
|
assertBalanced(input)
|
|
})
|
|
|
|
it('creates entry with FX loss (debit 7960)', async () => {
|
|
const invoice = makeSupplierInvoice({ total: 11500, currency: 'EUR' })
|
|
|
|
// exchangeRateDifference < 0 = loss
|
|
await createSupplierInvoicePaymentEntry(
|
|
null as never, 'user-1', invoice, 11500, '2024-07-15', -300
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
expect(input.lines).toHaveLength(3)
|
|
|
|
const debit2440 = findByAccount(input.lines, '2440')[0]
|
|
expect(debit2440.debit_amount).toBe(11500)
|
|
|
|
const credit1930 = findByAccount(input.lines, '1930')[0]
|
|
expect(credit1930.credit_amount).toBe(11800) // 11500 - (-300)
|
|
|
|
const debit7960 = findByAccount(input.lines, '7960')[0]
|
|
expect(debit7960.debit_amount).toBe(300)
|
|
|
|
assertBalanced(input)
|
|
})
|
|
|
|
it('exchangeRateDifference=0 creates standard 2-line entry', async () => {
|
|
const invoice = makeSupplierInvoice()
|
|
|
|
await createSupplierInvoicePaymentEntry(
|
|
null as never, 'user-1', invoice, 10000, '2024-07-01', 0
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
expect(input.lines).toHaveLength(2)
|
|
|
|
expect(findByAccount(input.lines, '3960')).toHaveLength(0)
|
|
expect(findByAccount(input.lines, '7960')).toHaveLength(0)
|
|
|
|
assertBalanced(input)
|
|
})
|
|
|
|
it('rounds amounts to 2 decimal places', async () => {
|
|
const invoice = makeSupplierInvoice()
|
|
|
|
await createSupplierInvoicePaymentEntry(
|
|
null as never, 'user-1', invoice, 10000.555, '2024-07-01'
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
for (const line of input.lines) {
|
|
if (line.debit_amount > 0) {
|
|
expect(line.debit_amount).toBe(Math.round(10000.555 * 100) / 100)
|
|
}
|
|
if (line.credit_amount > 0) {
|
|
expect(line.credit_amount).toBe(Math.round(10000.555 * 100) / 100)
|
|
}
|
|
}
|
|
})
|
|
|
|
it('sets source_type to supplier_invoice_paid', async () => {
|
|
const invoice = makeSupplierInvoice({ id: 'si-pay-1' })
|
|
|
|
await createSupplierInvoicePaymentEntry(
|
|
null as never, 'user-1', invoice, 10000, '2024-07-01'
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
expect(input.source_type).toBe('supplier_invoice_paid')
|
|
expect(input.source_id).toBe('si-pay-1')
|
|
})
|
|
|
|
it('uses paymentDate not invoice_date as entry_date', async () => {
|
|
const invoice = makeSupplierInvoice({ invoice_date: '2024-06-01' })
|
|
|
|
await createSupplierInvoicePaymentEntry(
|
|
null as never, 'user-1', invoice, 10000, '2024-08-15'
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
expect(input.entry_date).toBe('2024-08-15')
|
|
})
|
|
})
|
|
|
|
// ============================================================
|
|
// createSupplierInvoiceCashEntry
|
|
// ============================================================
|
|
|
|
describe('createSupplierInvoiceCashEntry', () => {
|
|
beforeEach(() => {
|
|
vi.clearAllMocks()
|
|
mockedFindFiscalPeriod.mockResolvedValue('period-1')
|
|
})
|
|
|
|
it('returns null when no fiscal period found', async () => {
|
|
mockedFindFiscalPeriod.mockResolvedValue(null)
|
|
const invoice = makeSupplierInvoice()
|
|
const items = [makeItem()]
|
|
|
|
const result = await createSupplierInvoiceCashEntry(
|
|
null as never, 'user-1', invoice, items, '2024-07-01', 'swedish_business'
|
|
)
|
|
|
|
expect(result).toBeNull()
|
|
expect(mockedCreateEntry).not.toHaveBeenCalled()
|
|
})
|
|
|
|
it('domestic with VAT — credits 1930 (not 2440)', async () => {
|
|
const invoice = makeSupplierInvoice({
|
|
subtotal: 8000,
|
|
vat_amount: 2000,
|
|
total: 10000,
|
|
})
|
|
const items = [makeItem({ line_total: 8000, account_number: '6200', vat_rate: 0.25 })]
|
|
|
|
await createSupplierInvoiceCashEntry(
|
|
null as never, 'user-1', invoice, items, '2024-07-01', 'swedish_business'
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
|
|
expect(findByAccount(input.lines, '6200')[0].debit_amount).toBe(8000)
|
|
expect(findByAccount(input.lines, '2641')[0].debit_amount).toBe(2000)
|
|
|
|
const credit1930 = findByAccount(input.lines, '1930')
|
|
expect(credit1930).toHaveLength(1)
|
|
expect(credit1930[0].credit_amount).toBe(10000)
|
|
|
|
assertBalanced(input)
|
|
})
|
|
|
|
it('domestic zero VAT', async () => {
|
|
const invoice = makeSupplierInvoice({
|
|
subtotal: 5000,
|
|
vat_amount: 0,
|
|
total: 5000,
|
|
})
|
|
const items = [makeItem({ line_total: 5000, account_number: '5410', vat_rate: 0 })]
|
|
|
|
await createSupplierInvoiceCashEntry(
|
|
null as never, 'user-1', invoice, items, '2024-07-01', 'swedish_business'
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
|
|
expect(findByAccount(input.lines, '5410')[0].debit_amount).toBe(5000)
|
|
expect(findByAccount(input.lines, '1930')[0].credit_amount).toBe(5000)
|
|
expect(findByAccount(input.lines, '2641')).toHaveLength(0)
|
|
|
|
assertBalanced(input)
|
|
})
|
|
|
|
it('EU reverse charge — credits 1930', async () => {
|
|
const invoice = makeSupplierInvoice({
|
|
subtotal: 10000,
|
|
vat_amount: 0,
|
|
total: 10000,
|
|
reverse_charge: true,
|
|
})
|
|
const items = [makeItem({ line_total: 10000, account_number: '6540', vat_rate: 0.25 })]
|
|
|
|
await createSupplierInvoiceCashEntry(
|
|
null as never, 'user-1', invoice, items, '2024-07-01', 'eu_business'
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
|
|
expect(findByAccount(input.lines, '2645')[0].debit_amount).toBe(2500)
|
|
expect(findByAccount(input.lines, '2614')[0].credit_amount).toBe(2500)
|
|
|
|
const credit1930 = findByAccount(input.lines, '1930')
|
|
expect(credit1930).toHaveLength(1)
|
|
// 1930 = totalDebits - totalCredits = (10000 + 2500) - 2500 = 10000
|
|
// Fiktiv moms entries are offsetting; bank payment equals actual invoice amount
|
|
expect(credit1930[0].credit_amount).toBe(10000)
|
|
|
|
assertBalanced(input)
|
|
})
|
|
|
|
it('has no 2440 line', async () => {
|
|
const invoice = makeSupplierInvoice()
|
|
const items = [makeItem()]
|
|
|
|
await createSupplierInvoiceCashEntry(
|
|
null as never, 'user-1', invoice, items, '2024-07-01', 'swedish_business'
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
expect(findByAccount(input.lines, '2440')).toHaveLength(0)
|
|
})
|
|
|
|
it('creates per-rate 2641 lines for mixed-rate domestic cash entry', async () => {
|
|
const invoice = makeSupplierInvoice({ vat_amount: 2680, total: 15680 })
|
|
const items = [
|
|
makeItem({ line_total: 10000, vat_rate: 0.25 }),
|
|
makeItem({ id: 'item-2', line_total: 3000, vat_rate: 0.06, account_number: '5410' }),
|
|
]
|
|
|
|
await createSupplierInvoiceCashEntry(
|
|
null as never, 'user-1', invoice, items, '2024-06-01', 'swedish_business'
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
const vat2641 = findByAccount(input.lines, '2641')
|
|
expect(vat2641).toHaveLength(2)
|
|
expect(vat2641.find((l) => l.line_description.includes('25%'))?.debit_amount).toBe(2500)
|
|
expect(vat2641.find((l) => l.line_description.includes('6%'))?.debit_amount).toBe(180)
|
|
|
|
assertBalanced(input)
|
|
})
|
|
|
|
it('sets source_type to supplier_invoice_cash_payment', async () => {
|
|
const invoice = makeSupplierInvoice({ id: 'si-cash-1' })
|
|
const items = [makeItem()]
|
|
|
|
await createSupplierInvoiceCashEntry(
|
|
null as never, 'user-1', invoice, items, '2024-07-01', 'swedish_business'
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
expect(input.source_type).toBe('supplier_invoice_cash_payment')
|
|
expect(input.source_id).toBe('si-cash-1')
|
|
})
|
|
|
|
it('description contains "kontantmetoden"', async () => {
|
|
const invoice = makeSupplierInvoice()
|
|
const items = [makeItem()]
|
|
|
|
await createSupplierInvoiceCashEntry(
|
|
null as never, 'user-1', invoice, items, '2024-07-01', 'swedish_business'
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
expect(input.description).toContain('kontantmetoden')
|
|
})
|
|
})
|
|
|
|
// ============================================================
|
|
// createSupplierCreditNoteEntry
|
|
// ============================================================
|
|
|
|
describe('createSupplierCreditNoteEntry', () => {
|
|
beforeEach(() => {
|
|
vi.clearAllMocks()
|
|
mockedFindFiscalPeriod.mockResolvedValue('period-1')
|
|
})
|
|
|
|
it('returns null when no fiscal period found', async () => {
|
|
mockedFindFiscalPeriod.mockResolvedValue(null)
|
|
const creditNote = makeSupplierInvoice({ is_credit_note: true })
|
|
const items = [makeItem()]
|
|
|
|
const result = await createSupplierCreditNoteEntry(
|
|
null as never, 'user-1', creditNote, items, 'swedish_business'
|
|
)
|
|
|
|
expect(result).toBeNull()
|
|
expect(mockedCreateEntry).not.toHaveBeenCalled()
|
|
})
|
|
|
|
it('domestic: D 2440, C expense, C 2641', async () => {
|
|
const creditNote = makeSupplierInvoice({
|
|
is_credit_note: true,
|
|
subtotal: -8000,
|
|
vat_amount: -2000,
|
|
total: -10000,
|
|
})
|
|
const items = [makeItem({ line_total: -8000, account_number: '6200', vat_rate: 0.25 })]
|
|
|
|
await createSupplierCreditNoteEntry(
|
|
null as never, 'user-1', creditNote, items, 'swedish_business'
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
|
|
const debit2440 = findByAccount(input.lines, '2440')[0]
|
|
expect(debit2440.debit_amount).toBe(10000) // abs
|
|
expect(debit2440.credit_amount).toBe(0)
|
|
|
|
const credit6200 = findByAccount(input.lines, '6200')[0]
|
|
expect(credit6200.credit_amount).toBe(8000) // abs
|
|
expect(credit6200.debit_amount).toBe(0)
|
|
|
|
const credit2641 = findByAccount(input.lines, '2641')[0]
|
|
expect(credit2641.credit_amount).toBe(2000) // abs(8000) * 0.25
|
|
expect(credit2641.debit_amount).toBe(0)
|
|
|
|
assertBalanced(input)
|
|
})
|
|
|
|
it('domestic zero VAT', async () => {
|
|
const creditNote = makeSupplierInvoice({
|
|
is_credit_note: true,
|
|
subtotal: -5000,
|
|
vat_amount: 0,
|
|
total: -5000,
|
|
})
|
|
const items = [makeItem({ line_total: -5000, account_number: '6200', vat_rate: 0 })]
|
|
|
|
await createSupplierCreditNoteEntry(
|
|
null as never, 'user-1', creditNote, items, 'swedish_business'
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
|
|
expect(findByAccount(input.lines, '2440')[0].debit_amount).toBe(5000)
|
|
expect(findByAccount(input.lines, '6200')[0].credit_amount).toBe(5000)
|
|
expect(findByAccount(input.lines, '2641')).toHaveLength(0)
|
|
|
|
assertBalanced(input)
|
|
})
|
|
|
|
it('EU reverse charge reversal (C 2645, D 2614)', async () => {
|
|
const creditNote = makeSupplierInvoice({
|
|
is_credit_note: true,
|
|
subtotal: -10000,
|
|
vat_amount: 0,
|
|
total: -10000,
|
|
reverse_charge: true,
|
|
})
|
|
const items = [makeItem({ line_total: -10000, account_number: '6540', vat_rate: 0.25 })]
|
|
|
|
await createSupplierCreditNoteEntry(
|
|
null as never, 'user-1', creditNote, items, 'eu_business'
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
|
|
// Reversed fiktiv moms
|
|
const credit2645 = findByAccount(input.lines, '2645')[0]
|
|
expect(credit2645.credit_amount).toBe(2500) // abs(10000) * 0.25
|
|
expect(credit2645.debit_amount).toBe(0)
|
|
|
|
const debit2614 = findByAccount(input.lines, '2614')[0]
|
|
expect(debit2614.debit_amount).toBe(2500)
|
|
expect(debit2614.credit_amount).toBe(0)
|
|
|
|
const credit6540 = findByAccount(input.lines, '6540')[0]
|
|
expect(credit6540.credit_amount).toBe(10000)
|
|
|
|
const debit2440 = findByAccount(input.lines, '2440')[0]
|
|
expect(debit2440.debit_amount).toBe(10000) // totalCredits - totalDebits = (2500 + 10000) - 2500
|
|
|
|
assertBalanced(input)
|
|
})
|
|
|
|
it('uses Math.abs for all amounts (negative inputs produce positive lines)', async () => {
|
|
const creditNote = makeSupplierInvoice({
|
|
is_credit_note: true,
|
|
total: -7500,
|
|
vat_amount: 0,
|
|
})
|
|
const items = [makeItem({ line_total: -7500, account_number: '6200', vat_rate: 0 })]
|
|
|
|
await createSupplierCreditNoteEntry(
|
|
null as never, 'user-1', creditNote, items, 'swedish_business'
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
for (const line of input.lines) {
|
|
expect(line.debit_amount).toBeGreaterThanOrEqual(0)
|
|
expect(line.credit_amount).toBeGreaterThanOrEqual(0)
|
|
}
|
|
})
|
|
|
|
it('2440 line is first (unshift)', async () => {
|
|
const creditNote = makeSupplierInvoice({
|
|
is_credit_note: true,
|
|
total: -10000,
|
|
vat_amount: -2000,
|
|
})
|
|
const items = [makeItem({ line_total: -8000, account_number: '6200', vat_rate: 0.25 })]
|
|
|
|
await createSupplierCreditNoteEntry(
|
|
null as never, 'user-1', creditNote, items, 'swedish_business'
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
expect(input.lines[0].account_number).toBe('2440')
|
|
})
|
|
|
|
it('sets source_type to supplier_credit_note', async () => {
|
|
const creditNote = makeSupplierInvoice({ id: 'si-cn-1', is_credit_note: true })
|
|
const items = [makeItem()]
|
|
|
|
await createSupplierCreditNoteEntry(
|
|
null as never, 'user-1', creditNote, items, 'swedish_business'
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
expect(input.source_type).toBe('supplier_credit_note')
|
|
expect(input.source_id).toBe('si-cn-1')
|
|
})
|
|
|
|
it('reverses mixed-rate reverse charge with correct per-rate accounts', async () => {
|
|
const creditNote = makeSupplierInvoice({
|
|
is_credit_note: true,
|
|
vat_amount: 0,
|
|
total: -15000,
|
|
reverse_charge: true,
|
|
})
|
|
const items = [
|
|
makeItem({ line_total: -10000, vat_rate: 0.25, account_number: '6540' }),
|
|
makeItem({ id: 'item-2', line_total: -5000, vat_rate: 0.12, account_number: '5410' }),
|
|
]
|
|
|
|
await createSupplierCreditNoteEntry(
|
|
null as never, 'user-1', creditNote, items, 'eu_business'
|
|
)
|
|
|
|
const input = mockedCreateEntry.mock.calls[0][2]
|
|
|
|
// 2645 credit lines: 2 (one per rate)
|
|
const vat2645 = findByAccount(input.lines, '2645')
|
|
expect(vat2645).toHaveLength(2)
|
|
|
|
// 2614 debit (25%): abs(10000) * 0.25 = 2500
|
|
expect(findByAccount(input.lines, '2614')[0].debit_amount).toBe(2500)
|
|
// 2624 debit (12%): abs(5000) * 0.12 = 600
|
|
expect(findByAccount(input.lines, '2624')[0].debit_amount).toBe(600)
|
|
|
|
assertBalanced(input)
|
|
})
|
|
})
|