gemba 0.1.1 → 0.2.0

data/test/test_fake_backend_achievements.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "gemba/headless"
+require "gemba/achievements"
+require_relative "support/fake_core"
+
+class TestFakeBackendAchievements < Minitest::Test
+  ADDR = 0x02000000
+
+  def setup
+    @backend = Gemba::Achievements::FakeBackend.new
+    @backend.add_achievement(id: 'test', title: 'Test', description: 'desc', points: 5) do |mem|
+      mem.call(ADDR) == 0x42
+    end
+    @core    = FakeCore.new
+    @unlocked = []
+    @backend.on_unlock { |ach| @unlocked << ach }
+  end
+
+  def test_no_unlock_when_condition_false
+    @core.poke(ADDR, 0x00)
+    @backend.do_frame(@core)
+    assert_empty @unlocked
+  end
+
+  def test_unlock_fires_when_condition_becomes_true
+    @core.poke(ADDR, 0x42)
+    @backend.do_frame(@core)
+    assert_equal 1, @unlocked.size
+    assert_equal 'test', @unlocked.first.id
+    assert_equal 'Test',  @unlocked.first.title
+    assert_equal 5,       @unlocked.first.points
+    assert @unlocked.first.earned?
+  end
+
+  def test_unlock_fires_only_once_rising_edge
+    @core.poke(ADDR, 0x42)
+    @backend.do_frame(@core)
+    @backend.do_frame(@core)
+    assert_equal 1, @unlocked.size
+  end
+
+  def test_no_second_unlock_after_condition_cycles
+    @core.poke(ADDR, 0x42)
+    @backend.do_frame(@core)
+    @core.poke(ADDR, 0x00)
+    @backend.do_frame(@core)
+    @core.poke(ADDR, 0x42)
+    @backend.do_frame(@core)
+    assert_equal 1, @unlocked.size
+  end
+
+  def test_fires_on_first_true_frame
+    @core.poke(ADDR, 0x42)
+    @backend.do_frame(@core)
+    assert_equal 1, @unlocked.size
+  end
+
+  def test_no_unlock_on_wrong_value
+    @core.poke(ADDR, 0x01)
+    @backend.do_frame(@core)
+    assert_empty @unlocked
+  end
+
+  def test_achievement_list_reflects_earned_state
+    assert_equal 1, @backend.total_count
+    assert_equal 0, @backend.earned_count
+
+    @core.poke(ADDR, 0x42)
+    @backend.do_frame(@core)
+
+    assert_equal 1, @backend.earned_count
+    assert @backend.achievement_list.first.earned?
+  end
+
+  def test_multiple_achievements_independent
+    @backend.add_achievement(id: 'two', title: 'Two', description: '', points: 10) do |mem|
+      mem.call(ADDR + 1) == 0xFF
+    end
+
+    @core.poke(ADDR, 0x42)
+    @backend.do_frame(@core)
+    assert_equal 1, @unlocked.size
+    assert_equal 'test', @unlocked.first.id
+
+    @core.poke(ADDR + 1, 0xFF)
+    @backend.do_frame(@core)
+    assert_equal 2, @unlocked.size
+    assert_equal 'two', @unlocked.last.id
+  end
+
+  def test_reset_earned_allows_re_unlock
+    @core.poke(ADDR, 0x42)
+    @backend.do_frame(@core)
+    assert_equal 1, @backend.earned_count
+
+    @backend.reset_earned
+    assert_equal 0, @backend.earned_count
+
+    @unlocked.clear
+    @core.poke(ADDR, 0x00)
+    @backend.do_frame(@core)
+    @core.poke(ADDR, 0x42)
+    @backend.do_frame(@core)
+    assert_equal 1, @unlocked.size
+  end
+
+  def test_load_game_resets_earned
+    @core.poke(ADDR, 0x42)
+    @backend.do_frame(@core)
+    assert_equal 1, @backend.earned_count
+
+    @backend.load_game(@core)
+    assert_equal 0, @backend.earned_count
+  end
+
+  def test_multiple_unlock_callbacks_all_fire
+    other = []
+    @backend.on_unlock { |ach| other << ach.id }
+    @core.poke(ADDR, 0x42)
+    @backend.do_frame(@core)
+    assert_equal ['test'], @unlocked.map(&:id)
+    assert_equal ['test'], other
+  end
+
+  def test_enabled
+    assert @backend.enabled?
+  end
+end

