gemba 0.1.1 → 0.2.0

data/test/test_bios.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "tmpdir"
+require "fileutils"
+require "gemba/headless"
+
+class TestBios < Minitest::Test
+  FAKE_BIOS = File.expand_path("fixtures/fake_bios.bin", __dir__)
+
+  def setup
+    @dir = Dir.mktmpdir("gemba-bios-test")
+  end
+
+  def teardown
+    FileUtils.rm_rf(@dir)
+  end
+
+  # -- exists? / valid? -------------------------------------------------------
+
+  def test_exists_true_for_real_file
+    bios = Gemba::Bios.new(path: FAKE_BIOS)
+    assert bios.exists?
+  end
+
+  def test_exists_false_for_missing_file
+    bios = Gemba::Bios.new(path: File.join(@dir, "no_such.bin"))
+    refute bios.exists?
+  end
+
+  def test_valid_for_correct_size
+    bios = Gemba::Bios.new(path: FAKE_BIOS)
+    assert_equal Gemba::Bios::EXPECTED_SIZE, bios.size
+    assert bios.valid?
+  end
+
+  def test_invalid_for_wrong_size
+    path = File.join(@dir, "small.bin")
+    File.binwrite(path, "\x00" * 100)
+    bios = Gemba::Bios.new(path: path)
+    refute bios.valid?
+  end
+
+  def test_invalid_for_missing_file
+    bios = Gemba::Bios.new(path: File.join(@dir, "missing.bin"))
+    refute bios.valid?
+  end
+
+  # -- filename ---------------------------------------------------------------
+
+  def test_filename_returns_basename
+    bios = Gemba::Bios.new(path: FAKE_BIOS)
+    assert_equal "fake_bios.bin", bios.filename
+  end
+
+  # -- checksum ---------------------------------------------------------------
+
+  def test_checksum_nil_for_invalid_file
+    bios = Gemba::Bios.new(path: File.join(@dir, "missing.bin"))
+    assert_nil bios.checksum
+  end
+
+  def test_checksum_returns_integer_for_valid_file
+    bios = Gemba::Bios.new(path: FAKE_BIOS)
+    assert_kind_of Integer, bios.checksum
+  end
+
+  def test_checksum_is_memoized
+    bios = Gemba::Bios.new(path: FAKE_BIOS)
+    c1 = bios.checksum
+    c2 = bios.checksum
+    assert_equal c1, c2
+    assert_same c1, c2  # same object, not just equal
+  end
+
+  # -- known? / official? / label ---------------------------------------------
+
+  def test_fake_bios_is_not_official
+    bios = Gemba::Bios.new(path: FAKE_BIOS)
+    refute bios.official?
+    refute bios.ds_mode?
+    refute bios.known?
+  end
+
+  def test_label_unknown_for_fake_bios
+    bios = Gemba::Bios.new(path: FAKE_BIOS)
+    assert_equal "Unknown BIOS", bios.label
+  end
+
+  # -- status_text ------------------------------------------------------------
+
+  def test_status_text_includes_size_for_valid_file
+    bios = Gemba::Bios.new(path: FAKE_BIOS)
+    assert_includes bios.status_text, "16384"
+  end
+
+  def test_status_text_not_found_for_missing_file
+    bios = Gemba::Bios.new(path: File.join(@dir, "gone.bin"))
+    assert_includes bios.status_text, "not found"
+  end
+
+  def test_status_text_invalid_size_for_wrong_size
+    path = File.join(@dir, "wrong.bin")
+    File.binwrite(path, "\x00" * 512)
+    bios = Gemba::Bios.new(path: path)
+    assert_includes bios.status_text, "Invalid size"
+  end
+
+  # -- from_config_name -------------------------------------------------------
+
+  def test_from_config_name_nil_returns_nil
+    assert_nil Gemba::Bios.from_config_name(nil)
+  end
+
+  def test_from_config_name_empty_returns_nil
+    assert_nil Gemba::Bios.from_config_name("")
+  end
+
+  def test_from_config_name_builds_path_under_bios_dir
+    bios = Gemba::Bios.from_config_name("gba_bios.bin")
+    assert_equal File.join(Gemba::Config.bios_dir, "gba_bios.bin"), bios.path
+  end
+end

