epub_tools 0.3.1 → 0.4.0

data/test/cli/option_builder_test.rb

@@ -0,0 +1,173 @@
+require_relative '../test_helper'
+require_relative '../../lib/epub_tools'
+require 'stringio'
+
+class OptionBuilderTest < Minitest::Test
+  def setup
+    @builder = EpubTools::CLI::OptionBuilder.new
+  end
+
+  def test_initialize_with_defaults
+    builder = EpubTools::CLI::OptionBuilder.new({ default: 'value' }, [:required])
+
+    assert_equal({ default: 'value' }, builder.options)
+    assert_equal [:required], builder.required_keys
+  end
+
+  def test_with_banner
+    @builder.with_banner('Test Banner')
+
+    assert_equal 'Test Banner', @builder.parser.banner
+  end
+
+  def test_with_help_option
+    # This test is tricky as --help would exit, so we'll test indirectly
+    @builder.with_help_option
+
+    assert_includes @builder.parser.to_s, '-h, --help'
+  end
+
+  def test_with_verbose_option
+    @builder.with_verbose_option
+
+    assert @builder.options[:verbose]
+
+    # Parse args with --quiet to change verbose to false
+    @builder.parse(['--quiet'])
+
+    refute @builder.options[:verbose]
+  end
+
+  def test_with_input_file
+    @builder.with_input_file('Test input')
+
+    assert_includes @builder.parser.to_s, '-i, --input-file FILE'
+    assert_includes @builder.parser.to_s, 'Test input (required)'
+
+    # Test with required=false
+    builder2 = EpubTools::CLI::OptionBuilder.new
+    builder2.with_input_file('Test input', false)
+
+    assert_includes builder2.parser.to_s, 'Test input'
+    refute_includes builder2.parser.to_s, 'Test input (required)'
+
+    # Test with actual parsing
+    @builder.parse(['-i', 'file.txt'])
+
+    assert_equal 'file.txt', @builder.options[:input_file]
+  end
+
+  def test_with_input_dir
+    @builder.with_input_dir('Test input dir')
+
+    assert_includes @builder.parser.to_s, '-i, --input-dir DIR'
+    assert_includes @builder.parser.to_s, 'Test input dir (required)'
+
+    @builder.parse(['-i', 'dir/path'])
+
+    assert_equal 'dir/path', @builder.options[:input_dir]
+  end
+
+  def test_with_output_dir
+    # Test with default value
+    @builder.with_output_dir('Test output dir', 'default/path')
+
+    assert_includes @builder.parser.to_s, '-o, --output-dir DIR'
+    assert_includes @builder.parser.to_s, 'Test output dir (default: default/path)'
+    assert_equal 'default/path', @builder.options[:output_dir]
+
+    # Test without default
+    builder2 = EpubTools::CLI::OptionBuilder.new
+    builder2.with_output_dir('Test output dir')
+
+    assert_includes builder2.parser.to_s, 'Test output dir (required)'
+
+    # Test actual parsing
+    @builder.parse(['-o', 'new/path'])
+
+    assert_equal 'new/path', @builder.options[:output_dir]
+  end
+
+  def test_with_output_file
+    @builder.with_output_file('Test output file')
+
+    assert_includes @builder.parser.to_s, '-o, --output-file FILE'
+    assert_includes @builder.parser.to_s, 'Test output file (required)'
+
+    @builder.parse(['-o', 'output.txt'])
+
+    assert_equal 'output.txt', @builder.options[:output_file]
+  end
+
+  def test_with_title_option
+    @builder.with_title_option
+
+    assert_includes @builder.parser.to_s, '-t, --title TITLE'
+    assert_includes @builder.parser.to_s, 'Book title (required)'
+
+    @builder.parse(['-t', 'Book Title'])
+
+    assert_equal 'Book Title', @builder.options[:title]
+  end
+
+  def test_with_author_option
+    @builder.with_author_option
+
+    assert_includes @builder.parser.to_s, '-a, --author AUTHOR'
+    assert_includes @builder.parser.to_s, 'Author name (required)'
+
+    @builder.parse(['-a', 'Author Name'])
+
+    assert_equal 'Author Name', @builder.options[:author]
+  end
+
+  def test_with_cover_option
+    @builder.with_cover_option
+
+    assert_includes @builder.parser.to_s, '-c, --cover PATH'
+    assert_includes @builder.parser.to_s, 'Cover image file path (optional)'
+
+    @builder.parse(['-c', 'cover.jpg'])
+
+    assert_equal 'cover.jpg', @builder.options[:cover_image]
+  end
+
+  def test_with_option
+    @builder.with_option('-x', '--extra VALUE', 'Extra option', :extra_option)
+
+    assert_includes @builder.parser.to_s, '-x, --extra VALUE'
+    assert_includes @builder.parser.to_s, 'Extra option'
+
+    @builder.parse(['-x', 'extra-value'])
+
+    assert_equal 'extra-value', @builder.options[:extra_option]
+  end
+
+  def test_with_custom_options
+    @builder.with_custom_options do |opts, options|
+      opts.on('-c', '--custom VALUE', 'Custom option') { |v| options[:custom] = v }
+    end
+
+    assert_includes @builder.parser.to_s, '-c, --custom VALUE'
+    assert_includes @builder.parser.to_s, 'Custom option'
+
+    @builder.parse(['-c', 'custom-value'])
+
+    assert_equal 'custom-value', @builder.options[:custom]
+  end
+
+  def test_parse_validates_required_keys
+    builder = EpubTools::CLI::OptionBuilder.new({}, [:required_option])
+    assert_output('', /Missing required options/) do
+      assert_raises(SystemExit) { builder.parse([]) }
+    end
+  end
+
+  def test_method_chaining
+    result = @builder.with_banner('Test')
+                     .with_verbose_option
+                     .with_title_option
+
+    assert_equal @builder, result
+  end
+end

