gemba 0.1.1 → 0.2.0

data/test/test_cli_sync_requester.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "webmock"
+require "gemba/headless"
+
+RA_URL = "https://retroachievements.org/dorequest.php" unless defined?(RA_URL)
+
+class TestCLISyncRequester < Minitest::Test
+  include WebMock::API
+
+  Requester = Gemba::Achievements::RetroAchievements::CliSyncRequester
+
+  def setup
+    WebMock.enable!
+    @req = Requester.new
+  end
+
+  def teardown
+    WebMock.reset!
+    WebMock.disable!
+  end
+
+  def stub_ra(body:, status: 200)
+    WebMock.stub_request(:post, RA_URL)
+      .to_return(status: status, body: body, headers: { "Content-Type" => "application/json" })
+  end
+
+  # -- Result interface -------------------------------------------------------
+
+  def test_result_on_progress_fires_synchronously
+    result = Requester::Result.new(["data", true])
+    received = nil
+    result.on_progress { |v| received = v }
+    assert_equal ["data", true], received
+  end
+
+  def test_result_on_progress_returns_self_for_chaining
+    r = Requester::Result.new(nil)
+    assert_same r, r.on_progress {}
+  end
+
+  def test_result_on_done_returns_self
+    r = Requester::Result.new(nil)
+    assert_same r, r.on_done {}
+  end
+
+  # -- Successful HTTP call ---------------------------------------------------
+
+  def test_success_returns_parsed_json_and_true
+    stub_ra(body: JSON.generate("Success" => true, "Token" => "abc"))
+
+    received = nil
+    @req.call(nil, { r: "login2", u: "user", p: "pass" })
+      .on_progress { |v| received = v }
+
+    assert_equal true,    received[1]
+    assert_equal true,    received[0]["Success"]
+    assert_equal "abc",   received[0]["Token"]
+  end
+
+  def test_posts_to_correct_url
+    stub_ra(body: JSON.generate("Success" => true))
+
+    @req.call(nil, { r: "gameid", m: "deadbeef" })
+      .on_progress {}
+
+    assert_requested :post, RA_URL
+  end
+
+  def test_sends_params_as_form_data
+    stub_ra(body: JSON.generate("GameID" => 42))
+
+    @req.call(nil, { r: "gameid", m: "abc123" })
+      .on_progress {}
+
+    assert_requested :post, RA_URL, body: "r=gameid&m=abc123"
+  end
+
+  def test_symbol_keys_stringified
+    stub_ra(body: JSON.generate("Success" => true))
+
+    @req.call(nil, { r: "ping", u: "user", t: "tok", g: 42, m: "Playing" })
+      .on_progress {}
+
+    assert_requested :post, RA_URL,
+      body: hash_including("r" => "ping", "u" => "user", "t" => "tok")
+  end
+
+  # -- HTTP error responses ---------------------------------------------------
+
+  def test_http_404_returns_nil_false
+    stub_ra(body: "Not Found", status: 404)
+
+    received = nil
+    @req.call(nil, { r: "gameid", m: "bad" })
+      .on_progress { |v| received = v }
+
+    assert_equal [nil, false], received
+  end
+
+  def test_http_500_returns_nil_false
+    stub_ra(body: "Internal Server Error", status: 500)
+
+    received = nil
+    @req.call(nil, { r: "patch", u: "u", t: "t", g: 1 })
+      .on_progress { |v| received = v }
+
+    assert_equal [nil, false], received
+  end
+
+  # -- Network errors ---------------------------------------------------------
+
+  def test_connection_error_returns_nil_false
+    WebMock.stub_request(:post, RA_URL).to_raise(Errno::ECONNREFUSED)
+
+    received = nil
+    _, stderr = capture_io do
+      @req.call(nil, { r: "login2" }).on_progress { |v| received = v }
+    end
+
+    assert_equal [nil, false], received
+    assert_match(/request error/i, stderr)
+  end
+
+  def test_timeout_returns_nil_false
+    WebMock.stub_request(:post, RA_URL).to_raise(Net::ReadTimeout)
+
+    received = nil
+    capture_io do
+      @req.call(nil, { r: "login2" }).on_progress { |v| received = v }
+    end
+
+    assert_equal [nil, false], received
+  end
+
+  # -- mode: and worker: kwargs are accepted but ignored ----------------------
+
+  def test_accepts_mode_kwarg
+    stub_ra(body: JSON.generate("ok" => true))
+    assert_silent do
+      @req.call(nil, { r: "ping" }, mode: :ractor).on_progress {}
+    end
+  end
+
+  def test_accepts_worker_kwarg
+    stub_ra(body: JSON.generate("ok" => true))
+    assert_silent do
+      @req.call(nil, { r: "ping" }, worker: Object.new).on_progress {}
+    end
+  end
+end

