gem_server_conformance 0.1.0

data/spec/support/request_helpers.rb

@@ -0,0 +1,364 @@
+# frozen_string_literal: true
+
+require "rubygems/gemcutter_utilities"
+
+module RequestHelpers
+  def self.included(base)
+    super
+    base.attr_reader :last_response
+  end
+
+  def build_gem(name, version, platform: nil)
+    spec = Gem::Specification.new do |s|
+      s.name = name
+      s.version = version
+      s.authors = ["Conformance"]
+      s.summary = "Conformance test"
+      s.files = []
+      s.date = "2024-07-09"
+      s.platform = platform if platform
+    end
+    yield spec if block_given?
+
+    package = Gem::Package.new(StringIO.new.binmode)
+    package.build_time = Time.utc(1970)
+    package.spec = spec
+    package.setup_signer
+    signer = package.instance_variable_get(:@signer)
+    package.gem.with_write_io do |gem_io|
+      Gem::Package::TarWriter.new gem_io do |gem|
+        digests = gem.add_file_signed "metadata.gz", 0o444, signer do |io|
+          package.gzip_to io do |gz_io|
+            yaml = spec.to_yaml
+            yaml.sub!(/^rubygems_version: .*/, "rubygems_version: 3.5.11")
+            gz_io.write yaml
+          end
+        end
+        checksums = package.instance_variable_get(:@checksums)
+        checksums["metadata.gz"] = digests
+
+        digests = gem.add_file_signed "data.tar.gz", 0o444, signer do |io|
+          package.gzip_to io do |gz_io|
+            # no files
+            Gem::Package::TarWriter.new gz_io
+          end
+        end
+        checksums["data.tar.gz"] = digests
+
+        package.add_checksums gem
+      end
+    end
+
+    MockGem.new(
+      name: name,
+      version: spec.version,
+      platform: spec.platform,
+      sha256: Digest::SHA256.hexdigest(package.gem.io.string),
+      contents: package.gem.io.string
+    ).tap { @all_gems << _1 }
+  end
+
+  MockGem = Struct.new(:name, :version, :platform, :sha256, :contents, keyword_init: true) do
+    def full_name
+      if platform == "ruby"
+        "#{name}-#{version}"
+      else
+        "#{name}-#{version}-#{platform}"
+      end
+    end
+
+    def prerelease?
+      version.prerelease?
+    end
+
+    def size
+      contents.bytesize
+    end
+
+    def spec
+      io = StringIO.new(contents)
+      io.binmode
+      Gem::Package.new(io).spec
+    end
+
+    def pretty_print(pp)
+      pp.object_address_group(self) do
+        attr_names = %i[name version platform sha256 size]
+        pp.seplist(attr_names, proc { pp.text "," }) do |attr_name|
+          pp.breakable " "
+          pp.group(1) do
+            pp.text attr_name
+            pp.text ":"
+            pp.breakable
+            value = send(attr_name)
+            pp.pp value
+          end
+        end
+      end
+    end
+  end
+
+  module Pusher
+    extend Gem::GemcutterUtilities
+
+    def self.options
+      {}
+    end
+  end
+
+  def push_gem(gem, expected_to:)
+    rubygems_api_request(
+      :post,
+      "api/v1/gems",
+      upstream,
+      scope: :push_rubygem
+    ) do |request|
+      request.body = gem.contents
+      request["Content-Length"] = gem.size.to_s
+      request["Content-Type"] = "application/octet-stream"
+      request.add_field "Authorization", Pusher.api_key
+    end.tap do
+      expect(last_response).to expected_to
+      set_time @time + 60
+    end
+  end
+
+  def yank_gem(gem, expected_to:)
+    rubygems_api_request(
+      :delete,
+      "api/v1/gems/yank",
+      upstream,
+      scope: :yank_rubygem
+    ) do |request|
+      request.body = URI.encode_www_form(
+        gem_name: gem.name,
+        version: gem.version.to_s,
+        platform: gem.platform
+      )
+      request["Content-Length"] = request.body.bytesize.to_s
+      request["Content-Type"] = "application/x-www-form-urlencoded"
+      request.add_field "Authorization", Pusher.api_key
+    end.tap do
+      expect(last_response).to expected_to, last_response.body
+      set_time @time + 60
+    end
+  end
+
+  def set_time(time) # rubocop:disable Naming/AccessorMethodName
+    @time = time
+    body = time.iso8601
+    rubygems_api_request(
+      :post,
+      "set_time",
+      upstream
+    ) do |request|
+      request.body = body
+      request["Content-Length"] = body.to_s
+      request["Content-Type"] = "text/plain"
+    end.tap do |response|
+      expect(response.code).to eq "200"
+    end
+  end
+
+  def rebuild_versions_list
+    rubygems_api_request(
+      :post,
+      "rebuild_versions_list",
+      upstream
+    ) { nil }.tap do |response|
+      expect(response.code).to eq "200"
+      set_time @time + 3600
+    end
+  end
+
+  def get_versions # rubocop:disable Naming/AccessorMethodName
+    rubygems_api_request(
+      :get,
+      "versions",
+      upstream
+    ) { nil }
+  end
+
+  def get_names # rubocop:disable Naming/AccessorMethodName
+    rubygems_api_request(
+      :get,
+      "names",
+      upstream
+    ) { nil }
+  end
+
+  def get_info(name)
+    rubygems_api_request(
+      :get,
+      "info/#{name}",
+      upstream
+    ) { nil }
+  end
+
+  def get_gem(name)
+    rubygems_api_request(
+      :get,
+      "gems/#{name}.gem",
+      upstream
+    ) { nil }
+  end
+
+  def get_quick_spec(name)
+    rubygems_api_request(
+      :get,
+      "quick/Marshal.4.8/#{name}.gemspec.rz",
+      upstream
+    ) { nil }
+  end
+
+  def get_specs(name = nil)
+    path = [name, "specs.4.8.gz"].compact.join("_")
+    rubygems_api_request(
+      :get,
+      path,
+      upstream
+    ) { nil }
+  end
+
+  class MockResponse
+    attr_reader :response
+
+    def initialize(response)
+      response.body_encoding = Encoding::BINARY
+      @response = response
+    end
+
+    def inspect
+      headers = +"HTTP/#{response.http_version} #{response.code} #{response.message}\n".b
+      response.each_header do |name, value|
+        headers << "#{name}: #{value}\n"
+      end
+      headers << "\n"
+      headers << response.body
+    end
+
+    def ok?
+      response.code == "200"
+    end
+
+    def not_found?
+      response.code == "404"
+    end
+
+    def conflict?
+      response.code == "409"
+    end
+
+    def forbidden?
+      response.code == "403"
+    end
+
+    def ==(other)
+      return false unless other.is_a?(self.class)
+
+      response.to_hash == other.response.to_hash &&
+        response.body == other.response.body
+    end
+
+    extend Forwardable
+
+    def_delegators :response, :code, :body, :http_version
+    def_delegators "response.body", :match?, :===, :=~
+  end
+
+  def rubygems_api_request(...)
+    internal = internal_request?(...)
+    Pusher.rubygems_api_request(...).tap do |response|
+      @last_response = MockResponse.new(response) unless internal
+    end
+  end
+
+  def internal_request?(_, path, *, **)
+    case path
+    when "rebuild_versions_list", "set_time"
+      true
+    else
+      false
+    end
+  end
+
+  RSpec::Matchers.define :have_header do
+    match do |response|
+      expect(response).to be_a(MockResponse)
+
+      @header_value = response.response.fetch(expected, nil)
+      values_match?(@value, @header_value)
+    end
+
+    failure_message do |_response|
+      super() + ", but got: #{description_of(@header_value)}"
+    end
+
+    chain :with_value do |value|
+      @value = value
+    end
+  end
+
+  RSpec::Matchers.define :have_body do
+    match do |response|
+      expect(response).to be_a(MockResponse)
+      body = response.body.b
+      @actual = body
+      values_match?(expected, body)
+    end
+
+    diffable
+  end
+
+  RSpec::Matchers.define :encoded_as do
+    match do |str|
+      @actual = str.encoding.to_s
+      expect(str.encoding).to eq(expected)
+    end
+    diffable
+  end
+
+  RSpec::Matchers.define :be_valid_compact_index_reponse do
+    match notify_expectation_failures: true do |response|
+      expect(response).to be_a(MockResponse)
+        .and be_ok
+        .and have_header("content-type").with_value("text/plain; charset=utf-8")
+        .and have_header("accept-ranges").with_value("bytes")
+        .and have_header("digest").with_value("sha-256=#{Digest::SHA256.base64digest(response.body)}")
+        .and have_header("repr-digest").with_value("sha-256=:#{Digest::SHA256.base64digest(response.body)}:")
+        .and have_header("etag").with_value("\"#{Digest::MD5.hexdigest(response.body)}\"")
+    end
+  end
+
+  RSpec::Matchers.define :have_content_length do
+    match do |response|
+      expect(response).to be_a(MockResponse)
+      expect(response).to have_header("content-length").with_value(response.body.bytesize.to_s)
+    end
+  end
+
+  RSpec::Matchers.define :be_unchanged do
+    match do |response|
+      expect(response).to be_a(MockResponse)
+      expect(response).to be_not_found
+    end
+  end
+
+  RSpec::Matchers.define :unmarshal_as do
+    match do |response|
+      expect(response).to be_a(MockResponse)
+      body = response.body.b
+      body = if must_inflate
+               Zlib.inflate(body)
+             else
+               Zlib.gunzip(body)
+             end
+      @actual = Marshal.load(body)
+      values_match?(expected, @actual)
+    end
+
+    chain :inflate, :must_inflate
+
+    diffable
+  end
+end

