coverband 6.1.6 → 6.1.7

data/test/coverband/mcp/tools/get_route_tracker_data_test.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require File.expand_path("../../../test_helper", File.dirname(__FILE__))
+
+begin
+  require "coverband/mcp"
+rescue LoadError
+  puts "MCP gem not available, skipping MCP tools tests"
+end
+
+if defined?(Coverband::MCP)
+  class GetRouteTrackerDataTest < Minitest::Test
+    def setup
+      super
+      Coverband.configure do |config|
+        config.store = Coverband::Adapters::RedisStore.new(Redis.new(db: 2))
+        config.track_routes = true
+        config.mcp_enabled = true  # Enable MCP for testing
+      end
+    end
+
+    def teardown
+      super
+      Coverband.configuration.store&.clear!
+      Coverband.configuration.track_routes = false
+    end
+
+    test "tool has correct metadata" do
+      assert_includes Coverband::MCP::Tools::GetRouteTrackerData.description, "Rails route usage tracking"
+    end
+
+    test "input schema has optional show_unused_only parameter" do
+      schema = Coverband::MCP::Tools::GetRouteTrackerData.input_schema
+      assert_instance_of ::MCP::Tool::InputSchema, schema
+    end
+
+    test "call returns route tracking data when tracker is enabled" do
+      tracker_mock = mock("route_tracker")
+      tracker_mock.expects(:tracking_since).returns("2024-01-01")
+      tracker_mock.expects(:as_json).returns({
+        "used_keys" => ["GET /users", "POST /users", "GET /users/:id"],
+        "unused_keys" => ["DELETE /users/:id", "PATCH /users/:id"]
+      }.to_json)
+
+      Coverband.configuration.expects(:route_tracker).returns(tracker_mock)
+
+      response = Coverband::MCP::Tools::GetRouteTrackerData.call(server_context: {})
+
+      assert_instance_of ::MCP::Tool::Response, response
+
+      result = JSON.parse(response.content.first[:text])
+
+      assert_equal "2024-01-01", result["tracking_since"]
+      assert_equal 3, result["total_used"]
+      assert_equal 2, result["total_unused"]
+      assert_includes result["used_routes"], "GET /users"
+      assert_includes result["unused_routes"], "DELETE /users/:id"
+    end
+
+    test "call returns only unused routes when show_unused_only is true" do
+      tracker_mock = mock("route_tracker")
+      tracker_mock.expects(:tracking_since).returns("2024-01-01")
+      tracker_mock.expects(:as_json).returns({
+        "unused_keys" => ["DELETE /users/:id", "PATCH /users/:id"]
+      }.to_json)
+
+      Coverband.configuration.expects(:route_tracker).returns(tracker_mock)
+
+      response = Coverband::MCP::Tools::GetRouteTrackerData.call(
+        show_unused_only: true,
+        server_context: {}
+      )
+
+      result = JSON.parse(response.content.first[:text])
+
+      assert_equal "2024-01-01", result["tracking_since"]
+      assert_equal 2, result["total_unused"]
+      assert_includes result["unused_routes"], "DELETE /users/:id"
+      refute_includes result, "used_routes"
+      refute_includes result, "total_used"
+    end
+
+    test "call returns message when route tracking is not enabled" do
+      Coverband.configuration.expects(:route_tracker).returns(nil)
+
+      response = Coverband::MCP::Tools::GetRouteTrackerData.call(server_context: {})
+
+      assert_instance_of ::MCP::Tool::Response, response
+      assert_includes response.content.first[:text], "Route tracking is not enabled"
+      assert_includes response.content.first[:text], "config.track_routes = true"
+    end
+
+    test "call handles empty tracking data gracefully" do
+      tracker_mock = mock("route_tracker")
+      tracker_mock.expects(:tracking_since).returns("2024-01-01")
+      tracker_mock.expects(:as_json).returns({
+        "used_keys" => nil,
+        "unused_keys" => nil
+      }.to_json)
+
+      Coverband.configuration.expects(:route_tracker).returns(tracker_mock)
+
+      response = Coverband::MCP::Tools::GetRouteTrackerData.call(server_context: {})
+
+      result = JSON.parse(response.content.first[:text])
+
+      assert_equal 0, result["total_used"]
+      assert_equal 0, result["total_unused"]
+      assert_equal [], result["used_routes"]
+      assert_equal [], result["unused_routes"]
+    end
+
+    test "call handles errors gracefully" do
+      Coverband.configuration.expects(:route_tracker).raises(StandardError.new("Test error"))
+
+      response = Coverband::MCP::Tools::GetRouteTrackerData.call(server_context: {})
+
+      assert_instance_of ::MCP::Tool::Response, response
+      assert_includes response.content.first[:text], "Error getting route tracker data: Test error"
+    end
+  end
+end

