gemba 0.1.0

data/test/test_recorder.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "gemba/headless"
+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?
+
+    Dir.mktmpdir do |dir|
+      trec_path = File.join(dir, "test.grec")
+      output_path = File.join(dir, "test.mp4")
+      frames = 10
+
+      # Record
+      Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+        player.start_recording(trec_path)
+        player.step(frames)
+        player.stop_recording
+      end
+
+      assert File.exist?(trec_path)
+      assert_operator File.size(trec_path), :>, 32 # at least header
+
+      # Decode → encode
+      info = Gemba::RecorderDecoder.decode(trec_path, output_path)
+
+      assert_equal 240, info[:width]
+      assert_equal 160, info[:height]
+      assert_equal frames, info[:frame_count]
+      assert_in_delta 59.7272, info[:fps], 0.01
+      assert_equal 44100, info[:audio_rate]
+      assert_equal 2, info[:audio_channels]
+
+      # Output video file should exist and have data
+      assert File.exist?(output_path)
+      assert_operator File.size(output_path), :>, 0
+    end
+  end
+
+  def test_decode_without_ffmpeg_raises
+    Dir.mktmpdir do |dir|
+      trec_path = File.join(dir, "test.grec")
+
+      Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+        player.start_recording(trec_path)
+        player.step(1)
+        player.stop_recording
+      end
+
+      output_path = File.join(dir, "test.mp4")
+      with_empty_path do
+        assert_raises(Gemba::RecorderDecoder::FfmpegNotFound) do
+          Gemba::RecorderDecoder.decode(trec_path, output_path)
+        end
+      end
+    end
+  end
+
+  def test_delta_compression_reduces_size
+    Dir.mktmpdir do |dir|
+      trec_path = File.join(dir, "test.grec")
+
+      Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+        player.start_recording(trec_path)
+        player.step(30)
+        player.stop_recording
+      end
+
+      trec_size = File.size(trec_path)
+      raw_size = 240 * 160 * 4 * 30 # ~4.6MB uncompressed video alone
+      assert_operator trec_size, :<, raw_size, "Compressed .grec should be smaller than raw"
+    end
+  end
+
+  def test_recording_state
+    Dir.mktmpdir do |dir|
+      trec_path = File.join(dir, "test.grec")
+
+      Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+        refute player.recording?
+        player.start_recording(trec_path)
+        assert player.recording?
+        player.step(5)
+        player.stop_recording
+        refute player.recording?
+      end
+    end
+  end
+
+  def test_close_stops_recording
+    Dir.mktmpdir do |dir|
+      trec_path = File.join(dir, "test.grec")
+
+      player = Gemba::HeadlessPlayer.new(TEST_ROM)
+      player.start_recording(trec_path)
+      player.step(5)
+      player.close # should stop recording gracefully
+
+      assert File.exist?(trec_path)
+      assert_operator File.size(trec_path), :>, 32
+    end
+  end
+
+  def test_double_start_raises
+    Dir.mktmpdir do |dir|
+      Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+        player.start_recording(File.join(dir, "a.grec"))
+        assert_raises(RuntimeError) do
+          player.start_recording(File.join(dir, "b.grec"))
+        end
+        player.stop_recording
+      end
+    end
+  end
+
+  def test_header_format
+    Dir.mktmpdir do |dir|
+      trec_path = File.join(dir, "test.grec")
+
+      Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+        player.start_recording(trec_path)
+        player.step(1)
+        player.stop_recording
+      end
+
+      File.open(trec_path, 'rb') do |f|
+        header = f.read(32)
+        assert_equal "GEMBAREC", header[0, 8]
+        assert_equal 1, header[8].unpack1('C') # version
+        w, h = header[9, 4].unpack('v2')
+        assert_equal 240, w
+        assert_equal 160, h
+      end
+    end
+  end
+
+  def test_footer_present
+    Dir.mktmpdir do |dir|
+      trec_path = File.join(dir, "test.grec")
+
+      Gemba::HeadlessPlayer.open(TEST_ROM) do |player|
+        player.start_recording(trec_path)
+        player.step(5)
+        player.stop_recording
+      end
+
+      File.open(trec_path, 'rb') do |f|
+        f.seek(-8, IO::SEEK_END)
+        footer = f.read(8)
+        frame_count, magic = footer.unpack('Va4')
+        assert_equal 5, frame_count
+        assert_equal "GEND", magic
+      end
+    end
+  end
+
+  private
+
+  def ffmpeg_available?
+    system('ffmpeg', '-version', out: File::NULL, err: File::NULL)
+  rescue Errno::ENOENT
+    false
+  end
+
+  def with_empty_path
+    old_path = ENV['PATH']
+    ENV['PATH'] = ''
+    yield
+  ensure
+    ENV['PATH'] = old_path
+  end
+end

