gemba 0.1.1 → 0.2.0

data/test/test_cli_decode.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "gemba/headless"
+require "gemba/cli/commands/decode"
+
+class TestCLIDecode < Minitest::Test
+  Decode = Gemba::CLI::Commands::Decode
+  # -- parse --
+
+  def test_grec_file
+    opts = dec(["recording.grec"]).parse
+    assert_equal "recording.grec", opts[:grec]
+  end
+
+  def test_output
+    opts = dec(["-o", "out.mkv", "recording.grec"]).parse
+    assert_equal "out.mkv", opts[:output]
+  end
+
+  def test_codecs
+    opts = dec(["--video-codec", "libx265", "--audio-codec", "opus", "r.grec"]).parse
+    assert_equal "libx265", opts[:video_codec]
+    assert_equal "opus", opts[:audio_codec]
+  end
+
+  def test_stats
+    opts = dec(["--stats", "recording.grec"]).parse
+    assert opts[:stats]
+    assert_equal "recording.grec", opts[:grec]
+  end
+
+  def test_list
+    opts = dec(["--list"]).parse
+    assert opts[:list]
+  end
+
+  def test_list_short
+    opts = dec(["-l"]).parse
+    assert opts[:list]
+  end
+
+  def test_no_progress
+    opts = dec(["--no-progress", "r.grec"]).parse
+    assert_equal false, opts[:progress]
+  end
+
+  def test_help
+    opts = dec(["--help"]).parse
+    assert opts[:help]
+  end
+
+  # -- dry_run via CLI.run dispatch --
+
+  def test_dry_run_no_args_lists
+    result = Gemba::CLI.run(["decode"], dry_run: true)
+    assert_equal :decode_list, result[:command]
+  end
+
+  def test_dry_run
+    result = Gemba::CLI.run(["decode", "recording.grec"], dry_run: true)
+    assert_equal :decode, result[:command]
+    assert_equal "recording.grec", result[:grec]
+    refute result[:stats]
+  end
+
+  def test_dry_run_stats
+    result = Gemba::CLI.run(["decode", "--stats", "recording.grec"], dry_run: true)
+    assert_equal :decode_stats, result[:command]
+    assert result[:stats]
+    assert_equal "recording.grec", result[:grec]
+  end
+
+  def test_dry_run_with_codecs
+    result = Gemba::CLI.run(["decode", "--video-codec", "libx265", "--audio-codec", "opus", "r.grec"], dry_run: true)
+    assert_equal :decode, result[:command]
+    assert_equal "libx265", result[:video_codec]
+    assert_equal "opus", result[:audio_codec]
+  end
+
+  def test_dry_run_list
+    result = Gemba::CLI.run(["decode", "--list"], dry_run: true)
+    assert_equal :decode_list, result[:command]
+  end
+
+  def test_dry_run_help
+    result = Gemba::CLI.run(["decode", "--help"], dry_run: true)
+    assert_equal :decode, result[:command]
+    assert result[:help]
+  end
+
+  private
+
+  def dec(argv)
+    Decode.new(argv)
+  end
+end

data/test/test_cli_patch.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "gemba/headless"
+require "gemba/cli/commands/patch"
+
+class TestCLIPatch < Minitest::Test
+  Patch = Gemba::CLI::Commands::Patch
+
+  # -- parse --
+
+  def test_rom_and_patch_args
+    opts = pat(["game.gba", "fix.ips"]).parse
+    assert_equal File.expand_path("game.gba"), opts[:rom]
+    assert_equal File.expand_path("fix.ips"),  opts[:patch]
+  end
+
+  def test_output_flag
+    opts = pat(["-o", "/tmp/out.gba", "game.gba", "fix.ips"]).parse
+    assert_equal File.expand_path("/tmp/out.gba"), opts[:output]
+  end
+
+  def test_help
+    assert pat(["--help"]).parse[:help]
+  end
+
+  def test_missing_args_returns_error
+    result = pat([]).call
+    assert_equal :patch, result[:command]
+    assert_equal :missing_args, result[:error]
+  end
+
+  # -- dry_run via CLI.run dispatch --
+
+  def test_dry_run
+    result = Gemba::CLI.run(["patch", "game.gba", "fix.ips"], dry_run: true)
+    assert_equal :patch, result[:command]
+    assert_equal File.expand_path("game.gba"), result[:rom]
+    assert_equal File.expand_path("fix.ips"),  result[:patch]
+  end
+
+  def test_dry_run_default_out_path
+    result = Gemba::CLI.run(["patch", "game.gba", "fix.ips"], dry_run: true)
+    assert_match(/-patched\.gba\z/, result[:out])
+  end
+
+  def test_dry_run_help
+    result = Gemba::CLI.run(["patch", "--help"], dry_run: true)
+    assert_equal :patch, result[:command]
+    assert result[:help]
+  end
+
+  private
+
+  def pat(argv)
+    Patch.new(argv)
+  end
+end

