Skip to content
← Public packages

@kentcdodds/linkedin

Headless helpers for LinkedIn identity, requests, and guarded posting using the saved linkedin OAuth integration.

FollowFork

Files

video-upload.test.ts

242 lines · 6.5 KB · TypeScript
import { test } from 'node:test'
import assert from 'node:assert/strict'
import { DatabaseSync } from 'node:sqlite'
import {
	uploadVideoBounded,
	inspectVideoJob,
	type VideoApi,
	type VideoJob,
} from '../src/video-upload-engine.ts'
import { videoStore } from '../src/video-upload-store.ts'
const p = {
	uploadKey: 'test-job',
	sourceId: 'original-source',
	sourceUrl: 'https://source.test/file?private=DO_NOT_STORE',
	confirm: true,
}
function fixture() {
	const db = new DatabaseSync(':memory:')
	const store = videoStore({
		sql: async (q, b = []) => ({ rows: db.prepare(q).all(...(b as any[])) }),
	})
	const bytes = new Uint8Array(11).map((_, i) => i)
	let registered = 0,
		parts = 0,
		finished = 0,
		etag = '"v1"',
		owner = 'urn:li:person:fixture',
		state = 'AVAILABLE'
	const api: VideoApi = {
		store,
		sourceFetch: async (_u, init) => {
			if (init?.method === 'HEAD')
				return new Response(null, { headers: { etag, 'content-length': '11' } })
			const range = new Headers(init?.headers).get('range')!
			const m = /bytes=(\d+)-(\d+)/.exec(range)!
			const a = +m[1],
				b = +m[2]
			return new Response(bytes.slice(a, b + 1), {
				status: 206,
				headers: { etag, 'content-range': `bytes ${a}-${b}/11` },
			})
		},
		owner: async () => owner,
		register: async () => {
			registered++
			return {
				value: {
					video: 'urn:li:video:fixture',
					uploadToken: 'DO_NOT_STORE_TOKEN',
					uploadInstructions: [
						{
							firstByte: 0,
							lastByte: 5,
							uploadUrl: 'https://www.linkedin.com/upload?private=DO_NOT_STORE',
						},
						{
							firstByte: 6,
							lastByte: 10,
							uploadUrl: 'https://www.linkedin.com/upload?private=DO_NOT_STORE',
						},
					],
				},
			}
		},
		part: async (_u, b) => {
			parts++
			return 'etag-' + parts
		},
		finalize: async () => {
			finished++
		},
		status: async () => state,
	}
	return {
		api,
		db,
		counts: () => ({ registered, parts, finished }),
		setEtag: (e) => (etag = e),
		setOwner: (o) => (owner = o),
		setState: (s) => (state = s),
	}
}
test('bounded parts checkpoint acknowledgements; repeated call never uploads/posts again', async () => {
	const f = fixture()
	try {
		assert.equal((await uploadVideoBounded(p, f.api)).state, 'available')
		assert.equal((await uploadVideoBounded(p, f.api)).state, 'available')
		assert.deepEqual(f.counts(), { registered: 1, parts: 2, finished: 1 })
		const persisted = JSON.stringify(f.db.prepare('select * from linkedin_upload_jobs_v1').all())
		assert(!persisted.includes('DO_NOT_STORE'))
		assert(!persisted.includes('https://'))
		assert.equal((await f.api.store.get(p.uploadKey))?.ackOffset, 11)
	} finally {
		f.db.close()
	}
})
test('lost final response resumes through status only', async () => {
	const f = fixture()
	f.api.finalize = async () => {
		throw new Error('private URL must not escape')
	}
	try {
		await assert.rejects(
			uploadVideoBounded(p, f.api),
			(e) => !String(e).includes('private URL') && /checkpoint preserved/.test(String(e)),
		)
		assert.equal((await uploadVideoBounded(p, f.api)).state, 'available')
		assert.equal(f.counts().registered, 1)
	} finally {
		f.db.close()
	}
})
test('unknown registration result never creates a second session', async () => {
	const f = fixture()
	let calls = 0
	f.api.register = async () => {
		calls++
		throw new Error('lost')
	}
	try {
		await assert.rejects(uploadVideoBounded(p, f.api))
		assert.equal((await uploadVideoBounded(p, f.api)).state, 'needs_reconciliation')
		assert.equal(calls, 1)
	} finally {
		f.db.close()
	}
})
test('changed source/account/sourceId fail before more writes', async () => {
	for (const mode of ['etag', 'owner', 'sourceId', 'sourceUrl']) {
		const f = fixture()
		try {
			await uploadVideoBounded(p, f.api)
			if (mode === 'etag') f.setEtag('"v2"')
			if (mode === 'owner') f.setOwner('urn:li:person:other')
			await assert.rejects(
				uploadVideoBounded(
					{
						...p,
						...(mode === 'sourceId' ? { sourceId: 'other' } : {}),
						...(mode === 'sourceUrl' ? { sourceUrl: 'https://other.test/video' } : {}),
					},
					f.api,
				),
				/changed/,
			)
			assert.equal(f.counts().registered, 1)
		} finally {
			f.db.close()
		}
	}
})
test('missing validator, partial ranges, oversized provider part and 429 never trigger retries', async () => {
	for (const mode of ['validator', 'partial', 'oversize', '429']) {
		const f = fixture()
		try {
			if (mode === 'validator') f.setEtag('W/"weak"')
			if (mode === 'partial') {
				const original = f.api.sourceFetch
				f.api.sourceFetch = async (u, i) =>
					i?.method === 'HEAD'
						? original(u, i)
						: new Response('x', {
								status: 206,
								headers: { etag: '"v1"', 'content-range': 'bytes 0-5/11' },
							})
			}
			if (mode === 'oversize')
				f.api.register = async () => ({
					video: 'urn:li:video:fixture',
					uploadInstructions: [{ firstByte: 0, lastByte: 9 * 1024 * 1024, uploadUrl: 'sensitive' }],
				})
			if (mode === '429') {
				f.api.part = async () => {
					throw Object.assign(new Error('rate limited'), { status: 429 })
				}
			}
			await assert.rejects(uploadVideoBounded(p, f.api))
			assert(f.counts().registered <= 1)
			assert.equal(f.counts().finished, 0)
		} finally {
			f.db.close()
		}
	}
})
test('SQL checkpoint creation and CAS exclude conflicting writers', async () => {
	const f = fixture()
	try {
		const j: VideoJob = {
			key: 'other',
			identity: 'i',
			owner: 'o',
			size: 1,
			phase: 'starting',
			version: 0,
			partIds: [],
			ackOffset: 0,
		}
		assert(await f.api.store.insert(j))
		assert(!(await f.api.store.insert(j)))
		assert(await f.api.store.save(j, 0))
		assert.equal(await f.api.store.save(j, 0), null)
	} finally {
		f.db.close()
	}
})
test('manual 308 sources are disposed before registration; AbortError and 401 never retry mutations', async () => {
	const f = fixture()
	let cancelled = false
	f.api.sourceFetch = async () =>
		new Response(
			new ReadableStream({
				cancel() {
					cancelled = true
				},
			}),
			{ status: 308, headers: { location: 'https://untrusted.test' } },
		)
	try {
		await assert.rejects(uploadVideoBounded(p, f.api))
		assert(cancelled)
		assert.equal(f.counts().registered, 0)
	} finally {
		f.db.close()
	}
	for (const code of ['AbortError', '401']) {
		const g = fixture()
		g.setState('WAITING_UPLOAD')
		let n = 0
		g.api.part = async () => {
			n++
			throw Object.assign(new Error('stopped'), { name: code, status: 401 })
		}
		try {
			await assert.rejects(uploadVideoBounded(p, g.api))
			assert.equal(n, 1)
			assert.equal((await uploadVideoBounded(p, g.api)).state, 'needs_reconciliation')
			assert.equal(n, 1)
		} finally {
			g.db.close()
		}
	}
})