gemba 0.1.1 → 0.2.0

data/test/test_ra_backend.rb

@@ -0,0 +1,313 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "gemba/headless"
+require_relative "support/fake_ra_runtime"
+require_relative "support/fake_requester"
+require_relative "support/fake_core"
+
+PATCH_RESPONSE = {
+  "PatchData" => {
+    "RichPresencePatch" => "",
+    "Achievements" => [
+      { "ID" => 101, "Title" => "First Blood", "Description" => "Get a kill",
+        "Points" => 5, "MemAddr" => "0=1", "Flags" => 3 },
+      { "ID" => 102, "Title" => "Survivor",    "Description" => "Survive 60s",
+        "Points" => 10, "MemAddr" => "1=1", "Flags" => 3 },
+    ],
+  },
+}.freeze
+
+# Tests for Gemba::Achievements::RetroAchievements::Backend.
+#
+# FakeRequester replaces BackgroundWork so all HTTP callbacks fire synchronously
+# in-process — no Tk event loop, no subprocesses, no wait_until.
+class TestRABackend < Minitest::Test
+  Backend = Gemba::Achievements::RetroAchievements::Backend
+
+  def setup
+    @rt  = FakeRARuntime.new
+    @req = FakeRequester.new
+    @b   = Backend.new(app: nil, runtime: @rt, requester: @req)
+  end
+
+  # Authenticate @b via the real login_with_token path.
+  def login(username: "user", token: "tok")
+    @req.stub(r: "login2", body: { "Success" => true })
+    @b.login_with_token(username: username, token: token)
+  end
+
+  # Drive the full gameid→patch→unlocks chain.
+  def load_game(earned_ids: [], patch: PATCH_RESPONSE)
+    @req.stub(r: "gameid",  body: { "GameID" => 42 })
+    @req.stub(r: "patch",   body: patch)
+    @req.stub(r: "unlocks", body: { "Success" => true, "UserUnlocks" => earned_ids })
+    Dir.mktmpdir do |dir|
+      rom = File.join(dir, "test.gba")
+      File.write(rom, "FAKEGBAROM")
+      @b.load_game(nil, rom, "deadbeef" * 4)
+    end
+  end
+
+  # ---------------------------------------------------------------------------
+  # Initial state
+  # ---------------------------------------------------------------------------
+
+  def test_not_authenticated_by_default
+    refute @b.authenticated?
+  end
+
+  def test_enabled
+    assert @b.enabled?
+  end
+
+  def test_achievement_list_empty_before_game_load
+    assert_empty @b.achievement_list
+  end
+
+  def test_rich_presence_message_nil_initially
+    assert_nil @b.rich_presence_message
+  end
+
+  # ---------------------------------------------------------------------------
+  # Authentication
+  # ---------------------------------------------------------------------------
+
+  def test_login_with_password_success
+    @req.stub(r: "login2", body: { "Success" => true, "Token" => "tok123" })
+    result = nil
+    @b.on_auth_change { |status, payload| result = [status, payload] }
+    @b.login_with_password(username: "user", password: "hunter2")
+
+    assert_equal :ok,      result[0]
+    assert_equal "tok123", result[1]
+    assert @b.authenticated?
+  end
+
+  def test_login_with_password_failure
+    @req.stub(r: "login2", body: { "Success" => false, "Error" => "Invalid credentials" })
+    result = nil
+    @b.on_auth_change { |status, msg| result = [status, msg] }
+    @b.login_with_password(username: "user", password: "wrong")
+
+    assert_equal :error, result[0]
+    assert_match(/invalid credentials/i, result[1])
+    refute @b.authenticated?
+  end
+
+  def test_login_with_token_success
+    result = nil
+    @b.on_auth_change { |status, _| result = status }
+    login
+    assert_equal :ok, result
+    assert @b.authenticated?
+  end
+
+  def test_login_with_token_failure
+    @req.stub(r: "login2", body: { "Success" => false, "Error" => "Token invalid" })
+    result = nil
+    @b.on_auth_change { |status, msg| result = [status, msg] }
+    @b.login_with_token(username: "user", token: "bad")
+
+    assert_equal :error, result[0]
+    refute @b.authenticated?
+  end
+
+  def test_token_test_success
+    login
+    result = nil
+    @b.on_auth_change { |status, _| result = status }
+    @b.token_test
+    assert_equal :ok, result
+  end
+
+  def test_token_test_failure
+    login
+    @req.stub(r: "login2", body: { "Success" => false, "Error" => "Token invalid" })
+    result = nil
+    @b.on_auth_change { |status, _| result = status }
+    @b.token_test
+    assert_equal :error, result
+    refute @b.authenticated?
+  end
+
+  def test_logout_clears_auth_state
+    login
+    @b.logout
+    refute @b.authenticated?
+    assert_empty @b.achievement_list
+  end
+
+  # ---------------------------------------------------------------------------
+  # Game load chain
+  # ---------------------------------------------------------------------------
+
+  def test_load_game_skipped_when_not_authenticated
+    load_game
+    assert_empty @b.achievement_list
+    refute @req.requested?("gameid"), "should not hit network when unauthenticated"
+  end
+
+  def test_load_game_populates_achievement_list
+    login
+    load_game
+
+    assert_equal 2, @b.total_count
+    assert_equal "101", @b.achievement_list[0].id
+    assert_equal "102", @b.achievement_list[1].id
+    assert_equal 2, @rt.count
+  end
+
+  def test_load_game_marks_preearned_achievements
+    login
+    load_game(earned_ids: [101])
+
+    list = @b.achievement_list
+    assert list.find { |a| a.id == "101" }&.earned?, "101 should be earned"
+    refute list.find { |a| a.id == "102" }&.earned?, "102 should not be earned"
+    assert_includes @rt.deactivated, "101"
+  end
+
+  def test_load_game_aborts_when_game_id_zero
+    login
+    @req.stub(r: "gameid", body: { "GameID" => 0 })
+    Dir.mktmpdir do |dir|
+      rom = File.join(dir, "test.gba")
+      File.write(rom, "FAKE")
+      @b.load_game(nil, rom, "deadbeef" * 4)
+    end
+
+    assert_empty @b.achievement_list
+    refute @req.requested?("patch"), "patch must not be requested when GameID is 0"
+  end
+
+  def test_load_game_activates_rich_presence_script
+    rp_patch = PATCH_RESPONSE.merge(
+      "PatchData" => PATCH_RESPONSE["PatchData"].merge("RichPresencePatch" => "Display: Hello")
+    )
+    login
+    load_game(patch: rp_patch)
+
+    assert_equal "Display: Hello", @rt.rp_script
+  end
+
+  def test_unload_game_clears_achievement_list
+    login
+    load_game
+    @b.unload_game
+    assert_empty @b.achievement_list
+  end
+
+  def test_sync_unlocks_repopulates_list
+    login
+    load_game
+
+    # Re-stub for the sync re-fetch
+    @req.stub(r: "patch",   body: PATCH_RESPONSE)
+    @req.stub(r: "unlocks", body: { "Success" => true, "UserUnlocks" => [102] })
+    @b.sync_unlocks
+
+    list = @b.achievement_list
+    refute list.find { |a| a.id == "101" }&.earned?
+    assert list.find { |a| a.id == "102" }&.earned?
+  end
+
+  # ---------------------------------------------------------------------------
+  # do_frame
+  # ---------------------------------------------------------------------------
+
+  def test_do_frame_silent_before_game_loaded
+    unlocked = []
+    @b.on_unlock { |a| unlocked << a }
+    @b.do_frame(FakeCore.new)
+    assert_empty unlocked
+  end
+
+  def test_do_frame_fires_unlock_and_submits_to_server
+    login
+    load_game
+
+    @req.stub(r: "awardachievement", body: { "Success" => true })
+    @rt.queue_triggers("101")
+
+    unlocked = []
+    @b.on_unlock { |a| unlocked << a }
+    @b.do_frame(FakeCore.new)
+
+    assert_equal 1, unlocked.size
+    assert_equal "101", unlocked.first.id
+    assert @req.requested?("awardachievement")
+    assert_equal "101", @req.requests_for("awardachievement").first[:a].to_s
+  end
+
+  def test_do_frame_skips_already_earned_achievement
+    login
+    load_game(earned_ids: [101])
+
+    @rt.queue_triggers("101")
+    unlocked = []
+    @b.on_unlock { |a| unlocked << a }
+    @b.do_frame(FakeCore.new)
+
+    assert_empty unlocked, "already-earned achievement must not fire again"
+    refute @req.requested?("awardachievement")
+  end
+
+  def test_do_frame_rich_presence_fires_callback_when_enabled
+    login
+    load_game
+
+    @rt.rp_message = "Playing Stage 1"
+    @b.rich_presence_enabled = true
+    @b.instance_variable_set(:@rp_eval_frame, 239)
+
+    fired = []
+    @b.on_rich_presence_changed { |m| fired << m }
+    @b.do_frame(FakeCore.new)
+
+    assert_equal ["Playing Stage 1"], fired
+    assert_equal "Playing Stage 1", @b.rich_presence_message
+  end
+
+  def test_do_frame_rich_presence_silent_when_disabled
+    login
+    load_game
+
+    @rt.rp_message = "Playing Stage 1"
+    @b.rich_presence_enabled = false
+    @b.instance_variable_set(:@rp_eval_frame, 239)
+
+    fired = []
+    @b.on_rich_presence_changed { |m| fired << m }
+    @b.do_frame(FakeCore.new)
+
+    assert_empty fired
+  end
+
+  # ---------------------------------------------------------------------------
+  # FakeRARuntime self-tests
+  # ---------------------------------------------------------------------------
+
+  def test_fake_runtime_activate_deactivate
+    @rt.activate("101", "0=1")
+    @rt.activate("102", "1=1")
+    assert_equal 2, @rt.count
+    @rt.deactivate("101")
+    assert_equal 1, @rt.count
+    refute @rt.activated.key?("101")
+  end
+
+  def test_fake_runtime_clear_resets_state
+    @rt.activate("101", "0=1")
+    @rt.queue_triggers("101")
+    @rt.clear
+    assert_equal 0, @rt.count
+    assert_empty @rt.do_frame(nil)
+  end
+
+  def test_fake_runtime_queue_consumed_once
+    @rt.queue_triggers("101")
+    assert_equal ["101"], @rt.do_frame(nil)
+    assert_empty @rt.do_frame(nil)
+  end
+end

