coverband 6.1.5 → 6.1.7

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/track_key_test.rb

@@ -7,7 +7,7 @@ class TrackKeyTest < Minitest::Test
     mock_view_tracker = mock
     mock_view_tracker.expects(:track_key).with("view/path/index.html.erb").returns(true)
     Coverband.configuration.expects(:view_tracker).returns(mock_view_tracker)
-    
+
     assert Coverband.track_key(:view_tracker, "view/path/index.html.erb")
   end
 
@@ -23,7 +23,7 @@ class TrackKeyTest < Minitest::Test
 
   test "track_key handles missing trackers" do
     Coverband.configuration.expects(:view_tracker).returns(nil)
-    
+
     assert_equal false, Coverband.track_key(:view_tracker, "some_view")
   end
 
@@ -31,7 +31,7 @@ class TrackKeyTest < Minitest::Test
     mock_invalid_tracker = mock
     mock_invalid_tracker.expects(:respond_to?).with(:track_key).returns(false)
     Coverband.configuration.expects(:view_tracker).returns(mock_invalid_tracker)
-    
+
     assert_equal false, Coverband.track_key(:view_tracker, "some_view")
   end
 
@@ -39,7 +39,7 @@ class TrackKeyTest < Minitest::Test
     mock_translations_tracker = mock
     mock_translations_tracker.expects(:track_key).with("translation.key").returns(true)
     Coverband.configuration.expects(:translations_tracker).returns(mock_translations_tracker)
-    
+
     assert Coverband.track_key(:translations_tracker, "translation.key")
   end
 
@@ -47,20 +47,20 @@ class TrackKeyTest < Minitest::Test
     mock_routes_tracker = mock
     mock_routes_tracker.expects(:track_key).with("index#show").returns(true)
     Coverband.configuration.expects(:routes_tracker).returns(mock_routes_tracker)
-    
+
     assert Coverband.track_key(:routes_tracker, "index#show")
   end
 
   test "track_key logs error when tracking fails" do
     mock_logger = mock
     mock_logger.expects(:error).with(regexp_matches(/Failed to track key/))
-    
+
     mock_tracker = mock
     mock_tracker.expects(:track_key).with("test_key").raises(StandardError.new("Test error"))
-    
+
     Coverband.configuration.expects(:translations_tracker).returns(mock_tracker)
     Coverband.configuration.expects(:logger).returns(mock_logger)
-    
+
     assert_equal false, Coverband.track_key(:translations_tracker, "test_key")
   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

data/test/coverband/user_environment_simulation_test.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# This test simulates using Coverband without COVERBAND_DISABLE_AUTO_START
+# to see if the issue still occurs
+
+require File.expand_path("../test_helper", File.dirname(__FILE__))
+
+class UserEnvironmentSimulationTest < Minitest::Test
+  def setup
+    super
+    # Clean slate
+    Thread.current[:coverband_instance] = nil
+  end
+
+  def teardown
+    super
+    Thread.current[:coverband_instance] = nil
+    # Restore the configured state
+    Coverband.configure do |config|
+      # Use default config
+    end
+    ENV.delete("COVERBAND_DISABLE_AUTO_START")
+  end
+
+  test "user workflow with auto-start disabled" do
+    # User disables auto-start and configures manually (recommended approach)
+    ENV["COVERBAND_DISABLE_AUTO_START"] = "true"
+
+    begin
+      # Reset state
+      Coverband.class_variable_set(:@@configured, false)
+      Coverband.configuration.instance_variable_set(:@store, nil)
+
+      # User configuration exactly like the GitHub issue
+      Coverband.configure do |config|
+        config.root = Dir.pwd
+        config.background_reporting_enabled = false
+        config.store = Coverband::Adapters::FileStore.new("tmp/coverband_log")
+        config.logger = Logger.new($stdout)
+        config.verbose = false
+      end
+
+      # Start manually
+      Coverband.start
+
+      # Should use FileStore without any Redis errors
+      assert_instance_of Coverband::Adapters::FileStore, Coverband.configuration.store
+
+      # These operations should work fine
+      Coverband.report_coverage
+    ensure
+      ENV.delete("COVERBAND_DISABLE_AUTO_START")
+    end
+  end
+
+  test "multiple reports with FileStore should never try Redis" do
+    Coverband.configure do |config|
+      config.root = Dir.pwd
+      config.background_reporting_enabled = false
+      config.store = Coverband::Adapters::FileStore.new("tmp/test_multiple_reports")
+      config.logger = Logger.new($stdout)
+      config.verbose = false
+    end
+
+    # Mock Redis to ensure it's never called after proper configuration
+    Redis.expects(:new).never
+
+    # Multiple reports should work fine
+    5.times do
+      Coverband.report_coverage
+    end
+
+    assert_instance_of Coverband::Adapters::FileStore, Coverband.configuration.store
+  end
+end

data/test/coverband/utils/lines_classifier_test.rb

@@ -64,7 +64,7 @@ describe Coverband::Utils::LinesClassifier do
 
         it "doesn't mistake interpolation as a comment" do
           classified_lines = subject.classify [
-            'puts "#{var}"'
+            "puts \"\#{var}\""
           ]
 
           assert_equal 1, classified_lines.length