data/test/test_fake_backend_auth.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "gemba/headless"
+require "gemba/achievements"
+
+class TestFakeBackendAuth < Minitest::Test
+  def test_any_nonempty_creds_succeed_by_default
+    b = Gemba::Achievements::FakeBackend.new
+    statuses = []
+    b.on_auth_change { |status, _| statuses << status }
+    b.login_with_token(username: 'alice', token: 'anything')
+    assert b.authenticated?
+    assert_equal [:ok], statuses
+  end
+
+  def test_empty_username_fails
+    b = Gemba::Achievements::FakeBackend.new
+    b.login_with_token(username: '', token: 'tok')
+    refute b.authenticated?
+  end
+
+  def test_empty_token_fails
+    b = Gemba::Achievements::FakeBackend.new
+    b.login_with_token(username: 'alice', token: '')
+    refute b.authenticated?
+  end
+
+  def test_restricted_correct_pair_succeeds
+    b = Gemba::Achievements::FakeBackend.new(valid_username: 'alice', valid_token: 'secret')
+    b.login_with_token(username: 'alice', token: 'secret')
+    assert b.authenticated?
+  end
+
+  def test_restricted_wrong_user_fails
+    b = Gemba::Achievements::FakeBackend.new(valid_username: 'alice', valid_token: 'secret')
+    statuses = []
+    errors   = []
+    b.on_auth_change { |s, e| statuses << s; errors << e }
+    b.login_with_token(username: 'bob', token: 'secret')
+    refute b.authenticated?
+    assert_equal [:error], statuses
+    refute_nil errors.first
+  end
+
+  def test_restricted_wrong_token_fails
+    b = Gemba::Achievements::FakeBackend.new(valid_username: 'alice', valid_token: 'secret')
+    b.login_with_token(username: 'alice', token: 'wrong')
+    refute b.authenticated?
+  end
+
+  def test_logout_clears_auth
+    b = Gemba::Achievements::FakeBackend.new
+    b.login_with_token(username: 'alice', token: 'tok')
+    assert b.authenticated?
+    b.logout
+    refute b.authenticated?
+  end
+
+  def test_multiple_auth_callbacks_all_fired
+    b = Gemba::Achievements::FakeBackend.new
+    results = []
+    b.on_auth_change { |s, _| results << "cb1:#{s}" }
+    b.on_auth_change { |s, _| results << "cb2:#{s}" }
+    b.login_with_token(username: 'u', token: 't')
+    assert_equal ['cb1:ok', 'cb2:ok'], results
+  end
+end

