curb-fu 0.4.3

data/lib/curb-fu/response.rb

@@ -0,0 +1,179 @@
+module CurbFu
+  module Response
+    class Base
+      attr_accessor :status, :body, :headers
+      
+      def initialize(status, headers, body)
+        @status = status
+        set_response_type(status)
+        @body = body
+        @headers = headers.is_a?(String) ? parse_headers(headers) : headers
+      end
+      
+      def success?
+        self.is_a?(CurbFu::Response::Success)
+      end
+      
+      def redirect?
+        self.is_a?(CurbFu::Response::Redirection)
+      end
+      
+      def failure?
+        !(success? || redirect?)
+      end
+      
+      def server_fail?
+        self.is_a?(CurbFu::Response::ServerError)
+      end
+      
+      def client_fail?
+        self.is_a?(CurbFu::Response::ClientError)
+      end
+      
+      def parse_headers(header_string)
+        header_lines = header_string.split($/)
+        header_lines.shift
+        header_lines.inject({}) do |hsh, line|
+          whole_enchillada, key, value = /^(.*?):\s*(.*)$/.match(line.chomp).to_a
+          hsh[key] = value unless whole_enchillada.nil?
+          hsh
+        end
+      end
+      
+      def to_hash
+        { :status => status, :body => body, :headers => headers }
+      end
+      
+      def set_response_type(status)
+        case status
+        when 100..199 then
+          self.extend CurbFu::Response::Information
+          case self.status
+          when 101 then self.extend CurbFu::Response::Continue
+          when 102 then self.extend CurbFu::Response::SwitchProtocl
+          end
+        when 200..299 then
+          self.extend CurbFu::Response::Success
+          case self.status
+          when 200 then self.extend CurbFu::Response::OK
+          when 201 then self.extend CurbFu::Response::Created
+          when 202 then self.extend CurbFu::Response::Accepted
+          when 203 then self.extend CurbFu::Response::NonAuthoritativeInformation
+          when 204 then self.extend CurbFu::Response::NoContent
+          when 205 then self.extend CurbFu::Response::ResetContent
+          when 206 then self.extend CurbFu::Response::PartialContent
+          end
+        when 300..399 then
+          self.extend CurbFu::Response::Redirection
+          case self.status
+          when 300 then self.extend CurbFu::Response::MultipleChoice
+          when 301 then self.extend CurbFu::Response::MovedPermanently
+          when 302 then self.extend CurbFu::Response::Found
+          when 303 then self.extend CurbFu::Response::SeeOther
+          when 304 then self.extend CurbFu::Response::NotModified
+          when 305 then self.extend CurbFu::Response::UseProxy
+          when 307 then self.extend CurbFu::Response::TemporaryRedirect
+          end
+        when 400..499 then
+          self.extend CurbFu::Response::ClientError
+          case self.status
+          when 400 then self.extend CurbFu::Response::BadRequest
+          when 401 then self.extend CurbFu::Response::Unauthorized
+          when 402 then self.extend CurbFu::Response::PaymentRequired
+          when 403 then self.extend CurbFu::Response::Forbidden
+          when 404 then self.extend CurbFu::Response::NotFound
+          when 405 then self.extend CurbFu::Response::MethodNotAllowed
+          when 406 then self.extend CurbFu::Response::NotAcceptable
+          when 407 then self.extend CurbFu::Response::ProxyAuthenticationRequired
+          when 408 then self.extend CurbFu::Response::RequestTimeOut
+          when 409 then self.extend CurbFu::Response::Conflict
+          when 410 then self.extend CurbFu::Response::Gone
+          when 411 then self.extend CurbFu::Response::LengthRequired
+          when 412 then self.extend CurbFu::Response::PreconditionFailed
+          when 413 then self.extend CurbFu::Response::RequestEntityTooLarge
+          when 414 then self.extend CurbFu::Response::RequestURITooLong
+          when 415 then self.extend CurbFu::Response::UnsupportedMediaType
+          when 416 then self.extend CurbFu::Response::UnsupportedMediaType
+          when 417 then self.extend CurbFu::Response::ExpectationFailed
+          end
+        when 500..599 then
+          self.extend CurbFu::Response::ServerError
+          case self.status
+          when 500 then self.extend CurbFu::Response::InternalServerError
+          when 501 then self.extend CurbFu::Response::NotImplemented
+          when 502 then self.extend CurbFu::Response::BadGateway
+          when 503 then self.extend CurbFu::Response::ServiceUnavailable
+          when 504 then self.extend CurbFu::Response::GatewayTimeOut
+          when 505 then self.extend CurbFu::Response::VersionNotSupported
+          end
+        else
+          self.extend CurbFu::Response::UnknownResponse
+        end
+      end
+      
+      class << self
+        def from_rack_response(rack)
+          raise ArgumentError.new("Rack response may not be nil") if rack.nil?
+          response = self.new(rack.status, rack.headers, rack.body)
+        end
+      
+        def from_curb_response(curb)
+          response = self.new(curb.response_code, curb.header_str, curb.body_str)
+          response
+        end
+        
+        def from_hash(hash)
+          return nil if hash.nil?
+          self.new(hash[:status], hash[:headers], hash[:body])
+        end
+      end
+    end
+          
+    module Information; end
+      module Continue;                           def self.to_i; 100; end; end
+      module SwitchProtocl; end
+    module Success;                              def self.to_i; 200; end; end
+      module OK;                                 def self.to_i; 200; end; end
+      module Created;                            def self.to_i; 201; end; end
+      module Accepted;                           def self.to_i; 202; end; end
+      module NonAuthoritativeInformation; end
+      module NoContent; end
+      module ResetContent; end
+      module PartialContent; end
+    module Redirection; end                    # 3xx
+      module MultipleChoice; end                 # 300
+      module MovedPermanently; end               # 301
+      module Found;                              def self.to_i; 302; end; end
+      module SeeOther; end                       # 303
+      module NotModified; end                    # 304
+      module UseProxy; end                       # 305
+      module TemporaryRedirect; end              # 307
+    module ClientError; end                    # 4xx
+      module BadRequest; end                     # 400
+      module Unauthorized; end                   # 401
+      module PaymentRequired; end                # 402
+      module Forbidden; end                      # 403
+      module NotFound;                           def self.to_i; 404; end; end
+      module MethodNotAllowed; end               # 405
+      module NotAcceptable; end                  # 406
+      module ProxyAuthenticationRequired; end    # 407
+      module RequestTimeOut; end                 # 408
+      module Conflict; end                       # 409
+      module Gone;                               def self.to_i; 410; end; end
+      module LengthRequired; end                 # 411
+      module PreconditionFailed; end             # 412
+      module RequestEntityTooLarge; end          # 413
+      module RequestURITooLong; end              # 414
+      module UnsupportedMediaType; end           # 415
+      module RequestedRangeNotSatisfiable; end   # 416
+      module ExpectationFailed; end              # 417
+    module ServerError; end                    # 5xx
+      module InternalServerError;                def self.to_i; 500; end; end
+      module NotImplemented; end                 # 501
+      module BadGateway; end                     # 502
+      module ServiceUnavailable;                 def self.to_i; 503; end; end
+      module GatewayTimeOut; end                 # 504
+      module VersionNotSupported; end            # 505
+    module UnknownResponse; end
+  end
+end

