watchparty/server/test/catalogService.test.ts

// Exercises CatalogService's real logic (library-type filtering, the
// audio/quality override forcing, subtitle proxying) through its PUBLIC
// methods against a mocked EmbyClient, not by calling private helpers directly.
import { describe, it } from 'node:test';
import assert from 'node:assert/strict';
import type { Request, Response } from 'express';
import { CatalogService } from '../src/services/CatalogService';
import { EmbyClient } from '../src/emby/EmbyClient';
import type { EmbySession } from '../src/types';

const session: EmbySession = { embyToken: 'tok', userId: 'u1', userName: 'Alice', serverId: 'srv1', createdUtc: Date.now() };

function jsonResponse(body: unknown): Response {
  return new Response(JSON.stringify(body), { status: 200, headers: { 'Content-Type': 'application/json' } }) as unknown as Response;
}

function fakeReq(query: Record<string, string>): Request {
  return { query, headers: {} } as unknown as Request;
}

function fakeRes(): Response {
  return { status() { return this; }, json() {}, end() {} } as unknown as Response;
}

describe('CatalogService', () => {
  it('getLibraries keeps only movies/tvshows/music/musicvideos out of everything /Views can return', async (t) => {
    t.mock.method(EmbyClient, 'fetch', async () => jsonResponse({
      Items: [
        { Id: '1', Name: 'Films', CollectionType: 'movies' },
        { Id: '2', Name: 'Series', CollectionType: 'tvshows' },
        { Id: '3', Name: 'Musique', CollectionType: 'music' },
        { Id: '4', Name: 'Clips', CollectionType: 'musicvideos' },
        { Id: '5', Name: 'Photos', CollectionType: 'photos' },
        { Id: '6', Name: 'Live TV', CollectionType: 'livetv' },
        { Id: '7', Name: 'Collections', CollectionType: 'boxsets' },
        { Id: '8', Name: 'No type at all' }
      ]
    }));

    const libraries = await CatalogService.getLibraries(session);
    assert.deepEqual(libraries.map((l) => l.name).sort(), ['Clips', 'Films', 'Musique', 'Series']);
  });

  it('proxyStream forces an audio pick onto a negotiated TranscodingUrl (subtitles are a separate concern - see proxySubtitle)', async (t) => {
    t.mock.method(EmbyClient, 'fetch', async () => jsonResponse({
      MediaSources: [{ Id: 'src1', TranscodingUrl: '/videos/item1/master.m3u8?MediaSourceId=src1&AudioStreamIndex=1' }],
      PlaySessionId: 'sess1'
    }));
    let capturedTarget = '';
    t.mock.method(EmbyClient, 'proxyResponse', async (_req: Request, _res: Response, target: string) => { capturedTarget = target; });

    await CatalogService.proxyStream(fakeReq({ AudioStreamIndex: '2' }), fakeRes(), session, 'item1');

    assert.ok(capturedTarget.includes('AudioStreamIndex=2'));
    assert.ok(!capturedTarget.includes('Subtitle'), 'this route never touches subtitle params at all any more');
  });

  it('proxyStream\'s hand-built fallback picks /Audio/ (and drops VideoCodec) for a music track', async (t) => {
    t.mock.method(EmbyClient, 'fetch', async () => jsonResponse({ MediaSources: [{ Id: 'src2' }], PlaySessionId: 'sess2' }));
    let capturedTarget = '';
    t.mock.method(EmbyClient, 'proxyResponse', async (_req: Request, _res: Response, target: string) => { capturedTarget = target; });

    await CatalogService.proxyStream(fakeReq({ mediaType: 'audio' }), fakeRes(), session, 'track1');

    assert.ok(capturedTarget.startsWith('/Audio/track1/master.m3u8'));
    assert.ok(!capturedTarget.includes('VideoCodec'));
  });

  it('proxyStream\'s hand-built fallback picks /Videos/ (with VideoCodec) for anything else', async (t) => {
    t.mock.method(EmbyClient, 'fetch', async () => jsonResponse({ MediaSources: [{ Id: 'src3' }], PlaySessionId: 'sess3' }));
    let capturedTarget = '';
    t.mock.method(EmbyClient, 'proxyResponse', async (_req: Request, _res: Response, target: string) => { capturedTarget = target; });

    await CatalogService.proxyStream(fakeReq({}), fakeRes(), session, 'movie1');

    assert.ok(capturedTarget.startsWith('/Videos/movie1/master.m3u8'));
    assert.ok(capturedTarget.includes('VideoCodec=h264'));
  });

  it('getRawItem preserves Emby\'s own status (a real 404), not a blanket 502', async (t) => {
    t.mock.method(EmbyClient, 'fetch', async () => new Response(null, { status: 404 }) as unknown as Response);

    await assert.rejects(
      () => CatalogService.getRawItem(session, 'missing'),
      (err: Error & { status?: number }) => err.status === 404
    );
  });

  it('getPlaybackOptions flags an image/bitmap subtitle (PGS) as not text-based, real text subtitles as fine', async (t) => {
    t.mock.method(EmbyClient, 'fetch', async () => jsonResponse({
      MediaSources: [{
        Id: 'src1',
        MediaStreams: [
          { Type: 'Audio', Index: 1, Language: 'fre' },
          { Type: 'Subtitle', Index: 2, Language: 'eng', Codec: 'subrip' },
          { Type: 'Subtitle', Index: 3, Language: 'eng', Codec: 'hdmv_pgs_subtitle' },
          { Type: 'Subtitle', Index: 4, Language: 'fre', Codec: 'ass' }
        ]
      }]
    }));

    const options = await CatalogService.getPlaybackOptions(session, 'item1');

    assert.equal(options.subtitleTracks.find((t) => t.index === 2)?.isTextBased, true, 'subrip is text');
    assert.equal(options.subtitleTracks.find((t) => t.index === 3)?.isTextBased, false, 'PGS is a bitmap - no text for Emby to convert to WebVTT');
    assert.equal(options.subtitleTracks.find((t) => t.index === 4)?.isTextBased, true, 'ass is text too');
  });

  it('proxySubtitle asks Emby for this track as WebVTT, using the negotiated MediaSourceId', async (t) => {
    t.mock.method(EmbyClient, 'fetch', async () => jsonResponse({ MediaSources: [{ Id: 'src7' }] }));
    let capturedTarget = '';
    t.mock.method(EmbyClient, 'proxyResponse', async (_req: Request, _res: Response, target: string) => { capturedTarget = target; });

    await CatalogService.proxySubtitle(fakeReq({}), fakeRes(), session, 'item9', '2');

    assert.equal(capturedTarget, '/Videos/item9/src7/Subtitles/2/Stream.vtt');
  });

  it('proxySubtitle fails cleanly (not a crash) when Emby has no media source for this item', async (t) => {
    t.mock.method(EmbyClient, 'fetch', async () => jsonResponse({ MediaSources: [] }));

    await assert.rejects(
      () => CatalogService.proxySubtitle(fakeReq({}), fakeRes(), session, 'missing', '0'),
      (err: Error & { status?: number }) => err.status === 502
    );
  });

  it('getMediaSource returns the negotiated id/container/streams together - what TranscodeService needs', async (t) => {
    t.mock.method(EmbyClient, 'fetch', async () => jsonResponse({
      MediaSources: [{
        Id: 'src9',
        Container: 'mkv',
        MediaStreams: [{ Type: 'Video', Index: 0 }, { Type: 'Subtitle', Index: 1 }]
      }]
    }));

    const source = await CatalogService.getMediaSource(session, 'item1');

    assert.equal(source.id, 'src9');
    assert.equal(source.container, 'mkv');
    assert.equal(source.streams.length, 2);
  });

  it('getMediaSource falls back to "mkv" when Emby omits Container', async (t) => {
    t.mock.method(EmbyClient, 'fetch', async () => jsonResponse({ MediaSources: [{ Id: 'src10' }] }));

    const source = await CatalogService.getMediaSource(session, 'item1');

    assert.equal(source.container, 'mkv');
  });

  it('getMediaSource fails cleanly (not a crash) when Emby has no media source for this item', async (t) => {
    t.mock.method(EmbyClient, 'fetch', async () => jsonResponse({ MediaSources: [] }));

    await assert.rejects(
      () => CatalogService.getMediaSource(session, 'missing'),
      (err: Error & { status?: number }) => err.status === 502
    );
  });
});