aitch 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d0dfe4472432f59487033b0e4ee493309ca64ea1
-  data.tar.gz: 7ac2a7504a11fd303cae76c2f626c4ef3e1a8d4e
+  metadata.gz: 23b168b3e1919c4678e936b498d68f03d76d633e
+  data.tar.gz: a389c8c536ca656791eb7eae62f2f74b15a62983
 SHA512:
-  metadata.gz: 572b6bd663e91bbfbd40bb1fec56656f7c9ddb6ed36ad4b60ed8595bb87b991ce4aa2a27819521af915e539d0042e27dc07155a4f22d09d29b2ab71cda212078
-  data.tar.gz: 390ff3a7a9dbffd717bbc2b6076e1e46801ed050f03c977ad0a63f77701d8366d539e2025e00f6bc61726897b19954961be44f80f54636153bf75e38586eeae3
+  metadata.gz: 355b7f2f6bb8cabf5defde1bfe2bf8dbeb0ca7d545d3f70c6e92ccfa1b08193d295bb859774306e76641a9b6f2854b08b75bd483f78453f1bd6eefb9748b3b65
+  data.tar.gz: d3dfa452ba5bb4c8483315372b966d45765e7d480f7a52cced117c58e131c15fa4f8a6c9e133f56090b2fbfcc48f8b62cf93e61fee890b1a3a2498c1998d0b17

data/.rspec

@@ -1 +1 @@
---color --order random --format documentation
+--color --order random

data/.travis.yml

@@ -1,11 +1,16 @@
 language: ruby
 script: "bundle exec rspec"
+before_install: gem install bundler
+cache: bundler
+sudo: false
 
 rvm:
-  - 2.1.2
-  - 2.0.0
-  - 1.9.3
+  - "2.2"
+  - "2.1"
+  - "2.0"
+  - "1.9"
   - jruby-19mode
+  - jruby-head
 
 gemfile:
   - Gemfile
@@ -13,3 +18,8 @@ gemfile:
 notifications:
   email:
     - fnando.vieira@gmail.com
+
+addons:
+  code_climate:
+    repo_token:
+      secure: "j/AjAG1u7NtdldftKUXnTMKC7CPd2R/O55ejzZnJi5IlHKKKZgJla1Z0YHTsGr75JQS7Q00D0L3TOSY8fLhV6fXO3Gn+9ShKTFRV5+iUtzlV0AWKBw+uENKNJH4jn1FhCoV8Th0I6OKtq98PqZ/hLR2J+/Uv3oCBwyriyJqag2U="

data/Gemfile

@@ -1,4 +1,4 @@
 source "https://rubygems.org"
 gemspec
 
-gem "pry-meta", platforms: :ruby
+gem "pry-meta", platforms: [:ruby_20, :ruby_21, :ruby_22]

data/README.md

