coverband 6.2.0 → 6.2.2

data/public/dead_code_session.js

@@ -0,0 +1,173 @@
+// Pure logic for the dead-code review session. Loaded in the browser as
+// window.CoverbandDeadCode and in Node (tests) via require.
+(function (root, factory) {
+  if (typeof module === "object" && module.exports) {
+    module.exports = factory();
+  } else {
+    root.CoverbandDeadCode = factory();
+  }
+})(typeof self !== "undefined" ? self : this, function () {
+  function emptyState() {
+    return { hiddenPaths: [], markedPaths: [], hideRuntimeUsed: false, startedAt: null };
+  }
+
+  function parseState(json) {
+    var raw;
+    try { raw = JSON.parse(json); } catch (e) { raw = null; }
+    var state = emptyState();
+    if (!raw || typeof raw !== "object") return state;
+    if (Object.prototype.toString.call(raw.hiddenPaths) === "[object Array]") {
+      state.hiddenPaths = raw.hiddenPaths.filter(function (p) {
+        return typeof p === "string" && p.length > 0;
+      });
+    }
+    if (Object.prototype.toString.call(raw.markedPaths) === "[object Array]") {
+      state.markedPaths = raw.markedPaths.filter(function (m) {
+        return m && typeof m.path === "string" && m.path.length > 0;
+      }).map(function (m) {
+        return {
+          path: m.path,
+          comment: typeof m.comment === "string" ? m.comment : "",
+          markedAt: typeof m.markedAt === "string" ? m.markedAt : ""
+        };
+      });
+    }
+    state.hideRuntimeUsed = raw.hideRuntimeUsed === true;
+    state.startedAt = typeof raw.startedAt === "string" ? raw.startedAt : null;
+    return state;
+  }
+
+  function pathMatches(entry, path) {
+    if (entry.charAt(entry.length - 1) === "/") return path.indexOf(entry) === 0;
+    return path === entry;
+  }
+
+  function matchesAny(entries, path) {
+    for (var i = 0; i < entries.length; i++) {
+      if (pathMatches(entries[i], path)) return true;
+    }
+    return false;
+  }
+
+  function isMarked(state, path) {
+    for (var i = 0; i < state.markedPaths.length; i++) {
+      if (pathMatches(state.markedPaths[i].path, path)) return true;
+    }
+    return false;
+  }
+
+  function isExcludedIgnoringMarks(state, path, runtimePercent) {
+    if (matchesAny(state.hiddenPaths, path)) return true;
+    if (state.hideRuntimeUsed && typeof runtimePercent === "number" && runtimePercent > 0) return true;
+    return false;
+  }
+
+  function isExcluded(state, path, runtimePercent) {
+    return isExcludedIgnoringMarks(state, path, runtimePercent) || isMarked(state, path);
+  }
+
+  function addHidden(state, entry) {
+    if (state.hiddenPaths.indexOf(entry) === -1) state.hiddenPaths.push(entry);
+  }
+
+  function removeHidden(state, entry) {
+    var i = state.hiddenPaths.indexOf(entry);
+    if (i !== -1) state.hiddenPaths.splice(i, 1);
+  }
+
+  function clearHides(state) {
+    state.hiddenPaths = [];
+    state.hideRuntimeUsed = false;
+  }
+
+  function addMark(state, path, comment, markedAt) {
+    removeMark(state, path);
+    state.markedPaths.push({ path: path, comment: comment || "", markedAt: markedAt || "" });
+  }
+
+  function removeMark(state, path) {
+    for (var i = state.markedPaths.length - 1; i >= 0; i--) {
+      if (state.markedPaths[i].path === path) state.markedPaths.splice(i, 1);
+    }
+  }
+
+  function updateComment(state, path, comment) {
+    for (var i = 0; i < state.markedPaths.length; i++) {
+      if (state.markedPaths[i].path === path) state.markedPaths[i].comment = comment;
+    }
+  }
+
+  function clearMarks(state) {
+    state.markedPaths = [];
+  }
+
+  function csvField(value) {
+    var s = String(value == null ? "" : value);
+    if (/[",\n\r]/.test(s)) return '"' + s.replace(/"/g, '""') + '"';
+    return s;
+  }
+
+  function toCSV(markedPaths) {
+    var lines = ["path,comment,marked_at"];
+    for (var i = 0; i < markedPaths.length; i++) {
+      var m = markedPaths[i];
+      lines.push([csvField(m.path), csvField(m.comment), csvField(m.markedAt)].join(","));
+    }
+    return lines.join("\r\n") + "\r\n";
+  }
+
+  function segmentPrefixes(path) {
+    var parts = path.split("/");
+    var out = [];
+    var prefix = "";
+    for (var i = 0; i < parts.length; i++) {
+      var isFile = i === parts.length - 1;
+      prefix += parts[i] + (isFile ? "" : "/");
+      out.push({ label: parts[i], prefix: prefix, isFile: isFile });
+    }
+    return out;
+  }
+
+  // Extracts the full path from a DataTables cell's rendered HTML (the
+  // title attribute on the source link), e.g. '<a title="app/foo.rb">foo.rb</a>'.
+  function extractPath(cellHtml) {
+    var m = String(cellHtml).match(/title="([^"]*)"/);
+    return m ? m[1] : "";
+  }
+
+  // Parses the runtime % column (aData[2]) of a report row into a number,
+  // or null when it isn't numeric (e.g. "-" for untracked files).
+  function rowRuntime(aData) {
+    var n = parseFloat(String(aData[2]));
+    return isNaN(n) ? null : n;
+  }
+
+  function escapeHtml(s) {
+    return String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+  }
+
+  function csvFilename(date) {
+    return "coverband-dead-code-" + date.toISOString().slice(0, 10) + ".csv";
+  }
+
+  return {
+    emptyState: emptyState,
+    parseState: parseState,
+    pathMatches: pathMatches,
+    isExcluded: isExcluded,
+    isExcludedIgnoringMarks: isExcludedIgnoringMarks,
+    addHidden: addHidden,
+    removeHidden: removeHidden,
+    clearHides: clearHides,
+    addMark: addMark,
+    removeMark: removeMark,
+    updateComment: updateComment,
+    clearMarks: clearMarks,
+    toCSV: toCSV,
+    segmentPrefixes: segmentPrefixes,
+    extractPath: extractPath,
+    rowRuntime: rowRuntime,
+    escapeHtml: escapeHtml,
+    csvFilename: csvFilename
+  };
+});

data/test/benchmarks/benchmark.rake

@@ -173,14 +173,20 @@ namespace :benchmarks do
     }.pretty_print
     data = $stdout.string
     $stdout = previous_out