data/lib/curb-fu/test.rb

@@ -0,0 +1,6 @@
+require 'curb-fu/test/server'
+require 'curb-fu/test/request_logger'
+
+module CurbFu
+  module Test; end
+end

data/lib/curb-fu/test/request_logger.rb

@@ -0,0 +1,31 @@
+module CurbFu
+  module Test
+    class RequestLogger
+      class << self
+        def entries(host)
+          @entries ||= {}
+          @entries[host] ||= []
+        end
+    
+        def log(env)
+          req = Rack::Request.new(env)
+          url = env['PATH_INFO']
+          post_params = req.POST
+          host = env['HTTP_HOST'] || env['SERVER_NAME']
+          entries(host) << { :url => url, :params => post_params }
+        end
+        def requested?(host, url, params = nil)
+          url_found = (url.is_a?(String)) ?
+            !entries(host).find { |entry| entry[:url] == url }.nil? :
+            !entries(host).find { |entry| entry[:url] =~ url }.nil?
+          if params.nil?
+            return url_found
+          else
+            params_found = !entries(host).find { |entry| entry[:params] == params }.nil?
+            url_found && params_found
+          end
+        end
+      end
+    end
+  end
+end

data/lib/curb-fu/test/server.rb

@@ -0,0 +1,21 @@
+require 'rack'
+
+module CurbFu
+  module Test
+    class Server
+      def self.serve(&blk)
+        Rack::Builder.app do
+          run lambda { |env|
+            CurbFu::Test::RequestLogger.log(env)
+            yield(env) 
+          }
+        end
+      end
+  
+      def self.error!(message)
+        puts message
+        raise StandardError, message
+      end
+    end
+  end
+end

