hurley 0.1

data/lib/hurley/url.rb

@@ -0,0 +1,197 @@
+require "base64"
+require "erb"
+require "forwardable"
+require "set"
+require "uri"
+
+module Hurley
+  class Url
+    def self.escape_path(path)
+      ERB::Util.url_encode(path.to_s)
+    end
+
+    def self.escape_paths(*paths)
+      paths.map do |path|
+        escape_path(path)
+      end.join(SLASH)
+    end
+
+    def self.parse(raw_url)
+      case raw_url
+      when Url then raw_url
+      when nil, EMPTY then Empty.new
+      else new(@@parser.call(raw_url.to_s))
+      end
+    end
+
+    def initialize(parsed)
+      @parsed = parsed
+      if u = @parsed.user
+        @user = CGI.unescape(u)
+        @parsed.user = nil
+      else
+        @user = nil
+      end
+
+      if pwd = @parsed.password
+        @password = CGI.unescape(pwd)
+        @parsed.password = nil
+      else
+        @password = nil
+      end
+
+      @parsed.userinfo = nil
+    end
+
+    def self.join(absolute, relative)
+      parse(absolute).join(parse(relative))
+    end
+
+    extend Forwardable
+    def_delegators(:@parsed,
+      :scheme, :scheme=,
+      :host, :host=,
+      :port=,
+    )
+
+    attr_accessor :user
+    attr_accessor :password
+
+    def port
+      @parsed.port || INFERRED_PORTS[@parsed.scheme]
+    end
+
+    def path
+      @parsed.path
+    end
+
+    def path=(new_path)
+      @parsed.path = new_path
+    end
+
+    def query
+      @query ||= query_class.parse(@parsed.query)
+    end
+
+    def join(relative)
+      has_host = false
+
+      query.each do |key, value|
+        relative.query[key] = value unless relative.query.key?(key)
+      end
+
+      if !path.empty? && !relative.path.start_with?(SLASH)
+        rel_path = relative.path
+        relative.path = path
+        if !rel_path.empty?
+          joiner = path.end_with?(SLASH) ? nil : SLASH
+          relative.path += "#{joiner}#{rel_path}"
+        end
+      end
+
+      if !relative.path.empty? && !relative.path.start_with?(SLASH)
+        relative.path = "/#{relative.path}"
+      end
+
+      if relative.host
+        has_host = true
+      else
+        relative.host = host
+      end
+
+      if has_host && relative.host != host
+        relative.user = relative.password = nil
+      else
+        relative.user ||= user
+        relative.password ||= password
+      end
+
+      if relative.scheme
+        has_host = true
+      else
+        relative.scheme = scheme
+      end
+
+      inferred_port = INFERRED_PORTS[relative.scheme]
+      if !has_host && relative.port == inferred_port
+        relative.port = port == inferred_port ? nil : port
+      end
+
+      relative
+    end
+
+    def request_uri
+      req_path = path
+      req_path = SLASH if req_path.empty?
+
+      if (q = query.to_query_string).empty?
+        req_path
+      else
+        "#{req_path}?#{q}"
+      end
+    end
+
+    def to_s
+      @parsed.query = raw_query
+      @parsed.to_s
+    end
+
+    def raw_query
+      if (q = query.to_query_string).empty?
+        nil
+      else
+        q
+      end
+    end
+
+    def raw_query=(new_query)
+      @query = nil
+      @parsed.query = new_query
+    end
+
+    def basic_auth
+      return unless @user
+      userinfo = @password ? "#{@user}:#{@password}" : @user
+      "Basic #{Base64.encode64(userinfo).rstrip}"
+    end
+
+    def query_class
+      @query_class ||= Query.default
+    end
+
+    def query_class=(new_query)
+      @query = query ? new_query.new(@query) : nil
+      @query_class = new_query
+    end
+
+    def inspect
+      "#<%s %s>" % [
+        self.class.name,
+        to_s,
+      ]
+    end
+
+    private
+
+    @@parser = URI.method(:parse)
+
+    EMPTY = "".freeze
+    SLASH = "/".freeze
+
+    INFERRED_PORTS = {
+      "https" => 443,
+      "http" => 80,
+    }.freeze
+
+    class Empty < self
+      def initialize
+        @parsed = @@parser.call(EMPTY)
+        @query = Query.parse(EMPTY)
+      end
+
+      def relation_with(url)
+        :diff
+      end
+    end
+  end
+end

