gemba 0.1.1 → 0.2.1

data/test/test_platform.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "gemba/headless"
+
+class TestPlatform < Minitest::Test
+  # -- Factory ---------------------------------------------------------------
+
+  def test_for_gba
+    core = MockCore.new("GBA")
+    platform = Gemba::Platform.for(core)
+    assert_instance_of Gemba::Platform::GBA, platform
+  end
+
+  def test_for_gb
+    core = MockCore.new("GB")
+    platform = Gemba::Platform.for(core)
+    assert_instance_of Gemba::Platform::GB, platform
+  end
+
+  def test_for_gbc
+    core = MockCore.new("GBC")
+    platform = Gemba::Platform.for(core)
+    assert_instance_of Gemba::Platform::GBC, platform
+  end
+
+  def test_for_unknown_defaults_to_gb
+    core = MockCore.new("Unknown")
+    platform = Gemba::Platform.for(core)
+    assert_instance_of Gemba::Platform::GB, platform
+  end
+
+  def test_default_is_gba
+    platform = Gemba::Platform.default
+    assert_instance_of Gemba::Platform::GBA, platform
+  end
+
+  # -- GBA -------------------------------------------------------------------
+
+  def test_gba_resolution
+    p = Gemba::Platform::GBA.new
+    assert_equal 240, p.width
+    assert_equal 160, p.height
+  end
+
+  def test_gba_fps
+    p = Gemba::Platform::GBA.new
+    assert_in_delta 59.7272, p.fps, 0.001
+  end
+
+  def test_gba_fps_fraction
+    num, den = Gemba::Platform::GBA.new.fps_fraction
+    assert_in_delta 59.7272, num.to_f / den, 0.001
+  end
+
+  def test_gba_aspect
+    assert_equal [3, 2], Gemba::Platform::GBA.new.aspect
+  end
+
+  def test_gba_name
+    assert_equal "Game Boy Advance", Gemba::Platform::GBA.new.name
+    assert_equal "GBA", Gemba::Platform::GBA.new.short_name
+  end
+
+  def test_gba_buttons_include_lr
+    buttons = Gemba::Platform::GBA.new.buttons
+    assert_includes buttons, :l
+    assert_includes buttons, :r
+    assert_equal 10, buttons.size
+  end
+
+  def test_gba_thumb_size
+    assert_equal [120, 80], Gemba::Platform::GBA.new.thumb_size
+  end
+
+  # -- GB --------------------------------------------------------------------
+
+  def test_gb_resolution
+    p = Gemba::Platform::GB.new
+    assert_equal 160, p.width
+    assert_equal 144, p.height
+  end
+
+  def test_gb_fps
+    assert_in_delta 59.7275, Gemba::Platform::GB.new.fps, 0.001
+  end
+
+  def test_gb_fps_fraction
+    num, den = Gemba::Platform::GB.new.fps_fraction
+    assert_in_delta 59.7275, num.to_f / den, 0.001
+  end
+
+  def test_gb_aspect
+    assert_equal [10, 9], Gemba::Platform::GB.new.aspect
+  end
+
+  def test_gb_name
+    assert_equal "Game Boy", Gemba::Platform::GB.new.name
+    assert_equal "GB", Gemba::Platform::GB.new.short_name
+  end
+
+  def test_gb_buttons_no_lr
+    buttons = Gemba::Platform::GB.new.buttons
+    refute_includes buttons, :l
+    refute_includes buttons, :r
+    assert_equal 8, buttons.size
+  end
+
+  def test_gb_thumb_size
+    assert_equal [80, 72], Gemba::Platform::GB.new.thumb_size
+  end
+
+  # -- GBC -------------------------------------------------------------------
+
+  def test_gbc_resolution_same_as_gb
+    p = Gemba::Platform::GBC.new
+    assert_equal 160, p.width
+    assert_equal 144, p.height
+  end
+
+  def test_gbc_name_differs_from_gb
+    assert_equal "Game Boy Color", Gemba::Platform::GBC.new.name
+    assert_equal "GBC", Gemba::Platform::GBC.new.short_name
+  end
+
+  def test_gbc_buttons_no_lr
+    buttons = Gemba::Platform::GBC.new.buttons
+    refute_includes buttons, :l
+    refute_includes buttons, :r
+  end
+
+  # -- Equality --------------------------------------------------------------
+
+  def test_same_platform_equal
+    assert_equal Gemba::Platform::GBA.new, Gemba::Platform::GBA.new
+    assert_equal Gemba::Platform::GB.new, Gemba::Platform::GB.new
+    assert_equal Gemba::Platform::GBC.new, Gemba::Platform::GBC.new
+  end
+
+  def test_different_platforms_not_equal
+    refute_equal Gemba::Platform::GBA.new, Gemba::Platform::GB.new
+    refute_equal Gemba::Platform::GBA.new, Gemba::Platform::GBC.new
+    refute_equal Gemba::Platform::GB.new, Gemba::Platform::GBC.new
+  end
+
+  private
+
+  MockCore = Struct.new(:platform)
+end

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_ra_backend_unlock_retry.rb