data/test/test_boxart_fetcher.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require_relative "shared/tk_test_helper"
+require "tmpdir"
+require "fileutils"
+require "gemba/headless"
+require "gemba/headless"
+
+class TestBoxartFetcher < Minitest::Test
+  include TeekTestHelper
+
+  FAKE_PNG = "\x89PNG\r\n\x1a\n fake image data".b
+
+  # Minimal backend that returns a fixed URL for known codes
+  class StubBackend
+    def url_for(game_code)
+      case game_code
+      when "AGB-AXVE"
+        "https://example.com/boxart/pokemon_ruby.png"
+      when "AGB-BPEE"
+        "https://example.com/boxart/pokemon_emerald.png"
+      else
+        nil
+      end
+    end
+  end
+
+  def setup
+    @tmpdir = Dir.mktmpdir("boxart_test")
+    @backend = StubBackend.new
+  end
+
+  def teardown
+    FileUtils.rm_rf(@tmpdir)
+  end
+
+  def test_cached_path
+    fetcher = Gemba::BoxartFetcher.new(app: nil, cache_dir: @tmpdir, backend: @backend)
+    expected = File.join(@tmpdir, "AGB-AXVE", "boxart.png")
+    assert_equal expected, fetcher.cached_path("AGB-AXVE")
+  end
+
+  def test_cached_returns_false_when_not_cached
+    fetcher = Gemba::BoxartFetcher.new(app: nil, cache_dir: @tmpdir, backend: @backend)
+    refute fetcher.cached?("AGB-AXVE")
+  end
+
+  def test_cached_returns_true_when_file_exists
+    dir = File.join(@tmpdir, "AGB-AXVE")
+    FileUtils.mkdir_p(dir)
+    File.binwrite(File.join(dir, "boxart.png"), FAKE_PNG)
+
+    fetcher = Gemba::BoxartFetcher.new(app: nil, cache_dir: @tmpdir, backend: @backend)
+    assert fetcher.cached?("AGB-AXVE")
+  end
+
+  def test_fetch_returns_cached_path_immediately_when_cached
+    dir = File.join(@tmpdir, "AGB-AXVE")
+    FileUtils.mkdir_p(dir)
+    cached = File.join(dir, "boxart.png")
+    File.binwrite(cached, FAKE_PNG)
+
+    fetcher = Gemba::BoxartFetcher.new(app: nil, cache_dir: @tmpdir, backend: @backend)
+    result = nil
+    fetcher.fetch("AGB-AXVE") { |path| result = path }
+
+    assert_equal cached, result
+  end
+
+  def test_fetch_does_nothing_for_unknown_game_code
+    fetcher = Gemba::BoxartFetcher.new(app: nil, cache_dir: @tmpdir, backend: @backend)
+    called = false
+    fetcher.fetch("AGB-ZZZZ") { |_| called = true }
+    refute called
+  end
+
+  def test_fetch_does_nothing_with_null_backend
+    null_fetcher = Gemba::BoxartFetcher.new(
+      app: nil, cache_dir: @tmpdir,
+      backend: Gemba::BoxartFetcher::NullBackend.new
+    )
+    called = false
+    null_fetcher.fetch("AGB-AXVE") { |_| called = true }
+    refute called
+  end
+
+  def test_fetch_does_nothing_without_block
+    fetcher = Gemba::BoxartFetcher.new(app: nil, cache_dir: @tmpdir, backend: @backend)
+    fetcher.fetch("AGB-AXVE")
+  end
+
+  def test_fetch_downloads_and_caches
+    assert_tk_app("boxart fetch downloads and caches") do
+      require "tmpdir"
+      require "webmock"
+      require "gemba/headless"
+      WebMock.enable!
+      WebMock.stub_request(:get, "https://example.com/boxart/pokemon_ruby.png")
+        .to_return(status: 200, body: "\x89PNG fake".b, headers: { "Content-Type" => "image/png" })
+
+      tmpdir = Dir.mktmpdir("boxart_test")
+      backend = Struct.new(:url) { def url_for(_) = url }.new("https://example.com/boxart/pokemon_ruby.png")
+      fetcher = Gemba::BoxartFetcher.new(app: app, cache_dir: tmpdir, backend: backend)
+      result = nil
+      done = false
+
+      fetcher.fetch("AGB-AXVE") do |path|
+        result = path
+        done = true
+      end
+
+      wait_until(timeout: 5.0) { done }
+
+      assert done, "Fetch did not complete"
+      assert_equal fetcher.cached_path("AGB-AXVE"), result
+      assert File.exist?(result), "Cached file should exist"
+      assert fetcher.cached?("AGB-AXVE")
+
+      FileUtils.rm_rf(tmpdir)
+      WebMock.disable!
+    end
+  end
+
+  def test_fetch_handles_404
+    assert_tk_app("boxart fetch handles 404 gracefully") do
+      require "tmpdir"
+      require "webmock"
+      require "gemba/headless"
+      WebMock.enable!
+      WebMock.stub_request(:get, "https://example.com/boxart/pokemon_ruby.png")
+        .to_return(status: 404, body: "Not Found")
+
+      tmpdir = Dir.mktmpdir("boxart_test")
+      backend = Struct.new(:url) { def url_for(_) = url }.new("https://example.com/boxart/pokemon_ruby.png")
+      fetcher = Gemba::BoxartFetcher.new(app: app, cache_dir: tmpdir, backend: backend)
+      called = false
+
+      fetcher.fetch("AGB-AXVE") { |_| called = true }
+
+      wait_until(timeout: 2.0) { false }  # let background thread finish
+
+      refute called, "Callback should not fire on 404"
+      refute fetcher.cached?("AGB-AXVE")
+
+      FileUtils.rm_rf(tmpdir)
+      WebMock.disable!
+    end
+  end
+end

