httparty 0.2.8 → 0.2.9

data/History

@@ -1,3 +1,9 @@
+== 0.2.9 2009-01-29
+* 3 minor enhancements
+  * Added a 'headers' accessor to the response with a hash of any HTTP headers. (Don Peterson)
+  * Add support for a ":cookies" option to be used at the class level, or as an option on any individual call.  It should be passed a hash, which will be converted to the proper format and added to the request headers when the call is made. (Don Peterson)
+  * Refactored several specs and added a full suite of cucumber features (Don Peterson)
+  
 == 0.2.8 2009-01-28
 * 1 major fix
   * fixed major bug with response where it wouldn't iterate or really work at all with parsed responses

data/Manifest

@@ -1,4 +1,5 @@
 bin/httparty
+cucumber.yml
 examples/aaws.rb
 examples/basic.rb
 examples/delicious.rb
@@ -6,9 +7,20 @@ examples/google.rb
 examples/rubyurl.rb
 examples/twitter.rb
 examples/whoismyrep.rb
+features/basic_authentication.feature
+features/command_line.feature
+features/deals_with_http_error_codes.feature
+features/handles_multiple_formats.feature
+features/steps/env.rb
+features/steps/httparty_response_steps.rb
+features/steps/httparty_steps.rb
+features/steps/mongrel_helper.rb
+features/steps/remote_service_steps.rb
+features/supports_redirection.feature
 History
 httparty.gemspec
 lib/core_extensions.rb
+lib/httparty/cookie_hash.rb
 lib/httparty/exceptions.rb
 lib/httparty/request.rb
 lib/httparty/response.rb
@@ -27,6 +39,7 @@ spec/fixtures/google.html
 spec/fixtures/twitter.json
 spec/fixtures/twitter.xml
 spec/fixtures/undefined_method_add_node_for_nil.xml
+spec/httparty/cookie_hash_spec.rb
 spec/httparty/request_spec.rb
 spec/httparty_spec.rb
 spec/spec.opts

data/Rakefile

@@ -6,6 +6,7 @@ require 'rake'
 require 'echoe'
 require 'spec/rake/spectask'
 require "lib/#{ProjectName}/version"
+require 'cucumber/rake/task'
 
 Echoe.new(ProjectName, HTTParty::Version) do |p|
   p.description     = "Makes http fun! Also, makes consuming restful web services dead easy."
@@ -40,4 +41,8 @@ Rake::Task[:default].prerequisites.clear
 task :default => :spec
 Spec::Rake::SpecTask.new do |t|
   t.spec_files = FileList["spec/**/*_spec.rb"]
-end
+end
+
+Cucumber::Rake::Task.new(:features) do |t|
+  t.cucumber_opts = "--format pretty" 
+end

data/cucumber.yml

@@ -0,0 +1 @@
+default: features

data/examples/basic.rb

@@ -4,7 +4,7 @@ require 'pp'
 
 # You can also use post, put, delete in the same fashion
 response = HTTParty.get('http://twitter.com/statuses/public_timeline.json')
-pp response
+puts response.body, response.code, response.headers.inspect
 
 response.each do |item|
   puts item['user']['screen_name']

data/examples/delicious.rb

@@ -34,3 +34,4 @@ delicious = Delicious.new(config['username'], config['password'])
 pp delicious.posts(:query => {:tag => 'ruby'})
 pp delicious.recent
 
+delicious.recent['posts']['post'].each { |post| puts post['href'] }

data/examples/rubyurl.rb

@@ -11,4 +11,4 @@ class Rubyurl
   end
 end
 
-pp Rubyurl.shorten( 'http://istwitterdown.com/' )
+pp Rubyurl.shorten( 'http://istwitterdown.com/')

data/features/basic_authentication.feature

@@ -0,0 +1,20 @@
+Feature:  Basic Authentication
+
+  As a developer
+  I want to be able to use a service that requires Basic Authentication
+  Because that is not an uncommon requirement
+
+  Scenario: Passing no credentials to a page requiring Basic Authentication
+    Given a restricted page at '/protected.html'
+    When I call HTTParty#get with '/protected.html'
+    Then it should return a response with a 401 response code
+
+  Scenario: Passing proper credentials to a page requiring Basic Authentication
+    Given a remote service that returns 'Authenticated Page'
+    And that service is accessed at the path '/protected.html'
+    And that service is protected by Basic Authentication
+    And that service requires the username 'jcash' with the password 'maninblack'
+    When I call HTTParty#get with '/protected.html' and a basic_auth hash:
+       | username | password   |
+       | jcash    | maninblack |
+    Then the return value should match 'Authenticated Page'

data/features/command_line.feature

@@ -0,0 +1,7 @@
+Feature: Command Line
+
+  As a developer
+  I want to be able to harness the power of HTTParty from the command line
+  Because that would make quick testing and debugging easy
+  And 'easy' is my middle name
+  And I'm kidding it's actually 'Danger'!

