aitch 0.5.0 → 1.0.0

data/test/aitch/response/custom_response_parser_test.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+require "test_helper"
+require "csv"
+
+class CustomResponseParserTest < Minitest::Test
+  setup do
+    parser = Class.new do
+      def self.type
+        :csv
+      end
+
+      def self.match?(content_type)
+        content_type =~ /csv/
+      end
+
+      def self.load(source)
+        CSV.parse(source)
+      end
+    end
+
+    Aitch::ResponseParser.prepend(:csv, parser)
+  end
+
+  test "returns csv" do
+    register_uri(:get, "http://example.org/file.csv", body: "1,2,3", content_type: "text/csv")
+    response = Aitch.get("http://example.org/file.csv")
+
+    assert_instance_of Array, response.data
+    assert_equal [%w[1 2 3]], response.data
+  end
+end

data/test/aitch/response/errors_test.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+require "test_helper"
+
+class ErrorsTest < Minitest::Test
+  Aitch::Response::ERRORS.each do |code, exception|
+    name = Aitch::Utils.underscore(exception.name.split("::").last).gsub("_error", "")
+
+    test "detects response as #{name}" do
+      config = {}
+      http_response = stub(code: code)
+      response = Aitch::Response.new(config, http_response)
+
+      assert response.public_send("#{name}?")
+    end
+  end
+end

data/test/aitch/response/html_response_test.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+require "test_helper"
+
+class HtmlResponseTest < Minitest::Test
+  test "detects as html" do
+    register_uri(:get, "http://example.org/", body: "", content_type: "text/html")
+    response = Aitch.get("http://example.org/")
+
+    assert response.html?
+  end
+
+  test "returns html" do
+    register_uri(:get, "http://example.org/", body: "Hello", content_type: "text/html")
+    response = Aitch.get("http://example.org/")
+
+    assert_instance_of Nokogiri::HTML::Document, response.data
+  end
+end

data/test/aitch/response/json_response_test.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+require "test_helper"
+
+class JsonResponseTest < Minitest::Test
+  test "detects as json" do
+    register_uri(:get, "http://example.org/", body: "[]", content_type: "application/json")
+    response = Aitch.get("http://example.org/")
+
+    assert response.json?
+  end
+
+  test "returns json" do
+    register_uri(:get, "http://example.org/", body: "[1,2,3]", content_type: "application/json")
+    response = Aitch.get("http://example.org/")
+
+    assert_equal [1,2,3], response.data
+  end
+end

data/test/aitch/response/raw_response_test.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+require "test_helper"
+
+class RawResponseTest < Minitest::Test
+  test "returns body as it is (raw)" do
+    register_uri(:get, "http://example.org/", body: "HELLO", content_type: "text/plain")
+    response = Aitch.get("http://example.org/")
+
+    assert_equal "HELLO", response.body
+  end
+end

data/test/aitch/response/status_3xx_test.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+require "test_helper"
+
+class Status3xxTest < Minitest::Test
+  setup { Aitch.configuration.follow_redirect = false }
+
+  test "sets default redirected from" do
+    assert_equal [], Aitch::Response.new({}, stub("response")).redirected_from
+  end
+
+  test "uses provided redirected from" do
+    assert_equal ["URL"], Aitch::Response.new({redirected_from: ["URL"]}, stub("response")).redirected_from
+  end
+
+  test "has body" do
+    register_uri(:get, "http://example.org/", body: "Hello", status: 301)
+    response = Aitch.get("http://example.org/")
+    assert_equal "Hello", response.body
+  end
+
+  test "detects as successful response" do
+    register_uri(:get, "http://example.org/", status: 301)
+    response = Aitch.get("http://example.org/")
+
+    assert response.success?
+    assert response.ok?
+  end
+
+  test "detects as redirect" do
+    register_uri(:get, "http://example.org/", status: 301)
+    response = Aitch.get("http://example.org/")
+
+    assert response.redirect?
+  end
+
+  test "returns location" do
+    register_uri(:get, "http://example.org/", status: 301, location: "https://example.com/")
+    response = Aitch.get("http://example.org/")
+    assert_equal "https://example.com/", response.location
+  end
+
+  test "follows absolute paths" do
+    Aitch.configuration.follow_redirect = true
+    Aitch.configuration.redirect_limit = 5
+
+    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/")
+
+    assert_equal ["http://example.org/", "http://example.org/hello"], response.redirected_from
+    assert_equal "http://example.org/hi", response.url
+    assert_equal "Hi", response.body
+  end
+end

