hurley 0.1

data/test/header_test.rb

@@ -0,0 +1,108 @@
+require File.expand_path("../helper", __FILE__)
+
+module Hurley
+  class HeaderTest < TestCase
+    def test_integration
+      client = Client.new "https://example.com"
+      client.header["Client"] = "1"
+      client.header["Override"] = "1"
+      client.connection = Test.new do |t|
+        t.get("/a") do |req|
+          output = []
+          req.header.each do |key, value|
+            output << "#{key}:#{value}"
+          end
+          [200, {}, output.join("\n")]
+        end
+      end
+
+      res = client.get("/a") do |req|
+        req.header["Request"] = "2"
+        req.header["Override"] = "2"
+      end
+
+      assert_equal 200, res.status_code
+      assert_equal "User-Agent:Hurley v0.1\nClient:1\nOverride:2\nRequest:2", res.body
+    end
+
+    def test_empty_initial
+      h = Header.new
+      assert !h.key?(:content_type)
+      assert_equal 0, h.size
+      assert_equal [], h.keys
+    end
+
+    def test_initial
+      h = Header.new :content_type => "text/plain"
+      assert_equal 1, h.size
+      assert_equal %w(Content-Type), h.keys
+      [
+        "Content-Type",
+        "content-type",
+        :content_type,
+      ].each do |key|
+        assert h.key?(key)
+        assert_equal "text/plain", h[key]
+      end
+    end
+
+    def test_set_and_get_key_with_shortcuts
+      ["Content-Type", "content-type", :content_type, "CONTENT-TYPE"].each do |key|
+        h = Header.new
+        assert_nil h[key]
+
+        h[key] = "text/plain"
+        assert_equal %w(Content-Type), h.keys
+        assert_equal "text/plain", h[key]
+      end
+    end
+
+    def test_set_and_get_custom_key
+      ["X-Hurley", "x-hurley", :x_hurley, "X-HURLEY"].each do |key|
+        h = Header.new
+        assert_nil h[key]
+
+        h[key] = "text/plain"
+        assert_equal %w(X-Hurley), h.keys
+        assert_equal "text/plain", h[key]
+      end
+    end
+
+    def test_delete_key
+      h = Header.new :content_type => "text/plain"
+      assert_equal %w(Content-Type), h.keys
+      assert_equal "text/plain", h[:content_type]
+
+      h.delete :content_type
+      assert_equal [], h.keys
+    end
+
+    def test_iterate_keys
+      h = Header.new :content_type => "text/plain", :content_length => 2
+      assert_equal %w(Content-Type Content-Length), h.keys
+      assert_equal "text/plain", h[:content_type]
+      assert_equal "2", h[:content_length]
+
+      pieces = []
+      h.each do |key, value|
+        pieces << "#{key}=#{value}"
+      end
+
+      assert_equal "Content-Type=text/plain\nContent-Length=2",
+        pieces.join("\n")
+    end
+
+    def test_dup
+      h1 = Header.new :content_type => "text/plain"
+      h2 = h1
+      h3 = h1.dup
+
+      h2[:content_type] = "text/plain; charset=utf-8"
+      h3[:content_type] = "image/gif"
+
+      assert_equal "text/plain; charset=utf-8", h1[:content_type]
+      assert_equal "text/plain; charset=utf-8", h2[:content_type]
+      assert_equal "image/gif", h3[:content_type]
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,14 @@
+require "minitest/autorun"
+require "rack"
+
+if ENV["HURLEY_ADDRESSABLE"]
+  require "addressable/uri"
+end
+
+require File.expand_path("../../lib/hurley", __FILE__)
+Hurley.require_lib "test", "test/integration"
+
+module Hurley
+  class TestCase < MiniTest::Test
+  end
+end

data/test/live/net_http_test.rb

@@ -0,0 +1,16 @@
+require File.expand_path("../../helper", __FILE__)
+
+module Hurley
+  module Live
+    class NetHttpTest < TestCase
+      features = []
+      features << :Compression if RUBY_VERSION >= "1.9"
+
+      Hurley::Test::Integration.apply(self, *features)
+
+      def connection
+        Hurley.default_connection
+      end
+    end
+  end
+end

