Files
accounted/lib/invoices/__tests__/pdf-render-helpers.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

508 lines
19 KiB
TypeScript

/**
* Regression tests for issue #772: "Logotyp kommer inte med på fakturor".
*
* Root cause: @react-pdf/renderer's <Image> only decodes JPG/PNG, but the logo
* upload route and the `logos` bucket accept SVG and WebP. When a logo was an
* SVG/WebP, @react-pdf silently dropped it (it swallows the decode error in a
* try/catch), so invoices rendered with no logo and no error.
*
* Fix: prepareInvoicePdfRender fetches the stored logo and re-encodes it to a
* PNG data URL via sharp, so every supported upload format renders. These tests
* mock `fetch` and exercise the real sharp pipeline.
*/
import { afterEach, beforeEach, describe, expect, it, vi, type MockInstance } from 'vitest'
import { readFile } from 'node:fs/promises'
import { join } from 'node:path'
import sharp from 'sharp'
import QRCode from 'qrcode'
import { prepareInvoicePdfRender, buildPaymentLinkQrDataUrl, buildSwishQrDataUrl } from '@/lib/invoices/pdf-render-helpers'
import { makeCompanySettings, makeInvoice } from '@/tests/helpers'
const fontDownloadMock = vi.hoisted(() => vi.fn())
vi.mock('@/lib/supabase/server', () => ({
createServiceClient: () => ({
storage: {
from: () => ({ download: fontDownloadMock }),
},
}),
}))
// The logo fetch runs through the outbound URL guard, which resolves DNS.
// Stub the validator (same seam the webhook dispatcher tests use): https hosts
// resolve to a public address, plain http is refused like the real guard does.
const guard = vi.hoisted(() => ({ validateUrl: vi.fn() }))
vi.mock('@/lib/webhooks/url-guard', async (importOriginal) => {
const actual = await importOriginal<typeof import('@/lib/webhooks/url-guard')>()
return {
...actual,
validateWebhookUrl: (...args: unknown[]) => guard.validateUrl(...args),
}
})
function guardPublicByDefault() {
guard.validateUrl.mockReset()
guard.validateUrl.mockImplementation(async (rawUrl: string) => {
const parsed = new URL(rawUrl)
if (parsed.protocol !== 'https:') {
return { ok: false, reason: 'non_https_scheme', detail: `${parsed.protocol} refused` }
}
return { ok: true, hostname: parsed.hostname, resolvedAddresses: ['203.0.113.10'] }
})
}
// The deployment's own storage origin: logos uploaded through the app live
// here, and it is exempt from the public-address check (a self-hosted NAS
// install may legitimately serve storage from a private address).
const STORAGE_ORIGIN = 'https://example.test'
const PNG_DATA_URL_PREFIX = 'data:image/png;base64,'
const SVG_LOGO = Buffer.from(
'<svg xmlns="http://www.w3.org/2000/svg" width="120" height="40">' +
'<rect width="120" height="40" fill="#1a1a1a"/>' +
'<text x="8" y="26" fill="#fff" font-size="18">ACME</text></svg>',
)
/** Build a one-shot fetch mock that returns the given bytes + content-type. */
function mockFetchOnce(buf: Buffer, contentType: string) {
const arrayBuffer = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength)
const fn = vi.fn().mockResolvedValue({
ok: true,
headers: { get: () => contentType },
arrayBuffer: async () => arrayBuffer,
})
vi.stubGlobal('fetch', fn)
return fn
}
/** A data: URL whose payload decodes to a valid PNG via sharp. */
async function expectValidEmbeddedPng(logoUrl: string | null | undefined) {
expect(logoUrl).toMatch(new RegExp(`^${PNG_DATA_URL_PREFIX}`))
const base64 = (logoUrl as string).slice(PNG_DATA_URL_PREFIX.length)
const meta = await sharp(Buffer.from(base64, 'base64')).metadata()
expect(meta.format).toBe('png')
}
describe('prepareInvoicePdfRender: logo resolution (issue #772)', () => {
beforeEach(() => {
vi.unstubAllGlobals()
fontDownloadMock.mockReset()
guardPublicByDefault()
vi.stubEnv('NEXT_PUBLIC_SUPABASE_URL', STORAGE_ORIGIN)
})
afterEach(() => {
vi.unstubAllGlobals()
vi.unstubAllEnvs()
vi.restoreAllMocks()
})
it('renders only the payment account matching the invoice currency', async () => {
const company = makeCompanySettings({
iban: 'SE0011111111111111111111',
invoice_payment_accounts: {
EUR: {
bank_name: 'EUR Bank',
clearing_number: null,
account_number: null,
bankgiro: null,
plusgiro: null,
swish: null,
iban: 'SE0022222222222222222222',
bic: 'EURRSESS',
},
},
})
const { company: resolved } = await prepareInvoicePdfRender(company, 'EUR')
expect(resolved.bank_name).toBe('EUR Bank')
expect(resolved.iban).toBe('SE0022222222222222222222')
expect(resolved.bankgiro).toBeNull()
})
it('rejects a foreign-currency PDF without a usable payment account', async () => {
const company = makeCompanySettings({ invoice_payment_accounts: {} })
await expect(prepareInvoicePdfRender(company, 'EUR')).rejects.toMatchObject({
code: 'INVOICE_SEND_PAYMENT_ACCOUNT_MISSING',
currency: 'EUR',
})
})
it('renders non-payable foreign documents without requiring an account or leaking SEK details', async () => {
const company = makeCompanySettings({
iban: 'SE0011111111111111111111',
invoice_payment_accounts: {},
})
const { company: resolved } = await prepareInvoicePdfRender(
company,
'EUR',
{ paymentAccountRequired: false },
)
expect(resolved.iban).toBeNull()
expect(resolved.bankgiro).toBeNull()
})
it('embeds an SVG logo as a PNG data URL so @react-pdf can draw it', async () => {
const fetchMock = mockFetchOnce(SVG_LOGO, 'image/svg+xml')
const company = makeCompanySettings({
logo_url: 'https://example.test/svg-logo-1.svg',
})
const { company: resolved } = await prepareInvoicePdfRender(company)
// Fetched with a timeout signal so a slow logo host can't hang the render,
// and with redirects disabled so the host can't bounce us elsewhere.
expect(fetchMock).toHaveBeenCalledWith(
'https://example.test/svg-logo-1.svg',
expect.objectContaining({ signal: expect.any(AbortSignal), redirect: 'manual' }),
)
// Our own storage origin skips the DNS guard (it may be private on self-host).
expect(guard.validateUrl).not.toHaveBeenCalled()
await expectValidEmbeddedPng(resolved.logo_url)
})
it('embeds a logo from a public https host once the DNS guard passes', async () => {
const fetchMock = mockFetchOnce(SVG_LOGO, 'image/svg+xml')
const url = 'https://cdn.example.org/public-logo-1.svg'
const company = makeCompanySettings({ logo_url: url })
const { company: resolved } = await prepareInvoicePdfRender(company)
expect(guard.validateUrl).toHaveBeenCalledWith(url, undefined)
expect(fetchMock).toHaveBeenCalledWith(url, expect.objectContaining({ redirect: 'manual' }))
await expectValidEmbeddedPng(resolved.logo_url)
})
it('renders without a logo when the logo host resolves to a private address (SSRF guard)', async () => {
guard.validateUrl.mockResolvedValue({
ok: false,
reason: 'private_address',
detail: 'Resolved address 10.0.0.9 for intranet.example.org is not publicly routable (private_address).',
})
const fetchMock = vi.fn()
vi.stubGlobal('fetch', fetchMock)
const company = makeCompanySettings({ logo_url: 'https://intranet.example.org/logo.png' })
const { company: resolved } = await prepareInvoicePdfRender(company)
// Refused means refused: no socket, and @react-pdf is not handed the URL either.
expect(fetchMock).not.toHaveBeenCalled()
expect(resolved.logo_url).toBeNull()
})
it('renders without a logo for a plain-http URL off the storage origin', async () => {
const fetchMock = vi.fn()
vi.stubGlobal('fetch', fetchMock)
const company = makeCompanySettings({ logo_url: 'http://cdn.example.org/http-logo.png' })
const { company: resolved } = await prepareInvoicePdfRender(company)
expect(fetchMock).not.toHaveBeenCalled()
expect(resolved.logo_url).toBeNull()
})
it('renders without a logo for a non-http(s) scheme', async () => {
const fetchMock = vi.fn()
vi.stubGlobal('fetch', fetchMock)
const company = makeCompanySettings({ logo_url: 'file:///etc/hostname' })
const { company: resolved } = await prepareInvoicePdfRender(company)
expect(fetchMock).not.toHaveBeenCalled()
expect(guard.validateUrl).not.toHaveBeenCalled()
expect(resolved.logo_url).toBeNull()
})
it('renders without a logo when the logo host answers with a redirect, even from the storage origin', async () => {
const cancel = vi.fn(async () => undefined)
vi.stubGlobal(
'fetch',
vi.fn().mockResolvedValue({
ok: false,
status: 302,
type: 'basic',
headers: new Headers({ location: 'http://169.254.169.254/latest/meta-data/' }),
body: { cancel },
}),
)
const company = makeCompanySettings({ logo_url: 'https://example.test/redirecting-logo.png' })
const { company: resolved } = await prepareInvoicePdfRender(company)
expect(resolved.logo_url).toBeNull()
expect(cancel).toHaveBeenCalled()
})
it('drops the logo instead of handing @react-pdf a remote URL when a non-storage host fails', async () => {
vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('network down')))
const url = 'https://cdn.example.org/flaky-logo.png'
const company = makeCompanySettings({ logo_url: url })
const { company: resolved } = await prepareInvoicePdfRender(company)
// @react-pdf's own fetch follows redirects with no guard; a tenant host
// that fails us and then redirects it would reopen the hole.
expect(resolved.logo_url).toBeNull()
})
it('embeds a WebP logo as a PNG data URL', async () => {
const webp = await sharp(SVG_LOGO).webp().toBuffer()
mockFetchOnce(webp, 'image/webp')
const company = makeCompanySettings({
logo_url: 'https://example.test/webp-logo-1.webp',
})
const { company: resolved } = await prepareInvoicePdfRender(company)
await expectValidEmbeddedPng(resolved.logo_url)
})
it('re-encodes a PNG logo to an embedded data URL (no remote fetch at render time)', async () => {
const png = await sharp(SVG_LOGO).png().toBuffer()
mockFetchOnce(png, 'image/png')
const company = makeCompanySettings({
logo_url: 'https://example.test/png-logo-1.png',
})
const { company: resolved } = await prepareInvoicePdfRender(company)
await expectValidEmbeddedPng(resolved.logo_url)
})
it('falls back to the original URL when the logo fetch is not ok', async () => {
const fn = vi.fn().mockResolvedValue({
ok: false,
headers: { get: () => null },
arrayBuffer: async () => new ArrayBuffer(0),
})
vi.stubGlobal('fetch', fn)
const url = 'https://example.test/missing-logo.png'
const company = makeCompanySettings({ logo_url: url })
const { company: resolved } = await prepareInvoicePdfRender(company)
// Unchanged: never worse than before (@react-pdf still fetches PNG/JPEG).
expect(resolved.logo_url).toBe(url)
})
it('falls back to the original URL when the fetch throws', async () => {
vi.stubGlobal(
'fetch',
vi.fn().mockRejectedValue(new Error('network down')),
)
const url = 'https://example.test/network-error-logo.png'
const company = makeCompanySettings({ logo_url: url })
const { company: resolved } = await prepareInvoicePdfRender(company)
expect(resolved.logo_url).toBe(url)
})
it('falls back to the original URL when the logo exceeds the size cap', async () => {
// Declared content-length over the cap is rejected before reading the body.
const fn = vi.fn().mockResolvedValue({
ok: true,
headers: {
get: (h: string) =>
h.toLowerCase() === 'content-length' ? String(11 * 1024 * 1024) : 'image/png',
},
arrayBuffer: async () => new ArrayBuffer(0),
})
vi.stubGlobal('fetch', fn)
const url = 'https://example.test/oversized-logo.png'
const company = makeCompanySettings({ logo_url: url })
const { company: resolved } = await prepareInvoicePdfRender(company)
expect(fn).toHaveBeenCalled()
expect(resolved.logo_url).toBe(url)
})
it('does not fetch when no logo is configured', async () => {
const fetchMock = vi.fn()
vi.stubGlobal('fetch', fetchMock)
const company = makeCompanySettings({ logo_url: null })
const { company: resolved } = await prepareInvoicePdfRender(company)
expect(fetchMock).not.toHaveBeenCalled()
expect(resolved.logo_url).toBeNull()
})
it('passes through an already-embedded data: URL without fetching', async () => {
const fetchMock = vi.fn()
vi.stubGlobal('fetch', fetchMock)
const dataUrl = `${PNG_DATA_URL_PREFIX}iVBORw0KGgo=`
const company = makeCompanySettings({ logo_url: dataUrl })
const { company: resolved } = await prepareInvoicePdfRender(company)
expect(fetchMock).not.toHaveBeenCalled()
expect(resolved.logo_url).toBe(dataUrl)
})
it('still returns branding alongside the resolved company', async () => {
mockFetchOnce(SVG_LOGO, 'image/svg+xml')
const company = makeCompanySettings({
logo_url: 'https://example.test/branding-logo.svg',
invoice_primary_color: '#c2410c',
})
const { branding } = await prepareInvoicePdfRender(company)
expect(branding.primaryColor).toBe('#c2410c')
})
})
describe('prepareInvoicePdfRender: invoice fonts', () => {
beforeEach(() => {
vi.unstubAllGlobals()
fontDownloadMock.mockReset()
})
afterEach(() => {
vi.unstubAllGlobals()
vi.unstubAllEnvs()
vi.restoreAllMocks()
})
it('registers a bundled font before returning it to the PDF template', async () => {
const company = makeCompanySettings({ invoice_font_family: 'Source Sans 3' })
const { branding } = await prepareInvoicePdfRender(company)
expect(branding.fontFamily).toBe('Source Sans 3')
})
it('registers a valid stored custom font under an isolated render family', async () => {
const bytes = await readFile(
join(process.cwd(), 'public', 'fonts', 'invoice', 'SourceSans3-Regular.ttf'),
)
const arrayBuffer = bytes.buffer.slice(
bytes.byteOffset,
bytes.byteOffset + bytes.byteLength,
)
fontDownloadMock.mockResolvedValue({
data: new Blob([arrayBuffer]),
error: null,
})
const company = makeCompanySettings({
invoice_font_family: 'Custom',
invoice_custom_font_path: 'company-1/invoice-font-1.ttf',
})
const { branding } = await prepareInvoicePdfRender(company)
expect(branding.fontFamily).toMatch(/^InvoiceCustom-[0-9a-f]{12}$/)
})
it('falls back to Helvetica when a custom font cannot be parsed', async () => {
const corruptedFont = new Uint8Array([0x00, 0x01, 0x00, 0x00, 0xff, 0xff])
fontDownloadMock.mockResolvedValue({
data: new Blob([corruptedFont]),
error: null,
})
const company = makeCompanySettings({
invoice_font_family: 'Custom',
invoice_custom_font_path: 'company-1/invoice-font-2.ttf',
})
const { branding } = await prepareInvoicePdfRender(company)
expect(branding.fontFamily).toBe('Helvetica')
})
it('does not download a custom font from another company path', async () => {
const company = makeCompanySettings({
invoice_font_family: 'Custom',
invoice_custom_font_path: 'company-2/invoice-font-3.ttf',
})
const { branding } = await prepareInvoicePdfRender(company)
expect(fontDownloadMock).not.toHaveBeenCalled()
expect(branding.fontFamily).toBe('Helvetica')
})
})
describe('buildPaymentLinkQrDataUrl', () => {
it('encodes the payment link as a PNG QR data URL for a real invoice', async () => {
const invoice = makeInvoice({ payment_link_url: 'https://buy.stripe.com/test_abc123' })
const qr = await buildPaymentLinkQrDataUrl(invoice)
expect(qr).toMatch(new RegExp(`^${PNG_DATA_URL_PREFIX}`))
})
it('returns null when the invoice has no payment link', async () => {
expect(await buildPaymentLinkQrDataUrl(makeInvoice())).toBeNull()
expect(await buildPaymentLinkQrDataUrl(makeInvoice({ payment_link_url: ' ' }))).toBeNull()
})
it('returns null for non-payable documents (proforma, delivery note, credit note)', async () => {
const url = 'https://buy.stripe.com/test_abc123'
expect(
await buildPaymentLinkQrDataUrl(makeInvoice({ payment_link_url: url, document_type: 'proforma' })),
).toBeNull()
expect(
await buildPaymentLinkQrDataUrl(makeInvoice({ payment_link_url: url, document_type: 'delivery_note' })),
).toBeNull()
expect(
await buildPaymentLinkQrDataUrl(makeInvoice({ payment_link_url: url, credited_invoice_id: 'inv-orig' })),
).toBeNull()
})
})
describe('buildSwishQrDataUrl', () => {
// Spy without replacing the implementation: the payload string is the unit
// under test (the PNG pixels are qrcode's concern), and the passthrough
// keeps the returned data URL real. The Swish payload locks the amount
// (editmask 0), so an amount above "Att betala" makes the customer overpay
// with no way to correct it in the app.
let toDataURL: MockInstance
beforeEach(() => {
toDataURL = vi.spyOn(QRCode, 'toDataURL')
})
afterEach(() => {
vi.restoreAllMocks()
})
const company = () => makeCompanySettings({ swish: '1234567890' })
it('encodes "Att betala" (total minus ROT/RUT deduction), not the invoice total', async () => {
const invoice = makeInvoice({ total: 1250, deduction_total: 625 })
const qr = await buildSwishQrDataUrl(company(), invoice)
expect(qr).toMatch(new RegExp(`^${PNG_DATA_URL_PREFIX}`))
expect(toDataURL).toHaveBeenCalledWith('C1234567890;625.00;F-2024001;0', expect.anything())
})
it('applies öresavrundning before the deduction, same order as the PDF totals block', async () => {
const invoice = makeInvoice({ total: 1250.49, ore_rounding: true, deduction_total: 625 })
await buildSwishQrDataUrl(company(), invoice)
expect(toDataURL).toHaveBeenCalledWith('C1234567890;625.00;F-2024001;0', expect.anything())
})
it('renders no QR when the deduction covers the whole invoice (nothing to pay)', async () => {
const invoice = makeInvoice({ total: 1250, deduction_total: 1250 })
expect(await buildSwishQrDataUrl(company(), invoice)).toBeNull()
expect(toDataURL).not.toHaveBeenCalled()
})
it('renders no QR for non-payable documents (credit note, proforma, delivery note)', async () => {
const creditNote = makeInvoice({ total: 1250, deduction_total: 625, credited_invoice_id: 'inv-orig' })
expect(await buildSwishQrDataUrl(company(), creditNote)).toBeNull()
expect(await buildSwishQrDataUrl(company(), makeInvoice({ document_type: 'proforma' }))).toBeNull()
expect(await buildSwishQrDataUrl(company(), makeInvoice({ document_type: 'delivery_note' }))).toBeNull()
expect(toDataURL).not.toHaveBeenCalled()
})
it('keeps the plain total for invoices without a deduction', async () => {
const invoice = makeInvoice()
await buildSwishQrDataUrl(company(), invoice)
expect(toDataURL).toHaveBeenCalledWith('C1234567890;12500.00;F-2024001;0', expect.anything())
})
})