video-workflow/server/routes/video-proxy.test.js

const assert = require('node:assert/strict');
const http = require('node:http');
const test = require('node:test');
const express = require('express');
const { registerVideoProxyRoutes } = require('./video-proxy');

function startServer(deps) {
  const app = express();
  registerVideoProxyRoutes(app, {
    isSafeRemoteUrl: () => true,
    sleep: async () => {},
    ...deps
  });
  app.get('/health', (req, res) => res.json({ status: 'ok' }));

  return new Promise(resolve => {
    const server = app.listen(0, '127.0.0.1', () => {
      resolve({
        server,
        baseUrl: `http://127.0.0.1:${server.address().port}`
      });
    });
  });
}

function request(url, headers = {}) {
  return new Promise((resolve, reject) => {
    const req = http.get(url, { headers }, res => {
      const chunks = [];
      res.on('data', chunk => chunks.push(chunk));
      res.on('end', () => resolve({
        status: res.statusCode,
        body: Buffer.concat(chunks).toString('utf8')
      }));
      res.on('error', reject);
    });
    req.on('error', reject);
  });
}

test('retries retryable connection errors before streaming', async t => {
  let attempts = 0;
  const { server, baseUrl } = await startServer({
    maxAttempts: 3,
    fetchImpl: async () => {
      attempts += 1;
      if (attempts < 3) {
        throw Object.assign(new Error('fetch failed'), {
          cause: { code: 'UND_ERR_CONNECT_TIMEOUT' }
        });
      }
      return new Response('video-bytes', {
        status: 200,
        headers: { 'content-type': 'video/mp4' }
      });
    }
  });
  t.after(() => server.close());

  const response = await request(`${baseUrl}/api/video-proxy?url=https://example.com/video.mp4`);

  assert.equal(attempts, 3);
  assert.equal(response.status, 200);
  assert.equal(response.body, 'video-bytes');
});

test('keeps serving requests when the upstream stream fails', async t => {
  const failingBody = new ReadableStream({
    start(controller) {
      controller.enqueue(new TextEncoder().encode('partial'));
      controller.error(Object.assign(new Error('terminated'), {
        cause: { code: 'ECONNRESET' }
      }));
    }
  });
  const { server, baseUrl } = await startServer({
    fetchImpl: async () => new Response(failingBody, {
      status: 200,
      headers: { 'content-type': 'video/mp4' }
    })
  });
  t.after(() => server.close());

  await request(`${baseUrl}/api/video-proxy?url=https://example.com/video.mp4`).catch(() => {});
  const health = await request(`${baseUrl}/health`);

  assert.equal(health.status, 200);
  assert.deepEqual(JSON.parse(health.body), { status: 'ok' });
});

test('does not retry an upstream HTTP error', async t => {
  let attempts = 0;
  const { server, baseUrl } = await startServer({
    fetchImpl: async () => {
      attempts += 1;
      return new Response('not found', { status: 404 });
    }
  });
  t.after(() => server.close());

  const response = await request(`${baseUrl}/api/video-proxy?url=https://example.com/missing.mp4`);

  assert.equal(attempts, 1);
  assert.equal(response.status, 404);
});