getraw 0.1.0

package/tests/unit/extractors/niconico.test.ts

@@ -0,0 +1,61 @@
+import { describe, test, expect } from "bun:test";
+import { NiconicoExtractor } from "../../../src/extractors/niconico/index";
+import { ExtractorError } from "../../../src/core/types";
+
+describe("NiconicoExtractor", () => {
+  const extractor = new NiconicoExtractor();
+
+  test("canHandle nicovideo.jp/watch/sm* URLs", () => {
+    expect(extractor.canHandle("https://www.nicovideo.jp/watch/sm9")).toBe(true);
+    expect(extractor.canHandle("https://nicovideo.jp/watch/sm12345678")).toBe(true);
+  });
+
+  test("canHandle nicovideo.jp/watch/nm* URLs", () => {
+    expect(extractor.canHandle("https://www.nicovideo.jp/watch/nm1234")).toBe(true);
+    expect(extractor.canHandle("https://nicovideo.jp/watch/nm5678")).toBe(true);
+  });
+
+  test("rejects non-niconico URLs", () => {
+    expect(extractor.canHandle("https://youtube.com/watch?v=sm9")).toBe(false);
+    expect(extractor.canHandle("https://nicovideo.jp/user/12345")).toBe(false);
+    expect(extractor.canHandle("https://nicovideo.jp/watch/lv12345")).toBe(false);
+  });
+
+  test("has correct extractor name", () => {
+    expect(extractor._NAME).toBe("niconico");
+  });
+
+  test("throws ExtractorError for unsupported URL", async () => {
+    await expect(extractor.extract("https://example.com/watch/sm1")).rejects.toThrow(ExtractorError);
+  });
+});
+
+describe("Niconico URL pattern matching", () => {
+  const extractor = new NiconicoExtractor();
+
+  const validUrls = [
+    "https://www.nicovideo.jp/watch/sm9",
+    "https://nicovideo.jp/watch/sm12345678",
+    "https://www.nicovideo.jp/watch/nm1234",
+    "https://nicovideo.jp/watch/nm9999999",
+  ];
+
+  const invalidUrls = [
+    "https://www.nicovideo.jp/watch/lv12345",
+    "https://www.nicovideo.jp/user/12345",
+    "https://nicovideo.jp/",
+    "https://youtube.com/watch/sm9",
+  ];
+
+  for (const url of validUrls) {
+    test(`matches: ${url}`, () => {
+      expect(extractor.canHandle(url)).toBe(true);
+    });
+  }
+
+  for (const url of invalidUrls) {
+    test(`rejects: ${url}`, () => {
+      expect(extractor.canHandle(url)).toBe(false);
+    });
+  }
+});

package/tests/unit/extractors/reddit.test.ts

