gemba 0.1.1 → 0.2.1

data/test/test_list_picker_frame.rb

@@ -0,0 +1,391 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require_relative "shared/tk_test_helper"
+
+class TestListPickerFrame < Minitest::Test
+  include TeekTestHelper
+
+  
+
+  # ── Population ─────────────────────────────────────────────────────────────
+
+  def test_empty_library_shows_no_rows
+    assert_tk_app("empty library produces zero treeview rows") do
+      require "gemba/headless"
+
+      lib    = Struct.new(:roms) { def all = roms }.new([])
+      picker = Gemba::ListPickerFrame.new(app: app, rom_library: lib)
+      picker.show
+      app.update
+
+      items = app.tcl_eval(".list_picker.tree children {}").split
+      assert_empty items, "no rows expected for empty library"
+
+      app.command(:destroy, '.list_picker') rescue nil
+    end
+  end
+
+  def test_roms_populate_title_column
+    assert_tk_app("ROM titles appear in the title column") do
+      require "gemba/headless"
+
+      roms = [
+        { 'title' => 'Alpha', 'platform' => 'gba', 'path' => '/a.gba',
+          'last_played' => '2026-02-20T10:00:00Z' },
+        { 'title' => 'Beta',  'platform' => 'gbc', 'path' => '/b.gbc',
+          'last_played' => '2026-02-19T10:00:00Z' },
+      ]
+      lib    = Struct.new(:roms) { def all = roms }.new(roms)
+      picker = Gemba::ListPickerFrame.new(app: app, rom_library: lib)
+      picker.show
+      app.update
+
+      items  = app.tcl_eval(".list_picker.tree children {}").split
+      titles = items.map { |id| app.tcl_eval(".list_picker.tree set #{id} title") }
+      assert_equal 2, titles.size
+      assert_includes titles, 'Alpha'
+      assert_includes titles, 'Beta'
+
+      app.command(:destroy, '.list_picker') rescue nil
+    end
+  end
+
+  def test_last_played_formatted_as_month_day_year
+    assert_tk_app("last_played ISO string is formatted for display") do
+      require "gemba/headless"
+
+      roms = [{ 'title' => 'Game', 'platform' => 'gba', 'path' => '/g.gba',
+                'last_played' => '2026-02-22T15:30:00Z' }]
+      lib    = Struct.new(:roms) { def all = roms }.new(roms)
+      picker = Gemba::ListPickerFrame.new(app: app, rom_library: lib)
+      picker.show
+      app.update
+
+      iid = app.tcl_eval(".list_picker.tree children {}").split.first
+      lp  = app.tcl_eval(".list_picker.tree set #{iid} last_played")
+      assert_match(/Feb\s+22,\s+2026/, lp)
+
+      app.command(:destroy, '.list_picker') rescue nil
+    end
+  end
+
+  def test_nil_last_played_shows_never_placeholder
+    assert_tk_app("ROM with no last_played shows never-played text, not a date") do
+      require "gemba/headless"
+
+      roms = [{ 'title' => 'New Game', 'platform' => 'gba', 'path' => '/n.gba' }]
+      lib    = Struct.new(:roms) { def all = roms }.new(roms)
+      picker = Gemba::ListPickerFrame.new(app: app, rom_library: lib)
+      picker.show
+      app.update
+
+      iid = app.tcl_eval(".list_picker.tree children {}").split.first
+      lp  = app.tcl_eval(".list_picker.tree set #{iid} last_played")
+      refute_empty lp
+      refute_match(/\d{4}/, lp, "should not look like a date")
+
+      app.command(:destroy, '.list_picker') rescue nil
+    end
+  end
+
+  def test_all_roms_shown_without_cap
+    assert_tk_app("all 20 library ROMs appear with no cap") do
+      require "gemba/headless"
+
+      roms = 20.times.map { |i| { 'title' => "Game #{i}", 'platform' => 'gba', 'path' => "/g#{i}.gba" } }
+      lib    = Struct.new(:roms) { def all = roms }.new(roms)
+      picker = Gemba::ListPickerFrame.new(app: app, rom_library: lib)
+      picker.show
+      app.update
+
+      count = app.tcl_eval(".list_picker.tree children {}").split.size
+      assert_equal 20, count
+
+      app.command(:destroy, '.list_picker') rescue nil
+    end
+  end
+
+  # ── Default sort ────────────────────────────────────────────────────────────
+
+  def test_default_sort_newest_last_played_first
+    assert_tk_app("default sort shows most-recently-played ROM first") do
+      require "gemba/headless"
+
+      roms = [
+        { 'title' => 'Old',    'platform' => 'gba', 'path' => '/o.gba',
+          'last_played' => '2024-01-01T00:00:00Z' },
+        { 'title' => 'Recent', 'platform' => 'gba', 'path' => '/r.gba',
+          'last_played' => '2026-02-22T00:00:00Z' },
+        { 'title' => 'Middle', 'platform' => 'gba', 'path' => '/m.gba',
+          'last_played' => '2025-06-15T00:00:00Z' },
+      ]
+      lib    = Struct.new(:roms) { def all = roms }.new(roms)
+      picker = Gemba::ListPickerFrame.new(app: app, rom_library: lib)
+      picker.show
+      app.update
+
+      items  = app.tcl_eval(".list_picker.tree children {}").split
+      titles = items.map { |id| app.tcl_eval(".list_picker.tree set #{id} title") }
+      assert_equal 'Recent', titles[0], "most recent should be first"
+      assert_equal 'Middle', titles[1]
+      assert_equal 'Old',    titles[2]
+
+      app.command(:destroy, '.list_picker') rescue nil
+    end
+  end
+
+  # ── Sorting ─────────────────────────────────────────────────────────────────
+
+  def test_click_title_heading_sorts_a_to_z_with_indicator
+    assert_tk_app("clicking title heading sorts A→Z and shows ▲") do
+      require "gemba/headless"
+
+      roms = [
+        { 'title' => 'Zelda',       'platform' => 'gba', 'path' => '/z.gba' },
+        { 'title' => 'Metroid',     'platform' => 'gba', 'path' => '/m.gba' },
+        { 'title' => 'Castlevania', 'platform' => 'gba', 'path' => '/c.gba' },
+      ]
+      lib    = Struct.new(:roms) { def all = roms }.new(roms)
+      picker = Gemba::ListPickerFrame.new(app: app, rom_library: lib)
+      picker.show
+      app.update
+
+      cmd = app.tcl_eval(".list_picker.tree heading title -command")
+      app.tcl_eval("uplevel #0 {#{cmd}}")
+      app.update
+
+      items  = app.tcl_eval(".list_picker.tree children {}").split
+      titles = items.map { |id| app.tcl_eval(".list_picker.tree set #{id} title") }
+      assert_equal %w[Castlevania Metroid Zelda], titles
+      assert_includes app.tcl_eval(".list_picker.tree heading title -text"), '▲'
+
+      app.command(:destroy, '.list_picker') rescue nil
+    end
+  end
+
+  def test_click_title_heading_twice_reverses_to_z_to_a
+    assert_tk_app("clicking title heading twice reverses to Z→A and shows ▼") do
+      require "gemba/headless"
+
+      roms = [
+        { 'title' => 'Zelda',   'platform' => 'gba', 'path' => '/z.gba' },
+        { 'title' => 'Metroid', 'platform' => 'gba', 'path' => '/m.gba' },
+      ]
+      lib    = Struct.new(:roms) { def all = roms }.new(roms)
+      picker = Gemba::ListPickerFrame.new(app: app, rom_library: lib)
+      picker.show
+      app.update
+
+      cmd = app.tcl_eval(".list_picker.tree heading title -command")
+      app.tcl_eval("uplevel #0 {#{cmd}}")  # asc
+      app.tcl_eval("uplevel #0 {#{cmd}}")  # desc
+      app.update
+
+      items  = app.tcl_eval(".list_picker.tree children {}").split
+      titles = items.map { |id| app.tcl_eval(".list_picker.tree set #{id} title") }
+      assert_equal %w[Zelda Metroid], titles
+      assert_includes app.tcl_eval(".list_picker.tree heading title -text"), '▼'
+
+      app.command(:destroy, '.list_picker') rescue nil
+    end
+  end
+
+  def test_click_last_played_heading_sorts_oldest_first
+    assert_tk_app("clicking last_played heading (toggle from default desc) shows oldest first") do
+      require "gemba/headless"
+
+      roms = [
+        { 'title' => 'Old',    'platform' => 'gba', 'path' => '/o.gba',
+          'last_played' => '2024-01-01T00:00:00Z' },
+        { 'title' => 'Recent', 'platform' => 'gba', 'path' => '/r.gba',
+          'last_played' => '2026-02-22T00:00:00Z' },
+      ]
+      lib    = Struct.new(:roms) { def all = roms }.new(roms)
+      picker = Gemba::ListPickerFrame.new(app: app, rom_library: lib)
+      picker.show
+      app.update
+
+      # Default is last_played desc — clicking once switches to asc (oldest first)
+      cmd = app.tcl_eval(".list_picker.tree heading last_played -command")
+      app.tcl_eval("uplevel #0 {#{cmd}}")
+      app.update
+
+      items  = app.tcl_eval(".list_picker.tree children {}").split
+      titles = items.map { |id| app.tcl_eval(".list_picker.tree set #{id} title") }
+      assert_equal 'Old', titles[0], "ascending: oldest first"
+      assert_includes app.tcl_eval(".list_picker.tree heading last_played -text"), '▲'
+
+      app.command(:destroy, '.list_picker') rescue nil
+    end
+  end
+
+  def test_switching_sort_column_clears_old_indicator
+    assert_tk_app("switching sort column removes ▲/▼ from the old column") do
+      require "gemba/headless"
+
+      roms = [{ 'title' => 'Solo', 'platform' => 'gba', 'path' => '/s.gba' }]
+      lib    = Struct.new(:roms) { def all = roms }.new(roms)
+      picker = Gemba::ListPickerFrame.new(app: app, rom_library: lib)
+      picker.show
+      app.update
+
+      title_cmd = app.tcl_eval(".list_picker.tree heading title -command")
+      lp_cmd    = app.tcl_eval(".list_picker.tree heading last_played -command")
+
+      app.tcl_eval("uplevel #0 {#{title_cmd}}")  # sort by title (adds ▲)
+      app.tcl_eval("uplevel #0 {#{lp_cmd}}")     # switch to last_played
+      app.update
+
+      title_text = app.tcl_eval(".list_picker.tree heading title -text")
+      refute_includes title_text, '▲', "title heading should lose its indicator"
+      refute_includes title_text, '▼', "title heading should lose its indicator"
+
+      lp_text = app.tcl_eval(".list_picker.tree heading last_played -text")
+      assert(lp_text.include?('▲') || lp_text.include?('▼'),
+             "last_played heading should now show an indicator")
+
+      app.command(:destroy, '.list_picker') rescue nil
+    end
+  end
+
+  # ── Interaction ─────────────────────────────────────────────────────────────
+
+  def test_double_click_row_emits_rom_selected
+    assert_tk_app("double-clicking a row emits :rom_selected with the ROM path") do
+      require "gemba/headless"
+
+      rom_path = '/games/fire_red.gba'
+      roms     = [{ 'title' => 'Fire Red', 'platform' => 'gba', 'path' => rom_path }]
+      lib      = Struct.new(:roms) { def all = roms }.new(roms)
+      picker   = Gemba::ListPickerFrame.new(app: app, rom_library: lib)
+
+      received = nil
+      Gemba.bus.on(:rom_selected) { |path| received = path }
+
+      picker.show
+      app.show
+      app.update
+
+      iid = app.tcl_eval(".list_picker.tree children {}").split.first
+      app.tcl_eval(".list_picker.tree focus #{iid}")
+      app.tcl_eval(".list_picker.tree selection set #{iid}")
+      app.tcl_eval("event generate .list_picker.tree <<DoubleClick>>")
+      app.update
+
+      assert_equal rom_path, received
+
+      app.command(:destroy, '.list_picker') rescue nil
+    end
+  end
+
+  def test_right_click_quick_load_disabled_when_no_save_state
+    assert_tk_app("<<RightClick>> quick load entry is disabled with no save file") do
+      require "gemba/headless"
+      require "tmpdir"
+
+      Dir.mktmpdir("list_picker_qs_test") do |tmpdir|
+        rom_id = "AGB-TEST-DEADBEEF"
+        roms   = [{ 'title' => 'Test', 'platform' => 'gba',
+                    'rom_id' => rom_id, 'game_code' => 'AGB-TEST',
+                    'path' => '/games/test.gba', 'last_played' => '2026-01-01T00:00:00Z' }]
+
+        Gemba.user_config.states_dir = tmpdir
+        lib    = Struct.new(:roms) { def all = roms }.new(roms)
+        picker = Gemba::ListPickerFrame.new(app: app, rom_library: lib)
+        picker.show
+        app.show
+        app.update
+
+        iid = app.tcl_eval(".list_picker.tree children {}").split.first
+        app.tcl_eval(".list_picker.tree focus #{iid}")
+        app.tcl_eval(".list_picker.tree selection set #{iid}")
+
+        override_tk_popup do
+          app.tcl_eval("event generate .list_picker.tree <<RightClick>>")
+          app.update
+        end
+
+        state = app.tcl_eval(".list_picker.tree.ctx entrycget 1 -state")
+        assert_equal 'disabled', state
+
+        app.command(:destroy, '.list_picker') rescue nil
+      end
+    end
+  end
+
+  def test_right_click_quick_load_enabled_when_save_state_exists
+    assert_tk_app("<<RightClick>> quick load entry is enabled when save file exists") do
+      require "gemba/headless"
+      require "tmpdir"
+      require "fileutils"
+
+      fixture = File.expand_path("test/fixtures/test_quicksave.ss")
+
+      Dir.mktmpdir("list_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"))
+
+        roms = [{ 'title' => 'Test', 'platform' => 'gba',
+                  'rom_id' => rom_id, 'game_code' => 'AGB-TEST',
+                  'path' => '/games/test.gba', 'last_played' => '2026-01-01T00:00:00Z' }]
+
+        Gemba.user_config.states_dir = tmpdir
+        lib    = Struct.new(:roms) { def all = roms }.new(roms)
+        picker = Gemba::ListPickerFrame.new(app: app, rom_library: lib)
+        picker.show
+        app.show
+        app.update
+
+        iid = app.tcl_eval(".list_picker.tree children {}").split.first
+        app.tcl_eval(".list_picker.tree focus #{iid}")
+        app.tcl_eval(".list_picker.tree selection set #{iid}")
+
+        override_tk_popup do
+          app.tcl_eval("event generate .list_picker.tree <<RightClick>>")
+          app.update
+        end
+
+        state = app.tcl_eval(".list_picker.tree.ctx entrycget 1 -state")
+        assert_equal 'normal', state
+
+        app.command(:destroy, '.list_picker') rescue nil
+      end
+    end
+  end
+
+  def test_refresh_repopulates_rows
+    assert_tk_app("receive(:refresh) updates rows from the current library state") do
+      require "gemba/headless"
+
+      roms = [{ 'title' => 'Alpha', 'platform' => 'gba', 'path' => '/a.gba' }]
+      lib  = Struct.new(:roms) { def all = roms }.new(roms)
+
+      picker = Gemba::ListPickerFrame.new(app: app, rom_library: lib)
+      picker.show
+      app.update
+
+      items  = app.tcl_eval(".list_picker.tree children {}").split
+      titles = items.map { |id| app.tcl_eval(".list_picker.tree set #{id} title") }
+      assert_equal ['Alpha'], titles
+
+      lib.roms = [
+        { 'title' => 'Alpha', 'platform' => 'gba', 'path' => '/a.gba' },
+        { 'title' => 'Beta',  'platform' => 'gbc', 'path' => '/b.gbc' },
+      ]
+      picker.receive(:refresh)
+      app.update
+
+      items  = app.tcl_eval(".list_picker.tree children {}").split
+      titles = items.map { |id| app.tcl_eval(".list_picker.tree set #{id} title") }
+      assert_equal 2, titles.size
+      assert_includes titles, 'Alpha'
+      assert_includes titles, 'Beta'
+
+      app.command(:destroy, '.list_picker') rescue nil
+    end
+  end
+end