data/script/bootstrap

@@ -0,0 +1,2 @@
+#!/bin/sh
+bundle install --quiet "$@"

data/script/package

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+# Usage: script/package
+# Updates the gemspec and builds a new gem in the pkg directory.
+
+mkdir -p pkg
+gem build *.gemspec
+mv *.gem pkg

data/script/test

@@ -0,0 +1,168 @@
+#!/usr/bin/env bash
+# Usage: script/test [file] [adapter]... -- [test/unit options]
+# Runs the test suite against a local server spawned automatically in a
+# thread. After tests are done, the server is shut down.
+#
+# If filename arguments are given, only those files are run. If arguments given
+# are not filenames, they are taken as words that filter the list of files to run.
+#
+# Examples:
+#
+#   $ script/test
+#   $ script/test test/env_test.rb
+#   $ script/test excon typhoeus
+#
+#   # Run only tests matching /ssl/ for the net_http adapter, with SSL enabled.
+#   $ HURLEY_SSL=1 script/test net_http -- -n /ssl/
+#
+#   # Run against multiple rbenv versions
+#   $ RBENV_VERSIONS="1.9.3-p194 ree-1.8.7-2012.02" script/test
+set -e
+
+port=3999
+proxy_port=3998
+scheme=http
+
+if [ "$HURLEY_SSL" = "1" ] || [ "$HURLEY_SSL" = "yes" ]; then
+  scheme=https
+  if [ -z "$HURLEY_SSL_KEY" ] || [ -z "$HURLEY_SSL_FILE" ]; then
+    eval "$(rake hurley:generate_certs IN_SHELL=1)"
+  fi
+fi
+
+find_test_files() {
+  find "$1" -name '*_test.rb'
+}
+
+filter_matching() {
+  pattern="$1"
+  shift
+  for line in "$@"; do
+    [[ $line == *"$pattern"* ]] && echo "$line"
+  done
+}
+
+start_server() {
+  mkdir -p log
+  rake hurley:start_server HURLEY_PORT=$port >log/test.log 2>&1 &
+  echo $!
+}
+
+start_proxy() {
+  mkdir -p log
+  rake hurley:start_proxy HURLEY_PORT=$proxy_port "HURLEY_PROXY_AUTH=hurley@test.local:there is cake" >log/proxy.log 2>&1 &
+  echo $!
+}
+
+server_started() {
+  lsof -i :${1?} >/dev/null
+}
+
+timestamp() {
+  date +%s
+}
+
+wait_for_server() {
+  timeout=$(( `timestamp` + $1 ))
+  while true; do
+    if server_started "$2"; then
+      break
+    elif [ `timestamp` -gt "$timeout" ]; then
+      echo "timed out after $1 seconds" >&2
+      return 1
+    fi
+  done
+}
+
+filtered=
+IFS=$'\n' test_files=($(find_test_files "test"))
+declare -a explicit_files
+
+# Process filter arguments:
+# - test filenames as taken as-is
+# - other words are taken as pattern to match the list of known files against
+# - arguments after "--" are forwarded to the ruby process
+while [ $# -gt 0 ]; do
+  arg="$1"
+  shift
+  if [ "$arg" = "--" ]; then
+    break
+  elif [ -f "$arg" ]; then
+    filtered=true
+    explicit_files[${#explicit_files[@]}+1]="$arg"
+  else
+    filtered=true
+    IFS=$'\n' explicit_files=(
+      ${explicit_files[@]}
+      $(filter_matching "$arg" "${test_files[@]}" || true)
+    )
+  fi
+done
+
+# If there were filter args, replace test files list with the results
+if [ -n "$filtered" ]; then
+  if [ ${#explicit_files[@]} -eq 0 ]; then
+    echo "Error: no test files match" >&2
+    exit 1
+  else
+    test_files=(${explicit_files[@]})
+    echo running "${test_files[@]}"
+  fi
+fi
+
+# If there are live tests, spin up the HTTP server
+if [ -n "$(filter_matching "live" "${test_files[@]}")" ]; then
+  if server_started $port; then
+    echo "aborted: another instance of server running on $port" >&2
+    exit 1
+  fi
+  server_pid=$(start_server)
+  proxy_pid=$(start_proxy)
+  wait_for_server 30 $port || {
+    cat log/test.log
+    kill "$server_pid"
+    kill "$proxy_pid"
+    exit 1
+  }
+  wait_for_server 5 $proxy_port
+  cleanup() {
+    if [ $? -ne 0 ] && [ -n "$TRAVIS" ]; then
+      cat log/test.log
+    fi
+    kill "$server_pid"
+    kill "$proxy_pid"
+  }
+  trap cleanup INT EXIT
+  export HURLEY_LIVE="${scheme}://localhost:${port}"
+  export HURLEY_PROXY="http://hurley%40test.local:there%20is%20cake@localhost:${proxy_port}"
+fi
+
+warnings="${TMPDIR:-/tmp}/hurley-warnings.$$"
+
+run_test_files() {
+  # Save warnings on stderr to a separate file
+  RUBYOPT="$RUBYOPT -w" ruby -e 'while f=ARGV.shift and f!="--"; load f; end' "${test_files[@]}" -- "$@" \
+    2> >(tee >(grep 'warning:' >"$warnings") | grep -v 'warning:')
+}
+
+check_warnings() {
+  # Display Ruby warnings from this project's source files. Abort if any were found.
+  num="$(grep -F "$PWD" "$warnings" | grep -v "${PWD}/bundle" | sort | uniq -c | sort -rn | tee /dev/stderr | wc -l)"
+  rm -f "$warnings"
+  if [ "$num" -gt 0 ]; then
+    echo "FAILED: this test suite doesn't tolerate Ruby syntax warnings!" >&2
+    exit 1
+  fi
+}
+
+if [ -n "$RBENV_VERSIONS" ]; then
+  IFS=' ' versions=($RBENV_VERSIONS)
+  for version in "${versions[@]}"; do
+    echo "[${version}]"
+    RBENV_VERSION="$version" run_test_files "$@"
+  done
+else
+  run_test_files "$@"
+fi
+
+check_warnings

data/test/client_test.rb

@@ -0,0 +1,585 @@
+require File.expand_path("../helper", __FILE__)
+
+module Hurley
+  class ClientTest < TestCase
+    def test_integration_verbs
+      verbs = [:head, :get, :put, :post, :delete, :options]
+      client = Client.new "https://example.com"
+      client.connection = Test.new do |t|
+        verbs.each do |verb|
+          t.handle(verb, "/a") do |req|
+            [200, {}, verb.inspect]
+          end
+        end
+      end
+
+      errors = []
+
+      verbs.each do |verb|
+        res = client.send(verb, "/a")
+        if res.body != verb.inspect
+          errors << "#{verb} = #{res.status_code} / #{res.body}"
+        end
+      end
+
+      if errors.any?
+        fail "\n" + errors.join("\n")
+      end
+    end
+
+    def test_integration_before_callback
+      c = Client.new "https://example.com"
+      c.connection = Test.new do |test|
+        test.post "/a" do |req|
+          assert_equal "BOOYA", req.body
+          [200, {}, "meh"]
+        end
+      end
+
+      c.before_call do |req|
+        req.body = req.body.to_s.upcase
+      end
+
+      res = c.post "a" do |req|
+        req.body = "booya"
+      end
+
+      assert_equal 200, res.status_code
+      assert c.connection.all_run?
+    end
+
+    def test_integration_after_callback
+      c = Client.new "https://example.com"
+      c.connection = Test.new do |test|
+        test.get "/a" do |req|
+          [200, {}, "meh"]
+        end
+      end
+
+      c.after_call do |res|
+        res.body = res.body.to_s.upcase
+      end
+
+      res = c.get "a"
+
+      assert_equal 200, res.status_code
+      assert_equal "MEH", res.body
+      assert c.connection.all_run?
+    end
+
+    def test_integration_default_headers
+      headers = [:content_type, :content_length, :transfer_encoding]
+      c = Client.new "https://example.com"
+      c.connection = Test.new do |test|
+        [:get, :put, :post, :patch, :options, :delete].each do |verb|
+          test.send(verb, "/a") do |req|
+            body = if !req.body
+              :-
+            elsif req.body.respond_to?(:path)
+              req.body.path
+            else
+              req.body_io.read
+            end
+            [200, {}, headers.map { |h| req.header[h] || "NONE" }.join(",") + " #{body}"]
+          end
+        end
+      end
+
+      errors = []
+      tests = {}
+      file_size = File.size(__FILE__)
+
+      # IO-like object without #size/#length
+      fake_reader = Object.new
+      def fake_reader.read(*args)
+        "READ"
+      end
+
+      # test defaults with non-body requests
+      [:get, :patch, :options, :delete].each do |verb|
+        tests.update(
+          lambda {
+            c.send(verb, "a")
+          } => "NONE,NONE,NONE -",
+
+          lambda {
+            c.send(verb, "a") { |r| r.body ="ABC" }
+          } => "application/octet-stream,3,NONE ABC",
+
+          lambda {
+            c.send(verb, "a") do |r|
+              r.header[:content_type] = "text/plain"
+              r.body = "ABC"
+            end
+          } => "text/plain,3,NONE ABC",
+        )
+      end
+
+      # these http verbs need a body
+      [:post, :put].each do |verb|
+        tests.update(
+          # RAW BODY TESTS
+
+          lambda {
+            c.send(verb, "a")
+          } => "NONE,0,NONE -",
+
+          lambda {
+            c.send(verb, "a") do |r|
+              r.body = "abc"
+            end
+          } => "application/octet-stream,3,NONE abc",
+
+          lambda {
+            c.send(verb, "a") do |r|
+              r.header[:content_type] = "text/plain"
+              r.body = "abc"
+            end
+          } => "text/plain,3,NONE abc",
+
+          # FILE TESTS
+
+          lambda {
+            c.send(verb, "a") do |r|
+              r.body = File.new(__FILE__)
+            end
+          } => "application/octet-stream,#{file_size},NONE #{__FILE__}",
+
+          lambda {
+            c.send(verb, "a") do |r|
+              r.header[:content_type] = "text/plain"
+              r.body = File.new(__FILE__)
+            end
+          } => "text/plain,#{file_size},NONE #{__FILE__}",
+
+          # GENERIC IO TESTS
+
+          lambda {
+            c.send(verb, "a") do |r|
+              r.body = fake_reader
+            end
+          } => "application/octet-stream,NONE,chunked READ",
+
+          lambda {
+            c.send(verb, "a") do |r|
+              r.header[:content_type] = "text/plain"
+              r.body = fake_reader
+            end
+          } => "text/plain,NONE,chunked READ",
+
+          lambda {
+            c.send(verb, "a") do |r|
+              r.header[:content_length] = 4
+              r.body = fake_reader
+            end
+          } => "application/octet-stream,4,NONE READ",
+
+          lambda {
+            c.send(verb, "a") do |r|
+              r.header[:content_length] = 4
+              r.header[:content_type] = "text/plain"
+              r.body = fake_reader
+            end
+          } => "text/plain,4,NONE READ",
+        )
+      end
+
+      tests.each do |req_block, expected|
+        res = req_block.call
+        req = res.request
+        if expected != res.body
+          errors << "#{req.inspect} Expected #{expected.inspect}; Got #{res.body.inspect}"
+        end
+      end
+
+      if errors.any?
+        fail "\n" + errors.join("\n")
+      end
+    end
+
+    def test_integration_with_query
+      c = Client.new "https://example.com"
+      c.connection = Test.new do |test|
+        [:get, :options, :delete].each do |verb|
+          test.send(verb, "/a") do |req|
+            [200, {}, req.url.to_s]
+          end
+        end
+      end
+
+      errors = []
+      prefix = "https://example.com/a"
+
+      {
+        nil => prefix,
+        {:foo => :bar} => "#{prefix}?foo=bar",
+      }.each do |input, expected|
+        [:get, :options, :delete].each do |verb|
+          res = c.send(verb, "a", input)
+          if res.body != expected
+            errors << "#{res.request.url.inspect} => #{expected.inspect} != #{res.body.inspect}"
+          end
+        end
+      end
+
+      if errors.any?
+        fail "\n" + errors.join("\n")
+      end
+    end
+
+    def test_integration_with_body
+      c = Client.new "https://example.com"
+      c.connection = Test.new do |test|
+        [:post, :put, :patch].each do |verb|
+          test.send(verb, "/form") do |req|
+            [200, {}, "#{req.header[:content_type]}:#{req.body_io.read}"]
+          end
+        end
+
+        [:post, :put, :patch].each do |verb|
+          test.send(verb, "/multipart") do |req|
+            m = Rack::Multipart.parse_multipart(
+              "CONTENT_TYPE" => req.header[:content_type],
+              "CONTENT_LENGTH" => req.header[:content_length],
+              "rack.input" => req.body_io,
+            )
+            [200, {}, "#{req.header[:content_type]}:#{Array(m["a"]).join(",")}:#{m["h"].inspect}:#{m["file"][:tempfile].read}"]
+          end
+        end
+      end
+
+      errors = []
+
+      flat_query = Query::Flat.new :a => [1,2]
+      nested_query = Query::Nested.new :a => [1,2]
+
+      {
+        ["abc"] => "application/octet-stream:abc",
+        ["abc", "text/plain"] => "text/plain:abc",
+        [{:a => 1}] => "application/x-www-form-urlencoded:a=1",
+        [flat_query] => "application/x-www-form-urlencoded:a=1&a=2",
+        [nested_query] => "application/x-www-form-urlencoded:a%5B%5D=1&a%5B%5D=2",
+        [flat_query, :form] => "form:a=1&a=2",
+        [nested_query, :form] => "form:a%5B%5D=1&a%5B%5D=2",
+      }.each do |args, expected|
+        [:post, :put, :patch].each do |verb|
+          res = c.send(verb, "form", *args)
+          if res.body != expected
+            errors << "#{verb} => #{expected.inspect} != #{res.body.inspect}"
+          end
+        end
+      end
+
+      multipart_tests = {}
+      [:post, :put, :patch].each do |verb|
+        nested_query = Query::Nested.new(:file => UploadIO.new(StringIO.new("ABC"), "text/plain"), :a => [1,2], :h => {:a => 1})
+        flat_query = Query::Flat.new(:file => UploadIO.new(StringIO.new("ABC"), "text/plain"), :a => [3,4], :h => 0)
+        hash_query = {:file => UploadIO.new(StringIO.new("ABC"), "text/plain"), :a => [5,6], :h => {:a => 1}}
+        multipart_tests.update(
+          c.send(verb, "multipart", nested_query) => %(:1,2:{"a"=>"1"}:ABC),
+          c.send(verb, "multipart", flat_query) => %(:4:"0":ABC),
+          c.send(verb, "multipart", hash_query) => %(:5,6:{"a"=>"1"}:ABC),
+        )
+      end
+
+      multipart_tests.each do |res, expected|
+        if res.body !~ %r{\Amultipart/form-data; boundary=Hurley-(\w+):}
+          errors << "#{res.request.verb} multipart (#{expected[1..-1]}) bad type: #{res.body}"
+        end
+
+        if !res.body.end_with?(expected)
+          errors << "#{res.request.verb} multipart (#{expected[1..-1]}) bad body: #{res.body}"
+        end
+      end
+
+      if errors.any?
+        fail "\n" + errors.join("\n")
+      end
+    end
+
+    def test_integration_follow_get_redirect
+      statuses = [301, 302, 303]
+
+      c = Client.new "http://example.com?o=1"
+      c.request_options.redirection_limit = 0
+      c.connection = Test.new do |t|
+        statuses.each do |st|
+          t.get "/#{st}/host/2" do |req|
+            [st, {"Location" => "http://example.com/#{st}/host/1"}, nil]
+          end
+
+          t.get "/#{st}/host/1" do |req|
+            [st, {"Location" => "http://example.com/#{st}/host/0"}, nil]
+          end
+
+          t.get "/#{st}/host/0" do |req|
+            [200, {}, "ok"]
+          end
+
+          t.post "/#{st}/host" do |req|
+            [st, {"Location" => "http://example.com/#{st}/host/2?o=2"}, nil]
+          end
+
+          t.get "/#{st}/path/2" do |req|
+            [st, {"Location" => "/#{st}/path/1"}, nil]
+          end
+
+          t.get "/#{st}/path/1" do |req|
+            [st, {"Location" => "/#{st}/path/0"}, nil]
+          end
+
+          t.get "/#{st}/path/0" do |req|
+            [200, {}, "ok"]
+          end
+
+          t.post "/#{st}/path" do |req|
+            [st, {"Location" => "2?o=2"}, nil]
+          end
+        end
+      end
+
+      statuses.each do |st|
+        {
+          "/#{st}/host" => "http://example.com/#{st}/host/",
+          "/#{st}/path" => "http://example.com/#{st}/path/",
+        }.each do |input, prefix|
+          res = c.post(input)
+          assert_equal st, res.status_code
+          assert_equal prefix + "2?o=2", res.location.url.to_s
+
+          res = c.call(res.location)
+          assert_equal st, res.status_code
+          assert_equal prefix + "1?o=2", res.location.url.to_s
+
+          res = c.call(res.location)
+          assert_equal st, res.status_code
+          assert_equal prefix + "0?o=2", res.location.url.to_s
+
+          res = c.call(res.location)
+          assert_equal 200, res.status_code
+        end
+      end
+    end
+
+    def test_integration_follow_post_redirect
+      statuses = [307, 308]
+
+      c = Client.new "http://example.com?o=1"
+      c.request_options.redirection_limit = 0
+      c.connection = Test.new do |t|
+        statuses.each do |st|
+          t.post "/#{st}/host/2" do |req|
+            [st, {"Location" => "http://example.com/#{st}/host/1"}, nil]
+          end
+
+          t.post "/#{st}/host/1" do |req|
+            [st, {"Location" => "http://example.com/#{st}/host/0"}, nil]
+          end
+
+          t.post "/#{st}/host/0" do |req|
+            [200, {}, "ok"]
+          end
+
+          t.post "/#{st}/host" do |req|
+            [st, {"Location" => "http://example.com/#{st}/host/2?o=2"}, nil]
+          end
+
+          t.post "/#{st}/path/2" do |req|
+            [st, {"Location" => "/#{st}/path/1"}, nil]
+          end
+
+          t.post "/#{st}/path/1" do |req|
+            [st, {"Location" => "/#{st}/path/0"}, nil]
+          end
+
+          t.post "/#{st}/path/0" do |req|
+            [200, {}, "ok"]
+          end
+
+          t.post "/#{st}/path" do |req|
+            [st, {"Location" => "2?o=2"}, nil]
+          end
+        end
+      end
+
+      statuses.each do |st|
+        {
+          "/#{st}/host" => "http://example.com/#{st}/host/",
+          "/#{st}/path" => "http://example.com/#{st}/path/",
+        }.each do |input, prefix|
+          res = c.post(input)
+          assert_equal st, res.status_code
+          assert_equal prefix + "2?o=2", res.location.url.to_s
+
+          res = c.call(res.location)
+          assert_equal st, res.status_code
+          assert_equal prefix + "1?o=2", res.location.url.to_s
+
+          res = c.call(res.location)
+          assert_equal st, res.status_code
+          assert_equal prefix + "0?o=2", res.location.url.to_s
+
+          res = c.call(res.location)
+          assert_equal 200, res.status_code
+        end
+      end
+    end
+
+    def test_integration_automatic_redirection
+      c = Client.new "https://example.com"
+      c.connection = Test.new do |t|
+        1.upto(5) do |i|
+          t.get "/#{i}" do |req|
+            [301, {"Location" => "/#{i - 1}"}, i.to_s]
+          end
+        end
+
+        t.get "/0" do |req|
+          [200, {}, "ok"]
+        end
+      end
+
+      res = c.get("/5") { |r| r.options.redirection_limit = 10 }
+      assert_equal "ok", res.body
+      assert_equal [
+        "https://example.com/5",
+        "https://example.com/4",
+        "https://example.com/3",
+        "https://example.com/2",
+        "https://example.com/1",
+      ], res.via.map { |r| r.url.to_s }
+      assert_equal "https://example.com/0", res.request.url.to_s
+
+      res = c.get("/5") { |r| r.options.redirection_limit = 3 }
+      assert_equal "2", res.body
+      assert_equal [
+        "https://example.com/5",
+        "https://example.com/4",
+        "https://example.com/3",
+        ], res.via.map { |r| r.url.to_s }
+        assert_equal "https://example.com/2", res.request.url.to_s
+    end
+
+    def test_parses_endpoint
+      c = Client.new "https://example.com/a?a=1"
+      assert_equal "https", c.scheme
+      assert_equal "example.com", c.host
+      assert_equal "/a", c.url.path
+    end
+
+    def test_builds_request
+      c = Client.new "https://example.com/a?a=1"
+      c.header["Accept"] = "*"
+      c.request_options.bind = "bind:123"
+      c.ssl_options.openssl_client_cert = "abc"
+
+      req = c.request :get, "b"
+      assert_equal "bind", req.options.bind.host
+      assert_equal 123, req.options.bind.port
+      assert_equal "abc", req.ssl_options.openssl_client_cert
+      req.ssl_options.openssl_client_cert = "def"
+      req.options.bind = "updated"
+
+      assert_equal "*", req.header["Accept"]
+      assert_equal "def", req.ssl_options.openssl_client_cert
+      assert_equal "updated", req.options.bind.host
+      assert_nil req.options.bind.port
+
+      url = req.url
+      assert_equal "https://example.com/a/b?a=1", url.to_s
+
+      assert_equal "abc", c.ssl_options.openssl_client_cert
+      assert_equal "bind", c.request_options.bind.host
+      assert_equal 123, c.request_options.bind.port
+    end
+
+    def test_sets_before_callbacks
+      c = Client.new nil
+      c.before_call(:first) { |r| 1 }
+      c.before_call { |r| 2 }
+      c.before_call NamedCallback.new(:third, lambda { |r| 3 })
+
+      callbacks = c.before_callbacks
+      assert_equal 3, callbacks.size
+      assert_equal :first, callbacks[0]
+      assert callbacks[1].start_with?("#<Proc:")
+      assert_equal :third, callbacks[2]
+    end
+
+    def test_sets_after_callbacks
+      c = Client.new nil
+      c.after_call(:first) { |r| 1 }
+      c.after_call { |r| 2 }
+      c.after_call NamedCallback.new(:third, lambda { |r| 3 })
+
+      callbacks = c.after_callbacks
+      assert_equal 3, callbacks.size
+      assert_equal :first, callbacks[0]
+      assert callbacks[1].start_with?("#<Proc:")
+      assert_equal :third, callbacks[2]
+    end
+
+    SUCCESSFUL_RESPONSES = [200, 201, 202, 204, 205, 206]
+    REDIRECTION_RESPONSES = [301, 302, 303, 307, 308]
+    CLIENT_ERROR_RESPONSES = [400, 404, 405, 406, 409, 410, 422]
+    SERVER_ERROR_RESPONSES = [500, 502, 503, 504]
+    ALL_RESPONSES = SUCCESSFUL_RESPONSES + REDIRECTION_RESPONSES + CLIENT_ERROR_RESPONSES + SERVER_ERROR_RESPONSES + [100, 304]
+
+    def test_knows_successful_responses
+      bad = SUCCESSFUL_RESPONSES.reject do |st|
+        res = Response.new(nil, st)
+        res.success? && res.status_type == :success
+      end
+      assert_empty bad
+
+      bad = (ALL_RESPONSES - SUCCESSFUL_RESPONSES).reject do |st|
+        res = Response.new(nil, st)
+
+        !Response.new(nil, st).success?
+      end
+      assert_empty bad
+    end
+
+    def test_knows_redirection_responses
+      bad = REDIRECTION_RESPONSES.reject do |st|
+        res = Response.new(nil, st)
+        res.redirection? && res.status_type == :redirection
+      end
+      assert_empty bad
+
+      bad = (ALL_RESPONSES - REDIRECTION_RESPONSES).reject do |st|
+        res = Response.new(nil, st)
+        !res.redirection? && res.status_type != :redirection
+      end
+      assert_empty bad
+    end
+
+    def test_knows_client_error_responses
+      bad = CLIENT_ERROR_RESPONSES.reject do |st|
+        res = Response.new(nil, st)
+        res.client_error? && res.status_type == :client_error
+      end
+      assert_empty bad
+
+      bad = (ALL_RESPONSES - CLIENT_ERROR_RESPONSES).reject do |st|
+        res = Response.new(nil, st)
+        !res.client_error? && res.status_type != :client_error
+      end
+      assert_empty bad
+    end
+
+    def test_knows_server_error_responses
+      bad = SERVER_ERROR_RESPONSES.reject do |st|
+        res = Response.new(nil, st)
+        res.server_error? && res.status_type == :server_error
+      end
+      assert_empty bad
+
+      bad = (ALL_RESPONSES - SERVER_ERROR_RESPONSES).reject do |st|
+        res = Response.new(nil, st)
+        !res.server_error? && res.status_type != :server_error
+      end
+      assert_empty bad
+    end
+  end
+end