httparty 0.13.7 → 0.20.0

data/features/command_line.feature

@@ -1,95 +0,0 @@
-@command_line
-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
-
-  Scenario: Show help information
-    When I run `httparty --help`
-    Then the output should contain "-f, --format [FORMAT]"
-
-  Scenario: Show current version
-    When I run `httparty --version`
-    Then the output should contain "Version:"
-    And the output should not contain "You need to provide a URL"
-
-  Scenario: Make a get request
-    Given a remote deflate service on port '4001'
-    And the response from the service has a body of 'GET request'
-    And that service is accessed at the path '/fun'
-    When I run `httparty http://0.0.0.0:4001/fun`
-    Then the output should contain "GET request"
-
-  Scenario: Make a post request
-    Given a remote deflate service on port '4002'
-    And the response from the service has a body of 'POST request'
-    And that service is accessed at the path '/fun'
-    When I run `httparty http://0.0.0.0:4002/fun --action post --data "a=1&b=2"`
-    Then the output should contain "POST request"
-
-  Scenario: Make a put request
-    Given a remote deflate service on port '4003'
-    And the response from the service has a body of 'PUT request'
-    And that service is accessed at the path '/fun'
-    When I run `httparty http://0.0.0.0:4003/fun --action put --data "a=1&b=2"`
-    Then the output should contain "PUT request"
-
-  Scenario: Make a delete request
-    Given a remote deflate service on port '4004'
-    And the response from the service has a body of 'DELETE request'
-    And that service is accessed at the path '/fun'
-    When I run `httparty http://0.0.0.0:4004/fun --action delete`
-    Then the output should contain "DELETE request"
-
-  Scenario: Set a verbose mode
-    Given a remote deflate service on port '4005'
-    And the response from the service has a body of 'Some request'
-    And that service is accessed at the path '/fun'
-    When I run `httparty http://0.0.0.0:4005/fun --verbose`
-    Then the output should contain "content-length"
-
-  Scenario: Use service with basic authentication
-    Given a remote deflate service on port '4006'
-    And the response from the service has a body of 'Successfull authentication'
-    And that service is accessed at the path '/fun'
-    And that service is protected by Basic Authentication
-    And that service requires the username 'user' with the password 'pass'
-    When I run `httparty http://0.0.0.0:4006/fun --user 'user:pass'`
-    Then the output should contain "Successfull authentication"
-
-  Scenario: Get response in plain format
-    Given a remote deflate service on port '4007'
-    And the response from the service has a body of 'Some request'
-    And that service is accessed at the path '/fun'
-    When I run `httparty http://0.0.0.0:4007/fun --format plain`
-    Then the output should contain "Some request"
-
-  Scenario: Get response in json format
-    Given a remote deflate service on port '4008'
-    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 run `httparty http://0.0.0.0:4008/service.json --format json`
-    Then the output should contain '"jennings": "waylon"'
-
-  Scenario: Get response in xml format
-    Given a remote deflate service on port '4009'
-    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 run `httparty http://0.0.0.0:4009/service.xml --format xml`
-    Then the output should contain "<singer>"
-
-  Scenario: Get response in csv format
-    Given a remote deflate service on port '4010'
-    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 run `httparty http://0.0.0.0:4010/service.csv --format csv`
-    Then the output should contain '["Last Name", "Name"]'

data/features/deals_with_http_error_codes.feature

@@ -1,26 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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'
-
-  Scenario: Passing proper credentials to a page requiring Digest Authentication using md5-sess algorithm
-    Given a remote service that returns 'Digest Authenticated Page Using MD5-sess'
-    And that service is accessed at the path '/digest_auth.html'
-    And that service is protected by MD5-sess 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 Using MD5-sess'

data/features/handles_compressed_responses.feature

@@ -1,27 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

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

data/features/steps/httparty_response_steps.rb

@@ -1,52 +0,0 @@
-# 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|
-  expect(@response_from_httparty).to be_a(class_string.class)
-end
-
-Then /the return value should match '(.*)'/ do |expected_text|
-  expect(@response_from_httparty.parsed_response).to eq(expected_text)
-end
-
-Then /it should return a Hash equaling:/ do |hash_table|
-  expect(@response_from_httparty).to be_a(Hash)
-  expect(@response_from_httparty.keys.length).to eq(hash_table.rows.length)
-  hash_table.hashes.each do |pair|
-    key, value = pair["key"], pair["value"]
-    expect(@response_from_httparty.keys).to include(key)
-    expect(@response_from_httparty[key]).to eq(value)
-  end
-end
-
-Then /it should return an Array equaling:/ do |array|
-  expect(@response_from_httparty).to be_a(Array)
-  expect(@response_from_httparty.parsed_response).to eq(array.raw)
-end
-
-Then /it should return a response with a (\d+) response code/ do |code|
-  expect(@response_from_httparty.code).to eq(code.to_i)
-end
-
-Then /it should return a response with a (.*) content\-encoding$/ do |content_type|
-  expect(@response_from_httparty.headers['content-encoding']).to eq('gzip')
-end
-
-Then /it should return a response with a blank body$/ do
-  expect(@response_from_httparty.body).to be_nil
-end
-
-Then /it should raise (?:an|a) ([\w:]+) exception/ do |exception|
-  expect(@exception_from_httparty).to_not be_nil
-  expect(@exception_from_httparty).to be_a constantize(exception)
-end

