yoyle439587298 0.13.0

data/examples/whoismyrep.rb

@@ -0,0 +1,10 @@
+dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require File.join(dir, 'httparty')
+require 'pp'
+
+class Rep
+  include HTTParty
+end
+
+pp Rep.get('http://whoismyrepresentative.com/getall_mems.php?zip=46544')
+pp Rep.get('http://whoismyrepresentative.com/getall_mems.php', :query => {:zip => 46544})

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 '/basic_auth.html'
+    When I call HTTParty#get with '/basic_auth.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 '/basic_auth.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 '/basic_auth.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 '/404_service.html'
+    When I call HTTParty#get with '/404_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 '/500_service.html'
+    When I call HTTParty#get with '/500_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 '/400_service.html'
+    When I call HTTParty#get with '/400_service.html'
+    Then it should return a response with a 400 response code
+    And the return value should match 'Bad response'

data/features/digest_authentication.feature

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

data/features/handles_compressed_responses.feature

@@ -0,0 +1,27 @@
+Feature: Handles Compressed Responses
+
+  In order to save bandwidth
+  As a developer
+  I want to uncompress compressed responses
+
+  Scenario: Supports deflate encoding
+    Given a remote deflate service
+    And the response from the service has a body of '<h1>Some HTML</h1>'
+    And that service is accessed at the path '/deflate_service.html'
+    When I call HTTParty#get with '/deflate_service.html'
+    Then the return value should match '<h1>Some HTML</h1>'
+
+  Scenario: Supports gzip encoding
+    Given a remote gzip service
+    And the response from the service has a body of '<h1>Some HTML</h1>'
+    And that service is accessed at the path '/gzip_service.html'
+    When I call HTTParty#get with '/gzip_service.html'
+    Then the return value should match '<h1>Some HTML</h1>'
+
+  Scenario: Supports HEAD request with gzip encoding
+    Given a remote gzip service
+    And that service is accessed at the path '/gzip_head.gz.js'
+    When I call HTTParty#head with '/gzip_head.gz.js'
+    Then it should return a response with a 200 response code
+    Then it should return a response with a gzip content-encoding
+    Then it should return a response with a blank body

data/features/handles_multiple_formats.feature

@@ -0,0 +1,57 @@
+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 '/html_service.html'
+    And the response from the service has a Content-Type of 'text/html'
+    When I call HTTParty#get with '/html_service.html'
+    Then it should return a String
+    And the return value should match '<h1>Some HTML</h1>'
+
+  Scenario: A CSV service
+    Given a remote service that returns:
+      """
+      "Last Name","Name"
+      "jennings","waylon"
+      "cash","johnny"
+      """
+    And that service is accessed at the path '/service.csv'
+    And the response from the service has a Content-Type of 'application/csv'
+    When I call HTTParty#get with '/service.csv'
+    Then it should return an Array equaling:
+      | Last Name | Name   |
+      | jennings  | waylon |
+      | cash      | johnny |
+
+  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 |
+
+  Scenario: A Javascript remote file
+    Given a remote service that returns '$(function() { alert("hi"); });'
+    And that service is accessed at the path '/service.js'
+    And the response from the service has a Content-Type of 'application/javascript'
+    When I call HTTParty#get with '/service.js'
+    Then it should return a String
+    And the return value should match '$(function() { alert("hi"); });'

data/features/steps/env.rb

@@ -0,0 +1,22 @@
+require 'mongrel'
+require './lib/httparty'
+require 'spec/expectations'
+
+Before do
+  def new_port
+    server = TCPServer.new('0.0.0.0', nil)
+    port = server.addr[1]
+  ensure
+    server.close
+  end
+
+  port = ENV["HTTPARTY_PORT"] || new_port
+  @host_and_port = "0.0.0.0:#{port}"
+  @server = Mongrel::HttpServer.new("0.0.0.0", port)
+  @server.run
+  @request_options = {}
+end
+
+After do
+  @server.stop
+end

data/features/steps/httparty_response_steps.rb

@@ -0,0 +1,52 @@
+# Not needed anymore in ruby 2.0, but needed to resolve constants
+# in nested namespaces. This is taken from rails :)
+def constantize(camel_cased_word)
+  names = camel_cased_word.split('::')
+  names.shift if names.empty? || names.first.empty?
+
+  constant = Object
+  names.each do |name|
+    constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+  end
+  constant
+end
+
+Then /it should return an? (\w+)$/ do |class_string|
+  @response_from_httparty.should be_an_instance_of(class_string.class)
+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 an Array equaling:/ do |array|
+  @response_from_httparty.should be_an_instance_of(Array)
+  @response_from_httparty.should eql array.raw
+end
+
+Then /it should return a response with a (\d+) response code/ do |code|
+  @response_from_httparty.code.should eql(code.to_i)
+end
+
+Then /it should return a response with a (.*) content\-encoding$/ do |content_type|
+  @response_from_httparty.headers['content-encoding'].should eql('gzip')
+end
+
+Then /it should return a response with a blank body$/ do
+  @response_from_httparty.body.should be(nil)
+end
+
+Then /it should raise (?:an|a) ([\w:]+) exception/ do |exception|
+  @exception_from_httparty.should_not be_nil
+  @exception_from_httparty.should be_a constantize(exception)
+end