data/spec/fixtures/foo.txt

@@ -0,0 +1 @@
+asdf

data/spec/lib/curb-fu/core_ext_spec.rb

@@ -0,0 +1,100 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'curb-fu/core_ext'
+
+describe "module inclusion" do
+  it "should include appropriate InstanceMethods" do
+    class Tester
+      include CurbFu::ObjectExtensions
+    end
+    
+    Tester.new.should respond_to(:to_param)
+  end
+  it "should not overwrite a pre-existing method named :to_param" do
+    class TesterWithToParam
+      def to_param
+        "hooray, to_param!"
+      end
+    end
+    
+    TesterWithToParam.send(:include, CurbFu::ObjectExtensions)
+    TesterWithToParam.new.to_param.should == "hooray, to_param!"
+  end
+  it "should not overwrite the pre-existing method even if it comes from a module" do
+    module ActsLikeRails
+      def to_param
+        "foo"
+      end
+    end
+    class TesterWithModule
+      include ActsLikeRails
+    end
+    TesterWithModule.send(:include, CurbFu::ObjectExtensions)
+    TesterWithModule.new.to_param.should == "foo"
+  end
+end
+
+describe String do
+  it "should respond_to #to_param" do
+    "".should respond_to(:to_param)
+  end
+  describe "to_param" do
+    it "should return itself as the value for the passed-in name" do
+      "foo".to_param("quux").should == "quux=foo"
+    end
+    it "should be CGI escaped" do
+      "Whee, some 'unsafe' uri things".to_param("safe").should == "safe=Whee%2C+some+%27unsafe%27+uri+things"
+    end
+  end
+end
+
+describe Hash do
+  it "should respond to #to_param" do
+    {}.should respond_to(:to_param)
+  end
+  describe "to_param" do
+    it "should collect its keys and values into parameter pairs, prepending the provided prefix" do
+      {
+        "kraplach" => "messy",
+        "zebot" => 2003
+      }.to_param("things").should == "things[kraplach]=messy&things[zebot]=2003"
+    end
+    it "should handle having an array as one of its parameters" do
+      result = {
+        "vielleicht" => "perhaps",
+        "ratings" => [5, 3, 5, 2, 4]
+      }.to_param("things")
+      result.split('&').size.should == 6
+      result.should =~ /things\[vielleicht\]=perhaps/
+      result.should =~ /things\[ratings\]\[\]=5/
+      result.should =~ /things\[ratings\]\[\]=3/
+      result.should =~ /things\[ratings\]\[\]=5/
+      result.should =~ /things\[ratings\]\[\]=2/
+      result.should =~ /things\[ratings\]\[\]=4/
+    end
+  end
+end
+
+describe Array do
+  it "should respond_to #to_param" do
+    [].should respond_to(:to_param)
+  end
+  describe "to_param" do
+    it "should join each element, prepending a provided key prefix" do
+      [1, 23, 5].to_param("magic_numbers").should == ["magic_numbers[]=1", "magic_numbers[]=23", "magic_numbers[]=5"].join("&")
+    end
+    it "should call to_param on each element, too" do
+      [1, 23, {"barkley" => 5}].to_param("magic_numbers").should == "magic_numbers[]=1&magic_numbers[]=23&magic_numbers[][barkley]=5"
+    end
+  end
+end
+
+describe Integer do
+  it "should respond_to #to_param" do
+    1.should respond_to(:to_param)
+  end
+  describe "to_param" do
+    it "should return a stringified version of itself, using the provided key" do
+      5.to_param("fixnum").should == "fixnum=5"
+    end
+  end
+end

data/spec/lib/curb-fu/entity_spec.rb