data/test/coverband/mcp/tools/get_translation_tracker_data_test.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require File.expand_path("../../../test_helper", File.dirname(__FILE__))
+
+begin
+  require "coverband/mcp"
+rescue LoadError
+  puts "MCP gem not available, skipping MCP tools tests"
+end
+
+if defined?(Coverband::MCP)
+  class GetTranslationTrackerDataTest < Minitest::Test
+    def setup
+      super
+      Coverband.configure do |config|
+        config.store = Coverband::Adapters::RedisStore.new(Redis.new(db: 2))
+        config.track_translations = true
+        config.mcp_enabled = true  # Enable MCP for testing
+      end
+    end
+
+    def teardown
+      super
+      Coverband.configuration.store&.clear!
+      Coverband.configuration.track_translations = false
+    end
+
+    test "tool has correct metadata" do
+      assert_includes Coverband::MCP::Tools::GetTranslationTrackerData.description, "I18n translation key usage"
+    end
+
+    test "input schema has optional show_unused_only parameter" do
+      schema = Coverband::MCP::Tools::GetTranslationTrackerData.input_schema
+      assert_instance_of ::MCP::Tool::InputSchema, schema
+    end
+
+    test "call returns translation tracking data when tracker is enabled" do
+      tracker_mock = mock("translation_tracker")
+      tracker_mock.expects(:tracking_since).returns("2024-01-01")
+      tracker_mock.expects(:as_json).returns({
+        "used_keys" => ["user.name", "user.email", "errors.required"],
+        "unused_keys" => ["admin.dashboard", "legacy.message"]
+      }.to_json)
+
+      Coverband.configuration.expects(:translations_tracker).returns(tracker_mock)
+
+      response = Coverband::MCP::Tools::GetTranslationTrackerData.call(server_context: {})
+
+      assert_instance_of ::MCP::Tool::Response, response
+
+      result = JSON.parse(response.content.first[:text])
+
+      assert_equal "2024-01-01", result["tracking_since"]
+      assert_equal 3, result["total_used"]
+      assert_equal 2, result["total_unused"]
+      assert_includes result["used_translations"], "user.name"
+      assert_includes result["unused_translations"], "admin.dashboard"
+    end
+
+    test "call returns only unused translations when show_unused_only is true" do
+      tracker_mock = mock("translation_tracker")
+      tracker_mock.expects(:tracking_since).returns("2024-01-01")
+      tracker_mock.expects(:as_json).returns({
+        "unused_keys" => ["admin.dashboard", "legacy.message"]
+      }.to_json)
+
+      Coverband.configuration.expects(:translations_tracker).returns(tracker_mock)
+
+      response = Coverband::MCP::Tools::GetTranslationTrackerData.call(
+        show_unused_only: true,
+        server_context: {}
+      )
+
+      result = JSON.parse(response.content.first[:text])
+
+      assert_equal "2024-01-01", result["tracking_since"]
+      assert_equal 2, result["total_unused"]
+      assert_includes result["unused_translations"], "admin.dashboard"
+      refute_includes result, "used_translations"
+      refute_includes result, "total_used"
+    end
+
+    test "call returns message when translation tracking is not enabled" do
+      Coverband.configuration.expects(:translations_tracker).returns(nil)
+
+      response = Coverband::MCP::Tools::GetTranslationTrackerData.call(server_context: {})
+
+      assert_instance_of ::MCP::Tool::Response, response
+      assert_includes response.content.first[:text], "Translation tracking is not enabled"
+      assert_includes response.content.first[:text], "config.track_translations = true"
+    end
+
+    test "call handles empty tracking data gracefully" do
+      tracker_mock = mock("translation_tracker")
+      tracker_mock.expects(:tracking_since).returns("2024-01-01")
+      tracker_mock.expects(:as_json).returns({
+        "used_keys" => nil,
+        "unused_keys" => nil
+      }.to_json)
+
+      Coverband.configuration.expects(:translations_tracker).returns(tracker_mock)
+
+      response = Coverband::MCP::Tools::GetTranslationTrackerData.call(server_context: {})
+
+      result = JSON.parse(response.content.first[:text])
+
+      assert_equal 0, result["total_used"]
+      assert_equal 0, result["total_unused"]
+      assert_equal [], result["used_translations"]
+      assert_equal [], result["unused_translations"]
+    end
+
+    test "call handles errors gracefully" do
+      Coverband.configuration.expects(:translations_tracker).raises(StandardError.new("Test error"))
+
+      response = Coverband::MCP::Tools::GetTranslationTrackerData.call(server_context: {})
+
+      assert_instance_of ::MCP::Tool::Response, response
+      assert_includes response.content.first[:text], "Error getting translation tracker data: Test error"
+    end
+  end
+end

