coverband 6.1.6 → 6.1.7

data/test/coverband/mcp/security_test.rb

@@ -0,0 +1,145 @@
+# 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 security tests"
+end
+
+if defined?(Coverband::MCP)
+  class MCPSecurityTest < Minitest::Test
+    def setup
+      super
+      # Don't enable MCP by default - we want to test security
+      Coverband.configure do |config|
+        config.store = Coverband::Adapters::RedisStore.new(Redis.new(db: 2))
+      end
+    end
+
+    def teardown
+      super
+      Coverband.configuration.store&.clear!
+    end
+
+    test "MCP is disabled by default" do
+      refute Coverband.configuration.mcp_enabled?, "MCP should be disabled by default"
+    end
+
+    test "cannot create MCP server when disabled" do
+      error = assert_raises(SecurityError) do
+        Coverband::MCP::Server.new
+      end
+
+      assert_includes error.message, "MCP is not enabled"
+      assert_includes error.message, "config.mcp_enabled = true"
+    end
+
+    test "MCP can be enabled for allowed environments" do
+      # Test environment should be allowed by default
+      Coverband.configuration.mcp_enabled = true
+
+      assert Coverband.configuration.mcp_enabled?, "MCP should be enabled when explicitly set"
+
+      # Should be able to create server now
+      server = Coverband::MCP::Server.new
+      refute_nil server
+    end
+
+    test "environment restrictions work correctly" do
+      Coverband.configuration.mcp_enabled = true
+
+      # Temporarily override environment detection
+      original_env_var = ENV["RAILS_ENV"]
+      ENV["RAILS_ENV"] = "production"
+
+      begin
+        refute Coverband.configuration.mcp_enabled?,
+          "MCP should be disabled in production environment"
+      ensure
+        if original_env_var
+          ENV["RAILS_ENV"] = original_env_var
+        else
+          ENV.delete("RAILS_ENV")
+        end
+      end
+    end
+
+    test "authentication works with valid password" do
+      Coverband.configuration.mcp_enabled = true
+      Coverband.configuration.mcp_password = "test-password"
+
+      handler = Coverband::MCP::HttpHandler.new
+      request = create_mock_request_with_auth("Bearer test-password")
+
+      # Should pass authentication
+      handler.call(request.env)
+      # Note: We're not testing the full response, just that it doesn't error with auth
+    end
+
+    test "authentication fails with invalid password" do
+      Coverband.configuration.mcp_enabled = true
+      Coverband.configuration.mcp_password = "test-password"
+
+      handler = Coverband::MCP::HttpHandler.new
+      request = create_mock_request_with_auth("Bearer wrong-password")
+
+      response = handler.call(request.env)
+
+      assert_equal 401, response[0], "Should return 401 Unauthorized"
+    end
+
+    test "authentication fails without password" do
+      Coverband.configuration.mcp_enabled = true
+      Coverband.configuration.mcp_password = "test-password"
+
+      handler = Coverband::MCP::HttpHandler.new
+      request = create_mock_request_without_auth
+
+      response = handler.call(request.env)
+
+      assert_equal 401, response[0], "Should return 401 Unauthorized without auth"
+    end
+
+    test "allowed environments can be customized" do
+      original_envs = Coverband.configuration.mcp_allowed_environments
+
+      begin
+        Coverband.configuration.mcp_allowed_environments = ["custom"]
+        Coverband.configuration.mcp_enabled = true
+
+        # Should be disabled because "test" is not in custom allowed environments
+        refute Coverband.configuration.mcp_enabled?,
+          "MCP should respect custom allowed environments"
+      ensure
+        Coverband.configuration.mcp_allowed_environments = original_envs
+      end
+    end
+
+    private
+
+    def create_mock_request_with_auth(auth_header)
+      request = mock("request")
+      request.stubs(:env).returns({
+        "REQUEST_METHOD" => "POST",
+        "PATH_INFO" => "/mcp",
+        "HTTP_AUTHORIZATION" => auth_header,
+        "rack.input" => StringIO.new("{}"),
+        "CONTENT_TYPE" => "application/json"
+      })
+      request
+    end
+
+    def create_mock_request_without_auth
+      request = mock("request")
+      request.stubs(:env).returns({
+        "REQUEST_METHOD" => "POST",
+        "PATH_INFO" => "/mcp",
+        "rack.input" => StringIO.new("{}"),
+        "CONTENT_TYPE" => "application/json"
+      })
+      request
+    end
+  end
+end

data/test/coverband/mcp/server_test.rb

