gemba 0.1.1 → 0.2.1

data/test/test_replay_player.rb

@@ -0,0 +1,316 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require_relative "shared/tk_test_helper"
+
+class TestReplayPlayer < Minitest::Test
+  include TeekTestHelper
+
+  PONG_ROM = File.expand_path("fixtures/pong.gba", __dir__)
+
+  # Generate a short .gir fixture for all GUI tests.
+  # Uses HeadlessPlayer + InputRecorder to record 60 frames of pong.
+  def self.gir_fixture_dir
+    @gir_fixture_dir ||= begin
+      require "tmpdir"
+      dir = Dir.mktmpdir("gemba_replay_test")
+      at_exit { FileUtils.rm_rf(dir) }
+
+      require "gemba/headless"
+      require "gemba/headless"
+
+      gir_path = File.join(dir, "pong_test.gir")
+      Gemba::HeadlessPlayer.open(PONG_ROM) do |player|
+        player.step(10)
+        core = player.core
+        rec = Gemba::InputRecorder.new(gir_path, core: core, rom_path: PONG_ROM)
+        rec.start
+        60.times do |i|
+          mask = i < 30 ? Gemba::KEY_START : 0
+          rec.capture(mask)
+          core.set_keys(mask)
+          core.run_frame
+        end
+        rec.stop
+      end
+
+      dir
+    end
+  end
+
+  def gir_path
+    File.join(self.class.gir_fixture_dir, "pong_test.gir")
+  end
+
+  # ReplayPlayer opens a window, plays frames, then exits cleanly.
+  def test_replay_exits_cleanly
+    code = <<~RUBY
+      require "gemba"
+      require "support/player_helpers"
+
+      rp = Gemba::ReplayPlayer.new("#{gir_path}")
+      app = rp.app
+
+      poll_until_ready(rp) { rp.running = false }
+
+      rp.run
+    RUBY
+
+    success, stdout, stderr, _status = tk_subprocess(code, timeout: 10)
+
+    output = []
+    output << "STDOUT:\n#{stdout}" unless stdout.empty?
+    output << "STDERR:\n#{stderr}" unless stderr.empty?
+
+    assert success, "ReplayPlayer should exit cleanly\n#{output.join("\n")}"
+  end
+
+  # After replay ends (60 frames), player should pause on last frame.
+  def test_replay_pauses_on_end
+    code = <<~RUBY
+      require "gemba"
+      require "support/player_helpers"
+
+      rp = Gemba::ReplayPlayer.new("#{gir_path}")
+      app = rp.app
+
+      poll_until_ready(rp) do
+        check = proc do
+          if rp.replay_ended?
+            unless rp.paused?
+              $stderr.puts "FAIL: replay ended but not paused"
+              exit 1
+            end
+            rp.running = false
+          else
+            app.after(100, &check)
+          end
+        end
+        app.after(100, &check)
+      end
+
+      rp.run
+    RUBY
+
+    success, stdout, stderr, _status = tk_subprocess(code, timeout: 10)
+
+    output = []
+    output << "STDOUT:\n#{stdout}" unless stdout.empty?
+    output << "STDERR:\n#{stderr}" unless stderr.empty?
+
+    assert success, "ReplayPlayer should pause on replay end\n#{output.join("\n")}"
+  end
+
+  # Fullscreen toggle (F11 twice) should not hang.
+  def test_fullscreen_toggle
+    code = <<~RUBY
+      require "gemba"
+      require "support/player_helpers"
+
+      rp = Gemba::ReplayPlayer.new("#{gir_path}")
+      app = rp.app
+
+      poll_until_ready(rp) do
+        vp = rp.viewport
+        frame = vp.frame.path
+
+        app.tcl_eval("focus -force \#{frame}")
+        app.command(:event, 'generate', frame, '<KeyPress>', keysym: 'F11')
+        app.update
+
+        app.after(50) do
+          app.command(:event, 'generate', frame, '<KeyPress>', keysym: 'F11')
+          app.update
+          app.after(50) { rp.running = false }
+        end
+      end
+
+      rp.run
+    RUBY
+
+    success, stdout, stderr, _status = tk_subprocess(code, timeout: 10)
+
+    output = []
+    output << "STDOUT:\n#{stdout}" unless stdout.empty?
+    output << "STDERR:\n#{stderr}" unless stderr.empty?
+
+    assert success, "ReplayPlayer fullscreen toggle should not hang\n#{output.join("\n")}"
+  end
+
+  # Fast-forward toggle (Tab) should not hang.
+  def test_fast_forward_toggle
+    code = <<~RUBY
+      require "gemba"
+      require "support/player_helpers"
+
+      rp = Gemba::ReplayPlayer.new("#{gir_path}")
+      app = rp.app
+
+      poll_until_ready(rp) do
+        vp = rp.viewport
+        frame = vp.frame.path
+
+        app.tcl_eval("focus -force \#{frame}")
+        app.command(:event, 'generate', frame, '<KeyPress>', keysym: 'Tab')
+        app.update
+
+        app.after(200) do
+          app.tcl_eval("focus -force \#{frame}")
+          app.command(:event, 'generate', frame, '<KeyPress>', keysym: 'Tab')
+          app.update
+          app.after(50) { rp.running = false }
+        end
+      end
+
+      rp.run
+    RUBY
+
+    success, stdout, stderr, _status = tk_subprocess(code, timeout: 10)
+
+    output = []
+    output << "STDOUT:\n#{stdout}" unless stdout.empty?
+    output << "STDERR:\n#{stderr}" unless stderr.empty?
+
+    assert success, "ReplayPlayer fast-forward toggle should not hang\n#{output.join("\n")}"
+  end
+
+  # Pause via public method, verify predicate.
+  def test_pause_via_method
+    code = <<~RUBY
+      require "gemba"
+      require "support/player_helpers"
+
+      rp = Gemba::ReplayPlayer.new("#{gir_path}")
+      app = rp.app
+
+      poll_until_ready(rp) do
+        app.after(100) do
+          rp.pause
+          unless rp.paused?
+            $stderr.puts "FAIL: pause method should set paused?"
+            exit 1
+          end
+
+          rp.resume
+          if rp.paused?
+            $stderr.puts "FAIL: resume should clear paused?"
+            exit 1
+          end
+
+          rp.running = false
+        end
+      end
+
+      rp.run
+    RUBY
+
+    success, stdout, stderr, _status = tk_subprocess(code, timeout: 10)
+
+    output = []
+    output << "STDOUT:\n#{stdout}" unless stdout.empty?
+    output << "STDERR:\n#{stderr}" unless stderr.empty?
+
+    assert success, "ReplayPlayer pause/resume methods should work\n#{output.join("\n")}"
+  end
+
+  # Pressing P should toggle pause via hotkey.
+  def test_pause_hotkey
+    code = <<~RUBY
+      require "gemba"
+      require "support/player_helpers"
+
+      rp = Gemba::ReplayPlayer.new("#{gir_path}")
+      app = rp.app
+
+      poll_until_ready(rp) do
+        vp = rp.viewport
+        frame = vp.frame.path
+
+        app.after(200) do
+          app.tcl_eval("focus -force \#{frame}")
+          app.command(:event, 'generate', frame, '<KeyPress>', keysym: 'p')
+          app.update
+
+          app.after(200) do
+            unless rp.paused?
+              $stderr.puts "FAIL: P should pause"
+              exit 1
+            end
+            rp.running = false
+          end
+        end
+      end
+
+      rp.run
+    RUBY
+
+    success, stdout, stderr, _status = tk_subprocess(code, timeout: 10)
+
+    output = []
+    output << "STDOUT:\n#{stdout}" unless stdout.empty?
+    output << "STDERR:\n#{stderr}" unless stderr.empty?
+
+    assert success, "ReplayPlayer P hotkey should toggle pause\n#{output.join("\n")}"
+  end
+
+  # Escape should exit (when not fullscreen).
+  def test_escape_exits
+    code = <<~RUBY
+      require "gemba"
+      require "support/player_helpers"
+
+      rp = Gemba::ReplayPlayer.new("#{gir_path}")
+      app = rp.app
+
+      poll_until_ready(rp) do
+        vp = rp.viewport
+        frame = vp.frame.path
+
+        app.tcl_eval("focus -force \#{frame}")
+        app.command(:event, 'generate', frame, '<KeyPress>', keysym: 'Escape')
+      end
+
+      rp.run
+    RUBY
+
+    success, stdout, stderr, _status = tk_subprocess(code, timeout: 10)
+
+    output = []
+    output << "STDOUT:\n#{stdout}" unless stdout.empty?
+    output << "STDERR:\n#{stderr}" unless stderr.empty?
+
+    assert success, "ReplayPlayer Escape should exit\n#{output.join("\n")}"
+  end
+
+  # frame_index should advance during replay.
+  def test_frame_index_advances
+    code = <<~RUBY
+      require "gemba"
+      require "support/player_helpers"
+
+      rp = Gemba::ReplayPlayer.new("#{gir_path}")
+      app = rp.app
+
+      poll_until_ready(rp) do
+        app.after(500) do
+          idx = rp.frame_index
+          if idx <= 0
+            $stderr.puts "FAIL: frame_index should advance, got \#{idx}"
+            exit 1
+          end
+          rp.running = false
+        end
+      end
+
+      rp.run
+    RUBY
+
+    success, stdout, stderr, _status = tk_subprocess(code, timeout: 10)
+
+    output = []
+    output << "STDOUT:\n#{stdout}" unless stdout.empty?
+    output << "STDERR:\n#{stderr}" unless stderr.empty?
+
+    assert success, "ReplayPlayer frame_index should advance\n#{output.join("\n")}"
+  end
+end