data/test/cli/runner_test.rb

@@ -0,0 +1,91 @@
+require_relative '../test_helper'
+require_relative '../../lib/epub_tools'
+require 'stringio'
+
+class RunnerTest < Minitest::Test
+  class TestCommand
+    attr_reader :options, :run_called
+
+    def initialize(options)
+      @options = options
+      @run_called = false
+    end
+
+    def run
+      @run_called = true
+      puts 'Called!'
+      true
+    end
+  end
+
+  def setup
+    @runner = EpubTools::CLI::Runner.new('test-program')
+
+    # Register a test command
+    @runner.registry.register('test-cmd', TestCommand,
+                              [:required_option],
+                              { default_option: 'default' })
+  end
+
+  def test_initialize
+    assert_equal 'test-program', @runner.program_name
+    assert_kind_of EpubTools::CLI::CommandRegistry, @runner.registry
+  end
+
+  def test_handle_command
+    assert_output(/Usage: test-program test-cmd/) do
+      assert_raises(SystemExit) { @runner.handle_command('test-cmd', ['-h']) }
+    end
+  end
+
+  def test_handle_command_with_required_args
+    runner = EpubTools::CLI::Runner.new('test-program')
+    runner.registry.register('test-cmd', TestCommand)
+    assert_output("Called!\n") { assert runner.handle_command('test-cmd') }
+  end
+
+  def test_handle_nonexistent_command
+    result = @runner.handle_command('nonexistent')
+
+    refute result # Should return false for nonexistent command
+  end
+
+  def test_run_with_version_flag
+    assert_output(/^\d+\.\d+\.\d+$/) do
+      assert_raises(SystemExit) { @runner.run(['-v']) }
+    end
+  end
+
+  def test_run_with_no_args_shows_usage
+    assert_output(/Usage: test-program COMMAND \[options\]/) do
+      assert_raises(SystemExit) { @runner.run([]) }
+    end
+  end
+
+  def test_program_name_defaults_to_current_program
+    default_runner = EpubTools::CLI::Runner.new
+
+    assert_equal File.basename($PROGRAM_NAME), default_runner.program_name
+  end
+
+  def test_configure_command_options
+    # This is testing a private method, which is generally not recommended,
+    # but it's useful to ensure all command configurations work
+
+    # Use send to access private method
+    builder = EpubTools::CLI::OptionBuilder.new
+
+    # Test each command configuration - we'll just check one example
+    @runner.send(:configure_command_options, 'add', builder)
+
+    # Check add command options were added
+    assert_includes builder.parser.to_s, '--chapters-dir DIR'
+    assert_includes builder.parser.to_s, '--epub-oebps-dir DIR'
+  end
+
+  def test_run_with_unknown_command
+    assert_output(/Usage: test-program COMMAND \[options\]/) do
+      assert_raises(SystemExit) { @runner.run(['unknown-command']) }
+    end
+  end
+end