data/test/test_cli_version.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "gemba/headless"
+require "gemba/cli/commands/version"
+
+class TestCLIVersion < Minitest::Test
+  Version = Gemba::CLI::Commands::Version
+
+  def test_dry_run_returns_version
+    result = Version.new([], dry_run: true).call
+    assert_equal :version, result[:command]
+    assert_equal Gemba::VERSION, result[:version]
+  end
+
+  def test_prints_version
+    out = capture_io { Version.new([]).call }[0]
+    assert_includes out, "gemba"
+    assert_includes out, Gemba::VERSION
+  end
+
+  def test_dry_run_via_dispatch
+    result = Gemba::CLI.run(["version"], dry_run: true)
+    assert_equal :version, result[:command]
+    assert_equal Gemba::VERSION, result[:version]
+  end
+end

data/test/test_config.rb

@@ -3,8 +3,7 @@
 require "minitest/autorun"
 require "tmpdir"
 require "json"
-require_relative "../lib/gemba/config"
-require_relative "../lib/gemba/version"
+require "gemba/headless"
 
 class TestMGBAConfig < Minitest::Test
   def setup
@@ -747,7 +746,7 @@ class TestMGBAConfig < Minitest::Test
 
   def test_per_game_settings_constant_keys
     expected = %w[scale pixel_filter integer_scale color_correction frame_blending
-                  volume muted turbo_speed quick_save_slot save_state_backup]
+                  volume muted turbo_speed quick_save_slot save_state_backup ra_rich_presence]
     assert_equal expected.sort, Gemba::Config::PER_GAME_SETTINGS.keys.sort
   end
 

data/test/test_config_ra.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "tmpdir"
+require "gemba/headless"
+
+class TestConfigRA < Minitest::Test
+  def setup
+    @dir  = Dir.mktmpdir("gemba-ra-test")
+    @path = File.join(@dir, "settings.json")
+  end
+
+  def teardown
+    FileUtils.rm_rf(@dir)
+  end
+
+  def new_config
+    Gemba::Config.new(path: @path)
+  end
+
+  def test_defaults
+    c = new_config
+    refute c.ra_enabled?
+    assert_equal '', c.ra_username
+    assert_equal '', c.ra_token
+    refute c.ra_hardcore?
+  end
+
+  def test_enabled_setter
+    c = new_config
+    c.ra_enabled = true
+    assert c.ra_enabled?
+    c.ra_enabled = false
+    refute c.ra_enabled?
+  end
+
+  def test_username_setter
+    c = new_config
+    c.ra_username = 'alice'
+    assert_equal 'alice', c.ra_username
+  end
+
+  def test_token_setter
+    c = new_config
+    c.ra_token = 'abc123'
+    assert_equal 'abc123', c.ra_token
+  end
+
+  def test_hardcore_setter
+    c = new_config
+    c.ra_hardcore = true
+    assert c.ra_hardcore?
+  end
+
+  def test_persistence_roundtrip
+    c = new_config
+    c.ra_enabled  = true
+    c.ra_username = 'alice'
+    c.ra_token    = 'secret'
+    c.ra_hardcore = true
+    c.save!
+
+    c2 = new_config
+    assert c2.ra_enabled?
+    assert_equal 'alice',  c2.ra_username
+    assert_equal 'secret', c2.ra_token
+    assert c2.ra_hardcore?
+  end
+end

data/test/test_core.rb