-    unless data.match?("Total retained:  0 bytes")
-      puts data
-      raise "leaking memory!!!"
-    end
+    assert_no_coverband_leak(data)
   ensure
     $stdout = previous_out
   end
 
+  # Check only that coverband itself retains no objects.
+  # External gems (json, redis-client) may retain strings via internal
+  # deduplication caches in newer Ruby versions — that is not a coverband leak.
+  def assert_no_coverband_leak(data)
+    return unless data.match(/retained objects by gem(.*)retained objects by file/m)&.[](0)&.match?(/coverband/)
+    puts data
+    raise "leaking memory!!!"
+  end
+
   def measure_memory_report_coverage
     require "memory_profiler"
     require "stringio"
@@ -205,16 +211,18 @@ namespace :benchmarks do
         # we clear this as this one variable is expected to retain memory and is a false positive
         ###
         Coverband::Collectors::Delta.class_variable_set(:@@previous_coverage, nil)
-        # Clear the RelativeFileConverter cache to avoid retaining strings
-        Coverband::Utils::RelativeFileConverter.reset
       end
+      # Reset file converter caches INSIDE the block but AFTER the loop.
+      # This lets GC collect the instance (and any strings allocated in it during the loop)
+      # before MemoryProfiler measures retained objects, so those strings aren't flagged.
+      # The instance was created before the block (during warmup), so its Regexp objects
+      # are invisible to MemoryProfiler even if GC defers collecting them.
+      Coverband::Utils::RelativeFileConverter.reset
+      Coverband::Utils::AbsoluteFileConverter.reset
     }.pretty_print
     data = $stdout.string
     $stdout = previous_out
