gemba 0.1.1 → 0.2.0

data/test/test_logging.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "tmpdir"
+require "fileutils"
+require "gemba/headless"
+
+class TestLogging < Minitest::Test
+  def setup
+    @dir = Dir.mktmpdir("gemba-logs-test")
+    @logger = Gemba::SessionLogger.new(dir: @dir, level: :info)
+  end
+
+  def teardown
+    Gemba.logger = nil
+    FileUtils.rm_rf(@dir)
+  end
+
+  # -- lazy file creation --
+
+  def test_no_file_before_first_log
+    assert_empty Dir.glob(File.join(@dir, "*.log"))
+  end
+
+  def test_file_created_on_first_log
+    @logger.log(:info) { "hello" }
+    logs = Dir.glob(File.join(@dir, "*.log"))
+    assert_equal 1, logs.length
+  end
+
+  def test_file_named_by_date
+    @logger.log(:info) { "hello" }
+    logs = Dir.glob(File.join(@dir, "*.log"))
+    assert_match(/gemba-\d{4}-\d{2}-\d{2}\.log/, File.basename(logs.first))
+  end
+
+  # -- level filtering --
+
+  def test_filters_below_level
+    @logger.log(:debug) { "should not appear" }
+    assert_empty Dir.glob(File.join(@dir, "*.log")),
+      "Debug message should not create log file at info level"
+  end
+
+  def test_allows_at_level
+    @logger.log(:info) { "visible" }
+    content = File.read(Dir.glob(File.join(@dir, "*.log")).first)
+    assert_includes content, "visible"
+  end
+
+  def test_allows_above_level
+    @logger.log(:error) { "bad thing" }
+    content = File.read(Dir.glob(File.join(@dir, "*.log")).first)
+    assert_includes content, "bad thing"
+  end
+
+  def test_debug_level_allows_debug
+    logger = Gemba::SessionLogger.new(dir: @dir, level: :debug)
+    logger.log(:debug) { "debug msg" }
+    content = File.read(Dir.glob(File.join(@dir, "*.log")).first)
+    assert_includes content, "debug msg"
+  end
+
+  # -- log format --
+
+  def test_log_format
+    @logger.log(:info) { "test message" }
+    content = File.read(Dir.glob(File.join(@dir, "*.log")).first)
+    assert_match(/\d{2}:\d{2}:\d{2}\.\d{3} \[INFO\] test message/, content)
+  end
+
+  # -- auto-prune --
+
+  def test_prune_keeps_max_files
+    # Create 30 fake log files
+    30.times do |i|
+      File.write(File.join(@dir, "gemba-2026-01-#{format('%02d', i + 1)}.log"), "old")
+    end
+
+    # New logger prunes on init
+    Gemba::SessionLogger.new(dir: @dir, level: :info)
+
+    remaining = Dir.glob(File.join(@dir, "gemba-*.log"))
+    assert_equal Gemba::SessionLogger::MAX_LOG_FILES, remaining.length
+  end
+
+  def test_prune_keeps_newest
+    30.times do |i|
+      File.write(File.join(@dir, "gemba-2026-01-#{format('%02d', i + 1)}.log"), "old")
+    end
+
+    Gemba::SessionLogger.new(dir: @dir, level: :info)
+
+    remaining = Dir.glob(File.join(@dir, "gemba-*.log")).sort
+    # Should keep the last 25 (days 06-30)
+    assert_equal "gemba-2026-01-06.log", File.basename(remaining.first)
+    assert_equal "gemba-2026-01-30.log", File.basename(remaining.last)
+  end
+
+  def test_prune_no_op_when_under_limit
+    3.times do |i|
+      File.write(File.join(@dir, "gemba-2026-01-#{format('%02d', i + 1)}.log"), "ok")
+    end
+
+    Gemba::SessionLogger.new(dir: @dir, level: :info)
+    assert_equal 3, Dir.glob(File.join(@dir, "gemba-*.log")).length
+  end
+
+  # -- module interface --
+
+  def test_gemba_log_module_method
+    Gemba.logger = Gemba::SessionLogger.new(dir: @dir, level: :info)
+    Gemba.log(:info) { "module test" }
+    content = File.read(Dir.glob(File.join(@dir, "*.log")).first)
+    assert_includes content, "module test"
+  end
+
+  def test_gemba_logger_setter
+    custom = Gemba::SessionLogger.new(dir: @dir, level: :warn)
+    Gemba.logger = custom
+    assert_same custom, Gemba.logger
+  end
+end

