lucille-node 0.0.1

package/integration-test.js

@@ -0,0 +1,346 @@
+#!/usr/bin/env node
+/**
+ * Lucille Integration Tests
+ *
+ * Tests all API endpoints against a running lucille instance.
+ *
+ * Usage:
+ *   node --env-file=.env integration-test.js                    # defaults to http://localhost:5444
+ *   node --env-file=.env integration-test.js http://localhost:5444
+ *   SERVER_URL=https://lucille.example.com node integration-test.js
+ *
+ * Options:
+ *   --skip-upload   Skip the video file upload test (skips DO Spaces + seeder)
+ */
+
+import sessionless from 'sessionless-node';
+
+const SERVER_URL = (process.argv[2] && !process.argv[2].startsWith('--'))
+  ? process.argv[2].replace(/\/$/, '')
+  : (process.env.SERVER_URL || 'http://localhost:5444');
+
+const SKIP_UPLOAD = process.argv.includes('--skip-upload');
+
+// ── result tracking ───────────────────────────────────────────────────────────
+
+let passed = 0;
+let failed = 0;
+const failures = [];
+
+function pass(name) {
+  passed++;
+  console.log(`  ✅ ${name}`);
+}
+
+function fail(name, reason) {
+  failed++;
+  failures.push({ name, reason });
+  console.log(`  ❌ ${name}: ${reason}`);
+}
+
+function section(title) {
+  console.log(`\n── ${title} ${'─'.repeat(Math.max(0, 50 - title.length))}`);
+}
+
+// ── HTTP helpers ──────────────────────────────────────────────────────────────
+
+async function get(route) {
+  const res = await fetch(`${SERVER_URL}${route}`);
+  return { status: res.status, body: await res.json().catch(() => ({})) };
+}
+
+async function put(route, body) {
+  const res = await fetch(`${SERVER_URL}${route}`, {
+    method: 'PUT',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+  return { status: res.status, body: await res.json().catch(() => ({})) };
+}
+
+async function post(route, body) {
+  const res = await fetch(`${SERVER_URL}${route}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+  return { status: res.status, body: await res.json().catch(() => ({})) };
+}
+
+async function putFile(route, fileBuffer, filename, timestamp, signature) {
+  const form = new FormData();
+  const blob = new Blob([fileBuffer], { type: 'video/mp4' });
+  form.append('video', blob, filename);
+
+  const res = await fetch(`${SERVER_URL}${route}`, {
+    method: 'PUT',
+    headers: {
+      'x-pn-timestamp': timestamp,
+      'x-pn-signature': signature,
+    },
+    body: form,
+  });
+  return { status: res.status, body: await res.json().catch(() => ({})) };
+}
+
+// ── assertion helpers ─────────────────────────────────────────────────────────
+
+function assertOk(name, { status, body }, extraCheck) {
+  if (status !== 200) {
+    fail(name, `HTTP ${status} — ${JSON.stringify(body).slice(0, 120)}`);
+    return false;
+  }
+  if (extraCheck) {
+    const err = extraCheck(body);
+    if (err) { fail(name, err); return false; }
+  }
+  pass(name);
+  return true;
+}
+
+function assertStatus(name, { status }, expected) {
+  if (status !== expected) {
+    fail(name, `expected HTTP ${expected}, got ${status}`);
+    return false;
+  }
+  pass(name);
+  return true;
+}
+
+// ── sessionless helper ────────────────────────────────────────────────────────
+
+async function makeKeys() {
+  let keys = null;
+  sessionless.getKeys = async () => keys;
+  await sessionless.generateKeys((k) => { keys = k; }, sessionless.getKeys);
+  return keys;
+}
+
+async function sign(message) {
+  return sessionless.sign(message);
+}
+
+// ── tests ─────────────────────────────────────────────────────────────────────
+
+async function testHealth() {
+  section('Health');
+
+  const r = await get('/health');
+  assertOk('GET /health returns ok', r, b => b.status === 'ok' ? null : `status=${b.status}`);
+  assertOk('GET /health has service=lucille', r, b => b.service === 'lucille' ? null : `service=${b.service}`);
+}
+
+async function testStatus() {
+  section('Seeder Status');
+
+  const r = await get('/status');
+  assertOk('GET /status returns torrents array', r, b =>
+    Array.isArray(b.torrents) ? null : 'torrents is not an array');
+  assertOk('GET /status has totalPeers', r, b =>
+    typeof b.totalPeers === 'number' ? null : 'missing totalPeers');
+}
+
+async function testUser() {
+  section('User');
+
+  const keys = await makeKeys();
+
+  if (!keys?.pubKey) {
+    fail('generate sessionless keys', 'generateKeys() did not produce keys');
+    return null;
+  }
+
+  const pubKey = keys.pubKey;
+
+  // ── create user ──
+  const ts1 = Date.now().toString();
+  const sig1 = await sign(ts1 + pubKey);
+
+  const r1 = await put('/user/create', { timestamp: ts1, pubKey, signature: sig1 });
+  if (!assertOk('PUT /user/create returns uuid', r1, b => b.uuid ? null : `missing uuid`)) return null;
+  assertOk('PUT /user/create returns pubKey', r1, b => b.pubKey === pubKey ? null : `pubKey mismatch`);
+
+  const uuid = r1.body.uuid;
+
+  // ── create again returns same user (idempotent) ──
+  const ts2 = Date.now().toString();
+  const sig2 = await sign(ts2 + pubKey);
+  const r2 = await put('/user/create', { timestamp: ts2, pubKey, signature: sig2 });
+  assertOk('PUT /user/create is idempotent', r2, b => b.uuid === uuid ? null : `uuid changed: ${b.uuid}`);
+
+  // ── bad signature ──
+  const ts3 = Date.now().toString();
+  const r3 = await put('/user/create', { timestamp: ts3, pubKey, signature: 'badsig' });
+  assertStatus('PUT /user/create rejects bad signature → 401', r3, 401);
+
+  // ── missing fields ──
+  const r4 = await put('/user/create', { pubKey });
+  assertStatus('PUT /user/create rejects missing fields → 400', r4, 400);
+
+  return { uuid, pubKey, keys };
+}
+
+async function testVideoMetadata(uuid, pubKey) {
+  section('Video Metadata');
+
+  const title = `test-video-${Date.now()}`;
+
+  // ── create video ──
+  const ts1 = Date.now().toString();
+  const sig1 = await sign(ts1 + pubKey);
+  const r1 = await put(`/user/${uuid}/video/${title}`, {
+    timestamp: ts1,
+    signature: sig1,
+    description: 'A test video',
+    tags: ['test', 'integration']
+  });
+  if (!assertOk('PUT /user/:uuid/video/:title creates video', r1,
+    b => b.videoId ? null : 'missing videoId')) return null;
+  assertOk('PUT /user/:uuid/video/:title has correct title', r1,
+    b => b.title === title ? null : `title=${b.title}`);
+  assertOk('PUT /user/:uuid/video/:title has description', r1,
+    b => b.description === 'A test video' ? null : `description=${b.description}`);
+
+  const videoId = r1.body.videoId;
+
+  // ── get videos (authed) ──
+  const ts2 = Date.now().toString();
+  const sig2 = await sign(ts2 + pubKey);
+  const r2 = await get(`/user/${uuid}/videos?timestamp=${ts2}&signature=${sig2}`);
+  assertOk('GET /user/:uuid/videos returns video', r2,
+    b => b[title] ? null : `video "${title}" not found in listing`);
+
+  // ── get videos (public) ──
+  const r3 = await get(`/videos/${uuid}`);
+  assertOk('GET /videos/:uuid public listing returns video', r3,
+    b => b[title] ? null : `video "${title}" not found in public listing`);
+  assertOk('GET /videos/:uuid strips no public fields', r3,
+    b => b[title]?.videoId === videoId ? null : 'videoId missing from public listing');
+
+  // ── auth required for user-scoped listing ──
+  const r4 = await get(`/user/${uuid}/videos`);
+  assertStatus('GET /user/:uuid/videos without auth → 400 or 401', r4, r4.status === 400 ? 400 : 401);
+
+  return { title, videoId };
+}
+
+async function testVideoUpload(uuid, pubKey, title) {
+  section('Video File Upload');
+
+  if (SKIP_UPLOAD) {
+    console.log('  ⏩ skipped (--skip-upload)');
+    return false;
+  }
+
+  // Create a small dummy binary buffer as a stand-in for a video file
+  const dummyVideo = Buffer.alloc(1024 * 64, 0x00); // 64KB of zeros
+
+  const ts = Date.now().toString();
+  const sig = await sign(ts + pubKey);
+
+  const r = await putFile(
+    `/user/${uuid}/video/${title}/file`,
+    dummyVideo,
+    `${title}.mp4`,
+    ts,
+    sig
+  );
+
+  if (!assertOk('PUT /user/:uuid/video/:title/file uploads to Spaces', r,
+    b => b.spacesKey ? null : `missing spacesKey, got: ${JSON.stringify(b).slice(0, 120)}`)) return false;
+  assertOk('PUT /user/:uuid/video/:title/file returns cdnUrl', r,
+    b => b.cdnUrl ? null : 'missing cdnUrl');
+
+  return true;
+}
+
+async function testWatch(videoId, expectMagnet) {
+  section('Watch / Magnet');
+
+  if (!expectMagnet) {
+    // No upload was done — endpoint should 404 or return no spacesKey yet
+    const r = await get(`/video/${videoId}/watch`);
+    assertStatus('GET /video/:videoId/watch without upload → 404', r, 404);
+    return;
+  }
+
+  // Give seeder a moment to seed the newly uploaded file
+  console.log('  ⏳ waiting 3s for seeder...');
+  await new Promise(r => setTimeout(r, 3000));
+
+  const r = await get(`/video/${videoId}/watch`);
+  assertOk('GET /video/:videoId/watch returns magnetURI', r,
+    b => b.magnetURI ? null : `missing magnetURI, got: ${JSON.stringify(b).slice(0, 120)}`);
+  assertOk('GET /video/:videoId/watch returns trackerUrl', r,
+    b => b.trackerUrl ? null : 'missing trackerUrl');
+  assertOk('GET /video/:videoId/watch returns title', r,
+    b => b.title ? null : 'missing title');
+
+  // ── not found ──
+  const r2 = await get('/video/nonexistent-video-id-00000/watch');
+  assertStatus('GET /video/:videoId/watch with bad id → 404', r2, 404);
+}
+
+async function testSeedEndpoint() {
+  section('Seed API');
+
+  // ── missing key ──
+  const r1 = await post('/seed', {});
+  assertStatus('POST /seed without key → 400', r1, 400);
+}
+
+// ── main ──────────────────────────────────────────────────────────────────────
+
+async function main() {
+  console.log(`\n🎬 Lucille Integration Tests`);
+  console.log(`   Target: ${SERVER_URL}`);
+  console.log(`   Time:   ${new Date().toISOString()}`);
+  if (SKIP_UPLOAD) console.log('   Upload: skipped (--skip-upload)');
+
+  try {
+    await testHealth();
+    await testStatus();
+
+    const user = await testUser();
+    if (!user) {
+      console.error('\n💥 User creation failed — skipping remaining tests');
+      process.exit(1);
+    }
+
+    const { uuid, pubKey } = user;
+    const video = await testVideoMetadata(uuid, pubKey);
+    if (!video) {
+      console.error('\n💥 Video metadata failed — skipping upload/watch tests');
+      process.exit(1);
+    }
+
+    const { title, videoId } = video;
+    const uploaded = await testVideoUpload(uuid, pubKey, title);
+    await testWatch(videoId, uploaded);
+    await testSeedEndpoint();
+
+  } catch (err) {
+    console.error('\n💥 Unexpected error during test run:', err.message);
+    if (err.cause?.code === 'ECONNREFUSED') {
+      console.error(`   Server not reachable at ${SERVER_URL}`);
+      console.error('   Make sure lucille is running: node --env-file=.env lucille.js');
+    } else {
+      console.error(err);
+    }
+    process.exit(2);
+  }
+
+  // ── summary ──
+  console.log(`\n${'═'.repeat(52)}`);
+  const total = passed + failed;
+  console.log(`Results: ${passed}/${total} passed`);
+  if (failures.length > 0) {
+    console.log('\nFailed tests:');
+    failures.forEach(f => console.log(`  ❌ ${f.name}: ${f.reason}`));
+  }
+  console.log('');
+
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+main();