Å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.
598 lines
21 KiB
TypeScript
598 lines
21 KiB
TypeScript
import { describe, it, expect, beforeEach, vi } from 'vitest'
|
|
import {
|
|
createMockRequest,
|
|
parseJsonResponse,
|
|
createQueuedMockSupabase,
|
|
} from '@/tests/helpers'
|
|
|
|
const { supabase: mockSupabase, enqueue, reset } = createQueuedMockSupabase()
|
|
vi.mock('@/lib/supabase/server', () => ({
|
|
createClient: () => Promise.resolve(mockSupabase),
|
|
}))
|
|
|
|
vi.mock('@/lib/events/bus', () => ({
|
|
eventBus: { emit: vi.fn().mockResolvedValue(undefined) },
|
|
}))
|
|
|
|
vi.mock('@/lib/init', () => ({
|
|
ensureInitialized: vi.fn(),
|
|
}))
|
|
|
|
vi.mock('@/lib/company/context', () => ({
|
|
requireCompanyId: vi.fn().mockResolvedValue('company-1'),
|
|
getActiveCompanyId: vi.fn().mockResolvedValue('company-1'),
|
|
}))
|
|
|
|
vi.mock('@/lib/auth/require-write', () => ({
|
|
requireWritePermission: vi.fn().mockResolvedValue({ ok: true }),
|
|
}))
|
|
|
|
// applyTemplate is the pure ratio/VAT expander used by the route. The
|
|
// route test stubs it so we don't need a real template object.
|
|
vi.mock('@/lib/bookkeeping/template-library', () => ({
|
|
applyTemplate: vi.fn(),
|
|
}))
|
|
|
|
// Stubbed so the queued mock stays aligned with the route's own
|
|
// queries; the helper's behaviour is covered in
|
|
// lib/transactions/__tests__/inbox-underlag.test.ts.
|
|
vi.mock('@/lib/transactions/inbox-underlag', () => ({
|
|
propagateUnderlagForBookedTransaction: vi.fn().mockResolvedValue(undefined),
|
|
}))
|
|
|
|
// The booking-time duplicate guard runs several queries of its own per tx;
|
|
// stubbing it keeps the queued supabase mock aligned with the route's queries.
|
|
// Detection behaviour is covered in
|
|
// lib/transactions/__tests__/booking-duplicate-detection.test.ts.
|
|
vi.mock('@/lib/transactions/booking-duplicate-detection', () => ({
|
|
detectBookingDuplicate: vi.fn().mockResolvedValue(null),
|
|
}))
|
|
vi.mock('@/lib/processing-history/append', () => ({
|
|
appendProcessingHistory: vi.fn().mockResolvedValue(undefined),
|
|
}))
|
|
|
|
import { POST } from '../route'
|
|
import { applyTemplate } from '@/lib/bookkeeping/template-library'
|
|
import { propagateUnderlagForBookedTransaction } from '@/lib/transactions/inbox-underlag'
|
|
import { detectBookingDuplicate } from '@/lib/transactions/booking-duplicate-detection'
|
|
import { appendProcessingHistory } from '@/lib/processing-history/append'
|
|
import type { BookedDuplicateCandidate } from '@/lib/transactions/booking-duplicate-detection'
|
|
|
|
const TX1 = '11111111-1111-4111-8111-111111111111'
|
|
const TX2 = '22222222-2222-4222-8222-222222222222'
|
|
const TPL = '33333333-3333-4333-8333-333333333333'
|
|
const JE = '44444444-4444-4444-8444-444444444444'
|
|
|
|
describe('POST /api/transactions/bulk-book', () => {
|
|
const mockUser = { id: 'user-1', email: 'test@test.se' }
|
|
|
|
beforeEach(() => {
|
|
vi.clearAllMocks()
|
|
reset()
|
|
mockSupabase.auth.getUser.mockResolvedValue({ data: { user: mockUser } })
|
|
vi.mocked(detectBookingDuplicate).mockResolvedValue(null)
|
|
})
|
|
|
|
it('returns 401 when unauthenticated', async () => {
|
|
mockSupabase.auth.getUser.mockResolvedValue({ data: { user: null }, error: null })
|
|
const request = createMockRequest('/api/transactions/bulk-book', {
|
|
method: 'POST',
|
|
body: { tx_ids: [TX1], existing_journal_entry_id: JE },
|
|
})
|
|
const response = await POST(request)
|
|
expect(response.status).toBe(401)
|
|
})
|
|
|
|
it('returns 400 when neither template_id nor existing_journal_entry_id is set', async () => {
|
|
const request = createMockRequest('/api/transactions/bulk-book', {
|
|
method: 'POST',
|
|
body: { tx_ids: [TX1] },
|
|
})
|
|
const response = await POST(request)
|
|
expect(response.status).toBe(400)
|
|
})
|
|
|
|
it('returns 400 when both template_id and existing_journal_entry_id are set', async () => {
|
|
const request = createMockRequest('/api/transactions/bulk-book', {
|
|
method: 'POST',
|
|
body: {
|
|
tx_ids: [TX1],
|
|
template_id: TPL,
|
|
existing_journal_entry_id: JE,
|
|
mode: 'one_line_per_tx',
|
|
entry_description: 'Test',
|
|
},
|
|
})
|
|
const response = await POST(request)
|
|
expect(response.status).toBe(400)
|
|
})
|
|
|
|
it('link path passes through to RPC and returns the success envelope', async () => {
|
|
// Currency gate tx fetch (hoisted: runs on every path).
|
|
enqueue({
|
|
data: [
|
|
{ id: TX1, amount: 100, currency: 'SEK', description: 'Swish 1', date: '2026-06-05' },
|
|
{ id: TX2, amount: 200, currency: 'SEK', description: 'Swish 2', date: '2026-06-05' },
|
|
],
|
|
error: null,
|
|
})
|
|
// RPC returns the link-existing happy path.
|
|
enqueue({
|
|
data: {
|
|
ok: true,
|
|
mode: 'link_existing',
|
|
journal_entry_id: JE,
|
|
voucher_series: 'A',
|
|
voucher_number: 12,
|
|
linked_tx_count: 2,
|
|
tx_sum: 300,
|
|
},
|
|
error: null,
|
|
})
|
|
// Event re-fetch (empty is fine for the test).
|
|
enqueue({ data: [], error: null })
|
|
|
|
const request = createMockRequest('/api/transactions/bulk-book', {
|
|
method: 'POST',
|
|
body: {
|
|
tx_ids: [TX1, TX2],
|
|
existing_journal_entry_id: JE,
|
|
},
|
|
})
|
|
const response = await POST(request)
|
|
const { status, body } = await parseJsonResponse<{
|
|
data: { mode: string; journal_entry_id: string; linked_tx_count: number }
|
|
}>(response)
|
|
expect(status).toBe(200)
|
|
expect(body.data.mode).toBe('link_existing')
|
|
expect(body.data.journal_entry_id).toBe(JE)
|
|
expect(body.data.linked_tx_count).toBe(2)
|
|
// Every booked tx gets its matched inbox items completed against the
|
|
// samlingsverifikat (underlag link + consumed stamp).
|
|
expect(propagateUnderlagForBookedTransaction).toHaveBeenCalledWith(
|
|
expect.anything(),
|
|
'company-1',
|
|
TX1,
|
|
JE,
|
|
)
|
|
expect(propagateUnderlagForBookedTransaction).toHaveBeenCalledWith(
|
|
expect.anything(),
|
|
'company-1',
|
|
TX2,
|
|
JE,
|
|
)
|
|
})
|
|
|
|
it('create-new path fetches template, expands per mode, and calls RPC', async () => {
|
|
// Tx fetch (hoisted for the currency gate): 2 incomes totalling 300.
|
|
enqueue({
|
|
data: [
|
|
{ id: TX1, amount: 100, currency: 'SEK', description: 'Swish 1', date: '2026-06-05' },
|
|
{ id: TX2, amount: 200, currency: 'SEK', description: 'Swish 2', date: '2026-06-05' },
|
|
],
|
|
error: null,
|
|
})
|
|
// Template fetch.
|
|
enqueue({
|
|
data: {
|
|
id: TPL,
|
|
name: 'Försäljning 25%',
|
|
lines: [
|
|
{ account: '1930', label: 'Bank', side: 'debit', type: 'settlement' },
|
|
{ account: '3001', label: 'Försäljning', side: 'credit', type: 'business', ratio: 0.8 },
|
|
{ account: '2611', label: 'Utg moms 25%', side: 'credit', type: 'vat', vat_rate: 0.25 },
|
|
],
|
|
is_active: true,
|
|
},
|
|
error: null,
|
|
})
|
|
|
|
// applyTemplate stub: return a balanced 3-line set per call.
|
|
vi.mocked(applyTemplate).mockImplementation((_lines, total) => [
|
|
{ account_number: '1930', debit_amount: String(total), credit_amount: '', line_description: 'Bank' },
|
|
{ account_number: '3001', debit_amount: '', credit_amount: String(total * 0.8), line_description: 'Försäljning' },
|
|
{ account_number: '2611', debit_amount: '', credit_amount: String(total * 0.2), line_description: 'Utg moms 25%' },
|
|
])
|
|
|
|
// Account dimension rules pre-check (PR10) — none configured.
|
|
enqueue({ data: [], error: null })
|
|
// RPC returns happy path.
|
|
enqueue({
|
|
data: {
|
|
ok: true,
|
|
mode: 'create_new',
|
|
journal_entry_id: JE,
|
|
voucher_series: 'A',
|
|
voucher_number: 13,
|
|
linked_tx_count: 2,
|
|
tx_sum: 300,
|
|
},
|
|
error: null,
|
|
})
|
|
// Event re-fetch.
|
|
enqueue({ data: [], error: null })
|
|
|
|
const request = createMockRequest('/api/transactions/bulk-book', {
|
|
method: 'POST',
|
|
body: {
|
|
tx_ids: [TX1, TX2],
|
|
template_id: TPL,
|
|
mode: 'one_line_per_tx',
|
|
entry_description: 'Samlingsverifikation 2026-06-05',
|
|
},
|
|
})
|
|
const response = await POST(request)
|
|
const { status, body } = await parseJsonResponse<{
|
|
data: { mode: string; journal_entry_id: string }
|
|
}>(response)
|
|
expect(status).toBe(200)
|
|
expect(body.data.mode).toBe('create_new')
|
|
expect(body.data.journal_entry_id).toBe(JE)
|
|
// Template expansion was invoked once per tx in one_line_per_tx mode.
|
|
expect(vi.mocked(applyTemplate)).toHaveBeenCalledTimes(2)
|
|
})
|
|
|
|
it('maps RPC structured failure code to errorResponseFromCode', async () => {
|
|
// Currency gate tx fetch.
|
|
enqueue({
|
|
data: [
|
|
{ id: TX1, amount: 100, currency: 'SEK', description: 'Swish 1', date: '2026-06-05' },
|
|
{ id: TX2, amount: 200, currency: 'SEK', description: 'Swish 2', date: '2026-06-06' },
|
|
],
|
|
error: null,
|
|
})
|
|
enqueue({
|
|
data: { ok: false, code: 'BULK_BOOK_DATE_MISMATCH', details: { expected: '2026-06-05', got: '2026-06-06' } },
|
|
error: null,
|
|
})
|
|
|
|
const request = createMockRequest('/api/transactions/bulk-book', {
|
|
method: 'POST',
|
|
body: { tx_ids: [TX1, TX2], existing_journal_entry_id: JE },
|
|
})
|
|
const response = await POST(request)
|
|
const { status, body } = await parseJsonResponse<{ error: { code: string } }>(response)
|
|
expect(status).toBe(400)
|
|
expect(body.error.code).toBe('BULK_BOOK_DATE_MISMATCH')
|
|
})
|
|
})
|
|
|
|
/**
|
|
* Mixed-currency guard (BFL 4 kap 6 §: one redovisningsvaluta). A
|
|
* samlingsverifikation spanning SEK and EUR has no representable single
|
|
* belopp, so all three request shapes must refuse it with the SAME code the
|
|
* MCP twin uses. Before this, only the template branch checked; manual_lines
|
|
* and existing_journal_entry_id went straight to the RPC, which summed
|
|
* 100 EUR + 100 SEK into the scalar 200.
|
|
*/
|
|
describe('POST /api/transactions/bulk-book: mixed-currency guard', () => {
|
|
const mockUser = { id: 'user-1', email: 'test@test.se' }
|
|
|
|
const MIXED_TXS = [
|
|
{ id: TX1, amount: 100, currency: 'SEK', description: 'Swish', date: '2026-06-05' },
|
|
{ id: TX2, amount: 100, currency: 'EUR', description: 'Stripe', date: '2026-06-05' },
|
|
]
|
|
|
|
beforeEach(() => {
|
|
vi.clearAllMocks()
|
|
reset()
|
|
mockSupabase.auth.getUser.mockResolvedValue({ data: { user: mockUser } })
|
|
})
|
|
|
|
it('refuses a mixed-currency selection on the template branch', async () => {
|
|
enqueue({ data: MIXED_TXS, error: null })
|
|
|
|
const request = createMockRequest('/api/transactions/bulk-book', {
|
|
method: 'POST',
|
|
body: {
|
|
tx_ids: [TX1, TX2],
|
|
template_id: TPL,
|
|
mode: 'sum_per_account',
|
|
entry_description: 'Samlingsverifikation',
|
|
},
|
|
})
|
|
const response = await POST(request)
|
|
const { status, body } = await parseJsonResponse<{
|
|
error: { code: string; details?: { currencies?: string[] } }
|
|
}>(response)
|
|
expect(status).toBe(400)
|
|
expect(body.error.code).toBe('BULK_BOOK_MIXED_CURRENCY')
|
|
})
|
|
|
|
it('refuses a mixed-currency selection on the manual_lines branch', async () => {
|
|
enqueue({ data: MIXED_TXS, error: null })
|
|
|
|
const request = createMockRequest('/api/transactions/bulk-book', {
|
|
method: 'POST',
|
|
body: {
|
|
tx_ids: [TX1, TX2],
|
|
entry_description: 'Samlingsverifikation',
|
|
manual_lines: [
|
|
{ account_number: '1930', debit_amount: 200, credit_amount: 0, currency: 'SEK' },
|
|
{ account_number: '3001', debit_amount: 0, credit_amount: 200, currency: 'SEK' },
|
|
],
|
|
},
|
|
})
|
|
const response = await POST(request)
|
|
const { status, body } = await parseJsonResponse<{ error: { code: string } }>(response)
|
|
expect(status).toBe(400)
|
|
expect(body.error.code).toBe('BULK_BOOK_MIXED_CURRENCY')
|
|
// Refused before the RPC: the chart-of-accounts lookup never ran either.
|
|
expect(mockSupabase.rpc).not.toHaveBeenCalled()
|
|
})
|
|
|
|
it('refuses a mixed-currency selection on the existing_journal_entry_id branch', async () => {
|
|
enqueue({ data: MIXED_TXS, error: null })
|
|
|
|
const request = createMockRequest('/api/transactions/bulk-book', {
|
|
method: 'POST',
|
|
body: { tx_ids: [TX1, TX2], existing_journal_entry_id: JE },
|
|
})
|
|
const response = await POST(request)
|
|
const { status, body } = await parseJsonResponse<{ error: { code: string } }>(response)
|
|
expect(status).toBe(400)
|
|
expect(body.error.code).toBe('BULK_BOOK_MIXED_CURRENCY')
|
|
expect(mockSupabase.rpc).not.toHaveBeenCalled()
|
|
})
|
|
|
|
it('refuses a homogeneous non-SEK selection with BULK_BOOK_FOREIGN_CURRENCY', async () => {
|
|
// Same currency throughout, but not kronor: the RPC would write the
|
|
// foreign magnitudes into the always-SEK debit/credit columns, so the
|
|
// route refuses before the RPC just like the mixed-currency case.
|
|
enqueue({
|
|
data: [
|
|
{ id: TX1, amount: 100, currency: 'EUR', description: 'Stripe 1', date: '2026-06-05' },
|
|
{ id: TX2, amount: 200, currency: 'EUR', description: 'Stripe 2', date: '2026-06-05' },
|
|
],
|
|
error: null,
|
|
})
|
|
|
|
const request = createMockRequest('/api/transactions/bulk-book', {
|
|
method: 'POST',
|
|
body: {
|
|
tx_ids: [TX1, TX2],
|
|
entry_description: 'Samlingsverifikation',
|
|
manual_lines: [
|
|
{ account_number: '1930', debit_amount: 300, credit_amount: 0, currency: 'EUR' },
|
|
{ account_number: '3001', debit_amount: 0, credit_amount: 300, currency: 'EUR' },
|
|
],
|
|
},
|
|
})
|
|
const response = await POST(request)
|
|
const { status, body } = await parseJsonResponse<{
|
|
error: { code: string; details?: { currency?: string } }
|
|
}>(response)
|
|
expect(status).toBe(400)
|
|
expect(body.error.code).toBe('BULK_BOOK_FOREIGN_CURRENCY')
|
|
expect(body.error.details?.currency).toBe('EUR')
|
|
expect(mockSupabase.rpc).not.toHaveBeenCalled()
|
|
})
|
|
|
|
it('books a single-currency manual_lines selection', async () => {
|
|
// Tx fetch: both SEK.
|
|
enqueue({
|
|
data: [
|
|
{ id: TX1, amount: 100, currency: 'SEK', description: 'Swish', date: '2026-06-05' },
|
|
{ id: TX2, amount: 100, currency: 'SEK', description: 'Swish', date: '2026-06-05' },
|
|
],
|
|
error: null,
|
|
})
|
|
// chart_of_accounts allowlist.
|
|
enqueue({
|
|
data: [{ account_number: '1930' }, { account_number: '3001' }],
|
|
error: null,
|
|
})
|
|
// Dimension rules: none configured.
|
|
enqueue({ data: [], error: null })
|
|
// RPC happy path.
|
|
enqueue({
|
|
data: {
|
|
ok: true,
|
|
mode: 'create_new',
|
|
journal_entry_id: JE,
|
|
voucher_series: 'A',
|
|
voucher_number: 14,
|
|
linked_tx_count: 2,
|
|
tx_sum: 200,
|
|
},
|
|
error: null,
|
|
})
|
|
// Event re-fetch.
|
|
enqueue({ data: [], error: null })
|
|
|
|
const request = createMockRequest('/api/transactions/bulk-book', {
|
|
method: 'POST',
|
|
body: {
|
|
tx_ids: [TX1, TX2],
|
|
entry_description: 'Samlingsverifikation',
|
|
manual_lines: [
|
|
{ account_number: '1930', debit_amount: 200, credit_amount: 0, currency: 'SEK' },
|
|
{ account_number: '3001', debit_amount: 0, credit_amount: 200, currency: 'SEK' },
|
|
],
|
|
},
|
|
})
|
|
const response = await POST(request)
|
|
const { status, body } = await parseJsonResponse<{ data: { mode: string } }>(response)
|
|
expect(status).toBe(200)
|
|
expect(body.data.mode).toBe('create_new')
|
|
})
|
|
|
|
it('treats NULL currency as SEK and still books', async () => {
|
|
enqueue({
|
|
data: [
|
|
{ id: TX1, amount: 100, currency: null, description: 'Legacy row', date: '2026-06-05' },
|
|
{ id: TX2, amount: 100, currency: 'SEK', description: 'Swish', date: '2026-06-05' },
|
|
],
|
|
error: null,
|
|
})
|
|
enqueue({ data: [{ account_number: '1930' }, { account_number: '3001' }], error: null })
|
|
enqueue({ data: [], error: null })
|
|
enqueue({
|
|
data: {
|
|
ok: true,
|
|
mode: 'create_new',
|
|
journal_entry_id: JE,
|
|
voucher_series: 'A',
|
|
voucher_number: 15,
|
|
linked_tx_count: 2,
|
|
tx_sum: 200,
|
|
},
|
|
error: null,
|
|
})
|
|
enqueue({ data: [], error: null })
|
|
|
|
const request = createMockRequest('/api/transactions/bulk-book', {
|
|
method: 'POST',
|
|
body: {
|
|
tx_ids: [TX1, TX2],
|
|
entry_description: 'Samlingsverifikation',
|
|
manual_lines: [
|
|
{ account_number: '1930', debit_amount: 200, credit_amount: 0, currency: 'SEK' },
|
|
{ account_number: '3001', debit_amount: 0, credit_amount: 200, currency: 'SEK' },
|
|
],
|
|
},
|
|
})
|
|
const response = await POST(request)
|
|
expect(response.status).toBe(200)
|
|
})
|
|
})
|
|
|
|
/**
|
|
* Booking-time duplicate guard on the samlingsverifikation path (parity with
|
|
* /categorize and /book): before this, bulk-book never called
|
|
* detectBookingDuplicate at all, so a batch containing an already-booked
|
|
* twin minted a second verifikat with no warning.
|
|
*/
|
|
describe('POST /api/transactions/bulk-book: duplicate guard', () => {
|
|
const mockUser = { id: 'user-1', email: 'test@test.se' }
|
|
|
|
const SEK_TXS = [
|
|
{ id: TX1, amount: 100, currency: 'SEK', description: 'Swish 1', date: '2026-06-05' },
|
|
{ id: TX2, amount: 200, currency: 'SEK', description: 'Swish 2', date: '2026-06-05' },
|
|
]
|
|
|
|
const CANDIDATE: BookedDuplicateCandidate = {
|
|
transaction_id: null,
|
|
journal_entry_id: '55555555-5555-4555-8555-555555555555',
|
|
voucher_label: 'A17',
|
|
entry_date: '2026-06-05',
|
|
description: 'Swish inbetalning',
|
|
amount: 200,
|
|
account_number: '1930',
|
|
currency: null,
|
|
amount_in_currency: null,
|
|
amount_verified: true,
|
|
unverified_reason: null,
|
|
}
|
|
|
|
beforeEach(() => {
|
|
vi.clearAllMocks()
|
|
reset()
|
|
mockSupabase.auth.getUser.mockResolvedValue({ data: { user: mockUser } })
|
|
vi.mocked(detectBookingDuplicate).mockResolvedValue(null)
|
|
})
|
|
|
|
it('returns 409 with the candidate and the flagged tx, before the RPC', async () => {
|
|
enqueue({ data: SEK_TXS, error: null })
|
|
// TX1 clean, TX2 flagged (checked in tx_ids order).
|
|
vi.mocked(detectBookingDuplicate)
|
|
.mockResolvedValueOnce(null)
|
|
.mockResolvedValueOnce(CANDIDATE)
|
|
|
|
const request = createMockRequest('/api/transactions/bulk-book', {
|
|
method: 'POST',
|
|
body: { tx_ids: [TX1, TX2], existing_journal_entry_id: JE },
|
|
})
|
|
const response = await POST(request)
|
|
const { status, body } = await parseJsonResponse<{
|
|
error: { code: string; details?: { transaction_id?: string; candidate?: { journal_entry_id: string } } }
|
|
}>(response)
|
|
expect(status).toBe(409)
|
|
expect(body.error.code).toBe('TRANSACTION_BOOK_POSSIBLE_DUPLICATE')
|
|
expect(body.error.details?.transaction_id).toBe(TX2)
|
|
expect(body.error.details?.candidate?.journal_entry_id).toBe(CANDIDATE.journal_entry_id)
|
|
expect(mockSupabase.rpc).not.toHaveBeenCalled()
|
|
})
|
|
|
|
it('passes intra-batch exclusions so siblings and the link target never flag each other', async () => {
|
|
enqueue({ data: SEK_TXS, error: null })
|
|
// RPC + event re-fetch for the clean pass-through.
|
|
enqueue({
|
|
data: {
|
|
ok: true, mode: 'link_existing', journal_entry_id: JE,
|
|
voucher_series: 'A', voucher_number: 12, linked_tx_count: 2, tx_sum: 300,
|
|
},
|
|
error: null,
|
|
})
|
|
enqueue({ data: [], error: null })
|
|
|
|
const request = createMockRequest('/api/transactions/bulk-book', {
|
|
method: 'POST',
|
|
body: { tx_ids: [TX1, TX2], existing_journal_entry_id: JE },
|
|
})
|
|
const response = await POST(request)
|
|
expect(response.status).toBe(200)
|
|
expect(detectBookingDuplicate).toHaveBeenCalledTimes(2)
|
|
expect(detectBookingDuplicate).toHaveBeenCalledWith(
|
|
expect.anything(),
|
|
'company-1',
|
|
expect.objectContaining({ id: TX1, date: '2026-06-05', amount: 100 }),
|
|
{ excludeTransactionIds: [TX1, TX2], excludeJournalEntryIds: [JE] },
|
|
)
|
|
})
|
|
|
|
it('force=true books through and records each dismissed candidate in behandlingshistorik', async () => {
|
|
enqueue({ data: SEK_TXS, error: null })
|
|
enqueue({
|
|
data: {
|
|
ok: true, mode: 'link_existing', journal_entry_id: JE,
|
|
voucher_series: 'A', voucher_number: 12, linked_tx_count: 2, tx_sum: 300,
|
|
},
|
|
error: null,
|
|
})
|
|
enqueue({ data: [], error: null })
|
|
// Re-detection under force: TX1 clean, TX2 had the candidate.
|
|
vi.mocked(detectBookingDuplicate)
|
|
.mockResolvedValueOnce(null)
|
|
.mockResolvedValueOnce(CANDIDATE)
|
|
|
|
const request = createMockRequest('/api/transactions/bulk-book', {
|
|
method: 'POST',
|
|
body: { tx_ids: [TX1, TX2], existing_journal_entry_id: JE, force: true },
|
|
})
|
|
const response = await POST(request)
|
|
expect(response.status).toBe(200)
|
|
expect(appendProcessingHistory).toHaveBeenCalledTimes(1)
|
|
expect(appendProcessingHistory).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
aggregateId: TX2,
|
|
eventType: 'BankTransactionDuplicateDismissed',
|
|
payload: expect.objectContaining({
|
|
dismissed_journal_entry_id: CANDIDATE.journal_entry_id,
|
|
via: 'bulk_book_force',
|
|
}),
|
|
}),
|
|
)
|
|
})
|
|
|
|
it('fails open when detection itself throws (a guard failure never blocks a booking)', async () => {
|
|
enqueue({ data: SEK_TXS, error: null })
|
|
enqueue({
|
|
data: {
|
|
ok: true, mode: 'link_existing', journal_entry_id: JE,
|
|
voucher_series: 'A', voucher_number: 12, linked_tx_count: 2, tx_sum: 300,
|
|
},
|
|
error: null,
|
|
})
|
|
enqueue({ data: [], error: null })
|
|
vi.mocked(detectBookingDuplicate).mockRejectedValue(new Error('detector down'))
|
|
|
|
const request = createMockRequest('/api/transactions/bulk-book', {
|
|
method: 'POST',
|
|
body: { tx_ids: [TX1, TX2], existing_journal_entry_id: JE },
|
|
})
|
|
const response = await POST(request)
|
|
expect(response.status).toBe(200)
|
|
})
|
|
})
|