cov-loupe 3.0.0 → 4.0.0.pre

data/spec/version_spec.rb

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe 'CovLoupe::VERSION' do
-  describe 'constant existence' do
-    it 'defines a VERSION constant' do
-      expect(CovLoupe.const_defined?(:VERSION)).to be true
-    end
-
-    it 'exposes VERSION as a non-empty string' do
-      expect(CovLoupe::VERSION).to be_a(String)
-      expect(CovLoupe::VERSION).not_to be_empty
-    end
-
-    it 'is frozen (immutable)' do
-      expect(CovLoupe::VERSION).to be_frozen
-    end
-  end
-
-  describe 'semantic versioning compliance' do
-    let(:version) { CovLoupe::VERSION }
-    # Simplified semantic versioning regex
-    # Preserves key semver rules: no leading zeros on numeric parts, optional prerelease/build metadata
-    let(:semver_regex) do
-      %r{\A
-        (?<major>0|[1-9]\d*)\.
-        (?<minor>0|[1-9]\d*)\.
-        (?<patch>0|[1-9]\d*)
-        (?:[.-](?<prerelease>[0-9A-Za-z.-]+))?
-        (?:\+(?<buildmetadata>[0-9A-Za-z.-]+))?
-      \z}x
-    end
-
-    it 'follows semantic versioning format (accepting hyphen or dot pre-release separator)' do
-      expect(version).to match(semver_regex)
-    end
-
-    it 'has valid major.minor.patch core version' do
-      match = version.match(semver_regex)
-      expect(match).not_to be_nil, "VERSION '#{version}' does not match semantic versioning format"
-
-      major = match[:major].to_i
-      minor = match[:minor].to_i
-      patch = match[:patch].to_i
-
-      expect(major).to be >= 0
-      expect(minor).to be >= 0
-      expect(patch).to be >= 0
-    end
-
-    context 'when version has prerelease identifier' do
-      let(:prerelease_version) { '9.9.9-rc.1' }
-
-      before do
-        stub_const('CovLoupe::VERSION', prerelease_version)
-      end
-
-      it 'has valid prerelease format' do
-        match = version.match(semver_regex)
-        prerelease = match[:prerelease]
-        expect(prerelease).not_to be_empty
-        expect(prerelease).not_to start_with('.')
-        expect(prerelease).not_to end_with('.')
-      end
-    end
-
-    context 'when version has build metadata' do
-      let(:build_metadata_version) { '9.9.9+build.42' }
-
-      before do
-        stub_const('CovLoupe::VERSION', build_metadata_version)
-      end
-
-      it 'has valid build metadata format' do
-        match = version.match(semver_regex)
-        buildmetadata = match[:buildmetadata]
-        expect(buildmetadata).not_to be_empty
-        expect(buildmetadata).to match(/\A[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*\z/)
-      end
-    end
-  end
-
-  describe 'version consistency' do
-    it 'is accessible via require path' do
-      expect { CovLoupe::VERSION }.not_to raise_error
-    end
-
-    it 'matches the version referenced in gemspec' do
-      gemspec_path = File.expand_path('../cov-loupe.gemspec', __dir__)
-      gemspec_content = File.read(gemspec_path)
-
-      version_line = gemspec_content.lines.find { |line| line.include?('spec.version') }
-      expect(version_line).not_to be_nil, 'Could not find version line in gemspec'
-      expect(version_line).to include('CovLoupe::VERSION')
-    end
-  end
-
-  describe 'current version sanity check' do
-    it 'is not the initial 0.0.0 version' do
-      # Ensure this is a real release, not an uninitialized version
-      expect(CovLoupe::VERSION).not_to eq('0.0.0')
-    end
-  end
-
-  describe 'standalone version file load' do
-    it 'defines the module and VERSION constant when only version.rb is loaded' do
-      original_version = CovLoupe::VERSION
-
-      stub_const('CovLoupe', Module.new do
-        class << self
-          attr_accessor :default_log_file, :active_log_file
-        end
-      end)
-
-      version_path = File.expand_path('../lib/cov_loupe/version.rb', __dir__)
-      load version_path
-
-      expect(Object.const_defined?(:CovLoupe)).to be true
-      expect(CovLoupe::VERSION).to eq(original_version)
-    end
-  end
-end

data/spec/version_tool_spec.rb

@@ -1,141 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'cov_loupe/tools/version_tool'
-
-RSpec.describe CovLoupe::Tools::VersionTool do
-  let(:server_context) { instance_double('ServerContext').as_null_object }
-
-  before do
-    setup_mcp_response_stub
-  end
-
-  describe '.call' do
-    it 'returns a text payload with the version string when called without arguments' do
-      response = described_class.call(server_context: server_context)
-      item = response.payload.first
-      expect(item[:type] || item['type']).to eq('text')
-      text = item['text']
-      expect(text).to eq("CovLoupe version: #{CovLoupe::VERSION}")
-    end
-
-    it 'includes the exact version constant value' do
-      response = described_class.call(server_context: server_context)
-      item = response.payload.first
-      text = item['text']
-      expect(text).to include(CovLoupe::VERSION)
-    end
-
-    it 'matches the expected format exactly' do
-      expected_format = "CovLoupe version: #{CovLoupe::VERSION}"
-      response = described_class.call(server_context: server_context)
-      item = response.payload.first
-      text = item['text']
-      expect(text).to eq(expected_format)
-    end
-
-    it 'returns an MCP::Tool::Response object' do
-      response = described_class.call(server_context: server_context)
-      expect(response).to be_a(MCP::Tool::Response)
-    end
-
-    it 'has a single payload item' do
-      response = described_class.call(server_context: server_context)
-      expect(response.payload).to be_an(Array)
-      expect(response.payload.size).to eq(1)
-    end
-
-    context 'when error_mode is specified' do
-      it 'accepts error_mode parameter without affecting output' do
-        response = described_class.call(error_mode: 'off', server_context: server_context)
-        item = response.payload.first
-        text = item['text']
-        expect(text).to eq("CovLoupe version: #{CovLoupe::VERSION}")
-      end
-
-      it 'accepts error_mode "log" (default)' do
-        response = described_class.call(error_mode: 'log', server_context: server_context)
-        item = response.payload.first
-        expect(item[:type] || item['type']).to eq('text')
-      end
-
-      it 'accepts error_mode "debug"' do
-        response = described_class.call(error_mode: 'debug', server_context: server_context)
-        item = response.payload.first
-        expect(item[:type] || item['type']).to eq('text')
-      end
-    end
-
-    context 'when additional arguments are passed' do
-      it 'ignores additional arguments gracefully' do
-        response = described_class.call(
-          server_context: server_context,
-          extra_arg: 'value',
-          another: { nested: 'data' }
-        )
-        item = response.payload.first
-        text = item['text']
-        expect(text).to eq("CovLoupe version: #{CovLoupe::VERSION}")
-      end
-    end
-
-    context 'when an error occurs' do
-      it 'handles VERSION constant access errors and returns structured error response' do
-        # Force an error by hiding VERSION so const_missing is triggered
-        hide_const('CovLoupe::VERSION')
-        allow(CovLoupe).to receive(:const_missing).with(:VERSION)
-          .and_raise(StandardError, 'Version access error')
-
-        response = described_class.call(error_mode: 'log', server_context: server_context)
-
-        # Should return error response in MCP format
-        expect(response).to be_a(MCP::Tool::Response)
-        item = response.payload.first
-        expect(item[:type] || item['type']).to eq('text')
-
-        error_text = item['text']
-        expect(error_text).to include('Error')
-      end
-
-      it 'handles errors in the response creation process' do
-        # Force an error by mocking string interpolation to fail
-        version_obj = double('VERSION')
-        allow(version_obj).to receive(:to_s).and_raise(StandardError, 'String conversion error')
-
-        # Replace VERSION with our mock object
-        stub_const('CovLoupe::VERSION', version_obj)
-
-        response = described_class.call(error_mode: 'log', server_context: server_context)
-
-        # Should return error response in MCP format via the rescue block
-        expect(response).to be_a(MCP::Tool::Response)
-        item = response.payload.first
-        expect(item[:type] || item['type']).to eq('text')
-
-        error_text = item['text']
-        expect(error_text).to include('Error')
-      end
-
-      it 'respects error_mode setting when handling errors' do
-        # Force an error using a mock VERSION that raises an exception
-        version_obj = double('VERSION')
-        allow(version_obj).to receive(:to_s).and_raise(StandardError, 'Version error')
-        stub_const('CovLoupe::VERSION', version_obj)
-
-        # Test error_mode 'off' (should be silent but still return structured response)
-        response = described_class.call(error_mode: 'off', server_context: server_context)
-        expect(response).to be_a(MCP::Tool::Response)
-        item = response.payload.first
-        expect(item[:type] || item['type']).to eq('text')
-
-        # Test error_mode 'debug' (should include more detail)
-        response = described_class.call(error_mode: 'debug', server_context: server_context)
-        expect(response).to be_a(MCP::Tool::Response)
-        item = response.payload.first
-        expect(item[:type] || item['type']).to eq('text')
-        error_text = item['text']
-        expect(error_text).to include('Error')
-      end
-    end
-  end
-end