data/test/coverband/mcp/tools/get_uncovered_files_test.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require File.expand_path("../../../test_helper", File.dirname(__FILE__))
+
+begin
+  require "coverband/mcp"
+rescue LoadError
+  puts "MCP gem not available, skipping MCP tools tests"
+end
+
+if defined?(Coverband::MCP)
+  class GetUncoveredFilesTest < Minitest::Test
+    def setup
+      super
+      Coverband.configure do |config|
+        config.store = Coverband::Adapters::RedisStore.new(Redis.new(db: 2))
+        config.mcp_enabled = true  # Enable MCP for testing
+      end
+    end
+
+    def teardown
+      super
+      Coverband.configuration.store&.clear!
+    end
+
+    test "tool has correct metadata" do
+      assert_includes Coverband::MCP::Tools::GetUncoveredFiles.description, "coverage below a specified threshold"
+    end
+
+    test "input schema has optional parameters" do
+      schema = Coverband::MCP::Tools::GetUncoveredFiles.input_schema
+      assert_instance_of ::MCP::Tool::InputSchema, schema
+    end
+
+    test "call returns uncovered files below threshold" do
+      mock_files = {
+        "/app/models/user.rb" => {"covered_percent" => 30.0, "never_loaded" => false},
+        "/app/models/order.rb" => {"covered_percent" => 80.0, "never_loaded" => false},
+        "/app/helpers/helper.rb" => {"covered_percent" => 20.0, "never_loaded" => false},
+        "/app/unused.rb" => {"covered_percent" => 0, "never_loaded" => true}
+      }
+
+      mock_data = {"files" => mock_files}
+
+      report_mock = mock("json_report")
+      report_mock.expects(:report).returns(mock_data.to_json)
+      Coverband::Reporters::JSONReport.expects(:new).with(
+        Coverband.configuration.store,
+        line_coverage: false
+      ).returns(report_mock)
+
+      response = Coverband::MCP::Tools::GetUncoveredFiles.call(
+        threshold: 50,
+        server_context: {}
+      )
+
+      assert_instance_of ::MCP::Tool::Response, response
+
+      result = JSON.parse(response.content.first[:text])
+
+      # Should include files below 50% and never loaded files
+      expected_files = ["/app/helpers/helper.rb", "/app/models/user.rb", "/app/unused.rb"]
+      actual_files = result["files"].map { |file| file["file"] }
+
+      assert_equal 3, result["files"].length
+      expected_files.each do |file|
+        assert_includes actual_files, file
+      end
+
+      # Should be sorted by coverage percentage (ascending)
+      coverages = result["files"].map { |file| file["covered_percent"] || 0 }
+      assert_equal coverages.sort, coverages
+    end
+
+    test "call excludes never loaded files when include_never_loaded is false" do
+      mock_files = {
+        "/app/models/user.rb" => {"covered_percent" => 30.0, "never_loaded" => false},
+        "/app/unused.rb" => {"covered_percent" => 0, "never_loaded" => true}
+      }
+
+      mock_data = {"files" => mock_files}
+
+      report_mock = mock("json_report")
+      report_mock.expects(:report).returns(mock_data.to_json)
+      Coverband::Reporters::JSONReport.expects(:new).returns(report_mock)
+
+      response = Coverband::MCP::Tools::GetUncoveredFiles.call(
+        threshold: 50,
+        include_never_loaded: false,
+        server_context: {}
+      )
+
+      result = JSON.parse(response.content.first[:text])
+
+      # Should only include user.rb (below threshold but not never_loaded)
+      assert_equal 1, result["files"].length
+      assert_equal "/app/models/user.rb", result["files"].first["file"]
+      assert_equal 30.0, result["files"].first["covered_percent"]
+    end
+
+    test "call uses default values when parameters not provided" do
+      mock_files = {
+        "/app/models/user.rb" => {"covered_percent" => 40.0, "never_loaded" => false},
+        "/app/models/order.rb" => {"covered_percent" => 60.0, "never_loaded" => false}
+      }
+
+      mock_data = {"files" => mock_files}
+
+      report_mock = mock("json_report")
+      report_mock.expects(:report).returns(mock_data.to_json)
+      Coverband::Reporters::JSONReport.expects(:new).returns(report_mock)
+
+      response = Coverband::MCP::Tools::GetUncoveredFiles.call(server_context: {})
+
+      result = JSON.parse(response.content.first[:text])
+
+      # Default threshold is 50, so should only include user.rb (40%)
+      assert_equal 1, result["files"].length
+      assert_equal "/app/models/user.rb", result["files"].first["file"]
+    end
+
+    test "call handles files with nil covered_percent" do
+      mock_files = {
+        "/app/models/user.rb" => {"covered_percent" => nil, "never_loaded" => false},
+        "/app/models/order.rb" => {"covered_percent" => 60.0, "never_loaded" => false}
+      }
+
+      mock_data = {"files" => mock_files}
+
+      report_mock = mock("json_report")
+      report_mock.expects(:report).returns(mock_data.to_json)
+      Coverband::Reporters::JSONReport.expects(:new).returns(report_mock)
+
+      response = Coverband::MCP::Tools::GetUncoveredFiles.call(
+        threshold: 50,
+        server_context: {}
+      )
+
+      result = JSON.parse(response.content.first[:text])
+
+      # File with nil coverage should be included (treated as 0)
+      assert_equal 1, result["files"].length
+      assert_equal "/app/models/user.rb", result["files"].first["file"]
+      assert_nil result["files"].first["covered_percent"]
+    end
+
+    test "call returns empty array when no files below threshold" do
+      mock_files = {
+        "/app/models/user.rb" => {"covered_percent" => 80.0, "never_loaded" => false},
+        "/app/models/order.rb" => {"covered_percent" => 90.0, "never_loaded" => false}
+      }
+
+      mock_data = {"files" => mock_files}
+
+      report_mock = mock("json_report")
+      report_mock.expects(:report).returns(mock_data.to_json)
+      Coverband::Reporters::JSONReport.expects(:new).returns(report_mock)
+
+      response = Coverband::MCP::Tools::GetUncoveredFiles.call(
+        threshold: 50,
+        server_context: {}
+      )
+
+      result = JSON.parse(response.content.first[:text])
+      assert_equal 0, result["files"].length
+    end
+
+    test "call handles errors gracefully" do
+      Coverband::Reporters::JSONReport.expects(:new).raises(StandardError.new("Test error"))
+
+      response = Coverband::MCP::Tools::GetUncoveredFiles.call(server_context: {})
+
+      assert_instance_of ::MCP::Tool::Response, response
+      assert_includes response.content.first[:text], "Error getting uncovered files: Test error"
+    end
+  end
+end

