azure 0.6.4 → 0.7.0.pre

data/test/unit/affinity_group/serialization_test.rb

@@ -17,7 +17,7 @@ require 'test_helper'
 describe Azure::BaseManagement::Serialization do
 
   subject { Azure::BaseManagement::Serialization }
-  let(:location) { 'West Us' }
+  let(:geo_location) { 'West Us' }
 
   describe '#affinity_group_to_xml' do
     let(:affinity_group_name) { 'AG1' }
@@ -25,26 +25,26 @@ describe Azure::BaseManagement::Serialization do
 
     it 'serializes the argument to xml' do
       result = subject.affinity_group_to_xml(affinity_group_name,
-                                             location,
+                                             geo_location,
                                              label)
       doc = Nokogiri::XML result
       doc.css('Name').text.must_equal affinity_group_name
       doc.css('Label').text.must_equal Base64.encode64(label).strip
-      doc.css('Location').text.must_equal location
+      doc.css('Location').text.must_equal geo_location
       result.must_be_kind_of String
     end
 
     it 'serializes the argument to xml when optional description is given' do
-      options = { description: 'Affinity Group Description' }
+      options = {description: 'Affinity Group Description'}
       result = subject.affinity_group_to_xml(affinity_group_name,
-                                             location,
+                                             geo_location,
                                              label,
                                              options)
       doc = Nokogiri::XML result
       doc.css('Name').text.must_equal affinity_group_name
       doc.css('Label').text.must_equal Base64.encode64(label).strip
       doc.css('Description').text.must_equal options[:description]
-      doc.css('Location').text.must_equal location
+      doc.css('Location').text.must_equal geo_location
       result.must_be_kind_of String
     end
   end
@@ -81,8 +81,7 @@ describe Azure::BaseManagement::Serialization do
       affinity_group.storage_services.size.must_equal 1
       affinity_group.capability.must_equal %w[PersistentVMRole HighMemory]
       affinity_group.name.must_equal affinity_group_xml.css('Name').text
-      affinity_group.description.must_equal affinity_group_xml.css(
-        'Description').text
+      affinity_group.description.must_equal affinity_group_xml.css('Description').text
     end
   end
 end

data/test/unit/base_management/location_test.rb

@@ -23,7 +23,6 @@ describe Azure::BaseManagement::Location do
   describe "#list_locations" do
     let(:request_path) { '/locations' }
     let(:locations_xml) { Fixtures['list_locations'] }