data/test/test_rom_loader.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "gemba"
+require "tmpdir"
+require "zip"
+
+class TestRomLoader < 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)
+    @tmpdir = Dir.mktmpdir("rom_loader_test")
+  end
+
+  def teardown
+    FileUtils.rm_rf(@tmpdir) if @tmpdir && File.directory?(@tmpdir)
+    Gemba::RomLoader.cleanup_temp
+  end
+
+  # -- resolve passthrough --
+
+  def test_resolve_gba_returns_path_unchanged
+    assert_equal TEST_ROM, Gemba::RomLoader.resolve(TEST_ROM)
+  end
+
+  def test_resolve_gb_returns_path_unchanged
+    path = "/some/game.gb"
+    assert_equal path, Gemba::RomLoader.resolve(path)
+  end
+
+  def test_resolve_gbc_returns_path_unchanged
+    path = "/some/game.gbc"
+    assert_equal path, Gemba::RomLoader.resolve(path)
+  end
+
+  # -- resolve from zip --
+
+  def test_resolve_zip_extracts_rom
+    zip_path = create_zip("game.zip", "game.gba" => File.binread(TEST_ROM))
+    result = Gemba::RomLoader.resolve(zip_path)
+
+    assert File.exist?(result), "extracted ROM should exist"
+    assert_equal ".gba", File.extname(result).downcase
+    assert_equal File.binread(TEST_ROM), File.binread(result)
+  end
+
+  def test_resolve_zip_loads_in_core
+    zip_path = create_zip("game.zip", "game.gba" => File.binread(TEST_ROM))
+    rom_path = Gemba::RomLoader.resolve(zip_path)
+
+    core = Gemba::Core.new(rom_path)
+    assert_equal "GEMBATEST", core.title
+  ensure
+    core&.destroy
+  end
+
+  # -- error cases --
+
+  def test_resolve_zip_no_rom_raises
+    zip_path = create_zip("empty.zip", "readme.txt" => "hello")
+
+    err = assert_raises(Gemba::RomLoader::NoRomInZip) do
+      Gemba::RomLoader.resolve(zip_path)
+    end
+    assert_includes err.message, "empty.zip"
+  end
+
+  def test_resolve_zip_multiple_roms_raises
+    rom_data = File.binread(TEST_ROM)
+    zip_path = create_zip("multi.zip",
+      "game1.gba" => rom_data,
+      "game2.gba" => rom_data)
+
+    err = assert_raises(Gemba::RomLoader::MultipleRomsInZip) do
+      Gemba::RomLoader.resolve(zip_path)
+    end
+    assert_includes err.message, "multi.zip"
+  end
+
+  def test_resolve_unsupported_extension_raises
+    assert_raises(Gemba::RomLoader::UnsupportedFormat) do
+      Gemba::RomLoader.resolve("/some/file.rar")
+    end
+  end
+
+  def test_resolve_corrupt_zip_raises
+    corrupt = File.join(@tmpdir, "corrupt.zip")
+    File.binwrite(corrupt, "this is not a zip file")
+
+    assert_raises(Gemba::RomLoader::ZipReadError) do
+      Gemba::RomLoader.resolve(corrupt)
+    end
+  end
+
+  # -- zip with subdirectories (only root-level ROMs) --
+
+  def test_resolve_zip_ignores_roms_in_subdirectories
+    zip_path = File.join(@tmpdir, "nested.zip")
+    Zip::OutputStream.open(zip_path) do |zos|
+      zos.put_next_entry("subdir/game.gba")
+      zos.write(File.binread(TEST_ROM))
+    end
+
+    assert_raises(Gemba::RomLoader::NoRomInZip) do
+      Gemba::RomLoader.resolve(zip_path)
+    end
+  end
+
+  # -- constants --
+
+  def test_rom_extensions
+    assert_includes Gemba::RomLoader::ROM_EXTENSIONS, ".gba"
+    assert_includes Gemba::RomLoader::ROM_EXTENSIONS, ".gb"
+    assert_includes Gemba::RomLoader::ROM_EXTENSIONS, ".gbc"
+  end
+
+  def test_supported_extensions_includes_zip
+    assert_includes Gemba::RomLoader::SUPPORTED_EXTENSIONS, ".zip"
+  end
+
+  # -- cleanup --
+
+  def test_cleanup_temp_removes_directory
+    zip_path = create_zip("game.zip", "game.gba" => File.binread(TEST_ROM))
+    Gemba::RomLoader.resolve(zip_path)
+    assert File.directory?(Gemba::RomLoader.tmp_dir)
+
+    Gemba::RomLoader.cleanup_temp
+    refute File.directory?(Gemba::RomLoader.tmp_dir)
+  end
+
+  private
+
+  # Build a ZIP file using rubyzip.
+  # @param name [String] output filename
+  # @param entries [Hash{String => String}] filename => content
+  # @return [String] path to the created ZIP file
+  def create_zip(name, entries)
+    path = File.join(@tmpdir, name)
+    Zip::OutputStream.open(path) do |zos|
+      entries.each do |fname, content|
+        zos.put_next_entry(fname)
+        zos.write(content)
+      end
+    end
+    path
+  end
+end