data/test/test_game_index.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+require "gemba/headless"
+
+class TestGameIndex < Minitest::Test
+  def setup
+    Gemba::GameIndex.reset!
+  end
+
+  # -- lookup (by game code) -----------------------------------------------
+
+  def test_lookup_known_gba_game
+    name = Gemba::GameIndex.lookup("AGB-AXVE")
+    assert_includes name, "Pokemon"
+    assert_includes name, "Ruby"
+  end
+
+  def test_lookup_returns_nil_for_unknown_code
+    assert_nil Gemba::GameIndex.lookup("AGB-ZZZZ")
+  end
+
+  def test_lookup_returns_nil_for_nil_input
+    assert_nil Gemba::GameIndex.lookup(nil)
+  end
+
+  def test_lookup_returns_nil_for_empty_string
+    assert_nil Gemba::GameIndex.lookup("")
+  end
+
+  def test_lookup_returns_nil_for_unknown_platform_prefix
+    assert_nil Gemba::GameIndex.lookup("XYZ-AAAA")
+  end
+
+  def test_lookup_known_gbc_game
+    # Pokemon Gold is a well-known GBC title
+    name = Gemba::GameIndex.lookup("CGB-BYEE")
+    assert_includes name, "Pokemon" if name  # only assert content if present
+    # At minimum it must not raise
+  end
+
+  # -- lookup_by_md5 -------------------------------------------------------
+
+  def test_lookup_by_md5_returns_nil_for_nil_md5
+    assert_nil Gemba::GameIndex.lookup_by_md5(nil, "gba")
+  end
+
+  def test_lookup_by_md5_returns_nil_for_empty_md5
+    assert_nil Gemba::GameIndex.lookup_by_md5("", "gba")
+  end
+
+  def test_lookup_by_md5_returns_nil_for_unknown_platform
+    assert_nil Gemba::GameIndex.lookup_by_md5("abc123", "snes")
+  end
+
+  def test_lookup_by_md5_returns_nil_for_unknown_digest
+    assert_nil Gemba::GameIndex.lookup_by_md5("0" * 32, "gba")
+  end
+
+  def test_lookup_by_md5_is_case_insensitive
+    # Use a real digest present in gba_md5.json so both lookups must return a non-nil title
+    md5   = "0007d212d9b76a466c7ca003d50c8c74"
+    lower = Gemba::GameIndex.lookup_by_md5(md5.downcase, "gba")
+    upper = Gemba::GameIndex.lookup_by_md5(md5.upcase,   "gba")
+    refute_nil lower, "lowercase MD5 lookup must return a title"
+    assert_equal lower, upper
+  end
+
+  # -- reset! / caching ----------------------------------------------------
+
+  def test_reset_clears_cache_and_reloads
+    Gemba::GameIndex.lookup("AGB-AXVE")
+    Gemba::GameIndex.reset!
+    name = Gemba::GameIndex.lookup("AGB-AXVE")
+    assert_includes name, "Pokemon"
+  end
+end

data/test/test_game_picker_frame.rb