data/test/test_cli.rb

@@ -1,281 +1,33 @@
 # frozen_string_literal: true
 
 require "minitest/autorun"
-require "gemba"
-require_relative "../lib/gemba/version"
-require_relative "../lib/gemba/cli"
+require "gemba/headless"
 
 class TestCLI < Minitest::Test
-  def parse(args)
-    Gemba::CLI.parse(args)
-  end
-
-  # -- ROM argument --
-
-  def test_rom_path
-    opts = parse(["game.gba"])
-    assert_equal File.expand_path("game.gba"), opts[:rom]
-  end
-
-  def test_rom_path_expands_tilde
-    opts = parse(["~/game.gba"])
-    assert_equal File.join(Dir.home, "game.gba"), opts[:rom]
-  end
-
-  def test_no_rom
-    opts = parse([])
-    assert_nil opts[:rom]
-  end
-
-  # -- player flags --
-
-  def test_scale
-    opts = parse(["--scale", "2"])
-    assert_equal 2, opts[:scale]
-  end
-
-  def test_scale_short
-    opts = parse(["-s", "3"])
-    assert_equal 3, opts[:scale]
-  end
-
-  def test_scale_clamps_high
-    opts = parse(["--scale", "10"])
-    assert_equal 4, opts[:scale]
-  end
-
-  def test_scale_clamps_low
-    opts = parse(["--scale", "0"])
-    assert_equal 1, opts[:scale]
-  end
-
-  def test_volume
-    opts = parse(["--volume", "50"])
-    assert_equal 50, opts[:volume]
-  end
-
-  def test_volume_short
-    opts = parse(["-v", "75"])
-    assert_equal 75, opts[:volume]
-  end
-
-  def test_volume_clamps
-    opts = parse(["--volume", "200"])
-    assert_equal 100, opts[:volume]
-  end
-
-  def test_mute
-    opts = parse(["--mute"])
-    assert opts[:mute]
-  end
-
-  def test_mute_short
-    opts = parse(["-m"])
-    assert opts[:mute]
-  end
-
-  def test_no_sound
-    opts = parse(["--no-sound"])
-    assert_equal false, opts[:sound]
-  end
-
-  def test_fullscreen
-    opts = parse(["--fullscreen"])
-    assert opts[:fullscreen]
-  end
-
-  def test_fullscreen_short
-    opts = parse(["-f"])
-    assert opts[:fullscreen]
-  end
-
-  def test_show_fps
-    opts = parse(["--show-fps"])
-    assert opts[:show_fps]
-  end
-
-  def test_turbo_speed
-    opts = parse(["--turbo-speed", "3"])
-    assert_equal 3, opts[:turbo_speed]
-  end
-
-  def test_turbo_speed_clamps
-    opts = parse(["--turbo-speed", "99"])
-    assert_equal 4, opts[:turbo_speed]
-  end
-
-  def test_locale
-    opts = parse(["--locale", "ja"])
-    assert_equal "ja", opts[:locale]
-  end
-
-  def test_version_flag
-    opts = parse(["--version"])
-    assert opts[:version]
-  end
-
-  def test_help_flag
-    opts = parse(["--help"])
-    assert opts[:help]
-  end
-
-  # -- combinations --
-
-  def test_flags_with_rom
-    opts = parse(["-s", "2", "--mute", "pokemon.gba"])
-    assert_equal 2, opts[:scale]
-    assert opts[:mute]
-    assert_equal File.expand_path("pokemon.gba"), opts[:rom]
-  end
-
-  def test_rom_before_flags
-    opts = parse(["game.gba", "--scale", "4"])
-    assert_equal File.expand_path("game.gba"), opts[:rom]
-    assert_equal 4, opts[:scale]
-  end
-
-  # -- parser included for help output --
-
-  def test_parser_present
-    opts = parse([])
-    assert_kind_of OptionParser, opts[:parser]
-  end
-
-  def test_help_output_includes_banner
-    opts = parse([])
-    help = opts[:parser].to_s
-    assert_includes help, "Usage: gemba"
-    assert_includes help, "GBA emulator"
-  end
-
-  def test_help_lists_subcommands
-    opts = parse([])
-    help = opts[:parser].to_s
-    assert_includes help, "record"
-    assert_includes help, "decode"
-    assert_includes help, "info"
-  end
-
-  # -- apply --
-
-  class MockConfig
-    attr_accessor :scale, :volume, :muted, :show_fps, :turbo_speed, :locale
-
-    def initialize
-      @scale = 3
-      @volume = 100
-      @muted = false
-      @show_fps = false
-      @turbo_speed = 0
-      @locale = 'auto'
-    end
-  end
-
-  def test_apply_overrides_config
-    config = MockConfig.new
-    Gemba::CLI.apply(config, { scale: 2, volume: 50, mute: true, show_fps: true })
-    assert_equal 2, config.scale
-    assert_equal 50, config.volume
-    assert config.muted
-    assert config.show_fps
-  end
-
-  def test_apply_skips_unset_options
-    config = MockConfig.new
-    Gemba::CLI.apply(config, {})
-    assert_equal 3, config.scale
-    assert_equal 100, config.volume
-    refute config.muted
-  end
-
-  def test_apply_locale
-    config = MockConfig.new
-    Gemba::CLI.apply(config, { locale: 'ja' })
-    assert_equal 'ja', config.locale
-  end
-
-  def test_apply_turbo_speed
-    config = MockConfig.new
-    Gemba::CLI.apply(config, { turbo_speed: 3 })
-    assert_equal 3, config.turbo_speed
-  end
-
   # -- subcommand dispatch --
 
   def test_subcommands_constant