data/features/steps/httparty_steps.rb

@@ -0,0 +1,35 @@
+When /^I set my HTTParty timeout option to (\d+)$/ do |timeout|
+  @request_options[:timeout] = timeout.to_i
+end
+
+When /I call HTTParty#get with '(.*)'$/ do |url|
+  begin
+    @response_from_httparty = HTTParty.get("http://#{@host_and_port}#{url}", @request_options)
+  rescue HTTParty::RedirectionTooDeep, Timeout::Error => e
+    @exception_from_httparty = e
+  end
+end
+
+When /^I call HTTParty#head with '(.*)'$/ do |url|
+  begin
+    @response_from_httparty = HTTParty.head("http://#{@host_and_port}#{url}", @request_options)
+  rescue HTTParty::RedirectionTooDeep, Timeout::Error => 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
+
+When /I call HTTParty#get with '(.*)' and a digest_auth hash:/ do |url, auth_table|
+  h = auth_table.hashes.first
+  @response_from_httparty = HTTParty.get(
+    "http://#{@host_and_port}#{url}",
+    :digest_auth => { :username => h["username"], :password => h["password"] }
+  )
+end

data/features/steps/mongrel_helper.rb

@@ -0,0 +1,94 @@
+require 'base64'
+class BasicMongrelHandler < Mongrel::HttpHandler
+  attr_accessor :content_type, :custom_headers, :response_body, :response_code, :preprocessor, :username, :password
+
+  def initialize
+    @content_type = "text/html"
+    @response_body = ""
+    @response_code = 200
+    @custom_headers = {}
+  end
+
+  def process(request, response)
+    instance_eval &preprocessor if preprocessor
+    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
+
+class DeflateHandler < BasicMongrelHandler
+  def process(request, response)
+    response.start do |head, body|
+      head['Content-Encoding'] = 'deflate'
+      body.write Zlib::Deflate.deflate(response_body)
+    end
+  end
+end
+
+class GzipHandler < BasicMongrelHandler
+  def process(request, response)
+    response.start do |head, body|
+      head['Content-Encoding'] = 'gzip'
+      body.write gzip(response_body)
+    end
+  end
+
+  protected
+
+  def gzip(string)
+    sio = StringIO.new('', 'r+')
+    gz = Zlib::GzipWriter.new sio
+    gz.write string
+    gz.finish
+    sio.rewind
+    sio.read
+  end
+end
+
+module BasicAuthentication
+  def self.extended(base)
+    base.custom_headers["WWW-Authenticate"] = 'Basic Realm="Super Secret Page"'
+  end
+
+  def process(request, response)
+    if authorized?(request)
+      super
+    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
+
+module DigestAuthentication
+  def self.extended(base)
+    base.custom_headers["WWW-Authenticate"] = 'Digest realm="testrealm@host.com",qop="auth,auth-int",nonce="nonce",opaque="opaque"'
+  end
+
+  def process(request, response)
+    if authorized?(request)
+      super
+    else
+      reply_with(response, 401, "Incorrect.  You have 20 seconds to comply.")
+    end
+  end
+
+  def authorized?(request)
+    request.params["HTTP_AUTHORIZATION"] =~ /Digest.*uri=/
+  end
+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,74 @@
+Given /a remote service that returns '(.*)'/ do |response_body|
+  @handler = BasicMongrelHandler.new
+  Given "the response from the service has a body of '#{response_body}'"
+end
+
+Given /^a remote service that returns:$/ do |response_body|
+  @handler = BasicMongrelHandler.new
+  @handler.response_body = response_body
+end
+
+Given /a remote service that returns a (\d+) status code/ do |code|
+  @handler = BasicMongrelHandler.new
+  @handler.response_code = code
+end
+
+Given /that service is accessed at the path '(.*)'/ do |path|
+  @server.register(path, @handler)
+end
+
+Given /^that service takes (\d+) seconds to generate a response$/ do |time|
+  @server_response_time = time.to_i
+  @handler.preprocessor = Proc.new { sleep time.to_i }
+end
+
+Given /^a remote deflate service$/ do
+  @handler = DeflateHandler.new
+end
+
+Given /^a remote gzip service$/ do
+  @handler = GzipHandler.new
+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
+  @handler.extend BasicAuthentication
+end
+
+Given /that service is protected by Digest Authentication/ do
+  @handler.extend DigestAuthentication
+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
+
+Then /I wait for the server to recover/ do
+  timeout = @request_options[:timeout] || 0
+  sleep @server_response_time - timeout
+end