Files
accounted/lib/import/__tests__/sie-import.account-names.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

352 lines
10 KiB
TypeScript

/**
* executeSIEImport ↔ syncMappedAccounts wiring (F: customized #KONTO names
* from Fortnox were lost on import).
*
* The name-resolution behavior itself is covered by account-sync.test.ts:
* these tests assert that executeSIEImport threads the updateAccountNames
* option through (default ON), surfaces rename counts as Swedish warnings,
* and aborts on a fatal create error.
*/
import { describe, it, expect, vi, beforeEach } from 'vitest'
import { executeSIEImport } from '../sie-import'
import { syncMappedAccounts } from '../account-sync'
import { createQueuedMockSupabase } from '@/tests/helpers'
import type { ParsedSIEFile, AccountMapping } from '../types'
import type { SupabaseClient } from '@supabase/supabase-js'
vi.mock('../account-sync', () => ({
syncMappedAccounts: vi.fn(),
}))
const mockSync = vi.mocked(syncMappedAccounts)
// Stops right after the account sync: stats carry no fiscal year, so
// executeSIEImport returns "No fiscal year defined" without needing the
// fiscal-period / voucher mocks.
function makeParsedFile(): ParsedSIEFile {
return {
header: {
sieType: 4,
flagga: 0,
program: 'TestProg',
programVersion: '1.0',
generatedDate: '2024-01-01',
format: 'PC8',
companyName: 'Test AB',
orgNumber: '5566778899',
address: null,
fiscalYears: [],
currency: 'SEK',
kontoPlanType: null,
},
accounts: [
{ number: '1930', name: 'Företagskonto Swedbank' },
{ number: '6110', name: 'Kontorsmaterial' },
],
openingBalances: [],
closingBalances: [],
resultBalances: [],
dimensions: [],
dimensionValues: [],
vouchers: [
{
series: 'A',
number: 1,
date: new Date(2024, 0, 15),
description: 'Inköp',
lines: [
{ account: '6110', amount: 1000 },
{ account: '1930', amount: -1000 },
],
},
],
issues: [],
stats: {
totalAccounts: 2,
totalVouchers: 1,
totalTransactionLines: 2,
fiscalYearStart: null,
fiscalYearEnd: null,
},
} as unknown as ParsedSIEFile
}
function makeMappings(): AccountMapping[] {
return [
{
sourceAccount: '1930',
sourceName: 'Företagskonto Swedbank',
targetAccount: '1930',
targetName: 'Företagskonto/checkkonto',
confidence: 1,
matchType: 'exact',
isOverride: false,
},
{
sourceAccount: '6110',
sourceName: 'Kontorsmaterial',
targetAccount: '6110',
targetName: 'Kontorsmaterial',
confidence: 1,
matchType: 'exact',
isOverride: false,
},
]
}
function buildSupabase() {
const { supabase, enqueueMany } = createQueuedMockSupabase()
enqueueMany([
{ data: null }, // checkDuplicateImport: no prior import
{ data: null }, // cleanupStaleImportRecords
{ data: { id: 'imp-1' } }, // createPendingImportRecord insert
])
return supabase as unknown as SupabaseClient
}
function runImport(opts?: { updateAccountNames?: boolean }) {
return executeSIEImport(
buildSupabase(),
'company-1',
'user-1',
makeParsedFile(),
makeMappings(),
{
filename: 'fortnox.se',
fileContent: '#dummy',
createFiscalPeriod: false,
importOpeningBalances: false,
importTransactions: true,
...opts,
}
)
}
beforeEach(() => {
mockSync.mockReset()
mockSync.mockResolvedValue({
created: 0,
renamed: 0,
renamedAccounts: [],
renameFailed: 0,
error: null,
})
})
describe('executeSIEImport: account name sync wiring', () => {
it('defaults updateAccountNames to true', async () => {
await runImport()
expect(mockSync).toHaveBeenCalledTimes(1)
const [, companyId, userId, mappings, updateNames] = mockSync.mock.calls[0]
expect(companyId).toBe('company-1')
expect(userId).toBe('user-1')
expect(mappings).toHaveLength(2)
expect(updateNames).toBe(true)
})
it('passes updateAccountNames: false through', async () => {
await runImport({ updateAccountNames: false })
expect(mockSync.mock.calls[0][4]).toBe(false)
})
it('surfaces rename counts as a Swedish warning (plural)', async () => {
mockSync.mockResolvedValue({
created: 1,
renamed: 2,
renamedAccounts: [
{ accountNumber: '1930', from: 'Företagskonto/checkkonto', to: 'Företagskonto Swedbank' },
{ accountNumber: '1510', from: 'Kundfordringar', to: 'Kundfordringar SEK' },
],
renameFailed: 0,
error: null,
})
const result = await runImport()
expect(result.warnings).toContain('2 konton bytte namn till namnen från SIE-filen')
})
it('uses singular wording for one rename', async () => {
mockSync.mockResolvedValue({
created: 0,
renamed: 1,
renamedAccounts: [
{ accountNumber: '1930', from: 'Företagskonto/checkkonto', to: 'Företagskonto Swedbank' },
],
renameFailed: 0,
error: null,
})
const result = await runImport()
expect(result.warnings).toContain('1 konto bytte namn till namnet från SIE-filen')
})
it('warns about failed renames without failing the import step', async () => {
mockSync.mockResolvedValue({
created: 0,
renamed: 0,
renamedAccounts: [],
renameFailed: 1,
error: null,
})
const result = await runImport()
expect(result.warnings).toContain('1 kontonamn kunde inte uppdateras från SIE-filen')
expect(result.errors.join(' ')).not.toMatch(/Failed to create accounts/)
})
it('aborts with an error when the create pass fails', async () => {
mockSync.mockResolvedValue({
created: 0,
renamed: 0,
renamedAccounts: [],
renameFailed: 0,
error: 'permission denied',
})
const result = await runImport()
expect(result.success).toBe(false)
expect(result.errors).toContain('Failed to create accounts: permission denied')
})
it('adds no rename warning when nothing was renamed', async () => {
const result = await runImport()
expect(result.warnings.join(' ')).not.toMatch(/bytte namn/)
})
it('reports the number of accounts the sync inserted', async () => {
mockSync.mockResolvedValue({
created: 109,
renamed: 0,
renamedAccounts: [],
renameFailed: 0,
error: null,
})
const result = await runImport()
expect(result.accountsCreated).toBe(109)
})
it('leaves accountsCreated unset when the create pass fails', async () => {
mockSync.mockResolvedValue({
created: 3,
renamed: 0,
renamedAccounts: [],
renameFailed: 0,
error: 'permission denied',
})
const result = await runImport()
expect(result.accountsCreated).toBeUndefined()
})
})
// Regression for 2026-09-09: the account insert timed out, executeSIEImport
// returned through the early `return result` after syncMappedAccounts, and
// the sie_imports row it had just created stayed 'pending'. That row holds
// the (company_id, file_hash) slot in the partial unique index, so the user's
// retry 40 s later failed on the index with a message that named the retired
// brand and a button that does not exist.
describe('executeSIEImport: pending import record on early exit', () => {
function importWith(mock: ReturnType<typeof createQueuedMockSupabase>) {
return executeSIEImport(
mock.supabase as unknown as SupabaseClient,
'company-1',
'user-1',
makeParsedFile(),
makeMappings(),
{
filename: 'bokio.se',
fileContent: '#dummy',
createFiscalPeriod: false,
importOpeningBalances: false,
importTransactions: true,
}
)
}
it('closes the pending record as failed when the create pass aborts', async () => {
mockSync.mockResolvedValue({
created: 0,
renamed: 0,
renamedAccounts: [],
renameFailed: 0,
error: 'canceling statement due to statement timeout',
})
const mock = createQueuedMockSupabase()
mock.enqueueMany([
{ data: null }, // checkDuplicateImport: no prior import
{ data: null }, // cleanupStaleImportRecords
{ data: { id: 'imp-1' } }, // createPendingImportRecord insert
{ data: null }, // finalizeImportRecord update
])
const result = await importWith(mock)
expect(result.success).toBe(false)
expect(result.importId).toBe('imp-1')
const updates = mock.findCalls('sie_imports', 'update')
expect(updates).toHaveLength(1)
expect(updates[0][0]).toMatchObject({
status: 'failed',
imported_at: null,
transactions_count: 0,
error_message: expect.stringContaining('statement timeout'),
})
})
it('closes the pending record as failed when the file has no fiscal year', async () => {
const mock = createQueuedMockSupabase()
mock.enqueueMany([
{ data: null },
{ data: null },
{ data: { id: 'imp-2' } },
{ data: null },
])
const result = await importWith(mock)
expect(result.errors).toContain('No fiscal year defined in the SIE file')
const updates = mock.findCalls('sie_imports', 'update')
expect(updates).toHaveLength(1)
expect(updates[0][0]).toMatchObject({ status: 'failed' })
})
it('explains a held file-hash slot in Swedish, without the retired brand or a missing button', async () => {
const mock = createQueuedMockSupabase()
mock.enqueueMany([
{ data: null }, // checkDuplicateImport
{ data: null }, // cleanupStaleImportRecords
{
data: null,
error: {
code: '23505',
message:
'duplicate key value violates unique constraint "sie_imports_company_id_file_hash_active_idx"',
},
},
])
const result = await importWith(mock)
expect(result.success).toBe(false)
expect(result.importId).toBeNull()
expect(result.errors).toHaveLength(1)
expect(result.errors[0]).toMatch(
/^Importen misslyckades: Samma SIE-fil håller redan på att importeras/
)
expect(result.errors[0]).toMatch(/Vänta några minuter och försök igen/)
expect(result.errors[0]).not.toMatch(/gnubok|Ersätt import|Fortnox/)
// No row was created, so there is nothing to close.
expect(mock.findCalls('sie_imports', 'update')).toHaveLength(0)
})
})