data/test/test_cli_play.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "gemba/headless"
+require "gemba/cli/commands/play"
+
+class TestCLIPlay < Minitest::Test
+  Play = Gemba::CLI::Commands::Play
+  # -- ROM argument --
+
+  def test_rom_path
+    assert_equal File.expand_path("game.gba"), play(["game.gba"]).parse[:rom]
+  end
+
+  def test_rom_path_expands_tilde
+    assert_equal File.join(Dir.home, "game.gba"), play(["~/game.gba"]).parse[:rom]
+  end
+
+  def test_no_rom
+    assert_nil play([]).parse[:rom]
+  end
+
+  # -- flags --
+
+  def test_scale
+    assert_equal 2, play(["--scale", "2"]).parse[:scale]
+  end
+
+  def test_scale_short
+    assert_equal 3, play(["-s", "3"]).parse[:scale]
+  end
+
+  def test_scale_clamps_high
+    assert_equal 4, play(["--scale", "10"]).parse[:scale]
+  end
+
+  def test_scale_clamps_low
+    assert_equal 1, play(["--scale", "0"]).parse[:scale]
+  end
+
+  def test_volume
+    assert_equal 50, play(["--volume", "50"]).parse[:volume]
+  end
+
+  def test_volume_short
+    assert_equal 75, play(["-v", "75"]).parse[:volume]
+  end
+
+  def test_volume_clamps
+    assert_equal 100, play(["--volume", "200"]).parse[:volume]
+  end
+
+  def test_mute
+    assert play(["--mute"]).parse[:mute]
+  end
+
+  def test_mute_short
+    assert play(["-m"]).parse[:mute]
+  end
+
+  def test_no_sound
+    assert_equal false, play(["--no-sound"]).parse[:sound]
+  end
+
+  def test_fullscreen
+    assert play(["--fullscreen"]).parse[:fullscreen]
+  end
+
+  def test_fullscreen_short
+    assert play(["-f"]).parse[:fullscreen]
+  end
+
+  def test_show_fps
+    assert play(["--show-fps"]).parse[:show_fps]
+  end
+
+  def test_turbo_speed
+    assert_equal 3, play(["--turbo-speed", "3"]).parse[:turbo_speed]
+  end
+
+  def test_turbo_speed_clamps
+    assert_equal 4, play(["--turbo-speed", "99"]).parse[:turbo_speed]
+  end
+
+  def test_locale
+    assert_equal "ja", play(["--locale", "ja"]).parse[:locale]
+  end
+
+  def test_help_flag
+    assert play(["--help"]).parse[:help]
+  end
+
+  def test_flags_with_rom
+    opts = play(["-s", "2", "--mute", "pokemon.gba"]).parse
+    assert_equal 2, opts[:scale]
+    assert opts[:mute]
+    assert_equal File.expand_path("pokemon.gba"), opts[:rom]
+  end
+
+  def test_rom_before_flags
+    opts = play(["game.gba", "--scale", "4"]).parse
+    assert_equal File.expand_path("game.gba"), opts[:rom]
+    assert_equal 4, opts[:scale]
+  end
+
+  def test_parser_present
+    assert_kind_of OptionParser, play([]).parse[:parser]
+  end
+
+  def test_help_output_includes_banner
+    assert_includes play([]).parse[:parser].to_s, "Usage: gemba"
+  end
+
+  # -- apply --
+
+  class MockConfig
+    attr_accessor :scale, :volume, :muted, :show_fps, :turbo_speed, :locale
+
+    def initialize
+      @scale = 3
+      @volume = 100
+      @muted = false
+      @show_fps = false
+      @turbo_speed = 0
+      @locale = 'auto'
+    end
+  end
+
+  def test_apply_overrides_config
+    config = MockConfig.new
+    play([]).apply(config, { scale: 2, volume: 50, mute: true, show_fps: true })
+    assert_equal 2, config.scale
+    assert_equal 50, config.volume
+    assert config.muted
+    assert config.show_fps
+  end
+
+  def test_apply_skips_unset_options
+    config = MockConfig.new
+    play([]).apply(config, {})
+    assert_equal 3, config.scale
+    assert_equal 100, config.volume
+    refute config.muted
+  end
+
+  def test_apply_locale
+    config = MockConfig.new
+    play([]).apply(config, { locale: 'ja' })
+    assert_equal 'ja', config.locale
+  end
+
+  def test_apply_turbo_speed
+    config = MockConfig.new
+    play([]).apply(config, { turbo_speed: 3 })
+    assert_equal 3, config.turbo_speed
+  end
+
+  # -- dry_run via CLI.run dispatch --
+
+  def test_dry_run_no_args
+    result = Gemba::CLI.run([], dry_run: true)
+    assert_equal :play, result[:command]
+    assert_nil result[:rom]
+    assert_equal true, result[:sound]
+  end
+
+  def test_dry_run_with_rom
+    result = Gemba::CLI.run(["game.gba"], dry_run: true)
+    assert_equal :play, result[:command]
+    assert_equal File.expand_path("game.gba"), result[:rom]
+  end
+
+  def test_dry_run_explicit_play
+    result = Gemba::CLI.run(["play", "-s", "2", "game.gba"], dry_run: true)
+    assert_equal :play, result[:command]
+    assert_equal File.expand_path("game.gba"), result[:rom]
+    assert_equal 2, result[:options][:scale]
+  end
+
+  def test_dry_run_no_sound
+    result = Gemba::CLI.run(["--no-sound", "game.gba"], dry_run: true)
+    assert_equal :play, result[:command]
+    assert_equal false, result[:sound]
+  end
+
+  def test_dry_run_fullscreen
+    result = Gemba::CLI.run(["-f", "game.gba"], dry_run: true)
+    assert_equal :play, result[:command]
+    assert_equal true, result[:fullscreen]
+  end
+
+  def test_dry_run_help
+    result = Gemba::CLI.run(["play", "--help"], dry_run: true)
+    assert_equal :play, result[:command]
+    assert result[:help]
+  end
+
+  # -- error cases --
+
+  def test_unknown_flag_raises
+    assert_raises(OptionParser::InvalidOption) { play(["--bogus"]).parse }
+  end
+
+  def test_missing_scale_value_raises
+    assert_raises(OptionParser::MissingArgument) { play(["--scale"]).parse }
+  end
+
+  private
+
+  def play(argv)
+    Play.new(argv)
+  end
+end