@@ -10,7 +10,6 @@ class TestMGBACore < 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)
     @core = Gemba::Core.new(TEST_ROM)
   end
 
@@ -385,6 +384,68 @@ class TestMGBACore < Minitest::Test
     assert_raises(ArgumentError) { @core.rewind_init(-1) }
   end
 
+  # -- GB / GBC ROM loading ----------------------------------------------------
+
+  GB_ROM  = File.expand_path("fixtures/test.gb", __dir__)
+  GBC_ROM = File.expand_path("fixtures/test.gbc", __dir__)
+
+  def test_gb_rom_dimensions
+    core = Gemba::Core.new(GB_ROM)
+    assert_equal 160, core.width
+    assert_equal 144, core.height
+    assert_equal "GB", core.platform
+    core.destroy
+  end
+
+  def test_gb_rom_video_buffer_size
+    core = Gemba::Core.new(GB_ROM)
+    core.run_frame
+    buf = core.video_buffer_argb
+    assert_equal 160 * 144 * 4, buf.bytesize
+    core.destroy
+  end
+
+  def test_gb_rom_title
+    core = Gemba::Core.new(GB_ROM)
+    assert_equal "GEMBAGB", core.title
+    core.destroy
+  end
+
+  def test_gb_rom_runs_frames
+    core = Gemba::Core.new(GB_ROM)
+    10.times { core.run_frame }
+    assert_equal 160 * 144 * 4, core.video_buffer.bytesize
+    core.destroy
+  end
+
+  def test_gbc_rom_dimensions
+    core = Gemba::Core.new(GBC_ROM)
+    assert_equal 160, core.width
+    assert_equal 144, core.height
+    core.destroy
+  end
+
+  def test_gbc_rom_video_buffer_size
+    core = Gemba::Core.new(GBC_ROM)
+    core.run_frame
+    buf = core.video_buffer_argb
+    assert_equal 160 * 144 * 4, buf.bytesize
+    core.destroy
+  end
+
+  def test_gbc_rom_title
+    core = Gemba::Core.new(GBC_ROM)
+    assert_equal "GEMBAGBC", core.title
+    core.destroy
+  end
+
+  def test_gbc_rom_runs_frames
+    core = Gemba::Core.new(GBC_ROM)
+    10.times { core.run_frame }
+    assert_equal 160 * 144 * 4, core.video_buffer.bytesize
+    core.destroy
+  end
+
   # -- Error handling ----------------------------------------------------------
 
   def test_nonexistent_file

