Å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.
298 lines
11 KiB
TypeScript
298 lines
11 KiB
TypeScript
import { createHash } from 'node:crypto'
|
|
import { describe, it, expect, beforeEach, vi } from 'vitest'
|
|
import {
|
|
DriveFileGoneError,
|
|
ensureFolder,
|
|
getFileMeta,
|
|
updateFile,
|
|
uploadFile,
|
|
} from '../google-drive'
|
|
|
|
beforeEach(() => {
|
|
vi.restoreAllMocks()
|
|
})
|
|
|
|
describe('ensureFolder', () => {
|
|
it('returns existing folder when found', async () => {
|
|
const fetchMock = vi.spyOn(globalThis, 'fetch').mockResolvedValue(
|
|
new Response(
|
|
JSON.stringify({ files: [{ id: 'folder-1', name: 'gnubok' }] }),
|
|
{ status: 200, headers: { 'Content-Type': 'application/json' } }
|
|
)
|
|
)
|
|
const folder = await ensureFolder('at', 'gnubok', null)
|
|
expect(folder.id).toBe('folder-1')
|
|
// Only the search call; no create needed.
|
|
expect(fetchMock).toHaveBeenCalledTimes(1)
|
|
const url = fetchMock.mock.calls[0][0] as string
|
|
expect(url).toContain('/files?q=')
|
|
expect(decodeURIComponent(url)).toContain(`name = 'gnubok'`)
|
|
expect(decodeURIComponent(url)).toContain(`'root' in parents`)
|
|
})
|
|
|
|
it('creates a new folder when none exists', async () => {
|
|
const fetchMock = vi
|
|
.spyOn(globalThis, 'fetch')
|
|
.mockResolvedValueOnce(
|
|
new Response(JSON.stringify({ files: [] }), {
|
|
status: 200,
|
|
headers: { 'Content-Type': 'application/json' },
|
|
})
|
|
)
|
|
.mockResolvedValueOnce(
|
|
new Response(JSON.stringify({ id: 'new-id', name: 'gnubok' }), {
|
|
status: 200,
|
|
headers: { 'Content-Type': 'application/json' },
|
|
})
|
|
)
|
|
const folder = await ensureFolder('at', 'gnubok', null)
|
|
expect(folder.id).toBe('new-id')
|
|
expect(fetchMock).toHaveBeenCalledTimes(2)
|
|
const createCall = fetchMock.mock.calls[1]
|
|
expect((createCall[1] as RequestInit).method).toBe('POST')
|
|
const body = JSON.parse(String((createCall[1] as RequestInit).body))
|
|
expect(body.mimeType).toBe('application/vnd.google-apps.folder')
|
|
expect(body.name).toBe('gnubok')
|
|
})
|
|
|
|
it('escapes single quotes in folder name and scopes to parent', async () => {
|
|
const fetchMock = vi
|
|
.spyOn(globalThis, 'fetch')
|
|
.mockResolvedValueOnce(
|
|
// findFolderByName → match so we never hit create.
|
|
new Response(JSON.stringify({ files: [{ id: 'x', name: "Kalle's" }] }), {
|
|
status: 200,
|
|
headers: { 'Content-Type': 'application/json' },
|
|
})
|
|
)
|
|
await ensureFolder('at', "Kalle's", 'parent-id')
|
|
const searchUrl = decodeURIComponent(fetchMock.mock.calls[0][0] as string)
|
|
expect(searchUrl).toContain(`name = 'Kalle\\'s'`)
|
|
expect(searchUrl).toContain(`'parent-id' in parents`)
|
|
})
|
|
})
|
|
|
|
/** Resumable init response: 200 with a session URL in the Location header. */
|
|
function initResponse(): Response {
|
|
return new Response(null, {
|
|
status: 200,
|
|
headers: { Location: 'https://upload.session/xyz' },
|
|
})
|
|
}
|
|
|
|
function fileResponse(
|
|
file: Record<string, unknown>,
|
|
status = 200
|
|
): Response {
|
|
return new Response(JSON.stringify(file), {
|
|
status,
|
|
headers: { 'Content-Type': 'application/json' },
|
|
})
|
|
}
|
|
|
|
function md5Of(data: ArrayBuffer): string {
|
|
return createHash('md5').update(Buffer.from(data)).digest('hex')
|
|
}
|
|
|
|
describe('uploadFile (resumable)', () => {
|
|
it('initiates a resumable session with metadata, then uploads the bytes', async () => {
|
|
const data = new Uint8Array([1, 2, 3, 4, 5]).buffer
|
|
const fetchMock = vi
|
|
.spyOn(globalThis, 'fetch')
|
|
.mockResolvedValueOnce(initResponse())
|
|
.mockResolvedValueOnce(
|
|
fileResponse({
|
|
id: 'file-123',
|
|
name: 'arkiv.zip',
|
|
size: '2048',
|
|
webViewLink: 'https://drive.google.com/file/d/file-123/view',
|
|
md5Checksum: md5Of(data),
|
|
})
|
|
)
|
|
|
|
const result = await uploadFile('access-tok', 'folder-1', 'arkiv.zip', data)
|
|
|
|
expect(result.id).toBe('file-123')
|
|
expect(result.size_bytes).toBe(2048)
|
|
expect(result.md5_checksum).toBe(md5Of(data))
|
|
|
|
const [initUrl, initInit] = fetchMock.mock.calls[0]
|
|
expect(initUrl).toContain('uploadType=resumable')
|
|
expect((initInit as RequestInit).method).toBe('POST')
|
|
const initHeaders = (initInit as RequestInit).headers as Record<string, string>
|
|
expect(initHeaders.Authorization).toBe('Bearer access-tok')
|
|
expect(initHeaders['X-Upload-Content-Length']).toBe('5')
|
|
const metadata = JSON.parse(String((initInit as RequestInit).body))
|
|
expect(metadata.name).toBe('arkiv.zip')
|
|
expect(metadata.parents).toEqual(['folder-1'])
|
|
|
|
const [chunkUrl, chunkInit] = fetchMock.mock.calls[1]
|
|
expect(chunkUrl).toBe('https://upload.session/xyz')
|
|
expect((chunkInit as RequestInit).method).toBe('PUT')
|
|
const chunkHeaders = (chunkInit as RequestInit).headers as Record<string, string>
|
|
expect(chunkHeaders['Content-Range']).toBe('bytes 0-4/5')
|
|
})
|
|
|
|
it('splits large payloads into chunks and follows 308 continuations', async () => {
|
|
const CHUNK = 8 * 1024 * 1024
|
|
const data = new Uint8Array(CHUNK + 10).buffer
|
|
const fetchMock = vi
|
|
.spyOn(globalThis, 'fetch')
|
|
.mockResolvedValueOnce(initResponse())
|
|
.mockResolvedValueOnce(
|
|
new Response(null, {
|
|
status: 308,
|
|
headers: { Range: `bytes=0-${CHUNK - 1}` },
|
|
})
|
|
)
|
|
.mockResolvedValueOnce(
|
|
fileResponse({ id: 'f-1', name: 'big.zip', md5Checksum: md5Of(data) })
|
|
)
|
|
|
|
const result = await uploadFile('at', 'folder', 'big.zip', data)
|
|
expect(result.id).toBe('f-1')
|
|
expect(fetchMock).toHaveBeenCalledTimes(3)
|
|
const firstRange = (fetchMock.mock.calls[1][1] as RequestInit)
|
|
.headers as Record<string, string>
|
|
expect(firstRange['Content-Range']).toBe(`bytes 0-${CHUNK - 1}/${CHUNK + 10}`)
|
|
const secondRange = (fetchMock.mock.calls[2][1] as RequestInit)
|
|
.headers as Record<string, string>
|
|
expect(secondRange['Content-Range']).toBe(`bytes ${CHUNK}-${CHUNK + 9}/${CHUNK + 10}`)
|
|
})
|
|
|
|
it('retries a chunk on 5xx before giving up', async () => {
|
|
const data = new Uint8Array([7, 7]).buffer
|
|
const fetchMock = vi
|
|
.spyOn(globalThis, 'fetch')
|
|
.mockResolvedValueOnce(initResponse())
|
|
.mockResolvedValueOnce(new Response('flaky', { status: 502 }))
|
|
.mockResolvedValueOnce(
|
|
fileResponse({ id: 'f-1', name: 'a.zip', md5Checksum: md5Of(data) })
|
|
)
|
|
|
|
const result = await uploadFile('at', 'folder', 'a.zip', data)
|
|
expect(result.id).toBe('f-1')
|
|
expect(fetchMock).toHaveBeenCalledTimes(3)
|
|
})
|
|
|
|
it('throws with Drive error body when the init fails', async () => {
|
|
vi.spyOn(globalThis, 'fetch').mockResolvedValue(
|
|
new Response('quota exceeded', { status: 403 })
|
|
)
|
|
await expect(
|
|
uploadFile('at', 'folder', 'a.zip', new Uint8Array(1).buffer)
|
|
).rejects.toThrow(/403/)
|
|
})
|
|
|
|
it('retries the whole upload once on checksum mismatch, then succeeds', async () => {
|
|
const data = new Uint8Array([1, 2, 3, 4, 5]).buffer
|
|
const fetchMock = vi
|
|
.spyOn(globalThis, 'fetch')
|
|
.mockResolvedValueOnce(initResponse())
|
|
.mockResolvedValueOnce(
|
|
fileResponse({ id: 'f-1', name: 'a.zip', md5Checksum: 'corrupted' })
|
|
)
|
|
.mockResolvedValueOnce(initResponse())
|
|
.mockResolvedValueOnce(
|
|
fileResponse({ id: 'f-2', name: 'a.zip', md5Checksum: md5Of(data) })
|
|
)
|
|
|
|
const result = await uploadFile('at', 'folder', 'a.zip', data)
|
|
expect(result.id).toBe('f-2')
|
|
expect(fetchMock).toHaveBeenCalledTimes(4)
|
|
})
|
|
|
|
it('throws after two checksum mismatches', async () => {
|
|
let call = 0
|
|
vi.spyOn(globalThis, 'fetch').mockImplementation(async () => {
|
|
call++
|
|
return call % 2 === 1
|
|
? initResponse()
|
|
: fileResponse({ id: 'f-1', name: 'a.zip', md5Checksum: 'corrupted' })
|
|
})
|
|
await expect(
|
|
uploadFile('at', 'folder', 'a.zip', new Uint8Array([9]).buffer)
|
|
).rejects.toThrow(/checksum mismatch/)
|
|
})
|
|
|
|
it('trusts the upload when Drive omits md5Checksum', async () => {
|
|
vi.spyOn(globalThis, 'fetch')
|
|
.mockResolvedValueOnce(initResponse())
|
|
.mockResolvedValueOnce(fileResponse({ id: 'f-1', name: 'a.zip' }))
|
|
const result = await uploadFile('at', 'folder', 'a.zip', new Uint8Array([9]).buffer)
|
|
expect(result.id).toBe('f-1')
|
|
expect(result.md5_checksum).toBeUndefined()
|
|
})
|
|
})
|
|
|
|
describe('updateFile (resumable, in place)', () => {
|
|
it('PATCHes an existing file id and uploads the new content', async () => {
|
|
const data = new Uint8Array([4, 5, 6]).buffer
|
|
const fetchMock = vi
|
|
.spyOn(globalThis, 'fetch')
|
|
.mockResolvedValueOnce(initResponse())
|
|
.mockResolvedValueOnce(
|
|
fileResponse({ id: 'file-9', name: 'Arkiv 2024.zip', md5Checksum: md5Of(data) })
|
|
)
|
|
|
|
const result = await updateFile('at', 'file-9', data)
|
|
expect(result.id).toBe('file-9')
|
|
|
|
const [initUrl, initInit] = fetchMock.mock.calls[0]
|
|
expect(initUrl).toContain('/file-9?uploadType=resumable')
|
|
expect((initInit as RequestInit).method).toBe('PATCH')
|
|
// No metadata body on a content-only update.
|
|
expect((initInit as RequestInit).body).toBeUndefined()
|
|
})
|
|
|
|
it('throws DriveFileGoneError when the file id no longer exists', async () => {
|
|
vi.spyOn(globalThis, 'fetch').mockResolvedValue(
|
|
new Response('not found', { status: 404 })
|
|
)
|
|
await expect(
|
|
updateFile('at', 'gone-id', new Uint8Array([1]).buffer)
|
|
).rejects.toBeInstanceOf(DriveFileGoneError)
|
|
})
|
|
})
|
|
|
|
describe('getFileMeta', () => {
|
|
it('returns metadata with trashed flag', async () => {
|
|
const fetchMock = vi.spyOn(globalThis, 'fetch').mockResolvedValue(
|
|
new Response(JSON.stringify({ id: 'f-1', name: 'gnubok', trashed: true }), {
|
|
status: 200,
|
|
headers: { 'Content-Type': 'application/json' },
|
|
})
|
|
)
|
|
const meta = await getFileMeta('at', 'f-1')
|
|
expect(meta).toEqual({ id: 'f-1', name: 'gnubok', trashed: true })
|
|
const url = fetchMock.mock.calls[0][0] as string
|
|
expect(url).toContain('/files/f-1')
|
|
expect(url).toContain('fields=id,name,trashed')
|
|
})
|
|
|
|
it('defaults trashed to false when the field is absent', async () => {
|
|
vi.spyOn(globalThis, 'fetch').mockResolvedValue(
|
|
new Response(JSON.stringify({ id: 'f-1', name: 'gnubok' }), {
|
|
status: 200,
|
|
headers: { 'Content-Type': 'application/json' },
|
|
})
|
|
)
|
|
const meta = await getFileMeta('at', 'f-1')
|
|
expect(meta?.trashed).toBe(false)
|
|
})
|
|
|
|
it('returns null on 404 (deleted or invisible to the scope)', async () => {
|
|
vi.spyOn(globalThis, 'fetch').mockResolvedValue(
|
|
new Response('not found', { status: 404 })
|
|
)
|
|
expect(await getFileMeta('at', 'gone')).toBeNull()
|
|
})
|
|
|
|
it('throws on other errors', async () => {
|
|
vi.spyOn(globalThis, 'fetch').mockResolvedValue(
|
|
new Response('server error', { status: 500 })
|
|
)
|
|
await expect(getFileMeta('at', 'f-1')).rejects.toThrow(/500/)
|
|
})
|
|
})
|