coverband 6.1.5 → 6.1.7

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

@@ -0,0 +1,162 @@
+# 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 GetDeadMethodsTest < 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::GetDeadMethods.description, "methods that have never been executed"
+    end
+
+    test "input schema has optional file_pattern parameter" do
+      schema = Coverband::MCP::Tools::GetDeadMethods.input_schema
+      assert_instance_of ::MCP::Tool::InputSchema, schema
+    end
+
+    if defined?(RubyVM::AbstractSyntaxTree)
+      test "call returns dead methods when AST support available" do
+        mock_dead_methods = [
+          {
+            file_path: "/app/models/user.rb",
+            class_name: "User",
+            method_name: "unused_method",
+            line_number: 10
+          },
+          {
+            file_path: "/app/models/user.rb",
+            class_name: "User",
+            method_name: "another_unused",
+            line_number: 15
+          },
+          {
+            file_path: "/app/models/order.rb",
+            class_name: "Order",
+            method_name: "dead_method",
+            line_number: 20
+          }
+        ]
+
+        Coverband::Utils::DeadMethods.expects(:scan_all).returns(mock_dead_methods)
+
+        response = Coverband::MCP::Tools::GetDeadMethods.call(server_context: {})
+
+        assert_instance_of ::MCP::Tool::Response, response
+
+        result = JSON.parse(response.content.first[:text])
+
+        assert_equal 3, result["total_dead_methods"]
+        assert_equal 2, result["files_with_dead_methods"]
+        assert_nil result["file_pattern"]
+
+        # Check grouped results
+        user_file = result["results"].find { |f| f["file"] == "/app/models/user.rb" }
+        assert_equal 2, user_file["dead_methods"].length
+
+        order_file = result["results"].find { |f| f["file"] == "/app/models/order.rb" }
+        assert_equal 1, order_file["dead_methods"].length
+
+        # Check method details
+        user_method = user_file["dead_methods"].first
+        assert_equal "User", user_method["class_name"]
+        assert_equal "unused_method", user_method["method_name"]
+        assert_equal 10, user_method["line_number"]
+      end
+
+      test "call filters by file_pattern when provided" do
+        mock_dead_methods = [
+          {
+            file_path: "/app/models/user.rb",
+            class_name: "User",
+            method_name: "unused_method",
+            line_number: 10
+          },
+          {
+            file_path: "/app/helpers/user_helper.rb",
+            class_name: "UserHelper",
+            method_name: "dead_helper",
+            line_number: 5
+          }
+        ]
+
+        Coverband::Utils::DeadMethods.expects(:scan_all).returns(mock_dead_methods)
+
+        response = Coverband::MCP::Tools::GetDeadMethods.call(
+          file_pattern: "/app/models/**/*.rb",
+          server_context: {}
+        )
+
+        result = JSON.parse(response.content.first[:text])
+
+        # Should only include the models file
+        assert_equal 1, result["total_dead_methods"]
+        assert_equal 1, result["files_with_dead_methods"]
+        assert_equal "/app/models/**/*.rb", result["file_pattern"]
+
+        assert_equal 1, result["results"].length
+        assert_equal "/app/models/user.rb", result["results"].first["file"]
+      end
+
+      test "call handles no dead methods found" do
+        Coverband::Utils::DeadMethods.expects(:scan_all).returns([])
+
+        response = Coverband::MCP::Tools::GetDeadMethods.call(server_context: {})
+
+        result = JSON.parse(response.content.first[:text])
+
+        assert_equal 0, result["total_dead_methods"]
+        assert_equal 0, result["files_with_dead_methods"]
+        assert_empty result["results"]
+      end
+    end
+
+    test "call returns error when AST support not available" do
+      # Temporarily hide the constant
+      if defined?(RubyVM::AbstractSyntaxTree)
+        original_ast = RubyVM::AbstractSyntaxTree
+        RubyVM.send(:remove_const, :AbstractSyntaxTree)
+      end
+
+      begin
+        response = Coverband::MCP::Tools::GetDeadMethods.call(server_context: {})
+
+        assert_instance_of ::MCP::Tool::Response, response
+        assert_includes response.content.first[:text], "requires Ruby 2.6+ with RubyVM::AbstractSyntaxTree"
+      ensure
+        # Restore the constant if it was defined
+        if defined?(original_ast)
+          RubyVM.const_set(:AbstractSyntaxTree, original_ast)
+        end
+      end
+    end
+
+    test "call handles errors gracefully" do
+      if defined?(RubyVM::AbstractSyntaxTree)
+        Coverband::Utils::DeadMethods.expects(:scan_all).raises(StandardError.new("Test error"))
+
+        response = Coverband::MCP::Tools::GetDeadMethods.call(server_context: {})
+
+        assert_instance_of ::MCP::Tool::Response, response
+        assert_includes response.content.first[:text], "Error analyzing dead methods: Test error"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,159 @@
+# 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 GetFileCoverageTest < 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::GetFileCoverage.description, "line-by-line coverage data"
+    end
+
+    test "input schema requires filename parameter" do
+      schema = Coverband::MCP::Tools::GetFileCoverage.input_schema
+      assert_instance_of ::MCP::Tool::InputSchema, schema
+    end
+
+    test "call returns file coverage data when file exists" do
+      filename = "app/models/user.rb"
+      full_path = "/app/app/models/user.rb"
+
+      mock_file_data = {
+        "filename" => full_path,
+        "covered_percent" => 85.0,
+        "lines_of_code" => 100,
+        "lines_covered" => 85,
+        "lines_missed" => 15,
+        "runtime_percentage" => 90.0,
+        "never_loaded" => false,
+        "coverage" => [1, 1, 0, 1, 1, nil, 1]
+      }
+
+      mock_data = {
+        "files" => {
+          full_path => mock_file_data
+        }
+      }
+
+      report_mock = mock("json_report")
+      report_mock.expects(:report).returns(mock_data.to_json)
+      Coverband::Reporters::JSONReport.expects(:new).with(
+        Coverband.configuration.store,
+        {filename: filename, line_coverage: true}
+      ).returns(report_mock)
+
+      response = Coverband::MCP::Tools::GetFileCoverage.call(
+        filename: filename,
+        server_context: {}
+      )
+
+      assert_instance_of ::MCP::Tool::Response, response
+
+      result = JSON.parse(response.content.first[:text])
+      assert_includes result, full_path
+      assert_equal 85.0, result[full_path]["covered_percent"]
+      assert_equal 100, result[full_path]["lines_of_code"]
+      assert_equal [1, 1, 0, 1, 1, nil, 1], result[full_path]["coverage"]
+    end
+
+    test "call returns message when no files found" do
+      filename = "nonexistent.rb"
+
+      mock_data = {"files" => nil}
+
+      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::GetFileCoverage.call(
+        filename: filename,
+        server_context: {}
+      )
+
+      assert_instance_of ::MCP::Tool::Response, response
+      assert_includes response.content.first[:text], "No coverage data found for file: nonexistent.rb"
+    end
+
+    test "call returns message when no matching files" do
+      filename = "nonexistent.rb"
+
+      mock_data = {
+        "files" => {
+          "/app/other/file.rb" => {"filename" => "/app/other/file.rb"}
+        }
+      }
+
+      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::GetFileCoverage.call(
+        filename: filename,
+        server_context: {}
+      )
+
+      assert_instance_of ::MCP::Tool::Response, response
+      assert_includes response.content.first[:text], "No coverage data found for file matching: nonexistent.rb"
+    end
+
+    test "call handles partial filename matches" do
+      filename = "user"
+
+      matching_files = {
+        "/app/models/user.rb" => {"filename" => "/app/models/user.rb", "covered_percent" => 85.0},
+        "/app/helpers/user_helper.rb" => {"filename" => "/app/helpers/user_helper.rb", "covered_percent" => 90.0}
+      }
+
+      mock_data = {
+        "files" => matching_files.merge({
+          "/app/models/order.rb" => {"filename" => "/app/models/order.rb", "covered_percent" => 75.0}
+        })
+      }
+
+      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::GetFileCoverage.call(
+        filename: filename,
+        server_context: {}
+      )
+
+      result = JSON.parse(response.content.first[:text])
+      assert_equal 2, result.keys.length
+      assert_includes result, "/app/models/user.rb"
+      assert_includes result, "/app/helpers/user_helper.rb"
+      refute_includes result, "/app/models/order.rb"
+    end
+
+    test "call handles errors gracefully" do
+      Coverband::Reporters::JSONReport.expects(:new).raises(StandardError.new("Test error"))
+
+      response = Coverband::MCP::Tools::GetFileCoverage.call(
+        filename: "test.rb",
+        server_context: {}
+      )
+
+      assert_instance_of ::MCP::Tool::Response, response
+      assert_includes response.content.first[:text], "Error getting file coverage: Test error"
+    end
+  end
+end

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