Files
accounted/extensions/general/mcp-server/__tests__/get-invoice.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

348 lines
12 KiB
TypeScript

/**
* Tests for gnubok_get_invoice (issue #1642).
*
* The round-trip read surface for gnubok_update_invoice: its items are a
* FULL REPLACE and no other MCP tool returned invoice lines, so an agent
* fixing a quantity had to rebuild the lines from memory and silently dropped
* article_id / revenue_account / vat_rate. This tool returns every line with
* its booking fields in display order, plus editable_draft so the agent knows
* whether an edit is possible at all. Privacy contract: the invoices row
* carries the encrypted ROT/RUT personnummer; the tool maps an explicit field
* list and this suite pins that nothing else leaks.
*/
import { describe, it, expect, vi, beforeEach } from 'vitest'
import { createQueuedMockSupabase } from '@/tests/helpers'
import { TOOL_SCOPE_MAP } from '@/lib/auth/api-keys'
import { tools } from '../server'
const getInvoice = tools.find((t) => t.name === 'gnubok_get_invoice')!
const COMPANY_ID = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa'
const USER_ID = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb'
const INVOICE_ID = 'cccccccc-cccc-4ccc-8ccc-cccccccccccc'
const CUSTOMER_ID = 'dddddddd-dddd-4ddd-8ddd-dddddddddddd'
const ARTICLE_ID = 'eeeeeeee-eeee-4eee-8eee-eeeeeeeeeeee'
function invoiceRow(overrides: Record<string, unknown> = {}) {
return {
id: INVOICE_ID,
invoice_number: null,
status: 'draft',
document_type: 'invoice',
customer_id: CUSTOMER_ID,
invoice_date: '2026-08-01',
due_date: '2026-08-31',
delivery_date: null,
currency: 'SEK',
subtotal: 3400,
vat_amount: 850,
total: 4250,
paid_amount: 0,
remaining_amount: 4250,
your_reference: 'Anna',
our_reference: null,
notes: null,
default_dimensions: { '1': 'KS01' },
journal_entry_id: null,
is_self_billed: false,
credited_invoice_id: null,
customer: { name: 'Synthetic Kund AB' },
// Deliberately out of display order: PostgREST does not order embeds.
items: [
{
id: 'item-2',
sort_order: 2,
line_type: 'product',
description: 'Resa',
quantity: 1,
unit: 'st',
unit_price: 1000,
line_total: 1000,
vat_rate: 25,
vat_amount: 250,
article_id: null,
revenue_account: null,
deduction_type: null,
labor_hours: null,
work_type: null,
housing_designation: null,
apartment_number: null,
brf_org_number: null,
accrual_period_start: null,
accrual_period_end: null,
accrual_balance_account: null,
dimensions: null,
},
{
id: 'item-1',
sort_order: 1,
line_type: 'product',
description: 'Konsulttimme',
quantity: 2,
unit: 'tim',
unit_price: 1200,
line_total: 2400,
vat_rate: 25,
vat_amount: 600,
article_id: ARTICLE_ID,
revenue_account: '3041',
deduction_type: null,
labor_hours: null,
work_type: null,
housing_designation: null,
apartment_number: null,
brf_org_number: null,
accrual_period_start: null,
accrual_period_end: null,
accrual_balance_account: null,
dimensions: { '6': 'P001' },
},
],
...overrides,
}
}
beforeEach(() => {
vi.clearAllMocks()
})
describe('gnubok_get_invoice: registration', () => {
it('is registered as a plain read-only tool (not a staged operation)', () => {
expect(getInvoice).toBeDefined()
expect(getInvoice.annotations.readOnlyHint).toBe(true)
expect(getInvoice.annotations.destructiveHint).toBe(false)
expect(getInvoice.annotations.idempotentHint).toBe(true)
const outputProps = (getInvoice.outputSchema as { properties: Record<string, unknown> }).properties
expect(outputProps.items).toBeDefined()
expect(outputProps.editable_draft).toBeDefined()
expect(outputProps.staged).toBeUndefined()
})
it('requires invoice_id and rejects unknown input properties', () => {
const schema = getInvoice.inputSchema as { additionalProperties: boolean; required: string[] }
expect(schema.additionalProperties).toBe(false)
expect(schema.required).toEqual(['invoice_id'])
})
it('is mapped to invoices:read scope', () => {
expect(TOOL_SCOPE_MAP.gnubok_get_invoice).toBe('invoices:read')
})
it('is search-only in the catalog (tools/list context budget)', () => {
// payload-size.bench.test.ts sits at its ceiling, and the tool this one
// serves (gnubok_update_invoice) is search-only as well.
expect(getInvoice.catalogVisibility).toBe('search')
})
it('keeps its description within the 280-char budget and names the update tool', () => {
expect(getInvoice.description.length).toBeLessThanOrEqual(280)
expect(getInvoice.description).toContain('gnubok_update_invoice')
})
it('exposes the booking fields per line in the output schema', () => {
const itemProps = (
getInvoice.outputSchema as { properties: { items: { items: { properties: Record<string, unknown> } } } }
).properties.items.items.properties
for (const key of ['invoice_item_id', 'article_id', 'revenue_account', 'vat_rate', 'line_total', 'deduction_type', 'housing_designation', 'apartment_number', 'brf_org_number', 'accrual_period_start', 'dimensions']) {
expect(itemProps[key], key).toBeDefined()
}
expect(itemProps.id).toBeUndefined()
})
})
describe('gnubok_get_invoice: execute', () => {
it('returns the header and every line in sort order with its booking fields', async () => {
const { supabase, enqueue, findCalls } = createQueuedMockSupabase()
enqueue({ data: invoiceRow() })
const result = (await getInvoice.execute(
{ invoice_id: INVOICE_ID },
COMPANY_ID,
USER_ID,
supabase as never,
{ type: 'api_key' } as never,
)) as Record<string, unknown> & { items: Array<Record<string, unknown>> }
expect(result).toMatchObject({
invoice_id: INVOICE_ID,
invoice_number: null,
status: 'draft',
document_type: 'invoice',
customer_id: CUSTOMER_ID,
customer_name: 'Synthetic Kund AB',
currency: 'SEK',
subtotal: 3400,
vat_amount: 850,
total: 4250,
remaining_amount: 4250,
your_reference: 'Anna',
default_dimensions: { '1': 'KS01' },
editable_draft: true,
item_count: 2,
})
expect(result.items.map((i) => i.invoice_item_id)).toEqual(['item-1', 'item-2'])
expect(result.items[0]).toEqual({
invoice_item_id: 'item-1',
line_type: 'product',
description: 'Konsulttimme',
quantity: 2,
unit: 'tim',
unit_price: 1200,
discount_percent: 0,
line_total: 2400,
vat_rate: 25,
vat_amount: 600,
article_id: ARTICLE_ID,
revenue_account: '3041',
deduction_type: null,
labor_hours: null,
work_type: null,
housing_designation: null,
apartment_number: null,
brf_org_number: null,
accrual_period_start: null,
accrual_period_end: null,
accrual_balance_account: null,
dimensions: { '6': 'P001' },
})
expect(result.items[1]).toMatchObject({ article_id: null, revenue_account: null, dimensions: {} })
// Company scoping is explicit (defense in depth: service-role paths have no RLS).
expect(supabase.from).toHaveBeenCalledTimes(1)
expect(supabase.from).toHaveBeenCalledWith('invoices')
expect(findCalls('invoices', 'eq')).toContainEqual(['company_id', COMPANY_ID])
expect(findCalls('invoices', 'eq')).toContainEqual(['id', INVOICE_ID])
})
it('reports editable_draft false for an issued invoice', async () => {
const { supabase, enqueue } = createQueuedMockSupabase()
enqueue({ data: invoiceRow({ status: 'sent', invoice_number: '2026-0042', journal_entry_id: 'je-1' }) })
const result = (await getInvoice.execute(
{ invoice_id: INVOICE_ID },
COMPANY_ID,
USER_ID,
supabase as never,
{ type: 'api_key' } as never,
)) as { editable_draft: boolean; invoice_number: string | null }
expect(result.editable_draft).toBe(false)
expect(result.invoice_number).toBe('2026-0042')
})
it('returns an empty line list for a draft without lines', async () => {
const { supabase, enqueue } = createQueuedMockSupabase()
enqueue({ data: invoiceRow({ items: [] }) })
const result = (await getInvoice.execute(
{ invoice_id: INVOICE_ID },
COMPANY_ID,
USER_ID,
supabase as never,
{ type: 'api_key' } as never,
)) as { items: unknown[]; item_count: number }
expect(result.items).toEqual([])
expect(result.item_count).toBe(0)
})
it('returns the ROT property identifiers per line so a deduction draft can round-trip', async () => {
// The housing columns are property identifiers, not personal data; without
// them an items update on a ROT draft fails at approval with
// 'Fastighetsbeteckning kravs for ROT-avdrag' (rot-rut-rules.ts).
const { supabase, enqueue } = createQueuedMockSupabase()
const base = invoiceRow()
const items = (base.items as Array<Record<string, unknown>>).map((row) =>
row.id === 'item-1'
? {
...row,
deduction_type: 'rot',
labor_hours: 10,
work_type: 'EL',
housing_designation: 'Almgren 1:23',
apartment_number: '1101',
brf_org_number: '769600-1234',
}
: row,
)
enqueue({ data: { ...base, items } })
const result = (await getInvoice.execute(
{ invoice_id: INVOICE_ID },
COMPANY_ID,
USER_ID,
supabase as never,
{ type: 'api_key' } as never,
)) as { items: Array<Record<string, unknown>> }
expect(result.items[0]).toMatchObject({
deduction_type: 'rot',
labor_hours: 10,
work_type: 'EL',
housing_designation: 'Almgren 1:23',
apartment_number: '1101',
brf_org_number: '769600-1234',
})
})
it('never returns the encrypted ROT/RUT personnummer columns even if selected by mistake', async () => {
const { supabase, enqueue } = createQueuedMockSupabase()
enqueue({
data: invoiceRow({
deduction_personnummer_encrypted: 'LEAKED-CIPHERTEXT',
deduction_personnummer_last4: '1234',
}),
})
const result = await getInvoice.execute(
{ invoice_id: INVOICE_ID },
COMPANY_ID,
USER_ID,
supabase as never,
{ type: 'api_key' } as never,
)
const serialized = JSON.stringify(result)
expect(serialized).not.toContain('LEAKED-CIPHERTEXT')
expect(serialized).not.toContain('deduction_personnummer')
})
it('throws Invoice not found for an invoice outside the routed company', async () => {
const { supabase, enqueue } = createQueuedMockSupabase()
enqueue({ data: null })
await expect(
getInvoice.execute(
{ invoice_id: INVOICE_ID },
COMPANY_ID,
USER_ID,
supabase as never,
{ type: 'api_key' } as never,
),
).rejects.toThrow(/invoice not found/i)
})
it('requires invoice_id', async () => {
const { supabase } = createQueuedMockSupabase()
await expect(
getInvoice.execute({}, COMPANY_ID, USER_ID, supabase as never, { type: 'api_key' } as never),
).rejects.toThrow(/invoice_id is required/)
expect(supabase.from).not.toHaveBeenCalled()
})
it('surfaces a database error instead of reporting a missing invoice', async () => {
const { supabase, enqueue } = createQueuedMockSupabase()
enqueue({ data: null, error: { message: 'connection reset' } })
await expect(
getInvoice.execute(
{ invoice_id: INVOICE_ID },
COMPANY_ID,
USER_ID,
supabase as never,
{ type: 'api_key' } as never,
),
).rejects.toThrow(/Database error/)
})
})