ruby_spriter 0.6.5

data/spec/ruby_spriter/cli_spec.rb

@@ -0,0 +1,1142 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe RubySpriter::CLI do
+  describe 'Other Options' do
+    describe '--keep-temp flag' do
+      it 'sets keep_temp option to true' do
+        # Mock the Processor to capture the options
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:keep_temp]).to eq(true)
+          processor_double
+        end
+
+        # Parse with --keep-temp and a valid input to avoid validation errors
+        described_class.start(['--video', 'test.mp4', '--keep-temp'])
+      end
+    end
+
+    describe '--debug flag' do
+      it 'sets both debug and keep_temp options to true' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:debug]).to eq(true)
+          expect(options[:keep_temp]).to eq(true)
+          processor_double
+        end
+
+        described_class.start(['--video', 'test.mp4', '--debug'])
+      end
+    end
+
+    describe '--help flag' do
+      it 'outputs help text and exits' do
+        expect do
+          expect { described_class.start(['--help']) }.to output(/Usage: ruby_spriter/).to_stdout
+        end.to raise_error(SystemExit)
+      end
+
+      it 'displays Other Options section' do
+        expect do
+          expect { described_class.start(['--help']) }.to output(/Other Options:/).to_stdout
+        end.to raise_error(SystemExit)
+      end
+
+      it 'lists --keep-temp in help output' do
+        expect do
+          expect { described_class.start(['--help']) }.to output(/--keep-temp/).to_stdout
+        end.to raise_error(SystemExit)
+      end
+
+      it 'lists --debug in help output' do
+        expect do
+          expect { described_class.start(['--help']) }.to output(/--debug/).to_stdout
+        end.to raise_error(SystemExit)
+      end
+
+      it 'lists --version in help output' do
+        expect do
+          expect { described_class.start(['--help']) }.to output(/--version/).to_stdout
+        end.to raise_error(SystemExit)
+      end
+
+      it 'lists --check-dependencies in help output' do
+        expect do
+          expect { described_class.start(['--help']) }.to output(/--check-dependencies/).to_stdout
+        end.to raise_error(SystemExit)
+      end
+
+      it 'supports short form -h' do
+        expect do
+          expect { described_class.start(['-h']) }.to output(/Usage: ruby_spriter/).to_stdout
+        end.to raise_error(SystemExit)
+      end
+    end
+
+    describe '--version flag' do
+      it 'outputs version information and exits' do
+        expect do
+          expect { described_class.start(['--version']) }
+            .to output(/Ruby Spriter v#{RubySpriter::VERSION}/).to_stdout
+        end.to raise_error(SystemExit)
+      end
+
+      it 'displays platform information' do
+        expect do
+          expect { described_class.start(['--version']) }
+            .to output(/Platform:/).to_stdout
+        end.to raise_error(SystemExit)
+      end
+
+      it 'displays date information' do
+        expect do
+          expect { described_class.start(['--version']) }
+            .to output(/Date: #{RubySpriter::VERSION_DATE}/).to_stdout
+        end.to raise_error(SystemExit)
+      end
+    end
+
+    describe '--check-dependencies flag' do
+      it 'sets check_dependencies option to true' do
+        # Mock DependencyChecker to avoid actually checking dependencies
+        checker_double = instance_double(RubySpriter::DependencyChecker)
+        allow(checker_double).to receive(:print_report)
+        allow(checker_double).to receive(:all_satisfied?).and_return(true)
+        allow(RubySpriter::DependencyChecker).to receive(:new).and_return(checker_double)
+
+        expect do
+          described_class.start(['--check-dependencies'])
+        end.to raise_error(SystemExit) { |error|
+          expect(error.status).to eq(0)
+        }
+      end
+
+      it 'exits with 0 when all dependencies are satisfied' do
+        checker_double = instance_double(RubySpriter::DependencyChecker)
+        allow(checker_double).to receive(:print_report)
+        allow(checker_double).to receive(:all_satisfied?).and_return(true)
+        allow(RubySpriter::DependencyChecker).to receive(:new).and_return(checker_double)
+
+        expect do
+          described_class.start(['--check-dependencies'])
+        end.to raise_error(SystemExit) { |error|
+          expect(error.status).to eq(0)
+        }
+      end
+
+      it 'exits with 1 when dependencies are missing' do
+        checker_double = instance_double(RubySpriter::DependencyChecker)
+        allow(checker_double).to receive(:print_report)
+        allow(checker_double).to receive(:all_satisfied?).and_return(false)
+        allow(RubySpriter::DependencyChecker).to receive(:new).and_return(checker_double)
+
+        expect do
+          described_class.start(['--check-dependencies'])
+        end.to raise_error(SystemExit) { |error|
+          expect(error.status).to eq(1)
+        }
+      end
+
+      it 'calls DependencyChecker with verbose: true' do
+        checker_double = instance_double(RubySpriter::DependencyChecker)
+        allow(checker_double).to receive(:print_report)
+        allow(checker_double).to receive(:all_satisfied?).and_return(true)
+
+        expect(RubySpriter::DependencyChecker).to receive(:new).with(verbose: true).and_return(checker_double)
+
+        expect do
+          described_class.start(['--check-dependencies'])
+        end.to raise_error(SystemExit)
+      end
+    end
+  end
+
+  describe '--image flag' do
+    let(:fixture_with_meta) { File.join(__dir__, '..', 'fixtures', 'spritesheet_with_metadata.png') }
+    let(:fixture_without_meta) { File.join(__dir__, '..', 'fixtures', 'image_without_metadata.png') }
+
+    describe 'argument parsing' do
+      it 'sets image option with --image flag' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:image]).to eq(fixture_with_meta)
+          processor_double
+        end
+
+        described_class.start(['--image', fixture_with_meta])
+      end
+
+      it 'supports short form -i flag' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:image]).to eq(fixture_without_meta)
+          processor_double
+        end
+
+        described_class.start(['-i', fixture_without_meta])
+      end
+
+      it 'accepts file path with spaces' do
+        # Create a temp file with spaces in the name for this test
+        temp_file = File.join(@test_dir, 'file with spaces.png')
+        FileUtils.cp(fixture_with_meta, temp_file)
+
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:image]).to eq(temp_file)
+          processor_double
+        end
+
+        described_class.start(['--image', temp_file])
+      end
+    end
+
+    describe 'mutual exclusivity with other input modes' do
+      it 'cannot be used with --video' do
+        expect do
+          described_class.start(['--video', 'test.mp4', '--image', fixture_with_meta])
+        end.to raise_error(RubySpriter::ValidationError, /Cannot use multiple input modes/)
+      end
+
+      it 'cannot be used with --consolidate' do
+        expect do
+          described_class.start(['--consolidate', 'a.png,b.png', '--image', fixture_with_meta])
+        end.to raise_error(RubySpriter::ValidationError, /Cannot use multiple input modes/)
+      end
+
+      it 'cannot be used with --verify' do
+        expect do
+          described_class.start(['--verify', fixture_with_meta, '--image', fixture_without_meta])
+        end.to raise_error(RubySpriter::ValidationError, /Cannot use multiple input modes/)
+      end
+
+      it 'can be used alone without error' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+        allow(RubySpriter::Processor).to receive(:new).and_return(processor_double)
+
+        expect do
+          described_class.start(['--image', fixture_with_meta])
+        end.not_to raise_error
+      end
+    end
+
+    describe 'file validation' do
+      describe 'file existence' do
+        it 'raises error for non-existent file' do
+          expect do
+            described_class.start(['--image', 'nonexistent.png'])
+          end.to raise_error(RubySpriter::ValidationError, /File not found/)
+        end
+
+        it 'accepts existing PNG file with metadata' do
+          processor_double = instance_double(RubySpriter::Processor)
+          allow(processor_double).to receive(:run)
+          allow(RubySpriter::Processor).to receive(:new).and_return(processor_double)
+
+          expect(File.exist?(fixture_with_meta)).to be true
+          expect do
+            described_class.start(['--image', fixture_with_meta])
+          end.not_to raise_error
+        end
+
+        it 'accepts existing PNG file without metadata' do
+          processor_double = instance_double(RubySpriter::Processor)
+          allow(processor_double).to receive(:run)
+          allow(RubySpriter::Processor).to receive(:new).and_return(processor_double)
+
+          expect(File.exist?(fixture_without_meta)).to be true
+          expect do
+            described_class.start(['--image', fixture_without_meta])
+          end.not_to raise_error
+        end
+      end
+
+      describe 'file extension validation' do
+        it 'accepts .png extension' do
+          processor_double = instance_double(RubySpriter::Processor)
+          allow(processor_double).to receive(:run)
+          allow(RubySpriter::Processor).to receive(:new).and_return(processor_double)
+
+          expect(File.extname(fixture_with_meta)).to eq('.png')
+          expect do
+            described_class.start(['--image', fixture_with_meta])
+          end.not_to raise_error
+        end
+
+        it 'accepts .PNG extension (case insensitive)' do
+          # Create a temp file with uppercase extension
+          temp_file = File.join(@test_dir, 'test.PNG')
+          FileUtils.cp(fixture_with_meta, temp_file)
+
+          processor_double = instance_double(RubySpriter::Processor)
+          allow(processor_double).to receive(:run)
+          allow(RubySpriter::Processor).to receive(:new).and_return(processor_double)
+
+          expect do
+            described_class.start(['--image', temp_file])
+          end.not_to raise_error
+        end
+
+        it 'rejects .jpg extension' do
+          # Create a fake .jpg file (doesn't need to be valid JPG for this test)
+          temp_file = File.join(@test_dir, 'test.jpg')
+          FileUtils.touch(temp_file)
+
+          expect do
+            described_class.start(['--image', temp_file])
+          end.to raise_error(RubySpriter::ValidationError, /--image expects \.png file, got: \.jpg/)
+        end
+
+        it 'rejects .jpeg extension' do
+          temp_file = File.join(@test_dir, 'test.jpeg')
+          FileUtils.touch(temp_file)
+
+          expect do
+            described_class.start(['--image', temp_file])
+          end.to raise_error(RubySpriter::ValidationError, /--image expects \.png file, got: \.jpeg/)
+        end
+
+        it 'rejects .gif extension' do
+          temp_file = File.join(@test_dir, 'test.gif')
+          FileUtils.touch(temp_file)
+
+          expect do
+            described_class.start(['--image', temp_file])
+          end.to raise_error(RubySpriter::ValidationError, /--image expects \.png file, got: \.gif/)
+        end
+
+        it 'rejects .bmp extension' do
+          temp_file = File.join(@test_dir, 'test.bmp')
+          FileUtils.touch(temp_file)
+
+          expect do
+            described_class.start(['--image', temp_file])
+          end.to raise_error(RubySpriter::ValidationError, /--image expects \.png file, got: \.bmp/)
+        end
+
+        it 'rejects file with no extension' do
+          temp_file = File.join(@test_dir, 'testfile')
+          FileUtils.touch(temp_file)
+
+          expect do
+            described_class.start(['--image', temp_file])
+          end.to raise_error(RubySpriter::ValidationError, /--image expects \.png file/)
+        end
+      end
+    end
+
+    describe 'integration with processing options' do
+      it 'works with --scale option' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:image]).to eq(fixture_with_meta)
+          expect(options[:scale_percent]).to eq(50)
+          processor_double
+        end
+
+        described_class.start(['--image', fixture_with_meta, '--scale', '50'])
+      end
+
+      it 'works with --remove-bg option' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:image]).to eq(fixture_with_meta)
+          expect(options[:remove_bg]).to eq(true)
+          processor_double
+        end
+
+        described_class.start(['--image', fixture_with_meta, '--remove-bg'])
+      end
+
+      it 'works with --sharpen option' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:image]).to eq(fixture_without_meta)
+          expect(options[:sharpen]).to eq(true)
+          processor_double
+        end
+
+        described_class.start(['--image', fixture_without_meta, '--sharpen'])
+      end
+
+      it 'works with --interpolation option' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:image]).to eq(fixture_with_meta)
+          expect(options[:scale_interpolation]).to eq('nohalo')
+          processor_double
+        end
+
+        described_class.start(['--image', fixture_with_meta, '--interpolation', 'nohalo'])
+      end
+
+      it 'works with multiple processing options combined' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:image]).to eq(fixture_without_meta)
+          expect(options[:scale_percent]).to eq(50)
+          expect(options[:remove_bg]).to eq(true)
+          expect(options[:sharpen]).to eq(true)
+          expect(options[:scale_interpolation]).to eq('lohalo')
+          processor_double
+        end
+
+        described_class.start([
+          '--image', fixture_without_meta,
+          '--scale', '50',
+          '--remove-bg',
+          '--sharpen',
+          '--interpolation', 'lohalo'
+        ])
+      end
+
+      it 'works with --output option' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:image]).to eq(fixture_with_meta)
+          expect(options[:output]).to eq('custom_output.png')
+          processor_double
+        end
+
+        described_class.start(['--image', fixture_with_meta, '--output', 'custom_output.png'])
+      end
+    end
+  end
+
+  describe '--video flag' do
+    let(:fixture_video) { File.join(__dir__, '..', 'fixtures', 'test_video.mp4') }
+
+    describe 'argument parsing' do
+      it 'sets video option with --video flag' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:video]).to eq(fixture_video)
+          processor_double
+        end
+
+        described_class.start(['--video', fixture_video])
+      end
+
+      it 'supports short form -v flag' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:video]).to eq(fixture_video)
+          processor_double
+        end
+
+        described_class.start(['-v', fixture_video])
+      end
+
+      it 'accepts file path with spaces' do
+        # Create a temp file with spaces in the name for this test
+        temp_file = File.join(@test_dir, 'video with spaces.mp4')
+        FileUtils.cp(fixture_video, temp_file)
+
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:video]).to eq(temp_file)
+          processor_double
+        end
+
+        described_class.start(['--video', temp_file])
+      end
+    end
+
+    describe 'mutual exclusivity with other input modes' do
+      it 'cannot be used with --image' do
+        expect do
+          described_class.start(['--video', fixture_video, '--image', 'test.png'])
+        end.to raise_error(RubySpriter::ValidationError, /Cannot use multiple input modes/)
+      end
+
+      it 'cannot be used with --consolidate' do
+        expect do
+          described_class.start(['--video', fixture_video, '--consolidate', 'a.png,b.png'])
+        end.to raise_error(RubySpriter::ValidationError, /Cannot use multiple input modes/)
+      end
+
+      it 'cannot be used with --verify' do
+        expect do
+          described_class.start(['--video', fixture_video, '--verify', 'test.png'])
+        end.to raise_error(RubySpriter::ValidationError, /Cannot use multiple input modes/)
+      end
+
+      it 'can be used alone without error' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+        allow(RubySpriter::Processor).to receive(:new).and_return(processor_double)
+
+        expect do
+          described_class.start(['--video', fixture_video])
+        end.not_to raise_error
+      end
+    end
+
+    describe 'file validation' do
+      describe 'file existence' do
+        it 'raises error for non-existent file' do
+          expect do
+            described_class.start(['--video', 'nonexistent.mp4'])
+          end.to raise_error(RubySpriter::ValidationError, /File not found/)
+        end
+
+        it 'accepts existing MP4 file' do
+          processor_double = instance_double(RubySpriter::Processor)
+          allow(processor_double).to receive(:run)
+          allow(RubySpriter::Processor).to receive(:new).and_return(processor_double)
+
+          expect(File.exist?(fixture_video)).to be true
+          expect do
+            described_class.start(['--video', fixture_video])
+          end.not_to raise_error
+        end
+      end
+
+      describe 'file extension validation' do
+        it 'accepts .mp4 extension' do
+          processor_double = instance_double(RubySpriter::Processor)
+          allow(processor_double).to receive(:run)
+          allow(RubySpriter::Processor).to receive(:new).and_return(processor_double)
+
+          expect(File.extname(fixture_video)).to eq('.mp4')
+          expect do
+            described_class.start(['--video', fixture_video])
+          end.not_to raise_error
+        end
+
+        it 'accepts .MP4 extension (case insensitive)' do
+          # Create a temp file with uppercase extension
+          temp_file = File.join(@test_dir, 'test.MP4')
+          FileUtils.cp(fixture_video, temp_file)
+
+          processor_double = instance_double(RubySpriter::Processor)
+          allow(processor_double).to receive(:run)
+          allow(RubySpriter::Processor).to receive(:new).and_return(processor_double)
+
+          expect do
+            described_class.start(['--video', temp_file])
+          end.not_to raise_error
+        end
+
+        it 'rejects .avi extension' do
+          temp_file = File.join(@test_dir, 'test.avi')
+          FileUtils.touch(temp_file)
+
+          expect do
+            described_class.start(['--video', temp_file])
+          end.to raise_error(RubySpriter::ValidationError, /--video expects \.mp4 file, got: \.avi/)
+        end
+
+        it 'rejects .mov extension' do
+          temp_file = File.join(@test_dir, 'test.mov')
+          FileUtils.touch(temp_file)
+
+          expect do
+            described_class.start(['--video', temp_file])
+          end.to raise_error(RubySpriter::ValidationError, /--video expects \.mp4 file, got: \.mov/)
+        end
+
+        it 'rejects .mkv extension' do
+          temp_file = File.join(@test_dir, 'test.mkv')
+          FileUtils.touch(temp_file)
+
+          expect do
+            described_class.start(['--video', temp_file])
+          end.to raise_error(RubySpriter::ValidationError, /--video expects \.mp4 file, got: \.mkv/)
+        end
+
+        it 'rejects .wmv extension' do
+          temp_file = File.join(@test_dir, 'test.wmv')
+          FileUtils.touch(temp_file)
+
+          expect do
+            described_class.start(['--video', temp_file])
+          end.to raise_error(RubySpriter::ValidationError, /--video expects \.mp4 file, got: \.wmv/)
+        end
+
+        it 'rejects file with no extension' do
+          temp_file = File.join(@test_dir, 'videofile')
+          FileUtils.touch(temp_file)
+
+          expect do
+            described_class.start(['--video', temp_file])
+          end.to raise_error(RubySpriter::ValidationError, /--video expects \.mp4 file/)
+        end
+      end
+    end
+
+    describe 'integration with video-specific options' do
+      it 'works with --frames option' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:video]).to eq(fixture_video)
+          expect(options[:frame_count]).to eq(32)
+          processor_double
+        end
+
+        described_class.start(['--video', fixture_video, '--frames', '32'])
+      end
+
+      it 'works with --columns option' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:video]).to eq(fixture_video)
+          expect(options[:columns]).to eq(8)
+          processor_double
+        end
+
+        described_class.start(['--video', fixture_video, '--columns', '8'])
+      end
+
+      it 'works with --width option' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:video]).to eq(fixture_video)
+          expect(options[:max_width]).to eq(640)
+          processor_double
+        end
+
+        described_class.start(['--video', fixture_video, '--width', '640'])
+      end
+
+      it 'works with --background option' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:video]).to eq(fixture_video)
+          expect(options[:bg_color]).to eq('white')
+          processor_double
+        end
+
+        described_class.start(['--video', fixture_video, '--background', 'white'])
+      end
+
+      it 'works with multiple video options combined' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:video]).to eq(fixture_video)
+          expect(options[:frame_count]).to eq(64)
+          expect(options[:columns]).to eq(8)
+          expect(options[:max_width]).to eq(480)
+          expect(options[:bg_color]).to eq('white')
+          processor_double
+        end
+
+        described_class.start([
+          '--video', fixture_video,
+          '--frames', '64',
+          '--columns', '8',
+          '--width', '480',
+          '--background', 'white'
+        ])
+      end
+    end
+
+    describe 'integration with processing options' do
+      it 'works with --scale option' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:video]).to eq(fixture_video)
+          expect(options[:scale_percent]).to eq(50)
+          processor_double
+        end
+
+        described_class.start(['--video', fixture_video, '--scale', '50'])
+      end
+
+      it 'works with --remove-bg option' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:video]).to eq(fixture_video)
+          expect(options[:remove_bg]).to eq(true)
+          processor_double
+        end
+
+        described_class.start(['--video', fixture_video, '--remove-bg'])
+      end
+
+      it 'works with --sharpen option' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:video]).to eq(fixture_video)
+          expect(options[:sharpen]).to eq(true)
+          processor_double
+        end
+
+        described_class.start(['--video', fixture_video, '--sharpen'])
+      end
+
+      it 'works with --interpolation option' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:video]).to eq(fixture_video)
+          expect(options[:scale_interpolation]).to eq('lohalo')
+          processor_double
+        end
+
+        described_class.start(['--video', fixture_video, '--interpolation', 'lohalo'])
+      end
+
+      it 'works with all options combined' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:video]).to eq(fixture_video)
+          expect(options[:frame_count]).to eq(32)
+          expect(options[:columns]).to eq(8)
+          expect(options[:scale_percent]).to eq(50)
+          expect(options[:remove_bg]).to eq(true)
+          expect(options[:sharpen]).to eq(true)
+          expect(options[:scale_interpolation]).to eq('nohalo')
+          processor_double
+        end
+
+        described_class.start([
+          '--video', fixture_video,
+          '--frames', '32',
+          '--columns', '8',
+          '--scale', '50',
+          '--remove-bg',
+          '--sharpen',
+          '--interpolation', 'nohalo'
+        ])
+      end
+
+      it 'works with --output option' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:video]).to eq(fixture_video)
+          expect(options[:output]).to eq('custom_spritesheet.png')
+          processor_double
+        end
+
+        described_class.start(['--video', fixture_video, '--output', 'custom_spritesheet.png'])
+      end
+    end
+
+    describe 'preset configurations' do
+      it 'works with --preset thumbnail' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:video]).to eq(fixture_video)
+          expect(options[:columns]).to eq(3)
+          expect(options[:frame_count]).to eq(9)
+          expect(options[:max_width]).to eq(240)
+          processor_double
+        end
+
+        described_class.start(['--video', fixture_video, '--preset', 'thumbnail'])
+      end
+
+      it 'works with --preset preview' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:video]).to eq(fixture_video)
+          expect(options[:columns]).to eq(4)
+          expect(options[:frame_count]).to eq(16)
+          expect(options[:max_width]).to eq(400)
+          processor_double
+        end
+
+        described_class.start(['--video', fixture_video, '--preset', 'preview'])
+      end
+
+      it 'works with --preset detailed' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:video]).to eq(fixture_video)
+          expect(options[:columns]).to eq(10)
+          expect(options[:frame_count]).to eq(50)
+          expect(options[:max_width]).to eq(320)
+          processor_double
+        end
+
+        described_class.start(['--video', fixture_video, '--preset', 'detailed'])
+      end
+
+      it 'works with --preset contact' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:video]).to eq(fixture_video)
+          expect(options[:columns]).to eq(8)
+          expect(options[:frame_count]).to eq(64)
+          expect(options[:max_width]).to eq(160)
+          processor_double
+        end
+
+        described_class.start(['--video', fixture_video, '--preset', 'contact'])
+      end
+    end
+  end
+
+  describe '--consolidate flag' do
+    # Real spritesheets generated from test_video.mp4 using --video
+    # These demonstrate the actual workflow: --video creates spritesheets, --consolidate combines them
+    let(:spritesheet_4x2) { File.join(__dir__, '..', 'fixtures', 'spritesheet_4x2.png') }  # 2 cols, 2 rows, 4 frames
+    let(:spritesheet_6x2) { File.join(__dir__, '..', 'fixtures', 'spritesheet_6x2.png') }  # 2 cols, 3 rows, 6 frames
+    let(:spritesheet_4x4) { File.join(__dir__, '..', 'fixtures', 'spritesheet_4x4.png') }  # 4 cols, 1 row, 4 frames (different columns)
+
+    # Generic PNG fixtures for edge case testing
+    let(:fixture_with_meta) { File.join(__dir__, '..', 'fixtures', 'spritesheet_with_metadata.png') }
+    let(:fixture_without_meta) { File.join(__dir__, '..', 'fixtures', 'image_without_metadata.png') }
+
+    describe 'argument parsing' do
+      it 'accepts comma-separated list of files' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:consolidate]).to eq([spritesheet_4x2, spritesheet_6x2])
+          processor_double
+        end
+
+        described_class.start(['--consolidate', "#{spritesheet_4x2},#{spritesheet_6x2}"])
+      end
+
+      it 'accepts three or more files' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:consolidate]).to eq([spritesheet_4x2, spritesheet_6x2, spritesheet_4x4])
+          processor_double
+        end
+
+        described_class.start(['--consolidate', "#{spritesheet_4x2},#{spritesheet_6x2},#{spritesheet_4x4}"])
+      end
+
+      it 'accepts file paths with spaces' do
+        # Create temp files with spaces in names
+        temp_file1 = File.join(@test_dir, 'file with spaces 1.png')
+        temp_file2 = File.join(@test_dir, 'file with spaces 2.png')
+        FileUtils.cp(spritesheet_4x2, temp_file1)
+        FileUtils.cp(spritesheet_6x2, temp_file2)
+
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:consolidate]).to eq([temp_file1, temp_file2])
+          processor_double
+        end
+
+        described_class.start(['--consolidate', "#{temp_file1},#{temp_file2}"])
+      end
+    end
+
+    describe 'minimum file count validation' do
+      it 'requires at least 2 files' do
+        expect do
+          described_class.start(['--consolidate', spritesheet_4x2])
+        end.to raise_error(RubySpriter::ValidationError, /requires at least 2 files/)
+      end
+
+      it 'accepts exactly 2 files' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+        allow(RubySpriter::Processor).to receive(:new).and_return(processor_double)
+
+        expect do
+          described_class.start(['--consolidate', "#{spritesheet_4x2},#{spritesheet_6x2}"])
+        end.not_to raise_error
+      end
+
+      it 'accepts more than 2 files' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+        allow(RubySpriter::Processor).to receive(:new).and_return(processor_double)
+
+        expect do
+          described_class.start(['--consolidate', "#{spritesheet_4x2},#{spritesheet_6x2},#{spritesheet_4x4}"])
+        end.not_to raise_error
+      end
+    end
+
+    describe 'mutual exclusivity with other input modes' do
+      it 'cannot be used with --video' do
+        expect do
+          described_class.start(['--video', 'test.mp4', '--consolidate', "#{spritesheet_4x2},#{spritesheet_6x2}"])
+        end.to raise_error(RubySpriter::ValidationError, /Cannot use multiple input modes/)
+      end
+
+      it 'cannot be used with --image' do
+        expect do
+          described_class.start(['--image', spritesheet_4x2, '--consolidate', "#{spritesheet_4x2},#{spritesheet_6x2}"])
+        end.to raise_error(RubySpriter::ValidationError, /Cannot use multiple input modes/)
+      end
+
+      it 'cannot be used with --verify' do
+        expect do
+          described_class.start(['--verify', spritesheet_4x2, '--consolidate', "#{spritesheet_4x2},#{spritesheet_6x2}"])
+        end.to raise_error(RubySpriter::ValidationError, /Cannot use multiple input modes/)
+      end
+
+      it 'can be used alone without error' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+        allow(RubySpriter::Processor).to receive(:new).and_return(processor_double)
+
+        expect do
+          described_class.start(['--consolidate', "#{spritesheet_4x2},#{spritesheet_6x2}"])
+        end.not_to raise_error
+      end
+    end
+
+    describe 'file validation' do
+      describe 'file existence' do
+        it 'raises error if first file does not exist' do
+          expect do
+            described_class.start(['--consolidate', "nonexistent1.png,#{spritesheet_4x2}"])
+          end.to raise_error(RubySpriter::ValidationError, /File not found/)
+        end
+
+        it 'raises error if second file does not exist' do
+          expect do
+            described_class.start(['--consolidate', "#{spritesheet_4x2},nonexistent2.png"])
+          end.to raise_error(RubySpriter::ValidationError, /File not found/)
+        end
+
+        it 'raises error if any file in list does not exist' do
+          expect do
+            described_class.start(['--consolidate', "#{spritesheet_4x2},nonexistent.png,#{spritesheet_6x2}"])
+          end.to raise_error(RubySpriter::ValidationError, /File not found/)
+        end
+
+        it 'accepts all existing spritesheet files' do
+          processor_double = instance_double(RubySpriter::Processor)
+          allow(processor_double).to receive(:run)
+          allow(RubySpriter::Processor).to receive(:new).and_return(processor_double)
+
+          expect(File.exist?(spritesheet_4x2)).to be true
+          expect(File.exist?(spritesheet_6x2)).to be true
+
+          expect do
+            described_class.start(['--consolidate', "#{spritesheet_4x2},#{spritesheet_6x2}"])
+          end.not_to raise_error
+        end
+      end
+
+      describe 'file extension validation' do
+        it 'accepts all .png spritesheet files' do
+          processor_double = instance_double(RubySpriter::Processor)
+          allow(processor_double).to receive(:run)
+          allow(RubySpriter::Processor).to receive(:new).and_return(processor_double)
+
+          expect do
+            described_class.start(['--consolidate', "#{spritesheet_4x2},#{spritesheet_6x2}"])
+          end.not_to raise_error
+        end
+
+        it 'accepts .PNG extension (case insensitive)' do
+          temp_file1 = File.join(@test_dir, 'test1.PNG')
+          temp_file2 = File.join(@test_dir, 'test2.PNG')
+          FileUtils.cp(spritesheet_4x2, temp_file1)
+          FileUtils.cp(spritesheet_6x2, temp_file2)
+
+          processor_double = instance_double(RubySpriter::Processor)
+          allow(processor_double).to receive(:run)
+          allow(RubySpriter::Processor).to receive(:new).and_return(processor_double)
+
+          expect do
+            described_class.start(['--consolidate', "#{temp_file1},#{temp_file2}"])
+          end.not_to raise_error
+        end
+
+        it 'rejects files with .jpg extension' do
+          temp_file = File.join(@test_dir, 'test.jpg')
+          FileUtils.touch(temp_file)
+
+          expect do
+            described_class.start(['--consolidate', "#{spritesheet_4x2},#{temp_file}"])
+          end.to raise_error(RubySpriter::ValidationError, /--consolidate expects \.png file, got: \.jpg/)
+        end
+
+        it 'rejects files with .mp4 extension' do
+          temp_file = File.join(@test_dir, 'test.mp4')
+          FileUtils.touch(temp_file)
+
+          expect do
+            described_class.start(['--consolidate', "#{spritesheet_4x2},#{temp_file}"])
+          end.to raise_error(RubySpriter::ValidationError, /--consolidate expects \.png file, got: \.mp4/)
+        end
+
+        it 'rejects files with no extension' do
+          temp_file = File.join(@test_dir, 'noextension')
+          FileUtils.touch(temp_file)
+
+          expect do
+            described_class.start(['--consolidate', "#{spritesheet_4x2},#{temp_file}"])
+          end.to raise_error(RubySpriter::ValidationError, /--consolidate expects \.png file/)
+        end
+
+        it 'validates all files in the list' do
+          temp_file1 = File.join(@test_dir, 'test1.jpg')
+          temp_file2 = File.join(@test_dir, 'test2.gif')
+          FileUtils.touch(temp_file1)
+          FileUtils.touch(temp_file2)
+
+          # Should fail on the first non-PNG file
+          expect do
+            described_class.start(['--consolidate', "#{spritesheet_4x2},#{temp_file1},#{temp_file2}"])
+          end.to raise_error(RubySpriter::ValidationError, /--consolidate expects \.png file/)
+        end
+      end
+    end
+
+    describe 'consolidation-specific options' do
+      it 'works with --validate-columns flag (default true)' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:consolidate]).to eq([spritesheet_4x2, spritesheet_6x2])
+          expect(options[:validate_columns]).to eq(true)
+          processor_double
+        end
+
+        described_class.start(['--consolidate', "#{spritesheet_4x2},#{spritesheet_6x2}", '--validate-columns'])
+      end
+
+      it 'works with --no-validate-columns flag' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:consolidate]).to eq([spritesheet_4x2, spritesheet_6x2])
+          expect(options[:validate_columns]).to eq(false)
+          processor_double
+        end
+
+        described_class.start(['--consolidate', "#{spritesheet_4x2},#{spritesheet_6x2}", '--no-validate-columns'])
+      end
+    end
+
+    describe 'integration with other options' do
+      it 'works with --output option' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:consolidate]).to eq([spritesheet_4x2, spritesheet_6x2])
+          expect(options[:output]).to eq('consolidated_output.png')
+          processor_double
+        end
+
+        described_class.start(['--consolidate', "#{spritesheet_4x2},#{spritesheet_6x2}", '--output', 'consolidated_output.png'])
+      end
+
+      it 'works with --debug option' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:consolidate]).to eq([spritesheet_4x2, spritesheet_6x2])
+          expect(options[:debug]).to eq(true)
+          expect(options[:keep_temp]).to eq(true)
+          processor_double
+        end
+
+        described_class.start(['--consolidate', "#{spritesheet_4x2},#{spritesheet_6x2}", '--debug'])
+      end
+
+      it 'works with multiple options combined' do
+        processor_double = instance_double(RubySpriter::Processor)
+        allow(processor_double).to receive(:run)
+
+        allow(RubySpriter::Processor).to receive(:new) do |options|
+          expect(options[:consolidate]).to eq([spritesheet_4x2, spritesheet_6x2])
+          expect(options[:validate_columns]).to eq(false)
+          expect(options[:output]).to eq('combined.png')
+          expect(options[:debug]).to eq(true)
+          processor_double
+        end
+
+        described_class.start([
+          '--consolidate', "#{spritesheet_4x2},#{spritesheet_6x2}",
+          '--no-validate-columns',
+          '--output', 'combined.png',
+          '--debug'
+        ])
+      end
+    end
+  end
+
+  describe 'error handling' do
+    describe 'invalid option' do
+      it 'displays error message for invalid option' do
+        expect do
+          expect { described_class.start(['--invalid-option']) }
+            .to output(/Error:.*invalid/).to_stdout
+        end.to raise_error(SystemExit) { |error|
+          expect(error.status).to eq(1)
+        }
+      end
+
+      it 'suggests using --help' do
+        expect do
+          expect { described_class.start(['--invalid-option']) }
+            .to output(/Use --help for usage information/).to_stdout
+        end.to raise_error(SystemExit)
+      end
+    end
+  end
+end