data/test/test_null_backend.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "gemba/headless"
+require "gemba/achievements"
+require_relative "support/fake_core"
+
+class TestNullBackend < Minitest::Test
+  def setup
+    @b = Gemba::Achievements::NullBackend.new
+  end
+
+  def test_not_enabled
+    refute @b.enabled?
+  end
+
+  def test_not_authenticated
+    refute @b.authenticated?
+  end
+
+  def test_achievement_list_empty
+    assert_equal [], @b.achievement_list
+  end
+
+  def test_counts_zero
+    assert_equal 0, @b.earned_count
+    assert_equal 0, @b.total_count
+  end
+
+  def test_do_frame_is_noop
+    assert_nil @b.do_frame(FakeCore.new)
+  end
+
+  def test_login_noop
+    assert_nil @b.login_with_token(username: 'u', token: 't')
+    refute @b.authenticated?
+  end
+
+  def test_logout_noop
+    assert_nil @b.logout
+  end
+end

data/test/test_offline_backend.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "gemba/headless"
+
+class TestOfflineBackend < Minitest::Test
+  ROM = "test/fixtures/test.gba"
+
+  def setup
+    skip "test.gba fixture not found" unless File.exist?(ROM)
+    @unlocked = []
+    @backend  = Gemba::Achievements::OfflineBackend.new
+    @backend.on_unlock { |ach| @unlocked << ach }
+  end
+
+  def test_always_authenticated
+    assert @backend.authenticated?
+  end
+
+  def test_enabled
+    assert @backend.enabled?
+  end
+
+  def test_login_and_logout_are_noops
+    @backend.login_with_password(username: "anyone", password: "anything")
+    assert @backend.authenticated?
+    @backend.logout
+    assert @backend.authenticated?
+  end
+
+  def test_on_load_achievement_fires_during_load_game
+    Gemba::HeadlessPlayer.open(ROM) do |player|
+      @backend.load_game(player.core)
+      assert_equal 1, @unlocked.size
+      assert_equal "gembatest_loaded", @unlocked.first.id
+      assert_equal "Ready to Play",    @unlocked.first.title
+      assert @unlocked.first.earned?
+    end
+  end
+
+  def test_achievement_list_shows_earned_after_load
+    Gemba::HeadlessPlayer.open(ROM) do |player|
+      @backend.load_game(player.core)
+      list = @backend.achievement_list
+      assert_equal 1, list.size
+      assert list.first.earned?
+    end
+  end
+
+  def test_counts
+    Gemba::HeadlessPlayer.open(ROM) do |player|
+      assert_equal 0, @backend.total_count
+      @backend.load_game(player.core)
+      assert_equal 1, @backend.total_count
+      assert_equal 1, @backend.earned_count
+    end
+  end
+
+  def test_unload_game_clears_state
+    Gemba::HeadlessPlayer.open(ROM) do |player|
+      @backend.load_game(player.core)
+      assert_equal 1, @backend.earned_count
+      @backend.unload_game
+      assert_equal 0, @backend.total_count
+      assert_equal 0, @backend.earned_count
+    end
+  end
+
+  def test_unknown_rom_has_no_achievements
+    Gemba::HeadlessPlayer.open(ROM) do |player|
+      custom = Gemba::Achievements::OfflineBackend.new(db: {})
+      custom.load_game(player.core)
+      assert_equal 0, custom.total_count
+      assert_empty @unlocked
+    end
+  end
+
+  def test_store_adds_definitions
+    Gemba::HeadlessPlayer.open(ROM) do |player|
+      custom = Gemba::Achievements::OfflineBackend.new(db: {})
+      custom.on_unlock { |a| @unlocked << a }
+      custom.store(player.core.checksum, [
+        { id: "extra", title: "Extra", description: "desc",
+          points: 5, trigger: :on_load }
+      ])
+      custom.load_game(player.core)
+      assert_equal 1, @unlocked.size
+      assert_equal "extra", @unlocked.first.id
+    end
+  end
+
+  def test_memory_achievement_fires_on_rising_edge
+    addr = 0x02000000
+    Gemba::HeadlessPlayer.open(ROM) do |player|
+      backend = Gemba::Achievements::OfflineBackend.new(db: {
+        player.core.checksum => [
+          { id: "mem_test", title: "Mem", description: "d", points: 2,
+            trigger: :memory,
+            condition: ->(mem) { mem.call(addr) == 0x01 } }
+        ]
+      })
+      backend.on_unlock { |a| @unlocked << a }
+      backend.load_game(player.core)
+
+      # EWRAM starts zeroed — condition false
+      player.step(1)
+      backend.do_frame(player.core)
+      assert_empty @unlocked
+
+      # Write 0x01 to EWRAM — but we can't poke real memory from Ruby,
+      # so verify do_frame doesn't crash and condition stays unevaluated
+      backend.do_frame(player.core)
+      assert_empty @unlocked
+    end
+  end
+end

data/test/test_overlay_renderer.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "minitest/autorun"
-require_relative "../lib/gemba/overlay_renderer"
+require "gemba/headless"
 
 class TestOverlayRenderer < Minitest::Test
   class MockTexture

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