@@ -0,0 +1,310 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require_relative "shared/tk_test_helper"
+
+class TestGamePickerFrame < Minitest::Test
+  include TeekTestHelper
+
+  # Each test gets a fresh picker. Since Teek::TestWorker persists across tests,
+  # we must destroy .game_picker at the end of each test so the next test can
+  # recreate it cleanly (ttk::frame fails if the path already exists).
+  def cleanup_picker(app)
+    app.command(:destroy, '.game_picker') rescue nil
+  end
+
+  def test_empty_library_shows_all_hollow_cards
+    assert_tk_app("empty library shows all hollow cards") do
+      require "gemba/headless"
+
+      lib = Struct.new(:roms) { def all = roms }.new([])
+      picker = Gemba::GamePickerFrame.new(app: app, rom_library: lib)
+      picker.show
+
+      16.times do |i|
+        title = app.command(".game_picker.card#{i}.title", :cget, '-text')
+        assert_equal '', title, "Card #{i} title should be empty"
+
+        img = app.command(".game_picker.card#{i}.img", :cget, '-image')
+        assert_equal 'boxart_placeholder', img, "Card #{i} should show placeholder image"
+
+        bg = app.command(".game_picker.card#{i}", :cget, '-bg')
+        refute_equal '#2a2a2a', bg, "Card #{i} should not have populated background"
+      end
+
+      picker.cleanup
+      app.command(:destroy, '.game_picker') rescue nil
+    end
+  end
+
+  def test_populated_card_shows_title_and_platform
+    assert_tk_app("populated card shows title and platform text") do
+      require "gemba/headless"
+
+      rom = { 'title' => 'Pokemon Ruby', 'platform' => 'gba',
+              'game_code' => 'AGB-AXVE', 'path' => '/games/ruby.gba' }
+      lib = Struct.new(:roms) { def all = roms }.new([rom])
+      picker = Gemba::GamePickerFrame.new(app: app, rom_library: lib)
+      picker.show
+
+      assert_equal 'Pokemon - Ruby Version (USA, Europe)', app.command('.game_picker.card0.title', :cget, '-text')
+      assert_equal 'GBA',          app.command('.game_picker.card0.plat',  :cget, '-text')
+
+      picker.cleanup
+      app.command(:destroy, '.game_picker') rescue nil
+    end
+  end
+
+  def test_platform_is_uppercased
+    assert_tk_app("platform label is uppercased") do
+      require "gemba/headless"
+
+      rom = { 'title' => 'Tetris', 'platform' => 'gbc', 'path' => '/games/tetris.gbc' }
+      lib = Struct.new(:roms) { def all = roms }.new([rom])
+      picker = Gemba::GamePickerFrame.new(app: app, rom_library: lib)
+      picker.show
+
+      assert_equal 'GBC', app.command('.game_picker.card0.plat', :cget, '-text')
+
+      picker.cleanup
+      app.command(:destroy, '.game_picker') rescue nil
+    end
+  end
+
+  def test_title_falls_back_to_rom_id_when_title_missing
+    assert_tk_app("title falls back to rom_id when title key absent") do
+      require "gemba/headless"
+
+      rom = { 'rom_id' => 'MY-ROM', 'platform' => 'gba', 'path' => '/games/x.gba' }
+      lib = Struct.new(:roms) { def all = roms }.new([rom])
+      picker = Gemba::GamePickerFrame.new(app: app, rom_library: lib)
+      picker.show
+
+      assert_equal 'MY-ROM', app.command('.game_picker.card0.title', :cget, '-text')
+
+      picker.cleanup
+      app.command(:destroy, '.game_picker') rescue nil
+    end
+  end
+
+  def test_populated_card_background_differs_from_hollow
+    assert_tk_app("populated card has different background color than hollow card") do
+      require "gemba/headless"
+
+      rom = { 'title' => 'Test Game', 'platform' => 'gba', 'path' => '/games/test.gba' }
+      lib = Struct.new(:roms) { def all = roms }.new([rom])
+      picker = Gemba::GamePickerFrame.new(app: app, rom_library: lib)
+      picker.show
+
+      pop_bg    = app.command('.game_picker.card0', :cget, '-bg')
+      hollow_bg = app.command('.game_picker.card1', :cget, '-bg')
+
+      assert_equal '#2a2a2a', pop_bg, "Populated card background"
+      refute_equal pop_bg, hollow_bg, "Hollow card should differ from populated"
+
+      picker.cleanup
+      app.command(:destroy, '.game_picker') rescue nil
+    end
+  end
+
+  def test_multiple_roms_populate_correct_cards_in_order
+    assert_tk_app("multiple ROMs fill cards in order; remainder are hollow") do
+      require "gemba/headless"
+
+      roms = [
+        { 'title' => 'Alpha', 'platform' => 'gba', 'path' => '/a.gba' },
+        { 'title' => 'Beta',  'platform' => 'gbc', 'path' => '/b.gbc' },
+      ]
+      lib = Struct.new(:roms) { def all = roms }.new(roms)
+      picker = Gemba::GamePickerFrame.new(app: app, rom_library: lib)
+      picker.show
+
+      assert_equal 'Alpha', app.command('.game_picker.card0.title', :cget, '-text')
+      assert_equal 'GBA',   app.command('.game_picker.card0.plat',  :cget, '-text')
+      assert_equal 'Beta',  app.command('.game_picker.card1.title', :cget, '-text')
+      assert_equal 'GBC',   app.command('.game_picker.card1.plat',  :cget, '-text')
+      assert_equal '',      app.command('.game_picker.card2.title', :cget, '-text')
+
+      picker.cleanup
+      app.command(:destroy, '.game_picker') rescue nil
+    end
+  end
+
+  def test_pre_cached_boxart_shown_immediately_without_network
+    assert_tk_app("pre-cached boxart image is set on the card without any network fetch") do
+      require "gemba/headless"
+      require "gemba/headless"
+      require "tmpdir"
+      require "fileutils"
+
+      game_code = 'AGB-AXVE'
+      tmpdir    = Dir.mktmpdir('picker_test')
+      cache_dir = File.join(tmpdir, game_code)
+      FileUtils.mkdir_p(cache_dir)
+      # Re-use the placeholder PNG — it's a real PNG Tk already loads successfully
+      FileUtils.cp(Gemba::GamePickerFrame::PLACEHOLDER_PNG, File.join(cache_dir, 'boxart.png'))
+
+      # Backend that would return a URL, but the cache hit means it's never called
+      backend = Struct.new(:url) { def url_for(_) = url }.new('https://example.com/fake.png')
+      fetcher = Gemba::BoxartFetcher.new(app: app, cache_dir: tmpdir, backend: backend)
+
+      rom = { 'title' => 'Pokemon Ruby', 'platform' => 'gba',
+              'game_code' => game_code, 'path' => '/fake.gba' }
+      lib = Struct.new(:roms) { def all = roms }.new([rom])
+      picker = Gemba::GamePickerFrame.new(app: app, rom_library: lib, boxart_fetcher: fetcher)
+      picker.show
+
+      img_name = app.command('.game_picker.card0.img', :cget, '-image')
+      assert_equal "boxart_#{game_code}", img_name,
+        "Card should display cached boxart image, not the placeholder"
+
+      FileUtils.rm_rf(tmpdir)
+      picker.cleanup
+      app.command(:destroy, '.game_picker') rescue nil
+    end
+  end
+
+  def test_no_fetcher_leaves_placeholder_on_card
+    assert_tk_app("card with game_code but no fetcher stays on placeholder") do
+      require "gemba/headless"
+
+      rom = { 'title' => 'Some Game', 'platform' => 'gba',
+              'game_code' => 'AGB-TEST', 'path' => '/games/some.gba' }
+      lib = Struct.new(:roms) { def all = roms }.new([rom])
+      # No boxart_fetcher passed
+      picker = Gemba::GamePickerFrame.new(app: app, rom_library: lib)
+      picker.show
+
+      img_name = app.command('.game_picker.card0.img', :cget, '-image')
+      assert_equal 'boxart_placeholder', img_name
+
+      picker.cleanup
+      app.command(:destroy, '.game_picker') rescue nil
+    end
+  end
+
+  # -- Quick Load context menu ------------------------------------------------
+  # Menu entry indices: 0=Play, 1=Quick Load, 2=Set Boxart, 3=separator, 4=Remove
+
+  def test_quick_load_disabled_when_no_save_state
+    assert_tk_app("quick load menu entry is disabled when no .ss file exists") do
+      require "gemba/headless"
+      require "tmpdir"
+
+      Dir.mktmpdir("picker_qs_test") do |tmpdir|
+        rom_id = "AGB-TEST-DEADBEEF"
+        rom = { 'title' => 'Test Game', 'platform' => 'gba',
+                'rom_id' => rom_id, 'game_code' => 'AGB-TEST', 'path' => '/games/test.gba' }
+        lib = Struct.new(:roms) { def all = roms }.new([rom])
+
+        Gemba.user_config.states_dir = tmpdir
+        picker = Gemba::GamePickerFrame.new(app: app, rom_library: lib)
+        picker.show
+        app.show
+        app.update
+
+        # Suppress tk_popup so the right-click binding configures menu entries
+        # without posting the menu (no platform grab → no blocking app.update).
+        override_tk_popup do
+          app.tcl_eval("event generate .game_picker.card0 <Button-3> -x 10 -y 10")
+          app.update
+        end
+
+        # index 1 = Quick Load
+        state = app.tcl_eval(".game_picker.card0.ctx entrycget 1 -state")
+        assert_equal 'disabled', state
+
+        picker.cleanup
+        app.command(:destroy, '.game_picker') rescue nil
+      end
+    end
+  end
+
+  def test_quick_load_enabled_when_save_state_exists
+    assert_tk_app("quick load menu entry is enabled when .ss file exists") do
+      require "gemba/headless"
+      require "tmpdir"
+      require "fileutils"
+
+      fixture = File.expand_path("test/fixtures/test_quicksave.ss")
+
+      Dir.mktmpdir("picker_qs_test") do |tmpdir|
+        rom_id    = "AGB-TEST-DEADBEEF"
+        slot      = Gemba.user_config.quick_save_slot
+        state_dir = File.join(tmpdir, rom_id)
+        FileUtils.mkdir_p(state_dir)
+        FileUtils.cp(fixture, File.join(state_dir, "state#{slot}.ss"))
+
+        rom = { 'title' => 'Test Game', 'platform' => 'gba',
+                'rom_id' => rom_id, 'game_code' => 'AGB-TEST', 'path' => '/games/test.gba' }
+        lib = Struct.new(:roms) { def all = roms }.new([rom])
+
+        Gemba.user_config.states_dir = tmpdir
+        picker = Gemba::GamePickerFrame.new(app: app, rom_library: lib)
+        picker.show
+        app.show
+        app.update
+
+        override_tk_popup do
+          app.tcl_eval("event generate .game_picker.card0 <Button-3> -x 10 -y 10")
+          app.update
+        end
+
+        # index 1 = Quick Load
+        state = app.tcl_eval(".game_picker.card0.ctx entrycget 1 -state")
+        assert_equal 'normal', state
+
+        picker.cleanup
+        app.command(:destroy, '.game_picker') rescue nil
+      end
+    end
+  end
+
+  def test_quick_load_emits_rom_quick_load_event
+    assert_tk_app("clicking quick load emits :rom_quick_load with path and slot") do
+      require "gemba/headless"
+      require "tmpdir"
+      require "fileutils"
+
+      fixture = File.expand_path("test/fixtures/test_quicksave.ss")
+
+      Dir.mktmpdir("picker_qs_test") do |tmpdir|
+        rom_id    = "AGB-TEST-DEADBEEF"
+        slot      = Gemba.user_config.quick_save_slot
+        state_dir = File.join(tmpdir, rom_id)
+        FileUtils.mkdir_p(state_dir)
+        FileUtils.cp(fixture, File.join(state_dir, "state#{slot}.ss"))
+
+        rom_path = '/games/test.gba'
+        rom = { 'title' => 'Test Game', 'platform' => 'gba',
+                'rom_id' => rom_id, 'game_code' => 'AGB-TEST', 'path' => rom_path }
+        lib = Struct.new(:roms) { def all = roms }.new([rom])
+
+        received = nil
+        Gemba.bus.on(:rom_quick_load) { |**kwargs| received = kwargs }
+
+        Gemba.user_config.states_dir = tmpdir
+        picker = Gemba::GamePickerFrame.new(app: app, rom_library: lib)
+        picker.show
+        app.show
+        app.update
+
+        override_tk_popup do
+          app.tcl_eval("event generate .game_picker.card0 <Button-3> -x 10 -y 10")
+          app.update
+        end
+
+        # Menu was built but not shown — invoke the Quick Load entry directly.
+        # index 1 = Quick Load
+        app.tcl_eval(".game_picker.card0.ctx invoke 1")
+        app.update
+
+        assert_equal rom_path, received[:path]
+        assert_equal slot,     received[:slot]
+
+        picker.cleanup
+        app.command(:destroy, '.game_picker') rescue nil
+      end
+    end
+  end
+end