@@ -0,0 +1,37 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe "CurbFu::Entity" do
+  before(:each) do
+    @entity = CurbFu::Entity.new
+    @entity.data = {
+      :zoltan => "Space Emperor!",
+      "em-dashes" => "more space=good"
+    }
+  end
+  
+  describe "to_request_data" do
+    it "should be able to convert parameters into json" do
+      @entity.content_type = :json
+    
+      JSON.parse(@entity.to_request_data).should include("zoltan" => "Space Emperor!", "em-dashes" => "more space=good")
+    end
+    it "should be able to convert parameters into 'XML'" do
+      pending "We need to choose an xml library"
+    
+      @entity.content_type = "application/xml"
+    
+      @entity.to_request_data.should == "XML"
+    end
+    it "should be able to convert parameters into form_url_encoding" do
+      @entity.content_type = :form
+    
+      @entity.to_request_data.split('&').sort.should == ["em-dashes=more+space%3Dgood","zoltan=Space+Emperor%21"]
+    end
+    it "should not attempt to coerce plain text into the requested format" do
+      @entity.content_type = :json
+      @entity.data = "{\"my_own\": \"data\"}"
+
+      @entity.to_request_data.should == "{\"my_own\": \"data\"}"
+    end
+  end
+end

data/spec/lib/curb-fu/request/base_spec.rb