data/test/cli_commands_test.rb

@@ -0,0 +1,100 @@
+require_relative 'test_helper'
+require 'fileutils'
+require 'tempfile'
+require 'pathname'
+
+class CLICommandsTest < Minitest::Test
+  def setup
+    @bin_path = File.expand_path('../bin/epub-tools', __dir__)
+  end
+
+  def test_show_usage_with_no_args
+    output = `#{@bin_path}`
+
+    assert_match(/Usage: epub-tools COMMAND \[options\]/, output)
+    assert_match(/Commands:/, output)
+    assert_includes output, 'init'
+    assert_includes output, 'extract'
+    assert_includes output, 'split'
+    assert_includes output, 'add'
+    assert_includes output, 'pack'
+    assert_includes output, 'unpack'
+    assert_includes output, 'compile'
+  end
+
+  def test_show_version
+    output = `#{@bin_path} --version`
+
+    assert_match(/^\d+\.\d+\.\d+$/, output.strip)
+
+    output = `#{@bin_path} -v`
+
+    assert_match(/^\d+\.\d+\.\d+$/, output.strip)
+  end
+
+  def test_compile_command_requires_required_options
+    output = `#{@bin_path} compile 2>&1`
+
+    assert_match(/Missing required options/, output)
+  end
+
+  def test_run_compile_command
+    # Mock the execution - we won't actually run the full compile since it's complex
+    # Instead we'll use the --help flag for each command to check it's available and formatted correctly
+    output = `#{@bin_path} compile --help`
+
+    assert_match(/Usage: epub-tools compile \[options\]/, output)
+    assert_includes output, '--title TITLE'
+    assert_includes output, '--author AUTHOR'
+    assert_includes output, '--source-dir DIR'
+  end
+
+  def test_extract_command
+    output = `#{@bin_path} extract --help`
+
+    assert_match(/Usage: epub-tools extract \[options\]/, output)
+    assert_includes output, '--source-dir DIR'
+    assert_includes output, '--target-dir DIR'
+  end
+
+  def test_split_command
+    output = `#{@bin_path} split --help`
+
+    assert_match(/Usage: epub-tools split \[options\]/, output)
+    assert_includes output, '--input FILE'
+    assert_includes output, '--title TITLE'
+  end
+
+  def test_init_command
+    output = `#{@bin_path} init --help`
+
+    assert_match(/Usage: epub-tools init \[options\]/, output)
+    assert_includes output, '--title TITLE'
+    assert_includes output, '--author AUTHOR'
+    assert_includes output, '--output-dir DIR'
+  end
+
+  def test_add_command
+    output = `#{@bin_path} add --help`
+
+    assert_match(/Usage: epub-tools add \[options\]/, output)
+    assert_includes output, '--chapters-dir DIR'
+    assert_includes output, '--epub-oebps-dir DIR'
+  end
+
+  def test_pack_command
+    output = `#{@bin_path} pack --help`
+
+    assert_match(/Usage: epub-tools pack \[options\]/, output)
+    assert_includes output, '--input-dir DIR'
+    assert_includes output, '--output-file FILE'
+  end
+
+  def test_unpack_command
+    output = `#{@bin_path} unpack --help`
+
+    assert_match(/Usage: epub-tools unpack \[options\]/, output)
+    assert_includes output, '--input-file FILE'
+    assert_includes output, '--output-dir DIR'
+  end
+end