data/test/test_locale.rb

@@ -2,7 +2,7 @@
 
 require "minitest/autorun"
 require "yaml"
-require_relative "../lib/gemba/locale"
+require "gemba/headless"
 
 class TestMGBALocale < Minitest::Test
   # -- Loading ---------------------------------------------------------------

data/test/test_logging.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "tmpdir"
+require "fileutils"
+require "gemba/headless"
+
+class TestLogging < Minitest::Test
+  def setup
+    @dir = Dir.mktmpdir("gemba-logs-test")
+    @logger = Gemba::SessionLogger.new(dir: @dir, level: :info)
+  end
+
+  def teardown
+    Gemba.logger = nil
+    FileUtils.rm_rf(@dir)
+  end
+
+  # -- lazy file creation --
+
+  def test_no_file_before_first_log
+    assert_empty Dir.glob(File.join(@dir, "*.log"))
+  end
+
+  def test_file_created_on_first_log
+    @logger.log(:info) { "hello" }
+    logs = Dir.glob(File.join(@dir, "*.log"))
+    assert_equal 1, logs.length
+  end
+
+  def test_file_named_by_date
+    @logger.log(:info) { "hello" }
+    logs = Dir.glob(File.join(@dir, "*.log"))
+    assert_match(/gemba-\d{4}-\d{2}-\d{2}\.log/, File.basename(logs.first))
+  end
+
+  # -- level filtering --
+
+  def test_filters_below_level
+    @logger.log(:debug) { "should not appear" }
+    assert_empty Dir.glob(File.join(@dir, "*.log")),
+      "Debug message should not create log file at info level"
+  end
+
+  def test_allows_at_level
+    @logger.log(:info) { "visible" }
+    content = File.read(Dir.glob(File.join(@dir, "*.log")).first)
+    assert_includes content, "visible"
+  end
+
+  def test_allows_above_level
+    @logger.log(:error) { "bad thing" }
+    content = File.read(Dir.glob(File.join(@dir, "*.log")).first)
+    assert_includes content, "bad thing"
+  end
+
+  def test_debug_level_allows_debug
+    logger = Gemba::SessionLogger.new(dir: @dir, level: :debug)
+    logger.log(:debug) { "debug msg" }
+    content = File.read(Dir.glob(File.join(@dir, "*.log")).first)
+    assert_includes content, "debug msg"
+  end
+
+  # -- log format --
+
+  def test_log_format
+    @logger.log(:info) { "test message" }
+    content = File.read(Dir.glob(File.join(@dir, "*.log")).first)
+    assert_match(/\d{2}:\d{2}:\d{2}\.\d{3} \[INFO\] test message/, content)
+  end
+
+  # -- auto-prune --
+
+  def test_prune_keeps_max_files
+    # Create 30 fake log files
+    30.times do |i|
+      File.write(File.join(@dir, "gemba-2026-01-#{format('%02d', i + 1)}.log"), "old")
+    end
+
+    # New logger prunes on init
+    Gemba::SessionLogger.new(dir: @dir, level: :info)
+
+    remaining = Dir.glob(File.join(@dir, "gemba-*.log"))
+    assert_equal Gemba::SessionLogger::MAX_LOG_FILES, remaining.length
+  end
+
+  def test_prune_keeps_newest
+    30.times do |i|
+      File.write(File.join(@dir, "gemba-2026-01-#{format('%02d', i + 1)}.log"), "old")
+    end
+
+    Gemba::SessionLogger.new(dir: @dir, level: :info)
+
+    remaining = Dir.glob(File.join(@dir, "gemba-*.log")).sort
+    # Should keep the last 25 (days 06-30)
+    assert_equal "gemba-2026-01-06.log", File.basename(remaining.first)
+    assert_equal "gemba-2026-01-30.log", File.basename(remaining.last)
+  end
+
+  def test_prune_no_op_when_under_limit
+    3.times do |i|
+      File.write(File.join(@dir, "gemba-2026-01-#{format('%02d', i + 1)}.log"), "ok")
+    end
+
+    Gemba::SessionLogger.new(dir: @dir, level: :info)
+    assert_equal 3, Dir.glob(File.join(@dir, "gemba-*.log")).length
+  end
+
+  # -- module interface --
+
+  def test_gemba_log_module_method
+    Gemba.logger = Gemba::SessionLogger.new(dir: @dir, level: :info)
+    Gemba.log(:info) { "module test" }
+    content = File.read(Dir.glob(File.join(@dir, "*.log")).first)
+    assert_includes content, "module test"
+  end
+
+  def test_gemba_logger_setter
+    custom = Gemba::SessionLogger.new(dir: @dir, level: :warn)
+    Gemba.logger = custom
+    assert_same custom, Gemba.logger
+  end
+end