+    assert_includes Gemba::CLI::SUBCOMMANDS, 'play'
     assert_includes Gemba::CLI::SUBCOMMANDS, 'record'
     assert_includes Gemba::CLI::SUBCOMMANDS, 'decode'
-    assert_includes Gemba::CLI::SUBCOMMANDS, 'info'
-  end
-
-  # -- record subcommand parsing --
-
-  def test_parse_record_frames_and_rom
-    opts = Gemba::CLI.parse_record(["--frames", "100", "game.gba"])
-    assert_equal 100, opts[:frames]
-    assert_equal File.expand_path("game.gba"), opts[:rom]
+    assert_includes Gemba::CLI::SUBCOMMANDS, 'replay'
+    assert_includes Gemba::CLI::SUBCOMMANDS, 'config'
+    assert_includes Gemba::CLI::SUBCOMMANDS, 'version'
+    refute_includes Gemba::CLI::SUBCOMMANDS, 'info'
   end
 
-  def test_parse_record_output
-    opts = Gemba::CLI.parse_record(["-o", "out.grec", "--frames", "10", "game.gba"])
-    assert_equal "out.grec", opts[:output]
-  end
-
-  def test_parse_record_help
-    opts = Gemba::CLI.parse_record(["--help"])
-    assert opts[:help]
-  end
-
-  # -- decode subcommand parsing --
-
-  def test_parse_decode_trec
-    opts = Gemba::CLI.parse_decode(["recording.grec"])
-    assert_equal "recording.grec", opts[:trec]
-  end
-
-  def test_parse_decode_output
-    opts = Gemba::CLI.parse_decode(["-o", "out.mkv", "recording.grec"])
-    assert_equal "out.mkv", opts[:output]
-  end
-
-  def test_parse_decode_codecs
-    opts = Gemba::CLI.parse_decode(["--video-codec", "libx265", "--audio-codec", "opus", "r.grec"])
-    assert_equal "libx265", opts[:video_codec]
-    assert_equal "opus", opts[:audio_codec]
-  end
-
-  # -- misc --
-
-  def test_reset_config_flag
-    opts = parse(["--reset-config"])
-    assert opts[:reset_config]
-  end
-
-  def test_yes_flag
-    opts = parse(["-y"])
-    assert opts[:yes]
-  end
-
-  def test_frames
-    opts = parse(["--frames", "100", "game.gba"])
-    assert_equal 100, opts[:frames]
-  end
-
-  def test_frames_without_value_raises
-    assert_raises(OptionParser::MissingArgument) { parse(["--frames"]) }
-  end
-
-  def test_frames_without_rom_exits
-    assert_raises(SystemExit) do
-      Gemba::CLI.run(["--frames", "100"])
-    end
-  end
-
-  def test_unknown_flag_raises
-    assert_raises(OptionParser::InvalidOption) { parse(["--bogus"]) }
+  def test_main_help_lists_subcommands
+    help = Gemba::CLI.main_help
+    assert_includes help, "play"
+    assert_includes help, "record"
+    assert_includes help, "decode"
+    assert_includes help, "replay"
+    assert_includes help, "config"
+    assert_includes help, "version"
   end
 