data/test/test_ra_backend_unlock_gate.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "gemba/headless"
+require "gemba/achievements"
+require_relative "support/fake_core"
+
+# Tests that RetroAchievements::Backend never awards achievements before the
+# server's earned list is known.
+#
+# The bug scenario:
+#   fetch_patch_data completes → runtime activated with 89 achievements
+#   emulator starts → do_frame fires → some conditions true at frame 0
+#   @earned is empty (r=unlocks still in flight) → all are re-awarded
+#
+# The fix: @achievements stays empty until fetch_unlocks completes.
+# do_frame's `return if @achievements.empty?` guards the window by construction.
+#
+# These tests verify the fix through the public API (no instance_variable_set):
+# if @achievements is empty, do_frame must be silent regardless of what the
+# underlying runtime would report.
+class TestRABackendUnlockGate < Minitest::Test
+  def setup
+    @backend  = Gemba::Achievements::RetroAchievements::Backend.new(app: nil)
+    @unlocked = []
+    @backend.on_unlock { |ach| @unlocked << ach }
+    @core = FakeCore.new
+  end
+
+  # Before any game is loaded, @achievements is empty → do_frame is a no-op.
+  def test_do_frame_silent_before_game_loaded
+    @backend.do_frame(@core)
+    assert_empty @unlocked
+  end
+
+  # @achievements only becomes non-empty after fetch_unlocks completes (HTTP).
+  # Since we can't make real HTTP calls, verify the state via achievement_list
+  # and total_count — they reflect @achievements.
+  def test_achievements_empty_until_unlocks_arrive
+    assert_equal 0, @backend.total_count,
+      "achievement list must be empty before fetch_unlocks completes"
+    assert_empty @backend.achievement_list
+  end
+
+  # do_frame with an empty achievement list never fires unlock callbacks.
+  # This is the structural guarantee — as long as @achievements is empty,
+  # no award can happen even if the C runtime were somehow active.
+  def test_do_frame_never_fires_when_achievement_list_empty
+    # Simulate being "mid-load": patch data fetched but unlocks not yet back.
+    # In the new design @achievements stays [] during this window.
+    5.times { @backend.do_frame(@core) }
+    assert_empty @unlocked,
+      "no unlock must fire during the patch→unlocks window"
+    assert_equal 0, @backend.earned_count
+  end
+end

data/test/test_recorder.rb

@@ -7,9 +7,6 @@ require "tmpdir"
 class TestRecorder < 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
 
   def test_record_and_decode_round_trip
     skip "ffmpeg not installed" unless ffmpeg_available?

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