data/test/test_cli_ra.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "tmpdir"
+require "gemba/headless"
+require "gemba/cli/commands/retro_achievements"
+require_relative "support/fake_requester"
+
+# Tests for the `gemba ra` CLI subcommand.
+#
+# All tests use:
+#   - FakeRequester   so no real HTTP calls are made
+#   - A temp Config   so real credentials on disk are never read or written
+class TestCLIRa < Minitest::Test
+  RA = Gemba::CLI::Commands::RetroAchievements
+
+  def setup
+    @tmpdir = Dir.mktmpdir("gemba_cli_ra_test")
+    @config = Gemba::Config.new(path: File.join(@tmpdir, "settings.json"))
+    @req    = FakeRequester.new
+  end
+
+  def teardown
+    FileUtils.rm_rf(@tmpdir)
+  end
+
+  def run_ra(argv, dry_run: false)
+    RA.new(argv, dry_run: dry_run, config: @config, requester: @req).call
+  end
+
+  # ---------------------------------------------------------------------------
+  # parse / dry_run
+  # ---------------------------------------------------------------------------
+
+  def test_parse_login_returns_subcommand_and_username
+    result = run_ra(["login", "--username", "bob"], dry_run: true)
+    assert_equal :ra_login, result[:command]
+    assert_equal :login,    result[:subcommand]
+    assert_equal "bob",     result[:username]
+  end
+
+  def test_parse_login_captures_password
+    result = run_ra(["login", "--username", "bob", "--password", "s3cr3t"], dry_run: true)
+    assert_equal "s3cr3t", result[:password]
+  end
+
+  def test_parse_verify_returns_subcommand
+    result = run_ra(["verify"], dry_run: true)
+    assert_equal :ra_verify, result[:command]
+  end
+
+  def test_parse_logout_returns_subcommand
+    result = run_ra(["logout"], dry_run: true)
+    assert_equal :ra_logout, result[:command]
+  end
+
+  def test_parse_achievements_captures_rom_and_json
+    result = run_ra(["achievements", "--rom", "/tmp/game.gba", "--json"], dry_run: true)
+    assert_equal :ra_achievements, result[:command]
+    assert_equal File.expand_path("/tmp/game.gba"), result[:rom]
+    assert result[:json]
+  end
+
+  def test_parse_no_subcommand_returns_help
+    result = run_ra([], dry_run: true)
+    assert_equal :ra, result[:command]
+    assert result[:help]
+  end
+
+  def test_parse_unknown_subcommand_returns_help
+    result = run_ra(["frobnicate"], dry_run: true)
+    assert result[:help]
+  end
+
+  # ---------------------------------------------------------------------------
+  # ra login
+  # ---------------------------------------------------------------------------
+
+  def test_login_success_saves_credentials
+    @req.stub(r: "login2", body: { "Success" => true, "Token" => "tok123" })
+
+    out, = capture_io do
+      run_ra(["login", "--username", "bob", "--password", "pass"])
+    end
+
+    assert_match(/logged in as bob/i, out)
+    assert_equal "bob",    @config.ra_username
+    assert_equal "tok123", @config.ra_token
+    assert @config.ra_enabled?
+
+    # Verify persisted to disk
+    reloaded = Gemba::Config.new(path: @config.instance_variable_get(:@path))
+    assert_equal "bob",    reloaded.ra_username
+    assert_equal "tok123", reloaded.ra_token
+  end
+
+  def test_login_failure_prints_error_and_exits
+    @req.stub(r: "login2", body: { "Success" => false, "Error" => "Bad password" }, ok: false)
+
+    assert_raises(SystemExit) do
+      capture_io { run_ra(["login", "--username", "bob", "--password", "wrong"]) }
+    end
+
+    assert_empty @config.ra_username, "credentials must not be saved on failure"
+  end
+
+  def test_login_missing_username_exits
+    assert_raises(SystemExit) do
+      capture_io { run_ra(["login", "--password", "pass"]) }
+    end
+  end
+
+  def test_login_posts_to_login2
+    @req.stub(r: "login2", body: { "Success" => true, "Token" => "t" })
+    capture_io { run_ra(["login", "--username", "bob", "--password", "p"]) }
+    assert @req.requested?("login2")
+    assert_equal "bob", @req.requests_for("login2").first[:u]
+  end
+
+  # ---------------------------------------------------------------------------
+  # ra verify
+  # ---------------------------------------------------------------------------
+
+  def test_verify_success_prints_ok
+    @config.ra_username = "bob"
+    @config.ra_token    = "tok"
+    @req.stub(r: "login2", body: { "Success" => true })
+
+    out, = capture_io { run_ra(["verify"]) }
+    assert_match(/token valid for bob/i, out)
+  end
+
+  def test_verify_failure_exits
+    @config.ra_username = "bob"
+    @config.ra_token    = "bad"
+    @req.stub(r: "login2", body: { "Success" => false, "Error" => "Token invalid" }, ok: false)
+
+    assert_raises(SystemExit) do
+      capture_io { run_ra(["verify"]) }
+    end
+  end
+
+  def test_verify_not_logged_in_exits
+    assert_raises(SystemExit) do
+      capture_io { run_ra(["verify"]) }
+    end
+  end
+
+  # ---------------------------------------------------------------------------
+  # ra logout
+  # ---------------------------------------------------------------------------
+
+  def test_logout_clears_credentials
+    @config.ra_username = "bob"
+    @config.ra_token    = "tok"
+    @config.ra_enabled  = true
+    @config.save!
+
+    out, = capture_io { run_ra(["logout"]) }
+
+    assert_match(/logged out/i, out)
+    assert_empty @config.ra_username
+    assert_empty @config.ra_token
+    refute @config.ra_enabled?
+
+    reloaded = Gemba::Config.new(path: @config.instance_variable_get(:@path))
+    assert_empty reloaded.ra_username
+    assert_empty reloaded.ra_token
+  end
+
+  def test_logout_makes_no_http_requests
+    capture_io { run_ra(["logout"]) }
+    assert_empty @req.requests
+  end
+end

