httparrot 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,8 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in httparrot.gemspec
+gemspec
+
+platforms :jruby do
+  gem 'jruby-openssl'
+end

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require "rspec"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = "--color"
+end
+
+task :default => [:spec]

data/Readme.rdoc

@@ -0,0 +1,97 @@
+= HTTParrot
+
+Do you need to mock an API endpoint over an HTTP connection?  Does your API only speak HTTP?  Other things and stuff related to mock servers and HTTP?
+
+Then you need HTTParrot! (or something else that does similar things maybe)
+
+= Install it
+    gem install httparrot  #=> OR include it in the development/test group of your Gemfile
+
+
+HTTParrot's goal is to simplify building mock HTTP responses and scripting the responses during an HTTP session interaction.  
+Responses are mocked in ERB and can be returned via matching params that are setup during use.  (We use HTTParrot to
+help mock our HTTP protocol support around the webs)
+
+== Example
+TotallyNewAwesomeCompany has decided that too many protocols exist in the Widget space.  Unfortunately none of those protocols 
+account for how awesome the protocol could be if only TotallyNewAwesomeCompany had a way to force adoption.  TNAC has decided
+to implement an HTTP based protocol to exchange Widget data, but they NEED to write tests for the session based HTTP protocol
+(Request => Response => Request => Response)
+
+Protocol logic:
+A connection is established with an ConnectWidget document sent to tnac.com/connect_widget
+A valid connection response contains "TNAC: VERIFIED"
+Widget data is requested with a POST sent to tnac.com/widget AND must POST the widget id
+
+(we know this isn't very RESTful, but it's a contrived example)
+
+Using HTTParrot we can test said protocol in a "simple" way :)
+
+  describe TNAC::Widget do
+    
+    before(:all) do 
+      @server = HTTParrot::Server.new
+      @server.start
+    end
+
+    after(:all) do 
+      @server.stop
+    end
+
+    before(:each) do 
+      HTTParrot::ResponseFactory.clear!
+      HTTParrot::ResponseFactory.define(:connection) { |c| c.tnac = "VERIFIED" }
+      HTTParrot::ResponseFactory.define(:widget) { |w| w.awesomeness = "YEPYEP" }
+      @connection = HTTParrot::ResponseFactory.build(:connection)
+      @widget = HTTParrot::ResponseFactory.build(:widget)
+      @server.clear!
+    end
+
+    it "totally connects" do 
+      connection_reg = @server.register(:get, "connect_widget", @connection.to_rack)
+      http_connection = Net::HTTP.new("127.0.0.1", HTTParrot::Config.Port)
+      http_connection.get("/connect_widget")
+      connection_reg.response_count.should eq(1)
+    end
+
+    it "allows me to get a widget" do 
+      @server.register(:post, /WIDGET/, @widget.to_rack)
+      data = "widget=WIDGET&id=1224"
+      http_connection = Net::HTTP.new("127.0.0.1", HTTParrot::Config.Port)
+      http_connection.post("/widget", data).should match(/VERIFIED/) 
+    end
+
+  end
+
+
+= Matchers
+Matchers are used to register responses based on scripted requests
+
+== Regex Matcher
+Matches based on the body of a request matching the Regex passed
+
+  @server.register(:get, /Match This/, @response.to_rack)
+
+== Endpoint Matchers
+Matches based on the endpoint URI that the HTTP verb acts on
+  
+  @server.register(:get, "endpoint", @response.to_rack)
+
+== Callable Matcher
+Any parameter that responds to :call can be used to return true/false depending on the body being passed to the callable
+(primarily used with lambdas/procs/method object)
+
+  @server.register(:get, lambda{ |b| b =~ /awesome/ }, @response.to_rack)
+
+== Complex Matcher
+A complex matcher is an Array comprised of any number of the other Matchers
+
+  @server.register(:get, [/awesome/, lambda{|v| v =~ /awesome/], @response.to_rack)
+
+
+= Registering Responses
+A response is registered as a HTTP verb type [:get, :post, :head, :delete] followed by the MATCHER and finally a Rack Response 
+of the data that will be returned when a match is found.  The primary means of the Rack Response in our tests comes from using
+HTTParrot::ResponseFactory to build responses based on ERB templates.
+
+(Checkout the tests in the spec folder to build out the templates.....more documentation to come)

data/httparrot.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "httparrot/version"
+
+Gem::Specification.new do |s|
+  s.name        = "httparrot"
+  s.version     = HTTParrot::VERSION
+  s.authors     = ["Brandon Dewitt"]
+  s.email       = ["brandonsdewitt@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Mock Server for testing HTTP anything!}
+  s.description = %q{helps cut through the clutter of HTTP testing}
+
+  s.rubyforge_project = "httparrot"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec", "=2.7"
+  s.add_development_dependency "rake"
+
+  s.add_runtime_dependency "rack"
+  s.add_runtime_dependency "active_support"
+end

data/lib/httparrot/response_factory.rb

@@ -0,0 +1,89 @@
+require 'httparrot/widget'
+
+module HTTParrot
+
+  class ResponseFactory
+
+    def self.clear!
+      @factory_classes = {}
+    end
+
+    def self.define(factory_class, &block)
+      raise error_no_block(factory_class) if block.nil?
+      @factory_classes ||= {} 
+      warn_factory_exists(factory_class) if @factory_classes.keys.include?(factory_class)
+      default_object = HTTParrot::Widget.new(:_class => "Widget::#{factory_class.to_s.camelize}")
+      @factory_classes[factory_class] = lambda{ block.call(default_object); default_object } 
+    end
+
+    def self.build(factory_class, new_options={})
+      raise error_for_missing(factory_class) if @factory_classes[factory_class].nil?
+      object = @factory_classes[factory_class].call
+
+      new_options.each do |k, v|
+        object.send("#{k}=", v) 
+      end
+
+      return Marshal.load(Marshal.dump(object)) 
+    end
+
+    def self.collection_of(factory_class, number, new_options={})
+      collection = []
+
+      number.times do 
+        collection << build(factory_class, new_options)
+      end
+
+      return collection
+    end
+
+    def self.one_of(choices)
+      warn_no_choices if choices.size <= 0
+      choices[rand(choices.size)]
+    end
+
+    private 
+
+    def self.error_for_missing(factory_class)
+      "Unknown factory type: #{factory_class} in known factories: #{@factory_classes.keys}"
+    end
+
+    def self.error_no_block(factory_class)
+      "No block included in definition of #{factory_class} factory"
+    end
+
+    def self.warn_no_choices
+      raise "foo"
+    rescue => e
+      warn <<-WARNING
+          ==============================================================
+              No choices were provided for #one_of
+
+                  This constitutes a nil choice 
+
+                  At:
+
+              #{e.backtrace.join("#{$/}      ")}
+          ==============================================================
+      WARNING
+    end
+
+    def self.warn_factory_exists(factory_class)
+      raise "foo"
+    rescue => e
+      warn <<-WARNING
+          ==============================================================
+              #{factory_class} is already defined as a ResponseFactory
+
+                  This constitutes a redefinition of the factory
+
+                  Redefined at:
+
+              #{e.backtrace.join("#{$/}      ")}
+          ==============================================================
+      WARNING
+    end
+
+  end
+
+end

data/lib/httparrot/server.rb

@@ -0,0 +1,254 @@
+# Mock server to accept requests and return known responses based on request content 
+#
+# influenced by: http://dynamicorange.com/2009/02/18/ruby-mock-web-server
+require 'openssl' unless defined?(JRUBY_VERSION)
+require 'ostruct'
+require 'net/http'
+require 'net/https'
+require 'webrick'
+require 'webrick/https'
+require 'rack'
+require 'thread'
+
+module HTTParrot 
+
+  class Server
+
+    attr_accessor :options
+
+    def initialize(opts={})
+      @server_started = @server = nil
+      @server_thread = nil
+      @secure_started = @secure_server = nil
+      @secure_thread = nil
+
+      @parent_thread = Thread.current
+      @options = { 
+        :Port => 4000, 
+        :Host => "127.0.0.1"
+      }.merge(HTTParrot::Config.config).merge(opts)
+
+      quiet_options = { 
+        :Logger => WEBrick::Log::new("/dev/null", 7),
+        :AccessLog => []
+      }
+
+      @options.merge!(quiet_options) unless HTTParrot::Config.verbose
+
+      self.clear!
+    end
+
+    def clear!
+      blank_handler = {
+        :get => [], 
+        :post => [], 
+        :head => [], 
+        :delete => []
+      }
+
+      # Using Marshal for deep copy purposes
+      # slow from an efficiency perspective, but #clear! 
+      # is not called frequently and this gem is for testing
+      @call_handlers = Marshal.load(Marshal.dump(blank_handler)) 
+      @regex_handlers = Marshal.load(Marshal.dump(blank_handler)) 
+      @endpoint_handlers = Marshal.load(Marshal.dump(blank_handler)) 
+      @complex_handlers = Marshal.load(Marshal.dump(blank_handler))
+      self
+    end
+
+    def reset_counts
+      [@call_handlers, @regex_handlers, @endpoint_handlers, @complex_handlers].each do |handler_type|
+        handler_type.each_key do |req_meth|
+          handler_type[req_meth].each { |handler| handler.response_count = 0 }
+        end
+      end
+    end
+
+    def call(env)
+      req = Rack::Request.new(env)
+      response = respond_with(env)
+
+      # TODO move this to WEBrick's builtin logging facilities
+      if ENV["PARROT_VERBOSE"] || HTTParrot::Config.verbose
+        puts "\n>>>>> REQUEST\n"
+        puts req.inspect
+        #puts req.body.string
+
+        puts "\n<<<<< RESPONSE\n"
+        puts response.inspect
+        #response[2].each{ |l| puts l }
+      end
+
+      return response
+
+    rescue Exception => e
+      # reraise the exception in the parent thread if it Errors out
+      @parent_thread.raise e
+    end
+
+    def register(http_method, method_key, response, call_with_env = false)
+      http_method = http_method.to_s.downcase.to_sym
+      raise "http_method in register must be one of [:get, :post, :head, :delete] : #{http_method}" if ![:get, :post, :head, :delete].include?(http_method)
+
+      response_handler = OpenStruct.new({
+        :method_key => method_key,
+        :response => response,
+        :env? => call_with_env,
+        :response_count => 0
+      })
+
+      case
+      when method_key.respond_to?(:call) then
+        @call_handlers[http_method] << response_handler      
+      when method_key.is_a?(Regexp) then
+        @regex_handlers[http_method] << response_handler 
+      when method_key.is_a?(String) then
+        @endpoint_handlers[http_method] << response_handler 
+      when method_key.is_a?(Array) then
+        @complex_handlers[http_method] << response_handler        
+      else
+        raise "method_key (Handler) must be callable, Regexp, Array, or String" 
+      end
+
+      return response_handler
+    end
+
+    def start(startup_interval = 1)
+      start_server
+      start_secure_server if options[:ssl]
+      sleep startup_interval # Ensure the server has time to startup
+      sleep startup_interval if !running? # Give it a little more time if they didn't start
+    end
+
+    def running?
+      secure_run_running = options[:ssl] ? (!@secure_server.nil? && @secure_started) : true
+      @server_started && !@server.nil? && secure_run_running 
+    end
+    alias_method :started?, :running?
+
+    def stop(shutdown_interval = 0)
+      @server.shutdown if @server.respond_to?(:shutdown)
+      @secure_server.shutdown if @secure_server.respond_to?(:shutdown)
+      sleep shutdown_interval
+      Thread.kill(@server_thread) if !@server_thread.nil?
+      Thread.kill(@secure_thread) if !@secure_thread.nil?
+      @server_started = @server = nil
+      @secure_started = @secure_server = nil
+    end
+
+    private
+
+    # Increment the number of times a handler was used (for asserting usage)
+    def increment_return(handler)
+      handler.response_count = handler.response_count + 1
+      return handler.response
+    end
+
+    def call_handler_match?(call_handler, env, request, request_method, request_body)
+      call_arg = (call_handler.env? ? env : request_body)
+
+      return call_handler.method_key.call(call_arg)
+    end
+
+    def complex_handler_match?(complex_handler, env, request, request_method, request_body)
+
+      complex_handler.method_key.inject(true) do |matching, handler|
+        current_handler_match = false
+
+        if matching
+          current_handler = OpenStruct.new({
+            :env? => complex_handler.env?,
+            :method_key => handler
+          })
+
+          case 
+          when handler.respond_to?(:call) then
+            current_handler_match = call_handler_match?(current_handler, env, request, request_method, request_body)    
+          when handler.is_a?(Regexp) then
+            current_handler_match = regex_handler_match?(current_handler, env, request, request_method, request_body)
+          when handler.is_a?(String) then
+            current_handler_match = endpoint_handler_match?(current_handler, env, request, request_method, request_body)
+          end
+        end
+
+        matching && current_handler_match
+      end
+    end
+
+    def endpoint_handler_match?(endpoint_handler, env, request, request_method, request_body)
+      return request.path_info =~ /#{endpoint_handler.method_key}/i
+    end
+
+    def regex_handler_match?(regex_handler, env, request, request_method, request_body)
+      return regex_handler.method_key =~ request_body
+    end
+
+    def respond_with(env)
+      req = Rack::Request.new(env)
+      req_meth = req.request_method.downcase.to_sym
+      request_body = req.body.string
+
+      @complex_handlers[req_meth].each do |com_handler|
+        return increment_return(com_handler) if complex_handler_match?(com_handler, env, req, req_meth, request_body)
+      end
+
+      @call_handlers[req_meth].each do |call_handler|
+        return increment_return(call_handler) if call_handler_match?(call_handler, env, req, req_meth, request_body) 
+      end
+
+      @regex_handlers[req_meth].each do |reg_handler|
+        return increment_return(reg_handler) if regex_handler_match?(reg_handler, env, req, req_meth, request_body) 
+      end
+
+      @endpoint_handlers[req_meth].each do |end_handler|
+        return increment_return(end_handler) if endpoint_handler_match?(end_handler, env, req, req_meth, request_body) 
+      end
+
+      return no_mock_error(req_meth)
+    end
+
+    def no_mock_error(request_method)
+      error_message = "No matched request handlers for: #{request_method}"
+      [404, { "Content-Type" => "text/plain", "Content-Length" => error_message.size.to_s }, [error_message]]
+    end
+
+    def start_server
+      if @server_thread.nil? || !@server_thread.alive?
+        @server_thread = Thread.new(self, @options) do |server, options| 
+          Rack::Handler::WEBrick.run(server, options) { |s| @server = s }
+        end
+
+        trap(:INT){ @server_thread.terminate; @server_thread = nil }
+        @server_started = true
+      end
+    end
+
+    def start_secure_server
+      if @secure_thread.nil? || !@secure_thread.alive?
+        @secure_thread = Thread.new(self, @options) do |server, options| 
+          options = options.merge(:Port => options[:SSLPort],
+                                  :SSLEnable => true,
+                                  :SSLVerifyClient => OpenSSL::SSL::VERIFY_NONE,
+                                  :SSLCertificate => ssl_cert,
+                                  :SSLPrivateKey => ssl_key,
+                                  :SSLCertName => [[ "CN", "127.0.0.1" ]])
+
+          Rack::Handler::WEBrick.run(server, options) { |s| @secure_server = s }
+        end
+
+        trap(:INT){ @secure_thread.terminate; @secure_thread = nil }
+        @secure_started = true
+      end
+    end
+
+    def ssl_key
+      OpenSSL::PKey::RSA.new(File.read(File.dirname(__FILE__) + "/ssl/" + "server.key"), "httparrot")
+    end
+
+    def ssl_cert
+      OpenSSL::X509::Certificate.new(File.read(File.dirname(__FILE__) + "/ssl/" + "server.crt"))
+    end
+
+  end
+
+end

data/lib/httparrot/ssl/server.crt

@@ -0,0 +1,14 @@
+-----BEGIN CERTIFICATE-----
+MIICEzCCAXwCCQCqQYI2AsyUpDANBgkqhkiG9w0BAQUFADBOMQswCQYDVQQGEwJV
+UzETMBEGA1UECBMKU29tZS1TdGF0ZTEUMBIGA1UEBxMLU3ByaW5nZmllbGQxFDAS
+BgNVBAoTC0F3ZXNvbWV0b3duMB4XDTExMTIyMTAwMjQwMVoXDTIxMTIxODAwMjQw
+MVowTjELMAkGA1UEBhMCVVMxEzARBgNVBAgTClNvbWUtU3RhdGUxFDASBgNVBAcT
+C1NwcmluZ2ZpZWxkMRQwEgYDVQQKEwtBd2Vzb21ldG93bjCBnzANBgkqhkiG9w0B
+AQEFAAOBjQAwgYkCgYEA1sbHVwOzZqIKFKkd8bBaGma9qXYrSrf8bGj9SZREIpAk
+kZGH2Dyta27P7njUGcB3RecTogQHAS/YVkPuSfPHlbU2qVDBmqT1ZVIComW0A7iI
+HiSsevGMgJAPNG2ekLBKJexxoS0nqfHO6G8nvPXIjWsXwT4IIL59sRxOx96Fc+0C
+AwEAATANBgkqhkiG9w0BAQUFAAOBgQCaDVQErv6g7SU7f5NJ3F+CHksXEkgAGrYd
+xb9mnaJlnJX8G/iG2jsE5lsNttQWBsLRrZ1x6eaVBOMlYnHTOny56TexLQqqFvSW
+HiJeG8HcrVdW3u9aCjxLojcWVlnf+doIwbS87Q6qGu6N7cAof3UmI9vMwuwnNjty
+9lXwRcxjMA==
+-----END CERTIFICATE-----

data/lib/httparrot/ssl/server.key

@@ -0,0 +1,15 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIICXgIBAAKBgQDWxsdXA7NmogoUqR3xsFoaZr2pditKt/xsaP1JlEQikCSRkYfY
+PK1rbs/ueNQZwHdF5xOiBAcBL9hWQ+5J88eVtTapUMGapPVlUgKiZbQDuIgeJKx6
+8YyAkA80bZ6QsEol7HGhLSep8c7obye89ciNaxfBPgggvn2xHE7H3oVz7QIDAQAB
+AoGBAMUvQMqhqi7bLBgl4EkKGN9OXmjcBgkWfBjoF0tbZWa6IejHzQl5Q9pzpVGS
++2AdNSQnb/36ZpfvXlZtDbQ1rZEUzbMaPy6e2YV90B95xLNgVlSa4tOcoZ70Lpfu
+2avWv5RaOHtySyV76JMdpiREJaNhDLEfkDBNRcuoI5Xu1RohAkEA+AaKy1YU4z2Z
+KNaNi1rzXAxvdiC+RsKuOHXyyoy75wbwD4TB3pQuyFoXlvzsvw6ijmTUHxLA4aGv
+tLKPu2JRhQJBAN2ukZxOAzf57B3HoI5Oti7fyoCUpxXfnJSypMK9KyihJRVX0/Ko
+3+VEKdSEABcqWF2/ViAbHkq3AuX9g9sm8UkCQEQF108JHtVr8XOH1G4h1ZirOG6X
+cFgL0KhfgOUYT/h+qJw49srKrUH5o3qfh3am1uJiuOKEzC2VoJDYYB8uSdkCQQDL
+xlN9XczhoLAmM8Hn7nzTm83W4k6w8atKmOiRRjitEWw4MVLYJdoiMsVM38YBhWBT
+VLXDr4np3k8gwSh6xFJZAkEAqPQIaRNZEI/uVoxAOhgkzZ8ci9YjRP1HmVdYy/Sv
+nSrcq5XcGzIwYQmrUDMnp9k3pL0Lm611fAhgicgbq9a0ew==
+-----END RSA PRIVATE KEY-----

data/lib/httparrot/version.rb

@@ -0,0 +1,3 @@
+module HTTParrot 
+  VERSION = "0.0.1"
+end

data/lib/httparrot/widget.rb

@@ -0,0 +1,113 @@
+require 'erb'
+require 'ostruct'
+require 'active_support/core_ext/numeric'
+require 'active_support/core_ext/time/conversions'
+require 'active_support/core_ext/string/inflections'
+
+module HTTParrot
+
+  class Widget < OpenStruct
+
+    def initialize(defaults = {})
+      @parent_overwrite = false 
+      @headers = {}
+      super(defaults)
+    end
+
+    def header
+      @headers
+    end
+
+    def parent(parental_class, defaults={})
+      case
+      when parental_class.is_a?(Symbol) then
+        parental_class = HTTParrot::ResponseFactory.build(parental_class, defaults)
+      when !parental_class.respond_to?(:to_hash) then
+        raise "Parent must be a symbol or respond_to #to_hash"
+      end 
+
+      merge_parent(parental_class)
+    end
+
+    def parent!(parental_class, defaults = {})
+      @parent_overwrite = true
+      parent(parental_class, defaults)
+      @parent_overwrite = false
+    end
+
+    def rack_response(response_code = 200)
+      rendered_response = self.to_s
+      return [response_code, @headers.merge({"Content-Length" => rendered_response.size.to_s}), [rendered_response]]
+    end
+    alias_method :to_rack, :rack_response
+    alias_method :to_rack_response, :rack_response
+
+    def to_hash
+      self.marshal_dump
+    end
+
+    def to_s
+      set_template_file
+
+      if @table.has_key?(:template_file) && !self.template_file.nil?
+        @headers = {}
+        file_string = File.read(self.template_file)
+        current_template = ERB.new(file_string, nil, "<>")
+        return current_template.result(binding)
+      else
+        warn_no_template
+        return self.inspect
+      end
+    end
+
+    private
+
+    def merge_parent(parental_class)
+      case 
+      when @parent_overwrite then
+        @table.merge!(parental_class.to_hash)
+      else
+        @table.merge!(parental_class.to_hash.merge(@table))
+      end
+    end
+
+    def template_root_search
+      self._class ||= self.class.to_s
+
+      template_root = HTTParrot::Config.config[:template_root] || ".."
+      template_root = template_root[0..-1] if template_root[-1] == "/"
+      filename = self._class.gsub("Widget::", "")
+      filename.gsub!("HTTParrot::", "")
+      return "#{template_root}/**/#{filename.underscore}.erb"
+    end
+
+    def set_template_file
+      if self.template_file.nil? || self.template_file.empty?
+        self.template_file = Dir.glob(template_root_search).first
+      end
+    end
+
+    def warn_no_template
+      raise "foo"
+    rescue => e
+      warn <<-WARNING
+          ===================================================================
+              #{self.class} does not have a template_file associated
+
+              This will leave the response as an inspection of the class
+              and is probably not the intended behavior.  Before returning
+              a rack_response, define a template file to render with.
+
+              template_root search:
+              #{template_root_search}
+
+              Called at:
+
+              #{e.backtrace.join("#{$/}      ")}
+          ===================================================================
+      WARNING
+    end
+
+  end
+
+end

data/lib/httparrot.rb

@@ -0,0 +1,51 @@
+require "httparrot/version"
+require "httparrot/server"
+require "httparrot/response_factory"
+
+require "ostruct"
+
+module HTTParrot
+  class Config 
+    @config = OpenStruct.new
+
+    def self.configure 
+      yield self
+    end
+
+    def self.config
+      @config.instance_variable_get(:@table)
+    end
+
+    def self.valid_key?(key)
+      [ :Port, 
+        :SSLPort,
+        :ssl,
+        :template_root,
+        :verbose ].include?(key)
+    end
+
+    def self.restore_defaults!
+      self.configure do |c|
+        c.Port = 4000
+        c.SSLPort = c.Port + 1
+        c.ssl = true
+        c.verbose = false
+        c.template_root = nil
+      end
+    end
+
+    def self.method_missing(sym, *args, &blk)
+      case 
+      when sym.to_s =~ /(.+)=$/ && valid_key?($1.to_sym) then
+        @config.send(sym, *args, &blk)
+      when @config.respond_to?(sym) then
+        @config.send(sym, *args, &blk)
+      else 
+        super
+      end
+    end
+
+  end
+end
+
+HTTParrot::Config.restore_defaults!