@@ -0,0 +1,222 @@
+import { describe, test, expect, mock, beforeEach, afterEach } from "bun:test";
+import { RedditExtractor } from "../../../src/extractors/reddit/index";
+import { RedditGalleryExtractor } from "../../../src/extractors/reddit/gallery";
+import { ExtractorError } from "../../../src/core/types";
+
+const redditExtractor = new RedditExtractor();
+const galleryExtractor = new RedditGalleryExtractor();
+
+describe("RedditExtractor", () => {
+  test("canHandle matches standard reddit video URL", () => {
+    expect(redditExtractor.canHandle("https://www.reddit.com/r/videos/comments/abc123/my_video/")).toBe(true);
+  });
+
+  test("canHandle matches old.reddit.com URL", () => {
+    expect(redditExtractor.canHandle("https://old.reddit.com/r/funny/comments/xyz789/title/")).toBe(true);
+  });
+
+  test("canHandle matches v.redd.it URL", () => {
+    expect(redditExtractor.canHandle("https://v.redd.it/abc123def")).toBe(true);
+  });
+
+  test("canHandle rejects non-reddit URL", () => {
+    expect(redditExtractor.canHandle("https://youtube.com/watch?v=abc")).toBe(false);
+  });
+
+  test("canHandle rejects reddit non-video URL", () => {
+    expect(redditExtractor.canHandle("https://www.reddit.com/r/pics/")).toBe(false);
+  });
+
+  test("_NAME is reddit", () => {
+    expect(redditExtractor._NAME).toBe("reddit");
+  });
+
+  test("extract throws ExtractorError on failed fetch", async () => {
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = mock(() => Promise.resolve(new Response(null, { status: 404 })));
+
+    await expect(
+      redditExtractor.extract("https://www.reddit.com/r/videos/comments/abc123/title/")
+    ).rejects.toThrow(ExtractorError);
+
+    globalThis.fetch = originalFetch;
+  });
+
+  test("extract parses reddit video JSON response", async () => {
+    const originalFetch = globalThis.fetch;
+
+    const mockPostData = {
+      id: "abc123",
+      title: "Test Video",
+      author: "testuser",
+      url: "https://v.redd.it/xyz",
+      score: 1000,
+      created_utc: 1700000000,
+      secure_media: {
+        reddit_video: {
+          dash_url: "https://v.redd.it/xyz/DASHPlaylist.mpd",
+          fallback_url: "https://v.redd.it/xyz/DASH_720.mp4",
+          width: 1280,
+          height: 720,
+          duration: 30,
+        },
+      },
+    };
+
+    globalThis.fetch = mock(() =>
+      Promise.resolve(
+        new Response(
+          JSON.stringify([
+            { data: { children: [{ data: mockPostData }] } },
+            { data: { children: [] } },
+          ]),
+          { status: 200, headers: { "Content-Type": "application/json" } }
+        )
+      )
+    );
+
+    const info = await redditExtractor.extract(
+      "https://www.reddit.com/r/videos/comments/abc123/title/"
+    );
+
+    expect(info.id).toBe("abc123");
+    expect(info.title).toBe("Test Video");
+    expect(info.uploader).toBe("testuser");
+    expect(info.duration).toBe(30);
+    expect(info.formats).toBeDefined();
+    expect(info.formats!.length).toBeGreaterThan(0);
+
+    const hasVideoFormat = info.formats!.some((f) => f.format_id === "mp4-video-only");
+    const hasDashFormat = info.formats!.some((f) => f.format_id === "dash");
+    expect(hasVideoFormat).toBe(true);
+    expect(hasDashFormat).toBe(true);
+
+    globalThis.fetch = originalFetch;
+  });
+
+  test("extract throws ExtractorError when no video data", async () => {
+    const originalFetch = globalThis.fetch;
+
+    const mockPostData = {
+      id: "abc123",
+      title: "Text Post",
+      author: "testuser",
+      url: "https://www.reddit.com/r/text/comments/abc123/",
+    };
+
+    globalThis.fetch = mock(() =>
+      Promise.resolve(
+        new Response(
+          JSON.stringify([{ data: { children: [{ data: mockPostData }] } }]),
+          { status: 200, headers: { "Content-Type": "application/json" } }
+        )
+      )
+    );
+
+    await expect(
+      redditExtractor.extract("https://www.reddit.com/r/text/comments/abc123/title/")
+    ).rejects.toThrow(ExtractorError);
+
+    globalThis.fetch = originalFetch;
+  });
+});
+
+describe("RedditGalleryExtractor", () => {
+  test("canHandle matches gallery URL", () => {
+    expect(galleryExtractor.canHandle("https://www.reddit.com/gallery/abc123")).toBe(true);
+  });
+
+  test("canHandle matches gallery post URL", () => {
+    expect(
+      galleryExtractor.canHandle(
+        "https://www.reddit.com/r/aww/comments/abc123/my_gallery/"
+      )
+    ).toBe(true);
+  });
+
+  test("_NAME is reddit:gallery", () => {
+    expect(galleryExtractor._NAME).toBe("reddit:gallery");
+  });
+
+  test("extract returns playlist type for gallery post", async () => {
+    const originalFetch = globalThis.fetch;
+
+    const mockPostData = {
+      id: "gal123",
+      title: "My Gallery",
+      author: "galleryuser",
+      score: 500,
+      created_utc: 1700000000,
+      gallery_data: {
+        items: [
+          { media_id: "img1", id: 1, caption: "First image" },
+          { media_id: "img2", id: 2 },
+        ],
+      },
+      media_metadata: {
+        img1: {
+          e: "Image",
+          m: "image/jpg",
+          id: "img1",
+          s: { u: "https://i.redd.it/img1.jpg", x: 1920, y: 1080 },
+          p: [{ u: "https://i.redd.it/img1_preview.jpg", x: 640, y: 360 }],
+        },
+        img2: {
+          e: "Image",
+          m: "image/png",
+          id: "img2",
+          s: { u: "https://i.redd.it/img2.png", x: 800, y: 600 },
+          p: [],
+        },
+      },
+    };
+
+    globalThis.fetch = mock(() =>
+      Promise.resolve(
+        new Response(
+          JSON.stringify([{ data: { children: [{ data: mockPostData }] } }]),
+          { status: 200, headers: { "Content-Type": "application/json" } }
+        )
+      )
+    );
+
+    const info = await galleryExtractor.extract(
+      "https://www.reddit.com/r/aww/comments/gal123/my_gallery/"
+    );
+
+    expect(info._type).toBe("playlist");
+    expect(info.id).toBe("gal123");
+    expect(info.title).toBe("My Gallery");
+    expect(info.entries).toBeDefined();
+    expect(info.entries!.length).toBe(2);
+    expect(info.playlist_count).toBe(2);
+    expect(info.entries![0].title).toBe("First image");
+
+    globalThis.fetch = originalFetch;
+  });
+
+  test("extract throws ExtractorError when no gallery data", async () => {
+    const originalFetch = globalThis.fetch;
+
+    const mockPostData = {
+      id: "txt123",
+      title: "Text Post",
+      author: "user",
+    };
+
+    globalThis.fetch = mock(() =>
+      Promise.resolve(
+        new Response(
+          JSON.stringify([{ data: { children: [{ data: mockPostData }] } }]),
+          { status: 200, headers: { "Content-Type": "application/json" } }
+        )
+      )
+    );
+
+    await expect(
+      galleryExtractor.extract("https://www.reddit.com/r/text/comments/txt123/title/")
+    ).rejects.toThrow(ExtractorError);
+
+    globalThis.fetch = originalFetch;
+  });
+});

