s3 0.2.0

data/lib/stree/service.rb

@@ -0,0 +1,110 @@
+module Stree
+  class Service
+    include Parser
+    extend Roxy::Moxie
+
+    attr_reader :access_key_id, :secret_access_key, :use_ssl
+
+    # Compares service to other, by access_key_id and secret_access_key
+    def ==(other)
+      self.access_key_id == other.access_key_id and self.secret_access_key == other.secret_access_key
+    end
+
+    # ==== Parameters:
+    # +options+:: a hash of options described below
+    #
+    # ==== Options:
+    # +access_key_id+:: Amazon access key id, required
+    # +secret_access_key+:: Amazon secret access key, required
+    # +use_ssl+:: true if use ssl in connection, otherwise false
+    # +timeout+:: parameter for Net::HTTP module
+    # +debug+:: prints the raw requests to STDOUT
+    def initialize(options)
+      @access_key_id = options[:access_key_id] or raise ArgumentError, "No access key id given"
+      @secret_access_key = options[:secret_access_key] or raise ArgumentError, "No secret access key given"
+      @use_ssl = options[:use_ssl]
+      @timeout = options[:timeout]
+      @debug = options[:debug]
+    end
+
+    # Returns all buckets in the service and caches the result (see reload)
+    def buckets(reload = false)
+      if reload or @buckets.nil?
+        @buckets = list_all_my_buckets
+      else
+        @buckets
+      end
+    end
+
+    # Returns "http://" or "https://", depends on use_ssl value from initializer
+    def protocol
+      use_ssl ? "https://" : "http://"
+    end
+
+    # Return 443 or 80, depends on use_ssl value from initializer
+    def port
+      use_ssl ? 443 : 80
+    end
+
+    proxy :buckets do
+      # Builds new bucket with given name
+      def build(name)
+        Bucket.send(:new, proxy_owner, name)
+      end
+
+      # Finds the bucket with given name
+      def find_first(name)
+        bucket = build(name)
+        bucket.retrieve
+      end
+      alias :find :find_first
+
+      # Find all buckets in the service
+      def find_all
+        proxy_target
+      end
+
+      # Reloads the bucket list (clears the cache)
+      def reload
+        proxy_owner.buckets(true)
+      end
+
+      # Destroy all buckets in the service. Doesn't destroy non-empty
+      # buckets by default, pass true to force destroy (USE WITH
+      # CARE!).
+      def destroy_all(force = false)
+        proxy_target.each do |bucket|
+          bucket.destroy(force)
+        end
+      end
+    end
+
+    def inspect #:nodoc:
+      "#<#{self.class}:#@access_key_id>"
+    end
+
+    private
+
+    def list_all_my_buckets
+      response = service_request(:get)
+      names = parse_list_all_my_buckets_result(response.body)
+      names.map { |name| Bucket.send(:new, self, name) }
+    end
+
+    def service_request(method, options = {})
+      connection.request(method, options.merge(:path => "/#{options[:path]}"))
+    end
+
+    def connection
+      if @connection.nil?
+        @connection = Connection.new
+        @connection.access_key_id = @access_key_id
+        @connection.secret_access_key = @secret_access_key
+        @connection.use_ssl = @use_ssl
+        @connection.timeout = @timeout
+        @connection.debug = @debug
+      end
+      @connection
+    end
+  end
+end

data/lib/stree/signature.rb

