# frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "http"
          
        
      
        

          

            
              1
            

            
              
            

            require "zeitwerk"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            Zeitwerk::Loader.new.then do |loader|
          
        
      
        

          

            
              1
            

            
              
            

              loader.inflector.inflect "http" => "HTTP"
          
        
      
        

          

            
              1
            

            
              
            

              loader.tag = "http-fake"
          
        
      
        

          

            
              1
            

            
              
            

              loader.push_dir "#{__dir__}/.."
          
        
      
        

          

            
              1
            

            
              
            

              loader.setup
          
        
      
        

          

            

            
              
            

            end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module HTTP
          
        
      
        

          

            

            
              
            

              # Main namespace.
          
        
      
        

          

            
              1
            

            
              
            

              module Fake
          
        
      
        

          

            
              1
            

            
              
            

                def self.loader registry = Zeitwerk::Registry
          
        
      
        

          

            
              4
            

            
              
            

                  @loader ||= registry.loaders.each.find { |loader| loader.tag == "http-fake" }
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "refinements/hash"
          
        
      
        

          

            
              1
            

            
              
            

            require "uri"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module HTTP
          
        
      
        

          

            
              1
            

            
              
            

              module Fake
          
        
      
        

          

            

            
              
            

                # Builds the response for a request.
          
        
      
        

          

            
              1
            

            
              
            

                class Builder
          
        
      
        

          

            
              1
            

            
              
            

                  using Refinements::Hash
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  ALLOWED_VERBS = /\A(connect|delete|get|head|options|patch|post|purge|put|trace)\z/
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  attr_reader :requests
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # :reek:DuplicateMethodCall
          
        
      
        

          

            
              1
            

            
              
            

                  def initialize verbs: ALLOWED_VERBS, responder: Responder
          
        
      
        

          

            
              39
            

            
              
            

                    @verbs = verbs
          
        
      
        

          

            
              39
            

            
              
            

                    @responder = responder
          
        
      
        

          

            
              39
            

            
              
            

                    @requests ||= Hash.with_default Hash.with_default([])
          
        
      
        

          

            
              39
            

            
              
            

                    @responders = Hash.with_default []
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def request verb, uri, arguments = {}
          
        
      
        

          

            
              65
            

            
              
            

                    responder = responders[verb].find { |fake| fake.match? verb, URI(uri).path }
          
        
      
        

          

            
              17
            

            
              
                
                  else: 15
                
              
                
                  then: 2
                
              
            

                    missing_route_error verb, uri unless responder
          
        
      
        

          

            
              15
            

            
              
            

                    requests[uri][verb] << arguments
          
        
      
        

          

            
              15
            

            
              
            

                    responder.call uri, arguments
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def method_missing(verb, *arguments, &)
          
        
      
        

          

            
              124
            

            
              
                
                  then: 123
                
              
                
                  else: 1
                
              
            

                    respond_to_missing?(verb) ? add_responder(verb, *arguments, &) : super
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  attr_reader :verbs, :responder, :responders
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def respond_to_missing?(verb, include_private = false) = verbs.match?(verb) || super
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def add_responder verb, pattern, &block
          
        
      
        

          

            
              123
            

            
              
            

                    responder.new(verb, pattern, block).then do |instance|
          
        
      
        

          

            
              123
            

            
              
            

                      responders[[verb, pattern]].append instance
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def missing_route_error verb, uri
          
        
      
        

          

            
              2
            

            
              
            

                    fail StandardError, "No route for #{verb.upcase} #{uri} in responders: #{responders}."
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "forwardable"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module HTTP
          
        
      
        

          

            
              1
            

            
              
            

              module Fake
          
        
      
        

          

            

            
              
            

                # Provides the primary client for dealing with fake requests and responses.
          
        
      
        

          

            
              1
            

            
              
            

                class Client
          
        
      
        

          

            
              1
            

            
              
            

                  include Chainable
          
        
      
        

          

            
              1
            

            
              
            

                  extend Forwardable
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  delegate %i[requests] => :builder
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def initialize builder: Builder.new, requester: Requester, &block
          
        
      
        

          

            
              11
            

            
              
            

                    @builder = builder
          
        
      
        

          

            
              11
            

            
              
            

                    @requester = requester
          
        
      
        

          

            
              11
            

            
              
            

                    @builder.instance_eval(&block)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  attr_reader :builder, :requester
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def branch(arguments) = requester.new arguments, builder:
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module HTTP
          
        
      
        

          

            
              1
            

            
              
            

              module Fake
          
        
      
        

          

            

            
              
            

                # Connects an HTTP request and response together.
          
        
      
        

          

            
              1
            

            
              
            

                class Connector
          
        
      
        

          

            
              1
            

            
              
            

                  def initialize version: Connection::HTTP_1_1, request: Request, response: Response
          
        
      
        

          

            
              25
            

            
              
            

                    @version = version
          
        
      
        

          

            
              25
            

            
              
            

                    @request = request
          
        
      
        

          

            
              25
            

            
              
            

                    @response = response
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def call **arguments
          
        
      
        

          

            
              25
            

            
              
            

                    response.new defaults.merge(
          
        
      
        

          

            

            
              
            

                      request: build_request(**arguments),
          
        
      
        

          

            

            
              
            

                      **arguments.slice(:headers, :version, :body, :status)
          
        
      
        

          

            

            
              
            

                    )
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  attr_reader :version, :request, :response
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def defaults = {headers: {}, version:, status: 200}
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def build_request(**arguments) = request.new arguments.slice :verb, :uri
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module HTTP
          
        
      
        

          

            
              1
            

            
              
            

              module Fake
          
        
      
        

          

            

            
              
            

                # Handles an incoming request.
          
        
      
        

          

            
              1
            

            
              
            

                class Requester
          
        
      
        

          

            
              1
            

            
              
            

                  include Chainable
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def initialize defaults = {}, builder: Builder.new
          
        
      
        

          

            
              13
            

            
              
            

                    @defaults = defaults
          
        
      
        

          

            
              13
            

            
              
            

                    @builder = builder
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def request(verb, uri, arguments = {}) = builder.request verb, uri, defaults.merge(arguments)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  attr_reader :defaults, :builder
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def branch(arguments) = self.class.new defaults.merge(arguments), builder:
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "mustermann"
          
        
      
        

          

            
              1
            

            
              
            

            require "refinements/string"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module HTTP
          
        
      
        

          

            
              1
            

            
              
            

              module Fake
          
        
      
        

          

            

            
              
            

                # Handles an outgoing response.
          
        
      
        

          

            
              1
            

            
              
            

                class Responder
          
        
      
        

          

            
              1
            

            
              
            

                  using Refinements::String
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  attr_reader :headers
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def initialize verb, pattern, function
          
        
      
        

          

            
              138
            

            
              
            

                    @verb = verb
          
        
      
        

          

            
              138
            

            
              
            

                    @pattern = Mustermann.new pattern
          
        
      
        

          

            
              138
            

            
              
            

                    @function = function
          
        
      
        

          

            
              138
            

            
              
            

                    @headers = {}
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def match?(verb, path) = !String(pattern.match(path)).blank? && verb == self.verb
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def call path, arguments = {}
          
        
      
        

          

            
              23
            

            
              
            

                    pattern.params(path)
          
        
      
        

          

            
              23
            

            
              
            

                           .then { |params| instance_exec(params, arguments, &function) }
          
        
      
        

          

            
              23
            

            
              
            

                           .then { |data| connect path, data }
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def status(code = nil) = @status ||= code
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  attr_reader :verb, :pattern, :function
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def connect path, data
          
        
      
        

          

            
              23
            

            
              
            

                    Connector.new.call verb:,
          
        
      
        

          

            

            
              
            

                                       uri: "https://example.com/#{path}",
          
        
      
        

          

            

            
              
            

                                       headers:,
          
        
      
        

          

            

            
              
            

                                       body: body(data),
          
        
      
        

          

            

            
              
            

                                       status:
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              24
            

            
              
                
                  then: 3
                
              
                
                  else: 20
                
              
            

                  def body(data) = data == status ? "" : data
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end