data/test/coverband/mcp/tools/get_view_tracker_data_test.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require File.expand_path("../../../test_helper", File.dirname(__FILE__))
+
+begin
+  require "coverband/mcp"
+rescue LoadError
+  puts "MCP gem not available, skipping MCP tools tests"
+end
+
+if defined?(Coverband::MCP)
+  class GetViewTrackerDataTest < Minitest::Test
+    def setup
+      super
+      Coverband.configure do |config|
+        config.store = Coverband::Adapters::RedisStore.new(Redis.new(db: 2))
+        config.track_views = true
+        config.mcp_enabled = true  # Enable MCP for testing
+      end
+    end
+
+    def teardown
+      super
+      Coverband.configuration.store&.clear!
+      Coverband.configuration.track_views = false
+    end
+
+    test "tool has correct metadata" do
+      assert_includes Coverband::MCP::Tools::GetViewTrackerData.description, "Rails view template usage"
+    end
+
+    test "input schema has optional show_unused_only parameter" do
+      schema = Coverband::MCP::Tools::GetViewTrackerData.input_schema
+      assert_instance_of ::MCP::Tool::InputSchema, schema
+    end
+
+    test "call returns view tracking data when tracker is enabled" do
+      tracker_mock = mock("view_tracker")
+      tracker_mock.expects(:tracking_since).returns("2024-01-01")
+      tracker_mock.expects(:as_json).returns({
+        "used_keys" => ["app/views/users/index.html.erb", "app/views/users/show.html.erb"],
+        "unused_keys" => ["app/views/users/new.html.erb", "app/views/users/edit.html.erb"]
+      }.to_json)
+
+      Coverband.configuration.expects(:view_tracker).returns(tracker_mock)
+
+      response = Coverband::MCP::Tools::GetViewTrackerData.call(server_context: {})
+
+      assert_instance_of ::MCP::Tool::Response, response
+
+      result = JSON.parse(response.content.first[:text])
+
+      assert_equal "2024-01-01", result["tracking_since"]
+      assert_equal 2, result["total_used"]
+      assert_equal 2, result["total_unused"]
+      assert_includes result["used_views"], "app/views/users/index.html.erb"
+      assert_includes result["unused_views"], "app/views/users/edit.html.erb"
+    end
+
+    test "call returns only unused views when show_unused_only is true" do
+      tracker_mock = mock("view_tracker")
+      tracker_mock.expects(:tracking_since).returns("2024-01-01")
+      tracker_mock.expects(:as_json).returns({
+        "unused_keys" => ["app/views/users/edit.html.erb", "app/views/orders/index.html.erb"]
+      }.to_json)
+
+      Coverband.configuration.expects(:view_tracker).returns(tracker_mock)
+
+      response = Coverband::MCP::Tools::GetViewTrackerData.call(
+        show_unused_only: true,
+        server_context: {}
+      )
+
+      result = JSON.parse(response.content.first[:text])
+
+      assert_equal "2024-01-01", result["tracking_since"]
+      assert_equal 2, result["total_unused"]
+      assert_includes result["unused_views"], "app/views/users/edit.html.erb"
+      refute_includes result, "used_views"
+      refute_includes result, "total_used"
+    end
+
+    test "call returns message when view tracking is not enabled" do
+      Coverband.configuration.expects(:view_tracker).returns(nil)
+
+      response = Coverband::MCP::Tools::GetViewTrackerData.call(server_context: {})
+
+      assert_instance_of ::MCP::Tool::Response, response
+      assert_includes response.content.first[:text], "View tracking is not enabled"
+      assert_includes response.content.first[:text], "config.track_views = true"
+    end
+
+    test "call handles empty tracking data gracefully" do
+      tracker_mock = mock("view_tracker")
+      tracker_mock.expects(:tracking_since).returns("2024-01-01")
+      tracker_mock.expects(:as_json).returns({
+        "used_keys" => nil,
+        "unused_keys" => nil
+      }.to_json)
+
+      Coverband.configuration.expects(:view_tracker).returns(tracker_mock)
+
+      response = Coverband::MCP::Tools::GetViewTrackerData.call(server_context: {})
+
+      result = JSON.parse(response.content.first[:text])
+
+      assert_equal 0, result["total_used"]
+      assert_equal 0, result["total_unused"]
+      assert_equal [], result["used_views"]
+      assert_equal [], result["unused_views"]
+    end
+
+    test "call handles errors gracefully" do
+      Coverband.configuration.expects(:view_tracker).raises(StandardError.new("Test error"))
+
+      response = Coverband::MCP::Tools::GetViewTrackerData.call(server_context: {})
+
+      assert_instance_of ::MCP::Tool::Response, response
+      assert_includes response.content.first[:text], "Error getting view tracker data: Test error"
+    end
+  end
+end