data/test/test_cli_record.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "gemba/headless"
+require "gemba/cli/commands/record"
+
+class TestCLIRecord < Minitest::Test
+  Record = Gemba::CLI::Commands::Record
+  # -- parse --
+
+  def test_frames_and_rom
+    opts = rec(["--frames", "100", "game.gba"]).parse
+    assert_equal 100, opts[:frames]
+    assert_equal File.expand_path("game.gba"), opts[:rom]
+  end
+
+  def test_output
+    opts = rec(["-o", "out.grec", "--frames", "10", "game.gba"]).parse
+    assert_equal "out.grec", opts[:output]
+  end
+
+  def test_compression
+    opts = rec(["-c", "6", "--frames", "10", "game.gba"]).parse
+    assert_equal 6, opts[:compression]
+  end
+
+  def test_compression_clamps
+    opts = rec(["--compression", "99", "--frames", "10", "game.gba"]).parse
+    assert_equal 9, opts[:compression]
+  end
+
+  def test_progress_flag
+    opts = rec(["--progress", "--frames", "10", "game.gba"]).parse
+    assert opts[:progress]
+  end
+
+  def test_help
+    opts = rec(["--help"]).parse
+    assert opts[:help]
+  end
+
+  # -- dry_run via CLI.run dispatch --
+
+  def test_dry_run
+    result = Gemba::CLI.run(["record", "--frames", "100", "game.gba"], dry_run: true)
+    assert_equal :record, result[:command]
+    assert_equal File.expand_path("game.gba"), result[:rom]
+    assert_equal 100, result[:frames]
+  end
+
+  def test_dry_run_with_output
+    result = Gemba::CLI.run(["record", "--frames", "50", "-o", "out.grec", "game.gba"], dry_run: true)
+    assert_equal :record, result[:command]
+    assert_equal "out.grec", result[:output]
+    assert_equal 50, result[:frames]
+  end
+
+  def test_dry_run_help
+    result = Gemba::CLI.run(["record", "--help"], dry_run: true)
+    assert_equal :record, result[:command]
+    assert result[:help]
+  end
+
+  private
+
+  def rec(argv)
+    Record.new(argv)
+  end
+end