data/test/test_rom_info.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "tmpdir"
+require "fileutils"
+require "gemba/headless"
+
+class TestRomInfo < Minitest::Test
+  # Stub that returns nil for every lookup — isolates RomInfo from real DAT data.
+  NULL_INDEX = Struct.new(:_) {
+    def lookup(_)        = nil
+    def lookup_by_md5(*) = nil
+  }.new(nil)
+
+  ROM = {
+    'rom_id'    => 'AGB_AXVE-DEADBEEF',
+    'title'     => 'Pokemon Ruby',
+    'platform'  => 'gba',
+    'game_code' => 'AGB-AXVE',
+    'path'      => '/games/ruby.gba',
+  }.freeze
+
+  def test_from_rom_sets_basic_fields
+    info = Gemba::RomInfo.from_rom(ROM, game_index: NULL_INDEX)
+    assert_equal 'AGB_AXVE-DEADBEEF', info.rom_id
+    assert_equal 'Pokemon Ruby',       info.title
+    assert_equal 'GBA',                info.platform
+    assert_equal 'AGB-AXVE',           info.game_code
+    assert_equal '/games/ruby.gba',    info.path
+  end
+
+  def test_platform_is_uppercased
+    info = Gemba::RomInfo.from_rom(ROM.merge('platform' => 'gbc'), game_index: NULL_INDEX)
+    assert_equal 'GBC', info.platform
+  end
+
+  def test_title_falls_back_to_rom_id
+    rom  = ROM.merge('title' => nil)
+    info = Gemba::RomInfo.from_rom(rom, game_index: NULL_INDEX)
+    assert_equal 'AGB_AXVE-DEADBEEF', info.title
+  end
+
+  def test_title_from_game_index_wins_over_stored_title
+    index = Struct.new(:_) {
+      def lookup(_)        = 'Index Title'
+      def lookup_by_md5(*) = nil
+    }.new(nil)
+    info = Gemba::RomInfo.from_rom(ROM, game_index: index)
+    assert_equal 'Index Title', info.title
+  end
+
+  def test_no_fetcher_or_overrides_yields_nil_boxart_fields
+    info = Gemba::RomInfo.from_rom(ROM, game_index: NULL_INDEX)
+    assert_nil info.cached_boxart_path
+    assert_nil info.custom_boxart_path
+    assert_nil info.boxart_path
+  end
+
+  def test_has_official_entry_true_when_index_returns_title
+    index = Struct.new(:_) {
+      def lookup(_)        = 'Some Game'
+      def lookup_by_md5(*) = nil
+    }.new(nil)
+    info = Gemba::RomInfo.from_rom(ROM, game_index: index)
+    assert info.has_official_entry
+  end
+
+  def test_has_official_entry_false_when_index_returns_nil
+    info = Gemba::RomInfo.from_rom(ROM, game_index: NULL_INDEX)
+    refute info.has_official_entry
+  end
+
+  def test_has_official_entry_false_when_no_game_code
+    rom  = ROM.merge('game_code' => nil)
+    info = Gemba::RomInfo.from_rom(rom, game_index: NULL_INDEX)
+    refute info.has_official_entry
+  end
+
+  def test_boxart_path_returns_custom_when_file_exists
+    Dir.mktmpdir do |dir|
+      ENV['GEMBA_CONFIG_DIR'] = dir
+      custom    = File.join(dir, "custom.png")
+      File.write(custom, "fake")
+      overrides = Gemba::RomOverrides.new(File.join(dir, "overrides.json"))
+      overrides.set_custom_boxart('AGB_AXVE-DEADBEEF', custom)
+
+      info = Gemba::RomInfo.from_rom(ROM, overrides: overrides, game_index: NULL_INDEX)
+      assert_equal File.join(dir, 'boxart', 'AGB_AXVE-DEADBEEF', 'custom.png'), info.boxart_path
+    ensure
+      ENV.delete('GEMBA_CONFIG_DIR')
+    end
+  end
+
+  def test_boxart_path_falls_back_to_cache_when_no_custom
+    Dir.mktmpdir do |dir|
+      ENV['GEMBA_CONFIG_DIR'] = dir
+      cache_dir = File.join(dir, "boxart")
+      fetcher   = Gemba::BoxartFetcher.new(app: nil, cache_dir: cache_dir,
+                                            backend: Gemba::BoxartFetcher::NullBackend.new)
+      overrides = Gemba::RomOverrides.new(File.join(dir, "overrides.json"))
+
+      cached = fetcher.cached_path('AGB-AXVE')
+      FileUtils.mkdir_p(File.dirname(cached))
+      File.write(cached, "fake")
+
+      info = Gemba::RomInfo.from_rom(ROM, fetcher: fetcher, overrides: overrides, game_index: NULL_INDEX)
+      assert_equal cached, info.boxart_path
+    ensure
+      ENV.delete('GEMBA_CONFIG_DIR')
+    end
+  end
+
+  def test_boxart_path_nil_when_neither_present
+    Dir.mktmpdir do |dir|
+      ENV['GEMBA_CONFIG_DIR'] = dir
+      fetcher   = Gemba::BoxartFetcher.new(app: nil, cache_dir: File.join(dir, "boxart"),
+                                            backend: Gemba::BoxartFetcher::NullBackend.new)
+      overrides = Gemba::RomOverrides.new(File.join(dir, "overrides.json"))
+
+      info = Gemba::RomInfo.from_rom(ROM, fetcher: fetcher, overrides: overrides, game_index: NULL_INDEX)
+      assert_nil info.boxart_path
+    ensure
+      ENV.delete('GEMBA_CONFIG_DIR')
+    end
+  end
+
+  def test_custom_beats_cache_in_boxart_path
+    Dir.mktmpdir do |dir|
+      ENV['GEMBA_CONFIG_DIR'] = dir
+      cache_dir = File.join(dir, "boxart")
+      fetcher   = Gemba::BoxartFetcher.new(app: nil, cache_dir: cache_dir,
+                                            backend: Gemba::BoxartFetcher::NullBackend.new)
+      overrides = Gemba::RomOverrides.new(File.join(dir, "overrides.json"))
+
+      cached = fetcher.cached_path('AGB-AXVE')
+      FileUtils.mkdir_p(File.dirname(cached))
+      File.write(cached, "cached")
+
+      src = File.join(dir, "my_cover.png")
+      File.write(src, "custom")
+      overrides.set_custom_boxart('AGB_AXVE-DEADBEEF', src)
+
+      info = Gemba::RomInfo.from_rom(ROM, fetcher: fetcher, overrides: overrides, game_index: NULL_INDEX)
+      assert_match %r{custom\.png$}, info.boxart_path, "Custom should beat cached"
+    ensure
+      ENV.delete('GEMBA_CONFIG_DIR')
+    end
+  end
+end

