paquette 0.1.0

data/test/gem_server/gem_repacker_test.rb

@@ -0,0 +1,289 @@
+require_relative "../test_helper"
+require "open3"
+
+class GemRepackerTest < Minitest::Test
+  def setup
+    @test_gem_path = File.join(FIXTURE_GEMS_DIR, "minuscule_test", "minuscule_test-0.1.0.gem")
+  end
+
+  def test_repack_with_line_transformation
+    assert File.exist?(@test_gem_path), "Test gem not found at #{@test_gem_path}"
+
+    # Generate random characters for the replacement
+    random_chars = (0...8).map { ("a".."z").to_a[rand(26)] }.join
+
+    # Use magic comment replacements to replace '# paquette_license_info' with '# LIC#{random_chars}'
+    new_gem_path = Paquette::GemServer::GemRepacker.repack(@test_gem_path,
+      gemspec_extras: {},
+      magic_comment_replacements: {"# paquette_license_info" => "LIC#{random_chars}"})
+
+    assert File.exist?(new_gem_path)
+    assert new_gem_path.end_with?("-repacked.gem")
+
+    # Unpack the produced gem and verify the replacement
+    verify_repacking(new_gem_path, random_chars)
+
+    # Clean up
+    File.delete(new_gem_path) if File.exist?(new_gem_path)
+  end
+
+  def test_repack_with_metadata_keys
+    assert File.exist?(@test_gem_path), "Test gem not found at #{@test_gem_path}"
+
+    # Test adding metadata keys to the gemspec
+    additional_metadata = {
+      "paquette.license_key" => "TEST-LICENSE-123",
+      "paquette.custom_field" => "custom_value"
+    }
+
+    new_gem_path = Paquette::GemServer::GemRepacker.repack(@test_gem_path,
+      gemspec_extras: additional_metadata,
+      magic_comment_replacements: {})
+
+    assert File.exist?(new_gem_path)
+    assert new_gem_path.end_with?("-repacked.gem")
+
+    # Verify the metadata was added to the gem spec
+    verify_metadata_in_gem(new_gem_path, additional_metadata)
+
+    # Clean up
+    File.delete(new_gem_path) if File.exist?(new_gem_path)
+  end
+
+  def test_repack_with_personalizer_metadata
+    assert File.exist?(@test_gem_path), "Test gem not found at #{@test_gem_path}"
+
+    # Test that Personalizer-style metadata addition works
+    personalized_gem_path = create_personalized_gem
+
+    # Verify the metadata was added
+    verify_metadata_in_gem(personalized_gem_path, {"paquette.license_key" => "TEST-LICENSE-456"})
+
+    # Clean up
+    File.delete(personalized_gem_path) if File.exist?(personalized_gem_path)
+  end
+
+  def test_repack_with_file_injection
+    assert File.exist?(@test_gem_path), "Test gem not found at #{@test_gem_path}"
+
+    # Test injecting new files into the gem
+    files_to_inject = {
+      "LICENSE" => "MIT License\nCopyright (c) 2024 Test Company",
+      "README.md" => "# Test Gem\n\nThis is a test gem with injected files.",
+      "docs/CHANGELOG.md" => "# Changelog\n\n## 0.1.0\n- Initial release"
+    }
+
+    new_gem_path = Paquette::GemServer::GemRepacker.repack(@test_gem_path,
+      gemspec_extras: {},
+      magic_comment_replacements: {},
+      files: files_to_inject)
+
+    assert File.exist?(new_gem_path)
+    assert new_gem_path.end_with?("-repacked.gem")
+
+    # Verify the injected files exist in the repacked gem
+    verify_injected_files(new_gem_path, files_to_inject)
+
+    # Clean up
+    File.delete(new_gem_path) if File.exist?(new_gem_path)
+  end
+
+  def test_repack_with_file_replacement
+    assert File.exist?(@test_gem_path), "Test gem not found at #{@test_gem_path}"
+
+    # Test replacing existing files in the gem
+    files_to_replace = {
+      "lib/minuscule_test.rb" => "# Replaced content\nmodule MinusculeTest\n  VERSION = '0.1.0-replaced'\nend"
+    }
+
+    new_gem_path = Paquette::GemServer::GemRepacker.repack(@test_gem_path,
+      gemspec_extras: {},
+      magic_comment_replacements: {},
+      files: files_to_replace)
+
+    assert File.exist?(new_gem_path)
+    assert new_gem_path.end_with?("-repacked.gem")
+
+    # Verify the file was replaced
+    verify_injected_files(new_gem_path, files_to_replace)
+
+    # Clean up
+    File.delete(new_gem_path) if File.exist?(new_gem_path)
+  end
+
+  def test_repack_with_combined_features
+    assert File.exist?(@test_gem_path), "Test gem not found at #{@test_gem_path}"
+
+    # Test combining file injection with other features
+    files_to_inject = {
+      "LICENSE" => "MIT License\nCopyright (c) 2024 Test Company",
+      "docs/README.md" => "# Test Gem\n\nThis gem has been personalized."
+    }
+
+    magic_comment_replacements = {
+      "# paquette_license_info" => "LICENSE-INJECTED"
+    }
+
+    gemspec_extras = {
+      "paquette.license_key" => "TEST-LICENSE-COMBINED"
+    }
+
+    new_gem_path = Paquette::GemServer::GemRepacker.repack(@test_gem_path,
+      gemspec_extras: gemspec_extras,
+      magic_comment_replacements: magic_comment_replacements,
+      files: files_to_inject)
+
+    assert File.exist?(new_gem_path)
+    assert new_gem_path.end_with?("-repacked.gem")
+
+    # Verify all features work together
+    verify_metadata_in_gem(new_gem_path, gemspec_extras)
+    verify_injected_files(new_gem_path, files_to_inject)
+
+    # Clean up
+    File.delete(new_gem_path) if File.exist?(new_gem_path)
+  end
+
+  def test_repack_with_magic_comment_replacements
+    assert File.exist?(@test_gem_path), "Test gem not found at #{@test_gem_path}"
+
+    # Test adding magic comment replacements
+    magic_comment_replacements = {
+      "# paquette_license_info" => "TEST-LICENSE-789",
+      "# paquette_custom_field" => "CUSTOM-VALUE-123"
+    }
+
+    new_gem_path = Paquette::GemServer::GemRepacker.repack(@test_gem_path,
+      gemspec_extras: {"paquette.license_key" => "TEST-LICENSE-789"},
+      magic_comment_replacements: magic_comment_replacements)
+
+    assert File.exist?(new_gem_path)
+    assert new_gem_path.end_with?("-repacked.gem")
+
+    # Verify the metadata was added to the gem spec
+    verify_metadata_in_gem(new_gem_path, {"paquette.license_key" => "TEST-LICENSE-789"})
+
+    # Clean up
+    File.delete(new_gem_path) if File.exist?(new_gem_path)
+  end
+
+  def test_personalizer_with_flexible_comment_replacements
+    assert File.exist?(@test_gem_path), "Test gem not found at #{@test_gem_path}"
+
+    # Test the Personalizer with custom magic comment replacements
+    dir_repository = Paquette::GemServer::DirectoryGemRepository.new(FIXTURE_GEMS_DIR)
+
+    custom_replacements = {
+      "# paquette_license_info" => "CUSTOM-LICENSE-123",
+      "# paquette_custom_field" => "CUSTOM-VALUE-456"
+    }
+
+    personalizer = Paquette::GemServer::Personalizer.new(dir_repository,
+      license_key: "CUSTOM-LICENSE-123",
+      magic_comment_replacements: custom_replacements)
+
+    # Get the personalized gem path
+    personalized_gem_path = personalizer.gem_file_path("minuscule_test", "0.1.0")
+    assert File.exist?(personalized_gem_path)
+
+    # Verify the metadata was added
+    verify_metadata_in_gem(personalized_gem_path, {"paquette.license_key" => "CUSTOM-LICENSE-123"})
+
+    # Clean up
+    File.delete(personalized_gem_path) if File.exist?(personalized_gem_path)
+  end
+
+  private
+
+  def verify_repacking(gem_path, expected_random_chars)
+    # Create a temporary directory to unpack the new gem
+    temp_dir = Dir.mktmpdir("verify_repacking")
+    unpacked_dir = File.join(temp_dir, "unpacked")
+    FileUtils.mkdir_p(unpacked_dir)
+
+    begin
+      # Unpack the new gem
+      _, stderr, status = Open3.capture3("gem unpack #{gem_path} --target=#{unpacked_dir}")
+      assert status.success?, "Failed to unpack the repacked gem: #{stderr}"
+
+      # Find the unpacked gem directory
+      gem_dir = Dir.glob(File.join(unpacked_dir, "*")).find { |path| File.directory?(path) }
+      assert gem_dir, "Could not find unpacked gem directory"
+
+      # Check all Ruby files for the replacement
+      found_replacement = false
+      Dir.glob(File.join(gem_dir, "**", "*.rb")).each do |rb_file|
+        File.readlines(rb_file).each do |line|
+          if line.chomp == "# LIC#{expected_random_chars}"
+            found_replacement = true
+          end
+          # Ensure the original line is gone
+          refute_equal line.chomp, "# paquette_license_info", "Original line still present in #{rb_file}"
+        end
+      end
+
+      assert found_replacement, "Replacement line '# LIC#{expected_random_chars}' not found in any Ruby file"
+    ensure
+      FileUtils.rm_rf(temp_dir)
+    end
+  end
+
+  def create_personalized_gem
+    # Create a personalized gem using the Personalizer approach
+    personalized_dir = File.join(Dir.tmpdir, "paquette_personalized")
+    FileUtils.mkdir_p(personalized_dir)
+
+    personalized_path = File.join(personalized_dir, "minuscule_test-0.1.0-personalized.gem")
+
+    Paquette::GemServer::GemRepacker.repack(@test_gem_path,
+      gemspec_extras: {"paquette.license_key" => "TEST-LICENSE-456"},
+      magic_comment_replacements: {"# paquette_license_info" => "TEST-LICENSE-456"})
+
+    # Move the repacked gem to our personalized location
+    temp_personalized = File.join(Dir.tmpdir, "minuscule_test-0.1.0-repacked.gem")
+    if File.exist?(temp_personalized)
+      FileUtils.mv(temp_personalized, personalized_path)
+    end
+
+    personalized_path
+  end
+
+  def verify_metadata_in_gem(gem_path, expected_metadata)
+    # Read the gem specification directly from the gem file
+    gem_package = Gem::Package.new(gem_path)
+    spec = gem_package.spec
+
+    # Verify each expected metadata key is present in the spec
+    expected_metadata.each do |key, value|
+      assert_equal value, spec.metadata[key], "Expected metadata key '#{key}' to have value '#{value}', but got '#{spec.metadata[key]}'"
+    end
+  end
+
+  def verify_injected_files(gem_path, expected_files)
+    # Create a temporary directory to unpack the new gem
+    temp_dir = Dir.mktmpdir("verify_injected_files")
+    unpacked_dir = File.join(temp_dir, "unpacked")
+    FileUtils.mkdir_p(unpacked_dir)
+
+    begin
+      # Unpack the new gem
+      _, stderr, status = Open3.capture3("gem unpack #{gem_path} --target=#{unpacked_dir}")
+      assert status.success?, "Failed to unpack the gem: #{stderr}"
+
+      # Find the unpacked gem directory
+      gem_dir = Dir.glob(File.join(unpacked_dir, "*")).find { |path| File.directory?(path) }
+      assert gem_dir, "Could not find unpacked gem directory"
+
+      # Verify each expected file exists and has the correct content
+      expected_files.each do |file_path, expected_content|
+        full_file_path = File.join(gem_dir, file_path)
+        assert File.exist?(full_file_path), "Expected file '#{file_path}' not found in unpacked gem"
+
+        actual_content = File.read(full_file_path)
+        assert_equal expected_content, actual_content, "File '#{file_path}' content doesn't match expected content"
+      end
+    ensure
+      FileUtils.rm_rf(temp_dir)
+    end
+  end
+end

