aitch 0.5.0 → 1.0.0

data/lib/aitch/response/errors.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Aitch
   class Response
     ERRORS = {

data/lib/aitch/response_parser.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module Aitch
+  module ResponseParser
+    PARSERS = []
+
+    def self.prepend(name, parser)
+      unregister(name)
+      PARSERS.unshift parser
+    end
+
+    def self.append(name, parser)
+      unregister(name)
+      PARSERS << parser
+    end
+
+    def self.unregister(name)
+      PARSERS.delete_if {|parser| parser.type == name }
+    end
+
+    def self.find(content_type)
+      PARSERS.find {|parser| parser.match?(content_type) }
+    end
+
+    append :json, JSONParser
+    append :xml, XMLParser
+    append :html, HTMLParser
+    append :default, DefaultParser
+  end
+end

data/lib/aitch/response_parser/default_parser.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module Aitch
+  module ResponseParser
+    module DefaultParser
+      def self.type
+        :default
+      end
+
+      def self.match?(content_type)
+        true
+      end
+
+      def self.load(source)
+        source.to_s
+      end
+    end
+  end
+end

data/lib/aitch/response_parser/html_parser.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module Aitch
+  module ResponseParser
+    module HTMLParser
+      def self.type
+        :html
+      end
+
+      def self.match?(content_type)
+        content_type =~ /html/
+      end
+
+      def self.load(source)
+        Nokogiri::HTML(source.to_s)
+      end
+    end
+  end
+end

data/lib/aitch/response_parser/json_parser.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module Aitch
+  module ResponseParser
+    module JSONParser
+      def self.type
+        :json
+      end
+
+      def self.match?(content_type)
+        content_type =~ /json/
+      end
+
+      def self.load(source)
+        ::JSON.load(source.to_s)
+      end
+    end
+  end
+end

data/lib/aitch/response_parser/xml_parser.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module Aitch
+  module ResponseParser
+    module XMLParser
+      def self.type
+        :xml
+      end
+
+      def self.match?(content_type)
+        content_type =~ /xml/
+      end
+
+      def self.load(source)
+        Nokogiri::XML(source.to_s, nil, "utf-8")
+      end
+    end
+  end
+end

data/lib/aitch/uri.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Aitch
   class URI
     extend Forwardable

data/lib/aitch/utils.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Aitch
   module Utils extend self
     def underscore(string)

data/lib/aitch/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Aitch
-  VERSION = "0.5.0"
+  VERSION = "1.0.0"
 end

data/test/aitch/aitch_test.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+require "test_helper"
+
+class AitchTest < Minitest::Test
+  test "defines public API" do
+    assert Aitch.respond_to?(:get)
+    assert Aitch.respond_to?(:get!)
+    assert Aitch.respond_to?(:post)
+    assert Aitch.respond_to?(:post!)
+    assert Aitch.respond_to?(:put)
+    assert Aitch.respond_to?(:put!)
+    assert Aitch.respond_to?(:patch)
+    assert Aitch.respond_to?(:patch!)
+    assert Aitch.respond_to?(:delete)
+    assert Aitch.respond_to?(:delete!)
+    assert Aitch.respond_to?(:head)
+    assert Aitch.respond_to?(:head!)
+    assert Aitch.respond_to?(:options)
+    assert Aitch.respond_to?(:options!)
+    assert Aitch.respond_to?(:trace)
+    assert Aitch.respond_to?(:trace!)
+    assert Aitch.respond_to?(:execute)
+    assert Aitch.respond_to?(:execute!)
+    assert Aitch.respond_to?(:config)
+    assert Aitch.respond_to?(:configuration)
+  end
+end

data/test/aitch/configuration_test.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+require "test_helper"
+
+class ConfigurationTest < Minitest::Test
+  test "sets default timeout" do
+    assert_equal 10, Aitch::Configuration.new.timeout
+  end
+
+  test "sets default user agent" do
+    user_agent = "Aitch/#{Aitch::VERSION} (http://rubygems.org/gems/aitch)"
+    assert_equal user_agent, Aitch::Configuration.new.user_agent
+  end
+
+  test "sets default maximum redirections" do
+    assert_equal 5, Aitch::Configuration.new.redirect_limit
+  end
+
+  test "sets default headers" do
+    assert_equal Hash.new, Aitch::Configuration.new.default_headers
+  end
+
+  test "configures aitch" do
+    Aitch.configure do |config|
+      config.timeout = 15
+    end
+
+    assert_equal 15, Aitch.configuration.timeout
+  end
+end

data/test/aitch/dsl_test.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+require "test_helper"
+
+class DslTest < Minitest::Test
+  let(:dsl) { Aitch::DSL.new }
+
+  test "sets url" do
+    dsl.url "URL"
+    assert_equal "URL", dsl.url
+  end
+
+  test "sets options" do
+    dsl.options "OPTIONS"
+    assert_equal "OPTIONS", dsl.options
+  end
+
+  test "sets headers" do
+    dsl.headers "HEADERS"
+    assert_equal "HEADERS", dsl.headers
+  end
+
+  test "sets data" do
+    dsl.data "DATA"
+    assert_equal "DATA", dsl.data
+  end
+
+  test "sets data through params" do
+    dsl.params "PARAMS"
+    assert_equal "PARAMS", dsl.data
+  end
+
+  test "sets data through body" do
+    dsl.body "BODY"
+    assert_equal "BODY", dsl.data
+  end
+
+  test "returns hash" do
+    dsl.options "OPTIONS"
+    dsl.headers "HEADERS"
+    dsl.url "URL"
+    dsl.data "DATA"
+
+    assert_equal "DATA", dsl.to_h[:data]
+    assert_equal "HEADERS", dsl.to_h[:headers]
+    assert_equal "URL", dsl.to_h[:url]
+    assert_equal "OPTIONS", dsl.to_h[:options]
+  end
+end

data/test/aitch/execute_test.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+require "test_helper"
+
+class ExecuteTest < Minitest::Test
+  let(:request) { stub_everything }
+
+  test "delegates to Request" do
+    options = {}
+
+    expected = {
+      request_method: "get",
+      url: "URL",
+      data: "DATA",
+      headers: "HEADERS",
+      options: options.merge(Aitch.config.to_h)
+    }
+
+    Aitch::Request.expects(:new).with(expected).returns(request)
+
+    Aitch.get("URL", "DATA", "HEADERS", options)
+  end
+
+  test "performs request" do
+    Aitch::Request.stubs(:new).returns(request)
+    request.expects(:perform)
+
+    Aitch.get("URL")
+  end
+end
+
+class ExecuteBangTest < Minitest::Test
+  test "returns response when successful" do
+    response = stub(error?: false)
+    Aitch::Request.any_instance.stubs(:perform).returns(response)
+
+    assert_equal response, Aitch.get!("URL")
+  end
+
+  test "raises when has errors" do
+    response = stub(error?: true, error: "ERROR")
+    Aitch::Request.any_instance.stubs(:perform).returns(response)
+
+    assert_raises("ERROR") { Aitch.get!("URL") }
+  end
+end

data/test/aitch/namespace_test.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+require "test_helper"
+
+class NamespaceTest < Minitest::Test
+  test "isolates namespace configuration" do
+    ns = Aitch::Namespace.new
+    ns.config.user_agent = "MyLib/1.0.0"
+
+    assert_equal "MyLib/1.0.0", ns.config.user_agent
+    assert_match %r[^Aitch], Aitch.config.user_agent
+  end
+end

data/test/aitch/request/client_https_test.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+require "test_helper"
+
+class ClientHttpsTest < Minitest::Test
+  let(:request) { build_request(url: "https://example.org") }
+  let(:client) { request.client }
+
+  test "sets https" do
+    assert client.use_ssl?
+  end
+
+  test "sets verification mode" do
+    assert_equal OpenSSL::SSL::VERIFY_PEER, client.verify_mode
+  end
+
+  test "sets timeout" do
+    request.options[:timeout] = 20
+    assert_equal 20, client.read_timeout
+  end
+end

data/test/aitch/request/follow_redirect_test.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+require "test_helper"
+
+class FollowRedirectTest < Minitest::Test
+  setup { Aitch.configuration.follow_redirect = true }
+
+  test "follows redirect" do
+    Aitch.configuration.redirect_limit = 5
+
+    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/")
+
+    refute response.redirect?
+    assert_equal "Hello", response.body
+    assert_equal ["http://example.org/", "http://example.com/"], response.redirected_from
+    assert_equal "http://www.example.com/", response.url
+  end
+
+  test "raises when doing too many redirects" do
+    Aitch.configuration.redirect_limit = 1
+
+    register_uri(:get, "http://example.org/", location: "http://example.com/", status: 301)
+    register_uri(:get, "http://example.com/", location: "https://example.com/", status: 301)
+
+    assert_raises(Aitch::TooManyRedirectsError) {
+      Aitch.get("http://example.org/")
+    }
+  end
+
+  test "returns only redirection urls" do
+    Aitch.configuration.redirect_limit = 5
+
+    register_uri(:get, "http://example.org/", location: "http://example.com/", status: 301)
+    register_uri(:get, "http://example.com/", status: 200)
+
+    response = Aitch.get("http://example.org/")
+
+    assert_equal "http://example.com/", response.url
+    assert_equal ["http://example.org/"], response.redirected_from
+  end
+
+  test "honors 307 status" do
+    Aitch.configuration.follow_redirect = true
+    Aitch.configuration.redirect_limit = 5
+
+    register_uri(:post, "http://example.org/", status: 307, location: "/hi")
+    register_uri(:post, "http://example.org/hi", status: 307, location: "/hello")
+    register_uri(:post, "http://example.org/hello", status: 200)
+
+    response = Aitch.post("http://example.org/", {a: 1}, {Range: "1..100"})
+
+    assert_equal "http://example.org/hello", response.url
+    assert_equal 200, response.code
+    assert_equal ["http://example.org/", "http://example.org/hi"], response.redirected_from
+
+    request = WebMock.requests.last
+
+    assert_equal "a=1", request.body
+    assert_equal "1..100", request.headers["Range"]
+  end
+end

data/test/aitch/request/request_class_test.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+require "test_helper"
+
+class RequestClassTest < Minitest::Test
+  test "raises with invalid method" do
+    error = assert_raises(Aitch::InvalidHTTPMethodError) {
+      build_request(request_method: "invalid").request
+    }
+
+    assert_equal %[unexpected HTTP verb: "invalid"], error.message
+  end
+
+  %w[
+    get
+    post
+    put
+    patch
+    delete
+    head
+    options
+    trace
+  ].each do |method|
+    test "instantiates #{method.upcase} method" do
+      request = build_request(request_method: method).request
+      assert_equal "Net::HTTP::#{method.capitalize}", request.class.name
+    end
+  end
+end

data/test/aitch/request/status_code_validation_test.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+require "test_helper"
+
+class StatusCodeValidationTest < Minitest::Test
+  test "raises exception when status code isn't valid" do
+    register_uri(:get, "http://example.org/", status: 404)
+
+    error = assert_raises(Aitch::StatusCodeError) {
+      Aitch.get("http://example.org/", {}, {}, expect: [200])
+    }
+
+    assert_equal "Expected(200 OK) <=> Actual(404 Not Found)", error.message
+  end
+
+  test "accepts valid status code" do
+    register_uri(:get, "http://example.org/", status: 200)
+    Aitch.get("http://example.org/", {}, {}, expect: [200])
+  end
+end

data/test/aitch/request_test.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+require "test_helper"
+
+class RequestTest < Minitest::Test
+  test "sets content type" do
+    request = build_request(content_type: 'application/json')
+    assert_equal 'application/json', request.content_type
+  end
+
+  test "raises with invalid uri" do
+    assert_raises(Aitch::InvalidURIError) { build_request(url: "\\").uri }
+  end
+
+  test "raises on timeout" do
+    request = build_request(request_method: "post", url: "http://example.org")
+    request.client.stubs(:request).raises(Net::ReadTimeout)
+
+    assert_raises(Aitch::RequestTimeoutError) { request.perform }
+  end
+
+  test "raises exception for invalid http method" do
+    request = build_request(request_method: "invalid", url: "http://example.org")
+
+    assert_raises(Aitch::InvalidHTTPMethodError) { request.perform }
+  end
+
+  test "sets user agent" do
+    requester = build_request
+    request = requester.request
+    assert_equal requester.options[:user_agent], request["User-Agent"]
+  end
+
+  test "requests gzip encoding" do
+    request = build_request.request
+    assert_equal "gzip,deflate", request["Accept-Encoding"]
+  end
+
+  test "sets path" do
+    request = build_request(url: "http://example.org/some/path").request
+    assert_equal "/some/path", request.path
+  end
+
+  test "sets request body from hash" do
+    request = build_request(request_method: "post", data: {a: 1}).request
+    assert_equal "a=1", request.body
+  end
+
+  test "sets request body from string" do
+    request = build_request(request_method: "post", data: "some body").request
+    assert_equal "some body", request.body
+  end
+
+  test "sets json body from object" do
+    request = build_request(
+      request_method: "post",
+      data: {a: 1},
+      content_type: "application/json",
+      options: {json_parser: JSON}
+    ).request
+
+    expected = {a: 1}.to_json
+    assert_equal expected, request.body
+  end
+
+  test "sets json body from object (default headers)" do
+    request = build_request(
+      request_method: "post",
+      data: {a: 1},
+      options: {json_parser: JSON, default_headers: {'Content-Type' => 'application/json'}}
+    ).request
+
+    expected = {a: 1}.to_json
+    assert_equal expected, request.body
+  end
+
+  test "sets request body from to_h protocol" do
+    data = stub(to_h: {a: 1})
+    request = build_request(request_method: "post", data: data).request
+    assert_equal "a=1", request.body
+  end
+
+  test "sets request body from to_s protocol" do
+    data = stub(to_s: "some body")
+    request = build_request(request_method: "post", data: data).request
+
+    assert_equal "some body", request.body
+  end
+
+  test "sets query string from hash data" do
+    register_uri :get, "http://example.org/?a=1&b=2", body: "hello"
+    requester = build_request(data: {a: 1, b: 2})
+
+    assert_equal "hello", requester.perform.body
+  end
+
+  test "sets default headers" do
+    requester = build_request
+    requester.options[:default_headers] = {"HEADER" => "VALUE"}
+    request = requester.request
+
+    assert_equal "VALUE", request["HEADER"]
+  end
+
+  test "sets custom headers" do
+    request = build_request(headers: {"HEADER" => "VALUE"}).request
+    assert_equal "VALUE", request["HEADER"]
+  end
+
+  test "executes headers with callable protocol" do
+    request = build_request(headers: {"HEADER" => -> { "VALUE" }}).request
+    assert_equal "VALUE", request["HEADER"]
+  end
+
+  test "sets basic auth credentials" do
+    request = build_request(options: {user: "USER", password: "PASS"}).request
+    credentials = Base64.decode64(request["Authorization"].gsub(/Basic /, ""))
+
+    assert_equal "USER:PASS", credentials
+  end
+
+  test "performs request when using dsl" do
+    register_uri(:post, /.+/)
+
+    response = Aitch.post do
+      url "http://example.org/some/path"
+      params a: 1, b: 2
+      headers Rendering: "0.1"
+      options user: "user", password: "pass"
+    end
+
+    assert_equal "/some/path", last_request.uri.request_uri
+    assert_equal :post, last_request.method
+    assert_equal "a=1&b=2", last_request.body
+    assert_equal "0.1", last_request.headers["Rendering"]
+    assert_equal "user", last_request.uri.user
+    assert_equal "pass", last_request.uri.password
+  end
+end