-    unless data.match?("Total retained:  0 bytes")
-      puts data
-      raise "leaking memory!!!"
-    end
+    assert_no_coverband_leak(data)
   ensure
     $stdout = previous_out
   end

data/test/benchmarks/benchmark_file_list_covered_lines.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "benchmark/ips"
+require "memory_profiler"
+
+# Mock SourceFile to simulate the overhead of creating line objects
+class MockSourceFile
+  attr_reader :covered_lines_count
+
+  def initialize(count)
+    @covered_lines_count = count
+  end
+
+  def covered_lines
+    # Simulate allocating an array of objects
+    Array.new(@covered_lines_count) { Object.new }
+  end
+end
+
+class FileList < Array
+  def covered_lines_original
+    return 0.0 if empty?
+    map { |f| f.covered_lines.count }.inject(:+)
+  end
+
+  def covered_lines_optimized
+    return 0.0 if empty?
+    sum(&:covered_lines_count)
+  end
+end
+
+# Generate data: 10,000 files with varying coverage
+files = Array.new(10000) { |i| MockSourceFile.new(i % 100) }
+file_list = FileList.new(files)
+
+puts "---------------------------------------------------"
+puts "Memory Profiling: FileList#covered_lines"
+
+puts "\nOriginal (map.inject):"
+report = MemoryProfiler.report { file_list.covered_lines_original }
+puts "  Total allocated: #{report.total_allocated_memsize} bytes (#{report.total_allocated} objects)"
+
+puts "\nOptimized (sum):"
+report = MemoryProfiler.report { file_list.covered_lines_optimized }
+puts "  Total allocated: #{report.total_allocated_memsize} bytes (#{report.total_allocated} objects)"
+
+puts "\n---------------------------------------------------"
+puts "Benchmark: FileList#covered_lines"
+
+Benchmark.ips do |x|
+  x.report("map.inject") { file_list.covered_lines_original }
+  x.report("sum") { file_list.covered_lines_optimized }
+  x.compare!
+end

data/test/coverband/benchmarks/benchmark_memory_leak_check_test.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require File.expand_path("../../test_helper", File.dirname(__FILE__))
+require "rake"
+
+load File.expand_path("../../benchmarks/benchmark.rake", File.dirname(__FILE__)) unless respond_to?(:assert_no_coverband_leak, true)
+
+class BenchmarkMemoryLeakCheckTest < Minitest::Test
+  def test_raises_when_coverband_retains_objects
+    data = <<~REPORT
+      retained objects by gem
+      -----------------------------------
+               1  coverband
+
+      retained objects by file
+      -----------------------------------
+    REPORT
+
+    error = assert_raises(RuntimeError) { send(:assert_no_coverband_leak, data) }
+    assert_equal "leaking memory!!!", error.message
+  end
+
+  # Regression test for https://github.com/danmayer/coverband/pull/647 CI failures:
+  # newer Ruby/json versions retain a small internal string-dedup cache that is not
+  # a Coverband leak, so it must not trip the check.
+  def test_does_not_raise_when_only_external_gems_retain_memory
+    data = <<~REPORT
+      retained objects by gem
+      -----------------------------------
+               7  json-2.21.2
+               1  redis-client-0.30.1
+
+      retained objects by file
+      -----------------------------------
+    REPORT
+
+    send(:assert_no_coverband_leak, data)
+  end
+
+  def test_does_not_raise_when_nothing_retained
+    send(:assert_no_coverband_leak, "Total retained:  0 bytes (0 objects)\n")
+  end
+end

data/test/coverband/collectors/delta_test.rb

@@ -92,6 +92,23 @@ class CollectorsDeltaTest < Minitest::Test
     assert_equal({"car.rb" => [nil, 0, 2, 0]}, results)
   end
 
