test: Fix missing coverage from new introduced code

- Add a reusable router agent test utility and replace all
supertest-dependent suites with in-memory request execution so tests
run without socket permissions.
- Expand helper and controller specs (including multi-domain and
watchlist error paths)
- Build new targeted suites, and rework mocks to exercise every branch
required for full coverage.

Author: justinhartman

AGENTS.md

@@ -0,0 +1,32 @@
+# Repository Guidelines
+
+## Project Structure & Module Organization
+- `api/index.ts` boots the Express server and wires middleware; domain logic sits in `controllers/`, `routes/`, `models/`, and `middleware/` to keep concerns isolated.
+- Configuration lives in `config/` with environment-driven exports; shared utilities extend `helpers/` and TypeScript declarations in `types/`.
+- UI assets are split between `views/` (EJS templates and partials such as `views/partials/card-add.ejs`) and `public/` for static files.
+- Data and ops artefacts live in `migrations/`, `docs/`, `system/`, and automated checks under `tests/e2e` and `tests/integration`.
+
+## Build, Test & Development Commands
+- `yarn start` launches the production server through `tsx api/index.ts`; use `yarn start:dev` for watch mode with source maps.
+- `yarn lint` performs TypeScript type-checking plus `npx ejslint` over templates; run `yarn lint:ts` or `yarn lint:ejs` to isolate either track.
+- `yarn db:migrate` and `yarn db:rollback` apply or revert Mongo migrations in `migrations/`; check current state with `yarn db:status`.
+- `yarn test` runs the Jest suite; add `:coverage` to emit reports into `coverage/` and update `junit.xml` for CI.
+
+## Coding Style & Naming Conventions
+- TypeScript files use 2-space indentation, trailing commas, and TSDoc-style blocks (`/** ... */`) for exported members as seen in `controllers/`.
+- Prefer `camelCase` for functions/variables, `PascalCase` for classes and interfaces, and `kebab-case` for EJS partial filenames.
+- Keep logic pure in controllers/helpers; place request wiring in routes; export a single default per module when practical.
+
+## Testing Guidelines
+- Tests run on Jest with the `ts-jest` preset; name specs `*.spec.ts` or `*.test.ts` under `tests/` to match `jest.config.js`.
+- Aim to maintain coverage across `api`, `config`, `controllers`, `helpers`, `middleware`, `models`, and `routes` as enforced by `collectCoverageFrom`.
+- Consume supertest for request flows and prefer fixture factories over network calls; refresh snapshots after intentional UI changes.
+
+## Commit & Pull Request Guidelines
+- Follow the observed Conventional Commit style (`feat:`, `refactor:`, `fix:`, `yarn:`) with concise, imperative summaries under ~70 characters.
+- Group related changes per commit; include migration IDs or view names when helpful.
+- Pull requests should link issues, describe behavioural impact, list validation commands (`yarn test`, `yarn db:migrate`), and attach UI screenshots for template updates.
+
+## Security & Configuration Tips
+- Never commit `.env`; update `.env.example` when introducing new settings and document defaults in `config/`.
+- Rotate API keys when sharing recordings or tests, and prefer local `.env.test` overrides for automation to avoid polluting development data.

controllers/appController.multidomain.spec.ts

@@ -1,14 +1,20 @@
 import { fetchOmdbData, getSeriesDetail } from '../helpers/appHelper';
 import History from '../models/History';
 