data/test/test_save_state_manager.rb

@@ -0,0 +1,289 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "tmpdir"
+require "json"
+require_relative "../lib/gemba/config"
+require_relative "../lib/gemba/locale"
+require_relative "../lib/gemba/save_state_manager"
+
+class TestSaveStateManager < Minitest::Test
+  # Recording mock for the mGBA Core.
+  # Responds to the duck-type interface SaveStateManager needs and
+  # records every call for test assertions.
+  class MockCore
+    attr_reader :calls
+    attr_accessor :game_code, :checksum, :destroyed, :save_result, :load_result
+
+    def initialize(game_code: "AGB-BGBE", checksum: 0xDEADBEEF)
+      @calls = []
+      @game_code = game_code
+      @checksum = checksum
+      @destroyed = false
+      @save_result = true
+      @load_result = true
+    end
+
+    def destroyed?
+      @destroyed
+    end
+
+    def save_state_to_file(path)
+      @calls << [:save_state_to_file, path]
+      File.write(path, "STATE") if @save_result
+      @save_result
+    end
+
+    def load_state_from_file(path)
+      @calls << [:load_state_from_file, path]
+      @load_result
+    end
+
+    def video_buffer_argb
+      @calls << [:video_buffer_argb]
+      "\x00".b * (240 * 160 * 4)
+    end
+  end
+
+  # Recording mock for Tk's Tcl interpreter (provides photo_put_block).
+  class MockInterp
+    attr_reader :calls
+
+    def initialize
+      @calls = []
+    end
+
+    def photo_put_block(name, pixels, w, h, format:)
+      @calls << [:photo_put_block, name, w, h, format]
+    end
+  end
+
+  # Recording mock for the Teek::App.
+  # Records command() calls and exposes a mock interp.
+  class MockApp
+    attr_reader :calls, :interp
+
+    def initialize
+      @calls = []
+      @interp = MockInterp.new
+    end
+
+    def command(*args, **kwargs)
+      @calls << [args, kwargs]
+      nil
+    end
+  end
+
+  def setup
+    @dir = Dir.mktmpdir("gemba-ssm-test")
+    @config_path = File.join(@dir, "settings.json")
+    @config = Gemba::Config.new(path: @config_path)
+    @config.save_state_debounce = 0  # disable debounce for tests
+    @states_dir = File.join(@dir, "states")
+    @config.states_dir = @states_dir
+
+    @core = MockCore.new
+    @app = MockApp.new
+    @mgr = new_manager
+  end
+
+  def teardown
+    FileUtils.rm_rf(@dir)
+  end
+
+  def new_manager(core: @core, config: @config, app: @app)
+    mgr = Gemba::SaveStateManager.new(core: core, config: config, app: app)
+    mgr.state_dir = mgr.state_dir_for_rom(core)
+    mgr
+  end
+
+  # -- state_dir_for_rom -----------------------------------------------------
+
+  def test_state_dir_for_rom_includes_game_code_and_crc
+    dir = @mgr.state_dir_for_rom(@core)
+    assert_includes dir, "AGB-BGBE"
+    assert_includes dir, "DEADBEEF"
+  end
+
+  def test_state_dir_for_rom_sanitizes_special_chars
+    @core.game_code = "AB/CD\\EF"
+    dir = @mgr.state_dir_for_rom(@core)
+    basename = File.basename(dir)
+    refute_match %r{[/\\]}, basename
+    assert_includes basename, "AB_CD_EF"
+  end
+
+  # -- state_path / screenshot_path ------------------------------------------
+
+  def test_state_path
+    assert @mgr.state_path(1).end_with?("state1.ss")
+  end
+
+  def test_screenshot_path
+    assert @mgr.screenshot_path(1).end_with?("state1.png")
+  end
+
+  # -- save_state ------------------------------------------------------------
+
+  def test_save_state_success
+    success, msg = @mgr.save_state(1)
+    assert success
+    assert_includes msg, "1"  # slot number in message
+    assert File.exist?(@mgr.state_path(1)), "state file should be written"
+  end
+
+  def test_save_state_calls_core
+    @mgr.save_state(1)
+    save_calls = @core.calls.select { |c| c[0] == :save_state_to_file }
+    assert_equal 1, save_calls.size
+    assert save_calls[0][1].end_with?("state1.ss")
+  end
+
+  def test_save_state_takes_screenshot
+    @mgr.save_state(1)
+    # Should have called video_buffer_argb
+    assert @core.calls.any? { |c| c[0] == :video_buffer_argb }
+    # Should have created a Tk photo via app.command
+    image_creates = @app.calls.select { |args, _| args[0] == :image && args[1] == :create }
+    assert_equal 1, image_creates.size
+    # Should have written the photo via app.command
+    write_calls = @app.calls.select { |args, _| args[1] == :write }
+    assert_equal 1, write_calls.size
+    # Should have cleaned up the photo
+    delete_calls = @app.calls.select { |args, _| args[0] == :image && args[1] == :delete }
+    assert_equal 1, delete_calls.size
+  end
+
+  def test_save_state_interp_photo_put_block
+    @mgr.save_state(1)
+    ppb = @app.interp.calls.select { |c| c[0] == :photo_put_block }
+    assert_equal 1, ppb.size
+    assert_equal 240, ppb[0][2]  # width
+    assert_equal 160, ppb[0][3]  # height
+    assert_equal :argb, ppb[0][4]
+  end
+
+  def test_save_state_failure
+    @core.save_result = false
+    success, msg = @mgr.save_state(1)
+    refute success
+    refute_nil msg
+  end
+
+  def test_save_state_with_destroyed_core
+    @core.destroyed = true
+    success, msg = @mgr.save_state(1)
+    refute success
+    assert_nil msg
+  end
+
+  # -- debounce --------------------------------------------------------------
+
+  def test_save_state_debounce_blocks_rapid_saves
+    @config.save_state_debounce = 10.0  # very long debounce
+    mgr = new_manager
+
+    success1, _ = mgr.save_state(1)
+    assert success1
+
+    success2, msg2 = mgr.save_state(2)
+    refute success2
+    refute_nil msg2  # should have a "blocked" message
+  end
+
+  # -- backup rotation -------------------------------------------------------
+
+  def test_save_state_backup_creates_bak_files
+    @mgr.backup = true
+
+    # First save
+    @mgr.save_state(1)
+    ss = @mgr.state_path(1)
+    assert File.exist?(ss)
+
+    # Second save — original should be renamed to .bak
+    @mgr.save_state(1)
+    assert File.exist?("#{ss}.bak"), ".bak file should exist after second save"
+  end
+
+  def test_save_state_no_backup_when_disabled
+    @mgr.backup = false
+
+    @mgr.save_state(1)
+    ss = @mgr.state_path(1)
+
+    @mgr.save_state(1)
+    refute File.exist?("#{ss}.bak"), ".bak should not exist when backup disabled"
+  end
+
+  # -- load_state ------------------------------------------------------------
+
+  def test_load_state_success
+    # Create a state file first
+    @mgr.save_state(1)
+
+    success, msg = @mgr.load_state(1)
+    assert success
+    assert_includes msg, "1"
+    load_calls = @core.calls.select { |c| c[0] == :load_state_from_file }
+    assert_equal 1, load_calls.size
+  end
+
+  def test_load_state_missing_file
+    success, msg = @mgr.load_state(7)
+    refute success
+    refute_nil msg  # "no state" message
+  end
+
+  def test_load_state_failure
+    @mgr.save_state(1)  # create the file
+    @core.load_result = false
+
+    success, msg = @mgr.load_state(1)
+    refute success
+    refute_nil msg
+  end
+
+  def test_load_state_with_destroyed_core
+    @core.destroyed = true
+    success, msg = @mgr.load_state(1)
+    refute success
+    assert_nil msg
+  end
+
+  # -- quick save / quick load -----------------------------------------------
+
+  def test_quick_save_uses_configured_slot
+    @mgr.quick_save_slot = 3
+    @mgr.quick_save
+    save_calls = @core.calls.select { |c| c[0] == :save_state_to_file }
+    assert_equal 1, save_calls.size
+    assert save_calls[0][1].end_with?("state3.ss")
+  end
+
+  def test_quick_load_uses_configured_slot
+    @mgr.quick_save_slot = 3
+    @mgr.quick_save  # create the file first
+    @mgr.quick_load
+    load_calls = @core.calls.select { |c| c[0] == :load_state_from_file }
+    assert_equal 1, load_calls.size
+    assert load_calls[0][1].end_with?("state3.ss")
+  end
+
+  # -- screenshot failure doesn't break save ---------------------------------
+
+  def test_screenshot_failure_does_not_prevent_save
+    # Make interp.photo_put_block raise
+    def @app.interp
+      obj = Object.new
+      def obj.photo_put_block(*)
+        raise "boom"
+      end
+      obj
+    end
+
+    success, msg = @mgr.save_state(1)
+    assert success, "save should still succeed even if screenshot fails"
+    assert File.exist?(@mgr.state_path(1))
+  end
+end