data/test/test_null_backend.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "gemba/headless"
+require "gemba/achievements"
+require_relative "support/fake_core"
+
+class TestNullBackend < Minitest::Test
+  def setup
+    @b = Gemba::Achievements::NullBackend.new
+  end
+
+  def test_not_enabled
+    refute @b.enabled?
+  end
+
+  def test_not_authenticated
+    refute @b.authenticated?
+  end
+
+  def test_achievement_list_empty
+    assert_equal [], @b.achievement_list
+  end
+
+  def test_counts_zero
+    assert_equal 0, @b.earned_count
+    assert_equal 0, @b.total_count
+  end
+
+  def test_do_frame_is_noop
+    assert_nil @b.do_frame(FakeCore.new)
+  end
+
+  def test_login_noop
+    assert_nil @b.login_with_token(username: 'u', token: 't')
+    refute @b.authenticated?
+  end
+
+  def test_logout_noop
+    assert_nil @b.logout
+  end
+end

data/test/test_offline_backend.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "gemba/headless"
+
+class TestOfflineBackend < Minitest::Test
+  ROM = "test/fixtures/test.gba"
+
+  def setup
+    skip "test.gba fixture not found" unless File.exist?(ROM)
+    @unlocked = []
+    @backend  = Gemba::Achievements::OfflineBackend.new
+    @backend.on_unlock { |ach| @unlocked << ach }
+  end
+
+  def test_always_authenticated
+    assert @backend.authenticated?
+  end
+
+  def test_enabled
+    assert @backend.enabled?
+  end
+
+  def test_login_and_logout_are_noops
+    @backend.login_with_password(username: "anyone", password: "anything")
+    assert @backend.authenticated?
+    @backend.logout
+    assert @backend.authenticated?
+  end
+
+  def test_on_load_achievement_fires_during_load_game
+    Gemba::HeadlessPlayer.open(ROM) do |player|
+      @backend.load_game(player.core)
+      assert_equal 1, @unlocked.size
+      assert_equal "gembatest_loaded", @unlocked.first.id
+      assert_equal "Ready to Play",    @unlocked.first.title
+      assert @unlocked.first.earned?
+    end
+  end
+
+  def test_achievement_list_shows_earned_after_load
+    Gemba::HeadlessPlayer.open(ROM) do |player|
+      @backend.load_game(player.core)
+      list = @backend.achievement_list
+      assert_equal 1, list.size
+      assert list.first.earned?
+    end
+  end
+
+  def test_counts
+    Gemba::HeadlessPlayer.open(ROM) do |player|
+      assert_equal 0, @backend.total_count
+      @backend.load_game(player.core)
+      assert_equal 1, @backend.total_count
+      assert_equal 1, @backend.earned_count
+    end
+  end
+
+  def test_unload_game_clears_state
+    Gemba::HeadlessPlayer.open(ROM) do |player|
+      @backend.load_game(player.core)
+      assert_equal 1, @backend.earned_count
+      @backend.unload_game
+      assert_equal 0, @backend.total_count
+      assert_equal 0, @backend.earned_count
+    end
+  end
+
+  def test_unknown_rom_has_no_achievements
+    Gemba::HeadlessPlayer.open(ROM) do |player|
+      custom = Gemba::Achievements::OfflineBackend.new(db: {})
+      custom.load_game(player.core)
+      assert_equal 0, custom.total_count
+      assert_empty @unlocked
+    end
+  end
+
+  def test_store_adds_definitions
+    Gemba::HeadlessPlayer.open(ROM) do |player|
+      custom = Gemba::Achievements::OfflineBackend.new(db: {})
+      custom.on_unlock { |a| @unlocked << a }
+      custom.store(player.core.checksum, [
+        { id: "extra", title: "Extra", description: "desc",
+          points: 5, trigger: :on_load }
+      ])
+      custom.load_game(player.core)
+      assert_equal 1, @unlocked.size
+      assert_equal "extra", @unlocked.first.id
+    end
+  end
+
+  def test_memory_achievement_fires_on_rising_edge
+    addr = 0x02000000
+    Gemba::HeadlessPlayer.open(ROM) do |player|
+      backend = Gemba::Achievements::OfflineBackend.new(db: {
+        player.core.checksum => [
+          { id: "mem_test", title: "Mem", description: "d", points: 2,
+            trigger: :memory,
+            condition: ->(mem) { mem.call(addr) == 0x01 } }
+        ]
+      })
+      backend.on_unlock { |a| @unlocked << a }
+      backend.load_game(player.core)
+
+      # EWRAM starts zeroed — condition false
+      player.step(1)
+      backend.do_frame(player.core)
+      assert_empty @unlocked
+
+      # Write 0x01 to EWRAM — but we can't poke real memory from Ruby,
+      # so verify do_frame doesn't crash and condition stays unevaluated
+      backend.do_frame(player.core)
+      assert_empty @unlocked
+    end
+  end
+end

data/test/test_overlay_renderer.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "minitest/autorun"
-require_relative "../lib/gemba/overlay_renderer"
+require "gemba/headless"
 
 class TestOverlayRenderer < Minitest::Test
   class MockTexture