data/test/gem_server/personalizer_metadata_test.rb

@@ -0,0 +1,49 @@
+require_relative "../test_helper"
+
+class PersonalizerMetadataTest < Minitest::Test
+  def setup
+    @gems_dir = FIXTURE_GEMS_DIR
+    @dir_repository = Paquette::GemServer::DirectoryGemRepository.new(@gems_dir)
+    @personalizer = Paquette::GemServer::Personalizer.new(@dir_repository, license_key: "TEST-LICENSE-789")
+  end
+
+  def test_personalizer_adds_license_metadata_to_gem_spec
+    skip "Test gem not found" unless @personalizer.gem_exists?("minuscule_test", "0.1.0")
+
+    # Get the personalized gem path
+    personalized_gem_path = @personalizer.gem_file_path("minuscule_test", "0.1.0")
+    assert File.exist?(personalized_gem_path)
+
+    # Read the gem specification and verify the license key metadata
+    gem_package = Gem::Package.new(personalized_gem_path)
+    spec = gem_package.spec
+
+    # Verify the license key is in the metadata
+    assert_equal "TEST-LICENSE-789", spec.metadata["paquette.license_key"], "Expected paquette.license_key metadata to be set"
+
+    # Verify the original gem doesn't have this metadata
+    original_gem_path = @dir_repository.gem_file_path("minuscule_test", "0.1.0")
+    original_gem_package = Gem::Package.new(original_gem_path)
+    original_spec = original_gem_package.spec
+
+    assert_nil original_spec.metadata["paquette.license_key"], "Original gem should not have paquette.license_key metadata"
+  end
+
+  def test_metadata_persistence_through_repository_stack
+    skip "Test gem not found" unless @personalizer.gem_exists?("minuscule_test", "0.1.0")
+
+    # Test that the metadata persists through the repository stack
+    personalized_repository = Paquette::GemServer::Personalizer.new(@dir_repository, license_key: "STACK-TEST-123")
+    gated_repository = Paquette::GemServer::ReadGatedRepository.new(personalized_repository) { |name:, version: nil| true }
+
+    # Get gem through the stack
+    gem_path = gated_repository.gem_file_path("minuscule_test", "0.1.0")
+    assert File.exist?(gem_path)
+
+    # Verify metadata is present
+    gem_package = Gem::Package.new(gem_path)
+    spec = gem_package.spec
+
+    assert_equal "STACK-TEST-123", spec.metadata["paquette.license_key"], "Expected paquette.license_key metadata to be set through repository stack"
+  end
+end