@@ -0,0 +1,123 @@
+# 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"
+
+# Tests for the unlock retry queue in RetroAchievements::Backend.
+#
+# FakeRequester fires on_progress synchronously so no event loop is needed.
+# For worker-style calls (drain_unlock_queue) it yields [ok, id] to match
+# what UnlockRetryWorker produces in production.
+class TestRABackendUnlockRetry < Minitest::Test
+  Backend = Gemba::Achievements::RetroAchievements::Backend
+
+  PATCH = {
+    "PatchData" => {
+      "RichPresencePatch" => "",
+      "Achievements" => [
+        { "ID" => 101, "Title" => "First Blood", "Description" => "Kill",
+          "Points" => 5, "MemAddr" => "0=1", "Flags" => 3 },
+        { "ID" => 102, "Title" => "Survivor", "Description" => "Survive",
+          "Points" => 10, "MemAddr" => "1=1", "Flags" => 3 },
+      ],
+    },
+  }.freeze
+
+  def setup
+    @rt  = FakeRARuntime.new
+    @req = FakeRequester.new
+    @b   = Backend.new(app: nil, runtime: @rt, requester: @req)
+  end
+
+  def login_and_load
+    @req.stub(r: "login2",  body: { "Success" => true })
+    @req.stub(r: "gameid",  body: { "GameID" => 42 })
+    @req.stub(r: "patch",   body: PATCH)
+    @req.stub(r: "unlocks", body: { "Success" => true, "UserUnlocks" => [] })
+    @b.login_with_token(username: "user", token: "tok")
+    Dir.mktmpdir do |dir|
+      rom = File.join(dir, "test.gba")
+      File.write(rom, "FAKEGBA")
+      @b.load_game(nil, rom, "deadbeef" * 4)
+    end
+  end
+
+  # -- Queue builds on initial failure ----------------------------------------
+
+  def test_failed_unlock_enqueues_for_retry
+    login_and_load
+    @req.stub(r: "awardachievement", ok: false, body: { "Success" => false })
+    @rt.queue_triggers("101")
+    @b.do_frame(FakeCore.new)
+    assert_equal 1, @b.unlock_queue.size
+    assert_equal "101", @b.unlock_queue.first[:id]
+  end
+
+  def test_successful_unlock_does_not_enqueue
+    login_and_load
+    @req.stub(r: "awardachievement", ok: true, body: { "Success" => true })
+    @rt.queue_triggers("101")
+    @b.do_frame(FakeCore.new)
+    assert_empty @b.unlock_queue
+  end
+
+  def test_multiple_failed_unlocks_all_enqueue
+    login_and_load
+    @req.stub(r: "awardachievement", ok: false, body: { "Success" => false })
+    @rt.queue_triggers("101", "102")
+    @b.do_frame(FakeCore.new)
+    assert_equal 2, @b.unlock_queue.size
+  end
+
+  # -- drain_unlock_queue -----------------------------------------------------
+
+  def test_drain_sends_retry_request_per_entry
+    login_and_load
+    @req.stub(r: "awardachievement", ok: true, body: { "Success" => true })
+    @b.unlock_queue << { id: "101", hardcore: false }
+    @b.unlock_queue << { id: "102", hardcore: false }
+    @b.drain_unlock_queue
+    assert_equal 2, @req.requests_for("awardachievement").size
+  end
+
+  def test_drain_clears_queue_on_success
+    login_and_load
+    @req.stub(r: "awardachievement", ok: true, body: { "Success" => true })
+    @b.unlock_queue << { id: "101", hardcore: false }
+    @b.drain_unlock_queue
+    assert_empty @b.unlock_queue
+  end
+
+  def test_drain_keeps_queue_on_failure
+    login_and_load
+    @req.stub(r: "awardachievement", ok: false, body: { "Success" => false })
+    @b.unlock_queue << { id: "101", hardcore: false }
+    @b.drain_unlock_queue
+    assert_equal 1, @b.unlock_queue.size
+  end
+
+  def test_drain_partial_success_removes_only_succeeded
+    login_and_load
+    @req.stub_queue(r: "awardachievement", ok: true,  body: { "Success" => true })
+    @req.stub_queue(r: "awardachievement", ok: false, body: { "Success" => false })
+    @b.unlock_queue << { id: "101", hardcore: false }
+    @b.unlock_queue << { id: "102", hardcore: false }
+    @b.drain_unlock_queue
+    assert_equal 1, @b.unlock_queue.size
+    assert_equal "102", @b.unlock_queue.first[:id]
+  end
+
+  # -- shutdown ---------------------------------------------------------------
+
+  def test_shutdown_logs_pending_and_does_not_raise
+    @b.unlock_queue << { id: "101", hardcore: false }
+    @b.shutdown
+  end
+
+  def test_shutdown_with_empty_queue_does_not_raise
+    @b.shutdown
+  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?