data/test/cli_test.rb

@@ -0,0 +1,4 @@
+require_relative 'test_helper'
+require_relative 'cli/command_registry_test'
+require_relative 'cli/option_builder_test'
+require_relative 'cli/runner_test'

data/test/cli_version_test.rb

@@ -9,12 +9,14 @@ class CLIVersionTest < Minitest::Test
     cli = File.join(project_root, 'bin', 'epub-tools')
     # Run with --version
     out, status = Open3.capture2(cli, '--version')
+
     assert_equal "#{EpubTools::VERSION}\n", out
-    assert status.success?, "Expected exit status 0, got #{status.exitstatus}"
+    assert_predicate status, :success?, "Expected exit status 0, got #{status.exitstatus}"
 
     # Run with -v
     out2, status2 = Open3.capture2(cli, '-v')
+
     assert_equal "#{EpubTools::VERSION}\n", out2
-    assert status2.success?, "Expected exit status 0, got #{status2.exitstatus}"
+    assert_predicate status2, :success?, "Expected exit status 0, got #{status2.exitstatus}"
   end
-end
+end

data/test/compile_book_test.rb

@@ -21,6 +21,7 @@ class CompileBookTest < Minitest::Test
       source_dir: @source,
       build_dir: @tmp
     )
+
     assert_equal 'My_Title.epub', cb.output_file
   end
 
@@ -32,6 +33,7 @@ class CompileBookTest < Minitest::Test
       output_file: 'custom.epub',
       build_dir: @tmp
     )
+
     assert_equal 'custom.epub', cb.output_file
   end
 
@@ -41,6 +43,7 @@ class CompileBookTest < Minitest::Test
       author: @author,
       source_dir: @source
     )
+
     assert cb.build_dir.end_with?('.epub_tools_build')
   end
 
@@ -54,6 +57,7 @@ class CompileBookTest < Minitest::Test
       build_dir: 'bd',
       verbose: false
     )
+
     assert_equal @title,       cb.title
     assert_equal @author,      cb.author
     assert_equal @source,      cb.source_dir
@@ -73,8 +77,10 @@ class CompileBookTest < Minitest::Test
       source_dir: @source,
       build_dir: build
     )
+
     assert Dir.exist?(build)
     cb.send(:clean_build_dir)
+
     refute Dir.exist?(build)
   end
 
@@ -87,8 +93,9 @@ class CompileBookTest < Minitest::Test
       build_dir: build
     )
     cb.send(:prepare_dirs)
-    xhtml_dir   = cb.send(:xhtml_dir)
+    xhtml_dir = cb.send(:xhtml_dir)
     chapters_dir = cb.send(:chapters_dir)
+
     assert Dir.exist?(xhtml_dir)
     assert Dir.exist?(chapters_dir)
   end
@@ -156,6 +163,7 @@ class CompileBookTest < Minitest::Test
     File.write(File.join(chapters, 'chap_1.xhtml'), '')
     File.write(File.join(chapters, 'chap_2.xhtml'), '')
     File.write(File.join(chapters, 'chap_3.xhtml'), '')
+
     assert_nil cb.send(:validate_sequence)
   end
 
@@ -184,8 +192,9 @@ class CompileBookTest < Minitest::Test
       [:log, /Done\. Output EPUB: .*o\.epub/],
       :clean
     ]
+
     assert_equal expected[0..7], seq[0..7]
-    assert seq[8].is_a?(Array)
+    assert_kind_of Array, seq[8]
     assert_equal :log, seq[8][0]
     assert_match expected[8][1], seq[8][1]
     assert_equal expected[9], seq[9]

data/test/epub_initializer_test.rb

@@ -14,26 +14,33 @@ class EpubInitializerTest < Minitest::Test
   end
 
   def test_run_creates_basic_structure