-    let(:method) { :get }
     let(:mock_request){ mock() }
     let(:response) {
       response = mock()
@@ -33,7 +32,7 @@ describe Azure::BaseManagement::Location do
     let(:response_body) { Nokogiri::XML response.body }
 
     before {
-      ManagementHttpRequest.stubs(:new).with(method, request_path, nil).returns(mock_request)
+      Azure::BaseManagement::ManagementHttpRequest.stubs(:new).with(:get, request_path, nil).returns(mock_request)
       mock_request.expects(:call).returns(response_body)
     }
 

data/test/unit/blob/auth/shared_access_signature_test.rb

@@ -0,0 +1,71 @@
+#-------------------------------------------------------------------------
+# # Copyright (c) Microsoft and contributors. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#--------------------------------------------------------------------------
+require "test_helper"
+require "azure/blob/auth/shared_access_signature"
+require "base64"
+require "uri"
+
+describe Azure::Blob::Auth::SharedAccessSignature do
+  let(:path) { 'example/path' }
+  let(:options) {
+    {
+      permissions:         'rwd',
+      expiry:              '2013-12-11',
+      resource:            'b',
+      version:             '2013-08-15',
+      content_disposition: 'inline, filename=nyan.cat'
+    }
+  }
+  let(:access_account_name) { 'account-name' }
+  let(:access_key_base64) { Base64.strict_encode64('access-key') }
+
+  subject { Azure::Blob::Auth::SharedAccessSignature.new(path, options, access_account_name, access_key_base64) }
+
+  it "decodes the base64 encoded access_key" do
+    subject.access_key.must_equal 'access-key'
+  end
+
+  describe "#signable_string" do
+
+    it "constructs a string in the required format" do
+      subject.signable_string.must_equal(
+        "rwd\n\n2013-12-11\n/account-name/example/path\n\n2013-08-15\n\ninline, filename=nyan.cat\n\n\n"
+      )
+    end
+  end
+
+  describe "#canonicalized_resource" do
+    it "prefixes and concatenates account name and resource path with forward slashes" do
+      subject.canonicalized_resource.must_equal '/account-name/example/path'
+    end
+  end
+
+  describe "#signed_uri" do
+    let(:uri) { URI(subject.signed_uri) }
+    let(:query_hash) { Hash[URI.decode_www_form(uri.query)] }
+
+    it "maps options to the abbreviated API versions" do
+      query_hash['sp'].must_equal 'rwd'
+      query_hash['se'].must_equal '2013-12-11'
+      query_hash['sr'].must_equal 'b'
+      query_hash['rscd'].must_equal 'inline, filename=nyan.cat'
+    end
+
+    it "includes the signature" do
+      query_hash['sig'].must_equal subject.sign(subject.signable_string)
+    end
+
+  end
+end

data/test/unit/blob/blob_service_test.rb

@@ -20,30 +20,30 @@ require 'azure/blob/blob'
 require 'azure/service/signed_identifier'
 
 describe Azure::Blob::BlobService do
-  
+
   subject { Azure::Blob::BlobService.new }
   let(:serialization) { Azure::Blob::Serialization }
   let(:uri) { URI.parse "http://foo.com" }
   let(:query) { {} }
-  let(:request_headers) { {} }
+  let(:request_headers) { {'x-ms-version' => '2013-08-15'} }
   let(:request_body) { "request-body" }
 
   let(:response_headers) { {} }
   let(:response_body) { mock() }
   let(:response) { mock() }
 
-  before { 
+  before {
     response.stubs(:body).returns(response_body)
     response.stubs(:headers).returns(response_headers)
   }
 
   describe "#list_containers" do
-    let(:method) { :get }
+    let(:verb) { :get }
     let(:container_enumeration_result) { Azure::Service::EnumerationResults.new }
 
-    before { 
+    before {
       subject.stubs(:containers_uri).with({}).returns(uri)
-      subject.stubs(:call).with(method, uri).returns(response)
+      subject.stubs(:call).with(verb, uri).returns(response)
       serialization.stubs(:container_enumeration_results_from_xml).with(response_body).returns(container_enumeration_result)
     }
 
@@ -53,7 +53,7 @@ describe Azure::Blob::BlobService do
     end
 
     it "calls StorageService#call with the prepared request" do
-      subject.expects(:call).with(method, uri).returns(response)
+      subject.expects(:call).with(verb, uri).returns(response)
       subject.list_containers
     end
 
@@ -74,48 +74,48 @@ describe Azure::Blob::BlobService do
       }
 
       it "modifies the URI query parameters when provided a :prefix value" do
-        query = { "prefix" => "pre" }
+        query = {"prefix" => "pre"}
         subject.expects(:containers_uri).with(query).returns(uri)
 
-        options = { :prefix => "pre" }
+        options = {:prefix => "pre"}
         subject.list_containers options
       end
-      
+
       it "modifies the URI query parameters when provided a :marker value" do
-        query = { "marker" => "mark" }
+        query = {"marker" => "mark"}
         subject.expects(:containers_uri).with(query).returns(uri)
 
-        options = { :marker => "mark" }
+        options = {:marker => "mark"}
         subject.list_containers options
       end
-      
+
       it "modifies the URI query parameters when provided a :max_results value" do
-        query = { "maxresults" => "5" }
+        query = {"maxresults" => "5"}
         subject.expects(:containers_uri).with(query).returns(uri)
 
-        options = { :max_results => 5 }
+        options = {:max_results => 5}
         subject.list_containers options
       end
-      
+
       it "modifies the URI query parameters when provided a :metadata value" do
-        query = { "include" => "metadata" }
+        query = {"include" => "metadata"}
         subject.expects(:containers_uri).with(query).returns(uri)
 
-        options = { :metadata => true }
+        options = {:metadata => true}
         subject.list_containers options
       end
 
       it "modifies the URI query parameters when provided a :timeout value" do
-        query = { "timeout" => "37" }
+        query = {"timeout" => "37"}
         subject.expects(:containers_uri).with(query).returns(uri)
 
-        options = { :timeout => 37 }
+        options = {:timeout => 37}
         subject.list_containers options
       end
       it "does not modify the URI query parameters when provided an unknown value" do
         subject.expects(:containers_uri).with({}).returns(uri)
 
-        options = { :unknown_key => "some_value" }
+        options = {:unknown_key => "some_value"}
         subject.list_containers options
       end
     end
@@ -127,10 +127,10 @@ describe Azure::Blob::BlobService do
 
     describe "#create_container" do
 
-      let(:method) { :put }
-      before { 
+      let(:verb) { :put }
+      before {
         subject.stubs(:container_uri).with(container_name, {}).returns(uri)
-        subject.stubs(:call).with(method, uri, nil, {}).returns(response)
+        subject.stubs(:call).with(verb, uri, nil, request_headers).returns(response)
         serialization.stubs(:container_from_headers).with(response_headers).returns(container)
       }
 
@@ -140,7 +140,7 @@ describe Azure::Blob::BlobService do
       end
 
       it "calls StorageService#call with the prepared request" do
-        subject.expects(:call).with(method, uri, nil, {}).returns(response)
+        subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
         subject.create_container container_name
       end
 
@@ -158,21 +158,21 @@ describe Azure::Blob::BlobService do
 
       describe "when optional metadata parameter is used" do
         let(:container_metadata) {
-          { 
-            "MetadataKey" => "MetaDataValue",
-            "MetadataKey1" => "MetaDataValue1" }
-          }
+          {
+              'MetadataKey' => 'MetaDataValue',
+              'MetadataKey1' => 'MetaDataValue1'}
+        }
 
-        before { 
+        before do
           request_headers = {
-            "x-ms-meta-MetadataKey" => "MetaDataValue",
-            "x-ms-meta-MetadataKey1" => "MetaDataValue1"
+              'x-ms-meta-MetadataKey' => 'MetaDataValue',
+              'x-ms-meta-MetadataKey1' => 'MetaDataValue1',
+              'x-ms-version' => '2013-08-15'
           }
-
           subject.stubs(:container_uri).with(container_name, {}).returns(uri)
           serialization.stubs(:container_from_headers).with(response_headers).returns(container)
-          subject.stubs(:call).with(method, uri, nil, request_headers).returns(response)
-        }
+          subject.stubs(:call).with(verb, uri, nil, request_headers).returns(response)
+        end
 
         it "adds metadata to the request headers" do
           subject.create_container container_name, container_metadata
@@ -182,35 +182,35 @@ describe Azure::Blob::BlobService do
       describe "when optional public_access_level parameter is used" do
         let(:public_access_level) { "public-access-level-value" }
 
-        before { 
-          request_headers = { "x-ms-blob-public-access" => public_access_level }
+        before {
+          request_headers = {"x-ms-blob-public-access" => public_access_level, 'x-ms-version' => '2013-08-15'}
 
           subject.stubs(:container_uri).with(container_name, {}).returns(uri)
           serialization.stubs(:container_from_headers).with(response_headers).returns(container)
-          subject.stubs(:call).with(method, uri, nil, request_headers).returns(response)
+          subject.stubs(:call).with(verb, uri, nil, request_headers).returns(response)
         }
 
         it "adds public_access_level to the request headers" do
-          subject.create_container container_name, { :public_access_level => public_access_level }
+          subject.create_container container_name, {:public_access_level => public_access_level}
         end
       end
     end
 
-    describe "#delete_container" do 
-      let(:method) { :delete }
+    describe "#delete_container" do
+      let(:verb) { :delete }
       before {
         response.stubs(:success?).returns(true)
         subject.stubs(:container_uri).with(container_name, {}).returns(uri)
-        subject.stubs(:call).with(method, uri).returns(response)
+        subject.stubs(:call).with(verb, uri).returns(response)
       }
-      
+
       it "assembles a URI for the request" do
         subject.expects(:container_uri).with(container_name, {}).returns(uri)
         subject.delete_container container_name
       end
 
       it "calls StorageService#call with the prepared request" do
-        subject.expects(:call).with(method, uri).returns(response)
+        subject.expects(:call).with(verb, uri).returns(response)
         subject.delete_container container_name
       end
 
@@ -221,14 +221,14 @@ describe Azure::Blob::BlobService do
     end
 
     describe "#get_container_properties" do
-      let(:method) { :get }
+      let(:verb) { :get }
       let(:container_properties) { {} }
 
       before {
         container.properties = container_properties
         response_headers = {}
         subject.stubs(:container_uri).with(container_name, {}).returns(uri)
-        subject.stubs(:call).with(method, uri).returns(response)
+        subject.stubs(:call).with(verb, uri).returns(response)
         serialization.stubs(:container_from_headers).with(response_headers).returns(container)
       }
 
@@ -238,7 +238,7 @@ describe Azure::Blob::BlobService do
       end
 
       it "calls StorageService#call with the prepared request" do
-        subject.expects(:call).with(method, uri).returns(response)
+        subject.expects(:call).with(verb, uri).returns(response)
         subject.get_container_properties container_name
       end
 
@@ -256,15 +256,15 @@ describe Azure::Blob::BlobService do
     end
 
     describe "#get_container_metadata" do
-      let(:method) { :get }
-      let(:container_metadata) { { "MetadataKey" => "MetaDataValue", "MetadataKey1" => "MetaDataValue1" } }
-      let(:response_headers) { { "x-ms-meta-MetadataKey" => "MetaDataValue", "x-ms-meta-MetadataKey1" => "MetaDataValue1" } }
+      let(:verb) { :get }
+      let(:container_metadata) { {"MetadataKey" => "MetaDataValue", "MetadataKey1" => "MetaDataValue1"} }
+      let(:response_headers) { {"x-ms-meta-MetadataKey" => "MetaDataValue", "x-ms-meta-MetadataKey1" => "MetaDataValue1"} }
 
       before {
-        query.update({ "comp" => "metadata" }) 
-        response.stubs(:headers).returns(response_headers) 
+        query.update({"comp" => "metadata"})
+        response.stubs(:headers).returns(response_headers)
         subject.stubs(:container_uri).with(container_name, query).returns(uri)
-        subject.stubs(:call).with(method, uri).returns(response)
+        subject.stubs(:call).with(verb, uri).returns(response)
 
         container.metadata = container_metadata
         serialization.stubs(:container_from_headers).with(response_headers).returns(container)
@@ -276,7 +276,7 @@ describe Azure::Blob::BlobService do
       end
 
       it "calls StorageService#call with the prepared request" do
-        subject.expects(:call).with(method, uri).returns(response)
+        subject.expects(:call).with(verb, uri).returns(response)
         subject.get_container_metadata container_name
       end
 
@@ -294,16 +294,16 @@ describe Azure::Blob::BlobService do
     end
 
     describe "#get_container_acl" do
-      let(:method) { :get }
-      let(:signed_identifier){ Azure::Service::SignedIdentifier.new }
-      let(:signed_identifiers){ [signed_identifier] }
+      let(:verb) { :get }
+      let(:signed_identifier) { Azure::Service::SignedIdentifier.new }
+      let(:signed_identifiers) { [signed_identifier] }
 
       before {
-        query.update({"comp"=>"acl"})
-        response.stubs(:headers).returns({}) 
+        query.update({"comp" => "acl"})
+        response.stubs(:headers).returns({})
         response_body.stubs(:length).returns(37)
         subject.stubs(:container_uri).with(container_name, query).returns(uri)
-        subject.stubs(:call).with(method, uri).returns(response)
+        subject.stubs(:call).with(verb, uri).returns(response)
 
         serialization.stubs(:container_from_headers).with(response_headers).returns(container)
         serialization.stubs(:signed_identifiers_from_xml).with(response_body).returns(signed_identifiers)
@@ -315,7 +315,7 @@ describe Azure::Blob::BlobService do
       end
 
       it "calls StorageService#call with the prepared request" do
-        subject.expects(:call).with(method, uri).returns(response)
+        subject.expects(:call).with(verb, uri).returns(response)
         subject.get_container_acl container_name
       end
 
@@ -327,7 +327,7 @@ describe Azure::Blob::BlobService do
 
       it "returns a container and an ACL" do
         returned_container, returned_acl = subject.get_container_acl container_name
-        
+
         returned_container.must_be_kind_of Azure::Blob::Container
         returned_container.name.must_equal container_name
 
@@ -337,16 +337,16 @@ describe Azure::Blob::BlobService do
     end
 
     describe "#set_container_acl" do
-      let(:method) { :put }
+      let(:verb) { :put }
       let(:public_access_level) { "any-public-access-level" }
 
       before {
-        query.update({"comp"=>"acl"})
+        query.update({"comp" => "acl"})
         request_headers["x-ms-blob-public-access"] = public_access_level
 
-        response.stubs(:headers).returns({}) 
+        response.stubs(:headers).returns({})
         subject.stubs(:container_uri).with(container_name, query).returns(uri)
-        subject.stubs(:call).with(method, uri, nil, request_headers).returns(response)
+        subject.stubs(:call).with(verb, uri, nil, request_headers).returns(response)
         serialization.stubs(:container_from_headers).with(response_headers).returns(container)
       }
 
@@ -356,7 +356,7 @@ describe Azure::Blob::BlobService do
       end
 
       it "calls StorageService#call with the prepared request" do
-        subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
+        subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
         subject.set_container_acl container_name, public_access_level
       end
 
@@ -368,40 +368,40 @@ describe Azure::Blob::BlobService do
 
       it "returns a container and an ACL" do
         returned_container, returned_acl = subject.set_container_acl container_name, public_access_level
-        
+
         returned_container.must_be_kind_of Azure::Blob::Container
         returned_container.name.must_equal container_name
         returned_container.public_access_level.must_equal public_access_level
 
         returned_acl.must_be_kind_of Array
       end
-      
+
       describe "when the public_access_level parameter is set to 'container'" do
-        let(:public_access_level) { "container"}
-        before { 
+        let(:public_access_level) { "container" }
+        before {
           request_headers["x-ms-blob-public-access"] = public_access_level
         }
 
         it "sets the x-ms-blob-public-access header" do
-          subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
+          subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
           subject.set_container_acl container_name, public_access_level
         end
 
         describe "when a signed_identifiers value is provided" do
-          let(:signed_identifier){ Azure::Service::SignedIdentifier.new }
-          let(:signed_identifiers){ [signed_identifier] }
+          let(:signed_identifier) { Azure::Service::SignedIdentifier.new }
+          let(:signed_identifiers) { [signed_identifier] }
           before {
-            subject.stubs(:call).with(method, uri, request_body, request_headers).returns(response)
+            subject.stubs(:call).with(verb, uri, request_body, request_headers).returns(response)
             serialization.stubs(:signed_identifiers_to_xml).with(signed_identifiers).returns(request_body)
           }
-          
+
           it "serializes the request contents" do
             serialization.expects(:signed_identifiers_to_xml).with(signed_identifiers).returns(request_body)
-            subject.set_container_acl container_name, public_access_level, { :signed_identifiers => signed_identifiers }
+            subject.set_container_acl container_name, public_access_level, {:signed_identifiers => signed_identifiers}
           end
 
           it "returns a container and an ACL" do
-            returned_container, returned_acl = subject.set_container_acl container_name, public_access_level, { :signed_identifiers => signed_identifiers }
+            returned_container, returned_acl = subject.set_container_acl container_name, public_access_level, {:signed_identifiers => signed_identifiers}
 
             returned_container.must_be_kind_of Azure::Blob::Container
             returned_container.name.must_equal container_name
@@ -415,39 +415,39 @@ describe Azure::Blob::BlobService do
 
       describe "when the public_access_level parameter is set to nil" do
         let(:public_access_level) { nil }
-        before { 
+        before {
           request_headers.delete "x-ms-blob-public-access"
         }
 
         it "sets the x-ms-blob-public-access header" do
-          subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
+          subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
           subject.set_container_acl container_name, public_access_level
         end
       end
 
       describe "when the public_access_level parameter is set to empty string" do
         let(:public_access_level) { "" }
-        before { 
+        before {
           request_headers.delete "x-ms-blob-public-access"
         }
 
         it "sets the x-ms-blob-public-access header" do
-          subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
+          subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
           subject.set_container_acl container_name, public_access_level
         end
       end
     end
 
     describe "#set_container_metadata" do
-      let(:method) { :put }
-      let(:container_metadata) { { "MetadataKey" => "MetaDataValue", "MetadataKey1" => "MetaDataValue1" } }
-      let(:request_headers) { { "x-ms-meta-MetadataKey" => "MetaDataValue", "x-ms-meta-MetadataKey1" => "MetaDataValue1" } }
+      let(:verb) { :put }
+      let(:container_metadata) { {"MetadataKey" => "MetaDataValue", "MetadataKey1" => "MetaDataValue1"} }
+      let(:request_headers) { {"x-ms-meta-MetadataKey" => "MetaDataValue", "x-ms-meta-MetadataKey1" => "MetaDataValue1", 'x-ms-version' => '2013-08-15'} }
 
       before {
-        query.update({ "comp" => "metadata" }) 
+        query.update({"comp" => "metadata"})
         response.stubs(:success?).returns(true)
         subject.stubs(:container_uri).with(container_name, query).returns(uri)
-        subject.stubs(:call).with(method, uri, nil, request_headers).returns(response)
+        subject.stubs(:call).with(verb, uri, nil, request_headers).returns(response)
       }
 
       it "assembles a URI for the request" do
@@ -456,7 +456,7 @@ describe Azure::Blob::BlobService do
       end
 
       it "calls StorageService#call with the prepared request" do
-        subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
+        subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
         subject.set_container_metadata container_name, container_metadata
       end
 
@@ -467,13 +467,13 @@ describe Azure::Blob::BlobService do
     end
 
     describe "#list_blobs" do
-      let(:method) { :get }
-      let(:query) {{"comp"=>"list"}}
-      let(:blob_enumeration_results) { Azure::Service::EnumerationResults.new}
+      let(:verb) { :get }
+      let(:query) { {"comp" => "list"} }
+      let(:blob_enumeration_results) { Azure::Service::EnumerationResults.new }
 
-      before { 
+      before {
         subject.stubs(:container_uri).with(container_name, query).returns(uri)
-        subject.stubs(:call).with(method, uri).returns(response)
+        subject.stubs(:call).with(verb, uri).returns(response)
         serialization.stubs(:blob_enumeration_results_from_xml).with(response_body).returns(blob_enumeration_results)
       }
 
@@ -483,7 +483,7 @@ describe Azure::Blob::BlobService do
       end
 
       it "calls StorageService#call with the prepared request" do
-        subject.expects(:call).with(method, uri).returns(response)
+        subject.expects(:call).with(verb, uri).returns(response)
         subject.list_blobs container_name
       end
 
@@ -506,97 +506,98 @@ describe Azure::Blob::BlobService do
 
         it "modifies the URI query parameters when provided a :prefix value" do
           query["prefix"]= "pre"
-          options = { :prefix => "pre" }
+          options = {:prefix => "pre"}
           subject.list_blobs container_name, options
         end
 
         it "modifies the URI query parameters when provided a :prefix value" do
           query["delimiter"] = "delim"
-          options = { :delimiter => "delim" }
+          options = {:delimiter => "delim"}
           subject.list_blobs container_name, options
         end
-        
+
         it "modifies the URI query parameters when provided a :marker value" do
           query["marker"] = "mark"
-          options = { :marker => "mark" }
+          options = {:marker => "mark"}
           subject.list_blobs container_name, options
         end
-        
+
         it "modifies the URI query parameters when provided a :max_results value" do
           query["maxresults"] = "5"
-          options = { :max_results => 5 }
+          options = {:max_results => 5}
           subject.list_blobs container_name, options
         end
-        
+
         it "modifies the URI query parameters when provided a :metadata value" do
           query["include"] = "metadata"
-          options = { :metadata => true }
+          options = {:metadata => true}
           subject.list_blobs container_name, options
         end
 
         it "modifies the URI query parameters when provided a :snapshots value" do
           query["include"] = "snapshots"
-          options = { :snapshots => true }
+          options = {:snapshots => true}
           subject.list_blobs container_name, options
         end
 
         it "modifies the URI query parameters when provided a :uncommittedblobs value" do
           query["include"] = "uncommittedblobs"
-          options = { :uncommittedblobs => true }
+          options = {:uncommittedblobs => true}
           subject.list_blobs container_name, options
         end
 
         it "modifies the URI query parameters when provided a :copy value" do
           query["include"] = "copy"
-          options = { :copy => true }
+          options = {:copy => true}
           subject.list_blobs container_name, options
         end
-        
+
         it "modifies the URI query parameters when provided more than one of :metadata, :snapshots, :uncommittedblobs or :copy values" do
           query["include"] = "metadata,snapshots,uncommittedblobs,copy"
 
-          options = { 
-            :copy => true,
-            :metadata => true, 
-            :snapshots => true,
-            :uncommittedblobs => true
+          options = {
+              :copy => true,
+              :metadata => true,
+              :snapshots => true,
+              :uncommittedblobs => true
           }
 
           subject.list_blobs container_name, options
         end
 
         it "modifies the URI query parameters when provided a :timeout value" do
-          query["timeout"] = "37" 
-          options = { :timeout => 37 }
+          query["timeout"] = "37"
+          options = {:timeout => 37}
           subject.list_blobs container_name, options
         end
 
         it "does not modify the URI query parameters when provided an unknown value" do
-          options = { :unknown_key => "some_value" }
+          options = {:unknown_key => "some_value"}
           subject.list_blobs container_name, options
         end
       end
     end
 
     describe "blob functions" do
-      let(:blob_name){ "blob-name" }
+      let(:blob_name) { "blob-name" }
       let(:blob) { Azure::Blob::Blob.new }
 
       describe "#create_page_blob" do
-        let(:method) { :put }
+        let(:verb) { :put }
         let(:blob_length) { 37 }
-        let(:request_headers) { 
+        let(:request_headers) {
           {
-            "x-ms-blob-type" => "PageBlob", 
-            "Content-Length" => 0.to_s,
-            "x-ms-blob-content-length" => blob_length.to_s, 
-            "x-ms-sequence-number" => 0.to_s
+              "x-ms-blob-type" => "PageBlob",
+              "Content-Length" => 0.to_s,
+              "x-ms-blob-content-length" => blob_length.to_s,
+              "x-ms-sequence-number" => 0.to_s,
+              'x-ms-version' => '2013-08-15'
           }
         }
 
         before {
           subject.stubs(:blob_uri).with(container_name, blob_name, {}).returns(uri)
-          subject.stubs(:call).with(method, uri, nil, request_headers).returns(response)
+          subject.stubs(:call).with(verb, uri, nil, request_headers).returns(response)
           serialization.stubs(:blob_from_headers).with(response_headers).returns(blob)
         }
 
@@ -606,7 +607,7 @@ describe Azure::Blob::BlobService do
         end
 
         it "calls StorageService#call with the prepared request" do
-          subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
+          subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
           subject.create_page_blob container_name, blob_name, blob_length
         end
 
@@ -620,89 +621,90 @@ describe Azure::Blob::BlobService do
         describe "when the options Hash is used" do
           it "modifies the request headers when provided a :sequence_number value" do
             request_headers["x-ms-sequence-number"] = 37.to_s
-            subject.create_page_blob container_name, blob_name, blob_length, { :sequence_number => 37.to_s }
+            subject.create_page_blob container_name, blob_name, blob_length, {:sequence_number => 37.to_s}
           end
 
           it "modifies the request headers when provided a :blob_content_type value" do
             request_headers["x-ms-blob-content-type"] = "bct-value"
-            subject.create_page_blob container_name, blob_name, blob_length, { :blob_content_type => "bct-value" }
+            subject.create_page_blob container_name, blob_name, blob_length, {:blob_content_type => "bct-value"}
           end
-          
+
           it "modifies the request headers when provided a :blob_content_encoding value" do
             request_headers["x-ms-blob-content-encoding"] = "bce-value"
-            subject.create_page_blob container_name, blob_name, blob_length, { :blob_content_encoding => "bce-value" }
+            subject.create_page_blob container_name, blob_name, blob_length, {:blob_content_encoding => "bce-value"}
           end
 
           it "modifies the request headers when provided a :blob_content_language value" do
             request_headers["x-ms-blob-content-language"] = "bcl-value"
-            subject.create_page_blob container_name, blob_name, blob_length, { :blob_content_language => "bcl-value" }
+            subject.create_page_blob container_name, blob_name, blob_length, {:blob_content_language => "bcl-value"}
           end
 
           it "modifies the request headers when provided a :blob_content_md5 value" do
             request_headers["x-ms-blob-content-md5"] = "bcm-value"
-            subject.create_page_blob container_name, blob_name, blob_length, { :blob_content_md5 => "bcm-value" }
+            subject.create_page_blob container_name, blob_name, blob_length, {:blob_content_md5 => "bcm-value"}
           end
 
           it "modifies the request headers when provided a :blob_cache_control value" do
             request_headers["x-ms-blob-cache-control"] = "bcc-value"
-            subject.create_page_blob container_name, blob_name, blob_length, { :blob_cache_control => "bcc-value" }
+            subject.create_page_blob container_name, blob_name, blob_length, {:blob_cache_control => "bcc-value"}
           end
 
           it "modifies the request headers when provided a :content_type value" do
             request_headers["Content-Type"] = "ct-value"
-            subject.create_page_blob container_name, blob_name, blob_length, { :content_type => "ct-value" }
+            subject.create_page_blob container_name, blob_name, blob_length, {:content_type => "ct-value"}
           end
-          
+
           it "modifies the request headers when provided a :content_encoding value" do
             request_headers["Content-Encoding"] = "ce-value"
-            subject.create_page_blob container_name, blob_name, blob_length, { :content_encoding => "ce-value" }
+            subject.create_page_blob container_name, blob_name, blob_length, {:content_encoding => "ce-value"}
           end
 
           it "modifies the request headers when provided a :content_language value" do
             request_headers["Content-Language"] = "cl-value"
-            subject.create_page_blob container_name, blob_name, blob_length, { :content_language => "cl-value" }
+            subject.create_page_blob container_name, blob_name, blob_length, {:content_language => "cl-value"}
           end
 
           it "modifies the request headers when provided a :content_md5 value" do
             request_headers["Content-MD5"] = "cm-value"
-            subject.create_page_blob container_name, blob_name, blob_length, { :content_md5 => "cm-value" }
+            subject.create_page_blob container_name, blob_name, blob_length, {:content_md5 => "cm-value"}
           end
 
           it "modifies the request headers when provided a :cache_control value" do
             request_headers["Cache-Control"] = "cc-value"
-            subject.create_page_blob container_name, blob_name, blob_length, { :cache_control => "cc-value" }
+            subject.create_page_blob container_name, blob_name, blob_length, {:cache_control => "cc-value"}
           end
 
           it "modifies the request headers when provided a :metadata value" do
             request_headers["x-ms-meta-MetadataKey"] = "MetaDataValue"
             request_headers["x-ms-meta-MetadataKey1"] = "MetaDataValue1"
-            options = { :metadata => { "MetadataKey" => "MetaDataValue", "MetadataKey1" => "MetaDataValue1"} }
+            options = {:metadata => {"MetadataKey" => "MetaDataValue", "MetadataKey1" => "MetaDataValue1"}}
             subject.create_page_blob container_name, blob_name, blob_length, options
           end
 
           it "does not modify the request headers when provided an unknown value" do
-            subject.create_page_blob container_name, blob_name, blob_length, { :unknown_key => "some_value" }
+            subject.create_page_blob container_name, blob_name, blob_length, {:unknown_key => "some_value"}
           end
         end
       end
 
       describe "#create_blob_pages" do
-        let(:method) { :put }
+        let(:verb) { :put }
         let(:start_range) { 255 }
         let(:end_range) { 512 }
         let(:content) { "some content" }
         let(:query) { {"comp" => "page"} }
-        let(:request_headers) { 
+        let(:request_headers) {
           {
-            "x-ms-page-write" => "update", 
-            "x-ms-range" => "bytes=#{start_range}-#{end_range}",
-            "Content-Type" => ""
+              "x-ms-page-write" => "update",
+              "x-ms-range" => "bytes=#{start_range}-#{end_range}",
+              "Content-Type" => "",
+              'x-ms-version' => '2013-08-15'
           }
         }
 
         before {
           subject.stubs(:blob_uri).with(container_name, blob_name, query).returns(uri)
-          subject.stubs(:call).with(method, uri, content, request_headers).returns(response)
+          subject.stubs(:call).with(verb, uri, content, request_headers).returns(response)
           serialization.stubs(:blob_from_headers).with(response_headers).returns(blob)
         }
 
@@ -712,7 +714,7 @@ describe Azure::Blob::BlobService do
         end
 
         it "calls StorageService#call with the prepared request" do
-          subject.expects(:call).with(method, uri, content, request_headers).returns(response)
+          subject.expects(:call).with(verb, uri, content, request_headers).returns(response)
           subject.create_blob_pages container_name, blob_name, start_range, end_range, content
         end
 
@@ -726,62 +728,63 @@ describe Azure::Blob::BlobService do
         describe "when the options Hash is used" do
           it "modifies the request headers when provided a :if_sequence_number_eq value" do
             request_headers["x-ms-if-sequence-number-eq"] = "isne-value"
-            subject.create_blob_pages container_name, blob_name, start_range, end_range, content, { :if_sequence_number_eq => "isne-value" }
+            subject.create_blob_pages container_name, blob_name, start_range, end_range, content, {:if_sequence_number_eq => "isne-value"}
           end
 
           it "modifies the request headers when provided a :if_sequence_number_lt value" do
             request_headers["x-ms-if-sequence-number-lt"] = "isnlt-value"
-            subject.create_blob_pages container_name, blob_name, start_range, end_range, content, { :if_sequence_number_lt => "isnlt-value" }
+            subject.create_blob_pages container_name, blob_name, start_range, end_range, content, {:if_sequence_number_lt => "isnlt-value"}
           end
 
           it "modifies the request headers when provided a :if_sequence_number_le value" do
             request_headers["x-ms-if-sequence-number-le"] = "isnle-value"
-            subject.create_blob_pages container_name, blob_name, start_range, end_range, content, { :if_sequence_number_le => "isnle-value" }
+            subject.create_blob_pages container_name, blob_name, start_range, end_range, content, {:if_sequence_number_le => "isnle-value"}
           end
 
           it "modifies the request headers when provided a :if_modified_since value" do
             request_headers["If-Modified-Since"] = "ims-value"
-            subject.create_blob_pages container_name, blob_name, start_range, end_range, content, { :if_modified_since => "ims-value" }
+            subject.create_blob_pages container_name, blob_name, start_range, end_range, content, {:if_modified_since => "ims-value"}
           end
 
           it "modifies the request headers when provided a :if_unmodified_since value" do
             request_headers["If-Unmodified-Since"] = "iums-value"
-            subject.create_blob_pages container_name, blob_name, start_range, end_range, content, { :if_unmodified_since => "iums-value" }
+            subject.create_blob_pages container_name, blob_name, start_range, end_range, content, {:if_unmodified_since => "iums-value"}
           end
 
           it "modifies the request headers when provided a :if_match value" do
             request_headers["If-Match"] = "im-value"
-            subject.create_blob_pages container_name, blob_name, start_range, end_range, content, { :if_match => "im-value" }
+            subject.create_blob_pages container_name, blob_name, start_range, end_range, content, {:if_match => "im-value"}
           end
 
           it "modifies the request headers when provided a :if_none_match value" do
             request_headers["If-None-Match"] = "inm-value"
-            subject.create_blob_pages container_name, blob_name, start_range, end_range, content, { :if_none_match => "inm-value" }
+            subject.create_blob_pages container_name, blob_name, start_range, end_range, content, {:if_none_match => "inm-value"}
           end
 
 
           it "does not modify the request headers when provided an unknown value" do
-            subject.create_blob_pages container_name, blob_name, start_range, end_range, content, { :unknown_key => "some_value" }
+            subject.create_blob_pages container_name, blob_name, start_range, end_range, content, {:unknown_key => "some_value"}
           end
         end
       end
 
       describe "#clear_blob_pages" do
-        let(:method) { :put }
+        let(:verb) { :put }
         let(:query) { {"comp" => "page"} }
-        let(:start_range){ 255 }
-        let(:end_range){ 512 }
-        let(:request_headers) { 
+        let(:start_range) { 255 }
+        let(:end_range) { 512 }
+        let(:request_headers) {
           {
-            "x-ms-range" => "bytes=#{start_range}-#{end_range}",
-            "x-ms-page-write" => "clear", 
-            "Content-Type" => ""
+              "x-ms-range" => "bytes=#{start_range}-#{end_range}",
+              "x-ms-page-write" => "clear",
+              "Content-Type" => "",
+              'x-ms-version' => '2013-08-15'
           }
         }
 
         before {
           subject.stubs(:blob_uri).with(container_name, blob_name, query).returns(uri)
-          subject.stubs(:call).with(method, uri, nil, request_headers).returns(response)
+          subject.stubs(:call).with(verb, uri, nil, request_headers).returns(response)
           serialization.stubs(:blob_from_headers).with(response_headers).returns(blob)
         }
 
@@ -791,7 +794,7 @@ describe Azure::Blob::BlobService do
         end
 
         it "calls StorageService#call with the prepared request" do
-          subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
+          subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
           subject.clear_blob_pages container_name, blob_name, start_range, end_range
         end
 
@@ -807,7 +810,7 @@ describe Azure::Blob::BlobService do
         #   before { request_headers["x-ms-range"]="#{start_range}-" }
 
         #   it "modifies the request headers with the desired range" do
-        #     subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
+        #     subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
         #     subject.clear_blob_pages container_name, blob_name, start_range
         #   end
         # end
@@ -817,7 +820,7 @@ describe Azure::Blob::BlobService do
         #   before { request_headers["x-ms-range"]="0-#{end_range}" }
 
         #   it "modifies the request headers with the desired range" do
-        #     subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
+        #     subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
         #     subject.clear_blob_pages container_name, blob_name, nil, end_range
         #   end
         # end
@@ -826,7 +829,7 @@ describe Azure::Blob::BlobService do
         #   before { request_headers["x-ms-range"]="bytes=#{start_range}-#{end_range}" }
 
         #   it "modifies the request headers with the desired range" do
-        #     subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
+        #     subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
         #     subject.clear_blob_pages container_name, blob_name, start_range, end_range
         #   end
         # end
@@ -835,17 +838,17 @@ describe Azure::Blob::BlobService do
       describe "#create_blob_block" do
         require 'base64'
 
-        let(:method) { :put }
-        let(:content) { "some content"}
-        let(:block_id) { "block-id"}
+        let(:verb) { :put }
+        let(:content) { "some content" }
+        let(:block_id) { "block-id" }
         let(:server_generated_content_md5) { "server-content-md5" }
-        let(:request_headers) { {} }
+        let(:request_headers) { {'x-ms-version' => '2013-08-15'} }
 
         before {
-          query.update({ "comp" => "block", "blockid" => Base64.strict_encode64(block_id) }) 
-          response_headers["Content-MD5"] = server_generated_content_md5 
+          query.update({"comp" => "block", "blockid" => Base64.strict_encode64(block_id)})
+          response_headers["Content-MD5"] = server_generated_content_md5
           subject.stubs(:blob_uri).with(container_name, blob_name, query).returns(uri)
-          subject.stubs(:call).with(method, uri, content, request_headers).returns(response)
+          subject.stubs(:call).with(verb, uri, content, request_headers).returns(response)
         }
 
         it "assembles a URI for the request" do
@@ -854,7 +857,7 @@ describe Azure::Blob::BlobService do
         end
 
         it "calls StorageService#call with the prepared request" do
-          subject.expects(:call).with(method, uri, content, request_headers).returns(response)
+          subject.expects(:call).with(verb, uri, content, request_headers).returns(response)
           subject.create_blob_block container_name, blob_name, block_id, content
         end
 
@@ -866,28 +869,29 @@ describe Azure::Blob::BlobService do
         describe "when the options Hash is used" do
           it "modifies the request headers when provided a :content_md5 value" do
             request_headers["Content-MD5"] = "content-md5"
-            subject.create_blob_block container_name, blob_name, block_id, content, { :content_md5 => "content-md5" }
+            subject.create_blob_block container_name, blob_name, block_id, content, {:content_md5 => "content-md5"}
           end
-          
+
           it "does not modify the request headers when provided an unknown value" do
-            subject.create_blob_block container_name, blob_name, block_id, content, { :unknown_key => "some_value" }
+            subject.create_blob_block container_name, blob_name, block_id, content, {:unknown_key => "some_value"}
           end
         end
       end
 
       describe "#create_block_blob" do
-        let(:method) { :put }
+        let(:verb) { :put }
         let(:content) { "some content" }
-        let(:request_headers) { 
+        let(:request_headers) {
           {
-            "x-ms-blob-type" => "BlockBlob",
-            "Content-Type" => "application/octet-stream"
+              "x-ms-blob-type" => "BlockBlob",
+              "Content-Type" => "application/octet-stream",
+              'x-ms-version' => '2013-08-15'
           }
         }
 
         before {
           subject.stubs(:blob_uri).with(container_name, blob_name, {}).returns(uri)
-          subject.stubs(:call).with(method, uri, content, request_headers).returns(response)
+          subject.stubs(:call).with(verb, uri, content, request_headers).returns(response)
           serialization.stubs(:blob_from_headers).with(response_headers).returns(blob)
         }
 
@@ -897,7 +901,7 @@ describe Azure::Blob::BlobService do
         end
 
         it "calls StorageService#call with the prepared request" do
-          subject.expects(:call).with(method, uri, content, request_headers).returns(response)
+          subject.expects(:call).with(verb, uri, content, request_headers).returns(response)
           subject.create_block_blob container_name, blob_name, content
         end
 
@@ -911,79 +915,84 @@ describe Azure::Blob::BlobService do
         describe "when the options Hash is used" do
           it "modifies the request headers when provided a :blob_content_type value" do
             request_headers["x-ms-blob-content-type"] = "bct-value"
-            subject.create_block_blob container_name, blob_name, content, { :blob_content_type => "bct-value" }
+            subject.create_block_blob container_name, blob_name, content, {:blob_content_type => "bct-value"}
           end
-          
+
           it "modifies the request headers when provided a :blob_content_encoding value" do
             request_headers["x-ms-blob-content-encoding"] = "bce-value"
-            subject.create_block_blob container_name, blob_name, content, { :blob_content_encoding => "bce-value" }
+            subject.create_block_blob container_name, blob_name, content, {:blob_content_encoding => "bce-value"}
           end
 
           it "modifies the request headers when provided a :blob_content_language value" do
             request_headers["x-ms-blob-content-language"] = "bcl-value"
-            subject.create_block_blob container_name, blob_name, content, { :blob_content_language => "bcl-value" }
+            subject.create_block_blob container_name, blob_name, content, {:blob_content_language => "bcl-value"}
           end
 
           it "modifies the request headers when provided a :blob_content_md5 value" do
             request_headers["x-ms-blob-content-md5"] = "bcm-value"
-            subject.create_block_blob container_name, blob_name, content, { :blob_content_md5 => "bcm-value" }
+            subject.create_block_blob container_name, blob_name, content, {:blob_content_md5 => "bcm-value"}
           end
 
           it "modifies the request headers when provided a :blob_cache_control value" do
             request_headers["x-ms-blob-cache-control"] = "bcc-value"
-            subject.create_block_blob container_name, blob_name, content, { :blob_cache_control => "bcc-value" }
+            subject.create_block_blob container_name, blob_name, content, {:blob_cache_control => "bcc-value"}
+          end
+
+          it "modifies the request headers when provided a :blob_content_disposition value" do
+            request_headers["x-ms-blob-content-disposition"] = "bcd-value"
+            subject.create_block_blob container_name, blob_name, content, {:blob_content_disposition => "bcd-value"}
           end
 
           it "modifies the request headers when provided a :content_type value" do
             request_headers["Content-Type"] = "ct-value"
-            subject.create_block_blob container_name, blob_name, content, { :content_type => "ct-value" }
+            subject.create_block_blob container_name, blob_name, content, {:content_type => "ct-value"}
           end
-          
+
           it "modifies the request headers when provided a :content_encoding value" do
             request_headers["Content-Encoding"] = "ce-value"
-            subject.create_block_blob container_name, blob_name, content, { :content_encoding => "ce-value" }
+            subject.create_block_blob container_name, blob_name, content, {:content_encoding => "ce-value"}
           end
 
           it "modifies the request headers when provided a :content_language value" do
             request_headers["Content-Language"] = "cl-value"
-            subject.create_block_blob container_name, blob_name, content, { :content_language => "cl-value" }
+            subject.create_block_blob container_name, blob_name, content, {:content_language => "cl-value"}
           end
 
           it "modifies the request headers when provided a :content_md5 value" do
             request_headers["Content-MD5"] = "cm-value"
-            subject.create_block_blob container_name, blob_name, content, { :content_md5 => "cm-value" }
+            subject.create_block_blob container_name, blob_name, content, {:content_md5 => "cm-value"}
           end
 
           it "modifies the request headers when provided a :cache_control value" do
             request_headers["Cache-Control"] = "cc-value"
-            subject.create_block_blob container_name, blob_name, content, { :cache_control => "cc-value" }
+            subject.create_block_blob container_name, blob_name, content, {:cache_control => "cc-value"}
           end
 
           it "modifies the request headers when provided a :metadata value" do
             request_headers["x-ms-meta-MetadataKey"] = "MetaDataValue"
             request_headers["x-ms-meta-MetadataKey1"] = "MetaDataValue1"
-            options = { :metadata => { "MetadataKey" => "MetaDataValue", "MetadataKey1" => "MetaDataValue1"} }
+            options = {:metadata => {"MetadataKey" => "MetaDataValue", "MetadataKey1" => "MetaDataValue1"}}
             subject.create_block_blob container_name, blob_name, content, options
           end
 
           it "does not modify the request headers when provided an unknown value" do
-            subject.create_block_blob container_name, blob_name, content, { :unknown_key => "some_value" }
+            subject.create_block_blob container_name, blob_name, content, {:unknown_key => "some_value"}
           end
         end
       end
 
       describe "#commit_blob_blocks" do
-        let(:method) { :put }
+        let(:verb) { :put }
         let(:request_body) { "body" }
         let(:block_list) { mock() }
-        let(:request_headers) { {} }
+        let(:request_headers) { {'x-ms-version' => '2013-08-15'} }
 
         before {
-          query.update({ "comp" => "blocklist" }) 
+          query.update({"comp" => "blocklist"})
           response.stubs(:success?).returns(true)
           subject.stubs(:blob_uri).with(container_name, blob_name, query).returns(uri)
           serialization.stubs(:block_list_to_xml).with(block_list).returns(request_body)
-          subject.stubs(:call).with(method, uri, request_body, request_headers).returns(response)
+          subject.stubs(:call).with(verb, uri, request_body, request_headers).returns(response)
         }
 
         it "assembles a URI for the request" do
@@ -992,7 +1001,7 @@ describe Azure::Blob::BlobService do
         end
 
         it "calls StorageService#call with the prepared request" do
-          subject.expects(:call).with(method, uri, request_body, request_headers).returns(response)
+          subject.expects(:call).with(verb, uri, request_body, request_headers).returns(response)
           subject.commit_blob_blocks container_name, blob_name, block_list
         end
 
@@ -1009,55 +1018,60 @@ describe Azure::Blob::BlobService do
         describe "when the options Hash is used" do
           it "modifies the request headers when provided a :content_md5 value" do
             request_headers["Content-MD5"] = "cm-value"
-            subject.commit_blob_blocks container_name, blob_name, block_list, { :content_md5 => "cm-value" }
+            subject.commit_blob_blocks container_name, blob_name, block_list, {:content_md5 => "cm-value"}
           end
 
           it "modifies the request headers when provided a :blob_content_type value" do
             request_headers["x-ms-blob-content-type"] = "bct-value"
-            subject.commit_blob_blocks container_name, blob_name, block_list, { :blob_content_type => "bct-value" }
+            subject.commit_blob_blocks container_name, blob_name, block_list, {:blob_content_type => "bct-value"}
           end
-          
+
           it "modifies the request headers when provided a :blob_content_encoding value" do
             request_headers["x-ms-blob-content-encoding"] = "bce-value"
-            subject.commit_blob_blocks container_name, blob_name, block_list, { :blob_content_encoding => "bce-value" }
+            subject.commit_blob_blocks container_name, blob_name, block_list, {:blob_content_encoding => "bce-value"}
           end
 
           it "modifies the request headers when provided a :blob_content_language value" do
             request_headers["x-ms-blob-content-language"] = "bcl-value"
-            subject.commit_blob_blocks container_name, blob_name, block_list, { :blob_content_language => "bcl-value" }
+            subject.commit_blob_blocks container_name, blob_name, block_list, {:blob_content_language => "bcl-value"}
           end
 
           it "modifies the request headers when provided a :blob_content_md5 value" do
             request_headers["x-ms-blob-content-md5"] = "bcm-value"
-            subject.commit_blob_blocks container_name, blob_name, block_list, { :blob_content_md5 => "bcm-value" }
+            subject.commit_blob_blocks container_name, blob_name, block_list, {:blob_content_md5 => "bcm-value"}
           end
 
           it "modifies the request headers when provided a :blob_cache_control value" do
             request_headers["x-ms-blob-cache-control"] = "bcc-value"
-            subject.commit_blob_blocks container_name, blob_name, block_list, { :blob_cache_control => "bcc-value" }
+            subject.commit_blob_blocks container_name, blob_name, block_list, {:blob_cache_control => "bcc-value"}
+          end
+
+          it "modifies the request headers when provided a :blob_content_disposition value" do
+            request_headers["x-ms-blob-content-disposition"] = "bcd-value"
+            subject.commit_blob_blocks container_name, blob_name, block_list, {:blob_content_disposition => "bcd-value"}
           end
 
           it "modifies the request headers when provided a :metadata value" do
             request_headers["x-ms-meta-MetadataKey"] = "MetaDataValue"
             request_headers["x-ms-meta-MetadataKey1"] = "MetaDataValue1"
-            options = { :metadata => { "MetadataKey" => "MetaDataValue", "MetadataKey1" => "MetaDataValue1"} }
+            options = {:metadata => {"MetadataKey" => "MetaDataValue", "MetadataKey1" => "MetaDataValue1"}}
             subject.commit_blob_blocks container_name, blob_name, block_list, options
           end
 
           it "does not modify the request headers when provided an unknown value" do
-            subject.commit_blob_blocks container_name, blob_name, block_list, { :unknown_key => "some_value" }
+            subject.commit_blob_blocks container_name, blob_name, block_list, {:unknown_key => "some_value"}
           end
         end
       end
 
       describe "#list_blob_blocks" do
-        let(:method) { :get }
-        let(:query) {{"comp"=>"blocklist", "blocklisttype"=>"all"}}
+        let(:verb) { :get }
+        let(:query) { {"comp" => "blocklist", "blocklisttype" => "all"} }
         let(:blob_block_list) { [Azure::Blob::Block.new] }
 
-        before { 
+        before {
           subject.stubs(:blob_uri).with(container_name, blob_name, query).returns(uri)
-          subject.stubs(:call).with(method, uri).returns(response)
+          subject.stubs(:call).with(verb, uri).returns(response)
           serialization.stubs(:block_list_from_xml).with(response_body).returns(blob_block_list)
         }
 
@@ -1067,7 +1081,7 @@ describe Azure::Blob::BlobService do
         end
 
         it "calls StorageService#call with the prepared request" do
-          subject.expects(:call).with(method, uri).returns(response)
+          subject.expects(:call).with(verb, uri).returns(response)
           subject.list_blob_blocks container_name, blob_name
         end
 
@@ -1085,36 +1099,36 @@ describe Azure::Blob::BlobService do
         describe "when blocklist_type is provided" do
           it "modifies the request query when the value is :all" do
             query["blocklisttype"] = "all"
-            subject.list_blob_blocks container_name, blob_name, { :blocklist_type => :all }
+            subject.list_blob_blocks container_name, blob_name, {:blocklist_type => :all}
           end
 
           it "modifies the request query when the value is :uncommitted" do
             query["blocklisttype"] = "uncommitted"
-            subject.list_blob_blocks container_name, blob_name, { :blocklist_type => :uncommitted }
+            subject.list_blob_blocks container_name, blob_name, {:blocklist_type => :uncommitted}
           end
 
           it "modifies the request query when the value is :committed" do
             query["blocklisttype"] = "committed"
-            subject.list_blob_blocks container_name, blob_name, { :blocklist_type => :committed }
+            subject.list_blob_blocks container_name, blob_name, {:blocklist_type => :committed}
           end
         end
 
         describe "when snapshot is provided" do
           it "modifies the request query with the provided value" do
             query["snapshot"] = "snapshot-id"
-            subject.list_blob_blocks container_name, blob_name, { :snapshot => "snapshot-id" }
+            subject.list_blob_blocks container_name, blob_name, {:snapshot => "snapshot-id"}
           end
         end
       end
 
       describe "#list_page_blob_ranges" do
-        let(:method) { :get }
-        let(:query) { {"comp"=>"pagelist"} }
+        let(:verb) { :get }
+        let(:query) { {"comp" => "pagelist"} }
         let(:page_list) { [[0, 511], [512, 1023]] }
 
-        before { 
+        before {
           subject.stubs(:blob_uri).with(container_name, blob_name, query).returns(uri)
-          subject.stubs(:call).with(method, uri, nil, request_headers).returns(response)
+          subject.stubs(:call).with(verb, uri, nil, request_headers).returns(response)
           serialization.stubs(:page_list_from_xml).with(response_body).returns(page_list)
         }
 
@@ -1124,7 +1138,7 @@ describe Azure::Blob::BlobService do
         end
 
         it "calls StorageService#call with the prepared request" do
-          subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
+          subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
           subject.list_page_blob_ranges container_name, blob_name
         end
 
@@ -1146,7 +1160,7 @@ describe Azure::Blob::BlobService do
         #   before { request_headers["x-ms-range"]="#{start_range}-" }
 
         #   it "modifies the request headers with the desired range" do
-        #     subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
+        #     subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
         #     subject.list_page_blob_ranges container_name, blob_name, start_range
         #   end
         # end
@@ -1156,39 +1170,39 @@ describe Azure::Blob::BlobService do
         #   before { request_headers["x-ms-range"]="0-#{end_range}" }
 
         #   it "modifies the request headers with the desired range" do
-        #     subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
+        #     subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
         #     subject.list_page_blob_ranges container_name, blob_name, nil, end_range
         #   end
         # end
 
         describe "when both start_range and end_range are provided" do
-          let(:start_range){ 255 }
-          let(:end_range){ 512 }
-          before { request_headers["x-ms-range"]="bytes=#{start_range}-#{end_range}" }
+          let(:start_range) { 255 }
+          let(:end_range) { 512 }
+          let(:request_headers) { {'x-ms-range' => "bytes=#{start_range}-#{end_range}"} }
 
           it "modifies the request headers with the desired range" do
-            subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
-            subject.list_page_blob_ranges container_name, blob_name, { :start_range => start_range, :end_range => end_range }
+            subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
+            subject.list_page_blob_ranges container_name, blob_name, {:start_range => start_range, :end_range => end_range}
           end
         end
 
         describe "when snapshot is provided" do
           it "modifies the request query with the provided value" do
             query["snapshot"] = "snapshot-id"
-            subject.list_page_blob_ranges container_name, blob_name, { :snapshot => "snapshot-id" }
+            subject.list_page_blob_ranges container_name, blob_name, {:snapshot => "snapshot-id"}
           end
         end
       end
 
       describe "#set_blob_properties" do
-        let(:method) { :put }
-        let(:request_headers) { {} }
+        let(:verb) { :put }
+        let(:request_headers) { {'x-ms-version' => '2013-08-15'} }
 
         before {
-          query.update({ "comp" => "properties" }) 
+          query.update({"comp" => "properties"})
           response.stubs(:success?).returns(true)
           subject.stubs(:blob_uri).with(container_name, blob_name, query).returns(uri)
-          subject.stubs(:call).with(method, uri, nil, request_headers).returns(response)
+          subject.stubs(:call).with(verb, uri, nil, request_headers).returns(response)
         }
 
         it "assembles a URI for the request" do
@@ -1197,7 +1211,7 @@ describe Azure::Blob::BlobService do
         end
 
         it "calls StorageService#call with the prepared request" do
-          subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
+          subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
           subject.set_blob_properties container_name, blob_name
         end
 
@@ -1209,60 +1223,65 @@ describe Azure::Blob::BlobService do
         describe "when the options Hash is used" do
           it "modifies the request headers when provided a :blob_content_type value" do
             request_headers["x-ms-blob-content-type"] = "bct-value"
-            subject.set_blob_properties container_name, blob_name, { :blob_content_type => "bct-value" }
+            subject.set_blob_properties container_name, blob_name, {:blob_content_type => "bct-value"}
           end
-          
+
           it "modifies the request headers when provided a :blob_content_encoding value" do
             request_headers["x-ms-blob-content-encoding"] = "bce-value"
-            subject.set_blob_properties container_name, blob_name, { :blob_content_encoding => "bce-value" }
+            subject.set_blob_properties container_name, blob_name, {:blob_content_encoding => "bce-value"}
           end
 
           it "modifies the request headers when provided a :blob_content_language value" do
             request_headers["x-ms-blob-content-language"] = "bcl-value"
-            subject.set_blob_properties container_name, blob_name, { :blob_content_language => "bcl-value" }
+            subject.set_blob_properties container_name, blob_name, {:blob_content_language => "bcl-value"}
           end
 
           it "modifies the request headers when provided a :blob_content_md5 value" do
             request_headers["x-ms-blob-content-md5"] = "bcm-value"
-            subject.set_blob_properties container_name, blob_name, { :blob_content_md5 => "bcm-value" }
+            subject.set_blob_properties container_name, blob_name, {:blob_content_md5 => "bcm-value"}
           end
 
           it "modifies the request headers when provided a :blob_cache_control value" do
             request_headers["x-ms-blob-cache-control"] = "bcc-value"
-            subject.set_blob_properties container_name, blob_name, { :blob_cache_control => "bcc-value" }
+            subject.set_blob_properties container_name, blob_name, {:blob_cache_control => "bcc-value"}
           end
 
           it "modifies the request headers when provided a :blob_content_length value" do
             request_headers["x-ms-blob-content-length"] = "37"
-            subject.set_blob_properties container_name, blob_name, { :blob_content_length => 37.to_s }
+            subject.set_blob_properties container_name, blob_name, {:blob_content_length => 37.to_s}
+          end
+
+          it "modifies the request headers when provided a :blob_content_disposition value" do
+            request_headers["x-ms-blob-content-disposition"] = "bcd-value"
+            subject.set_blob_properties container_name, blob_name, {:blob_content_disposition => "bcd-value"}
           end
 
           it "modifies the request headers when provided a :sequence_number_action value" do
             request_headers["x-ms-blob-sequence-number-action"] = "anyvalue"
-            subject.set_blob_properties container_name, blob_name, { :sequence_number_action => :anyvalue }
+            subject.set_blob_properties container_name, blob_name, {:sequence_number_action => :anyvalue}
           end
 
           it "modifies the request headers when provided a :sequence_number value" do
             request_headers["x-ms-blob-sequence-number"] = "37"
-            subject.set_blob_properties container_name, blob_name, { :sequence_number => 37.to_s }
+            subject.set_blob_properties container_name, blob_name, {:sequence_number => 37.to_s}
           end
 
           it "does not modify the request headers when provided an unknown value" do
-            subject.set_blob_properties container_name, blob_name, { :unknown_key => "some_value" }
+            subject.set_blob_properties container_name, blob_name, {:unknown_key => "some_value"}
           end
         end
       end
 
       describe "#set_blob_metadata" do
-        let(:method) { :put }
-        let(:blob_metadata) { { "MetadataKey" => "MetaDataValue", "MetadataKey1" => "MetaDataValue1" } }
-        let(:request_headers) { { "x-ms-meta-MetadataKey" => "MetaDataValue", "x-ms-meta-MetadataKey1" => "MetaDataValue1" } }
+        let(:verb) { :put }
+        let(:blob_metadata) { {"MetadataKey" => "MetaDataValue", "MetadataKey1" => "MetaDataValue1"} }
+        let(:request_headers) { {"x-ms-meta-MetadataKey" => "MetaDataValue", "x-ms-meta-MetadataKey1" => "MetaDataValue1", 'x-ms-version' => '2013-08-15'} }
 
         before {
-          query.update({ "comp" => "metadata" }) 
+          query.update({"comp" => "metadata"})
           response.stubs(:success?).returns(true)
           subject.stubs(:blob_uri).with(container_name, blob_name, query).returns(uri)
-          subject.stubs(:call).with(method, uri, nil, request_headers).returns(response)
+          subject.stubs(:call).with(verb, uri, nil, request_headers).returns(response)
         }
 
         it "assembles a URI for the request" do
@@ -1271,7 +1290,7 @@ describe Azure::Blob::BlobService do
         end
 
         it "calls StorageService#call with the prepared request" do
-          subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
+          subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
           subject.set_blob_metadata container_name, blob_name, blob_metadata
         end
 
@@ -1282,121 +1301,121 @@ describe Azure::Blob::BlobService do
       end
 
       describe "#get_blob_properties" do
-        let(:method) { :head }
+        let(:verb) { :head }
 
         before {
           subject.stubs(:blob_uri).with(container_name, blob_name, query).returns(uri)
-          subject.stubs(:call).with(method, uri).returns(response)
+          subject.stubs(:call).with(verb, uri).returns(response)
           serialization.stubs(:blob_from_headers).with(response_headers).returns(blob)
         }
-      
+
         it "assembles a URI for the request" do
           subject.expects(:blob_uri).with(container_name, blob_name, query).returns(uri)
           subject.get_blob_properties container_name, blob_name
         end
 
         it "calls StorageService#call with the prepared request" do
-          subject.expects(:call).with(method, uri).returns(response)
+          subject.expects(:call).with(verb, uri).returns(response)
           subject.get_blob_properties container_name, blob_name
         end
 
         it "returns the blob on success" do
           result = subject.get_blob_properties container_name, blob_name
-          
+
           result.must_be_kind_of Azure::Blob::Blob
           result.must_equal blob
           result.name.must_equal blob_name
         end
 
         describe "when snapshot is provided" do
-          let(:snapshot){ "snapshot" }
+          let(:snapshot) { "snapshot" }
           before { query["snapshot"]=snapshot }
 
           it "modifies the blob uri query string with the snapshot" do
             subject.expects(:blob_uri).with(container_name, blob_name, query).returns(uri)
-            subject.get_blob_properties container_name, blob_name, { :snapshot => snapshot }
+            subject.get_blob_properties container_name, blob_name, {:snapshot => snapshot}
           end
 
           it "sets the snapshot value on the returned blob" do
-            result = subject.get_blob_properties container_name, blob_name, { :snapshot => snapshot }
+            result = subject.get_blob_properties container_name, blob_name, {:snapshot => snapshot}
             result.snapshot.must_equal snapshot
           end
         end
       end
 
       describe "#get_blob_metadata" do
-        let(:method) { :get }
+        let(:verb) { :get }
 
         before {
           query["comp"]="metadata"
 
           subject.stubs(:blob_uri).with(container_name, blob_name, query).returns(uri)
-          subject.stubs(:call).with(method, uri).returns(response)
+          subject.stubs(:call).with(verb, uri).returns(response)
           serialization.stubs(:blob_from_headers).with(response_headers).returns(blob)
         }
-      
+
         it "assembles a URI for the request" do
           subject.expects(:blob_uri).with(container_name, blob_name, query).returns(uri)
           subject.get_blob_metadata container_name, blob_name
         end
 
         it "calls StorageService#call with the prepared request" do
-          subject.expects(:call).with(method, uri).returns(response)
+          subject.expects(:call).with(verb, uri).returns(response)
           subject.get_blob_metadata container_name, blob_name
         end
 
         it "returns the blob on success" do
           result = subject.get_blob_metadata container_name, blob_name
-          
+
           result.must_be_kind_of Azure::Blob::Blob
           result.must_equal blob
           result.name.must_equal blob_name
         end
 
         describe "when snapshot is provided" do
-          let(:snapshot){ "snapshot" }
-          before { 
-            query["snapshot"]=snapshot 
+          let(:snapshot) { "snapshot" }
+          before {
+            query["snapshot"]=snapshot
             subject.stubs(:blob_uri).with(container_name, blob_name, query).returns(uri)
           }
 
           it "modifies the blob uri query string with the snapshot" do
             subject.expects(:blob_uri).with(container_name, blob_name, query).returns(uri)
-            subject.get_blob_metadata container_name, blob_name, { :snapshot => snapshot }
+            subject.get_blob_metadata container_name, blob_name, {:snapshot => snapshot}
           end
 
           it "sets the snapshot value on the returned blob" do
-            result = subject.get_blob_metadata container_name, blob_name, { :snapshot => snapshot }
+            result = subject.get_blob_metadata container_name, blob_name, {:snapshot => snapshot}
             result.snapshot.must_equal snapshot
           end
         end
       end
 
       describe "#get_blob" do
-        let(:method) { :get }
+        let(:verb) { :get }
 
         before {
           response.stubs(:success?).returns(true)
           response_body = "body-contents"
 
           subject.stubs(:blob_uri).with(container_name, blob_name, query).returns(uri)
-          subject.stubs(:call).with(method, uri, nil, request_headers).returns(response)
+          subject.stubs(:call).with(verb, uri, nil, request_headers).returns(response)
           serialization.stubs(:blob_from_headers).with(response_headers).returns(blob)
         }
-      
+
         it "assembles a URI for the request" do
           subject.expects(:blob_uri).with(container_name, blob_name, query).returns(uri)
           subject.get_blob container_name, blob_name
         end
 
         it "calls StorageService#call with the prepared request" do
-          subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
+          subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
           subject.get_blob container_name, blob_name
         end
 
         it "returns the blob and blob contents on success" do
           returned_blob, returned_blob_contents = subject.get_blob container_name, blob_name
-          
+
           returned_blob.must_be_kind_of Azure::Blob::Blob
           returned_blob.must_equal blob
 
@@ -1404,12 +1423,12 @@ describe Azure::Blob::BlobService do
         end
 
         describe "when snapshot is provided" do
-          let(:source_snapshot){ "source-snapshot" }
+          let(:source_snapshot) { "source-snapshot" }
           before { query["snapshot"]=source_snapshot }
 
           it "modifies the blob uri query string with the snapshot" do
             subject.expects(:blob_uri).with(container_name, blob_name, query).returns(uri)
-            subject.get_blob container_name, blob_name, { :snapshot => source_snapshot }
+            subject.get_blob container_name, blob_name, {:snapshot => source_snapshot}
           end
         end
 
@@ -1418,7 +1437,7 @@ describe Azure::Blob::BlobService do
         #   before { request_headers["x-ms-range"]="#{start_range}-" }
 
         #   it "modifies the request headers with the desired range" do
-        #     subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
+        #     subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
         #     subject.get_blob container_name, blob_name, start_range
         #   end
         # end
@@ -1428,19 +1447,21 @@ describe Azure::Blob::BlobService do
         #   before { request_headers["x-ms-range"]="0-#{end_range}" }
 
         #   it "modifies the request headers with the desired range" do
-        #     subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
+        #     subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
         #     subject.get_blob container_name, blob_name, nil, end_range
         #   end
         # end
 
         describe "when both start_range and end_range are provided" do
-          let(:start_range){ 255 }
-          let(:end_range){ 512 }
-          before { request_headers["x-ms-range"]="bytes=#{start_range}-#{end_range}" }
+          let(:start_range) { 255 }
+          let(:end_range) { 512 }
+          before {
+            request_headers["x-ms-range"]="bytes=#{start_range}-#{end_range}"
+          }
 
           it "modifies the request headers with the desired range" do
-            subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
-            subject.get_blob container_name, blob_name, { :start_range => start_range, :end_range => end_range }
+            subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
+            subject.get_blob container_name, blob_name, {:start_range => start_range, :end_range => end_range}
           end
         end
 
@@ -1448,46 +1469,47 @@ describe Azure::Blob::BlobService do
           let(:get_content_md5) { true }
 
           describe "and a range is specified" do
-            let(:start_range){ 255 }
-            let(:end_range){ 512 }
-            before { 
+            let(:start_range) { 255 }
+            let(:end_range) { 512 }
+            before {
               request_headers["x-ms-range"]="bytes=#{start_range}-#{end_range}"
               request_headers["x-ms-range-get-content-md5"]= true
             }
 
             it "modifies the request headers to include the x-ms-range-get-content-md5 header" do
-              subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
-              subject.get_blob container_name, blob_name, { :start_range => start_range, :end_range => end_range, :get_content_md5 => true }
+              subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
+              subject.get_blob container_name, blob_name, {:start_range => start_range, :end_range => end_range, :get_content_md5 => true}
             end
           end
 
           describe "and a range is NOT specified" do
             it "does not modify the request headers" do
-              subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
-              subject.get_blob container_name, blob_name, { :get_content_md5 => true }
+              subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
+              subject.get_blob container_name, blob_name, {:get_content_md5 => true}
             end
           end
         end
       end
 
       describe "#delete_blob" do
-        let(:method) { :delete }
+        let(:verb) { :delete }
 
         before {
           response.stubs(:success?).returns(true)
           request_headers["x-ms-delete-snapshots"] = "include"
+          request_headers['x-ms-version'] = '2013-08-15'
 
           subject.stubs(:blob_uri).with(container_name, blob_name, query).returns(uri)
-          subject.stubs(:call).with(method, uri, nil, request_headers).returns(response)
+          subject.stubs(:call).with(verb, uri, nil, request_headers).returns(response)
         }
-      
+
         it "assembles a URI for the request" do
           subject.expects(:blob_uri).with(container_name, blob_name, query).returns(uri)
           subject.delete_blob container_name, blob_name
         end
 
         it "calls StorageService#call with the prepared request" do
-          subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
+          subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
           subject.delete_blob container_name, blob_name
         end
 
@@ -1495,75 +1517,75 @@ describe Azure::Blob::BlobService do
           result = subject.delete_blob container_name, blob_name
           result.must_equal nil
         end
-        
+
         describe "when snapshot is provided" do
-          let(:source_snapshot){ "source-snapshot" }
+          let(:source_snapshot) { "source-snapshot" }
           before {
             request_headers.delete "x-ms-delete-snapshots"
-            query["snapshot"] = source_snapshot 
+            query["snapshot"] = source_snapshot
           }
 
           it "modifies the blob uri query string with the snapshot" do
             subject.expects(:blob_uri).with(container_name, blob_name, query).returns(uri)
-            subject.delete_blob container_name, blob_name, { :snapshot => source_snapshot }
+            subject.delete_blob container_name, blob_name, {:snapshot => source_snapshot}
           end
 
           it "does not include a x-ms-delete-snapshots header" do
-            subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
-            subject.delete_blob container_name, blob_name, { :snapshot => source_snapshot }
+            subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
+            subject.delete_blob container_name, blob_name, {:snapshot => source_snapshot}
           end
         end
 
         describe "when delete_snapshots is provided" do
-          let(:delete_snapshots){ :anyvalue }
+          let(:delete_snapshots) { :anyvalue }
           before { request_headers["x-ms-delete-snapshots"]=delete_snapshots.to_s }
 
           it "modifies the request headers with the provided value" do
-            subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
-            subject.delete_blob container_name, blob_name, { :delete_snapshots => delete_snapshots }
+            subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
+            subject.delete_blob container_name, blob_name, {:delete_snapshots => delete_snapshots}
           end
         end
 
         describe "when snapshot is provided and delete_snapshots is provided" do
-          let(:source_snapshot){ "source-snapshot" }
-          let(:delete_snapshots){ :anyvalue }
+          let(:source_snapshot) { "source-snapshot" }
+          let(:delete_snapshots) { :anyvalue }
           before {
             request_headers.delete "x-ms-delete-snapshots"
-            query["snapshot"]=source_snapshot 
+            query["snapshot"]=source_snapshot
           }
 
           it "modifies the blob uri query string with the snapshot" do
             subject.expects(:blob_uri).with(container_name, blob_name, query).returns(uri)
-            subject.delete_blob container_name, blob_name, { :snapshot => source_snapshot, :delete_snapshots => delete_snapshots }
+            subject.delete_blob container_name, blob_name, {:snapshot => source_snapshot, :delete_snapshots => delete_snapshots}
           end
 
           it "does not include a x-ms-delete-snapshots header" do
-            subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
-            subject.delete_blob container_name, blob_name, { :snapshot => source_snapshot, :delete_snapshots => delete_snapshots }
+            subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
+            subject.delete_blob container_name, blob_name, {:snapshot => source_snapshot, :delete_snapshots => delete_snapshots}
           end
         end
       end
 
       describe "#create_blob_snapshot" do
-        let(:method) { :put }
+        let(:verb) { :put }
         let(:snapshot_id) { "snapshot-id" }
 
         before {
           query["comp"] = "snapshot"
-          
+
           response_headers["x-ms-snapshot"] = snapshot_id
 
           subject.stubs(:blob_uri).with(container_name, blob_name, query).returns(uri)
-          subject.stubs(:call).with(method, uri, nil, request_headers).returns(response)
+          subject.stubs(:call).with(verb, uri, nil, request_headers).returns(response)
         }
-      
+
         it "assembles a URI for the request" do
           subject.expects(:blob_uri).with(container_name, blob_name, query).returns(uri)
           subject.create_blob_snapshot container_name, blob_name
         end
 
         it "calls StorageService#call with the prepared request" do
-          subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
+          subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
           subject.create_blob_snapshot container_name, blob_name
         end
 
@@ -1574,49 +1596,49 @@ describe Azure::Blob::BlobService do
         end
 
         describe "when the options Hash is used" do
-          before { 
-            subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
+          before {
+            subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
           }
 
           it "modifies the request headers when provided a :if_modified_since value" do
             request_headers["If-Modified-Since"] = "ims-value"
-            subject.create_blob_snapshot container_name, blob_name, { :if_modified_since => "ims-value" }
+            subject.create_blob_snapshot container_name, blob_name, {:if_modified_since => "ims-value"}
           end
-          
+
           it "modifies the request headers when provided a :if_unmodified_since value" do
             request_headers["If-Unmodified-Since"] = "iums-value"
-            subject.create_blob_snapshot container_name, blob_name, { :if_unmodified_since => "iums-value" }
+            subject.create_blob_snapshot container_name, blob_name, {:if_unmodified_since => "iums-value"}
           end
 
           it "modifies the request headers when provided a :if_match value" do
             request_headers["If-Match"] = "im-value"
-            subject.create_blob_snapshot container_name, blob_name, { :if_match => "im-value" }
+            subject.create_blob_snapshot container_name, blob_name, {:if_match => "im-value"}
           end
 
           it "modifies the request headers when provided a :if_none_match value" do
             request_headers["If-None-Match"] = "inm-value"
-            subject.create_blob_snapshot container_name, blob_name, { :if_none_match => "inm-value" }
+            subject.create_blob_snapshot container_name, blob_name, {:if_none_match => "inm-value"}
           end
 
           it "modifies the request headers when provided a :metadata value" do
             request_headers["x-ms-meta-MetadataKey"] = "MetaDataValue"
             request_headers["x-ms-meta-MetadataKey1"] = "MetaDataValue1"
-            options = { :metadata => { "MetadataKey" => "MetaDataValue", "MetadataKey1" => "MetaDataValue1"} }
+            options = {:metadata => {"MetadataKey" => "MetaDataValue", "MetadataKey1" => "MetaDataValue1"}}
             subject.create_blob_snapshot container_name, blob_name, options
           end
 
           it "does not modify the request headers when provided an unknown value" do
-            subject.create_blob_snapshot container_name, blob_name, { :unknown_key => "some_value" }
+            subject.create_blob_snapshot container_name, blob_name, {:unknown_key => "some_value"}
           end
         end
       end
 
       describe "#copy_blob" do
-        let(:method) { :put }
+        let(:verb) { :put }
         let(:source_container_name) { "source-container-name" }
         let(:source_blob_name) { "source-blob-name" }
         let(:source_uri) { URI.parse("http://dummy.uri/source") }
-        
+
         let(:copy_id) { "copy-id" }
         let(:copy_status) { "copy-status" }
 
@@ -1628,9 +1650,9 @@ describe Azure::Blob::BlobService do
 
           subject.stubs(:blob_uri).with(container_name, blob_name, {}).returns(uri)
           subject.stubs(:blob_uri).with(source_container_name, source_blob_name, query).returns(source_uri)
-          subject.stubs(:call).with(method, uri, nil, request_headers).returns(response)
+          subject.stubs(:call).with(verb, uri, nil, request_headers).returns(response)
         }
-      
+
         it "assembles a URI for the request" do
           subject.expects(:blob_uri).with(container_name, blob_name, {}).returns(uri)
           subject.copy_blob container_name, blob_name, source_container_name, source_blob_name
@@ -1642,7 +1664,7 @@ describe Azure::Blob::BlobService do
         end
 
         it "calls StorageService#call with the prepared request" do
-          subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
+          subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
           subject.copy_blob container_name, blob_name, source_container_name, source_blob_name
         end
 
@@ -1651,85 +1673,85 @@ describe Azure::Blob::BlobService do
           returned_copy_id.must_equal copy_id
           returned_copy_status.must_equal copy_status
         end
-        
+
         describe "when snapshot is provided" do
-          let(:source_snapshot){"source-snapshot"}
-          before { 
+          let(:source_snapshot) { "source-snapshot" }
+          before {
             query["snapshot"]=source_snapshot
           }
 
           it "modifies the source blob uri query string with the snapshot" do
             subject.expects(:blob_uri).with(source_container_name, source_blob_name, query).returns(source_uri)
-            subject.copy_blob container_name, blob_name, source_container_name, source_blob_name, { :source_snapshot => source_snapshot }
+            subject.copy_blob container_name, blob_name, source_container_name, source_blob_name, {:source_snapshot => source_snapshot}
           end
         end
 
         describe "when the options Hash is used" do
-          before { 
-            subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
+          before {
+            subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
           }
 
           it "modifies the request headers when provided a :dest_if_modified_since value" do
             request_headers["If-Modified-Since"] = "ims-value"
-            subject.copy_blob container_name, blob_name, source_container_name, source_blob_name, { :dest_if_modified_since => "ims-value" }
+            subject.copy_blob container_name, blob_name, source_container_name, source_blob_name, {:dest_if_modified_since => "ims-value"}
           end
-          
+
           it "modifies the request headers when provided a :dest_if_unmodified_since value" do
             request_headers["If-Unmodified-Since"] = "iums-value"
-            subject.copy_blob container_name, blob_name, source_container_name, source_blob_name, { :dest_if_unmodified_since => "iums-value" }
+            subject.copy_blob container_name, blob_name, source_container_name, source_blob_name, {:dest_if_unmodified_since => "iums-value"}
           end
 
           it "modifies the request headers when provided a :dest_if_match value" do
             request_headers["If-Match"] = "im-value"
-            subject.copy_blob container_name, blob_name, source_container_name, source_blob_name, { :dest_if_match => "im-value" }
+            subject.copy_blob container_name, blob_name, source_container_name, source_blob_name, {:dest_if_match => "im-value"}
           end
 
           it "modifies the request headers when provided a :dest_if_none_match value" do
             request_headers["If-None-Match"] = "inm-value"
-            subject.copy_blob container_name, blob_name, source_container_name, source_blob_name, { :dest_if_none_match => "inm-value" }
+            subject.copy_blob container_name, blob_name, source_container_name, source_blob_name, {:dest_if_none_match => "inm-value"}
           end
 
           it "modifies the request headers when provided a :source_if_modified_since value" do
             request_headers["x-ms-source-if-modified-since"] = "ims-value"
-            subject.copy_blob container_name, blob_name, source_container_name, source_blob_name, { :source_if_modified_since => "ims-value" }
+            subject.copy_blob container_name, blob_name, source_container_name, source_blob_name, {:source_if_modified_since => "ims-value"}
           end
-          
+
           it "modifies the request headers when provided a :source_if_unmodified_since value" do
             request_headers["x-ms-source-if-unmodified-since"] = "iums-value"
-            subject.copy_blob container_name, blob_name, source_container_name, source_blob_name, { :source_if_unmodified_since => "iums-value" }
+            subject.copy_blob container_name, blob_name, source_container_name, source_blob_name, {:source_if_unmodified_since => "iums-value"}
           end
 
           it "modifies the request headers when provided a :source_if_match value" do
             request_headers["x-ms-source-if-match"] = "im-value"
-            subject.copy_blob container_name, blob_name, source_container_name, source_blob_name, { :source_if_match => "im-value" }
+            subject.copy_blob container_name, blob_name, source_container_name, source_blob_name, {:source_if_match => "im-value"}
           end
 
           it "modifies the request headers when provided a :source_if_none_match value" do
             request_headers["x-ms-source-if-none-match"] = "inm-value"
-            subject.copy_blob container_name, blob_name, source_container_name, source_blob_name, { :source_if_none_match => "inm-value" }
+            subject.copy_blob container_name, blob_name, source_container_name, source_blob_name, {:source_if_none_match => "inm-value"}
           end
 
           it "modifies the request headers when provided a :metadata value" do
             request_headers["x-ms-meta-MetadataKey"] = "MetaDataValue"
             request_headers["x-ms-meta-MetadataKey1"] = "MetaDataValue1"
-            options = { :metadata => { "MetadataKey" => "MetaDataValue", "MetadataKey1" => "MetaDataValue1"} }
+            options = {:metadata => {"MetadataKey" => "MetaDataValue", "MetadataKey1" => "MetaDataValue1"}}
             subject.copy_blob container_name, blob_name, source_container_name, source_blob_name, options
           end
 
           it "does not modify the request headers when provided an unknown value" do
-            subject.copy_blob container_name, blob_name, source_container_name, source_blob_name, { :unknown_key => "some_value" }
+            subject.copy_blob container_name, blob_name, source_container_name, source_blob_name, {:unknown_key => "some_value"}
           end
         end
       end
 
-      describe "lease functions" do 
-        let(:method) { :put }
+      describe "lease functions" do
+        let(:verb) { :put }
         let(:lease_id) { "lease-id" }
-        
-        before { 
-          query.update({"comp"=>"lease"})
+
+        before {
+          query.update({"comp" => "lease"})
           subject.stubs(:blob_uri).with(container_name, blob_name, query).returns(uri)
-          subject.stubs(:call).with(method, uri, nil, request_headers).returns(response)
+          subject.stubs(:call).with(verb, uri, nil, request_headers).returns(response)
         }
 
         describe "#acquire_lease" do
@@ -1740,14 +1762,14 @@ describe Azure::Blob::BlobService do
             response.stubs(:success?).returns(true)
             response_headers["x-ms-lease-id"] = lease_id
           }
-          
+
           it "assembles a URI for the request" do
             subject.expects(:blob_uri).with(container_name, blob_name, query).returns(uri)
             subject.acquire_lease container_name, blob_name
           end
 
           it "calls StorageService#call with the prepared request" do
-            subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
+            subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
             subject.acquire_lease container_name, blob_name
           end
 
@@ -1761,8 +1783,8 @@ describe Azure::Blob::BlobService do
             before { request_headers["x-ms-lease-duration"] = "37" }
 
             it "modifies the headers to include the provided duration value" do
-              subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
-              subject.acquire_lease container_name, blob_name, { :duration => duration }
+              subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
+              subject.acquire_lease container_name, blob_name, {:duration => duration}
             end
           end
 
@@ -1772,8 +1794,8 @@ describe Azure::Blob::BlobService do
             before { request_headers["x-ms-proposed-lease-id"] = proposed_lease_id }
 
             it "modifies the headers to include the proposed lease id" do
-              subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
-              subject.acquire_lease container_name, blob_name, { :duration => default_duration, :proposed_lease_id => proposed_lease_id }
+              subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
+              subject.acquire_lease container_name, blob_name, {:duration => default_duration, :proposed_lease_id => proposed_lease_id}
             end
           end
         end
@@ -1786,14 +1808,14 @@ describe Azure::Blob::BlobService do
             response.stubs(:success?).returns(true)
             response_headers["x-ms-lease-id"] = lease_id
           }
-          
+
           it "assembles a URI for the request" do
             subject.expects(:blob_uri).with(container_name, blob_name, query).returns(uri)
             subject.renew_lease container_name, blob_name, lease_id
           end
 
           it "calls StorageService#call with the prepared request" do
-            subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
+            subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
             subject.renew_lease container_name, blob_name, lease_id
           end
 
@@ -1810,14 +1832,14 @@ describe Azure::Blob::BlobService do
 
             response.stubs(:success?).returns(true)
           }
-          
+
           it "assembles a URI for the request" do
             subject.expects(:blob_uri).with(container_name, blob_name, query).returns(uri)
             subject.release_lease container_name, blob_name, lease_id
           end
 
           it "calls StorageService#call with the prepared request" do
-            subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
+            subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
             subject.release_lease container_name, blob_name, lease_id
           end
 
@@ -1835,14 +1857,14 @@ describe Azure::Blob::BlobService do
             response.stubs(:success?).returns(true)
             response_headers["x-ms-lease-time"] = lease_time.to_s
           }
-          
+
           it "assembles a URI for the request" do
             subject.expects(:blob_uri).with(container_name, blob_name, query).returns(uri)
             subject.break_lease container_name, blob_name
           end
 
           it "calls StorageService#call with the prepared request" do
-            subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
+            subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
             subject.break_lease container_name, blob_name
           end
 
@@ -1856,8 +1878,8 @@ describe Azure::Blob::BlobService do
             before { request_headers["x-ms-lease-break-period"] = break_period.to_s }
 
             it "modifies the request headers to include a break period" do
-              subject.expects(:call).with(method, uri, nil, request_headers).returns(response)
-              subject.break_lease container_name, blob_name, { :break_period => break_period }
+              subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
+              subject.break_lease container_name, blob_name, {:break_period => break_period}
             end
           end
         end
@@ -1884,10 +1906,10 @@ describe Azure::Blob::BlobService do
 
     let(:container_name) { "container" }
     let(:blob_name) { "blob" }
-    let(:query) { { "param" => "value", "param 1" => "value 1" } }
+    let(:query) { {"param" => "value", "param 1" => "value 1"} }
     let(:host_uri) { "http://dummy.uri" }
 
-    before { 
+    before {
       subject.host = host_uri
     }
 
@@ -1929,7 +1951,7 @@ describe Azure::Blob::BlobService do
       end
     end
 
-    describe "#blob_uri" do 
+    describe "#blob_uri" do
       it "returns a blob URI" do
         result = subject.blob_uri container_name, blob_name
         result.must_be_kind_of URI