Å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.
244 lines
7.9 KiB
TypeScript
244 lines
7.9 KiB
TypeScript
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
|
|
import {
|
|
downloadFile,
|
|
saveBlobToDisk,
|
|
DOWNLOAD_TIMEOUT_MS,
|
|
OBJECT_URL_REVOKE_DELAY_MS,
|
|
} from '@/lib/browser/download-file'
|
|
|
|
const originalFetch = globalThis.fetch
|
|
|
|
const EXPORT_BODY = JSON.stringify({ version: 1, templates: [{ name: 'Inköp EU-varor' }] })
|
|
|
|
function jsonResponse(body: unknown, status = 200): Response {
|
|
return new Response(typeof body === 'string' ? body : JSON.stringify(body), {
|
|
status,
|
|
headers: { 'Content-Type': 'application/json' },
|
|
})
|
|
}
|
|
|
|
/** A fetch that never resolves and rejects the way the platform does on abort. */
|
|
function hangingFetch() {
|
|
return vi.fn((_url: unknown, init?: RequestInit) => {
|
|
return new Promise<Response>((_resolve, reject) => {
|
|
init?.signal?.addEventListener('abort', () => {
|
|
const err = new Error('The operation was aborted due to timeout')
|
|
err.name = 'TimeoutError'
|
|
reject(err)
|
|
})
|
|
})
|
|
})
|
|
}
|
|
|
|
beforeEach(() => {
|
|
vi.clearAllMocks()
|
|
})
|
|
|
|
afterEach(() => {
|
|
globalThis.fetch = originalFetch
|
|
})
|
|
|
|
describe('downloadFile', () => {
|
|
it('saves the file when the server answers 2xx', async () => {
|
|
globalThis.fetch = vi.fn().mockResolvedValue(jsonResponse(EXPORT_BODY))
|
|
const saveBlob = vi.fn()
|
|
|
|
const result = await downloadFile({
|
|
url: '/api/settings/booking-templates/export',
|
|
filename: 'bokforingsmallar.json',
|
|
saveBlob,
|
|
})
|
|
|
|
expect(result).toEqual({ ok: true, filename: 'bokforingsmallar.json' })
|
|
expect(saveBlob).toHaveBeenCalledTimes(1)
|
|
const [blob, filename] = saveBlob.mock.calls[0]
|
|
expect(filename).toBe('bokforingsmallar.json')
|
|
await expect((blob as Blob).text()).resolves.toBe(EXPORT_BODY)
|
|
})
|
|
|
|
it('writes NO file on a 500 and reports the envelope message', async () => {
|
|
// The regression guard. The old handler called res.blob() with no res.ok
|
|
// check, so this error envelope was saved to disk as bokforingsmallar.json
|
|
// and the download was reported as a success.
|
|
globalThis.fetch = vi.fn().mockResolvedValue(
|
|
jsonResponse(
|
|
{
|
|
error: {
|
|
code: 'INTERNAL_ERROR',
|
|
message: 'Kunde inte hämta mallarna. Försök igen.',
|
|
message_en: 'Could not load the templates. Please try again.',
|
|
},
|
|
},
|
|
500,
|
|
),
|
|
)
|
|
const saveBlob = vi.fn()
|
|
|
|
const result = await downloadFile({
|
|
url: '/api/settings/booking-templates/export',
|
|
filename: 'bokforingsmallar.json',
|
|
saveBlob,
|
|
})
|
|
|
|
expect(saveBlob).not.toHaveBeenCalled()
|
|
expect(result.ok).toBe(false)
|
|
expect(result).toEqual({
|
|
ok: false,
|
|
reason: 'server',
|
|
status: 500,
|
|
message: 'Kunde inte hämta mallarna. Försök igen.',
|
|
})
|
|
})
|
|
|
|
it('falls back to the status message when the error body is not JSON', async () => {
|
|
globalThis.fetch = vi.fn().mockResolvedValue(
|
|
new Response('<html>502 Bad Gateway</html>', {
|
|
status: 502,
|
|
headers: { 'Content-Type': 'text/html' },
|
|
}),
|
|
)
|
|
const saveBlob = vi.fn()
|
|
|
|
const result = await downloadFile({ url: '/x', filename: 'f.json', saveBlob })
|
|
|
|
expect(saveBlob).not.toHaveBeenCalled()
|
|
expect(result).toEqual({
|
|
ok: false,
|
|
reason: 'server',
|
|
status: 502,
|
|
message: 'Servern är tillfälligt otillgänglig. Försök igen om en stund.',
|
|
})
|
|
})
|
|
|
|
it('reports a server error in English for an English UI', async () => {
|
|
globalThis.fetch = vi.fn().mockResolvedValue(
|
|
jsonResponse({ error: { code: 'INTERNAL_ERROR', message: 'Ett oväntat serverfel uppstod.' } }, 500),
|
|
)
|
|
const saveBlob = vi.fn()
|
|
|
|
const result = await downloadFile({
|
|
url: '/x',
|
|
filename: 'f.json',
|
|
locale: 'en',
|
|
saveBlob,
|
|
})
|
|
|
|
expect(saveBlob).not.toHaveBeenCalled()
|
|
expect(result).toMatchObject({ ok: false, reason: 'server', message: 'Internal server error.' })
|
|
})
|
|
|
|
it('writes NO file when the request throws', async () => {
|
|
globalThis.fetch = vi.fn().mockRejectedValue(new TypeError('fetch failed'))
|
|
const saveBlob = vi.fn()
|
|
|
|
const result = await downloadFile({ url: '/x', filename: 'f.json', saveBlob })
|
|
|
|
expect(saveBlob).not.toHaveBeenCalled()
|
|
expect(result).toEqual({
|
|
ok: false,
|
|
reason: 'network',
|
|
message: 'Något gick fel. Försök igen.',
|
|
})
|
|
})
|
|
|
|
it('writes NO file when the body is truncated mid-read', async () => {
|
|
const res = new Response(EXPORT_BODY, { status: 200 })
|
|
vi.spyOn(res, 'blob').mockRejectedValue(new TypeError('network error'))
|
|
globalThis.fetch = vi.fn().mockResolvedValue(res)
|
|
const saveBlob = vi.fn()
|
|
|
|
const result = await downloadFile({ url: '/x', filename: 'f.json', saveBlob })
|
|
|
|
expect(saveBlob).not.toHaveBeenCalled()
|
|
expect(result).toMatchObject({ ok: false, reason: 'network' })
|
|
})
|
|
|
|
it('reports a hung request as a timeout, not as a generic failure', async () => {
|
|
globalThis.fetch = hangingFetch()
|
|
const saveBlob = vi.fn()
|
|
|
|
const result = await downloadFile({
|
|
url: '/x',
|
|
filename: 'f.json',
|
|
timeoutMs: 20,
|
|
saveBlob,
|
|
})
|
|
|
|
expect(saveBlob).not.toHaveBeenCalled()
|
|
expect(result).toEqual({ ok: false, reason: 'timeout' })
|
|
// The call site branches on this to say "took too long" instead of the
|
|
// generic "something went wrong".
|
|
expect(result).not.toMatchObject({ reason: 'network' })
|
|
})
|
|
|
|
it('passes the deadline to fetch as an abort signal', async () => {
|
|
const fetchMock = vi.fn().mockResolvedValue(jsonResponse(EXPORT_BODY))
|
|
globalThis.fetch = fetchMock
|
|
|
|
await downloadFile({ url: '/x', filename: 'f.json', saveBlob: vi.fn() })
|
|
|
|
const init = fetchMock.mock.calls[0][1] as RequestInit
|
|
expect(init.signal).toBeInstanceOf(AbortSignal)
|
|
expect(DOWNLOAD_TIMEOUT_MS).toBe(15_000)
|
|
})
|
|
})
|
|
|
|
describe('saveBlobToDisk', () => {
|
|
const originalCreateObjectURL = URL.createObjectURL
|
|
const originalRevokeObjectURL = URL.revokeObjectURL
|
|
|
|
function stubDom() {
|
|
const anchor = { href: '', download: '', rel: '', click: vi.fn(), remove: vi.fn() }
|
|
const body = { appendChild: vi.fn() }
|
|
;(globalThis as Record<string, unknown>).document = {
|
|
createElement: vi.fn(() => anchor),
|
|
body,
|
|
}
|
|
const createObjectURL = vi.fn(() => 'blob:test-url')
|
|
const revokeObjectURL = vi.fn()
|
|
URL.createObjectURL = createObjectURL as typeof URL.createObjectURL
|
|
URL.revokeObjectURL = revokeObjectURL as typeof URL.revokeObjectURL
|
|
return { anchor, body, revokeObjectURL }
|
|
}
|
|
|
|
afterEach(() => {
|
|
delete (globalThis as Record<string, unknown>).document
|
|
URL.createObjectURL = originalCreateObjectURL
|
|
URL.revokeObjectURL = originalRevokeObjectURL
|
|
vi.useRealTimers()
|
|
})
|
|
|
|
it('defers object-URL revocation so the browser can finish reading the blob', () => {
|
|
// Revoking synchronously in a finally right after a.click() can abort the
|
|
// save in Firefox/Safari: the click only STARTS the download.
|
|
vi.useFakeTimers()
|
|
const { anchor, revokeObjectURL } = stubDom()
|
|
|
|
saveBlobToDisk(new Blob(['x']), 'f.json')
|
|
|
|
expect(anchor.click).toHaveBeenCalledTimes(1)
|
|
expect(revokeObjectURL).not.toHaveBeenCalled()
|
|
|
|
vi.advanceTimersByTime(OBJECT_URL_REVOKE_DELAY_MS - 1)
|
|
expect(revokeObjectURL).not.toHaveBeenCalled()
|
|
|
|
vi.advanceTimersByTime(1)
|
|
expect(revokeObjectURL).toHaveBeenCalledTimes(1)
|
|
expect(revokeObjectURL).toHaveBeenCalledWith('blob:test-url')
|
|
})
|
|
|
|
it('revokes immediately when the click never happened', () => {
|
|
// Nothing is reading the URL if the DOM threw before the click, so the
|
|
// blob memory is released right away instead of leaking for 10 seconds.
|
|
vi.useFakeTimers()
|
|
const { body, revokeObjectURL } = stubDom()
|
|
body.appendChild.mockImplementation(() => {
|
|
throw new Error('detached document')
|
|
})
|
|
|
|
expect(() => saveBlobToDisk(new Blob(['x']), 'f.json')).toThrow('detached document')
|
|
expect(revokeObjectURL).toHaveBeenCalledTimes(1)
|
|
expect(revokeObjectURL).toHaveBeenCalledWith('blob:test-url')
|
|
})
|
|
})
|