+  test "Coverage with oneshot_lines payload works when coverband oneshot mode is disabled" do
+    current_coverage = {
+      "car.rb" => {oneshot_lines: [2, 3]}
+    }
+    ::Coverage.expects(:line_stub).with("car.rb").returns([nil, 0, 0, 0, nil])
+    ::Coverage.expects(:peek_result).returns(current_coverage)
+    results = Coverband::Collectors::Delta.results
+    assert_equal({"car.rb" => [nil, 1, 1, 0, nil]}, results)
+
+    current_coverage = {
+      "car.rb" => {oneshot_lines: [2, 3, 4]}
+    }
+    ::Coverage.expects(:peek_result).returns(current_coverage)
+    results = Coverband::Collectors::Delta.results
+    assert_equal({"car.rb" => [nil, 0, 0, 1, nil]}, results)
+  end
+
   test "oneshot coverage calls clear" do
     Coverband.configuration.stubs(:use_oneshot_lines_coverage).returns(true)
     current_coverage = {

data/test/coverband/collectors/query_burst_tracker_test.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require File.expand_path("../../test_helper", File.dirname(__FILE__))
+
+class QueryBurstTrackerTest < Minitest::Test
+  def tracker
+    Coverband::Collectors::QueryBurstTracker.expects(:supported_version?).at_least_once.returns(true)
+    Coverband::Collectors::QueryBurstTracker.new(store: fake_store)
+  end
+
+  def tracker_key
+    tracker.send(:tracker_key)
+  end
+
+  def tracker_time_key
+    tracker.send(:tracker_time_key)
+  end
+
+  def setup
+    super
+    fake_store.raw_store.del(tracker_key)
+    fake_store.raw_store.del(tracker_time_key)
+  end
+
+  test "track key aggregates request SQL stats and threshold hits" do
+    Coverband.configuration.query_burst_query_count_threshold = 30
+    Coverband.configuration.query_burst_sql_time_threshold_ms = 100.0
+
+    subject = tracker
+    key = "controller:users#index"
+
+    subject.track_key(key: key, queries: 40, sql_time_ms: 120.5)
+    subject.track_key(key: key, queries: 10, sql_time_ms: 20.0)
+    subject.save_report
+
+    assert_equal [key], subject.used_keys.keys
+
+    stats = subject.used_key_stats[key]
+    assert_equal 2, stats["requests"]
+    assert_equal 50, stats["total_queries"]
+    assert_equal 140.5, stats["total_sql_time_ms"]
+    assert_equal 40, stats["max_queries"]
+    assert_equal 120.5, stats["max_sql_time_ms"]
+    assert_equal 1, stats["threshold_hits"]
+  end
+
+  test "as_json includes thresholds and tracked keys" do
+    subject = tracker
+    key = "job:HardWorker queue:default"
+
+    subject.track_key(key: key, queries: 3, sql_time_ms: 12.0)
+    subject.save_report
+
+    parsed = JSON.parse(subject.as_json)
+    assert_equal Coverband.configuration.query_burst_query_count_threshold, parsed.dig("thresholds", "query_count")
+    assert_equal Coverband.configuration.query_burst_sql_time_threshold_ms, parsed.dig("thresholds", "sql_time_ms")
+    assert parsed["used_keys"].key?(key)
+  end
+
+  test "clear key removes tracked query burst stats" do
+    subject = tracker
+    key = "controller:orders#show"
+
+    subject.track_key(key: key, queries: 31, sql_time_ms: 55.0)
+    subject.save_report
+    assert_equal [key], subject.used_keys.keys
+
+    subject.clear_key!(key)
+    assert_equal [], subject.used_keys.keys
+  end
+
+  protected
+
+  def fake_store
+    @fake_store ||= Coverband::Adapters::RedisStore.new(Coverband::Test.redis, redis_namespace: "coverband_test")
+  end
+end

data/test/coverband/collectors/view_tracker_test.rb

@@ -107,6 +107,19 @@ class ViewTrackerTest < Minitest::Test
     assert_equal [], tracker.used_keys.keys
   end
 
+  test "track view_component renders via railtie" do
+    Coverband::Collectors::ViewTracker.expects(:supported_version?).returns(true)
+    store = fake_store
+    file_path = "#{File.expand_path(Coverband.configuration.root)}/app/components/example_component.html.erb"
+    tracker = Coverband::Collectors::ViewTracker.new(store: store, roots: "dir")
+    Coverband.configuration.expects(:view_tracker).returns(tracker).at_least_once
+    tracker.railtie!
+
+    ActiveSupport::Notifications.instrument("render.view_component", view_identifier: file_path)
+
+    assert_includes tracker.logged_keys, file_path
+  end
+
   test "reset store" do
     Coverband::Collectors::ViewTracker.expects(:supported_version?).returns(true)
     store = fake_store
@@ -128,6 +141,20 @@ class ViewTrackerTest < Minitest::Test
     assert_equal [], tracker.logged_keys
   end
 
+  test "no-op tracker operations with non-redis stores" do
+    Coverband::Collectors::ViewTracker.expects(:supported_version?).returns(true)
+    store = Coverband::Adapters::NullStore.new
+    tracker = Coverband::Collectors::ViewTracker.new(store: store, roots: "dir")
+
+    tracker.track_key(identifier: "file")
+    tracker.save_report
+
+    assert_equal({}, tracker.used_keys)
+    assert_equal "N/A", tracker.tracking_since
+    assert_nil tracker.reset_recordings
+    assert_nil tracker.clear_key!("file")
+  end
+
   protected
 
   def fake_store

data/test/coverband/configuration_test.rb

@@ -112,4 +112,16 @@ class BaseTest < Minitest::Test
       config.redis_url = "redis://localhost:3333"
     end
   end
+
+  test "redis_url with rediss:// scheme for TLS support" do
+    Coverband::Collectors::Coverage.instance.reset_instance
+    Coverband.configuration.reset
+    # Verify that rediss:// URLs (TLS) can be configured
+    # The Redis gem will automatically enable TLS when it sees the rediss:// scheme
+    Coverband.configure do |config|
+      config.redis_url = "rediss://my-elasticache.example.com:6379"
+    end
+
+    assert_equal "rediss://my-elasticache.example.com:6379", Coverband.configuration.redis_url
+  end
 end

data/test/coverband/mcp/http_handler_test.rb

@@ -37,13 +37,13 @@ if defined?(Coverband::MCP)
       end
     end
 
-    test "handles MCP requests at /mcp endpoint" do
-      # Mock the server to return a simple response
-      server_mock = mock("server")
-      server_mock.expects(:handle_json).returns({"result" => "success"})
+    test "handles MCP POST requests at /mcp endpoint via StreamableHTTPTransport" do
+      # Mock the transport to verify it's called
+      transport_mock = mock("transport")
+      transport_mock.expects(:handle_request).returns([200, {"Content-Type" => "application/json"}, ["{}"]])
 
       handler = Coverband::MCP::HttpHandler.new
-      handler.expects(:mcp_server).returns(server_mock)
+      handler.expects(:transport).returns(transport_mock)
 
       @app = handler
 
@@ -56,12 +56,21 @@ if defined?(Coverband::MCP)
       post "/mcp", json_request, {"CONTENT_TYPE" => "application/json"}
 
       assert_equal 200, last_response.status
-      assert_equal "application/json", last_response.content_type
+    end
 
-      # Check CORS headers
-      assert_equal "*", last_response.headers["Access-Control-Allow-Origin"]
-      assert_equal "POST, OPTIONS", last_response.headers["Access-Control-Allow-Methods"]
-      assert_equal "Content-Type", last_response.headers["Access-Control-Allow-Headers"]
+    test "handles MCP GET requests at /mcp endpoint via StreamableHTTPTransport" do
+      # Mock the transport to verify it's called for GET
+      transport_mock = mock("transport")
+      transport_mock.expects(:handle_request).returns([200, {"Content-Type" => "text/event-stream"}, []])
+
+      handler = Coverband::MCP::HttpHandler.new
+      handler.expects(:transport).returns(transport_mock)
+
+      @app = handler
+
+      get "/mcp", {}, {"ACCEPT" => "text/event-stream"}
+
+      assert_equal 200, last_response.status
     end
 
     test "returns 404 for non-MCP requests when no wrapped app" do
@@ -81,51 +90,49 @@ if defined?(Coverband::MCP)
       assert_equal "wrapped app response", last_response.body
     end
 
-    test "only responds to POST requests for MCP endpoint" do
-      get "/mcp"
+    test "responds to GET, POST, DELETE, OPTIONS for MCP endpoint" do
+      transport_mock = mock("transport")
+      transport_mock.expects(:handle_request).at_least(3).returns([200, {"Content-Type" => "application/json"}, ["{}"]])
 
-      assert_equal 404, last_response.status
-    end
+      handler = Coverband::MCP::HttpHandler.new
+      handler.expects(:transport).at_least(3).returns(transport_mock)
 
-    test "handles invalid JSON gracefully" do
-      post "/mcp", "invalid json", {"CONTENT_TYPE" => "application/json"}
+      @app = handler
 
-      assert_equal 400, last_response.status
-      assert_equal "application/json", last_response.content_type
+      # POST request
+      post "/mcp", "{}", {"CONTENT_TYPE" => "application/json"}
+      assert_equal 200, last_response.status
 
-      response = JSON.parse(last_response.body)
-      assert_includes response["error"], "Invalid JSON"
-    end
+      # GET request
+      get "/mcp", {}, {"ACCEPT" => "text/event-stream"}
+      assert_equal 200, last_response.status
 
-    test "handles server errors gracefully" do
-      # Mock server to raise an error
-      server_mock = mock("server")
-      server_mock.expects(:handle_json).raises(StandardError.new("Test error"))
+      # DELETE request
+      delete "/mcp"
+      assert_equal 200, last_response.status
+    end
 
+    test "handles CORS preflight OPTIONS request" do
       handler = Coverband::MCP::HttpHandler.new
-      handler.expects(:mcp_server).returns(server_mock)
-
       @app = handler
 
-      json_request = {"test" => "request"}.to_json
-      post "/mcp", json_request, {"CONTENT_TYPE" => "application/json"}
-
-      assert_equal 500, last_response.status
+      options "/mcp"
 
-      response = JSON.parse(last_response.body)
-      assert_includes response["error"], "Server error: Test error"
+      assert_equal 204, last_response.status
+      assert_equal "*", last_response.headers["Access-Control-Allow-Origin"]
+      assert_equal "GET, POST, DELETE, OPTIONS", last_response.headers["Access-Control-Allow-Methods"]
     end
 
-    test "mcp_server is lazily initialized" do
-      handler = Coverband::MCP::HttpHandler.new
+    test "delegates non-MCP requests to wrapped app for non-POST" do
+      @app = app_with_wrapped_handler
 
-      # First call creates the server
-      server1 = handler.send(:mcp_server)
-      assert_instance_of Coverband::MCP::Server, server1
+      get "/other-path"
+      assert_equal 200, last_response.status
+      assert_equal "wrapped app response", last_response.body
 
-      # Second call returns the same instance
-      server2 = handler.send(:mcp_server)
-      assert_same server1, server2
+      delete "/other-path"
+      assert_equal 200, last_response.status
+      assert_equal "wrapped app response", last_response.body
     end
 
     test "mcp_request? correctly identifies MCP requests" do
@@ -136,15 +143,20 @@ if defined?(Coverband::MCP)
       request = Rack::Request.new(env)
       assert handler.send(:mcp_request?, request)
 
-      # POST request to /some-path/mcp (ends with /mcp)
-      env = Rack::MockRequest.env_for("/some-path/mcp", method: "POST")
+      # GET request to /mcp
+      env = Rack::MockRequest.env_for("/mcp", method: "GET")
       request = Rack::Request.new(env)
       assert handler.send(:mcp_request?, request)
 
-      # GET request to /mcp
-      env = Rack::MockRequest.env_for("/mcp", method: "GET")
+      # DELETE request to /mcp
+      env = Rack::MockRequest.env_for("/mcp", method: "DELETE")
       request = Rack::Request.new(env)
-      refute handler.send(:mcp_request?, request)
+      assert handler.send(:mcp_request?, request)
+
+      # OPTIONS request to /mcp
+      env = Rack::MockRequest.env_for("/mcp", method: "OPTIONS")
+      request = Rack::Request.new(env)
+      assert handler.send(:mcp_request?, request)
 
       # POST request to /other-path
       env = Rack::MockRequest.env_for("/other-path", method: "POST")