data/test/gem_server/personalizer_test.rb

@@ -0,0 +1,66 @@
+require_relative "../test_helper"
+
+class PersonalizerTest < Minitest::Test
+  def setup
+    @gems_dir = FIXTURE_GEMS_DIR
+    @dir_repository = Paquette::GemServer::DirectoryGemRepository.new(@gems_dir)
+    @personalizer = Paquette::GemServer::Personalizer.new(@dir_repository,
+      license_key: "TEST-LICENSE-123",
+      magic_comment_replacements: {"# paquette_license_info" => "TEST-LICENSE-123"})
+  end
+
+  def test_personalizer_delegates_to_repository
+    # Test that basic repository methods still work
+    assert @personalizer.gem_names.include?("minuscule_test")
+    assert @personalizer.versions_for_gem("minuscule_test").include?("0.1.0")
+    assert @personalizer.gem_exists?("minuscule_test", "0.1.0")
+  end
+
+  def test_gem_file_path_returns_personalized_gem
+    skip "Test gem not found" unless @personalizer.gem_exists?("minuscule_test", "0.1.0")
+
+    # Get the personalized gem path
+    personalized_path = @personalizer.gem_file_path("minuscule_test", "0.1.0")
+
+    # Should be a different path than the original
+    original_path = @dir_repository.gem_file_path("minuscule_test", "0.1.0")
+    refute_equal original_path, personalized_path
+
+    # Should exist and be a file
+    assert File.exist?(personalized_path)
+    assert File.file?(personalized_path)
+
+    # Should have a different checksum than the original
+    require "digest"
+    original_checksum = Digest::SHA256.file(original_path).hexdigest
+    personalized_checksum = Digest::SHA256.file(personalized_path).hexdigest
+    refute_equal original_checksum, personalized_checksum
+  end
+
+  def test_compact_info_uses_personalized_checksums
+    skip "Test gem not found" unless @personalizer.gem_exists?("minuscule_test", "0.1.0")
+
+    # Get compact info from personalizer
+    personalized_info = @personalizer.compact_info("minuscule_test")
+
+    # Get compact info from original repository
+    original_info = @dir_repository.compact_info("minuscule_test")
+
+    # Should have same number of versions
+    assert_equal original_info.length, personalized_info.length
+
+    # But checksums should be different
+    original_checksum = extract_checksum(original_info.first)
+    personalized_checksum = extract_checksum(personalized_info.first)
+
+    refute_equal original_checksum, personalized_checksum
+  end
+
+  private
+
+  def extract_checksum(info_line)
+    if (match = info_line.match(/checksum:([a-f0-9]+)/))
+      match[1]
+    end
+  end
+end

