2b38717c05
Queue reviewable Whisper drafts from the song list and lyrics editor. Preserve line breaks within one timed cue across editing, saving, reporting, and service views. Add storage and listening analytics with a durable metadata collector, related-search depth, video limits, thumbnail storage, and a browsable metadata library.
84 lines
8.6 KiB
JavaScript
84 lines
8.6 KiB
JavaScript
import { test, expect, beforeAll, afterAll } from 'bun:test';
|
|
import { mkdtempSync, rmSync } from 'node:fs';
|
|
import { tmpdir } from 'node:os';
|
|
import { join } from 'node:path';
|
|
import { Hono } from 'hono';
|
|
const root = mkdtempSync(join(tmpdir(), 'ytp-analytics-'));
|
|
process.env.DB_PATH = join(root, 'test.db');
|
|
const { db, initDb, upsertMedia } = await import('./db.js');
|
|
const { registerAnalyticsRoutes, storageAnalytics } = await import('./admin-analytics.js');
|
|
const catalog = await import('./video-catalog.js');
|
|
const originalFetch = globalThis.fetch;
|
|
globalThis.fetch = async () => new Response(new Uint8Array([1,2,3]), { headers: { 'Content-Type': 'image/jpeg' } });
|
|
let app, runner, calls = [], serial = 0;
|
|
const adminAuth = async (c, next) => c.req.header('x-test-admin') === 'yes' ? next() : c.json({ ok: false }, 401);
|
|
const get = path => app.request(path, { headers: { 'x-test-admin': 'yes' } });
|
|
const post = (path, body = {}) => app.request(path, { method: 'POST', headers: { 'x-test-admin': 'yes', 'Content-Type': 'application/json' }, body: JSON.stringify(body) });
|
|
const fakeExtractor = async args => {
|
|
calls.push(args);
|
|
if (args[0].startsWith('ytsearch')) return Array.from({ length: Number(args[0].match(/^ytsearch(\d+)/)[1]) }, () => ({ id: String(++serial).padStart(11, '0'), title: 'Worship ' + serial, channel: 'Channel ' + serial })).map(JSON.stringify).join('\n');
|
|
const id = args.at(-1).split('v=')[1];
|
|
return JSON.stringify({ id, title: 'Enriched ' + id, channel: 'Related ' + id, tags: ['Topic ' + id], duration: 60, description: 'Full description '.repeat(200), view_count: 1234, formats: [{ format_id: '140', acodec: 'aac', url: 'https://temporary.example', http_headers: { Cookie: 'omitted' } }] });
|
|
};
|
|
beforeAll(async () => { await initDb(); app = new Hono(); runner = registerAnalyticsRoutes(app, { adminAuth, runYtdlp: fakeExtractor, autoStart: false, paths: [{ label: 'DB', path: root }] }); });
|
|
afterAll(async () => { await catalog.drainThumbnails(); globalThis.fetch = originalFetch; db.close(); rmSync(root, { recursive: true, force: true }); });
|
|
test('admin routes reject unauthenticated requests and validate collector limits', async () => {
|
|
for (const path of ['/api/admin/analytics','/api/admin/metadata','/api/admin/metadata/00000000001','/api/admin/collections']) expect((await app.request(path)).status).toBe(401);
|
|
expect((await app.request('/api/admin/collections', { method: 'POST' })).status).toBe(401);
|
|
for (const body of [{ query: '', maxVideos: 5, depth: 0 }, { query: 'worship', maxVideos: 501, depth: 0 }, { query: 'worship', maxVideos: 5, depth: 4 }]) expect((await post('/api/admin/collections', body)).status).toBe(400);
|
|
for (let i = 0; i < 3; i++) expect((await post('/api/admin/collections', { query: 'queue ' + i, maxVideos: 1, depth: 0 })).status).toBe(202);
|
|
expect((await post('/api/admin/collections', { query: 'queue 4', maxVideos: 1, depth: 0 })).status).toBe(429);
|
|
for (const job of (await (await get('/api/admin/collections')).json()).jobs) await post('/api/admin/collections/' + job.id + '/cancel');
|
|
});
|
|
test('depth zero stores full descriptive metadata and actual thumbnail bytes', async () => {
|
|
calls = []; await post('/api/admin/collections', { query: 'root worship', maxVideos: 4, depth: 0 }); await runner.runNext(); await catalog.drainThumbnails();
|
|
const job = (await (await get('/api/admin/collections')).json()).jobs.find(j => j.query === 'root worship');
|
|
expect(job.status).toBe('complete'); expect(job.collected).toBe(4); expect(job.enriched).toBe(4); expect(calls.filter(a => a[0].startsWith('ytsearch'))).toHaveLength(1);
|
|
const videos = (await (await get('/api/admin/metadata')).json()).videos;
|
|
expect(videos).toHaveLength(4); expect(videos.every(v => v.enriched && v.thumbnailBytes === 3)).toBe(true);
|
|
const detail = (await (await get('/api/admin/metadata/' + videos[0].id)).json()).metadata;
|
|
expect(detail.description.length).toBeGreaterThan(1200); expect(detail.view_count).toBe(1234); expect(detail.formats[0].url).toBeUndefined(); expect(detail.formats[0].http_headers).toBeUndefined();
|
|
});
|
|
test('related depth follows channels/topics but caps unique videos across all searches', async () => {
|
|
calls = []; await post('/api/admin/collections', { query: 'deep worship', maxVideos: 10, depth: 2 }); await runner.runNext();
|
|
const job = (await (await get('/api/admin/collections')).json()).jobs.find(j => j.query === 'deep worship');
|
|
expect(job.status).toBe('complete'); expect(job.collected).toBe(10); expect(job.enriched).toBe(10);
|
|
const searches = calls.filter(a => a[0].startsWith('ytsearch')); expect(searches.length).toBeGreaterThan(1); expect(searches[1][0]).toContain('Related'); expect(searches.length).toBeLessThanOrEqual(24);
|
|
});
|
|
test('expired jobs resume pending videos without repeating their search', async () => {
|
|
await db.execute({ sql: "INSERT INTO metadata_collections (id,query,max_videos,depth,status,state,lease_until,created_at,updated_at) VALUES ('restart','resume',1,0,'running',?,0,0,0)", args: [JSON.stringify({ ids: ['99999999999'], queries: [], pending: [{ id: '99999999999', level: 0 }] })] });
|
|
calls = []; await runner.runNext(); const job = (await (await get('/api/admin/collections')).json()).jobs.find(j => j.id === 'restart');
|
|
expect(job.status).toBe('complete'); expect(job.collected).toBe(1); expect(job.enriched).toBe(1); expect(calls).toHaveLength(1);
|
|
});
|
|
test('storage totals count table aggregates once and use actual disk capacity', async () => {
|
|
await upsertMedia('aaaaaaaaaaa', { status: 'ready', size: 2048, duration: 120 });
|
|
await db.execute("INSERT INTO listening_daily (fingerprint,day,video_id,plays) VALUES ('listener','2026-10-03','aaaaaaaaaaa',3)");
|
|
const result = await storageAnalytics([{ label: 'DB', path: root }, { label: 'Absent', path: root + '/missing' }]);
|
|
expect(Number(result.media.find(r => r.status === 'ready').bytes)).toBe(2048); expect(Number(result.listening.plays)).toBe(3); expect(result.volumes[0].free).toBeGreaterThan(0); expect(result.volumes[1].unavailable).toBe(true);
|
|
expect(result.sources.find(r => r.source === 'collector')).toBeDefined(); expect((await get('/api/admin/metadata?q=Related&offset=0')).status).toBe(200); expect((await get('/api/admin/metadata?q=%25')).status).toBe(200);
|
|
});
|
|
test('extraction errors remain visible while discovered cards stay stored', async () => {
|
|
const failureApp = new Hono(); const failed = registerAnalyticsRoutes(failureApp, { adminAuth, autoStart: false, runYtdlp: async a => a[0].startsWith('ytsearch') ? JSON.stringify({ id: 'failure0001', title: 'Discovered before failure' }) : Promise.reject(Error('Unavailable video')) });
|
|
await post('/api/admin/collections', { query: 'failure', maxVideos: 1, depth: 0 }); await failed.runNext();
|
|
const job = (await (await get('/api/admin/collections')).json()).jobs.find(j => j.query === 'failure');
|
|
expect(job.status).toBe('complete'); expect(job.failed).toBe(1); expect(job.collected).toBe(1); expect(job.errors[0].error).toBe('Unavailable video');
|
|
});
|
|
|
|
test('duplicate search cards do not consume slots before unique results', async () => {
|
|
const a = { id: 'unique00001', title: 'Unique A' }, b = { id: 'unique00002', title: 'Unique B' };
|
|
const worker = registerAnalyticsRoutes(new Hono(), { adminAuth, autoStart: false, runYtdlp: async args => args[0].startsWith('ytsearch') ? [a,a,b].map(JSON.stringify).join('\n') : JSON.stringify(args.at(-1).endsWith(a.id) ? a : b) });
|
|
await post('/api/admin/collections', { query: 'duplicates', maxVideos: 2, depth: 0 }); await worker.runNext();
|
|
const job = (await (await get('/api/admin/collections')).json()).jobs.find(j => j.query === 'duplicates');
|
|
expect(job.collected).toBe(2); expect(job.enriched).toBe(2);
|
|
});
|
|
test('cancelling an in-flight search prevents storing its returned cards', async () => {
|
|
let started, release;
|
|
const began = new Promise(resolve => { started = resolve; }), pause = new Promise(resolve => { release = resolve; });
|
|
const worker = registerAnalyticsRoutes(new Hono(), { adminAuth, autoStart: false, runYtdlp: async () => { started(); await pause; return JSON.stringify({ id: 'cancel00001', title: 'Should not save' }); } });
|
|
const queued = await (await post('/api/admin/collections', { query: 'cancel while searching', maxVideos: 1, depth: 0 })).json();
|
|
const work = worker.runNext(); await began; await post('/api/admin/collections/' + queued.id + '/cancel'); release(); await work;
|
|
const job = (await (await get('/api/admin/collections')).json()).jobs.find(j => j.id === queued.id);
|
|
expect(job.status).toBe('cancelled'); expect(job.failed).toBe(0);
|
|
expect((await db.execute("SELECT * FROM video_meta WHERE id='cancel00001'")).rows).toHaveLength(0);
|
|
});
|