data/test/test_credentials_presenter.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "gemba/headless"
+
+class TestCredentialsPresenter < Minitest::Test
+  def setup
+    Gemba.bus = Gemba::EventBus.new
+    @config = Gemba::Config.new(path: nil)  # in-memory defaults
+  end
+
+  def presenter(**overrides)
+    cfg = @config
+    cfg.ra_enabled  = overrides.fetch(:enabled,  false)
+    cfg.ra_username = overrides.fetch(:username, '')
+    cfg.ra_token    = overrides.fetch(:token,    '')
+    Gemba::Achievements::CredentialsPresenter.new(cfg)
+  end
+
+  # -- Disabled state ----------------------------------------------------------
+
+  def test_disabled_everything_off
+    p = presenter(enabled: false)
+    assert_equal :disabled, p.fields_state
+    assert_equal :disabled, p.login_button_state
+    assert_equal :disabled, p.verify_button_state
+    assert_equal :disabled, p.logout_button_state
+    assert_equal :disabled, p.reset_button_state
+    assert_equal :empty,    p.feedback[:key]
+  end
+
+  # -- Enabled, not logged in --------------------------------------------------
+
+  def test_enabled_no_token_fields_editable
+    p = presenter(enabled: true)
+    assert_equal :normal, p.fields_state
+  end
+
+  def test_enabled_no_token_login_disabled_when_fields_empty
+    p = presenter(enabled: true)
+    assert_equal :disabled, p.login_button_state
+    assert_equal :disabled, p.verify_button_state
+  end
+
+  def test_enabled_login_enabled_when_fields_filled
+    p = presenter(enabled: true)
+    p.username = 'alice'
+    p.password = 'secret'
+    assert_equal :normal,   p.login_button_state
+    assert_equal :disabled, p.verify_button_state  # no token yet — verify stays disabled
+  end
+
+  def test_enabled_login_disabled_with_only_username
+    p = presenter(enabled: true)
+    p.username = 'alice'
+    assert_equal :disabled, p.login_button_state
+  end
+
+  def test_enabled_login_disabled_with_only_password
+    p = presenter(enabled: true)
+    p.password = 'secret'
+    assert_equal :disabled, p.login_button_state
+  end
+
+  def test_enabled_no_token_logout_and_reset_disabled
+    p = presenter(enabled: true)
+    assert_equal :disabled, p.logout_button_state
+    assert_equal :disabled, p.reset_button_state
+  end
+
+  def test_enabled_no_token_feedback_not_logged_in
+    p = presenter(enabled: true)
+    assert_equal :not_logged_in, p.feedback[:key]
+  end
+
+  # -- Enabled, logged in (token present) --------------------------------------
+
+  def test_logged_in_fields_disabled
+    p = presenter(enabled: true, username: 'alice', token: 'tok123')
+    assert_equal :readonly, p.fields_state
+  end
+
+  def test_logged_in_login_disabled
+    p = presenter(enabled: true, username: 'alice', token: 'tok123')
+    assert_equal :disabled, p.login_button_state
+  end
+
+  def test_logged_in_verify_enabled
+    p = presenter(enabled: true, username: 'alice', token: 'tok123')
+    assert_equal :normal, p.verify_button_state
+  end
+
+  def test_logged_in_logout_and_reset_enabled
+    p = presenter(enabled: true, username: 'alice', token: 'tok123')
+    assert_equal :normal, p.logout_button_state
+    assert_equal :normal, p.reset_button_state
+  end
+
+  def test_logged_in_feedback_shows_username
+    p = presenter(enabled: true, username: 'alice', token: 'tok123')
+    fb = p.feedback
+    assert_equal :logged_in_as, fb[:key]
+    assert_equal 'alice',       fb[:username]
+  end
+
+  # -- State mutations ----------------------------------------------------------
+
+  def test_enabling_clears_disabled_state
+    p = presenter(enabled: false)
+    assert_equal :disabled, p.fields_state
+    p.enabled = true
+    assert_equal :normal, p.fields_state
+  end
+
+  def test_credentials_changed_emitted_on_mutations
+    p = presenter(enabled: false)
+    fired = 0
+    Gemba.bus.on(:credentials_changed) { fired += 1 }
+    p.enabled  = true
+    p.username = 'alice'
+    p.password = 'pw'
+    assert_equal 3, fired
+  end
+
+  # -- Auth result handling (via :ra_auth_result bus events) -------------------
+
+  def auth(status, token: nil, message: nil)
+    Gemba.bus.emit(:ra_auth_result, status: status, token: token, message: message)
+  end
+
+  def test_login_success_stores_token_and_clears_password
+    p = presenter(enabled: true, username: 'alice')
+    p.password = 'pw'
+    auth(:ok, token: 'real_token')
+    assert_equal 'real_token', p.token
+    assert_equal '',           p.password
+    assert p.logged_in?
+  end
+
+  def test_login_success_locks_fields
+    p = presenter(enabled: true, username: 'alice')
+    auth(:ok, token: 'tok')
+    assert_equal :readonly, p.fields_state
+    assert_equal :normal,   p.logout_button_state
+    assert_equal :normal,   p.verify_button_state
+  end
+
+  def test_login_error_sets_feedback
+    p = presenter(enabled: true, username: 'alice')
+    auth(:error, message: 'Bad credentials')
+    assert_equal :error,            p.feedback[:key]
+    assert_equal 'Bad credentials', p.feedback[:message]
+  end
+
+  def test_login_error_does_not_affect_button_states
+    p = presenter(enabled: true, username: 'alice')
+    p.password = 'pw'
+    auth(:error, message: 'Bad credentials')
+    # Fields and login button should still be enabled
+    assert_equal :normal, p.fields_state
+    assert_equal :normal, p.login_button_state
+  end
+
+  def test_logout_clears_token_keeps_username
+    p = presenter(enabled: true, username: 'alice', token: 'tok')
+    auth(:logout)
+    assert_equal '',      p.token
+    assert_equal 'alice', p.username  # kept so user can re-enter password
+    refute p.logged_in?
+  end
+
+  def test_logout_re_enables_fields
+    p = presenter(enabled: true, username: 'alice', token: 'tok')
+    auth(:logout)
+    assert_equal :normal, p.fields_state
+  end
+
+  # -- Transient feedback -------------------------------------------------------
+
+  def test_transient_overrides_normal_feedback
+    p = presenter(enabled: true, username: 'alice', token: 'tok')
+    p.show_transient(:test_ok)
+    assert_equal :test_ok, p.feedback[:key]
+  end
+
+  def test_clear_transient_restores_normal_feedback
+    p = presenter(enabled: true, username: 'alice', token: 'tok')
+    p.show_transient(:test_ok)
+    p.clear_transient
+    assert_equal :logged_in_as, p.feedback[:key]
+  end
+end

