webvideo-clip-core/test/index.test.ts

import {
  describe, it, expect, vi, beforeEach, Mock, afterEach,
} from 'vitest';
import { spawnSync } from 'child_process';
import { readFileSync, unlinkSync } from 'fs';
import * as webVideoClipCore from '../src';
import { ClipEventEmitter } from '../src';

vi.mock('child_process', () => ({
  spawnSync: vi.fn(),
}));

vi.mock('fs', () => ({
  readFileSync: vi.fn(),
  unlinkSync: vi.fn(),
}));

describe('createVideoClipper', () => {
  beforeEach(() => {
    (readFileSync as Mock).mockReturnValueOnce(Buffer.from(''));
  });

  let clipper: ClipEventEmitter;
  beforeEach(() => {
    clipper = webVideoClipCore.createVideoClipper({
      downloaderExecutablePath: 'yt-dlp',
      postprocessorExecutablePath: 'ffmpeg',
      type: webVideoClipCore.VideoType.YOUTUBE,
      url: 'https://www.youtube.com/watch?v=BaW_jenozKc',
      start: 0,
      end: 0,
    });
  });

  afterEach(() => {
    (spawnSync as Mock).mockReset();
  });

  it('calls the downloader function', () => new Promise((done) => {
    (spawnSync as Mock)
      .mockReturnValueOnce({ stdout: Buffer.from('') })
      .mockReturnValueOnce({});

    clipper.on('end', done);
    clipper.process();
    expect(spawnSync).nthCalledWith(1, 'yt-dlp', expect.anything());
  }));

  it('emits downloader errors', () => new Promise((done) => {
    const causeError = new Error('generic downloader message');
    (spawnSync as Mock)
      .mockReturnValueOnce({ error: causeError })
      .mockReturnValueOnce({});

    clipper.on('error', (err: Error) => {
      expect(err.cause).toHaveProperty('message', causeError.message);
    });
    clipper.on('end', done);
    clipper.process();
  }));

  it('calls the postprocess function', () => new Promise((done) => {
    (spawnSync as Mock)
      .mockReturnValueOnce({ stdout: Buffer.from('') })
      .mockReturnValueOnce({});

    clipper.on('end', done);
    clipper.process();
    expect(spawnSync).nthCalledWith(2, 'ffmpeg', expect.anything());
  }));

  it('emits postprocess errors', () => new Promise((done) => {
    const causeError = new Error('generic postprocessor message');
    (spawnSync as Mock)
      .mockReturnValueOnce({ stdout: Buffer.from('') })
      .mockReturnValueOnce({ error: causeError });

    clipper.on('error', (err: Error) => {
      expect(err.cause).toHaveProperty('message', causeError.message);
    });
    clipper.on('end', done);
    clipper.process();
  }));

  it('calls the buffer extract function', () => new Promise((done) => {
    (spawnSync as Mock)
      .mockReturnValueOnce({ stdout: Buffer.from('') })
      .mockReturnValueOnce({});

    clipper.on('end', done);
    clipper.process();

    expect(readFileSync).toBeCalled();
  }));

  it('calls the cleanup function', () => new Promise((done) => {
    (spawnSync as Mock)
      .mockReturnValueOnce({ stdout: Buffer.from('') })
      .mockReturnValueOnce({});

    clipper.on('end', done);
    clipper.process();

    expect(unlinkSync).toBeCalled();
  }));
});