data/features/deals_with_http_error_codes.feature

@@ -0,0 +1,26 @@
+Feature: Deals with HTTP error codes
+
+  As a developer
+  I want to be informed of non-successful responses
+  Because sometimes thing explode
+  And I should probably know what happened
+
+  Scenario: A response of '404 - Not Found'
+    Given a remote service that returns a 404 status code
+    And that service is accessed at the path '/service.html'
+    When I call HTTParty#get with '/service.html'
+    Then it should return a response with a 404 response code
+
+  Scenario: A response of '500 - Internal Server Error'
+    Given a remote service that returns a 500 status code
+    And that service is accessed at the path '/service.html'
+    When I call HTTParty#get with '/service.html'
+    Then it should return a response with a 500 response code
+
+  Scenario: A non-successful response where I need the body
+    Given a remote service that returns a 400 status code
+    And the response from the service has a body of 'Bad response'
+    And that service is accessed at the path '/service.html'
+    When I call HTTParty#get with '/service.html'
+    Then it should return a response with a 400 response code
+    And the return value should match 'Bad response'

data/features/handles_multiple_formats.feature

@@ -0,0 +1,34 @@
+Feature: Handles Multiple Formats
+
+  As a developer
+  I want to be able to consume remote services of many different formats
+  And I want those formats to be automatically detected and handled
+  Because web services take many forms
+  And I don't want to have to do any extra work
+
+  Scenario: An HTML service
+    Given a remote service that returns '<h1>Some HTML</h1>'
+    And that service is accessed at the path '/service.html'
+    And the response from the service has a Content-Type of 'text/html'
+    When I call HTTParty#get with '/service.html'
+    Then it should return a String
+    And the return value should match '<h1>Some HTML</h1>'
+
+  Scenario: A JSON service
+    Given a remote service that returns '{ "jennings": "waylon", "cash": "johnny" }'
+    And that service is accessed at the path '/service.json'
+    And the response from the service has a Content-Type of 'application/json'
+    When I call HTTParty#get with '/service.json'
+    Then it should return a Hash equaling:
+       | key      | value  |
+       | jennings | waylon |
+       | cash     | johnny |
+
+  Scenario: An XML Service
+    Given a remote service that returns '<singer>waylon jennings</singer>'
+    And that service is accessed at the path '/service.xml'
+    And the response from the service has a Content-Type of 'text/xml'
+    When I call HTTParty#get with '/service.xml'
+    Then it should return a Hash equaling:
+       | key    | value           |
+       | singer | waylon jennings |

data/features/steps/env.rb

@@ -0,0 +1,15 @@
+require 'mongrel'
+require 'activesupport'
+require 'lib/httparty'
+require 'spec/expectations'
+
+Before do
+  port = ENV["HTTPARTY_PORT"] || 31981
+  @host_and_port = "0.0.0.0:#{port}"
+  @server = Mongrel::HttpServer.new("0.0.0.0", port)
+  @server.run
+end
+
+After do
+  @server.stop
+end

data/features/steps/httparty_response_steps.rb

@@ -0,0 +1,26 @@
+Then /it should return an? (\w+)$/ do |class_string|
+  @response_from_httparty.should be_an_instance_of(class_string.constantize)
+end
+
+Then /the return value should match '(.*)'/ do |expected_text|
+  @response_from_httparty.should eql(expected_text)
+end
+
+Then /it should return a Hash equaling:/ do |hash_table|
+  @response_from_httparty.should be_an_instance_of(Hash)
+  @response_from_httparty.keys.length.should eql(hash_table.rows.length)
+  hash_table.hashes.each do |pair|
+    key, value = pair["key"], pair["value"]
+    @response_from_httparty.keys.should include(key)
+    @response_from_httparty[key].should eql(value)
+  end
+end
+
+Then /it should return a response with a (\d+) response code/ do |code|
+  @response_from_httparty.code.should eql(code)
+end
+
+Then /it should raise an HTTParty::RedirectionTooDeep exception/ do
+  @exception_from_httparty.should_not be_nil
+  @exception_from_httparty.class.should eql(HTTParty::RedirectionTooDeep)
+end

data/features/steps/httparty_steps.rb

@@ -0,0 +1,15 @@
+When /I call HTTParty#get with '(.*)'$/ do |url|
+  begin
+    @response_from_httparty = HTTParty.get("http://#{@host_and_port}#{url}")
+  rescue HTTParty::RedirectionTooDeep => e
+    @exception_from_httparty = e
+  end
+end
+
+When /I call HTTParty#get with '(.*)' and a basic_auth hash:/ do |url, auth_table|
+  h = auth_table.hashes.first
+  @response_from_httparty = HTTParty.get(
+    "http://#{@host_and_port}#{url}",
+    :basic_auth => { :username => h["username"], :password => h["password"] }
+  )
+end