data/test/gem_server/read_gated_repository_test.rb

@@ -0,0 +1,254 @@
+require_relative "../test_helper"
+
+class ReadGatedRepositoryTest < Minitest::Test
+  def setup
+    @gems_dir = FIXTURE_GEMS_DIR
+    @directory_repository = Paquette::GemServer::DirectoryGemRepository.new(@gems_dir)
+  end
+
+  def test_gem_names_with_all_gems_entitled
+    entitler = ->(name:, version: nil) { true }
+    repository = Paquette::GemServer::ReadGatedRepository.new(@directory_repository, &entitler)
+
+    assert_equal ["minuscule_test", "zip_kit"], repository.gem_names.sort
+  end
+
+  def test_gem_names_with_only_zip_kit_entitled
+    entitler = ->(name:, version: nil) { name == "zip_kit" }
+    repository = Paquette::GemServer::ReadGatedRepository.new(@directory_repository, &entitler)
+
+    assert_equal ["zip_kit"], repository.gem_names
+  end
+
+  def test_gem_names_with_no_gems_entitled
+    entitler = ->(name:, version: nil) { false }
+    repository = Paquette::GemServer::ReadGatedRepository.new(@directory_repository, &entitler)
+
+    assert_equal [], repository.gem_names
+  end
+
+  def test_gem_versions_with_all_entitled
+    entitler = ->(name:, version: nil) { true }
+    repository = Paquette::GemServer::ReadGatedRepository.new(@directory_repository, &entitler)
+
+    versions = repository.gem_versions
+    assert_equal 3, versions.length
+
+    # standard:disable Style/HashSlice
+    zip_kit_versions = versions.select { |name, _| name == "zip_kit" }
+    # standard:enable Style/HashSlice
+    assert_equal 2, zip_kit_versions.length
+    assert_includes zip_kit_versions.map { |_, v| v }, "6.2.0"
+    assert_includes zip_kit_versions.map { |_, v| v }, "6.2.1"
+  end
+
+  def test_gem_versions_with_only_zip_kit_entitled
+    entitler = ->(name:, version: nil) { name == "zip_kit" }
+    repository = Paquette::GemServer::ReadGatedRepository.new(@directory_repository, &entitler)
+
+    versions = repository.gem_versions
+    assert_equal 2, versions.length
+    versions.each do |name, _|
+      assert_equal "zip_kit", name
+    end
+
+    zip_kit_versions = versions.map { |_, v| v }
+    assert_includes zip_kit_versions, "6.2.0"
+    assert_includes zip_kit_versions, "6.2.1"
+  end
+
+  def test_gem_versions_with_subset_of_zip_kit_versions_entitled
+    entitler = ->(name:, version: nil) do
+      name == "zip_kit" && (version.nil? || version == "6.2.0")
+    end
+    repository = Paquette::GemServer::ReadGatedRepository.new(@directory_repository, &entitler)
+
+    versions = repository.gem_versions
+    assert_equal 1, versions.length
+    assert_equal "zip_kit", versions.first.first
+    assert_equal "6.2.0", versions.first.last
+  end
+
+  def test_versions_for_gem_with_all_versions_entitled
+    entitler = ->(name:, version: nil) { true }
+    repository = Paquette::GemServer::ReadGatedRepository.new(@directory_repository, &entitler)
+
+    zip_kit_versions = repository.versions_for_gem("zip_kit")
+    assert_equal 2, zip_kit_versions.length
+    assert_includes zip_kit_versions, "6.2.0"
+    assert_includes zip_kit_versions, "6.2.1"
+  end
+
+  def test_versions_for_gem_with_only_zip_kit_entitled
+    entitler = ->(name:, version: nil) { name == "zip_kit" }
+    repository = Paquette::GemServer::ReadGatedRepository.new(@directory_repository, &entitler)
+
+    zip_kit_versions = repository.versions_for_gem("zip_kit")
+    assert_equal 2, zip_kit_versions.length
+    assert_includes zip_kit_versions, "6.2.0"
+    assert_includes zip_kit_versions, "6.2.1"
+
+    assert_equal [], repository.versions_for_gem("minuscule_test")
+  end
+
+  def test_versions_for_gem_with_subset_of_versions_entitled
+    entitler = ->(name:, version: nil) do
+      name == "zip_kit" && (version.nil? || version == "6.2.0")
+    end
+    repository = Paquette::GemServer::ReadGatedRepository.new(@directory_repository, &entitler)
+
+    zip_kit_versions = repository.versions_for_gem("zip_kit")
+    assert_equal ["6.2.0"], zip_kit_versions
+  end
+
+  def test_versions_for_gem_with_gem_not_entitled
+    entitler = ->(name:, version: nil) { name == "zip_kit" }
+    repository = Paquette::GemServer::ReadGatedRepository.new(@directory_repository, &entitler)
+
+    assert_equal [], repository.versions_for_gem("minuscule_test")
+  end
+
+  def test_gem_file_path_with_entitled_version
+    entitler = ->(name:, version: nil) { true }
+    repository = Paquette::GemServer::ReadGatedRepository.new(@directory_repository, &entitler)
+
+    expected_path = File.join(@gems_dir, "zip_kit", "zip_kit-6.2.0.gem")
+    assert_equal expected_path, repository.gem_file_path("zip_kit", "6.2.0")
+  end
+
+  def test_gem_file_path_with_not_entitled_version
+    entitler = ->(name:, version: nil) do
+      name == "zip_kit" && (version.nil? || version == "6.2.0")
+    end
+    repository = Paquette::GemServer::ReadGatedRepository.new(@directory_repository, &entitler)
+
+    expected_path = File.join(@gems_dir, "zip_kit", "zip_kit-6.2.0.gem")
+    assert_equal expected_path, repository.gem_file_path("zip_kit", "6.2.0")
+
+    assert_nil repository.gem_file_path("zip_kit", "6.2.1")
+  end
+
+  def test_gem_file_path_with_not_entitled_gem
+    entitler = ->(name:, version: nil) { name == "zip_kit" }
+    repository = Paquette::GemServer::ReadGatedRepository.new(@directory_repository, &entitler)
+
+    assert_nil repository.gem_file_path("minuscule_test", "0.1.0")
+  end
+
+  def test_gem_exists_with_entitled_version
+    entitler = ->(name:, version: nil) { true }
+    repository = Paquette::GemServer::ReadGatedRepository.new(@directory_repository, &entitler)
+
+    assert repository.gem_exists?("zip_kit", "6.2.0")
+    assert repository.gem_exists?("zip_kit", "6.2.1")
+    assert repository.gem_exists?("minuscule_test", "0.1.0")
+  end
+
+  def test_gem_exists_with_not_entitled_version
+    entitler = ->(name:, version: nil) do
+      name == "zip_kit" && (version.nil? || version == "6.2.0")
+    end
+    repository = Paquette::GemServer::ReadGatedRepository.new(@directory_repository, &entitler)
+
+    assert repository.gem_exists?("zip_kit", "6.2.0")
+    assert_nil repository.gem_exists?("zip_kit", "6.2.1")
+  end
+
+  def test_gem_exists_with_not_entitled_gem
+    entitler = ->(name:, version: nil) { name == "zip_kit" }
+    repository = Paquette::GemServer::ReadGatedRepository.new(@directory_repository, &entitler)
+
+    assert_nil repository.gem_exists?("minuscule_test", "0.1.0")
+  end
+
+  def test_compact_info_with_entitled_gem
+    entitler = ->(name:, version: nil) { true }
+    repository = Paquette::GemServer::ReadGatedRepository.new(@directory_repository, &entitler)
+
+    info = repository.compact_info("zip_kit")
+    assert info.is_a?(Array)
+    assert_equal 2, info.length
+    info.each do |line|
+      assert_match(/^\S+\s+\|checksum:[a-f0-9]{64},ruby:.+$/, line)
+    end
+
+    versions = info.map { |line| line.split(" ")[0] }
+    assert_includes versions, "6.2.0"
+    assert_includes versions, "6.2.1"
+  end
+
+  def test_compact_info_with_not_entitled_gem
+    entitler = ->(name:, version: nil) { name == "zip_kit" }
+    repository = Paquette::GemServer::ReadGatedRepository.new(@directory_repository, &entitler)
+
+    info = repository.compact_info("zip_kit")
+    assert info.is_a?(Array)
+    assert_equal 2, info.length
+
+    assert_nil repository.compact_info("minuscule_test")
+  end
+
+  def test_compact_info_with_subset_of_versions_entitled
+    entitler = ->(name:, version: nil) do
+      name == "zip_kit" && (version.nil? || version == "6.2.0")
+    end
+    repository = Paquette::GemServer::ReadGatedRepository.new(@directory_repository, &entitler)
+
+    info = repository.compact_info("zip_kit")
+    assert info.is_a?(Array)
+    assert_equal 1, info.length
+    assert_equal "6.2.0", info.first.split(" ")[0]
+  end
+
+  def test_add_gem_raises_write_not_allowed
+    repository = Paquette::GemServer::ReadGatedRepository.new(@directory_repository) { |**| true }
+
+    assert_raises(Paquette::GemServer::ReadGatedRepository::WriteNotAllowed) do
+      repository.add_gem("anything")
+    end
+  end
+
+  def test_yank_gem_raises_write_not_allowed
+    repository = Paquette::GemServer::ReadGatedRepository.new(@directory_repository) { |**| true }
+
+    assert_raises(Paquette::GemServer::ReadGatedRepository::WriteNotAllowed) do
+      repository.yank_gem("zip_kit", "6.2.0")
+    end
+  end
+
+  def test_delegated_methods_still_work
+    # Test that methods not overridden in ReadGatedRepository still delegate correctly
+    entitler = ->(name:, version: nil) { true }
+    repository = Paquette::GemServer::ReadGatedRepository.new(@directory_repository, &entitler)
+
+    spec = repository.gem_spec("zip_kit", "6.2.0")
+    refute_nil spec
+    assert_equal "zip_kit", spec.name
+    assert_equal "6.2.0", spec.version.to_s
+
+    deps = repository.gem_dependencies("zip_kit", "6.2.0")
+    assert deps.is_a?(Array)
+  end
+
+  def test_complex_entitlement_logic
+    # Allow zip_kit >= 6.2.1 and all minuscule_test
+    entitler = ->(name:, version: nil) do
+      if name == "zip_kit"
+        version.nil? || Gem::Version.new(version) >= Gem::Version.new("6.2.1")
+      else
+        name == "minuscule_test"
+      end
+    end
+    repository = Paquette::GemServer::ReadGatedRepository.new(@directory_repository, &entitler)
+
+    names = repository.gem_names
+    assert_includes names, "zip_kit"
+    assert_includes names, "minuscule_test"
+
+    zip_kit_versions = repository.versions_for_gem("zip_kit")
+    assert_equal ["6.2.1"], zip_kit_versions
+
+    minuscule_versions = repository.versions_for_gem("minuscule_test")
+    assert_equal ["0.1.0"], minuscule_versions
+  end
+end