-    EpubTools::EpubInitializer.new(@title, @author, @dest).run
+    result = EpubTools::EpubInitializer.new(title: @title, author: @author, destination: @dest).run
+
+    # Check return value is the destination directory
+    assert_equal @dest, result
+
     # Check directories
     assert Dir.exist?(@dest)
     assert File.directory?(File.join(@dest, 'META-INF'))
     assert File.directory?(File.join(@dest, 'OEBPS'))
     # Check files
     mimetype = File.join(@dest, 'mimetype')
-    assert File.exist?(mimetype)
+
+    assert_path_exists mimetype
     assert_equal 'application/epub+zip', File.read(mimetype)
-    assert File.exist?(File.join(@dest, 'META-INF', 'container.xml'))
-    assert File.exist?(File.join(@dest, 'OEBPS', 'title.xhtml'))
-    assert File.exist?(File.join(@dest, 'OEBPS', 'nav.xhtml'))
-    assert File.exist?(File.join(@dest, 'OEBPS', 'package.opf'))
-    assert File.exist?(File.join(@dest, 'OEBPS', 'style.css'))
+    assert_path_exists File.join(@dest, 'META-INF', 'container.xml')
+    assert_path_exists File.join(@dest, 'OEBPS', 'title.xhtml')
+    assert_path_exists File.join(@dest, 'OEBPS', 'nav.xhtml')
+    assert_path_exists File.join(@dest, 'OEBPS', 'package.opf')
+    assert_path_exists File.join(@dest, 'OEBPS', 'style.css')
     # Check content of title.xhtml
     title_page = File.read(File.join(@dest, 'OEBPS', 'title.xhtml'))
+
     assert_includes title_page, "<h1 class=\"title\">#{@title}</h1>"
     assert_includes title_page, "<p class=\"author\">by #{@author}</p>"
     # Check package.opf metadata
     opf = File.read(File.join(@dest, 'OEBPS', 'package.opf'))
+
     assert_includes opf, "<dc:title>#{@title}</dc:title>"
     assert_includes opf, "<dc:creator>#{@author}</dc:creator>"
     refute_includes opf, 'cover.xhtml'
@@ -43,11 +50,12 @@ class EpubInitializerTest < Minitest::Test
     # create dummy image
     cover = File.join(@tmp, 'cover.png')
     File.write(cover, 'PNGDATA')
-    EpubTools::EpubInitializer.new(@title, @author, @dest, cover).run
+    EpubTools::EpubInitializer.new(title: @title, author: @author, destination: @dest, cover_image: cover).run
     # Check cover file and page
-    assert File.exist?(File.join(@dest, 'OEBPS', 'cover.png'))
-    assert File.exist?(File.join(@dest, 'OEBPS', 'cover.xhtml'))
+    assert_path_exists File.join(@dest, 'OEBPS', 'cover.png')
+    assert_path_exists File.join(@dest, 'OEBPS', 'cover.xhtml')
     opf = File.read(File.join(@dest, 'OEBPS', 'package.opf'))
+
     assert_includes opf, 'cover-image'
     assert_includes opf, '<item id="cover-page"'
     assert_includes opf, '<itemref idref="cover-page"'
@@ -56,64 +64,76 @@ class EpubInitializerTest < Minitest::Test
   def test_run_with_cover_jpg
     cover = File.join(@tmp, 'cover.jpg')
     File.write(cover, 'JPGDATA')
-    EpubTools::EpubInitializer.new(@title, @author, @dest, cover).run
-    assert File.exist?(File.join(@dest, 'OEBPS', 'cover.jpg'))
-    assert File.exist?(File.join(@dest, 'OEBPS', 'cover.xhtml'))
+    EpubTools::EpubInitializer.new(title: @title, author: @author, destination: @dest, cover_image: cover).run
+
+    assert_path_exists File.join(@dest, 'OEBPS', 'cover.jpg')
+    assert_path_exists File.join(@dest, 'OEBPS', 'cover.xhtml')
     opf = File.read(File.join(@dest, 'OEBPS', 'package.opf'))