-  def test_missing_scale_value_raises
-    assert_raises(OptionParser::MissingArgument) { parse(["--scale"]) }
+  def test_dry_run_main_help
+    result = Gemba::CLI.run(["--help"], dry_run: true)
+    assert_equal :help, result[:command]
   end
 end

data/test/test_cli_config.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "gemba/headless"
+require "gemba/cli/commands/config_cmd"
+
+class TestCLIConfig < Minitest::Test
+  ConfigCmd = Gemba::CLI::Commands::ConfigCmd
+
+  # -- parse --
+
+  def test_reset_flag
+    assert cfg(["--reset"]).parse[:reset]
+  end
+
+  def test_reset_with_yes
+    opts = cfg(["--reset", "-y"]).parse
+    assert opts[:reset]
+    assert opts[:yes]
+  end
+
+  def test_help
+    assert cfg(["--help"]).parse[:help]
+  end
+
+  def test_no_flags
+    opts = cfg([]).parse
+    refute opts[:reset]
+    refute opts[:help]
+  end
+
+  # -- dry_run via CLI.run dispatch --
+
+  def test_dry_run_show
+    result = Gemba::CLI.run(["config"], dry_run: true)
+    assert_equal :config_show, result[:command]
+    refute result[:reset]
+  end
+
+  def test_dry_run_reset
+    result = Gemba::CLI.run(["config", "--reset"], dry_run: true)
+    assert_equal :config_reset, result[:command]
+    assert result[:reset]
+  end
+
+  def test_dry_run_reset_yes
+    result = Gemba::CLI.run(["config", "--reset", "-y"], dry_run: true)
+    assert_equal :config_reset, result[:command]
+    assert result[:reset]
+    assert result[:yes]
+  end
+
+  def test_dry_run_help
+    result = Gemba::CLI.run(["config", "--help"], dry_run: true)
+    assert_equal :config, result[:command]
+    assert result[:help]
+  end
+
+  private
+
+  def cfg(argv)
+    ConfigCmd.new(argv)
+  end
+end