data/features/steps/mongrel_helper.rb

@@ -0,0 +1,55 @@
+def basic_mongrel_handler
+  Class.new(Mongrel::HttpHandler) do
+    attr_writer :content_type, :response_body, :response_code
+
+    def initialize
+      @content_type = "text/html"
+      @response_body = ""
+      @response_code = 200
+      @custom_headers = {}
+    end
+
+    def process(request, response)
+      reply_with(response, @response_code, @response_body)
+    end
+
+    def reply_with(response, code, response_body)
+      response.start(code) do |head, body|
+        head["Content-Type"] = @content_type
+        @custom_headers.each { |k,v| head[k] = v }
+        body.write(response_body)
+      end
+    end
+  end
+end
+
+def new_mongrel_handler
+  basic_mongrel_handler.new
+end
+
+def add_basic_authentication_to(handler)
+  m = Module.new do
+    attr_writer :username, :password
+
+    def self.extended(base)
+      base.instance_eval { @custom_headers["WWW-Authenticate"] = 'Basic Realm="Super Secret Page"' }
+      base.class_eval { alias_method_chain :process, :basic_authentication }
+    end
+
+    def process_with_basic_authentication(request, response)
+      if authorized?(request) then process_without_basic_authentication(request, response)
+      else reply_with(response, 401, "Incorrect.  You have 20 seconds to comply.")
+      end
+    end
+
+    def authorized?(request)
+      request.params["HTTP_AUTHORIZATION"] == "Basic " + Base64.encode64("#{@username}:#{@password}").strip
+    end
+  end
+  handler.extend(m)
+end
+
+def new_mongrel_redirector(target_url, relative_path = false)
+  target_url = "http://#{@host_and_port}#{target_url}" unless relative_path
+  Mongrel::RedirectHandler.new(target_url)
+end

data/features/steps/remote_service_steps.rb

@@ -0,0 +1,47 @@
+Given /a remote service that returns '(.*)'/ do |response_body|
+  @handler = new_mongrel_handler
+  Given "the response from the service has a body of '#{response_body}'"
+end
+
+Given /a remote service that returns a (\d+) status code/ do |code|
+  @handler = new_mongrel_handler
+  @handler.response_code = code
+end
+
+Given /that service is accessed at the path '(.*)'/ do |path|
+  @server.register(path, @handler)
+end
+
+Given /the response from the service has a Content-Type of '(.*)'/ do |content_type|
+  @handler.content_type = content_type
+end
+
+Given /the response from the service has a body of '(.*)'/ do |response_body|
+  @handler.response_body = response_body
+end
+
+Given /the url '(.*)' redirects to '(.*)'/ do |redirection_url, target_url|
+  @server.register redirection_url, new_mongrel_redirector(target_url)
+end
+
+Given /that service is protected by Basic Authentication/ do
+  add_basic_authentication_to @handler
+end
+
+Given /that service requires the username '(.*)' with the password '(.*)'/ do |username, password|
+  @handler.username = username
+  @handler.password = password
+end
+
+Given /a restricted page at '(.*)'/ do |url|
+  Given "a remote service that returns 'A response I will never see'"
+  And "that service is accessed at the path '#{url}'"
+  And "that service is protected by Basic Authentication"
+  And "that service requires the username 'something' with the password 'secret'"
+end
+
+# This joins the server thread, and halts cucumber, so you can actually hit the
+# server with a browser.  Runs until you kill it with Ctrl-c
+Given /I want to hit this in a browser/ do
+  @server.acceptor.join
+end

data/features/supports_redirection.feature

@@ -0,0 +1,22 @@
+Feature: Supports Redirection
+
+  As a developer
+  I want to work with services that may redirect me
+  And I want it to follow a reasonable number of redirects
+  Because sometimes web services do that
+
+  Scenario: A service that redirects once
+    Given a remote service that returns 'Service Response'
+    And that service is accessed at the path '/service.html'
+    And the url '/redirector.html' redirects to '/service.html'
+    When I call HTTParty#get with '/redirector.html'
+    Then the return value should match 'Service Response'
+
+  # TODO: Look in to why this actually fails...
+  Scenario: A service that redirects to a relative URL
+
+  Scenario: A service that redirects infinitely
+    Given the url '/first.html' redirects to '/second.html'
+    And the url '/second.html' redirects to '/first.html'
+    When I call HTTParty#get with '/first.html'
+    Then it should raise an HTTParty::RedirectionTooDeep exception

data/httparty.gemspec

@@ -2,17 +2,17 @@
 
 Gem::Specification.new do |s|
   s.name = %q{httparty}
-  s.version = "0.2.8"
+  s.version = "0.2.9"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["John Nunemaker"]
-  s.date = %q{2009-01-28}
+  s.date = %q{2009-01-29}
   s.default_executable = %q{httparty}
   s.description = %q{Makes http fun! Also, makes consuming restful web services dead easy.}
   s.email = %q{nunemaker@gmail.com}
   s.executables = ["httparty"]