data/test/test_rom_overrides.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "tmpdir"
+require "fileutils"
+require "gemba/headless"
+require "gemba/headless"
+
+class TestRomOverrides < Minitest::Test
+  def setup
+    @tmpdir  = Dir.mktmpdir("rom_overrides_test")
+    @json    = File.join(@tmpdir, "rom_overrides.json")
+    @boxart  = File.join(@tmpdir, "boxart")
+    # Point Config.boxart_dir at our tmpdir so copies land there
+    @orig_env = ENV['GEMBA_CONFIG_DIR']
+    ENV['GEMBA_CONFIG_DIR'] = @tmpdir
+  end
+
+  def teardown
+    ENV['GEMBA_CONFIG_DIR'] = @orig_env
+    FileUtils.rm_rf(@tmpdir)
+  end
+
+  def test_custom_boxart_returns_nil_when_nothing_set
+    overrides = Gemba::RomOverrides.new(@json)
+    assert_nil overrides.custom_boxart("AGB_AXVE-DEADBEEF")
+  end
+
+  def test_set_custom_boxart_copies_file_and_returns_dest
+    src = File.join(@tmpdir, "cover.png")
+    File.write(src, "fake png")
+
+    overrides = Gemba::RomOverrides.new(@json)
+    dest = overrides.set_custom_boxart("AGB_AXVE-DEADBEEF", src)
+
+    assert File.exist?(dest), "Copied file should exist at dest"
+    assert_equal "fake png", File.read(dest)
+    assert_match %r{/AGB_AXVE-DEADBEEF/custom\.png$}, dest
+  end
+
+  def test_set_custom_boxart_persists_across_reload
+    src = File.join(@tmpdir, "cover.png")
+    File.write(src, "fake png")
+
+    Gemba::RomOverrides.new(@json).set_custom_boxart("AGB_AXVE-DEADBEEF", src)
+
+    reloaded = Gemba::RomOverrides.new(@json)
+    stored   = reloaded.custom_boxart("AGB_AXVE-DEADBEEF")
+    refute_nil stored
+    assert File.exist?(stored)
+  end
+
+  def test_set_custom_boxart_preserves_extension
+    src = File.join(@tmpdir, "cover.jpg")
+    File.write(src, "fake jpg")
+
+    overrides = Gemba::RomOverrides.new(@json)
+    dest = overrides.set_custom_boxart("AGB_AXVE-DEADBEEF", src)
+
+    assert dest.end_with?(".jpg"), "Extension should be preserved"
+  end
+
+  def test_multiple_rom_ids_stored_independently
+    src1 = File.join(@tmpdir, "a.png"); File.write(src1, "a")
+    src2 = File.join(@tmpdir, "b.png"); File.write(src2, "b")
+
+    overrides = Gemba::RomOverrides.new(@json)
+    overrides.set_custom_boxart("AGB_AXVE-AAAAAAAA", src1)
+    overrides.set_custom_boxart("AGB_BPEE-BBBBBBBB", src2)
+
+    assert_match %r{AAAAAAAA}, overrides.custom_boxart("AGB_AXVE-AAAAAAAA")
+    assert_match %r{BBBBBBBB}, overrides.custom_boxart("AGB_BPEE-BBBBBBBB")
+    assert_nil overrides.custom_boxart("AGB_ZZZZ-ZZZZZZZZ")
+  end
+
+  def test_json_file_is_valid_json
+    src = File.join(@tmpdir, "cover.png")
+    File.write(src, "fake")
+
+    Gemba::RomOverrides.new(@json).set_custom_boxart("AGB_AXVE-DEADBEEF", src)
+
+    parsed = JSON.parse(File.read(@json))
+    assert_instance_of Hash, parsed
+    assert parsed.key?("AGB_AXVE-DEADBEEF")
+  end
+end