@@ -0,0 +1,157 @@
+module Stree
+
+  # Class responsible for generating signatures to requests.
+  #
+  # Implements algorithm defined by Amazon Web Services to sign
+  # request with secret private credentials
+  #
+  # === See:
+  # http://docs.amazonwebservices.com/AmazonS3/latest/index.html?RESTAuthentication.html
+
+  class Signature
+
+    # Generates signature for given parameters
+    #
+    # ==== Parameters:
+    # +options+: a hash that contains options listed below
+    #
+    # ==== Options:
+    # +host+: hostname
+    # +request+: Net::HTTPRequest object with correct headers
+    # +access_key_id+: access key id
+    # +secret_access_key+: secret access key
+    #
+    # ==== Returns:
+    # Generated signature for given hostname and request
+    def self.generate(options)
+      request = options[:request]
+      host = options[:host]
+      access_key_id = options[:access_key_id]
+      secret_access_key = options[:secret_access_key]
+
+      http_verb = request.method
+      content_md5 = request["content-md5"] || ""
+      content_type = request["content-type"] || ""
+      date = request["x-amz-date"].nil? ? request["date"] : ""
+      canonicalized_resource = canonicalized_resource(host, request)
+      canonicalized_amz_headers = canonicalized_amz_headers(request)
+
+      string_to_sign = ""
+      string_to_sign << http_verb
+      string_to_sign << "\n"
+      string_to_sign << content_md5
+      string_to_sign << "\n"
+      string_to_sign << content_type
+      string_to_sign << "\n"
+      string_to_sign << date
+      string_to_sign << "\n"
+      string_to_sign << canonicalized_amz_headers
+      string_to_sign << canonicalized_resource
+
+      digest = OpenSSL::Digest::Digest.new('sha1')
+      hmac = OpenSSL::HMAC.digest(digest, secret_access_key, string_to_sign)
+      base64 = Base64.encode64(hmac)
+      signature = base64.chomp
+
+      "AWS #{access_key_id}:#{signature}"
+    end
+
+    private
+
+    # Helper method for extracting header fields from Net::HTTPRequest and
+    # preparing them for singing in #generate method
+    #
+    # ==== Parameters:
+    # +request+: Net::HTTPRequest object with header fields filled in
+    #
+    # ==== Returns:
+    # String containing interesting header fields in suitable order and form
+    def self.canonicalized_amz_headers(request)
+      headers = []
+
+      # 1. Convert each HTTP header name to lower-case. For example,
+      # 'X-Amz-Date' becomes 'x-amz-date'.
+      request.each { |key, value| headers << [key.downcase, value] if key =~ /\Ax-amz-/io }
+      #=> [["c", 0], ["a", 1], ["a", 2], ["b", 3]]
+
+      # 2. Sort the collection of headers lexicographically by header
+      # name.
+      headers.sort!
+      #=> [["a", 1], ["a", 2], ["b", 3], ["c", 0]]
+
+      # 3. Combine header fields with the same name into one
+      # "header-name:comma-separated-value-list" pair as prescribed by
+      # RFC 2616, section 4.2, without any white-space between
+      # values. For example, the two metadata headers
+      # 'x-amz-meta-username: fred' and 'x-amz-meta-username: barney'
+      # would be combined into the single header 'x-amz-meta-username:
+      # fred,barney'.
+      groupped_headers = headers.group_by { |i| i.first }
+      #=> {"a"=>[["a", 1], ["a", 2]], "b"=>[["b", 3]], "c"=>[["c", 0]]}
+      combined_headers = groupped_headers.map do |key, value|
+        values = value.map { |e| e.last }
+        [key, values.join(",")]
+      end
+      #=> [["a", "1,2"], ["b", "3"], ["c", "0"]]
+
+      # 4. "Un-fold" long headers that span multiple lines (as allowed
+      # by RFC 2616, section 4.2) by replacing the folding white-space
+      # (including new-line) by a single space.
+      unfolded_headers = combined_headers.map do |header|
+        key = header.first
+        value = header.last
+        value.gsub!(/\s+/, " ")
+        [key, value]
+      end
+
+      # 5. Trim any white-space around the colon in the header. For
+      # example, the header 'x-amz-meta-username: fred,barney' would
+      # become 'x-amz-meta-username:fred,barney'
+      joined_headers = unfolded_headers.map do |header|
+        key = header.first.strip
+        value = header.last.strip
+        "#{key}:#{value}"
+      end
+
+      # 6. Finally, append a new-line (U+000A) to each canonicalized
+      # header in the resulting list. Construct the
+      # CanonicalizedResource element by concatenating all headers in
+      # this list into a single string.
+      joined_headers << "" unless joined_headers.empty?
+      joined_headers.join("\n")
+    end
+
+    # Helper methods for extracting caninocalized resource address
+    #
+    # ==== Parameters:
+    # +host+: hostname
+    # +request+: Net::HTTPRequest object with headers filealds filled in
+    #
+    # ==== Returns:
+    # String containing extracted canonicalized resource
+    def self.canonicalized_resource(host, request)
+      # 1. Start with the empty string ("").
+      string = ""
+
+      # 2. If the request specifies a bucket using the HTTP Host
+      # header (virtual hosted-style), append the bucket name preceded
+      # by a "/" (e.g., "/bucketname"). For path-style requests and
+      # requests that don't address a bucket, do nothing. For more
+      # information on virtual hosted-style requests, see Virtual
+      # Hosting of Buckets.
+      bucket_name = host.sub(/\.?s3\.amazonaws\.com\Z/, "")
+      string << "/#{bucket_name}" unless bucket_name.empty?
+
+      # 3. Append the path part of the un-decoded HTTP Request-URI,
+      # up-to but not including the query string.
+      uri = URI.parse(request.path)
+      string << uri.path
+
+      # 4. If the request addresses a sub-resource, like ?location,
+      # ?acl, or ?torrent, append the sub-resource including question
+      # mark.
+      string << "?#{$1}" if uri.query =~ /&?(acl|torrent|logging|location)(?:&|=|\Z)/
+      string
+    end
+  end
+end