data/test/multipart_test.rb

@@ -0,0 +1,306 @@
+require File.expand_path("../helper", __FILE__)
+
+module Hurley
+  class MultipartTest < TestCase
+    def test_build_form_with_flat_query
+      ctype, body = Query::Flat.new(:a => [1,2,3]).to_form
+      assert_equal "application/x-www-form-urlencoded", ctype
+      assert_equal "a=1&a=2&a=3", body.read
+    end
+
+    def test_build_form_with_nested_query
+      ctype, body = Query::Nested.new(:a => {:b => 2}).to_form
+      assert_equal "application/x-www-form-urlencoded", ctype
+      assert_equal "a%5Bb%5D=2", body.read
+    end
+
+    def test_build_multipart_with_set_boundary
+      options = RequestOptions.new
+      options.boundary = :wat
+
+      ctype, _ = Query::Nested.new(:file => UploadIO.new(__FILE__, "text/plain")).to_form(options)
+      assert_equal "multipart/form-data; boundary=wat", ctype
+    end
+
+    def test_build_multipart_with_flat_query
+      ctype, body = Query::Flat.new(
+        :a => 1,
+        :array => [1, 2],
+        :file => UploadIO.new(__FILE__, "text/plain"),
+      ).to_form
+
+      src = IO.read(__FILE__)
+
+      boundary = nil
+      if ctype =~ %r{\Amultipart/form-data; boundary=(Hurley\-.*)}
+        boundary = $1
+      else
+        fail "bad ctype: #{ctype.inspect}"
+      end
+
+      assert_match %r{\Amultipart/form-data; boundary=Hurley\-}, ctype
+      expected = %(--#{boundary}\r\n) +
+        %(Content-Disposition: form-data; name="a"\r\n) +
+        %(\r\n1\r\n) +
+
+        %(--#{boundary}\r\n) +
+        %(Content-Disposition: form-data; name="array"\r\n) +
+        %(\r\n1\r\n) +
+
+        %(--#{boundary}\r\n) +
+        %(Content-Disposition: form-data; name="array"\r\n) +
+        %(\r\n2\r\n) +
+
+        %(--#{boundary}\r\n) +
+        %(Content-Disposition: form-data; name="file"; filename="multipart_test.rb"\r\n) +
+        %(Content-Length: #{src.size}\r\n) +
+        %(Content-Type: text/plain\r\n) +
+        %(Content-Transfer-Encoding: binary\r\n) +
+        %(\r\n#{src}\r\n) +
+
+        %(--#{boundary}--\r\n\r\n)
+
+      assert_equal expected, body.read.to_s
+    end
+
+    def test_build_multipart_with_nested_query
+      ctype, body = Query::Nested.new(:a => {
+        :num => 1,
+        :arr => [1, 2],
+        :file => UploadIO.new(__FILE__, "text/plain"),
+      }).to_form
+
+      src = IO.read(__FILE__)
+
+      boundary = nil
+      if ctype =~ %r{\Amultipart/form-data; boundary=(Hurley\-.*)}
+        boundary = $1
+      else
+        fail "bad ctype: #{ctype.inspect}"
+      end
+
+      expected = %(--#{boundary}\r\n) +
+        %(Content-Disposition: form-data; name="a[num]"\r\n) +
+        %(\r\n1\r\n) +
+
+        %(--#{boundary}\r\n) +
+        %(Content-Disposition: form-data; name="a[arr][]"\r\n) +
+        %(\r\n1\r\n) +
+
+        %(--#{boundary}\r\n) +
+        %(Content-Disposition: form-data; name="a[arr][]"\r\n) +
+        %(\r\n2\r\n) +
+
+        %(--#{boundary}\r\n) +
+        %(Content-Disposition: form-data; name="a[file]"; filename="multipart_test.rb"\r\n) +
+        %(Content-Length: #{src.size}\r\n) +
+        %(Content-Type: text/plain\r\n) +
+        %(Content-Transfer-Encoding: binary\r\n) +
+        %(\r\n#{src}\r\n) +
+
+        %(--#{boundary}--\r\n\r\n)
+
+      assert_equal expected, body.read.to_s
+    end
+  end
+
+  class ParamPartTest < TestCase
+    def test_build_without_content_type
+      part = Multipart::Part.new("boundary", "foo", "bar", {})
+      expected = %(--boundary\r\n) +
+        %(Content-Disposition: form-data; name="foo"\r\n) +
+        %(\r\nbar\r\n)
+      assert_equal expected.size, part.length
+      assert_equal expected, part.to_io.read
+    end
+
+    def test_build_with_content_type
+      part = Multipart::Part.new("boundary", "foo", "bar",
+        :content_type => "text/plain")
+      expected = %(--boundary\r\n) +
+        %(Content-Disposition: form-data; name="foo"\r\n) +
+        %(Content-Type: text/plain\r\n) +
+        %(\r\nbar\r\n)
+      assert_equal expected.size, part.length
+      assert_equal expected, part.to_io.read
+    end
+  end
+
+  class FilePartTest < TestCase
+    def test_build_without_options
+      src = IO.read(__FILE__)
+      io = UploadIO.new(__FILE__, "text/plain")
+
+      part = Multipart::Part.new("boundary", "foo", io, {})
+
+      expected = %(--boundary\r\n) +
+        %(Content-Disposition: form-data; name="foo"; filename="multipart_test.rb"\r\n) +
+        %(Content-Length: #{src.size}\r\n) +
+        %(Content-Type: text/plain\r\n) +
+        %(Content-Transfer-Encoding: binary\r\n) +
+        %(\r\n#{src}\r\n)
+
+      assert_equal expected.size, part.length
+      assert_equal expected, part.to_io.read
+    end
+
+    def test_build_with_content_type
+      src = IO.read(__FILE__)
+      io = UploadIO.new(__FILE__, "text/plain")
+
+      part = Multipart::Part.new("boundary", "foo", io,
+        :content_type => "text/ruby")
+
+      expected = %(--boundary\r\n) +
+        %(Content-Disposition: form-data; name="foo"; filename="multipart_test.rb"\r\n) +
+        %(Content-Length: #{src.size}\r\n) +
+        %(Content-Type: text/ruby\r\n) +
+        %(Content-Transfer-Encoding: binary\r\n) +
+        %(\r\n#{src}\r\n)
+
+      assert_equal expected.size, part.length
+      assert_equal expected, part.to_io.read
+    end
+
+    def test_build_with_content_disposition
+      src = IO.read(__FILE__)
+      io = UploadIO.new(__FILE__, "text/plain")
+
+      part = Multipart::Part.new("boundary", "foo", io,
+        :content_disposition => "attachment")
+
+      expected = %(--boundary\r\n) +
+        %(Content-Disposition: attachment; name="foo"; filename="multipart_test.rb"\r\n) +
+        %(Content-Length: #{src.size}\r\n) +
+        %(Content-Type: text/plain\r\n) +
+        %(Content-Transfer-Encoding: binary\r\n) +
+        %(\r\n#{src}\r\n)
+
+      assert_equal expected.size, part.length
+      assert_equal expected, part.to_io.read
+    end
+
+    def test_build_with_content_transfer_encoding
+      src = IO.read(__FILE__)
+      io = UploadIO.new(__FILE__, "text/plain")
+
+      part = Multipart::Part.new("boundary", "foo", io,
+        :content_transfer_encoding => "rofl")
+
+      expected = %(--boundary\r\n) +
+        %(Content-Disposition: form-data; name="foo"; filename="multipart_test.rb"\r\n) +
+        %(Content-Length: #{src.size}\r\n) +
+        %(Content-Type: text/plain\r\n) +
+        %(Content-Transfer-Encoding: rofl\r\n) +
+        %(\r\n#{src}\r\n)
+
+      assert_equal expected.size, part.length
+      assert_equal expected, part.to_io.read
+    end
+
+    def test_build_with_content_id
+      src = IO.read(__FILE__)
+      io = UploadIO.new(__FILE__, "text/plain")
+
+      part = Multipart::Part.new("boundary", "foo", io,
+        :content_id => "abc123")
+
+      expected = %(--boundary\r\n) +
+        %(Content-Disposition: form-data; name="foo"; filename="multipart_test.rb"\r\n) +
+        %(Content-Length: #{src.size}\r\n) +
+        %(Content-ID: abc123\r\n) +
+        %(Content-Type: text/plain\r\n) +
+        %(Content-Transfer-Encoding: binary\r\n) +
+        %(\r\n#{src}\r\n)
+
+      assert_equal expected.size, part.length
+      assert_equal expected, part.to_io.read
+    end
+  end
+
+  class CompositeReadIOTest < TestCase
+    def test_read_all
+      io = CompositeReadIO.new StringIO.new("one"), StringIO.new("two")
+      assert_equal "onetwo", io.read
+    end
+
+    def test_read_chunks
+      io = CompositeReadIO.new StringIO.new("one"), StringIO.new("two")
+      assert_equal "on", io.read(2)
+      assert_equal "et", io.read(2)
+      assert_equal "wo", io.read(2)
+      assert_nil io.read(2)
+
+      io.rewind
+
+      assert_equal "on", io.read(2)
+      assert_equal "et", io.read(2)
+      assert_equal "wo", io.read(2)
+      assert_nil io.read(2)
+
+      io.rewind
+
+      assert_equal "one", io.read(3)
+      assert_equal "two", io.read(3)
+      assert_nil io.read(3)
+    end
+  end
+
+  class UploadIOTest < TestCase
+    def test_with_filename_and_no_custom_filename
+      io = UploadIO.new(__FILE__, "text/plain")
+      assert_equal "text/plain", io.content_type
+      assert_equal "multipart_test.rb", io.original_filename
+      assert_equal __FILE__, io.local_path
+      assert_empty io.opts
+      assert_equal IO.read(__FILE__), io.read
+    end
+
+    def test_with_filename_and_custom_filename
+      io = UploadIO.new(__FILE__, "text/plain", "wat.rb")
+      assert_equal "text/plain", io.content_type
+      assert_equal "wat.rb", io.original_filename
+      assert_equal __FILE__, io.local_path
+      assert_empty io.opts
+      assert_equal IO.read(__FILE__), io.read
+    end
+
+    def test_with_file_io_and_no_custom_filename
+      io = UploadIO.new(File.new(__FILE__), "text/plain")
+      assert_equal "text/plain", io.content_type
+      assert_equal "multipart_test.rb", io.original_filename
+      assert_equal __FILE__, io.local_path
+      assert_empty io.opts
+      assert_equal IO.read(__FILE__), io.read
+    end
+
+    def test_with_file_io_and_custom_filename
+      io = UploadIO.new(File.new(__FILE__), "text/plain", "wat.rb")
+      assert_equal "text/plain", io.content_type
+      assert_equal "wat.rb", io.original_filename
+      assert_equal __FILE__, io.local_path
+      assert_empty io.opts
+      assert_equal IO.read(__FILE__), io.read
+    end
+
+    def test_with_io_and_no_custom_filename
+      stringio = StringIO.new(IO.read(__FILE__))
+      io = UploadIO.new(stringio, "text/plain")
+      assert_equal "text/plain", io.content_type
+      assert_equal "local.path", io.original_filename
+      assert_equal "local.path", io.local_path
+      assert_empty io.opts
+      assert_equal IO.read(__FILE__), io.read
+    end
+
+    def test_with_io_and_custom_filename
+      stringio = StringIO.new(IO.read(__FILE__))
+      io = UploadIO.new(stringio, "text/plain", "wat.rb")
+      assert_equal "text/plain", io.content_type
+      assert_equal "wat.rb", io.original_filename
+      assert_equal "local.path", io.local_path
+      assert_empty io.opts
+      assert_equal IO.read(__FILE__), io.read
+    end
+  end
+end

data/test/query_test.rb

@@ -0,0 +1,189 @@
+require File.expand_path("../helper", __FILE__)
+
+module Hurley
+  class QueryTest < TestCase
+    def test_encode_and_parse_string_value
+      q = Query::Nested.new
+      q["a"] = 1
+
+      assert !q.key?("a+b")
+      assert_nil q["a+b"]
+      q["a+b"] = "1+2"
+      assert_equal "1+2", q["a+b"]
+      assert q.key?("a+b")
+
+      assert_equal "a=1&a%2Bb=1%2B2", q.to_query_string
+
+      q2 = Query.parse(q.to_query_string)
+      assert_equal %w(a a+b), q2.keys
+      assert_equal "1", q2["a"]
+      assert_equal "1+2", q2["a+b"]
+    end
+
+    def test_encode_and_parse_nil_value
+      q = Query::Nested.new
+      q["a"] = 1
+      assert !q.key?("a+b")
+      assert_nil q["a+b"]
+      q["a+b"] = nil
+      assert_nil q["a+b"]
+      assert q.key?("a+b")
+
+      assert_equal "a=1&a%2Bb", q.to_query_string
+
+      q2 = Query.parse(q.to_query_string)
+      assert_equal %w(a a+b), q2.keys
+      assert_equal "1", q2["a"]
+      assert_nil q2["a+b"]
+    end
+
+    def test_delete_value
+      q = Query::Nested.new
+      q["a+b"] = "1+2"
+      assert_equal "a%2Bb=1%2B2", q.to_query_string
+      q.delete "a+b"
+      assert_equal "", q.to_query_string
+    end
+
+    def test_encode_and_parse_array_value_in_nested_query
+      q = Query::Nested.new
+      q["a"] = 1
+      q["a+b"] = %w(1+1 2+2 3+3)
+      assert_query "a=1&a%2Bb[]=1%2B1&a%2Bb[]=2%2B2&a%2Bb[]=3%2B3", q.to_query_string
+
+      q2 = Query::Nested.parse(q.to_query_string)
+      assert_equal %w(a a+b), q2.keys
+      assert_equal "1", q2["a"]
+      assert_equal %w(1+1 2+2 3+3), q2["a+b"]
+    end
+
+    def test_encode_and_parse_array_value_in_flat_query
+      q = Query::Flat.new
+      q["a"] = 1
+      q["a+b"] = %w(1+1 2+2 3+3)
+      assert_equal "a=1&a%2Bb=1%2B1&a%2Bb=2%2B2&a%2Bb=3%2B3", q.to_query_string
+
+      q2 = Query::Flat.parse(q.to_query_string)
+      assert_equal %w(a a+b), q2.keys
+      assert_equal "1", q2["a"]
+      assert_equal %w(1+1 2+2 3+3), q2["a+b"]
+    end
+
+    def test_encode_and_parse_simple_hash_value_in_nested_query
+      q = Query::Nested.new
+      q["a"] = 1
+      q["a+b"] = {"1+1" => "a+a", "2+2" => "b+b"}
+      assert_query "a=1&a%2Bb[1%2B1]=a%2Ba&a%2Bb[2%2B2]=b%2Bb", q.to_query_string
+
+      q2 = Query::Nested.parse(q.to_query_string)
+      assert_equal %w(a a+b), q2.keys
+      assert_equal "1", q2["a"]
+      assert_equal %w(1+1 2+2), q2["a+b"].keys
+      assert_equal "a+a", q2["a+b"]["1+1"]
+      assert_equal "b+b", q2["a+b"]["2+2"]
+    end
+
+    def test_encode_and_parse_deeply_nested_hash
+      q = Query::Nested.new
+      q["a"] = 1
+      q["a+1"] = {
+        "b+2" => {
+          "c+3" => "d+4",
+          "c+wat" => "c",
+        },
+        "b+wat" => "b"
+      }
+
+      assert_query "a=1&a%2B1[b%2B2][c%2B3]=d%2B4&a%2B1[b%2B2][c%2Bwat]=c&a%2B1[b%2Bwat]=b", q.to_query_string
+      q2 = Query::Nested.parse(q.to_query_string)
+      assert_equal %w(a a+1), q2.keys
+      assert_equal "1", q2["a"]
+
+      assert_equal %w(b+2 b+wat), q2["a+1"].keys
+      assert_equal %w(c+3 c+wat), q2["a+1"]["b+2"].keys
+      assert_equal "b", q2["a+1"]["b+wat"]
+      assert_equal "c", q2["a+1"]["b+2"]["c+wat"]
+      assert_equal "d+4", q2["a+1"]["b+2"]["c+3"]
+    end
+
+    def test_encode_and_parse_deeply_nested_array
+      q = Query::Nested.new
+      q["a"] = 1
+      q["a+1"] = {
+        "b+2" => {
+          "c+3" => %w(d+4 d),
+          "c+wat" => "c",
+        },
+        "b+wat" => "b"
+      }
+
+      assert_query "a=1&a%2B1[b%2B2][c%2B3][]=d%2B4&a%2B1[b%2B2][c%2B3][]=d&a%2B1[b%2B2][c%2Bwat]=c&a%2B1[b%2Bwat]=b", q.to_query_string
+      q2 = Query::Nested.parse(q.to_query_string)
+      assert_equal %w(a a+1), q2.keys
+      assert_equal "1", q2["a"]
+
+      assert_equal %w(b+2 b+wat), q2["a+1"].keys
+      assert_equal %w(c+3 c+wat), q2["a+1"]["b+2"].keys
+      assert_equal "b", q2["a+1"]["b+wat"]
+      assert_equal "c", q2["a+1"]["b+2"]["c+wat"]
+      assert_equal %w(d+4 d), q2["a+1"]["b+2"]["c+3"]
+    end
+
+    def test_encode_and_parse_deeply_nested_key
+      q = Query::Nested.new
+      q["a"] = 1
+      q["a+1"] = [ # 1
+        { # 2
+          "b+2" => { # 3
+            "c+3" => [ # 4
+              {"d+4" => %w(e 5)}
+            ]
+          }
+        }
+      ]
+
+      assert_query "a=1&a%2B1[][b%2B2][c%2B3][][d%2B4][]=e&a%2B1[][b%2B2][c%2B3][][d%2B4][]=5", q.to_query_string
+      q2 = Query::Nested.parse(q.to_query_string)
+      assert_equal %w(a a+1), q2.keys
+      assert_equal "1", q2["a"]
+
+      arr1 = q2["a+1"]
+      assert_equal 2, arr1.size
+      hash2 = arr1[0]
+      assert_equal %w(b+2), hash2.keys
+      hash3 = hash2["b+2"]
+      assert_equal %w(c+3), hash3.keys
+      arr4 = hash3["c+3"]
+      assert_equal 1, arr4.size
+      hash5 = arr4[0]
+      assert_equal %w(e), hash5["d+4"]
+
+      hash2 = arr1[1]
+      assert_equal %w(b+2), hash2.keys
+      hash3 = hash2["b+2"]
+      assert_equal %w(c+3), hash3.keys
+      arr4 = hash3["c+3"]
+      assert_equal 1, arr4.size
+      hash5 = arr4[0]
+      assert_equal %w(5), hash5["d+4"]
+    end
+
+    def test_encode_hash_value_in_flat_query
+      q = Query::Flat.new
+      q["a"] = {1 => "a", 2 => "b"}
+      assert_raises NotImplementedError do
+        q.to_query_string
+      end
+    end
+
+    def test_parse_hash_value_in_flat_query
+      q = Query::Flat.parse("a=1&a%2Ba[1%2B1]=a%2Ba&a%2Ba[2%2B2]=b%2Bb")
+      assert_equal %w(a a+a[1+1] a+a[2+2]), q.keys
+    end
+
+    def assert_query(expected, actual)
+      expected.gsub! /\[|\]/, "[" => "%5B", "]" => "%5D"
+      assert_equal expected, actual
+    end
+  end
+end