@@ -0,0 +1,240 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require 'curb'
+
+def regex_for_url_with_params(url, *params)
+  regex = '^' + url.gsub('/','\/').gsub('.','\.')
+  regex += '\?' unless params.empty?
+
+  unless params.empty?
+    param_possibilities = params.join('|')
+    regex += params.inject([]) { |list, param| list << "(#{param_possibilities})" }.join('&')
+  end
+  regex += '$'
+  Regexp.new(regex)
+end
+
+class TestHarness
+  extend CurbFu::Request::Base
+  
+  def self.create_post_fields(*args)   # testing interface to private method #create_post_fields
+    super(*args)
+  end
+  
+  def self.create_put_fields(*args)   # testing interface to private method #create_put_fields
+    super(*args)
+  end
+end
+
+describe CurbFu::Request::Base do
+  describe "build_url" do
+    it "should return a string if a string parameter is given" do
+      TestHarness.build_url("http://www.cliffsofinsanity.com").should == "http://www.cliffsofinsanity.com"
+    end
+    it "should return a built url with just a hostname if only the hostname is given" do
+      TestHarness.build_url(:host => "poisonedwine.com").should == "http://poisonedwine.com"
+    end
+    it "should return a built url with hostname and port if port is also given" do
+      TestHarness.build_url(:host => "www2.giantthrowingrocks.com", :port => 8080).
+        should == "http://www2.giantthrowingrocks.com:8080"
+    end
+    it "should return a built url with hostname, port, and path if all are given" do
+      TestHarness.build_url(:host => "spookygiantburningmonk.org", :port => 3000, :path => '/standing/in/a/wheelbarrow.aspx').
+        should == "http://spookygiantburningmonk.org:3000/standing/in/a/wheelbarrow.aspx"
+    end
+    it 'should append a query string if a query params hash is given' do
+      TestHarness.build_url('http://navyseals.mil', :swim_speed => '2knots').
+        should == 'http://navyseals.mil?swim_speed=2knots'
+    end
+    it 'should append a query string if a query string is given' do
+      TestHarness.build_url('http://chocolatecheese.com','?nuts=true').
+        should == 'http://chocolatecheese.com?nuts=true'
+    end
+  end
+
+  describe "get" do
+    it "should get the google" do
+      @mock_curb = mock(Curl::Easy, :headers= => nil, :headers => {}, :header_str => "", :response_code => 200, :body_str => 'yeeeah', :timeout= => nil, :http_get => nil)
+      Curl::Easy.should_receive(:new).with('http://www.google.com').and_return(@mock_curb)
+      
+      TestHarness.get("http://www.google.com")
+    end
+    it "should return a 404 code correctly" do
+      mock_curb = mock(Object, :http_get => nil)
+      TestHarness.stub!(:build).and_return(mock_curb)
+      mock_response = mock(CurbFu::Response::NotFound, :status => 404)
+      CurbFu::Response::Base.stub!(:from_curb_response).and_return(mock_response)
+      
+      TestHarness.get("http://www.google.com/ponies_and_pirates").should == mock_response
+    end
+    it "should append query parameters" do
+      @mock_curb = mock(Curl::Easy, :headers= => nil, :headers => {}, :header_str => "", :response_code => 200, :body_str => 'yeeeah', :timeout= => nil, :http_get => nil)
+      Curl::Easy.should_receive(:new).with(regex_for_url_with_params('http://www.google.com', 'search=MSU\+vs\+UNC', 'limit=200')).and_return(@mock_curb)
+      TestHarness.get('http://www.google.com', { :search => 'MSU vs UNC', :limit => 200 })
+    end
+
+    describe "with_hash" do
+      it "should get google from {:host => \"www.google.com\", :port => 80}" do
+        @mock_curb = mock(Curl::Easy, :headers= => nil, :headers => {}, :header_str => "", :response_code => 200, :body_str => 'yeeeah', :timeout= => nil, :http_get => nil)
+        Curl::Easy.should_receive(:new).with('http://www.google.com:80').and_return(@mock_curb)
+      
+        TestHarness.get({:host => "www.google.com", :port => 80})
+      end
+      it "should set authorization username and password if provided" do
+        @mock_curb = mock(Curl::Easy, :headers= => nil, :headers => {}, :header_str => "", :response_code => 200, :body_str => 'yeeeah', :timeout= => nil, :http_get => nil, :http_auth_types= => nil)
+        Curl::Easy.stub!(:new).and_return(@mock_curb)
+        @mock_curb.should_receive(:userpwd=).with("agent:donttellanyone")
+      
+        TestHarness.get({:host => "secret.domain.com", :port => 80, :username => "agent", :password => "donttellanyone"})
+      end
+      it "should append parameters to the url" do
+        @mock_curb = mock(Curl::Easy, :headers= => nil, :headers => {}, :header_str => "", :response_code => 200, :body_str => 'yeeeah', :timeout= => nil, :http_get => nil)
+        Curl::Easy.should_receive(:new).with(regex_for_url_with_params('http://www.google.com', 'search=MSU\+vs\+UNC', 'limit=200')).and_return(@mock_curb)
+        TestHarness.get({ :host => 'www.google.com' }, { :search => 'MSU vs UNC', :limit => 200 })
+      end
+    end
+  end
+
+  describe "post" do
+    before(:each) do
+      @mock_curb = mock(Curl::Easy, :headers= => nil, :headers => {}, :header_str => "", :response_code => 200, :body_str => 'yeeeah', :timeout= => nil)
+      Curl::Easy.stub!(:new).and_return(@mock_curb)
+    end
+
+    it "should send each parameter to Curb#http_post" do
+      @mock_q = Curl::PostField.content('q','derek')
+      @mock_r = Curl::PostField.content('r','matt')
+      TestHarness.stub!(:create_post_fields).and_return([@mock_q,@mock_r])
+
+      @mock_curb.should_receive(:http_post).with(@mock_q,@mock_r)
+
+      response = TestHarness.post(
+        {:host => "google.com", :port => 80, :path => "/search"},
+        { 'q' => 'derek', 'r' => 'matt' })
+    end
+  end
+  
+  describe "post_file" do
+    it "should set encoding to multipart/form-data" do
+      @cc = mock(Curl::PostField)
+      Curl::PostField.stub!(:file).and_return(@cc)
+      mock_curl = mock(Object, :http_post => nil)
+      mock_curl.should_receive(:multipart_form_post=).with(true)
+      TestHarness.stub!(:build).and_return(mock_curl)
+      CurbFu::Response::Base.stub!(:from_curb_response)
+      
+      TestHarness.post_file('http://example.com', {'gelato' => 'peanut butter'}, 'cc_pic' => '/images/credit_card.jpg')
+    end
+    it "should post with file fields" do
+      @cc = mock(Curl::PostField)
+      Curl::PostField.should_receive(:file).and_return(@cc)
+      mock_curl = mock(Object, :multipart_form_post= => nil, :http_post => nil)
+      TestHarness.stub!(:build).and_return(mock_curl)
+      CurbFu::Response::Base.stub!(:from_curb_response)
+      
+      TestHarness.post_file('http://example.com', {'gelato' => 'peanut butter'}, 'cc_pic' => '/images/credit_card.jpg')
+    end
+    it "should offer more debug information about CurlErrInvalidPostField errors" do
+      @cc = mock(Curl::PostField)
+      Curl::PostField.should_receive(:file).and_return(@cc)
+      mock_curl = mock(Object, :multipart_form_post= => nil)
+      mock_curl.stub!(:http_post).and_raise(Curl::Err::InvalidPostFieldError)
+      TestHarness.stub!(:build).and_return(mock_curl)
+      CurbFu::Response::Base.stub!(:from_curb_response)
+      
+      lambda { TestHarness.post_file('http://example.com', {'gelato' => 'peanut butter'}, 'cc_pic' => '/images/credit_card.jpg') }.
+        should raise_error(Curl::Err::InvalidPostFieldError)
+    end
+  end
+
+  describe "put" do
+    before(:each) do
+      @mock_curb = mock(Curl::Easy, :headers= => nil, :headers => {}, :header_str => "", :response_code => 200, :body_str => 'yeeeah', :timeout= => nil)
+      Curl::Easy.stub!(:new).and_return(@mock_curb)
+    end
+
+    it "should send each parameter to Curb#http_put" do
+      Curl::Easy.should_receive(:new).with('http://google.com:80/search?q=derek&r=matt').and_return(@mock_curb)
+      @mock_curb.should_receive(:http_put)
+
+      response = TestHarness.put(
+        {:host => "google.com", :port => 80, :path => "/search"},
+        { 'q' => 'derek', 'r' => 'matt' })
+    end
+  end
+  
+  describe "create_post_fields" do
+    it "should return the params if params is a string" do
+      TestHarness.create_post_fields("my awesome data that I'm sending to you").
+        should == "my awesome data that I'm sending to you"
+    end
+    it "should convert hash items into Curl::PostFields" do
+      Curl::PostField.should_receive(:content).with('us','obama')
+      Curl::PostField.should_receive(:content).with('de','merkel')
+      TestHarness.create_post_fields(:us => 'obama', :de => 'merkel')
+    end
+    it "should handle params that contain arrays" do
+      Curl::PostField.should_receive(:content).with('q','derek,matt')
+
+      TestHarness.create_post_fields('q' => ['derek','matt'])
+    end
+    it "should handle params that contain any non-Array or non-String data" do
+      Curl::PostField.should_receive(:content).with('q','1')
+
+      TestHarness.create_post_fields('q' => 1)
+    end
+    it "should return an array of Curl::PostFields" do
+      TestHarness.create_post_fields(:ice_cream => 'chocolate', :beverage => 'water').each do |field|
+        field.should be_a_kind_of(Curl::PostField)
+      end
+    end
+  end
+  
+  describe "create_put_fields" do
+    it "should return the params if params is a string" do
+      TestHarness.create_put_fields("my awesome data that I'm sending to you").
+        should == "my awesome data that I'm sending to you"
+    end
+    
+    it 'should handle multiple parameters' do
+      TestHarness.create_put_fields(:rock => 'beatles', :rap => '2pac').
+        should == "rock=beatles&rap=2pac"
+    end
+    
+    it "should handle params that contain arrays" do
+      TestHarness.create_put_fields('q' => ['derek','matt']).
+        should == "q=derek,matt"
+    end
+
+    it "should handle params that contain any non-Array or non-String data" do
+      TestHarness.create_put_fields('q' => 1).should == "q=1"
+    end
+  end
+  
+  describe "global_headers" do
+    it "should use any global headers for every request" do
+      TestHarness.global_headers = {
+        'X-Http-Modern-Parlance' => 'Transmogrify'
+      }
+      
+      mock_curl = mock(Object, :timeout= => 'sure', :http_get => 'uhuh', :response_code => 200, :header_str => 'yep: sure', :body_str => 'ok')
+      Curl::Easy.stub!(:new).and_return(mock_curl)
+      mock_curl.should_receive(:headers=).with('X-Http-Modern-Parlance' => 'Transmogrify')
+      TestHarness.get('http://example.com')
+    end
+    it "should not keep temporary headers from previous requests" do
+      TestHarness.global_headers = {
+        'X-Http-Political-Party' => 'republican'
+      }
+      
+      mock_curl = mock(Object, :timeout= => 'sure', :http_get => 'uhuh', :response_code => 200, :header_str => 'yep: sure', :body_str => 'ok')
+      Curl::Easy.stub!(:new).and_return(mock_curl)
+      mock_curl.stub!(:headers=)
+      
+      TestHarness.get(:host => 'example.com', :headers => { 'Content-Type' => 'cash/dollars' })
+      
+      mock_curl.should_not_receive(:headers=).with(hash_including('Content-Type' => 'cash/dollars'))
+      TestHarness.get('http://example.com')
+      TestHarness.global_headers.should_not include('Content-Type' => 'cash/dollars')  # leave no trace!
+    end
+  end
+end