azure 0.7.1 → 0.7.3

data/test/unit/affinity_group/serialization_test.rb

@@ -1,87 +0,0 @@
-#-------------------------------------------------------------------------
-# 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

@@ -1,19 +0,0 @@
-#-------------------------------------------------------------------------
-# 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

@@ -1,56 +0,0 @@
-#-------------------------------------------------------------------------
-# 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

@@ -1,50 +0,0 @@
-#-------------------------------------------------------------------------
-# 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

@@ -1,71 +0,0 @@
-#-------------------------------------------------------------------------
-# # 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

@@ -1,1970 +0,0 @@
-#-------------------------------------------------------------------------
-# # 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