azure-fix 0.7.0.pre3

data/test/unit/affinity_group/serialization_test.rb

@@ -0,0 +1,87 @@
+#-------------------------------------------------------------------------
+# Copyright 2013 Microsoft Open Technologies, Inc.
+#
+# 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'
+
+describe Azure::BaseManagement::Serialization do
+
+  subject { Azure::BaseManagement::Serialization }
+  let(:geo_location) { 'West Us' }
+
+  describe '#affinity_group_to_xml' do
+    let(:affinity_group_name) { 'AG1' }
+    let(:label) { 'Label Name' }
+
+    it 'serializes the argument to xml' do
+      result = subject.affinity_group_to_xml(affinity_group_name,
+                                             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 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'}
+      result = subject.affinity_group_to_xml(affinity_group_name,
+                                             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 geo_location
+      result.must_be_kind_of String
+    end
+  end
+
+  describe '#affinity_groups_from_xml' do
+    let(:affinity_groups_xml) do
+      Nokogiri::XML(Fixtures['list_affinity_groups'])
+    end
+
+    it 'accepts an XML string' do
+      subject.affinity_groups_from_xml affinity_groups_xml
+    end
+
+    it 'returns an Array of Azure::BaseManagementt::AffinityGroup instances' do
+      results = subject.affinity_groups_from_xml affinity_groups_xml
+      results.must_be_kind_of Array
+      results[0].must_be_kind_of Azure::BaseManagement::AffinityGroup
+      results.count.must_equal 2
+    end
+  end
+
+  describe '#affinity_group_from_xml' do
+
+    let(:affinity_group_xml) { Nokogiri::XML(Fixtures['affinity_group']) }
+
+    it 'accepts an XML string' do
+      subject.affinity_group_from_xml affinity_group_xml
+    end
+
+    it 'returns an Azure::BaseManagement::AffinityGroup instances' do
+      affinity_group = subject.affinity_group_from_xml affinity_group_xml
+      affinity_group.must_be_kind_of Azure::BaseManagement::AffinityGroup
+      affinity_group.hosted_services.size.must_equal 1
+      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
+    end
+  end
+end

data/test/unit/base_management/base_management_service_test.rb

@@ -0,0 +1,19 @@
+#-------------------------------------------------------------------------
+# Copyright 2013 Microsoft Open Technologies, Inc.
+#
+# 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'
+
+describe Azure::BaseManagement::BaseManagementService do
+
+end

data/test/unit/base_management/location_test.rb

@@ -0,0 +1,56 @@
+#-------------------------------------------------------------------------
+# Copyright 2013 Microsoft Open Technologies, Inc.
+#
+# 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'
+
+describe Azure::BaseManagement::Location do
+
+  subject do
+    Azure::BaseManagementService.new
+  end
+
+  describe '#list_locations' do
+    let(:request_path) { '/locations' }
+    let(:locations_xml) { Fixtures['list_locations'] }
+    let(:mock_request){ mock() }
+    let(:response) {
+      response = mock()
+      response.stubs(:body).returns(locations_xml)
+      response
+    }
+    let(:response_body) { Nokogiri::XML response.body }
+
+    before {
+      Azure::BaseManagement::ManagementHttpRequest.stubs(:new).with(:get, request_path, anything).returns(mock_request)
+      mock_request.expects(:call).returns(response_body)
+    }
+
+    it 'assembles a URI for the request' do
+      subject.list_locations
+    end
+
+    it 'sets the properties of the location' do
+      location = subject.list_locations.first
+      location.name.must_equal 'West US'
+    end
+
+    it 'returns a list of locations data center locations that are valid for given subscription' do
+      results = subject.list_locations
+      results.must_be_kind_of Array
+      results.length.must_equal 6
+      results.first.must_be_kind_of Azure::BaseManagement::Location
+    end
+  end
+
+end

data/test/unit/base_management/role_size_test.rb

@@ -0,0 +1,50 @@
+#-------------------------------------------------------------------------
+# Copyright 2013 Microsoft Open Technologies, Inc.
+#
+# 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'
+
+describe Azure::BaseManagement::Location do
+
+  subject do
+    Azure::BaseManagementService.new
+  end
+
+  describe '#list_role_sizes' do
+    let(:request_path) { '/locations' }
+    let(:locations_xml) { Fixtures['list_locations'] }
+    let(:mock_request){ mock() }
+    let(:response) {
+      response = mock()
+      response.stubs(:body).returns(locations_xml)
+      response
+    }
+    let(:response_body) { Nokogiri::XML response.body }
+
+    before {
+      Azure::BaseManagement::ManagementHttpRequest.stubs(:new).with(:get, request_path, anything).returns(mock_request)
+      mock_request.expects(:call).returns(response_body)
+    }
+
+    it 'assembles a URI for the request' do
+      subject.list_role_sizes
+    end
+
+    it 'returns a list of role-sizes that are valid for given subscription' do
+      results = subject.list_role_sizes
+      results.must_be_kind_of Array
+      results.length.must_equal 21
+    end
+  end
+
+end

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:             '2014-02-14',
+      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(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(path, options).must_equal(
+        "rwd\n\n2013-12-11\n/account-name/example/path\n\n2014-02-14\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(path).must_equal '/account-name/example/path'
+    end
+  end
+
+  describe '#signed_uri' do
+    let(:uri) { URI(subject.signed_uri(URI(path), options)) }
+    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(path, options))
+    end
+
+  end
+end

data/test/unit/blob/blob_service_test.rb

@@ -0,0 +1,1970 @@
+#-------------------------------------------------------------------------
+# # 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/blob_service'
+require 'azure/blob/serialization'
+require 'azure/blob/container'
+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(:x_ms_version) {'2014-02-14'}
+  let(:request_headers) { {'x-ms-version' => x_ms_version} }
+  let(:request_body) { 'request-body' }
+
+  let(:response_headers) { {} }
+  let(:response_body) { mock() }
+  let(:response) { mock() }
+
+  before {
+    response.stubs(:body).returns(response_body)
+    response.stubs(:headers).returns(response_headers)
+  }
+
+  describe '#list_containers' do
+    let(:verb) { :get }
+    let(:container_enumeration_result) { Azure::Service::EnumerationResults.new }
+
+    before {
+      subject.stubs(:containers_uri).with({}).returns(uri)
+      subject.stubs(:call).with(verb, uri).returns(response)
+      serialization.stubs(:container_enumeration_results_from_xml).with(response_body).returns(container_enumeration_result)
+    }
+
+    it 'assembles a URI for the request' do
+      subject.expects(:containers_uri).with({}).returns(uri)
+      subject.list_containers
+    end
+
+    it 'calls StorageService#call with the prepared request' do
+      subject.expects(:call).with(verb, uri).returns(response)
+      subject.list_containers
+    end
+
+    it 'deserializes the response' do
+      serialization.expects(:container_enumeration_results_from_xml).with(response_body).returns(container_enumeration_result)
+      subject.list_containers
+    end
+
+    it 'returns a list of containers for the account' do
+      result = subject.list_containers
+      result.must_be_kind_of Azure::Service::EnumerationResults
+    end
+
+    describe 'when the options Hash is used' do
+      before {
+        subject.expects(:call).with(:get, uri).returns(response)
+        serialization.expects(:container_enumeration_results_from_xml).with(response_body).returns(container_enumeration_result)
+      }
+
+      it 'modifies the URI query parameters when provided a :prefix value' do
+        query = {'prefix' => 'pre'}
+        subject.expects(:containers_uri).with(query).returns(uri)
+
+        options = {:prefix => 'pre'}
+        subject.list_containers options
+      end
+
+      it 'modifies the URI query parameters when provided a :marker value' do
+        query = {'marker' => 'mark'}
+        subject.expects(:containers_uri).with(query).returns(uri)
+
+        options = {:marker => 'mark'}
+        subject.list_containers options
+      end
+
+      it 'modifies the URI query parameters when provided a :max_results value' do
+        query = {'maxresults' => '5'}
+        subject.expects(:containers_uri).with(query).returns(uri)
+
+        options = {:max_results => 5}
+        subject.list_containers options
+      end
+
+      it 'modifies the URI query parameters when provided a :metadata value' do
+        query = {'include' => 'metadata'}
+        subject.expects(:containers_uri).with(query).returns(uri)
+
+        options = {:metadata => true}
+        subject.list_containers options
+      end
+
+      it 'modifies the URI query parameters when provided a :timeout value' do
+        query = {'timeout' => '37'}
+        subject.expects(:containers_uri).with(query).returns(uri)
+
+        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'}
+        subject.list_containers options
+      end
+    end
+  end
+
+  describe 'container functions' do
+    let(:container_name) { 'container-name' }
+    let(:container) { Azure::Blob::Container.new }
+
+    describe '#create_container' do
+
+      let(:verb) { :put }
+      before {
+        subject.stubs(:container_uri).with(container_name, {}).returns(uri)
+        subject.stubs(:call).with(verb, uri, nil, request_headers).returns(response)
+        serialization.stubs(:container_from_headers).with(response_headers).returns(container)
+      }
+
+      it 'assembles a URI for the request' do
+        subject.expects(:container_uri).with(container_name, {}).returns(uri)
+        subject.create_container container_name
+      end
+
+      it 'calls StorageService#call with the prepared request' do
+        subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
+        subject.create_container container_name
+      end
+
+      it 'deserializes the response' do
+        serialization.expects(:container_from_headers).with(response_headers).returns(container)
+        subject.create_container container_name
+      end
+
+      it 'returns a new container' do
+        result = subject.create_container container_name
+
+        result.must_be_kind_of Azure::Blob::Container
+        result.name.must_equal container_name
+      end
+
+      describe 'when optional metadata parameter is used' do
+        let(:container_metadata) {
+          {
+              'MetadataKey' => 'MetaDataValue',
+              'MetadataKey1' => 'MetaDataValue1'}
+        }
+
+        before do
+          request_headers = {
+              'x-ms-meta-MetadataKey' => 'MetaDataValue',
+              'x-ms-meta-MetadataKey1' => 'MetaDataValue1',
+              'x-ms-version' => x_ms_version
+          }
+          subject.stubs(:container_uri).with(container_name, {}).returns(uri)
+          serialization.stubs(:container_from_headers).with(response_headers).returns(container)
+          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
+        end
+      end
+
+      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, 'x-ms-version' => x_ms_version}
+
+          subject.stubs(:container_uri).with(container_name, {}).returns(uri)
+          serialization.stubs(:container_from_headers).with(response_headers).returns(container)
+          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}
+        end
+      end
+    end
+
+    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(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(verb, uri).returns(response)
+        subject.delete_container container_name
+      end
+
+      it 'returns nil on success' do
+        result = subject.delete_container container_name
+        result.must_equal nil
+      end
+    end
+
+    describe '#get_container_properties' do
+      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(verb, uri).returns(response)
+        serialization.stubs(:container_from_headers).with(response_headers).returns(container)
+      }
+
+      it 'assembles a URI for the request' do
+        subject.expects(:container_uri).with(container_name, {}).returns(uri)
+        subject.get_container_properties container_name
+      end
+
+      it 'calls StorageService#call with the prepared request' do
+        subject.expects(:call).with(verb, uri).returns(response)
+        subject.get_container_properties container_name
+      end
+
+      it 'deserializes the response' do
+        serialization.expects(:container_from_headers).with(response_headers).returns(container)
+        subject.get_container_properties container_name
+      end
+
+      it "returns a container, with it's properties attribute populated" do
+        result = subject.get_container_properties container_name
+        result.must_be_kind_of Azure::Blob::Container
+        result.name.must_equal container_name
+        result.properties.must_equal container_properties
+      end
+    end
+
+    describe '#get_container_metadata' do
+      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)
+        subject.stubs(:container_uri).with(container_name, query).returns(uri)
+        subject.stubs(:call).with(verb, uri).returns(response)
+
+        container.metadata = container_metadata
+        serialization.stubs(:container_from_headers).with(response_headers).returns(container)
+      }
+
+      it 'assembles a URI for the request' do
+        subject.expects(:container_uri).with(container_name, query).returns(uri)
+        subject.get_container_metadata container_name
+      end
+
+      it 'calls StorageService#call with the prepared request' do
+        subject.expects(:call).with(verb, uri).returns(response)
+        subject.get_container_metadata container_name
+      end
+
+      it 'deserializes the response' do
+        serialization.expects(:container_from_headers).with(response_headers).returns(container)
+        subject.get_container_metadata container_name
+      end
+
+      it "returns a container, with it's metadata attribute populated" do
+        result = subject.get_container_metadata container_name
+        result.must_be_kind_of Azure::Blob::Container
+        result.name.must_equal container_name
+        result.metadata.must_equal container_metadata
+      end
+    end
+
+    describe '#get_container_acl' do
+      let(:verb) { :get }
+      let(:signed_identifier) { Azure::Service::SignedIdentifier.new }
+      let(:signed_identifiers) { [signed_identifier] }
+
+      before {
+        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(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)
+      }
+
+      it 'assembles a URI for the request' do
+        subject.expects(:container_uri).with(container_name, query).returns(uri)
+        subject.get_container_acl container_name
+      end
+
+      it 'calls StorageService#call with the prepared request' do
+        subject.expects(:call).with(verb, uri).returns(response)
+        subject.get_container_acl container_name
+      end
+
+      it 'deserializes the response' do
+        serialization.expects(:container_from_headers).with(response_headers).returns(container)
+        serialization.expects(:signed_identifiers_from_xml).with(response_body).returns(signed_identifiers)
+        subject.get_container_acl container_name
+      end
+
+      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
+
+        returned_acl.must_be_kind_of Array
+        returned_acl[0].must_be_kind_of Azure::Service::SignedIdentifier
+      end
+    end
+
+    describe '#set_container_acl' do
+      let(:verb) { :put }
+      let(:public_access_level) { 'any-public-access-level' }
+
+      before {
+        query.update({'comp' => 'acl'})
+        request_headers['x-ms-blob-public-access'] = public_access_level
+
+        response.stubs(:headers).returns({})
+        subject.stubs(:container_uri).with(container_name, query).returns(uri)
+        subject.stubs(:call).with(verb, uri, nil, request_headers).returns(response)
+        serialization.stubs(:container_from_headers).with(response_headers).returns(container)
+      }
+
+      it 'assembles a URI for the request' do
+        subject.expects(:container_uri).with(container_name, query).returns(uri)
+        subject.set_container_acl container_name, public_access_level
+      end
+
+      it 'calls StorageService#call with the prepared request' do
+        subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
+        subject.set_container_acl container_name, public_access_level
+      end
+
+
+      it 'deserializes the response' do
+        serialization.expects(:container_from_headers).with(response_headers).returns(container)
+        subject.set_container_acl container_name, public_access_level
+      end
+
+      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 {
+          request_headers['x-ms-blob-public-access'] = public_access_level
+        }
+
+        it 'sets the x-ms-blob-public-access header' do
+          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] }
+          before {
+            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}
+          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.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
+            returned_acl[0].must_be_kind_of Azure::Service::SignedIdentifier
+          end
+        end
+      end
+
+      describe 'when the public_access_level parameter is set to nil' do
+        let(:public_access_level) { nil }
+        before {
+          request_headers.delete 'x-ms-blob-public-access'
+        }
+
+        it 'sets the x-ms-blob-public-access header' do
+          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 {
+          request_headers.delete 'x-ms-blob-public-access'
+        }
+
+        it 'sets the x-ms-blob-public-access header' do
+          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(: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' => x_ms_version} }
+
+      before {
+        query.update({'comp' => 'metadata'})
+        response.stubs(:success?).returns(true)
+        subject.stubs(:container_uri).with(container_name, query).returns(uri)
+        subject.stubs(:call).with(verb, uri, nil, request_headers).returns(response)
+      }
+
+      it 'assembles a URI for the request' do
+        subject.expects(:container_uri).with(container_name, query).returns(uri)
+        subject.set_container_metadata container_name, container_metadata
+      end
+
+      it 'calls StorageService#call with the prepared request' do
+        subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
+        subject.set_container_metadata container_name, container_metadata
+      end
+
+      it 'returns nil on success' do
+        result = subject.set_container_metadata container_name, container_metadata
+        result.must_equal nil
+      end
+    end
+
+    describe '#list_blobs' do
+      let(:verb) { :get }
+      let(:query) { {'comp' => 'list'} }
+      let(:blob_enumeration_results) { Azure::Service::EnumerationResults.new }
+
+      before {
+        subject.stubs(:container_uri).with(container_name, query).returns(uri)
+        subject.stubs(:call).with(verb, uri).returns(response)
+        serialization.stubs(:blob_enumeration_results_from_xml).with(response_body).returns(blob_enumeration_results)
+      }
+
+      it 'assembles a URI for the request' do
+        subject.expects(:container_uri).with(container_name, query).returns(uri)
+        subject.list_blobs container_name
+      end
+
+      it 'calls StorageService#call with the prepared request' do
+        subject.expects(:call).with(verb, uri).returns(response)
+        subject.list_blobs container_name
+      end
+
+      it 'deserializes the response' do
+        serialization.expects(:blob_enumeration_results_from_xml).with(response_body).returns(blob_enumeration_results)
+        subject.list_blobs container_name
+      end
+
+      it 'returns a list of containers for the account' do
+        result = subject.list_blobs container_name
+        result.must_be_kind_of Azure::Service::EnumerationResults
+      end
+
+      describe 'when the options Hash is used' do
+        before {
+          subject.expects(:call).with(:get, uri).returns(response)
+          serialization.expects(:blob_enumeration_results_from_xml).with(response_body).returns(blob_enumeration_results)
+          subject.expects(:container_uri).with(container_name, query).returns(uri)
+        }
+
+        it 'modifies the URI query parameters when provided a :prefix value' do
+          query['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'}
+          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'}
+          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}
+          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}
+          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}
+          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}
+          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}
+          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
+          }
+
+          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}
+          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'}
+          subject.list_blobs container_name, options
+        end
+      end
+    end
+
+    describe 'blob functions' do
+      let(:blob_name) { 'blob-name' }
+      let(:blob) { Azure::Blob::Blob.new }
+
+      describe '#create_page_blob' do
+        let(:verb) { :put }
+        let(:blob_length) { 37 }
+        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-version' => x_ms_version
+          }
+        }
+
+        before {
+          subject.stubs(:blob_uri).with(container_name, blob_name, {}).returns(uri)
+          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, {}).returns(uri)
+          subject.create_page_blob container_name, blob_name, blob_length
+        end
+
+        it 'calls StorageService#call with the prepared request' do
+          subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
+          subject.create_page_blob container_name, blob_name, blob_length
+        end
+
+        it 'returns a Blob on success' do
+          result = subject.create_page_blob container_name, blob_name, blob_length
+          result.must_be_kind_of Azure::Blob::Blob
+          result.must_equal blob
+          result.name.must_equal blob_name
+        end
+
+        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}
+          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'}
+          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'}
+          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'}
+          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'}
+          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'}
+          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'}
+          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'}
+          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'}
+          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'}
+          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'}
+          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'}}
+            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'}
+          end
+        end
+      end
+
+      describe '#create_blob_pages' do
+        let(:verb) { :put }
+        let(:start_range) { 255 }
+        let(:end_range) { 512 }
+        let(:content) { 'some content' }
+        let(:query) { {'comp' => 'page'} }
+        let(:request_headers) {
+          {
+              'x-ms-page-write' => 'update',
+              'x-ms-range' => "bytes=#{start_range}-#{end_range}",
+              'Content-Type' => '',
+              'x-ms-version' => x_ms_version
+          }
+        }
+
+        before {
+          subject.stubs(:blob_uri).with(container_name, blob_name, query).returns(uri)
+          subject.stubs(:call).with(verb, uri, content, 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.create_blob_pages container_name, blob_name, start_range, end_range, content
+        end
+
+        it 'calls StorageService#call with the prepared request' do
+          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
+
+        it 'returns a Blob on success' do
+          result = subject.create_blob_pages container_name, blob_name, start_range, end_range, content
+          result.must_be_kind_of Azure::Blob::Blob
+          result.must_equal blob
+          result.name.must_equal blob_name
+        end
+
+        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'}
+          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'}
+          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'}
+          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'}
+          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'}
+          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'}
+          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'}
+          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'}
+          end
+        end
+      end
+
+      describe '#clear_blob_pages' do
+        let(:verb) { :put }
+        let(:query) { {'comp' => 'page'} }
+        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-version' => x_ms_version
+          }
+        }
+
+        before {
+          subject.stubs(:blob_uri).with(container_name, blob_name, query).returns(uri)
+          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.clear_blob_pages container_name, blob_name, start_range, end_range
+        end
+
+        it 'calls StorageService#call with the prepared request' do
+          subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
+          subject.clear_blob_pages container_name, blob_name, start_range, end_range
+        end
+
+        it 'returns a Blob on success' do
+          result = subject.clear_blob_pages container_name, blob_name, start_range, end_range
+          result.must_be_kind_of Azure::Blob::Blob
+          result.must_equal blob
+          result.name.must_equal blob_name
+        end
+
+        # describe "when start_range is provided" do
+        #   let(:start_range){ 255 }
+        #   before { request_headers["x-ms-range"]="#{start_range}-" }
+
+        #   it "modifies the request headers with the desired range" do
+        #     subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
+        #     subject.clear_blob_pages container_name, blob_name, start_range
+        #   end
+        # end
+
+        # describe "when end_range is provided" do
+        #   let(:end_range){ 512 }
+        #   before { request_headers["x-ms-range"]="0-#{end_range}" }
+
+        #   it "modifies the request headers with the desired range" do
+        #     subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
+        #     subject.clear_blob_pages container_name, blob_name, nil, end_range
+        #   end
+        # end
+
+        # describe "when both start_range and end_range are provided" 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(verb, uri, nil, request_headers).returns(response)
+        #     subject.clear_blob_pages container_name, blob_name, start_range, end_range
+        #   end
+        # end
+      end
+
+      describe '#create_blob_block' do
+        require 'base64'
+
+        let(:verb) { :put }
+        let(:content) { 'some content' }
+        let(:block_id) { 'block-id' }
+        let(:server_generated_content_md5) { 'server-content-md5' }
+        let(:request_headers) { {'x-ms-version' => x_ms_version} }
+
+        before {
+          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(verb, uri, content, 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_block container_name, blob_name, block_id, content
+        end
+
+        it 'calls StorageService#call with the prepared request' do
+          subject.expects(:call).with(verb, uri, content, request_headers).returns(response)
+          subject.create_blob_block container_name, blob_name, block_id, content
+        end
+
+        it 'returns content MD5 on success' do
+          result = subject.create_blob_block container_name, blob_name, block_id, content
+          result.must_equal server_generated_content_md5
+        end
+
+        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'}
+          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'}
+          end
+        end
+      end
+
+      describe '#create_block_blob' do
+        let(:verb) { :put }
+        let(:content) { 'some content' }
+        let(:request_headers) {
+          {
+              'x-ms-blob-type' => 'BlockBlob',
+              'Content-Type' => 'application/octet-stream',
+              'x-ms-version' => x_ms_version
+          }
+        }
+
+        before {
+          subject.stubs(:blob_uri).with(container_name, blob_name, {}).returns(uri)
+          subject.stubs(:call).with(verb, uri, content, 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, {}).returns(uri)
+          subject.create_block_blob container_name, blob_name, content
+        end
+
+        it 'calls StorageService#call with the prepared request' do
+          subject.expects(:call).with(verb, uri, content, request_headers).returns(response)
+          subject.create_block_blob container_name, blob_name, content
+        end
+
+        it 'returns a Blob on success' do
+          result = subject.create_block_blob container_name, blob_name, content
+          result.must_be_kind_of Azure::Blob::Blob
+          result.must_equal blob
+          result.name.must_equal blob_name
+        end
+
+        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'}
+          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'}
+          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'}
+          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'}
+          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'}
+          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'}
+          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'}
+          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'}
+          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'}
+          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'}
+          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'}}
+            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'}
+          end
+        end
+      end
+
+      describe '#commit_blob_blocks' do
+        let(:verb) { :put }
+        let(:request_body) { 'body' }
+        let(:block_list) { mock() }
+        let(:request_headers) { {'x-ms-version' => x_ms_version} }
+
+        before {
+          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(verb, uri, request_body, 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.commit_blob_blocks container_name, blob_name, block_list
+        end
+
+        it 'calls StorageService#call with the prepared request' do
+          subject.expects(:call).with(verb, uri, request_body, request_headers).returns(response)
+          subject.commit_blob_blocks container_name, blob_name, block_list
+        end
+
+        it 'serializes the block list' do
+          serialization.expects(:block_list_to_xml).with(block_list).returns(request_body)
+          subject.commit_blob_blocks container_name, blob_name, block_list
+        end
+
+        it 'returns nil on success' do
+          result = subject.commit_blob_blocks container_name, blob_name, block_list
+          result.must_equal nil
+        end
+
+        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'}
+          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'}
+          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'}
+          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'}
+          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'}
+          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'}
+          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'}}
+            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'}
+          end
+        end
+      end
+
+      describe '#list_blob_blocks' do
+        let(:verb) { :get }
+        let(:query) { {'comp' => 'blocklist', 'blocklisttype' => 'all'} }
+        let(:blob_block_list) { [Azure::Blob::Block.new] }
+
+        before {
+          subject.stubs(:blob_uri).with(container_name, blob_name, query).returns(uri)
+          subject.stubs(:call).with(verb, uri).returns(response)
+          serialization.stubs(:block_list_from_xml).with(response_body).returns(blob_block_list)
+        }
+
+        it 'assembles a URI for the request' do
+          subject.expects(:blob_uri).with(container_name, blob_name, query).returns(uri)
+          subject.list_blob_blocks container_name, blob_name
+        end
+
+        it 'calls StorageService#call with the prepared request' do
+          subject.expects(:call).with(verb, uri).returns(response)
+          subject.list_blob_blocks container_name, blob_name
+        end
+
+        it 'deserializes the response' do
+          serialization.expects(:block_list_from_xml).with(response_body).returns(blob_block_list)
+          subject.list_blob_blocks container_name, blob_name
+        end
+
+        it 'returns a list of containers for the account' do
+          result = subject.list_blob_blocks container_name, blob_name
+          result.must_be_kind_of Array
+          result.first.must_be_kind_of Azure::Blob::Block
+        end
+
+        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}
+          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}
+          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}
+          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'}
+          end
+        end
+      end
+
+      describe '#list_page_blob_ranges' do
+        let(:verb) { :get }
+        let(:query) { {'comp' => 'pagelist'} }
+        let(:page_list) { [[0, 511], [512, 1023]] }
+
+        before {
+          subject.stubs(:blob_uri).with(container_name, blob_name, query).returns(uri)
+          subject.stubs(:call).with(verb, uri, nil, request_headers).returns(response)
+          serialization.stubs(:page_list_from_xml).with(response_body).returns(page_list)
+        }
+
+        it 'assembles a URI for the request' do
+          subject.expects(:blob_uri).with(container_name, blob_name, query).returns(uri)
+          subject.list_page_blob_ranges container_name, blob_name
+        end
+
+        it 'calls StorageService#call with the prepared request' do
+          subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
+          subject.list_page_blob_ranges container_name, blob_name
+        end
+
+        it 'deserializes the response' do
+          serialization.expects(:page_list_from_xml).with(response_body).returns(page_list)
+          subject.list_page_blob_ranges container_name, blob_name
+        end
+
+        it 'returns a list of containers for the account' do
+          result = subject.list_page_blob_ranges container_name, blob_name
+          result.must_be_kind_of Array
+          result.first.must_be_kind_of Array
+          result.first.first.must_be_kind_of Integer
+          result.first.first.next.must_be_kind_of Integer
+        end
+
+        # describe "when start_range is provided" do
+        #   let(:start_range){ 255 }
+        #   before { request_headers["x-ms-range"]="#{start_range}-" }
+
+        #   it "modifies the request headers with the desired range" do
+        #     subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
+        #     subject.list_page_blob_ranges container_name, blob_name, start_range
+        #   end
+        # end
+
+        # describe "when end_range is provided" do
+        #   let(:end_range){ 512 }
+        #   before { request_headers["x-ms-range"]="0-#{end_range}" }
+
+        #   it "modifies the request headers with the desired range" do
+        #     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 }
+          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(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'}
+          end
+        end
+      end
+
+      describe '#set_blob_properties' do
+        let(:verb) { :put }
+        let(:request_headers) { {'x-ms-version' => x_ms_version} }
+
+        before {
+          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(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.set_blob_properties container_name, blob_name
+        end
+
+        it 'calls StorageService#call with the prepared request' do
+          subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
+          subject.set_blob_properties container_name, blob_name
+        end
+
+        it 'returns nil on success' do
+          result = subject.set_blob_properties container_name, blob_name
+          result.must_equal nil
+        end
+
+        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'}
+          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'}
+          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'}
+          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'}
+          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'}
+          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}
+          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}
+          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}
+          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'}
+          end
+        end
+      end
+
+      describe '#set_blob_metadata' do
+        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' => x_ms_version} }
+
+        before {
+          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(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.set_blob_metadata container_name, blob_name, blob_metadata
+        end
+
+        it 'calls StorageService#call with the prepared request' do
+          subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
+          subject.set_blob_metadata container_name, blob_name, blob_metadata
+        end
+
+        it 'returns nil on success' do
+          result = subject.set_blob_metadata container_name, blob_name, blob_metadata
+          result.must_equal nil
+        end
+      end
+
+      describe '#get_blob_properties' do
+        let(:verb) { :head }
+
+        before {
+          subject.stubs(:blob_uri).with(container_name, blob_name, query).returns(uri)
+          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(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' }
+          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}
+          end
+
+          it 'sets the snapshot value on the returned blob' do
+            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(:verb) { :get }
+
+        before {
+          query['comp']='metadata'
+
+          subject.stubs(:blob_uri).with(container_name, blob_name, query).returns(uri)
+          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(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
+            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}
+          end
+
+          it 'sets the snapshot value on the returned blob' do
+            result = subject.get_blob_metadata container_name, blob_name, {:snapshot => snapshot}
+            result.snapshot.must_equal snapshot
+          end
+        end
+      end
+
+      describe '#get_blob' do
+        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(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(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
+
+          returned_blob_contents.must_equal response_body
+        end
+
+        describe 'when snapshot is provided' do
+          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}
+          end
+        end
+
+        # describe "when start_range is provided" do
+        #   let(:start_range){ 255 }
+        #   before { request_headers["x-ms-range"]="#{start_range}-" }
+
+        #   it "modifies the request headers with the desired range" do
+        #     subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
+        #     subject.get_blob container_name, blob_name, start_range
+        #   end
+        # end
+
+        # describe "when end_range is provided" do
+        #   let(:end_range){ 512 }
+        #   before { request_headers["x-ms-range"]="0-#{end_range}" }
+
+        #   it "modifies the request headers with the desired range" do
+        #     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}"
+          }
+
+          it 'modifies the request headers with the desired range' do
+            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
+
+        describe 'when get_content_md5 is true' do
+          let(:get_content_md5) { true }
+
+          describe 'and a range is specified' do
+            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(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(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(:verb) { :delete }
+
+        before {
+          response.stubs(:success?).returns(true)
+          request_headers['x-ms-delete-snapshots'] = 'include'
+          request_headers['x-ms-version'] = x_ms_version
+
+          subject.stubs(:blob_uri).with(container_name, blob_name, query).returns(uri)
+          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(verb, uri, nil, request_headers).returns(response)
+          subject.delete_blob container_name, blob_name
+        end
+
+        it 'returns nil on success' 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' }
+          before {
+            request_headers.delete 'x-ms-delete-snapshots'
+            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}
+          end
+
+          it 'does not include a x-ms-delete-snapshots header' do
+            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 }
+          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(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 }
+          before {
+            request_headers.delete 'x-ms-delete-snapshots'
+            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}
+          end
+
+          it 'does not include a x-ms-delete-snapshots header' do
+            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(: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(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(verb, uri, nil, request_headers).returns(response)
+          subject.create_blob_snapshot container_name, blob_name
+        end
+
+        it 'returns the snapshot id on success' do
+          result = subject.create_blob_snapshot container_name, blob_name
+          result.must_be_kind_of String
+          result.must_equal snapshot_id
+        end
+
+        describe 'when the options Hash is used' do
+          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'}
+          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'}
+          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'}
+          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'}
+          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'}}
+            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'}
+          end
+        end
+      end
+
+      describe '#copy_blob' do
+        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' }
+
+        before {
+          request_headers['x-ms-copy-source'] = source_uri.to_s
+
+          response_headers['x-ms-copy-id'] = copy_id
+          response_headers['x-ms-copy-status'] = copy_status
+
+          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(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
+        end
+
+        it 'assembles the source URI and places it in the header' 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
+        end
+
+        it 'calls StorageService#call with the prepared request' do
+          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
+
+        it 'returns the copy id and copy status on success' do
+          returned_copy_id, returned_copy_status = subject.copy_blob container_name, blob_name, source_container_name, source_blob_name
+          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 {
+            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}
+          end
+        end
+
+        describe 'when the options Hash is used' do
+          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'}
+          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'}
+          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'}
+          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'}
+          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'}
+          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'}
+          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'}
+          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'}
+          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'}}
+            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'}
+          end
+        end
+      end
+
+      describe 'lease functions' do
+        let(:verb) { :put }
+        let(:lease_id) { 'lease-id' }
+
+        before {
+          query.update({'comp' => 'lease'})
+          subject.stubs(:blob_uri).with(container_name, blob_name, query).returns(uri)
+          subject.stubs(:call).with(verb, uri, nil, request_headers).returns(response)
+        }
+
+        describe '#acquire_lease' do
+          before {
+            request_headers['x-ms-lease-action'] = 'acquire'
+            request_headers['x-ms-lease-duration'] = '-1'
+
+            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(verb, uri, nil, request_headers).returns(response)
+            subject.acquire_lease container_name, blob_name
+          end
+
+          it 'returns lease id on success' do
+            result = subject.acquire_lease container_name, blob_name
+            result.must_equal lease_id
+          end
+
+          describe 'when passed a duration' do
+            let(:duration) { 37 }
+            before { request_headers['x-ms-lease-duration'] = '37' }
+
+            it 'modifies the headers to include the provided duration value' do
+              subject.expects(:call).with(verb, uri, nil, request_headers).returns(response)
+              subject.acquire_lease container_name, blob_name, {:duration => duration}
+            end
+          end
+
+          describe 'when passed a proposed_lease_id' do
+            let(:default_duration) { -1 }
+            let(:proposed_lease_id) { 'proposed-lease-id' }
+            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(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
+
+        describe '#renew_lease' do
+          before {
+            request_headers['x-ms-lease-action'] = 'renew'
+            request_headers['x-ms-lease-id'] = lease_id
+
+            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(verb, uri, nil, request_headers).returns(response)
+            subject.renew_lease container_name, blob_name, lease_id
+          end
+
+          it 'returns lease id on success' do
+            result = subject.renew_lease container_name, blob_name, lease_id
+            result.must_equal lease_id
+          end
+        end
+
+        describe '#release_lease' do
+          before {
+            request_headers['x-ms-lease-action'] = 'release'
+            request_headers['x-ms-lease-id'] = lease_id
+
+            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(verb, uri, nil, request_headers).returns(response)
+            subject.release_lease container_name, blob_name, lease_id
+          end
+
+          it 'returns nil on success' do
+            result = subject.release_lease container_name, blob_name, lease_id
+            result.must_equal nil
+          end
+        end
+
+        describe '#break_lease' do
+          let(:lease_time) { 38 }
+          before {
+            request_headers['x-ms-lease-action'] = 'break'
+
+            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(verb, uri, nil, request_headers).returns(response)
+            subject.break_lease container_name, blob_name
+          end
+
+          it 'returns lease time on success' do
+            result = subject.break_lease container_name, blob_name
+            result.must_equal lease_time
+          end
+
+          describe 'when passed an optional break period' do
+            let(:break_period) { 37 }
+            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(verb, uri, nil, request_headers).returns(response)
+              subject.break_lease container_name, blob_name, {:break_period => break_period}
+            end
+          end
+        end
+      end
+    end
+  end
+
+  class MockBlobService < Azure::Blob::BlobService
+    def containers_uri(query={})
+      super
+    end
+
+    def container_uri(name, query={})
+      super
+    end
+
+    def blob_uri(container_name, blob_name, query={})
+      super
+    end
+  end
+
+  describe 'uri functions' do
+    subject { MockBlobService.new }
+
+    let(:container_name) { 'container' }
+    let(:blob_name) { 'blob' }
+    let(:query) { {'param' => 'value', 'param 1' => 'value 1'} }
+    let(:host_uri) { 'http://dummy.uri' }
+
+    before {
+      subject.host = host_uri
+    }
+
+    describe '#containers_uri' do
+      it 'returns a containers URI' do
+        result = subject.containers_uri
+        result.must_be_kind_of URI
+        result.scheme.must_equal 'http'
+        result.host.must_equal 'dummy.uri'
+        result.path.must_equal '/'
+        result.query.must_equal 'comp=list'
+      end
+
+      it 'encodes optional query has as uri parameters' do
+        result = subject.containers_uri query
+        result.query.must_equal 'comp=list&param=value&param+1=value+1'
+      end
+    end
+
+    describe '#container_uri' do
+      it 'returns a container URI' do
+        result = subject.container_uri container_name
+        result.must_be_kind_of URI
+        result.scheme.must_equal 'http'
+        result.host.must_equal 'dummy.uri'
+        result.path.must_equal '/container'
+        result.query.must_equal 'restype=container'
+      end
+
+      it 'encodes optional query has as uri parameters' do
+        result = subject.container_uri container_name, query
+        result.query.must_equal 'restype=container&param=value&param+1=value+1'
+      end
+
+      it 'returns the same URI instance when the first parameter is a URI' do
+        random_uri = URI.parse('http://random.uri')
+        result = subject.container_uri random_uri
+        result.must_equal random_uri
+      end
+    end
+
+    describe '#blob_uri' do
+      it 'returns a blob URI' do
+        result = subject.blob_uri container_name, blob_name
+        result.must_be_kind_of URI
+        result.scheme.must_equal 'http'
+        result.host.must_equal 'dummy.uri'
+        result.path.must_equal '/container/blob'
+      end
+
+      it 'encodes optional query has as uri parameters' do
+        result = subject.blob_uri container_name, blob_name, query
+        result.query.must_equal 'param=value&param+1=value+1'
+      end
+    end
+  end
+end