Introduce better Compact Index API stub for testing.

Author: simi

test/rubygems/helper.rb

@@ -1143,6 +1143,25 @@ def write_marshalled_gemspecs(*all_specs)
     end
   end
 
+  ##
+  # Sets up Compact Index API endpoints for testing. Does NOT set up old marshal API.
+  # This causes Source#new_dependency_resolver_set to use APISet.
+  #
+  # Usage:
+  #   compact_index do |ci|
+  #     ci.gem "a", 1 do |s|
+  #       s.add_dependency "b", ">= 2.0"
+  #     end
+  #     ci.gem "b", 2
+  #   end
+
+  def compact_index(&block)
+    fake_compact_index = Gem::TestCase::CompactIndexSetup.new(self, @gem_repo)
+    yield fake_compact_index
+    fake_compact_index.stub
+    fake_compact_index.specs
+  end
+
   ##
   # Deflates +data+
 

test/rubygems/test_gem_commands_install_command.rb

@@ -1644,38 +1644,22 @@ def test_execute_bindir_with_nonexistent_parent_dirs
   end
 
   def test_install_from_compact_index_only_source
-    specs = spec_fetcher do |fetcher|
-      fetcher.gem "main-gem", "2" do |s|
+    compact_index do |ci|
+      ci.gem "main-gem", "2" do |s|
         s.add_dependency "dep-gem", ">= 1.0"
       end
-      fetcher.gem "dep-gem", "1"
+      ci.gem "dep-gem", "1"
     end
 
-    compact_index_response = Gem::Net::HTTPResponse.new "1.1", 200, "OK"
-    compact_index_response.uri = Gem::URI(@gem_repo) + "versions"
-    @fetcher.data["#{@gem_repo}versions"] = compact_index_response
-
-    info_main_gem_response = <<~INFO
-      ---
-      2 dep-gem:>= 1.0|ruby:>= 2.5.0,rubygems:>= 3.0.0
-    INFO
-    @fetcher.data["#{@gem_repo}info/main-gem"] = info_main_gem_response
-
-    info_dep_gem_response = <<~INFO
-      ---
-      1 |ruby:>= 2.0.0
-    INFO
-    @fetcher.data["#{@gem_repo}info/dep-gem"] = info_dep_gem_response
-
-    @cmd.options[:args] = %w[main-gem] # gem install main-gem
+    @cmd.options[:args] = %w[main-gem]
 
     use_ui @ui do
       assert_raise Gem::MockGemUi::SystemExitException, @ui.error do
         @cmd.execute
       end
     end
 
-    assert_equal %w[main-gem-2], @cmd.installed_specs.map(&:full_name)
+    assert_equal %w[dep-gem-1 main-gem-2], @cmd.installed_specs.map(&:full_name).sort
 
     installed_gem = @cmd.installed_specs.find {|s| s.name == "main-gem" }
     assert_equal "main-gem", installed_gem.name

test/rubygems/utilities.rb

@@ -420,6 +420,108 @@ def write_spec(spec) # :nodoc:
   end
 end
 
+##
+# Minimal CompactIndex implementation for tests.
+# This is a simplified version that only implements what's needed for test fixtures.
+module CompactIndexBuilder
+  # Generates the /info/{gem_name} response body
+  # Format: ---\nVERSION DEPS|METADATA\n
+  # Where DEPS is: dep_name:requirement,dep_name:requirement
+  # And METADATA is: checksum:SHA256,ruby:requirement,rubygems:requirement
+  def self.info(versions)
+    lines = ["---"]
+    versions.each do |version|
+      parts = [version.version]
+
+      # Add dependencies (if any)
+      deps = version.dependencies.map {|d| "#{d.name}:#{d.requirement}" }
+      deps_string = deps.join(",")
+
+      # Build metadata
+      metadata = []
+      metadata << "checksum:#{version.checksum}" if version.checksum
+      metadata << "ruby:#{version.ruby_version}" if version.ruby_version && version.ruby_version != ">= 0"
+      metadata << "rubygems:#{version.rubygems_version}" if version.rubygems_version && version.rubygems_version != ">= 0"
+
+      # Format: "VERSION DEPS|METADATA" or "VERSION |METADATA" (space before | only when no deps)
+      line = "#{version.version} #{deps_string}|" + metadata.join(",")
+      lines << line
+    end
+    lines.join("\n") << "\n"
+  end
+
+  GemVersion = Data.define(:version, :platform, :checksum, :info_checksum, :dependencies, :ruby_version, :rubygems_version) do
+    def initialize(version:, platform:, checksum:, info_checksum: nil, dependencies: [], ruby_version: nil, rubygems_version: nil)
+      super(version:, platform:, checksum:, info_checksum:, dependencies:, ruby_version:, rubygems_version:)
+    end
+  end
+
+  Dependency = Data.define(:name, :requirement)
+end
+
+##
+# The CompactIndexSetup allows easy setup of compact index endpoints in tests.
+# Unlike SpecFetcherSetup, this only sets up compact index (no marshal API).
+#
+#   compact_index do |ci|
+#     ci.gem "a", 1 do |s|
+#       s.add_dependency "b", "~> 2.0"
+#     end
+#     ci.gem "b", 2
+#   end
+
+class Gem::TestCase::CompactIndexSetup
+  attr_reader :specs
+
+  def initialize(test, repository)
+    @test = test
+    @repository = repository
+    @test.fetcher = Gem::FakeFetcher.new
+    Gem::RemoteFetcher.fetcher = @test.fetcher
+    @specs = {}
+  end
+
+  def gem(name, version, dependencies = nil, &block)
+    spec = @test.util_spec(name, version, dependencies, &block)
+    @specs[spec.full_name] = spec
+  end
+
+  def stub
+    @specs.values.group_by(&:name).each do |name, gem_specs|
+      versions = gem_specs.map do |spec|
+        gem_file = Gem::Package.build(spec)
+        gem_contents = Gem.read_binary(gem_file)
+        FileUtils.cp gem_file, spec.cache_file
+
+        @test.fetcher.data["#{@repository}gems/#{spec.file_name}"] = gem_contents
+
+        dependencies = spec.dependencies.select(&:runtime?).map do |dep|
+          CompactIndexBuilder::Dependency.new(dep.name, dep.requirement.to_s)
+        end
+
+        checksum = Digest::SHA256.hexdigest(gem_contents)
+
+        CompactIndexBuilder::GemVersion.new(
+          spec.version.to_s,
+          spec.platform.to_s,
+          checksum,
+          nil,
+          dependencies,
+          spec.required_ruby_version.to_s,
+          spec.required_rubygems_version.to_s
+        )
+      end
+
+      @test.fetcher.data["#{@repository}info/#{name}"] = CompactIndexBuilder.info(versions)
+    end
+
+    # stub only to pass Compact Index API presence check currently
+    versions_response = Gem::Net::HTTPResponse.new "1.1", 200, "OK"
+    versions_response.uri = Gem::URI("#{@repository}versions")
+    @test.fetcher.data["#{@repository}versions"] = versions_response
+  end
+end
+
 ##
 # A StringIO duck-typed class that uses Tempfile instead of String as the
 # backing store.