@@ -1,9 +1,9 @@
 # Aitch
 
 [![Build Status](https://travis-ci.org/fnando/aitch.png)](https://travis-ci.org/fnando/aitch)
-[![CodeClimate](https://codeclimate.com/github/fnando/aitch.png)](https://codeclimate.com/github/fnando/aitch/)
+[![Code Climate](https://codeclimate.com/github/fnando/aitch/badges/gpa.svg)](https://codeclimate.com/github/fnando/aitch)
+[![Test Coverage](https://codeclimate.com/github/fnando/aitch/badges/coverage.svg)](https://codeclimate.com/github/fnando/aitch)
 [![RubyGems](https://badge.fury.io/rb/aitch.png)](https://rubygems.org/gems/aitch)
-[![Coveralls](https://coveralls.io/repos/fnando/aitch/badge.png?branch=master)](https://coveralls.io/r/fnando/aitch)
 
 A simple HTTP client.
 
@@ -169,7 +169,7 @@ Setting basic auth credentials:
 ```ruby
 response = Aitch.get do
   url "http://restrict.example.org/"
-  options: {user: "john", password: "test"}
+  options user: "john", password: "test"
 end
 ```
 
@@ -206,6 +206,25 @@ end
 Request.get("http://example.org")
 ```
 
+### Validating responses
+
+When you know of kind of response you're expecting, you can validate the response with a list of accepted response statuses.
+
+```ruby
+Aitch.get do
+  url "http://example.org"
+  options expect: 200
+end
+```
+
+If this request receives anything other than `200`, it will raise a `Aitch::StatusCodeError` exception.
+
+```
+Expect(200 OK) <=> Actual(404 Not Found)
+```
+
+You can also provide a list of accepted statuses, like `expect: [200, 201]`.
+
 ## Contributing
 
 1. Fork it

data/aitch.gemspec

@@ -1,7 +1,4 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'aitch/version'
+require "./lib/aitch/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "aitch"
@@ -19,11 +16,11 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "nokogiri", ">= 1.6.0"
-  spec.add_dependency "activesupport"
 
+  spec.add_development_dependency "codeclimate-test-reporter"
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "test_notifier"
-  spec.add_development_dependency "fakeweb"
+  spec.add_development_dependency "webmock"
 end

data/lib/aitch.rb

@@ -4,7 +4,12 @@ require "json"
 require "zlib"
 
 require "nokogiri"
-require "active_support/core_ext/object/to_query"
+
+begin
+  require "active_support/core_ext/object/to_query"
+rescue LoadError
+  require "aitch/ext/to_query"
+end
 
 require "aitch/utils"
 require "aitch/uri"
@@ -18,6 +23,7 @@ require "aitch/redirect"
 require "aitch/response/errors"
 require "aitch/response"
 require "aitch/response/body"
+require "aitch/response/description"
 require "aitch/xml_parser"
 require "aitch/html_parser"
 require "aitch/version"

data/lib/aitch/errors.rb

@@ -3,6 +3,7 @@ module Aitch
   InvalidHTTPMethodError = Class.new(StandardError)
   RequestTimeoutError    = Class.new(StandardError)
   TooManyRedirectsError  = Class.new(StandardError)
+  StatusCodeError        = Class.new(StandardError)
 
   ResponseError                      = Class.new(StandardError)
   BadRequestError                    = Class.new(ResponseError)

data/lib/aitch/ext/to_query.rb

@@ -0,0 +1,84 @@
+require "cgi"
+
+class Object
+  # Alias of <tt>to_s</tt>.
+  def to_param
+    to_s
+  end
+
+  # Converts an object into a string suitable for use as a URL query string,
+  # using the given <tt>key</tt> as the param name.
+  def to_query(key)
+    "#{CGI.escape(key.to_param)}=#{CGI.escape(to_param.to_s)}"
+  end
+end
+
+class NilClass
+  # Returns +self+.
+  def to_param
+    self
+  end
+end
+
+class TrueClass
+  # Returns +self+.
+  def to_param
+    self
+  end
+end
+
+class FalseClass
+  # Returns +self+.
+  def to_param
+    self
+  end
+end
+
+class Array
+  # Calls <tt>to_param</tt> on all its elements and joins the result with
+  # slashes. This is used by <tt>url_for</tt> in Action Pack.
+  def to_param
+    collect { |e| e.to_param }.join '/'
+  end
+
+  # Converts an array into a string suitable for use as a URL query string,
+  # using the given +key+ as the param name.
+  #
+  #   ['Rails', 'coding'].to_query('hobbies') # => "hobbies%5B%5D=Rails&hobbies%5B%5D=coding"
+  def to_query(key)
+    prefix = "#{key}[]"
+
+    if empty?
+      nil.to_query(prefix)
+    else
+      collect { |value| value.to_query(prefix) }.join '&'
+    end
+  end
+end
+
+class Hash
+  # Returns a string representation of the receiver suitable for use as a URL
+  # query string:
+  #
+  #   {name: 'David', nationality: 'Danish'}.to_query
+  #   # => "name=David&nationality=Danish"
+  #
+  # An optional namespace can be passed to enclose key names:
+  #
+  #   {name: 'David', nationality: 'Danish'}.to_query('user')
+  #   # => "user%5Bname%5D=David&user%5Bnationality%5D=Danish"
+  #
+  # The string pairs "key=value" that conform the query string
+  # are sorted lexicographically in ascending order.
+  #
+  # This method is also aliased as +to_param+.
+  def to_query(namespace = nil)
+    collect do |key, value|
+      unless (value.is_a?(Hash) || value.is_a?(Array)) && value.empty?
+        value.to_query(namespace ? "#{namespace}[#{key}]" : key)
+      end
+    end.compact.sort! * '&'
+  end
+
+  alias_method :to_param, :to_query
+end

data/lib/aitch/request.rb

@@ -18,18 +18,8 @@ module Aitch
     def perform
       response = Response.new(options, client.request(request))
       response.url = url
-      redirect = Redirect.new(options)
-
-      while redirect.follow?(response)
-        redirected_from ||= [url]
-        redirected_from << Location.new(redirected_from, response.location).location
-        redirect.followed!
-        response = Aitch.get(redirected_from.last)
-      end
-
-      raise TooManyRedirectsError if redirect.enabled? && response.redirect?
-
-      response.redirected_from = redirected_from
+      response = follow_redirect(response)
+      validate_response! response
       response
     rescue timeout_exception
       raise RequestTimeoutError
@@ -94,7 +84,8 @@ module Aitch
     end
 
     def set_credentials(request)
-      request.basic_auth(options[:user], options[:password]) if options[:user]
+      return unless options[:user] || options[:password]
+      request.basic_auth(options[:user], options[:password])
     end
 
     def set_https(client)
@@ -122,5 +113,35 @@ module Aitch
     def timeout_exception
       defined?(Net::ReadTimeout) ? Net::ReadTimeout : Timeout::Error
     end
+
+    def follow_redirect(response)
+      redirect = Redirect.new(options)
+
+      while redirect.follow?(response)
+        redirected_from ||= [url]
+        redirected_from << Location.new(redirected_from, response.location).location
+        redirect.followed!
+        response = Aitch.get(redirected_from.last)
+      end
+
+      raise TooManyRedirectsError if redirect.enabled? && response.redirect?
+
+      response.redirected_from = redirected_from
+      response
+    end
+
+    def validate_response!(response)
+      return unless options[:expect]
+
+      expected = [options[:expect]].flatten
+      return if expected.include?(response.code)
+
+      descriptions = expected
+                      .map {|code| Response.description_for_code(code) }
+                      .join(', ')
+
+      raise StatusCodeError,
+        "Expected(#{descriptions}) <=> Actual(#{response.description})"
+    end
   end
 end

data/lib/aitch/response.rb

@@ -5,6 +5,10 @@ module Aitch
     def_delegators :@http_response, :content_type
     attr_accessor :redirected_from, :url
 
+    def self.description_for_code(code)
+      [code, DESCRIPTION[code]].compact.join(' ')
+    end
+
     def initialize(options, http_response)
       @options = options
       @http_response = http_response
@@ -87,8 +91,12 @@ module Aitch
       headers.key?(name.to_s)
     end
 
+    def description
+      @description ||= self.class.description_for_code(code)
+    end
+
     def inspect
-      "#<#{self.class} #{code} #{@http_response.msg} (#{content_type})>"
+      "#<#{self.class} #{description} (#{content_type})>"
     end
 
     alias_method :to_s, :inspect

data/lib/aitch/response/description.rb

@@ -0,0 +1,61 @@
+module Aitch
+  class Response
+    DESCRIPTION = {
+      100 => 'Continue',
+      101 => 'Switch Protocol',
+
+      200 => 'OK',
+      201 => 'Created',
+      202 => 'Accepted',
+      203 => 'Non Authoritative Information',
+      204 => 'No Content',
+      205 => 'Reset Content',
+      206 => 'Partial Content',
+      207 => 'Multi Status',
+      226 => 'IM Used',
+
+      300 => 'Multiple Choices',
+      301 => 'Moved Permanently',
+      302 => 'Found',
+      303 => 'See Other',
+      304 => 'Not Modified',
+      305 => 'Use Proxy',
+      307 => 'Temporary Redirect',
+
+      400 => 'Bad Request',
+      401 => 'Unauthorized',
+      402 => 'Payment Required',
+      403 => 'Forbidden',
+      404 => 'Not Found',
+      405 => 'Method Not Allowed',
+      406 => 'Not Acceptable',
+      407 => 'Proxy Authentication Required',
+      408 => 'Request Time Out',
+      409 => 'Conflict',
+      410 => 'Gone',
+      411 => 'Length Required',
+      412 => 'Precondition Failed',
+      413 => 'Request Entity Too Large',
+      414 => 'Request URIToo Long',
+      415 => 'Unsupported Media Type',
+      416 => 'Requested Range Not Satisfiable',
+      417 => 'Expectation Failed',
+      422 => 'Unprocessable Entity',
+      423 => 'Locked',
+      424 => 'Failed Dependency',
+      426 => 'Upgrade Required',
+      428 => 'Precondition Required',
+      429 => 'Too Many Requests',
+      431 => 'Request Header Fields Too Large',
+
+      500 => 'Internal Server Error',
+      501 => 'Not Implemented',
+      502 => 'Bad Gateway',
+      503 => 'Service Unavailable',
+      504 => 'Gateway Time Out',
+      505 => 'Version Not Supported',
+      507 => 'Insufficient Storage',
+      511 => 'Network Authentication Required',
+    }
+  end
+end

data/lib/aitch/version.rb

@@ -1,3 +1,3 @@
 module Aitch
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 end

data/spec/aitch/aitch_spec.rb

@@ -56,7 +56,7 @@ describe Aitch do
       response = double(error?: false)
       allow_any_instance_of(Aitch::Request).to receive(:perform).and_return(response)
 
-      expect(Aitch.get!("URL")).to eql(response)
+      expect(Aitch.get!("URL")).to eq(response)
     end
 
     it "raises when has errors" do

data/spec/aitch/configuration_spec.rb

@@ -2,24 +2,24 @@ require "spec_helper"
 
 describe Aitch::Configuration do
   it "sets default timeout" do
-    expect(Aitch::Configuration.new.timeout).to eql(10)
+    expect(Aitch::Configuration.new.timeout).to eq(10)
   end
 
   it "sets default user agent" do
     user_agent = "Aitch/#{Aitch::VERSION} (http://rubygems.org/gems/aitch)"
-    expect(Aitch::Configuration.new.user_agent).to eql(user_agent)
+    expect(Aitch::Configuration.new.user_agent).to eq(user_agent)
   end
 
   it "sets default maximum redirections" do
-    expect(Aitch::Configuration.new.redirect_limit).to eql(5)
+    expect(Aitch::Configuration.new.redirect_limit).to eq(5)
   end
 
   it "sets default headers" do
-    expect(Aitch::Configuration.new.default_headers).to eql({})
+    expect(Aitch::Configuration.new.default_headers).to eq({})
   end
 
   it "sets default XML parser" do
-    expect(Aitch::Configuration.new.xml_parser).to eql(Aitch::XMLParser)
+    expect(Aitch::Configuration.new.xml_parser).to eq(Aitch::XMLParser)
   end
 
   it "configures aitch" do
@@ -27,7 +27,7 @@ describe Aitch::Configuration do
       config.timeout = 15
     end
 
-    expect(Aitch.configuration.timeout).to eql(15)
+    expect(Aitch.configuration.timeout).to eq(15)
   end
 end
 

data/spec/aitch/dsl_spec.rb

@@ -5,32 +5,32 @@ describe Aitch::DSL do
 
   it "sets url" do
     dsl.url "URL"
-    expect(dsl.url).to eql("URL")
+    expect(dsl.url).to eq("URL")
   end
 
   it "sets options" do
     dsl.options "OPTIONS"
-    expect(dsl.options).to eql("OPTIONS")
+    expect(dsl.options).to eq("OPTIONS")
   end
 
   it "sets headers" do
     dsl.headers "HEADERS"
-    expect(dsl.headers).to eql("HEADERS")
+    expect(dsl.headers).to eq("HEADERS")
   end
 
   it "sets data" do
     dsl.data "DATA"
-    expect(dsl.data).to eql("DATA")
+    expect(dsl.data).to eq("DATA")
   end
 
   it "sets data through params" do
     dsl.params "PARAMS"
-    expect(dsl.data).to eql("PARAMS")
+    expect(dsl.data).to eq("PARAMS")
   end
 
   it "sets data through body" do
     dsl.body "BODY"
-    expect(dsl.data).to eql("BODY")
+    expect(dsl.data).to eq("BODY")
   end
 
   it "returns hash" do

data/spec/aitch/namespace_spec.rb

@@ -5,7 +5,7 @@ describe Aitch::Namespace do
     ns = Aitch::Namespace.new
     ns.config.user_agent = "MyLib/1.0.0"
 
-    expect(ns.config.user_agent).to eql("MyLib/1.0.0")
+    expect(ns.config.user_agent).to eq("MyLib/1.0.0")
     expect(Aitch.config.user_agent).to match(%r[^Aitch])
   end
 end

data/spec/aitch/request_spec.rb

@@ -38,30 +38,38 @@ describe Aitch::Request do
     }.to raise_error(Aitch::RequestTimeoutError)
   end
 
+  it "raises exception for invalid http method" do
+    request = build_request(request_method: "invalid", url: "http://example.org")
+
+    expect {
+      request.perform
+    }.to raise_error(Aitch::InvalidHTTPMethodError)
+  end
+
   it "sets user agent" do
     requester = build_request
     request = requester.request
-    expect(request["User-Agent"]).to eql(requester.options[:user_agent])
+    expect(request["User-Agent"]).to eq(requester.options[:user_agent])
   end
 
   it "requests gzip encoding" do
     request = build_request.request
-    expect(request["Accept-Encoding"]).to eql("gzip,deflate")
+    expect(request["Accept-Encoding"]).to eq("gzip,deflate")
   end
 
   it "sets path" do
     request = build_request(url: "http://example.org/some/path").request
-    expect(request.path).to eql("/some/path")
+    expect(request.path).to eq("/some/path")
   end
 
   it "sets request body from hash" do
     request = build_request(request_method: "post", data: {a: 1}).request
-    expect(request.body).to eql("a=1")
+    expect(request.body).to eq("a=1")
   end
 
   it "sets request body from string" do
     request = build_request(request_method: "post", data: "some body").request
-    expect(request.body).to eql("some body")
+    expect(request.body).to eq("some body")
   end
 
   it "sets json body from object" do
@@ -72,7 +80,7 @@ describe Aitch::Request do
       options: {json_parser: JSON}
     ).request
 
-    expect(request.body).to eql({a: 1}.to_json)
+    expect(request.body).to eq({a: 1}.to_json)
   end
 
   it "sets json body from object (default headers)" do
@@ -82,27 +90,27 @@ describe Aitch::Request do
       options: {json_parser: JSON, default_headers: {'Content-Type' => 'application/json'}}
     ).request
 
-    expect(request.body).to eql({a: 1}.to_json)
+    expect(request.body).to eq({a: 1}.to_json)
   end
 
   it "sets request body from to_h protocol" do
     data = double(to_h: {a: 1})
     request = build_request(request_method: "post", data: data).request
-    expect(request.body).to eql("a=1")
+    expect(request.body).to eq("a=1")
   end
 
   it "sets request body from to_s protocol" do
     data = double(to_s: "some body")
     request = build_request(request_method: "post", data: data).request
 
-    expect(request.body).to eql("some body")
+    expect(request.body).to eq("some body")
   end
 
   it "sets query string from hash data" do
-    FakeWeb.register_uri :get, "http://example.org/?a=1&b=2", body: "hello"
+    register_uri :get, "http://example.org/?a=1&b=2", body: "hello"
     requester = build_request(data: {a: 1, b: 2})
 
-    expect(requester.perform.body).to eql("hello")
+    expect(requester.perform.body).to eq("hello")
   end
 
   it "sets default headers" do
@@ -110,24 +118,24 @@ describe Aitch::Request do
     requester.options[:default_headers] = {"HEADER" => "VALUE"}
     request = requester.request
 
-    expect(request["HEADER"]).to eql("VALUE")
+    expect(request["HEADER"]).to eq("VALUE")
   end
 
   it "sets custom headers" do
     request = build_request(headers: {"HEADER" => "VALUE"}).request
-    expect(request["HEADER"]).to eql("VALUE")
+    expect(request["HEADER"]).to eq("VALUE")
   end
 
   it "executes headers with callable protocol" do
     request = build_request(headers: {"HEADER" => -> { "VALUE" }}).request
-    expect(request["HEADER"]).to eql("VALUE")
+    expect(request["HEADER"]).to eq("VALUE")
   end
 
   it "sets basic auth credentials" do
     request = build_request(options: {user: "USER", password: "PASS"}).request
     credentials = Base64.decode64(request["Authorization"].gsub(/Basic /, ""))
 
-    expect(credentials).to eql("USER:PASS")
+    expect(credentials).to eq("USER:PASS")
   end
 
   describe "#client" do
@@ -140,12 +148,12 @@ describe Aitch::Request do
       end
 
       it "sets verification mode" do
-        expect(client.verify_mode).to eql(OpenSSL::SSL::VERIFY_PEER)
+        expect(client.verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER)
       end
 
       it "sets timeout" do
         request.options[:timeout] = 20
-        expect(client.read_timeout).to eql(20)
+        expect(client.read_timeout).to eq(20)
       end
     end
   end
@@ -169,7 +177,7 @@ describe Aitch::Request do
     ].each do |method|
       it "instantiates #{method.upcase} method" do
         request = build_request(request_method: method).request
-        expect(request.class.name).to eql("Net::HTTP::#{method.capitalize}")
+        expect(request.class.name).to eq("Net::HTTP::#{method.capitalize}")
       end
     end
   end
@@ -180,23 +188,23 @@ describe Aitch::Request do
     it "follows redirect" do
       Aitch.configuration.redirect_limit = 5
 
-      FakeWeb.register_uri(:get, "http://example.org/", location: "http://example.com/", status: 301)
-      FakeWeb.register_uri(:get, "http://example.com/", location: "http://www.example.com/", status: 301)
-      FakeWeb.register_uri(:get, "http://www.example.com/", body: "Hello")
+      register_uri(:get, "http://example.org/", location: "http://example.com/", status: 301)
+      register_uri(:get, "http://example.com/", location: "http://www.example.com/", status: 301)
+      register_uri(:get, "http://www.example.com/", body: "Hello")
 
       response = Aitch.get("http://example.org/")
 
       expect(response).not_to be_redirect
-      expect(response.body).to eql("Hello")
-      expect(response.redirected_from).to eql(["http://example.org/", "http://example.com/"])
-      expect(response.url).to eql("http://www.example.com/")
+      expect(response.body).to eq("Hello")
+      expect(response.redirected_from).to eq(["http://example.org/", "http://example.com/"])
+      expect(response.url).to eq("http://www.example.com/")
     end
 
     it "raises when doing too many redirects" do
       Aitch.configuration.redirect_limit = 1
 
-      FakeWeb.register_uri(:get, "http://example.org/", location: "http://example.com/", status: 301)
-      FakeWeb.register_uri(:get, "http://example.com/", location: "https://example.com/", status: 301)
+      register_uri(:get, "http://example.org/", location: "http://example.com/", status: 301)
+      register_uri(:get, "http://example.com/", location: "https://example.com/", status: 301)
 
       expect {
         Aitch.get("http://example.org/")
@@ -206,16 +214,16 @@ describe Aitch::Request do
 
   describe "GET requests" do
     it "sets data as query string" do
-      FakeWeb.register_uri(:get, %r[.+], body: "")
+      register_uri(:get, /.+/)
       Aitch.get("http://example.org/", a: 1, b: 2)
 
-      expect(FakeWeb.last_request.path).to eql("/?a=1&b=2")
+      expect(last_request.uri.request_uri).to eq("/?a=1&b=2")
     end
   end
 
   describe "using the DSL" do
     it "performs request" do
-      FakeWeb.register_uri(:post, %r[.+], body: "")
+      register_uri(:post, /.+/)
 
       response = Aitch.post do
         url "http://example.org/some/path"
@@ -224,13 +232,30 @@ describe Aitch::Request do
         options user: "user", password: "pass"
       end
 
-      expect(FakeWeb.last_request.path).to eql("/some/path")
-      expect(FakeWeb.last_request.method).to eql("POST")
-      expect(FakeWeb.last_request.body).to eql("a=1&b=2")
-      expect(FakeWeb.last_request["Rendering"]).to eql("0.1")
+      expect(last_request.uri.request_uri).to eq("/some/path")
+      expect(last_request.method).to eq(:post)
+      expect(last_request.body).to eq("a=1&b=2")
+      expect(last_request.headers["Rendering"]).to eq("0.1")
+      expect(last_request.uri.user).to eq("user")
+      expect(last_request.uri.password).to eq("pass")
+    end
+  end
 
-      auth = Base64.encode64("user:pass").chomp
-      expect(FakeWeb.last_request["Authorization"]).to eql("Basic #{auth}")
+  describe "status code validation" do
+    it "raises exception when status code isn't valid" do
+      register_uri(:get, "http://example.org/", status: 404)
+
+      expect {
+        Aitch.get("http://example.org/", {}, {}, expect: [200])
+      }.to raise_error(Aitch::StatusCodeError, "Expected(200 OK) <=> Actual(404 Not Found)")
+    end
+
+    it "accepts valid status code" do
+      register_uri(:get, "http://example.org/", status: 200)
+
+      expect {
+        Aitch.get("http://example.org/", {}, {}, expect: [200])
+      }.not_to raise_error
     end
   end
 end

data/spec/aitch/response_spec.rb

@@ -2,15 +2,15 @@ require "spec_helper"
 
 describe Aitch::Response do
   it "has body" do
-    FakeWeb.register_uri(:get, "http://example.org/", body: "Hello")
+    register_uri(:get, "http://example.org/", body: "Hello")
     response = Aitch.get("http://example.org/")
-    expect(response.body).to eql("Hello")
+    expect(response.body).to eq("Hello")
   end
 
   it "sets current url" do
-    FakeWeb.register_uri(:get, "http://example.org/", body: "Hello")
+    register_uri(:get, "http://example.org/", body: "Hello")
     response = Aitch.get("http://example.org/")
-    expect(response.url).to eql("http://example.org/")
+    expect(response.url).to eq("http://example.org/")
   end
 
   it "parses gzip response" do
@@ -19,74 +19,111 @@ describe Aitch::Response do
     gzipped.write("Hello")
     gzipped.finish
 
-    FakeWeb.register_uri(:get, "http://example.org/", body: stdio.string, content_encoding: "gzip")
+    register_uri(:get, "http://example.org/", body: stdio.string, content_encoding: "gzip")
     response = Aitch.get("http://example.org/")
 
-    expect(response.body).to eql("Hello")
+    expect(response.body).to eq("Hello")
   end
 
   it "deflates response" do
     stdio = StringIO.new
     deflated = Zlib::Deflate.deflate("Hello")
 
-    FakeWeb.register_uri(:get, "http://example.org/", body: deflated, content_encoding: "deflate")
+    register_uri(:get, "http://example.org/", body: deflated, content_encoding: "deflate")
     response = Aitch.get("http://example.org/")
 
-    expect(response.body).to eql("Hello")
+    expect(response.body).to eq("Hello")
   end
 
   it "returns status code" do
-    FakeWeb.register_uri(:get, "http://example.org/", body: "")
+    register_uri(:get, "http://example.org/", body: "")
     response = Aitch.get("http://example.org/")
-    expect(response.code).to eql(200)
+    expect(response.code).to eq(200)
   end
 
   it "returns content type" do
-    FakeWeb.register_uri(:get, "http://example.org/", content_type: "text/html")
+    register_uri(:get, "http://example.org/", content_type: "text/html")
     response = Aitch.get("http://example.org/")
-    expect(response.content_type).to eql("text/html")
+    expect(response.content_type).to eq("text/html")
   end
 
   it "detects as successful response" do
-    FakeWeb.register_uri(:get, "http://example.org/", content_type: "text/html")
+    register_uri(:get, "http://example.org/", content_type: "text/html")
     response = Aitch.get("http://example.org/")
     expect(response).to be_success
   end
 
   it "returns headers" do
-    FakeWeb.register_uri(:get, "http://example.org/", content_type: "text/html")
+    register_uri(:get, "http://example.org/", content_type: "text/html")
     headers = Aitch.get("http://example.org/").headers
 
     expect(headers).to be_a(Hash)
-    expect(headers["content-type"]).to eql("text/html")
+    expect(headers["content-type"]).to eq("text/html")
   end
 
   it "normalizes custom headers" do
-    FakeWeb.register_uri(:get, "http://example.org/", "X-Runtime" => "0.003")
+    register_uri(:get, "http://example.org/", headers: {"X-Runtime" => "0.003"})
     headers = Aitch.get("http://example.org/").headers
 
-    expect(headers["runtime"]).to eql("0.003")
+    expect(headers["runtime"]).to eq("0.003")
   end
 
   it "maps missing methods to headers" do
-    FakeWeb.register_uri(:get, "http://example.org/", "X-Runtime" => "0.003")
+    register_uri(:get, "http://example.org/", headers: {"X-Runtime" => "0.003"})
     response = Aitch.get("http://example.org/")
 
-    expect(response.runtime).to eql("0.003")
+    expect(response.runtime).to eq("0.003")
     expect(response).to respond_to(:runtime)
   end
 
+  it "raises when have no method" do
+    register_uri(:get, "http://example.org/")
+    response = Aitch.get("http://example.org/")
+
+    expect {
+      response.runtime
+    }.to raise_error(NoMethodError)
+  end
+
+  it "returns description for 200 OK" do
+    register_uri(:get, "http://example.org/", status: 200)
+    response = Aitch.get("http://example.org/")
+
+    expect(response.description).to eq("200 OK")
+  end
+
+  it "returns description for 101 Switch Protocol" do
+    register_uri(:get, "http://example.org/", status: 101)
+    response = Aitch.get("http://example.org/")
+
+    expect(response.description).to eq("101 Switch Protocol")
+  end
+
+  it "returns description for 444 No Response (nginx)" do
+    register_uri(:get, "http://example.org/", status: 444)
+    response = Aitch.get("http://example.org/")
+
+    expect(response.description).to eq("444")
+  end
+
+  it "overrides inspect" do
+    register_uri(:get, "http://example.org/", status: 101, content_type: "text/html")
+    response = Aitch.get("http://example.org/")
+
+    expect(response.inspect).to eq("#<Aitch::Response 101 Switch Protocol (text/html)>")
+  end
+
   context "status 3xx" do
     before { Aitch.configuration.follow_redirect = false }
 
     it "has body" do
-      FakeWeb.register_uri(:get, "http://example.org/", body: "Hello", status: 301)
+      register_uri(:get, "http://example.org/", body: "Hello", status: 301)
       response = Aitch.get("http://example.org/")
-      expect(response.body).to eql("Hello")
+      expect(response.body).to eq("Hello")
     end
 
     it "detects as successful response" do
-      FakeWeb.register_uri(:get, "http://example.org/", status: 301)
+      register_uri(:get, "http://example.org/", status: 301)
       response = Aitch.get("http://example.org/")
 
       expect(response).to be_success
@@ -94,91 +131,99 @@ describe Aitch::Response do
     end
 
     it "detects as redirect" do
-      FakeWeb.register_uri(:get, "http://example.org/", status: 301)
+      register_uri(:get, "http://example.org/", status: 301)
       response = Aitch.get("http://example.org/")
       expect(response).to be_redirect
     end
 
     it "returns location" do
-      FakeWeb.register_uri(:get, "http://example.org/", status: 301, location: "https://example.com/")
+      register_uri(:get, "http://example.org/", status: 301, location: "https://example.com/")
       response = Aitch.get("http://example.org/")
-      expect(response.location).to eql("https://example.com/")
+      expect(response.location).to eq("https://example.com/")
     end
 
     it "follows absolute paths" do
       Aitch.configuration.follow_redirect = true
       Aitch.configuration.redirect_limit = 5
 
-      FakeWeb.register_uri(:get, "http://example.org/", status: 301, location: "/hello")
-      FakeWeb.register_uri(:get, "http://example.org/hello", status: 301, location: "/hi")
-      FakeWeb.register_uri(:get, "http://example.org/hi", status: 200, body: "Hi")
+      register_uri(:get, "http://example.org/", status: 301, location: "/hello")
+      register_uri(:get, "http://example.org/hello", status: 301, location: "/hi")
+      register_uri(:get, "http://example.org/hi", status: 200, body: "Hi")
 
       response = Aitch.get("http://example.org/")
 
-      expect(response.redirected_from).to eql(["http://example.org/", "http://example.org/hello"])
-      expect(response.url).to eql("http://example.org/hi")
-      expect(response.body).to eql("Hi")
+      expect(response.redirected_from).to eq(["http://example.org/", "http://example.org/hello"])
+      expect(response.url).to eq("http://example.org/hi")
+      expect(response.body).to eq("Hi")
     end
   end
 
   context "status 4xx" do
     it "detects as error" do
-      FakeWeb.register_uri(:get, "http://example.org/", status: 404)
+      register_uri(:get, "http://example.org/", status: 404)
       response = Aitch.get("http://example.org/")
 
       expect(response).to be_error
     end
 
     it "sets error" do
-      FakeWeb.register_uri(:get, "http://example.org/", status: 404)
+      register_uri(:get, "http://example.org/", status: 404)
       response = Aitch.get("http://example.org/")
 
-      expect(response.error).to eql(Aitch::NotFoundError)
+      expect(response.error).to eq(Aitch::NotFoundError)
     end
   end
 
   context "status 5xx" do
     it "detects as error" do
-      FakeWeb.register_uri(:get, "http://example.org/", status: 500)
+      register_uri(:get, "http://example.org/", status: 500)
       response = Aitch.get("http://example.org/")
 
       expect(response).to be_error
     end
 
     it "sets error" do
-      FakeWeb.register_uri(:get, "http://example.org/", status: 500)
+      register_uri(:get, "http://example.org/", status: 500)
       response = Aitch.get("http://example.org/")
 
-      expect(response.error).to eql(Aitch::InternalServerErrorError)
+      expect(response.error).to eq(Aitch::InternalServerErrorError)
+    end
+  end
+
+  context "raw body" do
+    it "returns as it is" do
+      register_uri(:get, "http://example.org/", body: "HELLO", content_type: "text/plain")
+      response = Aitch.get("http://example.org/")
+      expect(response.body).to eq("HELLO")
     end
   end
 
   context "JSON" do
     it "detects as json" do
-      FakeWeb.register_uri(:get, "http://example.org/", body: "[]", content_type: "application/json")
+      register_uri(:get, "http://example.org/", body: "[]", content_type: "application/json")
       response = Aitch.get("http://example.org/")
 
       expect(response).to be_json
     end
 
     it "returns json" do
-      FakeWeb.register_uri(:get, "http://example.org/", body: "[1,2,3]", content_type: "application/json")
+      register_uri(:get, "http://example.org/", body: "[1,2,3]", content_type: "application/json")
       response = Aitch.get("http://example.org/")
 
-      expect(response.json).to eql([1,2,3])
+      expect(response.json).to eq([1,2,3])
     end
   end
 
   context "HTML" do
     it "detects as html" do
-      FakeWeb.register_uri(:get, "http://example.org/", body: "", content_type: "text/html")
+      register_uri(:get, "http://example.org/", body: "", content_type: "text/html")
       response = Aitch.get("http://example.org/")
 
       expect(response).to be_html
     end
 
     it "returns html" do
-      FakeWeb.register_uri(:get, "http://example.org/", body: "Hello", content_type: "text/html")
+      register_uri(:get, "http://example.org/", body: "Hello", content_type: "text/html")
       response = Aitch.get("http://example.org/")
 
       expect(response.html).to be_a(Nokogiri::HTML::Document)
@@ -187,14 +232,14 @@ describe Aitch::Response do
 
   context "XML" do
     it "detects as xml" do
-      FakeWeb.register_uri(:get, "http://example.org/", body: "[]", content_type: "application/xml")
+      register_uri(:get, "http://example.org/", body: "[]", content_type: "application/xml")
       response = Aitch.get("http://example.org/")
 
       expect(response).to be_xml
     end
 
     it "returns xml" do
-      FakeWeb.register_uri(:get, "http://example.org/", body: "<foo/>", content_type: "application/xml")
+      register_uri(:get, "http://example.org/", body: "<foo/>", content_type: "application/xml")
       response = Aitch.get("http://example.org/")
 
       expect(response.xml).to be_a(Nokogiri::XML::Document)

data/spec/aitch/uri_spec.rb

@@ -2,35 +2,35 @@ require "spec_helper"
 
 describe Aitch::URI do
   it "returns default path" do
-    expect(Aitch::URI.new("http://example.org").path).to eql("/")
+    expect(Aitch::URI.new("http://example.org").path).to eq("/")
   end
 
   it "returns defined path" do
-    expect(Aitch::URI.new("http://example.org/some/path").path).to eql("/some/path")
+    expect(Aitch::URI.new("http://example.org/some/path").path).to eq("/some/path")
   end
 
   it "returns fragment" do
-    expect(Aitch::URI.new("http://example.org/#top").fragment).to eql("#top")
+    expect(Aitch::URI.new("http://example.org/#top").fragment).to eq("#top")
   end
 
   it "returns query string" do
-    expect(Aitch::URI.new("http://example.org/?a=1&b=2").query).to eql("?a=1&b=2")
+    expect(Aitch::URI.new("http://example.org/?a=1&b=2").query).to eq("?a=1&b=2")
   end
 
   it "converts data into query string" do
-    expect(Aitch::URI.new("http://example.org", a: 1, b: 2).query).to eql("?a=1&b=2")
+    expect(Aitch::URI.new("http://example.org", a: 1, b: 2).query).to eq("?a=1&b=2")
   end
 
   it "merges data into query string" do
-    expect(Aitch::URI.new("http://example.org/?a=1&b=2", c: 3).query).to eql("?a=1&b=2&c=3")
+    expect(Aitch::URI.new("http://example.org/?a=1&b=2", c: 3).query).to eq("?a=1&b=2&c=3")
   end
 
   it "ignores data when request has body" do
-    expect(Aitch::URI.new("http://example.org/", {c: 3}, true).query).to eql(nil)
+    expect(Aitch::URI.new("http://example.org/", {c: 3}, true).query).to eq(nil)
   end
 
   it "returns request uri" do
     uri = Aitch::URI.new("http://example.org/some/path?a=1&b=2#hello", c: 3)
-    expect(uri.request_uri).to eql("/some/path?a=1&b=2&c=3#hello")
+    expect(uri.request_uri).to eq("/some/path?a=1&b=2&c=3#hello")
   end
 end

data/spec/aitch/utils_spec.rb

@@ -3,17 +3,17 @@ require "spec_helper"
 describe Aitch::Utils do
   describe ".underscore" do
     it "replaces capital letters by underscores" do
-      expect(Aitch::Utils.underscore("SomeConstantName")).to eql("some_constant_name")
+      expect(Aitch::Utils.underscore("SomeConstantName")).to eq("some_constant_name")
     end
 
     it "considers URI acronym" do
-      expect(Aitch::Utils.underscore("RequestURITooLong")).to eql("request_uri_too_long")
+      expect(Aitch::Utils.underscore("RequestURITooLong")).to eq("request_uri_too_long")
     end
   end
 
   describe ".symbolize_keys" do
     it "converts keys to symbols" do
-      expect(Aitch::Utils.symbolize_keys("a" => 1)).to eql(a: 1)
+      expect(Aitch::Utils.symbolize_keys("a" => 1)).to eq(a: 1)
     end
   end
 end

data/spec/aitch/xml_parser_spec.rb

@@ -10,7 +10,7 @@ describe Aitch::XMLParser do
   it "converts ISO-8859-1 to UTF-8" do
     xml = Aitch::XMLParser.load(File.read("./spec/fixtures/iso8859-1.xml"))
 
-    expect(xml.encoding).to eql("utf-8")
+    expect(xml.encoding).to eq("utf-8")
     expect(xml.to_xml).to include(%[<?xml version="1.0" encoding="utf-8"?>])
   end
 end

data/spec/spec_helper.rb

@@ -1,13 +1,17 @@
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
 require "bundler/setup"
 Bundler.require
 
 require "aitch"
 require "base64"
 require "test_notifier/runner/rspec"
-require "fakeweb"
+require "webmock/rspec"
 require "nokogiri"
 
-FakeWeb.allow_net_connect = false
+require_relative "support/webmock"
+require_relative "support/request_uri"
 
 RSpec.configure do |config|
   config.filter_run_excluding :ruby => -> version {

data/spec/support/request_uri.rb

@@ -0,0 +1,24 @@
+RSpec.configure do |config|
+  config.include Module.new {
+    def add_hash_entry(source, target, from, to)
+      target[to] = source[from] if source[from]
+    end
+
+    def register_uri(http_method, url, options = {})
+      body = options.fetch(:body, '')
+      status = options.fetch(:status, 200)
+      headers = options.fetch(:headers, {})
+
+      add_hash_entry(options, headers, :location, 'Location')
+      add_hash_entry(options, headers, :content_type, 'Content-Type')
+      add_hash_entry(options, headers, :content_encoding, 'Content-Encoding')
+
+      stub_request(http_method, url)
+        .to_return(status: status, body: body, headers: headers)
+    end
+
+    def last_request
+      WebMock.requests.last
+    end
+  }
+end

data/spec/support/webmock.rb

@@ -0,0 +1,15 @@
+WebMock.disable_net_connect!(allow: /codeclimate\.com/)
+
+def WebMock.requests
+  @requests ||= []
+end
+
+WebMock.after_request do |request, response|
+  WebMock.requests << request
+end
+
+RSpec.configure do |config|
+  config.before(:each) do
+    WebMock.requests.clear
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aitch
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Nando Vieira
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-20 00:00:00.000000000 Z
+date: 2015-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -25,13 +25,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 1.6.0
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: codeclimate-test-reporter
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -95,7 +95,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: fakeweb
+  name: webmock
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -115,12 +115,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".coveralls.yml"
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
 - Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -129,6 +127,7 @@ files:
 - lib/aitch/configuration.rb
 - lib/aitch/dsl.rb
 - lib/aitch/errors.rb
+- lib/aitch/ext/to_query.rb
 - lib/aitch/html_parser.rb
 - lib/aitch/location.rb
 - lib/aitch/namespace.rb
@@ -136,6 +135,7 @@ files:
 - lib/aitch/request.rb
 - lib/aitch/response.rb
 - lib/aitch/response/body.rb
+- lib/aitch/response/description.rb
 - lib/aitch/response/errors.rb
 - lib/aitch/uri.rb
 - lib/aitch/utils.rb
@@ -153,6 +153,8 @@ files:
 - spec/aitch/xml_parser_spec.rb
 - spec/fixtures/iso8859-1.xml
 - spec/spec_helper.rb
+- spec/support/request_uri.rb
+- spec/support/webmock.rb
 homepage: http://rubygems.org/gems/aitch
 licenses:
 - MIT
@@ -173,7 +175,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: A simple HTTP client
@@ -190,3 +192,5 @@ test_files:
 - spec/aitch/xml_parser_spec.rb
 - spec/fixtures/iso8859-1.xml
 - spec/spec_helper.rb
+- spec/support/request_uri.rb
+- spec/support/webmock.rb

data/.coveralls.yml

@@ -1 +0,0 @@
-service_name: travis-ci