data/test/test_gamepad_map.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
 require "minitest/autorun"
-require "gemba"
-require_relative "../lib/gemba/config"
-require_relative "../lib/gemba/input_mappings"
+require "gemba/headless"
 require_relative "support/input_mocks"
 
 class TestGamepadMap < Minitest::Test

data/test/test_headless_player.rb

@@ -7,9 +7,6 @@ require "tmpdir"
 class TestHeadlessPlayer < Minitest::Test
   TEST_ROM = File.expand_path("fixtures/test.gba", __dir__)
 
-  def setup
-    skip "Run: ruby gemba/scripts/generate_test_rom.rb" unless File.exist?(TEST_ROM)
-  end
 
   # -- Lifecycle ---------------------------------------------------------------
 
@@ -202,4 +199,21 @@ class TestHeadlessPlayer < Minitest::Test
       assert_equal 0, player.rewind_count
     end
   end
+
+  # -- BIOS loading -----------------------------------------------------------
+
+  FAKE_BIOS = File.expand_path("fixtures/fake_bios.bin", __dir__)
+
+  def test_bios_not_loaded_by_default
+    Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+      refute player.core.bios_loaded?
+    end
+  end
+
+  def test_bios_loaded_when_path_given
+    skip "fake_bios.bin not present" unless File.exist?(FAKE_BIOS)
+    Gemba::HeadlessPlayer.open(TEST_ROM, bios_path: FAKE_BIOS) do |player|
+      assert player.core.bios_loaded?
+    end
+  end
 end