coverband 6.1.5 → 6.1.7

data/test/coverband/initialization_timing_test.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# This test simulates the exact scenario from GitHub issue #586
+# to verify the timing and sequence of initialization
+
+require File.expand_path("../test_helper", File.dirname(__FILE__))
+
+class InitializationTimingTest < Minitest::Test
+  def setup
+    super
+    # Clear all state to simulate fresh require
+    Thread.current[:coverband_instance] = nil
+    Coverband.class_variable_set(:@@configured, false)
+    Coverband.configuration.instance_variable_set(:@store, nil)
+  end
+
+  def teardown
+    super
+    Thread.current[:coverband_instance] = nil
+    Coverband.configure do |config|
+      # Reset to default
+    end
+    Coverband.class_variable_set(:@@configured, false)
+  end
+
+  test "simulate auto-start before user configuration" do
+    # Clear configuration to simulate fresh require
+    Coverband.configuration.instance_variable_set(:@store, nil)
+    Coverband.class_variable_set(:@@configured, false)
+
+    # Mock Redis to fail when auto-start tries to create default store
+    Redis.expects(:new).raises(Redis::CannotConnectError.new("Connection refused")).once
+
+    # This simulates what happens during auto-start (configure + start)
+    # before user has configured anything
+    Coverband.configure  # No block, no file
+    Coverband.start
+
+    # At this point, the store should have fallen back to NullStore
+    assert_instance_of Coverband::Adapters::NullStore, Coverband.configuration.store
+
+    # Now user tries to configure with FileStore
+    Coverband.configure do |config|
+      config.store = Coverband::Adapters::FileStore.new("coverband/log")
+    end
+
+    # Should now use the configured FileStore
+    assert_instance_of Coverband::Adapters::FileStore, Coverband.configuration.store
+  end
+
+  test "check what happens if store is accessed before user configures it" do
+    # Clear configuration to simulate unconfigured state
+    Coverband.configuration.instance_variable_set(:@store, nil)
+    Coverband.class_variable_set(:@@configured, false)
+
+    # Mock Redis to fail
+    Redis.expects(:new).raises(Redis::CannotConnectError.new("Connection refused")).once
+
+    # Access store before configuration - should trigger fallback
+    store = Coverband.configuration.store
+    assert_instance_of Coverband::Adapters::NullStore, store
+
+    # Now configure with FileStore
+    Coverband.configure do |config|
+      config.store = Coverband::Adapters::FileStore.new("coverband/log")
+    end
+
+    # Should now use the configured FileStore
+    assert_instance_of Coverband::Adapters::FileStore, Coverband.configuration.store
+  end
+end

data/test/coverband/mcp/http_handler_test.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require File.expand_path("../../test_helper", File.dirname(__FILE__))
+require "rack/test"
+
+begin
+  require "coverband/mcp"
+rescue LoadError
+  puts "MCP gem not available, skipping MCP HTTP handler tests"
+end
+
+if defined?(Coverband::MCP)
+  class MCPHttpHandlerTest < Minitest::Test
+    include Rack::Test::Methods
+
+    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
+
+    def app
+      @app ||= Coverband::MCP::HttpHandler.new
+    end
+
+    def app_with_wrapped_handler
+      @wrapped_app ||= begin
+        mock_app = lambda { |env| [200, {"Content-Type" => "text/plain"}, ["wrapped app response"]] }
+        Coverband::MCP::HttpHandler.new(mock_app)
+      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"})
+
+      handler = Coverband::MCP::HttpHandler.new
+      handler.expects(:mcp_server).returns(server_mock)
+
+      @app = handler
+
+      json_request = {
+        "jsonrpc" => "2.0",
+        "method" => "tools/list",
+        "id" => 1
+      }.to_json
+
+      post "/mcp", json_request, {"CONTENT_TYPE" => "application/json"}
+
+      assert_equal 200, last_response.status
+      assert_equal "application/json", last_response.content_type
+
+      # 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"]
+    end
+
+    test "returns 404 for non-MCP requests when no wrapped app" do
+      get "/other-path"
+
+      assert_equal 404, last_response.status
+      assert_equal "text/plain", last_response.content_type
+      assert_equal "Not Found", last_response.body
+    end
+
+    test "delegates non-MCP requests to wrapped app" do
+      @app = app_with_wrapped_handler
+
+      get "/other-path"
+
+      assert_equal 200, last_response.status
+      assert_equal "wrapped app response", last_response.body
+    end
+
+    test "only responds to POST requests for MCP endpoint" do
+      get "/mcp"
+
+      assert_equal 404, last_response.status
+    end
+
+    test "handles invalid JSON gracefully" do
+      post "/mcp", "invalid json", {"CONTENT_TYPE" => "application/json"}
+
+      assert_equal 400, last_response.status
+      assert_equal "application/json", last_response.content_type
+
+      response = JSON.parse(last_response.body)
+      assert_includes response["error"], "Invalid JSON"
+    end
+
+    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"))
+
+      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
+
+      response = JSON.parse(last_response.body)
+      assert_includes response["error"], "Server error: Test error"
+    end
+
+    test "mcp_server is lazily initialized" do
+      handler = Coverband::MCP::HttpHandler.new
+
+      # First call creates the server
+      server1 = handler.send(:mcp_server)
+      assert_instance_of Coverband::MCP::Server, server1
+
+      # Second call returns the same instance
+      server2 = handler.send(:mcp_server)
+      assert_same server1, server2
+    end
+
+    test "mcp_request? correctly identifies MCP requests" do
+      handler = Coverband::MCP::HttpHandler.new
+
+      # POST request to /mcp path
+      env = Rack::MockRequest.env_for("/mcp", method: "POST")
+      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")
+      request = Rack::Request.new(env)
+      assert handler.send(:mcp_request?, request)
+
+      # GET request to /mcp
+      env = Rack::MockRequest.env_for("/mcp", method: "GET")
+      request = Rack::Request.new(env)
+      refute handler.send(:mcp_request?, request)
+
+      # POST request to /other-path
+      env = Rack::MockRequest.env_for("/other-path", method: "POST")
+      request = Rack::Request.new(env)
+      refute handler.send(:mcp_request?, request)
+    end
+
+    test "constant MCP_PATH is defined" do
+      assert_equal "/mcp", Coverband::MCP::HttpHandler::MCP_PATH
+    end
+  end
+end

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