@shaztech/video-cutter 1.0.0

package/tests/index.spec.js

@@ -0,0 +1,250 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+
+import fs from 'fs'
+import inquirer from 'inquirer'
+import { Command } from 'commander'
+import { getVideoDuration, createCountSegments, createTimeSegments } from '../src/core.js'
+import { processVideo, setupCli } from '../index.js'
+
+vi.mock('child_process', () => ({
+  execSync: vi.fn(), // doesn't throw = ffmpeg/ffprobe available
+  spawn: vi.fn()
+}))
+
+vi.mock('../src/core.js', () => ({
+  getVideoDuration: vi.fn(),
+  createCountSegments: vi.fn(),
+  createTimeSegments: vi.fn()
+}))
+
+vi.mock('commander', () => {
+  const mockProgram = {
+    name: vi.fn().mockReturnThis(),
+    description: vi.fn().mockReturnThis(),
+    version: vi.fn().mockReturnThis(),
+    requiredOption: vi.fn().mockReturnThis(),
+    addOption: vi.fn().mockReturnThis(),
+    option: vi.fn().mockReturnThis(),
+    action: vi.fn().mockReturnThis(),
+    parse: vi.fn()
+  }
+  // eslint-disable-next-line prefer-arrow-callback
+  const MockOption = vi.fn(function MockOption () { return { conflicts: vi.fn().mockReturnThis() } })
+  // eslint-disable-next-line prefer-arrow-callback
+  return { Command: vi.fn(function MockCommand () { return mockProgram }), Option: MockOption }
+})
+
+describe('processVideo', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.spyOn(console, 'log').mockImplementation(() => {})
+    vi.spyOn(console, 'warn').mockImplementation(() => {})
+    vi.spyOn(console, 'error').mockImplementation(() => {})
+  })
+  afterEach(() => vi.restoreAllMocks())
+
+  it('exits when input file does not exist', async () => {
+    vi.spyOn(fs, 'existsSync').mockReturnValueOnce(false)
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => { throw new Error('exit') })
+    await expect(processVideo({ input: 'missing.mp4', segments: 2, output: '/out' })).rejects.toThrow('exit')
+    expect(exitSpy).toHaveBeenCalledWith(1)
+  })
+
+  it('creates default output directory path when none provided', async () => {
+    vi.spyOn(fs, 'existsSync')
+      .mockReturnValueOnce(true) // input file exists
+      .mockReturnValueOnce(false) // output dir does not exist
+    vi.spyOn(fs, 'mkdirSync').mockImplementation(() => {})
+    vi.mocked(getVideoDuration).mockResolvedValue(120)
+    vi.mocked(createCountSegments).mockResolvedValue()
+
+    await processVideo({ input: 'video.mp4', segments: 2 })
+
+    expect(fs.mkdirSync).toHaveBeenCalledWith(expect.stringContaining('output'), { recursive: true })
+  })
+
+  it('creates output directory when it does not exist', async () => {
+    vi.spyOn(fs, 'existsSync')
+      .mockReturnValueOnce(true) // input file exists
+      .mockReturnValueOnce(false) // output dir does not exist
+    vi.spyOn(fs, 'mkdirSync').mockImplementation(() => {})
+    vi.mocked(getVideoDuration).mockResolvedValue(120)
+    vi.mocked(createCountSegments).mockResolvedValue()
+
+    await processVideo({ input: 'video.mp4', segments: 2, output: '/out' })
+
+    expect(fs.mkdirSync).toHaveBeenCalledWith('/out', { recursive: true })
+  })
+
+  it('exits when video duration cannot be determined (falsy)', async () => {
+    vi.spyOn(fs, 'existsSync').mockReturnValue(true)
+    vi.mocked(getVideoDuration).mockResolvedValue(0)
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => { throw new Error('exit') })
+    await expect(processVideo({ input: 'video.mp4', segments: 2, output: '/out' })).rejects.toThrow('exit')
+    expect(exitSpy).toHaveBeenCalledWith(1)
+  })
+
+  it('exits when getVideoDuration throws', async () => {
+    vi.spyOn(fs, 'existsSync').mockReturnValue(true)
+    vi.mocked(getVideoDuration).mockRejectedValue(new Error('ffprobe failed'))
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => { throw new Error('exit') })
+    await expect(processVideo({ input: 'video.mp4', segments: 2, output: '/out' })).rejects.toThrow('exit')
+    expect(exitSpy).toHaveBeenCalledWith(1)
+  })
+
+  describe('time-based segmentation (--duration)', () => {
+    it('warns about stream copy mode when not re-encoding', async () => {
+      vi.spyOn(fs, 'existsSync').mockReturnValue(true)
+      vi.mocked(getVideoDuration).mockResolvedValue(120)
+      vi.mocked(createTimeSegments).mockResolvedValue()
+
+      await processVideo({ input: 'video.mp4', duration: 60, output: '/out' })
+
+      expect(console.warn).toHaveBeenCalledWith(expect.stringContaining('stream copy mode'))
+      expect(createTimeSegments).toHaveBeenCalledWith('video.mp4', 120, 60, '/out', false, false)
+    })
+
+    it('does not warn when re-encoding', async () => {
+      vi.spyOn(fs, 'existsSync').mockReturnValue(true)
+      vi.mocked(getVideoDuration).mockResolvedValue(120)
+      vi.mocked(createTimeSegments).mockResolvedValue()
+
+      await processVideo({ input: 'video.mp4', duration: 60, output: '/out', reEncode: true })
+
+      expect(console.warn).not.toHaveBeenCalled()
+      expect(createTimeSegments).toHaveBeenCalledWith('video.mp4', 120, 60, '/out', false, true)
+    })
+
+    it('prompts user for short segments (<30s) and proceeds when confirmed', async () => {
+      vi.spyOn(fs, 'existsSync').mockReturnValue(true)
+      vi.mocked(getVideoDuration).mockResolvedValue(60)
+      vi.mocked(createTimeSegments).mockResolvedValue()
+      vi.spyOn(inquirer, 'prompt').mockResolvedValue({ confirm: true })
+
+      await processVideo({ input: 'video.mp4', duration: 10, output: '/out' })
+
+      expect(inquirer.prompt).toHaveBeenCalled()
+      expect(createTimeSegments).toHaveBeenCalled()
+    })
+
+    it('exits when user cancels short segment prompt', async () => {
+      vi.spyOn(fs, 'existsSync').mockReturnValue(true)
+      vi.mocked(getVideoDuration).mockResolvedValue(60)
+      vi.spyOn(inquirer, 'prompt').mockResolvedValue({ confirm: false })
+      const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => { throw new Error('exit') })
+
+      await expect(processVideo({ input: 'video.mp4', duration: 10, output: '/out' })).rejects.toThrow('exit')
+      expect(exitSpy).toHaveBeenCalledWith(0)
+    })
+  })
+
+  describe('count-based segmentation (--segments)', () => {
+    it('warns about stream copy mode when segments >= 30s', async () => {
+      vi.spyOn(fs, 'existsSync').mockReturnValue(true)
+      vi.mocked(getVideoDuration).mockResolvedValue(120)
+      vi.mocked(createCountSegments).mockResolvedValue()
+
+      await processVideo({ input: 'video.mp4', segments: 2, output: '/out' })
+
+      expect(console.warn).toHaveBeenCalledWith(expect.stringContaining('stream copy mode'))
+      expect(createCountSegments).toHaveBeenCalledWith('video.mp4', 120, 2, '/out', false, false)
+    })
+
+    it('does not warn when re-encoding with segments >= 30s', async () => {
+      vi.spyOn(fs, 'existsSync').mockReturnValue(true)
+      vi.mocked(getVideoDuration).mockResolvedValue(120)
+      vi.mocked(createCountSegments).mockResolvedValue()
+
+      await processVideo({ input: 'video.mp4', segments: 2, output: '/out', reEncode: true })
+
+      expect(console.warn).not.toHaveBeenCalled()
+    })
+
+    it('warns about stream copy mode when segments < 30s and not re-encoding', async () => {
+      vi.spyOn(fs, 'existsSync').mockReturnValue(true)
+      vi.mocked(getVideoDuration).mockResolvedValue(60)
+      vi.mocked(createCountSegments).mockResolvedValue()
+      vi.spyOn(inquirer, 'prompt').mockResolvedValue({ confirm: true })
+
+      await processVideo({ input: 'video.mp4', segments: 10, output: '/out' })
+
+      expect(console.warn).toHaveBeenCalledWith(expect.stringContaining('stream copy mode'))
+    })
+
+    it('does not warn when re-encoding with short count segments', async () => {
+      vi.spyOn(fs, 'existsSync').mockReturnValue(true)
+      vi.mocked(getVideoDuration).mockResolvedValue(60)
+      vi.mocked(createCountSegments).mockResolvedValue()
+      vi.spyOn(inquirer, 'prompt').mockResolvedValue({ confirm: true })
+
+      await processVideo({ input: 'video.mp4', segments: 10, output: '/out', reEncode: true })
+
+      expect(console.warn).not.toHaveBeenCalled()
+      expect(createCountSegments).toHaveBeenCalled()
+    })
+
+    it('prompts user for short segments and proceeds when confirmed', async () => {
+      vi.spyOn(fs, 'existsSync').mockReturnValue(true)
+      vi.mocked(getVideoDuration).mockResolvedValue(60)
+      vi.mocked(createCountSegments).mockResolvedValue()
+      vi.spyOn(inquirer, 'prompt').mockResolvedValue({ confirm: true })
+
+      await processVideo({ input: 'video.mp4', segments: 10, output: '/out' })
+
+      expect(inquirer.prompt).toHaveBeenCalled()
+      expect(createCountSegments).toHaveBeenCalled()
+    })
+
+    it('exits when user cancels short segment prompt', async () => {
+      vi.spyOn(fs, 'existsSync').mockReturnValue(true)
+      vi.mocked(getVideoDuration).mockResolvedValue(60)
+      vi.spyOn(inquirer, 'prompt').mockResolvedValue({ confirm: false })
+      const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => { throw new Error('exit') })
+
+      await expect(processVideo({ input: 'video.mp4', segments: 10, output: '/out' })).rejects.toThrow('exit')
+      expect(exitSpy).toHaveBeenCalledWith(0)
+    })
+
+    it('passes verify and reEncode flags correctly', async () => {
+      vi.spyOn(fs, 'existsSync').mockReturnValue(true)
+      vi.mocked(getVideoDuration).mockResolvedValue(120)
+      vi.mocked(createCountSegments).mockResolvedValue()
+
+      await processVideo({ input: 'video.mp4', segments: 2, output: '/out', verify: true, reEncode: true })
+
+      expect(createCountSegments).toHaveBeenCalledWith('video.mp4', 120, 2, '/out', true, true)
+    })
+  })
+})
+
+describe('setupCli', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.spyOn(console, 'log').mockImplementation(() => {})
+  })
+  afterEach(() => vi.restoreAllMocks())
+
+  it('configures CLI with correct name, version, and options then calls parse', () => {
+    setupCli()
+    const program = vi.mocked(Command).mock.results[0].value
+    expect(program.name).toHaveBeenCalledWith('video-cutter')
+    expect(program.version).toHaveBeenCalledWith('1.0.0')
+    expect(program.requiredOption).toHaveBeenCalledWith('-i, --input <path>', expect.any(String))
+    expect(program.action).toHaveBeenCalledWith(processVideo)
+    expect(program.parse).toHaveBeenCalled()
+  })
+})

package/vitest.config.js

@@ -0,0 +1,13 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'html', 'lcov'],
+      exclude: ['**/node_modules/**', '**/dist/**', '**/*.spec.js', 'vitest.config.js']
+    }
+  }
+})