-  s.extra_rdoc_files = ["bin/httparty", "lib/core_extensions.rb", "lib/httparty/exceptions.rb", "lib/httparty/request.rb", "lib/httparty/response.rb", "lib/httparty/version.rb", "lib/httparty.rb", "lib/module_level_inheritable_attributes.rb", "README"]
-  s.files = ["bin/httparty", "examples/aaws.rb", "examples/basic.rb", "examples/delicious.rb", "examples/google.rb", "examples/rubyurl.rb", "examples/twitter.rb", "examples/whoismyrep.rb", "History", "httparty.gemspec", "lib/core_extensions.rb", "lib/httparty/exceptions.rb", "lib/httparty/request.rb", "lib/httparty/response.rb", "lib/httparty/version.rb", "lib/httparty.rb", "lib/module_level_inheritable_attributes.rb", "Manifest", "MIT-LICENSE", "Rakefile", "README", "setup.rb", "spec/as_buggery_spec.rb", "spec/fixtures/delicious.xml", "spec/fixtures/empty.xml", "spec/fixtures/google.html", "spec/fixtures/twitter.json", "spec/fixtures/twitter.xml", "spec/fixtures/undefined_method_add_node_for_nil.xml", "spec/httparty/request_spec.rb", "spec/httparty_spec.rb", "spec/spec.opts", "spec/spec_helper.rb", "website/css/common.css", "website/index.html"]
+  s.extra_rdoc_files = ["bin/httparty", "lib/core_extensions.rb", "lib/httparty/cookie_hash.rb", "lib/httparty/exceptions.rb", "lib/httparty/request.rb", "lib/httparty/response.rb", "lib/httparty/version.rb", "lib/httparty.rb", "lib/module_level_inheritable_attributes.rb", "README"]
+  s.files = ["bin/httparty", "cucumber.yml", "examples/aaws.rb", "examples/basic.rb", "examples/delicious.rb", "examples/google.rb", "examples/rubyurl.rb", "examples/twitter.rb", "examples/whoismyrep.rb", "features/basic_authentication.feature", "features/command_line.feature", "features/deals_with_http_error_codes.feature", "features/handles_multiple_formats.feature", "features/steps/env.rb", "features/steps/httparty_response_steps.rb", "features/steps/httparty_steps.rb", "features/steps/mongrel_helper.rb", "features/steps/remote_service_steps.rb", "features/supports_redirection.feature", "History", "httparty.gemspec", "lib/core_extensions.rb", "lib/httparty/cookie_hash.rb", "lib/httparty/exceptions.rb", "lib/httparty/request.rb", "lib/httparty/response.rb", "lib/httparty/version.rb", "lib/httparty.rb", "lib/module_level_inheritable_attributes.rb", "Manifest", "MIT-LICENSE", "Rakefile", "README", "setup.rb", "spec/as_buggery_spec.rb", "spec/fixtures/delicious.xml", "spec/fixtures/empty.xml", "spec/fixtures/google.html", "spec/fixtures/twitter.json", "spec/fixtures/twitter.xml", "spec/fixtures/undefined_method_add_node_for_nil.xml", "spec/httparty/cookie_hash_spec.rb", "spec/httparty/request_spec.rb", "spec/httparty_spec.rb", "spec/spec.opts", "spec/spec_helper.rb", "website/css/common.css", "website/index.html"]
   s.has_rdoc = true
   s.homepage = %q{http://httparty.rubyforge.org}
   s.post_install_message = %q{When you HTTParty, you must party hard!}

data/lib/core_extensions.rb

@@ -346,4 +346,8 @@ class Hash
       %{#{k.to_s.snake_case.sub(/^(.{1,1})/) { |m| m.downcase }}="#{v}"}
     end.join(' ')
   end
-end
+end
+
+class BlankSlate
+  instance_methods.each { |m| undef_method m unless m =~ /^__/ }
+end

data/lib/httparty.rb

@@ -58,6 +58,12 @@ module HTTParty
       default_options[:headers] ||= {}
       default_options[:headers].merge!(h)
     end
+
+    def cookies(h={})
+      raise ArgumentError, 'Cookies must be a hash' unless h.is_a?(Hash)
+      default_options[:cookies] ||= CookieHash.new
+      default_options[:cookies].add_cookies(h)
+    end
     
     def format(f)
       raise UnsupportedFormat, "Must be one of: #{AllowedFormats.values.join(', ')}" unless AllowedFormats.value?(f)
@@ -82,8 +88,18 @@ module HTTParty
 
     private
       def perform_request(http_method, path, options) #:nodoc:
+        process_cookies(options)
         Request.new(http_method, path, default_options.dup.merge(options)).perform
       end
+
+      def process_cookies(options) #:nodoc:
+        return unless options[:cookies] || default_options[:cookies]
+        options[:headers] ||= {}
+        options[:headers]["cookie"] = cookies(options[:cookies] || {}).to_cookie_string
+
+        default_options.delete(:cookies)
+        options.delete(:cookies)
+      end
   end
 
   def self.normalize_base_uri(url) #:nodoc:
@@ -119,4 +135,5 @@ end
 
 require 'httparty/exceptions'
 require 'httparty/request'
-require 'httparty/response'
+require 'httparty/response'
+require 'httparty/cookie_hash'

data/lib/httparty/cookie_hash.rb

@@ -0,0 +1,9 @@
+class HTTParty::CookieHash < Hash
+  def add_cookies(hash)
+    merge!(hash)
+  end
+
+  def to_cookie_string
+    collect { |k, v| "#{k}=#{v}" }.join("; ")
+  end
+end

data/lib/httparty/request.rb

@@ -93,7 +93,7 @@ module HTTParty
             perform
           else
             parsed_response = parse_response(response.body)
-            Response.new(parsed_response, response.body, response.code)
+            Response.new(parsed_response, response.body, response.code, response.to_hash)
           end
       end
       

data/lib/httparty/response.rb

@@ -1,27 +1,16 @@
 module HTTParty
-  class Response
-    attr_accessor :body, :code
+  class Response < BlankSlate
+    attr_accessor :body, :code, :headers
 
-    def initialize(delegate, body, code)
+    def initialize(delegate, body, code, headers)
       @delegate = delegate
       @body = body
       @code = code
+      @headers = headers
     end
 
     def method_missing(name, *args, &block)
       @delegate.send(name, *args, &block)
     end
-
-    def ==(other)
-      @delegate == other
-    end
-    
-    def nil?
-      @delegate.nil?
-    end
-
-    def pretty_print(q)
-      @delegate.pretty_print(q)
-    end
   end
-end
+end

data/lib/httparty/version.rb

@@ -1,3 +1,3 @@
 module HTTParty
-  Version = '0.2.8'
+  Version = '0.2.9'
 end

data/spec/httparty/cookie_hash_spec.rb

@@ -0,0 +1,38 @@
+require File.join(File.dirname(__FILE__), '../spec_helper')
+
+describe HTTParty::CookieHash do
+  before(:each) do
+    @cookie_hash = HTTParty::CookieHash.new
+  end
+
+  describe "#add_cookies" do
+    it "should add new key/value pairs to the hash" do
+      @cookie_hash.add_cookies(:foo => "bar")
+      @cookie_hash.add_cookies(:rofl => "copter")
+      @cookie_hash.length.should eql(2)
+    end
+
+    it "should overwrite any existing key" do
+      @cookie_hash.add_cookies(:foo => "bar")
+      @cookie_hash.add_cookies(:foo => "copter")
+      @cookie_hash.length.should eql(1)
+      @cookie_hash[:foo].should eql("copter")
+    end
+  end
+
+  # The regexen are required because Hashes aren't ordered, so a test against
+  # a hardcoded string was randomly failing.
+  describe "#to_cookie_string" do
+    before(:each) do
+      @cookie_hash.add_cookies(:foo => "bar")
+      @cookie_hash.add_cookies(:rofl => "copter")
+      @s = @cookie_hash.to_cookie_string
+    end
+
+    it "should format the key/value pairs, delimited by semi-colons" do
+      @s.should match(/foo=bar/)
+      @s.should match(/rofl=copter/)
+      @s.should match(/^\w+=\w+; \w+=\w+$/)
+    end
+  end
+end

data/spec/httparty/request_spec.rb

@@ -1,6 +1,20 @@
 require File.join(File.dirname(__FILE__), '..', 'spec_helper')
 
 describe HTTParty::Request do
+  def stub_response(body, code = 200)
+    unless @http
+      @http = Net::HTTP.new('localhost', 80)
+      @request.stub!(:http).and_return(@http)
+      @request.stub!(:uri).and_return(URI.parse("http://foo.com/foobar"))
+    end
+
+    response = Net::HTTPResponse::CODE_TO_OBJ[code.to_s].new("1.1", code, body)
+    response.stub!(:body).and_return(body)
+
+    @http.stub!(:request).and_return(response)
+    response
+  end
+
   before do
     @request = HTTParty::Request.new(Net::HTTP::Get, 'http://api.foo.com/v1', :format => :xml)
   end
@@ -79,14 +93,19 @@ describe HTTParty::Request do
       @request.options[:format] = :json
       @request.send(:parse_response, json).should == {'books' => {'book' => {'id' => '1234', 'name' => 'Foo Bar!'}}}
     end
+
+    it "should include any HTTP headers in the returned response" do
+      @request.options[:format] = :html
+      response = stub_response "Content"
+      response.initialize_http_header("key" => "value")
+
+      @request.perform.headers.should == { "key" => ["value"] }
+    end
     
     describe 'with non-200 responses' do
 
       it 'should return a valid object for 4xx response' do
-        http_response = Net::HTTPUnauthorized.new('1.1', 401, '')
-        http_response.stub!(:body).and_return('<foo><bar>yes</bar></foo>')
-        
-        @request.should_receive(:get_response).and_return(http_response)
+        stub_response '<foo><bar>yes</bar></foo>', 401
         resp = @request.perform
         resp.code.should == 401
         resp.body.should == "<foo><bar>yes</bar></foo>"
@@ -94,10 +113,7 @@ describe HTTParty::Request do
       end
 
       it 'should return a valid object for 5xx response' do
-        http_response = Net::HTTPUnauthorized.new('1.1', 500, '')
-        http_response.stub!(:body).and_return('<foo><bar>error</bar></foo>')
-        
-        @request.should_receive(:get_response).and_return(http_response)
+        stub_response '<foo><bar>error</bar></foo>', 500
         resp = @request.perform
         resp.code.should == 500
         resp.body.should == "<foo><bar>error</bar></foo>"
@@ -108,92 +124,59 @@ describe HTTParty::Request do
   end
 
   it "should not attempt to parse empty responses" do
-    http = Net::HTTP.new('localhost', 80)
-    @request.stub!(:http).and_return(http)
-    response = Net::HTTPNoContent.new("1.1", 204, "No content for you")
-    response.stub!(:body).and_return(nil)
-    http.stub!(:request).and_return(response)
-    
-    @request.options[:format] = :xml
-    @request.perform.should be_nil
+    stub_response "", 204
 
-    response.stub!(:body).and_return("")
+    @request.options[:format] = :xml
     @request.perform.should be_nil
   end
   
   it "should not fail for missing mime type" do
-    http = Net::HTTP.new('localhost', 80)
-    @request.stub!(:http).and_return(http)
-    
-    response = Net::HTTPOK.new("1.1", 200, "Content for you")
-    response.stub!(:[]).with('content-type').and_return(nil)
-    response.stub!(:body).and_return('Content for you')
-    
-    http.stub!(:request).and_return(response)
-    
+    stub_response "Content for you"
     @request.options[:format] = :html
     @request.perform.should == 'Content for you'
   end
 
-  describe "that respond with redirects" do
-    def setup_redirect
-      @http = Net::HTTP.new('localhost', 80)
-      @request.stub!(:http).and_return(@http)
-      @request.stub!(:uri).and_return(URI.parse("http://foo.com/foobar"))
-      @redirect = Net::HTTPFound.new("1.1", 302, "")
+  describe "a request that redirects" do
+    before(:each) do
+      @redirect = stub_response("", 302)
       @redirect['location'] = '/foo'
-    end
-
-    def setup_ok_response
-      @ok = Net::HTTPOK.new("1.1", 200, "Content for you")
-      @ok.stub!(:body).and_return('<hash><foo>bar</foo></hash>')
-      @http.should_receive(:request).and_return(@redirect, @ok)
-      @request.options[:format] = :xml
-    end
 
-    def setup_redirect_response
-      @http.stub!(:request).and_return(@redirect)
+      @ok = stub_response('<hash><foo>bar</foo></hash>', 200)
     end
 
-    def setup_successful_redirect
-      setup_redirect
-      setup_ok_response
-    end
-
-    def setup_infinite_redirect
-      setup_redirect
-      setup_redirect_response
-    end
+    describe "once" do
+      before(:each) do
+        @http.stub!(:request).and_return(@redirect, @ok)
+      end
 
-    it "should handle redirects for GET transparently" do
-      setup_successful_redirect
-      @request.perform.should == {"hash" => {"foo" => "bar"}}
-    end
+      it "should be handled by GET transparently" do
+        @request.perform.should == {"hash" => {"foo" => "bar"}}
+      end
 
-    it "should handle redirects for POST transparently" do
-      setup_successful_redirect
-      @request.http_method = Net::HTTP::Post
-      @request.perform.should == {"hash" => {"foo" => "bar"}}
-    end
+      it "should be handled by POST transparently" do
+        @request.http_method = Net::HTTP::Post
+        @request.perform.should == {"hash" => {"foo" => "bar"}}
+      end
 
-    it "should handle redirects for DELETE transparently" do
-      setup_successful_redirect
-      @request.http_method = Net::HTTP::Delete
-      @request.perform.should == {"hash" => {"foo" => "bar"}}
-    end
+      it "should be handled by DELETE transparently" do
+        @request.http_method = Net::HTTP::Delete
+        @request.perform.should == {"hash" => {"foo" => "bar"}}
+      end
 
-    it "should handle redirects for PUT transparently" do
-      setup_successful_redirect
-      @request.http_method = Net::HTTP::Put
-      @request.perform.should == {"hash" => {"foo" => "bar"}}
+      it "should be handled by PUT transparently" do
+        @request.http_method = Net::HTTP::Put
+        @request.perform.should == {"hash" => {"foo" => "bar"}}
+      end
     end
 
-    it "should prevent infinite loops" do
-      setup_infinite_redirect
+    describe "infinitely" do
+      before(:each) do
+        @http.stub!(:request).and_return(@redirect)
+      end
 
-      lambda do
-        @request.perform
-      end.should raise_error(HTTParty::RedirectionTooDeep)
+      it "should raise an exception" do
+        lambda { @request.perform }.should raise_error(HTTParty::RedirectionTooDeep)
+      end
     end
   end
 end
@@ -204,4 +187,4 @@ describe HTTParty::Request, "with POST http method" do
       HTTParty::Request.new(Net::HTTP::Post, 'http://api.foo.com/v1', :format => :xml, :query => 'astring').perform
     }.should raise_error(ArgumentError)
   end
-end
+end

data/spec/httparty_spec.rb

@@ -1,36 +1,23 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
-class Foo
-  include HTTParty
-  base_uri 'api.foo.com/v1'
-end
-
-class GRest
-  include HTTParty
-  base_uri "grest.com"
-  default_params :one => 'two'
-end
-
-class HRest
-  include HTTParty
-  base_uri "hrest.com"
-  default_params :two => 'three'
-end
-
 describe HTTParty do
-  
+  before(:each) do
+    @klass = Class.new
+    @klass.instance_eval { include HTTParty }
+  end
+
   describe "base uri" do
-    before do
-      Foo.base_uri('api.foo.com/v1')
+    before(:each) do
+      @klass.base_uri('api.foo.com/v1')
     end
 
     it "should have reader" do
-      Foo.base_uri.should == 'http://api.foo.com/v1'
+      @klass.base_uri.should == 'http://api.foo.com/v1'
     end
     
     it 'should have writer' do
-      Foo.base_uri('http://api.foobar.com')
-      Foo.base_uri.should == 'http://api.foobar.com'
+      @klass.base_uri('http://api.foobar.com')
+      @klass.base_uri.should == 'http://api.foobar.com'
     end
   end
   
@@ -53,49 +40,113 @@ describe HTTParty do
   
   describe "headers" do
     it "should default to empty hash" do
-      Foo.headers.should == {}
+      @klass.headers.should == {}
     end
     
     it "should be able to be updated" do
       init_headers = {:foo => 'bar', :baz => 'spax'}
-      Foo.headers init_headers
-      Foo.headers.should == init_headers
+      @klass.headers init_headers
+      @klass.headers.should == init_headers
+    end
+  end
+
+  describe "cookies" do
+    def expect_cookie_header(s)
+      HTTParty::Request.should_receive(:new) \
+        .with(anything, anything, hash_including({ :headers => { "cookie" => s } })) \
+        .and_return(mock("mock response", :perform => nil))
+    end
+
+    it "should not be in the headers by default" do
+      HTTParty::Request.stub!(:new).and_return(stub(nil, :perform => nil))
+      @klass.get("")
+      @klass.headers.keys.should_not include("cookie")
+    end
+
+    it "should raise an ArgumentError if passed a non-Hash" do
+      lambda do
+        @klass.cookies("nonsense")
+      end.should raise_error(ArgumentError)
+    end
+
+    it "should allow a cookie to be specified with a one-off request" do
+      expect_cookie_header "type=snickerdoodle"
+      @klass.get("", :cookies => { :type => "snickerdoodle" })
+    end
+
+    describe "when a cookie is set at the class level" do
+      before(:each) do
+        @klass.cookies({ :type => "snickerdoodle" })
+      end
+
+      it "should include that cookie in the request" do
+        expect_cookie_header "type=snickerdoodle"
+        @klass.get("")
+      end
+
+      it "should allow the class defaults to be overridden" do
+        expect_cookie_header "type=chocolate_chip"
+
+        @klass.get("", :cookies => { :type => "chocolate_chip" })
+      end
+    end
+
+    describe "in a class with multiple methods that use different cookies" do
+      before(:each) do
+        @klass.instance_eval do
+          def first_method
+            get("first_method", :cookies => { :first_method_cookie => "foo" })
+          end
+
+          def second_method
+            get("second_method", :cookies => { :second_method_cookie => "foo" })
+          end
+        end
+      end
+
+      it "should not allow cookies used in one method to carry over into other methods" do
+        expect_cookie_header "first_method_cookie=foo"
+        @klass.first_method
+
+        expect_cookie_header "second_method_cookie=foo"
+        @klass.second_method
+      end
     end
   end
   
   describe "default params" do
     it "should default to empty hash" do
-      Foo.default_params.should == {}
+      @klass.default_params.should == {}
     end
     
     it "should be able to be updated" do
       new_defaults = {:foo => 'bar', :baz => 'spax'}
-      Foo.default_params new_defaults
-      Foo.default_params.should == new_defaults
+      @klass.default_params new_defaults
+      @klass.default_params.should == new_defaults
     end
   end
   
   describe "basic http authentication" do
     it "should work" do
-      Foo.basic_auth 'foobar', 'secret'
-      Foo.default_options[:basic_auth].should == {:username => 'foobar', :password => 'secret'}
+      @klass.basic_auth 'foobar', 'secret'
+      @klass.default_options[:basic_auth].should == {:username => 'foobar', :password => 'secret'}
     end
   end
   
   describe "format" do
     it "should allow xml" do
-      Foo.format :xml
-      Foo.default_options[:format].should == :xml
+      @klass.format :xml
+      @klass.default_options[:format].should == :xml
     end
     
     it "should allow json" do
-      Foo.format :json
-      Foo.default_options[:format].should == :json
+      @klass.format :json
+      @klass.default_options[:format].should == :json
     end
     
     it 'should not allow funky format' do
       lambda do
-        Foo.format :foobar
+        @klass.format :foobar
       end.should raise_error(HTTParty::UnsupportedFormat)
     end
   end
@@ -104,33 +155,47 @@ describe HTTParty do
 
     it "should fail with redirected GET" do
       lambda do
-        Foo.get('/foo', :no_follow => true)
+        @klass.get('/foo', :no_follow => true)
       end.should raise_error(HTTParty::RedirectionTooDeep)
     end
 
     it "should fail with redirected POST" do
       lambda do
-        Foo.post('/foo', :no_follow => true)
+        @klass.post('/foo', :no_follow => true)
       end.should raise_error(HTTParty::RedirectionTooDeep)
     end
 
     it "should fail with redirected DELETE" do
       lambda do
-        Foo.delete('/foo', :no_follow => true)
+        @klass.delete('/foo', :no_follow => true)
       end.should raise_error(HTTParty::RedirectionTooDeep)
     end
 
     it "should fail with redirected PUT" do
       lambda do
-        Foo.put('/foo', :no_follow => true)
+        @klass.put('/foo', :no_follow => true)
       end.should raise_error(HTTParty::RedirectionTooDeep)
     end
   end
   
   describe "with multiple class definitions" do
+    before(:each) do
+      @klass.instance_eval do
+        base_uri "http://first.com"
+        default_params :one => 1
+      end
+
+      @additional_klass = Class.new
+      @additional_klass.instance_eval do
+        include HTTParty
+        base_uri "http://second.com"
+        default_params :two => 2
+      end
+    end
+
     it "should not run over each others options" do
-      HRest.default_options.should == {:base_uri => 'http://hrest.com', :default_params => {:two => 'three'}}
-      GRest.default_options.should == {:base_uri => 'http://grest.com', :default_params => {:one => 'two'}}
+      @klass.default_options.should == { :base_uri => 'http://first.com', :default_params => { :one => 1 } }
+      @additional_klass.default_options.should == { :base_uri => 'http://second.com', :default_params => { :two => 2 } }
     end
   end
   

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: httparty
 version: !ruby/object:Gem::Version 
-  version: 0.2.8
+  version: 0.2.9
 platform: ruby
 authors: 
 - John Nunemaker
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-28 00:00:00 -05:00
+date: 2009-01-29 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -41,6 +41,7 @@ extensions: []
 extra_rdoc_files: 
 - bin/httparty
 - lib/core_extensions.rb
+- lib/httparty/cookie_hash.rb
 - lib/httparty/exceptions.rb
 - lib/httparty/request.rb
 - lib/httparty/response.rb
@@ -50,6 +51,7 @@ extra_rdoc_files:
 - README
 files: 
 - bin/httparty
+- cucumber.yml
 - examples/aaws.rb
 - examples/basic.rb
 - examples/delicious.rb
@@ -57,9 +59,20 @@ files:
 - examples/rubyurl.rb
 - examples/twitter.rb
 - examples/whoismyrep.rb
+- features/basic_authentication.feature
+- features/command_line.feature
+- features/deals_with_http_error_codes.feature
+- features/handles_multiple_formats.feature
+- features/steps/env.rb
+- features/steps/httparty_response_steps.rb
+- features/steps/httparty_steps.rb
+- features/steps/mongrel_helper.rb
+- features/steps/remote_service_steps.rb
+- features/supports_redirection.feature
 - History
 - httparty.gemspec
 - lib/core_extensions.rb
+- lib/httparty/cookie_hash.rb
 - lib/httparty/exceptions.rb
 - lib/httparty/request.rb
 - lib/httparty/response.rb
@@ -78,6 +91,7 @@ files:
 - spec/fixtures/twitter.json
 - spec/fixtures/twitter.xml
 - spec/fixtures/undefined_method_add_node_for_nil.xml
+- spec/httparty/cookie_hash_spec.rb
 - spec/httparty/request_spec.rb
 - spec/httparty_spec.rb
 - spec/spec.opts