-    assert_includes opf, "<item id=\"cover-image\" href=\"cover.jpg\" media-type=\"image/jpeg\""
+
+    assert_includes opf, '<item id="cover-image" href="cover.jpg" media-type="image/jpeg"'
     assert_includes opf, '<item id="cover-page"'
     assert_includes opf, '<itemref idref="cover-page"'
     cover_xhtml = File.read(File.join(@dest, 'OEBPS', 'cover.xhtml'))
+
     assert_includes cover_xhtml, 'src="cover.jpg"'
   end
 
   def test_run_with_cover_jpeg
     cover = File.join(@tmp, 'cover.jpeg')
     File.write(cover, 'JPEGDATA')
-    EpubTools::EpubInitializer.new(@title, @author, @dest, cover).run
-    assert File.exist?(File.join(@dest, 'OEBPS', 'cover.jpeg'))
-    assert File.exist?(File.join(@dest, 'OEBPS', 'cover.xhtml'))
+    EpubTools::EpubInitializer.new(title: @title, author: @author, destination: @dest, cover_image: cover).run
+
+    assert_path_exists File.join(@dest, 'OEBPS', 'cover.jpeg')
+    assert_path_exists File.join(@dest, 'OEBPS', 'cover.xhtml')
     opf = File.read(File.join(@dest, 'OEBPS', 'package.opf'))
-    assert_includes opf, "<item id=\"cover-image\" href=\"cover.jpeg\" media-type=\"image/jpeg\""
+
+    assert_includes opf, '<item id="cover-image" href="cover.jpeg" media-type="image/jpeg"'
     cover_xhtml = File.read(File.join(@dest, 'OEBPS', 'cover.xhtml'))
+
     assert_includes cover_xhtml, 'src="cover.jpeg"'
   end
 
   def test_run_with_cover_gif
     cover = File.join(@tmp, 'cover.gif')
     File.write(cover, 'GIFDATA')
-    EpubTools::EpubInitializer.new(@title, @author, @dest, cover).run
-    assert File.exist?(File.join(@dest, 'OEBPS', 'cover.gif'))
+    EpubTools::EpubInitializer.new(title: @title, author: @author, destination: @dest, cover_image: cover).run
+
+    assert_path_exists File.join(@dest, 'OEBPS', 'cover.gif')
     opf = File.read(File.join(@dest, 'OEBPS', 'package.opf'))
-    assert_includes opf, "<item id=\"cover-image\" href=\"cover.gif\" media-type=\"image/gif\""
+
+    assert_includes opf, '<item id="cover-image" href="cover.gif" media-type="image/gif"'
   end
 
   def test_run_with_cover_svg
     cover = File.join(@tmp, 'cover.svg')
     File.write(cover, '<svg/>')
-    EpubTools::EpubInitializer.new(@title, @author, @dest, cover).run
-    assert File.exist?(File.join(@dest, 'OEBPS', 'cover.svg'))
+    EpubTools::EpubInitializer.new(title: @title, author: @author, destination: @dest, cover_image: cover).run
+
+    assert_path_exists File.join(@dest, 'OEBPS', 'cover.svg')
     opf = File.read(File.join(@dest, 'OEBPS', 'package.opf'))
-    assert_includes opf, "<item id=\"cover-image\" href=\"cover.svg\" media-type=\"image/svg+xml\""
+
+    assert_includes opf, '<item id="cover-image" href="cover.svg" media-type="image/svg+xml"'
   end
 
   def test_run_with_unsupported_cover_image
     cover = File.join(@tmp, 'cover.bmp')
     File.write(cover, 'BMPDATA')
-    ei = EpubTools::EpubInitializer.new(@title, @author, @dest, cover)
-    assert_output("", /unsupported cover image type/) { ei.run }
-    refute File.exist?(File.join(@dest, 'OEBPS', 'cover.bmp'))
-    refute File.exist?(File.join(@dest, 'OEBPS', 'cover.xhtml'))
+    ei = EpubTools::EpubInitializer.new(title: @title, author: @author, destination: @dest, cover_image: cover)
+    assert_output('', /unsupported cover image type/) { ei.run }
+    refute_path_exists File.join(@dest, 'OEBPS', 'cover.bmp')
+    refute_path_exists File.join(@dest, 'OEBPS', 'cover.xhtml')
     opf = File.read(File.join(@dest, 'OEBPS', 'package.opf'))