-jest.mock('../helpers/appHelper', () => ({
-  fetchOmdbData: jest.fn(),
-  fetchAndUpdatePosters: jest.fn(),
-  getSeriesDetail: jest.fn(),
-}));
+jest.mock('../helpers/appHelper', () => {
+  const actual = jest.requireActual('../helpers/appHelper');
+  return {
+    ...actual,
+    fetchOmdbData: jest.fn(),
+    getSeriesDetail: jest.fn(),
+  };
+});
 
 jest.mock('../models/History', () => ({
-  findOneAndUpdate: jest.fn(),
+  __esModule: true,
+  default: {
+    findOneAndUpdate: jest.fn(),
+  },
 }));
 
 describe('controllers/appController with MULTI_DOMAIN', () => {

controllers/appController.resume.spec.ts

@@ -0,0 +1,41 @@
+jest.mock('../helpers/appHelper', () => {
+  const actual = jest.requireActual('../helpers/appHelper');
+  return {
+    ...actual,
+    fetchOmdbData: jest.fn(async () => ({})),
+    getSeriesDetail: jest.fn(async () => ({ totalSeasons: 1, currentSeason: { season: 1, episodes: [] } })),
+    getResumeRedirect: jest.fn(async () => '/view/tt/series/5/11'),
+    upsertSeriesProgress: jest.fn(),
+  };
+});
+
+jest.mock('../models/History', () => ({
+  __esModule: true,
+  default: {
+    findOne: jest.fn(),
+    findOneAndUpdate: jest.fn(),
+  },
+}));
+
+import appController from './appController';
+import { getResumeRedirect, upsertSeriesProgress } from '../helpers/appHelper';
+import History from '../models/History';
+
+describe('appController getView resume redirect', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('redirects to resume location when available', async () => {
+    const req: any = { params: { q: '', id: 'tt', type: 'series' }, user: { id: 'user-1' } };
+    const res: any = { locals: { APP_URL: 'http://app' }, render: jest.fn(), redirect: jest.fn() };
+
+    (getResumeRedirect as jest.Mock).mockResolvedValue('/view/tt/series/5/11');
+
+    await appController.getView(req, res, jest.fn());
+
+    expect(res.redirect).toHaveBeenCalledWith('/view/tt/series/5/11');
+    expect(upsertSeriesProgress).not.toHaveBeenCalled();
+    expect(History.findOneAndUpdate).not.toHaveBeenCalled();
+  });
+});

controllers/appController.spec.ts

@@ -8,11 +8,15 @@ jest.mock('../helpers/httpClient', () => ({
   __esModule: true,
   default: { get: jest.fn() },
 }));
-jest.mock('../helpers/appHelper', () => ({
-  fetchOmdbData: jest.fn(),
-  fetchAndUpdatePosters: jest.fn(),
-  getSeriesDetail: jest.fn(),
-}));
+jest.mock('../helpers/appHelper', () => {
+  const actual = jest.requireActual('../helpers/appHelper');
+  return {
+    ...actual,
+    fetchOmdbData: jest.fn(),
+    fetchAndUpdatePosters: jest.fn(),
+    getSeriesDetail: jest.fn(),
+  };
+});
 
 jest.mock('../helpers/cache', () => ({
   getLatest: jest.fn(),
@@ -21,8 +25,11 @@ jest.mock('../helpers/cache', () => ({
 }));
 
 jest.mock('../models/History', () => ({
-  findOne: jest.fn(),
-  findOneAndUpdate: jest.fn(),
+  __esModule: true,
+  default: {
+    findOne: jest.fn(),
+    findOneAndUpdate: jest.fn(),
+  },
 }));
 
 jest.mock('../config/app', () => ({

controllers/watchlistController.branch.spec.ts

@@ -0,0 +1,43 @@
+jest.mock('../models/Watchlist', () => {
+  const ctor: any = function (this: any, payload: any) {
+    Object.assign(this, payload);
+    this.save = jest.fn(async () => undefined);
+    if (!this.items) this.items = [];
+  };
+  ctor.findOne = jest.fn(async () => null);
+  ctor.find = jest.fn(async () => []);
+  return {
+    __esModule: true,
+    default: ctor,
+  };
+});
+
+import watchlistController from './watchlistController';
+import Watchlist from '../models/Watchlist';
+
+const makeReq = (body: any = {}, user: any = { id: 'user-1' }) => {
+  const req: any = { body, user, flash: jest.fn() };
+  return req;
+};
+
+const makeRes = () => {
+  const res: any = { locals: { APP_URL: 'http://app' }, redirect: jest.fn(), render: jest.fn() };
+  return res;
+};
+
+describe('watchlistController branch coverage', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('addToWatchlist creates new watchlist when missing', async () => {
+    const req = makeReq({ imdbId: 'tt1', title: 'Title', poster: 'p', type: 'movie' });
+    const res = makeRes();
+
+    await watchlistController.addToWatchlist(req, res, jest.fn());
+
+    expect((Watchlist as any).findOne).toHaveBeenCalled();
+    expect(req.flash).toHaveBeenCalledWith('success_msg', expect.stringMatching(/Added Title/));
+    expect(res.redirect).toHaveBeenCalledWith('/watchlist');
+  });
+});

helpers/appHelper.multidomain.spec.ts

@@ -0,0 +1,52 @@
+jest.mock('./httpClient', () => ({
+  __esModule: true,
+  default: { request: jest.fn(), head: jest.fn() },
+}));
+
+type AppConfig = {
+  OMDB_API_KEY: string;
+  OMDB_API_URL: string;
+  APP_URL: string;
+  MONGO_DB_URI: string;
+  MONGO_DB_NAME: string;
+  APP_NAME: string;
+  APP_SUBTITLE: string;
+  APP_DESCRIPTION: string;
+  API_HOST: string;
+  API_PORT: number;
+  VIDSRC_DOMAIN: string;
+  MULTI_DOMAIN: string;
+};
+
+const multiConfig: AppConfig = {
+  OMDB_API_KEY: 'key',
+  OMDB_API_URL: 'http://omdb',
+  APP_URL: 'http://app',
+  MONGO_DB_URI: '',
+  MONGO_DB_NAME: '',
+  APP_NAME: 'app',
+  APP_SUBTITLE: '',
+  APP_DESCRIPTION: '',
+  API_HOST: 'localhost',
+  API_PORT: 3000,
+  VIDSRC_DOMAIN: 'domain',
+  MULTI_DOMAIN: 'multi.example',
+};
+
+jest.mock('../config/app', () => multiConfig);
+
+import { buildSources } from './appHelper';
+
+describe('appHelper buildSources with MULTI_DOMAIN', () => {
+  test('series sources prefer multi domain', () => {
+    const result = buildSources('tt123', 'series', '1', '5');
+    expect(result.server2Src).toBe('https://multi.example/?video_id=tt123&s=1&e=5');
+    expect(result.currentServer).toBe('2');
+  });
+
+  test('movie sources prefer multi domain', () => {
+    const result = buildSources('tt123', 'movie');
+    expect(result.server2Src).toBe('https://multi.example/?video_id=tt123');
+    expect(result.currentServer).toBe('2');
+  });
+});

helpers/appHelper.spec.ts

@@ -17,6 +17,7 @@ const mockAppConfig = {
   API_HOST: 'localhost',
   API_PORT: 3000,
   VIDSRC_DOMAIN: 'domain',
+  MULTI_DOMAIN: '',
 };
 
 jest.mock('../config/app', () => mockAppConfig);
@@ -88,8 +89,8 @@ describe('helpers/appHelper', () => {
       { imdb_id: '3' },
       { imdb_id: '4' },
     ];
-    const spy = jest
-      .spyOn(helper, 'fetchOmdbData')
+    const fetchMock = jest
+      .fn<ReturnType<typeof helper.fetchOmdbData>, Parameters<typeof helper.fetchOmdbData>>()
       .mockResolvedValueOnce({ Response: 'True', Poster: 'p1' })
       .mockResolvedValueOnce({ Response: 'True', Poster: 'p2' })
       .mockResolvedValueOnce({ Response: 'True', Poster: 'N/A' })
@@ -98,8 +99,8 @@ describe('helpers/appHelper', () => {
       .mockResolvedValueOnce({})
       .mockRejectedValueOnce(new Error('404'));
 
-    await helper.fetchAndUpdatePosters(shows);
-    expect(spy).toHaveBeenCalledTimes(4);
+    await helper.fetchAndUpdatePosters(shows, fetchMock);
+    expect(fetchMock).toHaveBeenCalledTimes(4);
     expect(http.head).toHaveBeenCalledTimes(2);
     expect(http.head).toHaveBeenNthCalledWith(1, 'p1');
     expect(http.head).toHaveBeenNthCalledWith(2, 'p2');
@@ -179,6 +180,27 @@ describe('helpers/appHelper', () => {
     expect(http.request).toHaveBeenCalledTimes(3);
   });
 
+  test('buildSources returns single-domain movie sources by default', () => {
+    const sources = helper.buildSources('tt1', 'movie');
+    expect(sources.server1Src).toBe('https://domain/embed/movie/tt1');
+    expect(sources.server2Src).toBe('');
+    expect(sources.currentServer).toBe('1');
+  });
+
+  test('buildSources prefers MULTI_DOMAIN sources when configured', () => {
+    jest.isolateModules(() => {
+      mockAppConfig.MULTI_DOMAIN = 'multi.example';
+      const mod = require('./appHelper');
+      const seriesSources = mod.buildSources('tt2', 'series', '1', '3');
+      expect(seriesSources.server2Src).toBe('https://multi.example/?video_id=tt2&s=1&e=3');
+      expect(seriesSources.currentServer).toBe('2');
+      const movieSources = mod.buildSources('tt2', 'movie');
+      expect(movieSources.server2Src).toBe('https://multi.example/?video_id=tt2');
+      expect(movieSources.currentServer).toBe('2');
+    });
+    mockAppConfig.MULTI_DOMAIN = '';
+  });
+
   test('useAuth is false when no mongo uri', () => {
     expect(helper.useAuth).toBe(false);
   });

helpers/appHelper.ts

@@ -89,11 +89,14 @@ const fetchOmdbData = async (
  *              If poster isn't available or request fails, sets default 'no-binger' image.
  *              Updates are performed in parallel using Promise.all
  */
-const fetchAndUpdatePosters = async (show: any[]): Promise<void> => {
+const fetchAndUpdatePosters = async (
+  show: any[],
+  fetchFn: typeof fetchOmdbData = fetchOmdbData
+): Promise<void> => {
   const fallback = `${appConfig.APP_URL}/images/no-binger.jpg`;
   await Promise.all(
     show.map(async (x: any) => {
-      const data = await fetchOmdbData(x.imdb_id, false);
+      const data = await fetchFn(x.imdb_id, false);
       if (data.Response === 'True' && data.Poster !== 'N/A') {
         try {
           await http.head(data.Poster);