package/tests/unit/extractors/soundcloud.test.ts

@@ -0,0 +1,299 @@
+import { describe, test, expect, mock } from "bun:test";
+import { SoundCloudExtractor } from "../../../src/extractors/soundcloud/index";
+import { SoundCloudPlaylistExtractor } from "../../../src/extractors/soundcloud/playlist";
+import { ExtractorError } from "../../../src/core/types";
+
+const trackExtractor = new SoundCloudExtractor();
+const playlistExtractor = new SoundCloudPlaylistExtractor();
+
+const FAKE_CLIENT_ID = "abc123def456ghi789jkl012mno345pq";
+
+function makeHTMLWithClientId(clientId: string): string {
+  return `
+    <html>
+      <head><title>SoundCloud</title></head>
+      <body>
+        <script src="https://a-v2.sndcdn.com/assets/50-abc123.js"></script>
+      </body>
+    </html>
+  `.trim();
+}
+
+function makeJSBundle(clientId: string): string {
+  return `(function(){var t=1,client_id:"${clientId}",exports={}}())`;
+}
+
+const mockTrackData = {
+  id: 987654321,
+  title: "My Track",
+  description: "A great track",
+  duration: 210000,
+  playback_count: 50000,
+  likes_count: 2000,
+  comment_count: 100,
+  created_at: "2024-01-20T10:00:00Z",
+  genre: "Electronic",
+  tag_list: '"deep house" techno ambient',
+  permalink_url: "https://soundcloud.com/artist/my-track",
+  user: {
+    id: 111222333,
+    username: "Artist Name",
+    permalink_url: "https://soundcloud.com/artist",
+  },
+  artwork_url: "https://i1.sndcdn.com/artworks-large.jpg",
+  media: {
+    transcodings: [
+      {
+        url: "https://api-v2.soundcloud.com/media/soundcloud:tracks:987654321/hls",
+        preset: "mp3_0_0",
+        duration: 210000,
+        format: { protocol: "hls", mime_type: "audio/mpeg" },
+        quality: "sq",
+      },
+      {
+        url: "https://api-v2.soundcloud.com/media/soundcloud:tracks:987654321/hls_aac",
+        preset: "aac_1_0",
+        duration: 210000,
+        format: { protocol: "hls", mime_type: "audio/mp4" },
+        quality: "sq",
+      },
+      {
+        url: "https://api-v2.soundcloud.com/media/soundcloud:tracks:987654321/progressive",
+        preset: "mp3_0_0",
+        duration: 210000,
+        format: { protocol: "progressive", mime_type: "audio/mpeg" },
+        quality: "sq",
+      },
+    ],
+  },
+};
+
+describe("SoundCloudExtractor", () => {
+  test("canHandle matches track URL", () => {
+    expect(trackExtractor.canHandle("https://soundcloud.com/artist/my-track")).toBe(true);
+    expect(trackExtractor.canHandle("https://www.soundcloud.com/artist/track-name")).toBe(true);
+    expect(trackExtractor.canHandle("https://m.soundcloud.com/artist/track-name")).toBe(true);
+  });
+
+  test("canHandle rejects playlist URL", () => {
+    expect(trackExtractor.canHandle("https://soundcloud.com/artist/sets/my-playlist")).toBe(false);
+  });
+
+  test("canHandle rejects non-soundcloud URL", () => {
+    expect(trackExtractor.canHandle("https://spotify.com/track/abc")).toBe(false);
+  });
+
+  test("_NAME is soundcloud", () => {
+    expect(trackExtractor._NAME).toBe("soundcloud");
+  });
+
+  test("extract fetches client_id and resolves track", async () => {
+    const originalFetch = globalThis.fetch;
+
+    const streamUrls: Record<string, string> = {
+      "https://api-v2.soundcloud.com/media/soundcloud:tracks:987654321/hls": "https://cf-hls-media.sndcdn.com/playlist.m3u8",
+      "https://api-v2.soundcloud.com/media/soundcloud:tracks:987654321/hls_aac": "https://cf-hls-media.sndcdn.com/aac_playlist.m3u8",
+      "https://api-v2.soundcloud.com/media/soundcloud:tracks:987654321/progressive": "https://cf-media.sndcdn.com/track.mp3",
+    };
+
+    globalThis.fetch = mock((input: string | URL | Request) => {
+      const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+
+      if (url.includes("soundcloud.com/artist/my-track") && !url.includes("api-v2")) {
+        return Promise.resolve(
+          new Response(makeHTMLWithClientId(FAKE_CLIENT_ID), {
+            status: 200,
+            headers: { "Content-Type": "text/html" },
+          })
+        );
+      }
+      if (url.includes("a-v2.sndcdn.com/assets")) {
+        return Promise.resolve(
+          new Response(makeJSBundle(FAKE_CLIENT_ID), {
+            status: 200,
+            headers: { "Content-Type": "application/javascript" },
+          })
+        );
+      }
+      if (url.includes("api-v2.soundcloud.com/resolve")) {
+        return Promise.resolve(
+          new Response(JSON.stringify(mockTrackData), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          })
+        );
+      }
+      for (const [transcodeUrl, streamUrl] of Object.entries(streamUrls)) {
+        if (url.startsWith(transcodeUrl)) {
+          return Promise.resolve(
+            new Response(JSON.stringify({ url: streamUrl }), {
+              status: 200,
+              headers: { "Content-Type": "application/json" },
+            })
+          );
+        }
+      }
+      return Promise.resolve(new Response(null, { status: 404 }));
+    });
+
+    const info = await trackExtractor.extract("https://soundcloud.com/artist/my-track");
+
+    expect(info.id).toBe("987654321");
+    expect(info.title).toBe("My Track");
+    expect(info.description).toBe("A great track");
+    expect(info.uploader).toBe("Artist Name");
+    expect(info.duration).toBe(210);
+    expect(info.view_count).toBe(50000);
+    expect(info.like_count).toBe(2000);
+    expect(info.upload_date).toBe("20240120");
+    expect(info.categories).toEqual(["Electronic"]);
+    expect(info.formats).toBeDefined();
+    expect(info.formats!.length).toBeGreaterThan(0);
+
+    const hlsFormats = info.formats!.filter((f) => f.protocol === "m3u8");
+    expect(hlsFormats.length).toBeGreaterThan(0);
+
+    expect(info.thumbnails).toBeDefined();
+    expect(info.thumbnails!.some((t) => t.url.includes("t500x500"))).toBe(true);
+
+    globalThis.fetch = originalFetch;
+  });
+
+  test("extract throws ExtractorError when page fetch fails", async () => {
+    const originalFetch = globalThis.fetch;
+
+    globalThis.fetch = mock(() => Promise.resolve(new Response(null, { status: 500 })));
+
+    await expect(
+      trackExtractor.extract("https://soundcloud.com/artist/track")
+    ).rejects.toThrow(ExtractorError);
+
+    globalThis.fetch = originalFetch;
+  });
+
+  test("extract throws ExtractorError when no JS bundle found", async () => {
+    const originalFetch = globalThis.fetch;
+
+    globalThis.fetch = mock((input: string | URL | Request) => {
+      const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+      if (url.includes("soundcloud.com") && !url.includes("a-v2.sndcdn")) {
+        return Promise.resolve(
+          new Response("<html><body>no scripts here</body></html>", {
+            status: 200,
+            headers: { "Content-Type": "text/html" },
+          })
+        );
+      }
+      return Promise.resolve(new Response(null, { status: 404 }));
+    });
+
+    await expect(
+      trackExtractor.extract("https://soundcloud.com/artist/track")
+    ).rejects.toThrow(ExtractorError);
+
+    globalThis.fetch = originalFetch;
+  });
+});
+
+describe("SoundCloudPlaylistExtractor", () => {
+  test("canHandle matches sets URL", () => {
+    expect(
+      playlistExtractor.canHandle("https://soundcloud.com/artist/sets/my-playlist")
+    ).toBe(true);
+  });
+
+  test("canHandle rejects track URL", () => {
+    expect(
+      playlistExtractor.canHandle("https://soundcloud.com/artist/my-track")
+    ).toBe(false);
+  });
+
+  test("_NAME is soundcloud:playlist", () => {
+    expect(playlistExtractor._NAME).toBe("soundcloud:playlist");
+  });
+
+  test("extract returns playlist with tracks", async () => {
+    const originalFetch = globalThis.fetch;
+
+    const mockPlaylistData = {
+      id: 111111111,
+      title: "My Playlist",
+      description: "A playlist",
+      duration: 600000,
+      track_count: 3,
+      likes_count: 500,
+      created_at: "2024-02-01T12:00:00Z",
+      permalink_url: "https://soundcloud.com/artist/sets/my-playlist",
+      user: { id: 111222333, username: "Artist Name", permalink_url: "https://soundcloud.com/artist" },
+    };
+
+    const mockTracksPage = {
+      collection: [
+        { id: 111, title: "Track One", permalink_url: "https://soundcloud.com/artist/track-one" },
+        { id: 222, title: "Track Two", permalink_url: "https://soundcloud.com/artist/track-two" },
+        { id: 333, title: "Track Three", permalink_url: "https://soundcloud.com/artist/track-three" },
+      ],
+      next_href: null,
+    };
+
+    let callCount = 0;
+    globalThis.fetch = mock((input: string | URL | Request) => {
+      const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+      callCount++;
+
+      if (url.includes("soundcloud.com/artist/sets") && !url.includes("api-v2")) {
+        return Promise.resolve(
+          new Response(makeHTMLWithClientId(FAKE_CLIENT_ID), {
+            status: 200,
+            headers: { "Content-Type": "text/html" },
+          })
+        );
+      }
+      if (url.includes("a-v2.sndcdn.com/assets")) {
+        return Promise.resolve(
+          new Response(makeJSBundle(FAKE_CLIENT_ID), {
+            status: 200,
+            headers: { "Content-Type": "application/javascript" },
+          })
+        );
+      }
+      if (url.includes("api-v2.soundcloud.com/resolve")) {
+        return Promise.resolve(
+          new Response(JSON.stringify(mockPlaylistData), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          })
+        );
+      }
+      if (url.includes("api-v2.soundcloud.com/playlists")) {
+        return Promise.resolve(
+          new Response(JSON.stringify(mockTracksPage), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+          })
+        );
+      }
+      return Promise.resolve(new Response(null, { status: 404 }));
+    });
+
+    const info = await playlistExtractor.extract(
+      "https://soundcloud.com/artist/sets/my-playlist"
+    );
+
+    expect(info._type).toBe("playlist");
+    expect(info.id).toBe("111111111");
+    expect(info.title).toBe("My Playlist");
+    expect(info.uploader).toBe("Artist Name");
+    expect(info.entries).toBeDefined();
+    expect(info.entries!.length).toBe(3);
+    expect(info.playlist_count).toBe(3);
+
+    const firstEntry = info.entries![0];
+    expect(firstEntry.id).toBe("111");
+    expect(firstEntry.title).toBe("Track One");
+    expect(firstEntry._type).toBe("url");
+    expect(firstEntry.playlist_index).toBe(1);
+
+    globalThis.fetch = originalFetch;
+  });
+});