+
     refute_includes opf, 'cover-image'
   end
 
   def test_run_without_cover_but_declaring_cover
     cover = File.join(@tmp, 'cover.bmp')
-    ei = EpubTools::EpubInitializer.new(@title, @author, @dest, cover)
-    assert_output("", /not found/) { ei.run }
-    refute File.exist?(File.join(@dest, 'OEBPS', 'cover.xhtml'))
+    ei = EpubTools::EpubInitializer.new(title: @title, author: @author, destination: @dest, cover_image: cover)
+    assert_output('', /not found/) { ei.run }
+    refute_path_exists File.join(@dest, 'OEBPS', 'cover.xhtml')
     opf = File.read(File.join(@dest, 'OEBPS', 'package.opf'))
+
     refute_includes opf, 'cover-image'
   end
 end

data/test/pack_ebook_test.rb

@@ -17,14 +17,16 @@ class PackEbookTest < Minitest::Test
     # Create minimal EPUB directory
     File.write(File.join(@epub_dir, 'mimetype'), 'application/epub+zip')
     FileUtils.mkdir_p(File.join(@epub_dir, 'META-INF'))
-    File.write(File.join(@epub_dir, 'META-INF', 'container.xml'), '<container/>' )
+    File.write(File.join(@epub_dir, 'META-INF', 'container.xml'), '<container/>')
     FileUtils.mkdir_p(File.join(@epub_dir, 'OEBPS'))
-    File.write(File.join(@epub_dir, 'OEBPS', 'title.xhtml'), '<html/>' )
+    File.write(File.join(@epub_dir, 'OEBPS', 'title.xhtml'), '<html/>')
 
     output = File.join(@tmp, 'out.epub')
-    EpubTools::PackEbook.new(@epub_dir, output).run
+    result = EpubTools::PackEbook.new(input_dir: @epub_dir, output_file: output).run
 
-    assert File.exist?(output), 'Expected output EPUB to exist'
+    # Check return value is the output file path
+    assert_equal output, result
+    assert_path_exists output, 'Expected output EPUB to exist'
     entries = []
     Zip::File.open(output) do |zip|
       zip.each do |entry|
@@ -38,13 +40,14 @@ class PackEbookTest < Minitest::Test
 
     # Check presence of other files
     names = entries.map { |e| e[:name] }
+
     assert_includes names, 'META-INF/container.xml'
     assert_includes names, 'OEBPS/title.xhtml'
   end
 
   def test_missing_input_dir_raises_error
     assert_raises(ArgumentError) do
-      EpubTools::PackEbook.new(File.join(@tmp, 'nonexistent'), 'out.epub').run
+      EpubTools::PackEbook.new(input_dir: File.join(@tmp, 'nonexistent'), output_file: 'out.epub').run
     end
   end
 
@@ -53,7 +56,7 @@ class PackEbookTest < Minitest::Test
     dir = File.join(@tmp, 'no_mime')
     Dir.mkdir(dir)
     assert_raises(ArgumentError) do
-      EpubTools::PackEbook.new(dir, 'out.epub').run
+      EpubTools::PackEbook.new(input_dir: dir, output_file: 'out.epub').run
     end
   end
 
@@ -61,8 +64,11 @@ class PackEbookTest < Minitest::Test
     # Setup minimal structure with mimetype
     File.write(File.join(@epub_dir, 'mimetype'), 'application/epub+zip')
     # Run without specifying output; default is "<basename>.epub" in parent
-    EpubTools::PackEbook.new(@epub_dir).run
+    result = EpubTools::PackEbook.new(input_dir: @epub_dir).run
     default_path = File.join(@tmp, 'my_epub.epub')
-    assert File.exist?(default_path), "Expected default EPUB at \\#{default_path}"
+
+    # Check return value is the default output path
+    assert_equal 'my_epub.epub', result
+    assert_path_exists default_path, "Expected default EPUB at \\#{default_path}"
   end
 end