data/test/test_cli_replay.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "gemba/headless"
+require "gemba/cli/commands/replay"
+
+class TestCLIReplay < Minitest::Test
+  Replay = Gemba::CLI::Commands::Replay
+  # -- parse --
+
+  def test_gir_file
+    opts = rep(["session.gir"]).parse
+    assert_equal "session.gir", opts[:gir]
+  end
+
+  def test_headless
+    opts = rep(["--headless", "session.gir"]).parse
+    assert opts[:headless]
+  end
+
+  def test_list
+    opts = rep(["--list"]).parse
+    assert opts[:list]
+  end
+
+  def test_fullscreen
+    opts = rep(["-f", "session.gir"]).parse
+    assert opts[:fullscreen]
+  end
+
+  def test_no_sound
+    opts = rep(["--no-sound", "session.gir"]).parse
+    assert_equal false, opts[:sound]
+  end
+
+  def test_help
+    opts = rep(["--help"]).parse
+    assert opts[:help]
+  end
+
+  # -- dry_run via CLI.run dispatch --
+
+  def test_dry_run
+    result = Gemba::CLI.run(["replay", "session.gir"], dry_run: true)
+    assert_equal :replay, result[:command]
+    assert_equal File.expand_path("session.gir"), result[:gir]
+    assert_equal true, result[:sound]
+  end
+
+  def test_dry_run_headless
+    result = Gemba::CLI.run(["replay", "--headless", "session.gir"], dry_run: true)
+    assert_equal :replay_headless, result[:command]
+    assert result[:headless]
+  end
+
+  def test_dry_run_list
+    result = Gemba::CLI.run(["replay", "--list"], dry_run: true)
+    assert_equal :replay_list, result[:command]
+  end
+
+  def test_dry_run_help
+    result = Gemba::CLI.run(["replay", "--help"], dry_run: true)
+    assert_equal :replay, result[:command]
+    assert result[:help]
+  end
+
+  private
+
+  def rep(argv)
+    Replay.new(argv)
+  end
+end