data/test/aitch/response/status_4xx_test.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+require "test_helper"
+
+class Status4xxTest < Minitest::Test
+  test "detects as error" do
+    register_uri(:get, "http://example.org/", status: 404)
+    response = Aitch.get("http://example.org/")
+
+    assert response.error?
+  end
+
+  test "sets error" do
+    register_uri(:get, "http://example.org/", status: 404)
+    response = Aitch.get("http://example.org/")
+
+    assert_equal Aitch::NotFoundError, response.error
+  end
+end

data/test/aitch/response/status_5xx_test.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+require "test_helper"
+
+class Status5xxTest < Minitest::Test
+  test "detects as error" do
+    register_uri(:get, "http://example.org/", status: 500)
+    response = Aitch.get("http://example.org/")
+
+    assert response.error?
+  end
+
+  test "sets error" do
+    register_uri(:get, "http://example.org/", status: 500)
+    response = Aitch.get("http://example.org/")
+
+    assert_equal Aitch::InternalServerErrorError, response.error
+  end
+end

data/test/aitch/response/xml_response_test.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+require "test_helper"
+
+class XmlResponseTest < Minitest::Test
+  test "detects as xml" do
+    register_uri(:get, "http://example.org/", body: "[]", content_type: "application/xml")
+    response = Aitch.get("http://example.org/")
+
+    assert response.xml?
+  end
+
+  test "returns xml" do
+    register_uri(:get, "http://example.org/", body: "<foo/>", content_type: "application/xml")
+    response = Aitch.get("http://example.org/")
+
+    assert_instance_of Nokogiri::XML::Document, response.data
+  end
+end

data/test/aitch/response_parser/html_parser_test.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+require "test_helper"
+
+class HtmlParserTest < Minitest::Test
+  test "instantiates Nokogiri" do
+    Nokogiri.expects(:HTML).with("HTML")
+    Aitch::ResponseParser::HTMLParser.load("HTML")
+  end
+end

data/test/aitch/response_parser/json_parser_test.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+require "test_helper"
+
+class JsonParserTest < Minitest::Test
+  test "loads JSON" do
+    JSON.expects(:load).with(%[{"a":1}])
+    Aitch::ResponseParser::JSONParser.load(%[{"a":1}])
+  end
+end

data/test/aitch/response_parser/xml_parser_test.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+# encoding: utf-8
+require "test_helper"
+
+class XmlParserTest < Minitest::Test
+  test "instantiates Nokogiri" do
+    Nokogiri.expects(:XML).with("XML", nil, "utf-8")
+    Aitch::ResponseParser::XMLParser.load("XML")
+  end
+
+  test "converts ISO-8859-1 to UTF-8" do
+    xml = Aitch::ResponseParser::XMLParser.load(File.read("./test/fixtures/iso8859-1.xml"))
+
+    assert_equal "utf-8", xml.encoding
+    assert_includes xml.to_xml, %[<?xml version="1.0" encoding="utf-8"?>]
+  end
+end

