accounted/lib/import/__tests__/sie-import-coverage.test.ts

/**
 * Regression suite for the Lookma AB support case (2026-05-28).
 *
 * The bug: gnubok_import_sie + executeSIEImport accepted mappings that
 * couldn't cover a single account in the file. The per-voucher loop then
 * silently skipped every verifikation, finalizeImportRecord marked the
 * sie_imports row 'completed' with transactions_count=0, and the partial
 * unique index on (company_id, file_hash) held the slot — blocking retry.
 *
 * The fix layers three guards:
 *   1. Stage-time refusal in gnubok_import_sie (covered in
 *      extensions/general/mcp-server/__tests__/import-sie-stage.test.ts).
 *   2. Defense-in-depth refusal in executeSIEImport (this file).
 *   3. Finalizer downgrade of any 0-entry success to 'failed' (this file).
 */
import { describe, it, expect } from 'vitest'
import { executeSIEImport, finalizeImportRecord } from '../sie-import'
import { createQueuedMockSupabase } from '@/tests/helpers'
import type { ParsedSIEFile, AccountMapping, ImportResult } from '../types'
import type { SupabaseClient } from '@supabase/supabase-js'

function makeParsedFile(overrides?: Partial<ParsedSIEFile>): ParsedSIEFile {
  return {
    header: {
      sieType: 4,
      flagga: 0,
      program: 'TestProg',
      programVersion: '1.0',
      generatedDate: '2024-01-01',
      format: 'PC8',
      companyName: 'Lookma Mock AB',
      orgNumber: '5567201701',
      address: null,
      fiscalYears: [{ yearIndex: 0, start: '2024-01-01', end: '2024-12-31' }],
      currency: 'SEK',
      kontoPlanType: null,
    },
    accounts: [
      { number: '1930', name: 'Företagskonto' },
      { number: '6110', name: 'Kontorsmaterial' },
    ],
    openingBalances: [{ yearIndex: 0, account: '1930', amount: 50000 }],
    closingBalances: [],
    resultBalances: [],
    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: '2024-01-01',
      fiscalYearEnd: '2024-12-31',
    },
    ...overrides,
  }
}

function makeMapping(source: string, target: string | null): AccountMapping {
  return {
    sourceAccount: source,
    sourceName: `Account ${source}`,
    targetAccount: target as string,
    targetName: target ? `Target ${target}` : '',
    confidence: target ? 1 : 0,
    matchType: target ? 'exact' : 'manual',
    isOverride: false,
  }
}

describe('executeSIEImport — defense-in-depth coverage check', () => {
  it('refuses to insert a sie_imports row when mappings is empty', async () => {
    const { supabase } = createQueuedMockSupabase()
    const parsed = makeParsedFile()

    const result = await executeSIEImport(
      supabase as unknown as SupabaseClient,
      'company-1',
      'user-1',
      parsed,
      [],
      {
        filename: 'lookma.se',
        fileContent: '#dummy',
        createFiscalPeriod: false,
        importOpeningBalances: false,
        importTransactions: true,
      },
    )

    expect(result.success).toBe(false)
    expect(result.importId).toBeNull()
    expect(result.errors.join(' ')).toMatch(/täcker inga konton/i)
  })

  it('refuses when mappings exist but cover none of the file\'s accounts', async () => {
    const { supabase } = createQueuedMockSupabase()
    const parsed = makeParsedFile()

    const result = await executeSIEImport(
      supabase as unknown as SupabaseClient,
      'company-1',
      'user-1',
      parsed,
      [makeMapping('9999', '9999')],
      {
        filename: 'wrong.se',
        fileContent: '#dummy',
        createFiscalPeriod: false,
        importOpeningBalances: false,
        importTransactions: true,
      },
    )

    expect(result.success).toBe(false)
    expect(result.importId).toBeNull()
    expect(result.errors.join(' ')).toMatch(/täcker inga konton/i)
  })

  it('still rejects mappings with targetAccount=null (existing guard)', async () => {
    const { supabase } = createQueuedMockSupabase()
    const parsed = makeParsedFile()

    const result = await executeSIEImport(
      supabase as unknown as SupabaseClient,
      'company-1',
      'user-1',
      parsed,
      [makeMapping('6110', null), makeMapping('1930', null)],
      {
        filename: 'half.se',
        fileContent: '#dummy',
        createFiscalPeriod: false,
        importOpeningBalances: false,
        importTransactions: true,
      },
    )

    expect(result.success).toBe(false)
    expect(result.errors.join(' ')).toMatch(/not mapped/i)
  })
})

describe('finalizeImportRecord — 0-entry downgrade', () => {
  it('flips a 0-entry success to status=failed and records the reason', async () => {
    const { supabase } = createQueuedMockSupabase()

    const result: ImportResult = {
      success: true,
      importId: 'imp-1',
      fiscalPeriodId: 'fp-1',
      openingBalanceEntryId: null,
      journalEntriesCreated: 0,
      journalEntryIds: [],
      errors: [],
      warnings: ['100 verifikationer hoppades över med ej mappade konton'],
      replacedPriorImport: null,
    }

    await finalizeImportRecord(
      supabase as unknown as SupabaseClient,
      'imp-1',
      'company-1',
      result,
      '#dummy',
    )

    expect(result.success).toBe(false)
    expect(result.errors.join(' ')).toMatch(/0 verifikationer/i)
  })

  it('leaves a successful run with entries alone', async () => {
    const { supabase } = createQueuedMockSupabase()

    const result: ImportResult = {
      success: true,
      importId: 'imp-2',
      fiscalPeriodId: 'fp-2',
      openingBalanceEntryId: null,
      journalEntriesCreated: 42,
      journalEntryIds: Array(42).fill('je'),
      errors: [],
      warnings: [],
      replacedPriorImport: null,
    }

    await finalizeImportRecord(
      supabase as unknown as SupabaseClient,
      'imp-2',
      'company-1',
      result,
      '#dummy',
    )

    expect(result.success).toBe(true)
    expect(result.errors).toEqual([])
  })

  it('leaves a 0-voucher run alone when an OB entry was created', async () => {
    const { supabase } = createQueuedMockSupabase()

    const result: ImportResult = {
      success: true,
      importId: 'imp-3',
      fiscalPeriodId: 'fp-3',
      openingBalanceEntryId: 'ob-1',
      journalEntriesCreated: 1,
      journalEntryIds: ['ob-1'],
      errors: [],
      warnings: [],
      replacedPriorImport: null,
    }

    await finalizeImportRecord(
      supabase as unknown as SupabaseClient,
      'imp-3',
      'company-1',
      result,
      '#dummy',
    )

    expect(result.success).toBe(true)
  })
})