fix: optimize integration tests for speed

- Use Apple bipbop stream for playlist quality detection (fast)
- Skip actual download test by default (INTEGRATION_SLOW=true to enable)
- All tests complete in ~1 second without download
- Full download test available for local testing

Author: swernerx

src/downloader/hlsDownloader.integration.test.ts

@@ -7,10 +7,6 @@
  * - Temp directory for output files
  *
  * Run with: npm run test:integration
- *
- * Note: The actual download test is skipped by default in CI
- * because it can take several minutes. Run locally with:
- *   INTEGRATION_DOWNLOAD=true npm run test:integration
  */
 
 import { existsSync, mkdirSync, rmSync, statSync } from "node:fs";
@@ -21,13 +17,13 @@ import { checkFfmpeg, downloadHLSVideo, fetchHLSQualities } from "./hlsDownloade
 
 // Test fixtures - public HLS streams for testing
 const TEST_STREAMS = {
-  // Apple's bipbop test stream (shorter variant)
-  bipbop:
+  // Apple's bipbop master playlist (for quality detection)
+  bipbopMaster:
     "https://devstreaming-cdn.apple.com/videos/streaming/examples/bipbop_4x3/bipbop_4x3_variant.m3u8",
 };
 
-// Skip download tests unless explicitly enabled (they're slow)
-const SKIP_DOWNLOAD = !process.env.INTEGRATION_DOWNLOAD;
+// Full download tests are slow - skip in CI unless explicitly enabled
+const RUN_SLOW_TESTS = process.env.INTEGRATION_SLOW === "true";
 
 describe("HLS Downloader Integration", () => {
   let tempDir: string;
@@ -48,65 +44,69 @@ describe("HLS Downloader Integration", () => {
   describe("checkFfmpeg", () => {
     it("should detect ffmpeg when installed", async () => {
       const result = await checkFfmpeg();
-      // This test will fail if ffmpeg is not installed
       expect(result).toBe(true);
     });
   });
 
   describe("fetchHLSQualities", () => {
     it("should fetch qualities from a real HLS master playlist", async () => {
-      const qualities = await fetchHLSQualities(TEST_STREAMS.bipbop);
+      const qualities = await fetchHLSQualities(TEST_STREAMS.bipbopMaster);
 
       expect(qualities.length).toBeGreaterThan(0);
       expect(qualities[0]).toHaveProperty("url");
       expect(qualities[0]).toHaveProperty("bandwidth");
       expect(qualities[0]).toHaveProperty("label");
-    }, 30000);
+
+      // Bipbop should have multiple quality levels
+      expect(qualities.length).toBeGreaterThanOrEqual(4);
+    }, 15000);
   });
 
   describe("downloadHLSVideo", () => {
-    it.skipIf(SKIP_DOWNLOAD)(
-      "should download a short HLS stream (slow, set INTEGRATION_DOWNLOAD=true)",
+    it("should return error for invalid URL", async () => {
+      const outputPath = join(tempDir, "invalid-test.mp4");
+
+      const result = await downloadHLSVideo(
+        "https://invalid-url-that-does-not-exist.example.com/video.m3u8",
+        outputPath
+      );
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    }, 15000);
+
+    it("should handle non-HLS URL gracefully", async () => {
+      const outputPath = join(tempDir, "not-hls.mp4");
+
+      const result = await downloadHLSVideo("https://example.com/not-a-playlist.txt", outputPath);
+
+      expect(result.success).toBe(false);
+      expect(result.errorCode).toBeDefined();
+    }, 15000);
+
+    // Full download test - only run when INTEGRATION_SLOW=true
+    it.skipIf(!RUN_SLOW_TESTS)(
+      "should download complete HLS stream (slow, set INTEGRATION_SLOW=true)",
       async () => {
         const outputPath = join(tempDir, "test-video.mp4");
 
         const progressUpdates: number[] = [];
-        const result = await downloadHLSVideo(TEST_STREAMS.bipbop, outputPath, (progress) => {
+        const result = await downloadHLSVideo(TEST_STREAMS.bipbopMaster, outputPath, (progress) => {
           progressUpdates.push(progress.percent);
         });
 
         expect(result.success).toBe(true);
         expect(result.outputPath).toBe(outputPath);
         expect(existsSync(outputPath)).toBe(true);
 
-        // Check file size is reasonable (at least 100KB)
+        // Check file size is reasonable
         const stats = statSync(outputPath);
         expect(stats.size).toBeGreaterThan(100 * 1024);
 
         // Should have received progress updates
         expect(progressUpdates.length).toBeGreaterThan(0);
       },
-      300000 // 5 minute timeout for actual download
+      300000 // 5 minute timeout
     );
-
-    it("should return error for invalid URL", async () => {
-      const outputPath = join(tempDir, "invalid-test.mp4");
-
-      const result = await downloadHLSVideo(
-        "https://invalid-url-that-does-not-exist.example.com/video.m3u8",
-        outputPath
-      );
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBeDefined();
-    }, 30000);
-
-    it("should handle non-HLS URL gracefully", async () => {
-      const outputPath = join(tempDir, "not-hls.mp4");
-
-      const result = await downloadHLSVideo("https://example.com/not-a-playlist.txt", outputPath);
-
-      expect(result.success).toBe(false);
-    }, 30000);
   });
 });