data/features/steps/httparty_steps.rb

@@ -1,43 +0,0 @@
-When /^I set my HTTParty timeout option to (\d+)$/ do |timeout|
-  @request_options[:timeout] = timeout.to_i
-end
-
-When /^I set my HTTParty open_timeout option to (\d+)$/ do |timeout|
-  @request_options[:open_timeout] = timeout.to_i
-end
-
-When /^I set my HTTParty read_timeout option to (\d+)$/ do |timeout|
-  @request_options[:read_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

@@ -1,127 +0,0 @@
-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
-
-module DigestAuthenticationUsingMD5Sess
-  NONCE = 'nonce'
-  REALM = 'testrealm@host.com'
-  QOP = 'auth,auth-int'
-  def self.extended(base)
-    base.custom_headers["WWW-Authenticate"] = %(Digest realm="#{REALM}",qop="#{QOP}",algorithm="MD5-sess",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 md5(str)
-    Digest::MD5.hexdigest(str)
-  end
-  
-  def authorized?(request)
-    auth = request.params["HTTP_AUTHORIZATION"]
-    params = {}
-    auth.to_s.gsub(/(\w+)="(.*?)"/) { params[$1] = $2 }.gsub(/(\w+)=([^,]*)/) { params[$1] = $2 }
-    a1a = [@username,REALM,@password].join(':')
-    a1 = [md5(a1a),NONCE,params['cnonce'] ].join(':')
-    a2 = [ request.params["REQUEST_METHOD"], request.params["REQUEST_URI"] ] .join(':')
-    expected_response = md5( [md5(a1), NONCE, params['nc'], params['cnonce'], QOP, md5(a2)].join(':') )
-    expected_response == params['response']
-  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

@@ -1,90 +0,0 @@
-Given /a remote service that returns '(.*)'/ do |response_body|
-  @handler = BasicMongrelHandler.new
-  step "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 { sleep time.to_i }
-end
-
-Given /^a remote deflate service$/ do
-  @handler = DeflateHandler.new
-end
-
-Given /^a remote deflate service on port '(\d+)'/ do |port|
-  run_server(port)
-  @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 is protected by MD5-sess Digest Authentication/ do
-  @handler.extend DigestAuthenticationUsingMD5Sess
-end
-
-Given /that service requires the username '(.*)' with the password '(.*)'/ do |username, password|
-  @handler.username = username
-  @handler.password = password
-end
-
-# customize aruba cucumber step
-Then /^the output should contain '(.*)'$/ do |expected|
-  assert_partial_output(expected, all_output)
-end
-
-Given /a restricted page at '(.*)'/ do |url|
-  steps "
-    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

data/features/supports_read_timeout_option.feature

@@ -1,13 +0,0 @@
-Feature: Supports the read timeout option
-  In order to handle inappropriately slow response times
-  As a developer
-  I want my request to raise an exception after my specified read_timeout as elapsed
-
-  Scenario: A long running response
-    Given a remote service that returns '<h1>Some HTML</h1>'
-    And that service is accessed at the path '/long_running_service.html'
-    And that service takes 2 seconds to generate a response
-    When I set my HTTParty read_timeout option to 1
-    And I call HTTParty#get with '/long_running_service.html'
-    Then it should raise a Timeout::Error exception
-    And I wait for the server to recover

data/features/supports_redirection.feature

@@ -1,22 +0,0 @@
-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 '/landing_service.html'
-    And the url '/redirector.html' redirects to '/landing_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/features/supports_timeout_option.feature

@@ -1,13 +0,0 @@
-Feature: Supports the timeout option
-  In order to handle inappropriately slow response times
-  As a developer
-  I want my request to raise an exception after my specified timeout as elapsed
-
-  Scenario: A long running response
-    Given a remote service that returns '<h1>Some HTML</h1>'
-    And that service is accessed at the path '/long_running_service.html'
-    And that service takes 2 seconds to generate a response
-    When I set my HTTParty timeout option to 1
-    And I call HTTParty#get with '/long_running_service.html'
-    Then it should raise a Timeout::Error exception
-    And I wait for the server to recover