@@ -0,0 +1,125 @@
+# 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 tests"
+end
+
+if defined?(Coverband::MCP)
+  class MCPServerTest < 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
+      @server = Coverband::MCP::Server.new
+    end
+
+    def teardown
+      super
+      Coverband.configuration.store&.clear!
+    end
+
+    test "server initializes with correct attributes" do
+      assert_equal "coverband", @server.mcp_server.name
+      assert_equal Coverband::VERSION, @server.mcp_server.version
+      assert_includes @server.mcp_server.instructions, "Coverband production code coverage"
+      refute_empty @server.mcp_server.tools
+    end
+
+    test "server has all expected tools registered" do
+      tool_names = @server.mcp_server.tools.keys
+      expected_tools = [
+        "get_coverage_summary",
+        "get_file_coverage",
+        "get_uncovered_files",
+        "get_dead_methods",
+        "get_view_tracker_data",
+        "get_route_tracker_data",
+        "get_translation_tracker_data"
+      ]
+
+      expected_tools.each do |tool_name|
+        assert_includes tool_names, tool_name, "Expected tool #{tool_name} to be registered"
+      end
+    end
+
+    test "server configures Coverband if not already configured" do
+      # Reset configuration
+      Coverband.instance_variable_set(:@configuration, nil)
+
+      # Enable MCP for the new configuration
+      Coverband.configure do |config|
+        config.mcp_enabled = true
+      end
+
+      # Creating server should auto-configure
+      Coverband::MCP::Server.new
+
+      assert Coverband.configured?, "Coverband should be auto-configured"
+    end
+
+    test "run_stdio creates and opens stdio transport" do
+      transport_mock = mock("stdio_transport")
+      transport_mock.expects(:open).once
+
+      ::MCP::Server::Transports::StdioTransport.expects(:new).with(@server.mcp_server).returns(transport_mock)
+
+      @server.run_stdio
+    end
+
+    test "run_http starts server with correct configuration" do
+      # Mock the handler - stub the handler lookup method that exists
+      handler_mock = mock("handler")
+      handler_mock.expects(:run).once
+
+      # Just stub the method on the server itself to avoid version dependencies
+      @server.expects(:puts).at_least_once # For the info output
+
+      # Mock Rack handler differently to avoid version issues
+      require "rack"
+      if defined?(Rackup) && Rackup.respond_to?(:server)
+        Rackup.expects(:server).with("puma").returns(handler_mock)
+      else
+        # Skip this test if we can't properly mock the handler
+        skip "Unable to mock Rack handler in this environment"
+      end
+
+      @server.run_http(port: 9999, host: "test.local")
+    end
+
+    test "handle_json delegates to mcp_server" do
+      json_request = {"method" => "test"}
+      expected_response = {"result" => "success"}
+
+      @server.mcp_server.expects(:handle_json).with(json_request).returns(expected_response)
+
+      result = @server.handle_json(json_request)
+      assert_equal expected_response, result
+    end
+
+    test "create_rack_app returns functioning rack application" do
+      transport = mock("transport")
+      app = @server.send(:create_rack_app, transport)
+
+      assert_respond_to app, :call
+
+      # Test request handling - just verify the transport is called
+      env = {"REQUEST_METHOD" => "POST", "PATH_INFO" => "/"}
+      transport.expects(:handle_request).with(kind_of(Rack::Request)).returns([200, {}, ["response"]])
+
+      response = app.call(env)
+
+      # Just check status and that we got a response (middleware may wrap body)
+      assert_equal 200, response[0]
+    end
+
+    test "default http port is 9023" do
+      assert_equal 9023, Coverband::MCP::Server::DEFAULT_HTTP_PORT
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# 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 GetCoverageSummaryTest < 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::GetCoverageSummary.description, "overall production code coverage"
+    end
+
+    test "input schema has no required parameters" do
+      schema = Coverband::MCP::Tools::GetCoverageSummary.input_schema
+      # Schema should be an InputSchema object
+      assert_instance_of ::MCP::Tool::InputSchema, schema
+    end
+
+    test "call returns coverage summary" do
+      # Mock the JSON report
+      mock_data = {
+        "total_files" => 50,
+        "lines_of_code" => 1000,
+        "lines_covered" => 800,
+        "lines_missed" => 200,
+        "covered_percent" => 80.0,
+        "covered_strength" => 85.5
+      }
+
+      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::GetCoverageSummary.call(server_context: {})
+
+      assert_instance_of ::MCP::Tool::Response, response
+      assert_equal 1, response.content.length
+      assert_equal "text", response.content.first[:type]
+
+      result = JSON.parse(response.content.first[:text])
+      assert_equal 50, result["total_files"]
+      assert_equal 1000, result["lines_of_code"]
+      assert_equal 800, result["lines_covered"]
+      assert_equal 200, result["lines_missed"]
+      assert_equal 80.0, result["covered_percent"]
+      assert_equal 85.5, result["covered_strength"]
+    end
+
+    test "call handles errors gracefully" do
+      Coverband::Reporters::JSONReport.expects(:new).raises(StandardError.new("Test error"))
+
+      response = Coverband::MCP::Tools::GetCoverageSummary.call(server_context: {})
+
+      assert_instance_of ::MCP::Tool::Response, response
+      assert_includes response.content.first[:text], "Error getting coverage summary: Test error"
+    end
+  end
+end

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