data/spec/support/step_helpers.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+module StepHelpers
+  class Step
+    attr_reader :parent, :requests, :children, :last_responses, :blk
+
+    def initialize(ctx, parent = nil, &blk)
+      @ctx = ctx
+      @parent = parent
+      @requests = []
+      @last_responses = {}
+      @children = []
+      @parent&.children&.<< self
+      @blk = blk
+      define! unless parent
+    end
+
+    def previous_requests
+      return [] unless @parent
+
+      req = @parent.requests + @parent.previous_requests
+      req.uniq!
+
+      req.reject! do |m, a, _k, _|
+        requests.any? { |m_2, a_2, _, _| m == m_2 && a == a_2 }
+      end
+      req
+    end
+
+    def then(message, before: nil, **kwargs, &blk)
+      raise ArgumentError, "block required" unless blk
+      raise ArgumentError, "message required" unless message
+      raise "already has children" if @children.any?
+
+      Step.new(@ctx.instance_eval { context(message, **kwargs) }, self).tap do |step|
+        step.instance_variable_get(:@ctx).before(:all, &before) if before
+        step.instance_eval(&blk)
+        step.define!
+      end
+    end
+
+    # class NullReporter
+    #   def self.method_missing(...)
+    #     pp(...)
+    #   end
+
+    #   def self.example_failed(ex)
+    #     pp ex
+    #     puts ex.display_exception.full_message
+    #   end
+    # end
+
+    def request(method, *args, **kwargs, &blk)
+      name = method.to_s
+      name += "(#{args.map(&:inspect).join(", ")})" unless args.empty?
+      name += " unchanged" if kwargs[:unchanged]
+      step = self
+
+      reset_examples = proc do |ctx|
+        ctx.examples.each do |example|
+          example.display_exception = nil
+          example.metadata[:execution_result] = RSpec::Core::Example::ExecutionResult.new
+        end
+        ctx.children.each(&reset_examples)
+      end
+
+      @ctx.context "#{name} response", **kwargs do
+        before(:all) do
+          20.times do
+            send(method, *args)
+            step.last_responses[[method, *args]] = last_response
+
+            reporter = RSpec::Core::NullReporter
+            self.class.store_before_context_ivars(self)
+            result_for_this_group = self.class.run_examples(reporter)
+            results_for_descendants = self.class.ordering_strategy.order(self.class.children).map do |child|
+              child.run(reporter)
+            end.all?
+
+            reset_examples[self.class]
+            break if result_for_this_group && results_for_descendants
+
+            sleep 0.1
+          end
+        end
+
+        let(:parent_response) do
+          step.parent.last_responses[[method, *args]]
+        end
+
+        alias_method :subject, :last_response
+        instance_eval(&blk)
+      end
+
+      @requests << [method, args, kwargs, blk, self]
+    end
+
+    def pushed_gem(full_name)
+      request(:get_gem, full_name) do
+        let(:gem) { @all_gems.reverse_each.find { _1.full_name == full_name } || raise("gem not found") }
+        it { is_expected.to be_ok }
+
+        it { is_expected.to have_header("content-type").with_value("application/octet-stream") }
+          .metadata[:content_type_header] = true
+        it { is_expected.to have_content_length }
+          .metadata[:content_length_header] = true
+        it { is_expected.to have_body(eq(gem.contents)) }
+      end
+
+      request(:get_quick_spec, full_name) do
+        let(:gem) { @all_gems.reverse_each.find { _1.full_name == full_name } || raise("gem not found") }
+
+        it { is_expected.to be_ok }
+
+        it { is_expected.to have_header("content-type").with_value("application/octet-stream") }
+          .metadata[:content_type_header] = true
+        it { is_expected.to have_content_length }
+          .metadata[:content_length_header] = true
+        it { is_expected.to unmarshal_as(gem.spec.tap(&:sanitize).tap(&:abbreviate)).inflate(true) }
+      end
+    end
+
+    def yanked_gem(full_name)
+      request(:get_gem, full_name) do
+        let(:gem) { @all_gems.reverse_each.find { _1.full_name == full_name } || raise("gem not found") }
+
+        it { is_expected.to be_not_found.or be_forbidden }
+        it { is_expected.not_to have_body(including(gem.contents)) }
+      end
+
+      request(:get_quick_spec, full_name) do
+        let(:gem) { @all_gems.reverse_each.find { _1.full_name == full_name } || raise("gem not found") }
+
+        it { is_expected.to be_not_found.or be_forbidden }
+      end
+    end
+
+    def define!
+      step = self
+
+      instance_eval(&step.blk) if step.blk
+
+      if step.parent.nil?
+        @ctx.instance_eval do
+          attr_reader :upstream
+
+          before(:all) do
+            @upstream = ENV.fetch("UPSTREAM", nil)
+            unless upstream
+              Bundler.with_original_env do
+                @upstream = "http://localhost:4567"
+                @pid = spawn("ruby", "-rbundler/setup", "lib/gem_server_conformance/server.rb", out: "/dev/null",
+                                                                                                err: "/dev/null")
+                sleep 1
+              end
+            end
+
+            @all_gems = []
+            set_time Time.utc(1990)
+          end
+
+          after(:all) do
+            if @pid
+              Process.kill "TERM", @pid
+              Process.wait @pid
+            end
+          end
+        end
+      end
+
+      step.previous_requests.each do |method, args, kwargs, blk, s|
+        request(method, *args, unchanged: true, **kwargs) do
+          let(:parent_response) do
+            s.parent.last_responses[[method, *args]]
+          end
+          instance_eval(&blk)
+          if kwargs[:compact_index]
+            it "is expected to have the same etag" do
+              is_expected.to have_header("ETag").with_value(step.parent.last_responses[[method,
+                                                                                        *args]].response["ETag"])
+            end
+          end
+        end
+      end
+
+      if requests.any?
+        @ctx.context "/versions", compact_index: true do
+          it "has matching etags" do
+            expect(step.last_responses).to include([:get_versions])
+            versions_response = step.last_responses[[:get_versions]]
+
+            expected = versions_response.body.lines.to_h do |l|
+              n, _, e = l.split
+              [n, "\"#{e}\""]
+            end
+            expected.delete("---")
+            expected.delete("created_at:")
+
+            etags = step.last_responses.filter_map do |k, v|
+              next unless k.first == :get_info
+              next unless v.ok?
+
+              [k[1], v.response["ETag"]]
+            end.to_h
+
+            expect(etags).to eq(expected)
+          end
+        end
+
+        @ctx.context "all expected requests", compact_index: true do
+          it "are tested" do
+            expect(step.last_responses).to include([:get_versions])
+            versions_response = step.last_responses[[:get_versions]]
+
+            expected = versions_response.body.lines.flat_map do |l|
+              next if l.start_with?("---")
+              next if l.start_with?("created_at:")
+
+              n, versions, = l.split
+              versions.split(",").flat_map do |v|
+                v.delete_prefix!("-")
+                [
+                  [:get_quick_spec, ["#{n}-#{v}"]],
+                  [:get_gem, ["#{n}-#{v}"]]
+                ]
+              end << [:get_info, [n]]
+            end
+            expected.compact!
+            expected.uniq!
+
+            actual = step.requests.map { |m, a, _| [m, a] }
+
+            missing = expected - actual
+
+            expect(missing).to be_empty
+          end
+        end
+      end
+
+      children.each(&:define!)
+    end
+  end
+
+  module ClassMethods
+    def all_requests
+      @all_requests ||= []
+    end
+
+    def all_requests_indices
+      @all_requests_indices ||= {}
+    end
+  end
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: gem_server_conformance
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Samuel Giddins
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2024-07-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 
+email:
+- segiddins@rubycentral.org
+executables:
+- gem_server_conformance
+- gem_server_example
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-version"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- exe/gem_server_conformance
+- exe/gem_server_example
+- lib/gem_server_conformance/server.rb
+- lib/gem_server_conformance/version.rb
+- spec/gem_server_conformance_spec.rb
+- spec/spec_helper.rb
+- spec/support/request_helpers.rb
+- spec/support/step_helpers.rb
+homepage: https://github.com/rubygems/gem_server_conformance
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/rubygems/gem_server_conformance
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key: 
+specification_version: 4
+summary: A conformance test suite for RubyGems servers.
+test_files: []