data/test/test_event_bus.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "gemba/headless"
+
+class TestEventBus < Minitest::Test
+  def setup
+    @bus = Gemba::EventBus.new
+  end
+
+  def test_on_and_emit
+    received = nil
+    @bus.on(:ping) { |val| received = val }
+    @bus.emit(:ping, 42)
+    assert_equal 42, received
+  end
+
+  def test_emit_with_no_subscribers_is_noop
+    @bus.emit(:ghost, 1, 2, 3) # should not raise
+  end
+
+  def test_multiple_subscribers
+    results = []
+    @bus.on(:tick) { |v| results << "a:#{v}" }
+    @bus.on(:tick) { |v| results << "b:#{v}" }
+    @bus.emit(:tick, 7)
+    assert_equal ["a:7", "b:7"], results
+  end
+
+  def test_different_events_are_independent
+    a = nil
+    b = nil
+    @bus.on(:foo) { |v| a = v }
+    @bus.on(:bar) { |v| b = v }
+    @bus.emit(:foo, 1)
+    assert_equal 1, a
+    assert_nil b
+  end
+
+  def test_emit_multiple_args
+    received = nil
+    @bus.on(:multi) { |x, y| received = [x, y] }
+    @bus.emit(:multi, :a, :b)
+    assert_equal [:a, :b], received
+  end
+
+  def test_emit_with_kwargs
+    received = nil
+    @bus.on(:kw) { |name:, val:| received = { name: name, val: val } }
+    @bus.emit(:kw, name: "scale", val: 3)
+    assert_equal({ name: "scale", val: 3 }, received)
+  end
+
+  def test_off_removes_subscriber
+    received = []
+    block = @bus.on(:evt) { |v| received << v }
+    @bus.emit(:evt, 1)
+    @bus.off(:evt, block)
+    @bus.emit(:evt, 2)
+    assert_equal [1], received
+  end
+
+  def test_on_returns_block_for_later_off
+    block = @bus.on(:x) { }
+    assert_instance_of Proc, block
+  end
+
+  # -- Module-level accessor ------------------------------------------------
+
+  def test_gemba_bus_auto_creates
+    Gemba.bus = nil
+    bus = Gemba.bus
+    assert_instance_of Gemba::EventBus, bus
+  ensure
+    Gemba.bus = nil
+  end
+
+  def test_gemba_bus_setter
+    custom = Gemba::EventBus.new
+    Gemba.bus = custom
+    assert_same custom, Gemba.bus
+  ensure
+    Gemba.bus = nil
+  end
+
+  # -- BusEmitter mixin -----------------------------------------------------
+
+  def test_bus_emitter_emits_to_gemba_bus
+    Gemba.bus = @bus
+    klass = Class.new { include Gemba::BusEmitter; public :emit }
+    obj = klass.new
+
+    received = nil
+    @bus.on(:test_event) { |v| received = v }
+    obj.emit(:test_event, 99)
+    assert_equal 99, received
+  ensure
+    Gemba.bus = nil
+  end
+end