data/lib/stree.rb

@@ -0,0 +1,24 @@
+require "base64"
+require "digest/md5"
+require "forwardable"
+require "net/http"
+require "net/https"
+require "openssl"
+require "rexml/document"
+require "time"
+
+require "stree/roxy/moxie"
+require "stree/roxy/proxy"
+
+require "stree/parser"
+require "stree/bucket"
+require "stree/connection"
+require "stree/exceptions"
+require "stree/object"
+require "stree/service"
+require "stree/signature"
+
+module Stree
+  # Default (and only) host serving S3 stuff
+  HOST = "s3.amazonaws.com"
+end

data/test/bucket_test.rb

@@ -0,0 +1,231 @@
+require 'test_helper'
+
+class BucketTest < Test::Unit::TestCase
+  def setup
+    @bucket_vhost = Stree::Bucket.new(nil, "data-bucket")
+    @bucket_path = Stree::Bucket.new(nil, "data_bucket")
+    @bucket = @bucket_vhost
+
+    @response_location = Net::HTTPOK.new("1.1", "200", "OK")
+    stub(@response_location).body { @bucket_location_body }
+    @bucket_location = "EU"
+    @bucket_location_body = <<-EOLocation
+    <?xml version="1.0" encoding="UTF-8"?>\n<LocationConstraint xmlns="http://s3.amazonaws.com/doc/2006-03-01/">EU</LocationConstraint>
+    EOLocation
+
+    @reponse_owned_by_you = Net::HTTPConflict.new("1.1", "409", "Conflict")
+    stub(@reponse_owned_by_you).body { @bucket_owned_by_you_body }
+    @bucket_owned_by_you_body = <<-EOOwnedByYou
+    <?xml version="1.0" encoding="UTF-8"?>\n<Error> <Code>BucketAlreadyOwnedByYou</Code> <Message>Your previous request to create the named bucket succeeded and you already own it.</Message> <BucketName>bucket</BucketName> <RequestId>117D08EA0EC6E860</RequestId> <HostId>4VpMSvmJ+G5+DLtVox6O5cZNgdPlYcjCu3l0n4HjDe01vPxxuk5eTAtcAkUynRyV</HostId> </Error>
+    EOOwnedByYou
+
+    @reponse_already_exists = Net::HTTPConflict.new("1.1", "409", "Conflict")
+    stub(@response_already_exists).body { @bucket_already_exists_body }
+    @bucket_already_exists_body = <<-EOAlreadyExists
+    <?xml version="1.0" encoding="UTF-8"?>\n<Error> <Code>BucketAlreadyExists</Code> <Message>The requested bucket name is not available. The bucket namespace is shared by all users of the system. Please select a different name and try again.</Message> <BucketName>bucket</BucketName> <RequestId>4C154D32807C92BD</RequestId> <HostId>/xyHQgXcUXTZQhoO+NUBzbaxbFrIhKlyuaRHFnmcId0bMePvY9Zwg+dyk2LYE4g5</HostId> </Error>
+    EOAlreadyExists
+
+    @objects_list_empty = []
+    @objects_list = [
+      Stree::Object.new(@bucket, "obj1"),
+      Stree::Object.new(@bucket, "obj2")
+    ]
+
+    @response_objects_list_empty = Net::HTTPOK.new("1.1", "200", "OK")
+    stub(@response_objects_list_empty).body { @response_objects_list_empty_body }
+    @response_objects_list_empty_body = <<-EOEmpty
+    <?xml version="1.0" encoding="UTF-8"?>\n<ListBucketResult xmlns="http://s3.amazonaws.com/doc/2006-03-01/"> <Name>bucket</Name> <Prefix></Prefix> <Marker></Marker> <MaxKeys>1000</MaxKeys> <IsTruncated>false</IsTruncated> </ListBucketResult>
+    EOEmpty
+
+    @response_objects_list = Net::HTTPOK.new("1.1", "200", "OK")
+    stub(@response_objects_list).body { @response_objects_list_body }
+    @response_objects_list_body = <<-EOObjects
+    <?xml version="1.0" encoding="UTF-8"?>\n<ListBucketResult xmlns="http://s3.amazonaws.com/doc/2006-03-01/"> <Name>bucket</Name> <Prefix></Prefix> <Marker></Marker> <MaxKeys>1000</MaxKeys> <IsTruncated>false</IsTruncated> <Contents> <Key>obj1</Key> <LastModified>2009-07-03T10:17:33.000Z</LastModified> <ETag>&quot;99519cdf14c255e580e1b7bca85a458c&quot;</ETag> <Size>1729</Size> <Owner> <ID>df864aeb6f42be43f1d9e60aaabe3f15e245b035a4b79d1cfe36c4deaec67205</ID> <DisplayName>owner</DisplayName> </Owner> <StorageClass>STANDARD</StorageClass> </Contents> <Contents> <Key>obj2</Key> <LastModified>2009-07-03T11:17:33.000Z</LastModified> <ETag>&quot;99519cdf14c255e586e1b12bca85a458c&quot;</ETag> <Size>179</Size> <Owner> <ID>df864aeb6f42be43f1d9e60aaabe3f17e247b037a4b79d1cfe36c4deaec67205</ID> <DisplayName>owner</DisplayName> </Owner> <StorageClass>STANDARD</StorageClass> </Contents> </ListBucketResult>
+    EOObjects
+  end
+
+  def test_name_valid
+    assert_raise ArgumentError do Stree::Bucket.new(nil, "") end # should not be valid with empty name
+    assert_raise ArgumentError do Stree::Bucket.new(nil, "10.0.0.1") end # should not be valid with IP as name
+    assert_raise ArgumentError do Stree::Bucket.new(nil, "as") end # should not be valid with name shorter than 3 characters
+    assert_raise ArgumentError do Stree::Bucket.new(nil, "a"*256) end # should not be valid with name longer than 255 characters
+    assert_raise ArgumentError do Stree::Bucket.new(nil, ".asdf") end # should not allow special characters as first character
+    assert_raise ArgumentError do Stree::Bucket.new(nil, "-asdf") end # should not allow special characters as first character
+    assert_raise ArgumentError do Stree::Bucket.new(nil, "_asdf") end # should not allow special characters as first character
+
+    assert_nothing_raised do
+      Stree::Bucket.new(nil, "a-a-")
+      Stree::Bucket.new(nil, "a.a.")
+      Stree::Bucket.new(nil, "a_a_")
+    end
+  end
+
+  def test_path_prefix
+    expected = ""
+    actual = @bucket_vhost.path_prefix
+    assert_equal expected, actual
+
+    expected = "data_bucket/"
+    actual = @bucket_path.path_prefix
+    assert_equal expected, actual
+  end
+
+  def test_host
+    expected = "data-bucket.s3.amazonaws.com"
+    actual = @bucket_vhost.host
+    assert_equal expected, actual
+
+    expected = "s3.amazonaws.com"
+    actual = @bucket_path.host
+    assert_equal expected, actual
+  end
+
+  def test_vhost
+    assert @bucket_vhost.vhost?
+    assert ! @bucket_path.vhost?
+  end
+
+  def test_exists
+    mock(@bucket).retrieve { @bucket_vhost }
+    assert @bucket.exists?
+
+    mock(@bucket).retrieve { raise Stree::Error::NoSuchBucket.new(nil, nil) }
+    assert ! @bucket.exists?
+  end
+
+  def test_location_and_parse_location
+    mock(@bucket).bucket_request(:get, {:params=>{:location=>nil}}) { @response_location }
+
+    expected = @bucket_location
+    actual = @bucket.location
+    assert_equal expected, actual
+
+    stub(@bucket).bucket_request(:get, {:params=>{:location=>nil}}) { flunk "should deliver from cached result" }
+    actual = @bucket.location
+    assert_equal expected, actual
+  end
+
+  def test_save
+    mock(@bucket).bucket_request(:put, {:headers=>{}}) { }
+    assert @bucket.save
+    # mock ensures that bucket_request was called
+  end
+
+  def test_save_failure_owned_by_you
+    mock(@bucket).bucket_request(:put, {:headers=>{}}) { raise Stree::Error::BucketAlreadyOwnedByYou.new(409, @response_owned_by_you) }
+    assert_raise Stree::Error::BucketAlreadyOwnedByYou do
+      @bucket.save
+    end
+
+    mock(@bucket).bucket_request(:put, {:headers=>{}}) { raise Stree::Error::BucketAlreadyExists.new(409, @response_already_exists) }
+    assert_raise Stree::Error::BucketAlreadyExists do
+      @bucket.save
+    end
+  end
+
+  def test_objects
+    mock(@bucket).fetch_objects { @objects_list_empty }
+    expected = @objects_list_empty
+    actual = @bucket.objects
+    assert_equal expected, actual
+
+    stub(@bucket).fetch_objects { flunk "should load objects from cache" }
+    actual = @bucket.objects
+    assert_equal expected, actual
+
+    stub(@bucket).fetch_objects { @objects_list }
+
+    expected = @objects_list
+    actual = @bucket.objects(true)
+    assert_equal expected, actual
+  end
+
+  def test_fetch_objects_and_parse_objects
+    mock(@bucket).bucket_request(:get, :test=>true) { @response_objects_list_empty }
+    expected = @objects_list_empty
+    actual = @bucket.objects.find_all(:test => true)
+    assert_equal expected, actual
+
+    mock(@bucket).bucket_request(:get, :test=>true) { @response_objects_list }
+    expected = @objects_list
+    actual = @bucket.objects.find_all(:test => true)
+    assert_equal expected, actual
+  end
+
+  def test_destroy
+    mock(@bucket).bucket_request(:delete) { }
+    assert @bucket.destroy
+  end
+
+  def test_objects_build
+    stub(@bucket).bucket_request { flunk "should not connect to server" }
+
+    expected = "object_name"
+    actual = @bucket.objects.build("object_name")
+    assert_kind_of Stree::Object, actual
+    assert_equal expected, actual.key
+  end
+
+  def test_objects_find_first
+    assert_nothing_raised do
+      stub.instance_of(Stree::Object).retrieve { Stree::Object.new(nil, "obj2") }
+      expected = "obj2"
+      actual = @bucket.objects.find_first("obj2")
+      assert_equal "obj2", actual.key
+    end
+  end
+
+  def test_objects_find_first_fail
+    assert_raise Stree::Error::NoSuchKey do
+      stub.instance_of(Stree::Object).retrieve { raise Stree::Error::NoSuchKey.new(404, nil) }
+      @bucket.objects.find_first("obj3")
+    end
+  end
+
+  def test_objects_find_all_on_empty_list
+    stub(@bucket).fetch_objects { @objects_list_empty }
+    assert_nothing_raised do
+      expected = @objects_list_empty
+      actual = @bucket.objects.find_all
+      assert_equal expected, actual
+    end
+  end
+
+  def test_objects_find_all
+    stub(@bucket).fetch_objects { @objects_list }
+    assert_nothing_raised do
+      expected = @objects_list
+      actual = @bucket.objects.find_all
+      assert_equal expected, actual
+    end
+  end
+
+  def test_objects_reload
+    stub(@bucket).fetch_objects { @objects_list_empty }
+    expected = @objects_list_empty
+    actual = @bucket.objects
+    assert_equal expected, actual
+
+    stub(@bucket).fetch_objects { @objects_list }
+    expected = @objects_list_empty
+    actual = @bucket.objects
+    assert_equal expected, actual
+
+    assert @bucket.objects.reload
+
+    expected = @objects_list
+    actual = @bucket.objects
+    assert_equal expected, actual
+  end
+
+  def test_objects_destroy_all
+    @counter = 0
+    stub(@bucket).fetch_objects { @objects_list }
+    @bucket.objects.each do |obj|
+      mock(obj).destroy { @counter += 1 }
+    end
+
+    @bucket.objects.destroy_all
+    assert_equal @objects_list.length, @counter
+  end
+end