data/test/coverband/reporters/web_test.rb

@@ -40,6 +40,11 @@ module Coverband
       post "/clear"
       assert_equal 302, last_response.status
     end
+
+    test "json endpoint accepts line_coverage parameter" do
+      get "/json?line_coverage=true"
+      assert last_response.ok?
+    end
   end
 end
 

data/test/coverband/tracker_initialization_test.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require File.expand_path("../test_helper", File.dirname(__FILE__))
+
+class TrackerInitializationTest < Minitest::Test
+  def setup
+    super
+    Thread.current[:coverband_instance] = nil
+  end
+
+  def teardown
+    super
+    Thread.current[:coverband_instance] = nil
+    Coverband.configure do |config|
+      # Reset
+    end
+  end
+
+  test "tracker initialization can trigger Redis connection" do
+    skip "ViewTracker requires Rails 7+" unless defined?(Rails::VERSION) && Rails::VERSION::STRING.split(".").first.to_i >= 7
+
+    # Reset everything
+    Coverband.configuration.instance_variable_set(:@store, nil)
+    Coverband.configuration.instance_variable_set(:@view_tracker, nil)
+
+    # Mock Redis to see if it gets called when trackers are created
+    Redis.expects(:new).raises(Redis::CannotConnectError.new("Connection refused")).once
+
+    # This could happen during railtie initialization
+    # Creating a view tracker when no store is configured yet
+    Coverband.configuration.railtie!
+
+    # Should have fallen back to NullStore due to Redis error
+    assert_instance_of Coverband::Adapters::NullStore, Coverband.configuration.store
+  end
+
+  test "tracker initialization after FileStore config works fine" do
+    skip "ViewTracker requires Rails 7+" unless defined?(Rails::VERSION) && Rails::VERSION::STRING.split(".").first.to_i >= 7
+
+    # Configure FileStore first
+    Coverband.configure do |config|
+      config.store = Coverband::Adapters::FileStore.new("tmp/tracker_test")
+      config.track_views = true
+    end
+
+    # Redis should never be attempted
+    Redis.expects(:new).never
+
+    # Creating trackers should use the configured FileStore
+    Coverband.configuration.railtie!
+
+    assert_instance_of Coverband::Adapters::FileStore, Coverband.configuration.store
+    assert_instance_of Coverband::Collectors::ViewTracker, Coverband.configuration.view_tracker
+  end
+
+  test "store configuration prevents Redis connection in tracker contexts" do
+    # Test the core issue without Rails dependency
+    # Configure FileStore first
+    Coverband.configure do |config|
+      config.store = Coverband::Adapters::FileStore.new("tmp/abstract_tracker_test")
+    end
+
+    # Redis should never be attempted
+    Redis.expects(:new).never
+
+    # This tests that the store getter works correctly
+    # when called from tracker initialization contexts
+    store = Coverband.configuration.store
+    assert_instance_of Coverband::Adapters::FileStore, store
+
+    # Multiple accesses should return the same cached instance
+    store2 = Coverband.configuration.store
+    assert_same store, store2
+  end
+end