data/test/aitch/response_test.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+require "test_helper"
+
+class ResponseTest < Minitest::Test
+  test "has body" do
+    register_uri(:get, "http://example.org/", body: "Hello")
+    response = Aitch.get("http://example.org/")
+    assert_equal "Hello", response.body
+  end
+
+  test "sets current url" do
+    register_uri(:get, "http://example.org/", body: "Hello")
+    response = Aitch.get("http://example.org/")
+    assert_equal "http://example.org/", response.url
+  end
+
+  test "parses gzip response" do
+    stdio = StringIO.new
+    gzipped = Zlib::GzipWriter.new(stdio)
+    gzipped.write("Hello")
+    gzipped.finish
+
+    register_uri(:get, "http://example.org/", body: stdio.string, content_encoding: "gzip")
+    response = Aitch.get("http://example.org/")
+
+    assert_equal "Hello", response.body
+  end
+
+  test "deflates response" do
+    stdio = StringIO.new
+    deflated = Zlib::Deflate.deflate("Hello")
+
+    register_uri(:get, "http://example.org/", body: deflated, content_encoding: "deflate")
+    response = Aitch.get("http://example.org/")
+
+    assert_equal "Hello", response.body
+  end
+
+  test "returns status code" do
+    register_uri(:get, "http://example.org/", body: "")
+    response = Aitch.get("http://example.org/")
+    assert_equal 200, response.code
+  end
+
+  test "returns content type" do
+    register_uri(:get, "http://example.org/", content_type: "text/html")
+    response = Aitch.get("http://example.org/")
+    assert_equal "text/html", response.content_type
+  end
+
+  test "detects as successful response" do
+    register_uri(:get, "http://example.org/", content_type: "text/html")
+    response = Aitch.get("http://example.org/")
+    assert response.success?
+  end
+
+  test "returns headers" do
+    register_uri(:get, "http://example.org/", content_type: "text/html")
+    headers = Aitch.get("http://example.org/").headers
+
+    assert_instance_of Hash, headers
+    assert_equal "text/html", headers["content-type"]
+  end
+
+  test "normalizes custom headers" do
+    register_uri(:get, "http://example.org/", headers: {"X-Runtime" => "0.003"})
+    headers = Aitch.get("http://example.org/").headers
+
+    assert_equal "0.003", headers["runtime"]
+  end
+
+  test "maps missing methods to headers" do
+    register_uri(:get, "http://example.org/", headers: {"X-Runtime" => "0.003"})
+    response = Aitch.get("http://example.org/")
+
+    assert_equal "0.003", response.runtime
+    assert response.respond_to?(:runtime)
+  end
+
+  test "raises when have no method" do
+    register_uri(:get, "http://example.org/")
+    response = Aitch.get("http://example.org/")
+
+    assert_raises(NoMethodError) { response.runtime }
+  end
+
+  test "returns description for 200 OK" do
+    register_uri(:get, "http://example.org/", status: 200)
+    response = Aitch.get("http://example.org/")
+
+    assert_equal "200 OK", response.description
+  end
+
+  test "returns description for 101 Switch Protocol" do
+    register_uri(:get, "http://example.org/", status: 101)
+    response = Aitch.get("http://example.org/")
+
+    assert_equal "101 Switch Protocol", response.description
+  end
+
+  test "returns description for 444 No Response (nginx)" do
+    register_uri(:get, "http://example.org/", status: 444)
+    response = Aitch.get("http://example.org/")
+
+    assert_equal "444", response.description
+  end
+
+  test "overrides inspect" do
+    register_uri(:get, "http://example.org/", status: 101, content_type: "text/html")
+    response = Aitch.get("http://example.org/")
+
+    assert_equal "#<Aitch::Response 101 Switch Protocol (text/html)>", response.inspect
+  end
+end

data/test/aitch/uri_test.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+require "test_helper"
+
+class UriTest < Minitest::Test
+  test "returns default path" do
+    assert_equal "/", Aitch::URI.new("http://example.org").path
+  end
+
+  test "returns defined path" do
+    assert_equal "/some/path", Aitch::URI.new("http://example.org/some/path").path
+  end
+
+  test "returns fragment" do
+    assert_equal "#top", Aitch::URI.new("http://example.org/#top").fragment
+  end
+
+  test "returns query string" do
+    assert_equal "?a=1&b=2", Aitch::URI.new("http://example.org/?a=1&b=2").query
+  end
+
+  test "converts data into query string" do
+    assert_equal "?a=1&b=2", Aitch::URI.new("http://example.org", a: 1, b: 2).query
+  end
+
+  test "merges data into query string" do
+    assert_equal "?a=1&b=2&c=3", Aitch::URI.new("http://example.org/?a=1&b=2", c: 3).query
+  end
+
+  test "ignores data when request has body" do
+    assert_equal nil, Aitch::URI.new("http://example.org/", {c: 3}, true).query
+  end
+
+  test "returns request uri" do
+    uri = Aitch::URI.new("http://example.org/some/path?a=1&b=2#hello", c: 3)
+    assert_equal "/some/path?a=1&b=2&c=3#hello", uri.request_uri
+  end
+end

data/test/aitch/utils/symbolize_keys_test.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+require "test_helper"
+
+class SymbolizeKeysTest < Minitest::Test
+  test "converts keys to symbols" do
+    expected = {a: 1}
+    assert_equal expected, Aitch::Utils.symbolize_keys("a" => 1)
+  end
+end

data/test/aitch/utils/underscore_test.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+require "test_helper"
+
+class UnderscoreTest < Minitest::Test
+  test "replaces capital letters by underscores" do
+    assert_equal "some_constant_name", Aitch::Utils.underscore("SomeConstantName")
+  end
+
+  test "considers URI acronym" do
+    assert_equal "request_uri_too_long", Aitch::Utils.underscore("RequestURITooLong")
+  end
+end

data/{spec/support/request_uri.rb → test/support/helpers.rb}

@@ -1,5 +1,6 @@
-RSpec.configure do |config|
-  config.include Module.new {
+# frozen_string_literal: true
+module Minitest
+  class Test
     def add_hash_entry(source, target, from, to)
       target[to] = source[from] if source[from]
     end
@@ -20,5 +21,13 @@ RSpec.configure do |config|
     def last_request
       WebMock.requests.last
     end
-  }
+
+    def build_request(options = {})
+      Aitch::Request.new({
+        request_method: "get",
+        url: "http://example.org",
+        options: {}
+      }.merge(options))
+    end
+  end
 end