data/test/connection_test.rb

@@ -0,0 +1,164 @@
+require 'test_helper'
+
+class ConnectionTest < Test::Unit::TestCase
+  def setup
+    @connection = Stree::Connection.new(
+      :access_key_id =>  "12345678901234567890",
+      :secret_access_key =>  "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDF"
+    )
+    @http_request = Net::HTTP.new("")
+    @response_ok = Net::HTTPOK.new("1.1", "200", "OK")
+    @response_not_found = Net::HTTPNotFound.new("1.1", "404", "Not Found")
+    stub(@connection).http { @http_request }
+    stub(@http_request).start { @response_ok }
+  end
+
+  def test_handle_response_not_modify_response_when_ok
+    assert_nothing_raised do
+      response = @connection.request(
+        :get,
+        :host => "s3.amazonaws.com",
+        :path => "/"
+      )
+      assert_equal @response_ok, response
+    end
+  end
+
+  def test_handle_response_throws_exception_when_not_ok
+    response_body = <<-EOFakeBody
+    <?xml version=\"1.0\" encoding=\"UTF-8\"?>
+    <SomeResult xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">
+      <Code>NoSuchBucket</Code>
+      <Message>The specified bucket does not exist</Message>
+    </SomeResult>
+    EOFakeBody
+    stub(@http_request).start { @response_not_found }
+    stub(@response_not_found).body { response_body }
+
+    assert_raise Stree::Error::NoSuchBucket do
+      response = @connection.request(
+        :get,
+        :host => "data.example.com.s3.amazonaws.com",
+        :path => "/"
+      )
+    end
+  end
+
+  def test_handle_response_throws_standard_exception_when_not_ok
+    stub(@http_request).start { @response_not_found }
+    stub(@response_not_found).body { nil }
+    assert_raise Stree::Error::ResponseError do
+      response = @connection.request(
+        :get,
+        :host => "data.example.com.s3.amazonaws.com",
+        :path => "/"
+      )
+    end
+
+    stub(@response_not_found).body { "" }
+    assert_raise Stree::Error::ResponseError do
+      response = @connection.request(
+        :get,
+        :host => "data.example.com.s3.amazonaws.com",
+        :path => "/"
+      )
+    end
+  end
+
+  def test_parse_params_empty
+    expected = ""
+    actual = Stree::Connection.parse_params({})
+    assert_equal expected, actual
+  end
+
+  def test_parse_params_only_interesting_params
+    expected = ""
+    actual = Stree::Connection.parse_params(:param1 => "1", :maxkeys => "2")
+    assert_equal expected, actual
+  end
+
+  def test_parse_params_remove_underscore
+    expected = "max-keys=100"
+    actual = Stree::Connection.parse_params(:max_keys => 100)
+    assert_equal expected, actual
+  end
+
+  def test_parse_params_with_and_without_values
+    expected = "max-keys=100&prefix"
+    actual = Stree::Connection.parse_params(:max_keys => 100, :prefix => nil)
+    assert_equal expected, actual
+  end
+
+  def test_headers_headers_empty
+    expected = {}
+    actual = Stree::Connection.parse_headers({})
+    assert_equal expected, actual
+  end
+
+  def test_parse_headers_only_interesting_headers
+    expected = {}
+    actual = Stree::Connection.parse_headers(
+      :accept => "text/*, text/html, text/html;level=1, */*",
+      :accept_charset => "iso-8859-2, unicode-1-1;q=0.8"
+    )
+    assert_equal expected, actual
+  end
+
+  def test_parse_headers_remove_underscore
+    expected = {
+      "content-type" => nil,
+      "x-amz-acl" => nil,
+      "if-modified-since" => nil,
+      "if-unmodified-since" => nil,
+      "if-match" => nil,
+      "if-none-match" => nil,
+      "content-disposition" => nil,
+      "content-encoding" => nil
+    }
+    actual = Stree::Connection.parse_headers(
+      :content_type => nil,
+      :x_amz_acl => nil,
+      :if_modified_since => nil,
+      :if_unmodified_since => nil,
+      :if_match => nil,
+      :if_none_match => nil,
+      :content_disposition => nil,
+      :content_encoding => nil
+    )
+    assert_equal expected, actual
+  end
+
+  def test_parse_headers_with_values
+    expected = {
+      "content-type" => "text/html",
+      "x-amz-acl" => "public-read",
+      "if-modified-since" => "today",
+      "if-unmodified-since" => "tomorrow",
+      "if-match" => "1234",
+      "if-none-match" => "1243",
+      "content-disposition" => "inline",
+      "content-encoding" => "gzip"
+    }
+    actual = Stree::Connection.parse_headers(
+      :content_type => "text/html",
+      :x_amz_acl => "public-read",
+      :if_modified_since => "today",
+      :if_unmodified_since => "tomorrow",
+      :if_match => "1234",
+      :if_none_match => "1243",
+      :content_disposition => "inline",
+      :content_encoding => "gzip"
+    )
+    assert_equal expected, actual
+  end
+
+  def test_parse_headers_with_range
+    expected = {
+      "range" => "bytes=0-100"
+    }
+    actual = Stree::Connection.parse_headers(
+      :range => 0..100
+    )
+    assert_equal expected, actual
+  end
+end