fog 1.12.1 → 1.13.0

data/tests/rackspace/models/storage/file_tests.rb

@@ -60,11 +60,6 @@ Shindo.tests('Fog::Rackspace::Storage | file', ['rackspace']) do
     directories.
     create(directory_attributes)
 
-  model_tests(@directory.files, file_attributes.merge(:etag => 'foo'), Fog.mocking?) do
-    tests('#save should not blow up with etag') do
-      @instance.save
-    end
-  end
 
   model_tests(@directory.files, file_attributes, Fog.mocking?) do
 
@@ -187,8 +182,29 @@ Shindo.tests('Fog::Rackspace::Storage | file', ['rackspace']) do
           tests('#streaming_url').returns(0) do
             @instance.streaming_url =~ /http:\/\/.+\.stream\..*#{@instance.key}/
           end
-        end        
+        end
+
+      tests('etags') do
+        text = lorem_file.read
+        md5 = Digest::MD5.new
+        md5 << text
+        etag = md5.hexdigest
+
+        begin
+          tests('valid tag').returns(true) do
+            @file = @directory.files.create :key => 'valid-etag.txt', :body => text,  :etag => etag
+            @file.reload
+            @file.etag == etag
+          end
+        ensure
+          @file.destroy if @file
+        end
+
+        tests('invalid tag').raises(Fog::Storage::Rackspace::ServiceError) do
+          @directory.files.create :key => 'invalid-etag.txt', :body => text,  :etag => "bad-bad-tag"
+        end
       end
+    end
     
       tests('#metadata keys') do
         

data/tests/rackspace/rackspace_tests.rb

@@ -18,4 +18,39 @@ Shindo.tests('Fog::Rackspace', ['rackspace']) do
     end
   end
 
+  tests('json_response?') do
+    returns(false, "nil") { Fog::Rackspace.json_response?(nil) }
+
+    tests('missing header').returns(false) do
+      response = Excon::Response.new
+      response.headers = nil #maybe this is a forced case
+      returns(true) { response.headers.nil? }
+      Fog::Rackspace.json_response?(response)
+    end
+
+    tests('nil Content-Type header').returns(false) do
+      response = Excon::Response.new
+      response.headers['Content-Type'] = nil
+      Fog::Rackspace.json_response?(response)
+    end
+
+    tests('text/html Content-Type header').returns(false) do
+      response = Excon::Response.new
+      response.headers['Content-Type'] = 'text/html'
+      Fog::Rackspace.json_response?(response)
+    end
+
+    tests('application/json Content-Type header').returns(true) do
+      response = Excon::Response.new
+      response.headers['Content-Type'] = 'application/json'
+      Fog::Rackspace.json_response?(response)
+    end
+
+    tests('APPLICATION/JSON Content-Type header').returns(true) do
+      response = Excon::Response.new
+      response.headers['Content-Type'] = 'APPLICATION/JSON'
+      Fog::Rackspace.json_response?(response)
+    end
+  end
+
 end

data/tests/rackspace/requests/block_storage/snapshot_tests.rb

@@ -8,9 +8,8 @@ Shindo.tests('Fog::Rackspace::BlockStorage | snapshot_tests', ['rackspace']) do
     'display_description' => Fog::Nullable::String,
     'volume_id' => String,
     'size' => Integer,
-    'created_at' => String,
-    'availability_zone' => String
-  }
+    'created_at' => String
+    }
 
   get_snapshot_format = {
     'snapshot' => snapshot_format

data/tests/rackspace/requests/block_storage/volume_type_tests.rb

@@ -1,15 +1,8 @@
 Shindo.tests('Fog::Rackspace::BlockStorage | volume_type_tests', ['rackspace']) do
   volume_type_format = {
     'name' => String,
-    'extra_specs' => Hash
-  }
-
-  list_volume_type_format = {
-    'volume_types' => [volume_type_format.merge({ 'id' => Integer })]
-  }
-
-  get_volume_type_format = {
-    'volume_type' => volume_type_format.merge({ 'id' => String })
+    'extra_specs' => Hash,
+    'id' => String
   }
 
   service = Fog::Rackspace::BlockStorage.new
@@ -17,11 +10,11 @@ Shindo.tests('Fog::Rackspace::BlockStorage | volume_type_tests', ['rackspace'])
   tests('success') do
     volume_type_id = service.volume_types.first.id
 
-    tests("#list_volume_types").formats(list_volume_type_format) do
+    tests("#list_volume_types").formats('volume_types' => [volume_type_format]) do
       service.list_volume_types.body
     end
 
-    tests("#get_volume_type(#{volume_type_id})").formats(get_volume_type_format) do
+    tests("#get_volume_type(#{volume_type_id})").formats('volume_type' => volume_type_format) do
       service.get_volume_type(volume_type_id).body
     end
   end

data/tests/rackspace/requests/compute_v2/address_tests.rb

@@ -5,7 +5,7 @@ Shindo.tests('Fog::Compute::RackspaceV2 | address requests', ['rackspace']) do
   tests('success') do
     unless Fog.mocking?
       @server = @service.servers.create(:flavor_id => 2, :image_id => "8a3a9f96-b997-46fd-b7a8-a9e740796ffd", :name => "address-tests-#{Time.now.to_i}")
-      @server.wait_for(timeout=1200) { ready? }
+      @server.wait_for { ready? }
       @server_id = @server.id
     else
       @server_id = 42

data/tests/rackspace/requests/compute_v2/attachment_tests.rb

@@ -1,9 +1,8 @@
 Shindo.tests('Fog::Compute::RackspaceV2 | attachment_tests', ['rackspace']) do
   compute_service       = Fog::Compute::RackspaceV2.new
   block_storage_service = Fog::Rackspace::BlockStorage.new
-  image_id              = Fog.credentials[:rackspace_image_id] || compute_service.images.first.id
-  flavor_id             = Fog.credentials[:rackspace_flavor_id] || compute_service.flavors.first.id
-  timeout = Fog.mocking? ? 1 : 10
+  image_id              = rackspace_test_image_id(compute_service)
+  flavor_id             = rackspace_test_flavor_id(compute_service)
 
   attachment_format = {
     'volumeAttachment' => {
@@ -27,12 +26,12 @@ Shindo.tests('Fog::Compute::RackspaceV2 | attachment_tests', ['rackspace']) do
 
 
   tests('success') do
-    until compute_service.get_server(server_id).body['server']['status'] == 'ACTIVE'
-      sleep timeout
+    wait_for_request("Waiting for server to become ready") do
+      compute_service.get_server(server_id).body['server']['status'] == 'ACTIVE'
     end
 
-    until block_storage_service.get_volume(volume_id).body['volume']['status'] == 'available'
-      sleep timeout
+    wait_for_request("Waiting for Volume to be ready") do
+      block_storage_service.get_volume(volume_id).body['volume']['status'] == 'available'
     end
 
     tests("#attach_volume(#{server_id}, #{volume_id}, #{device_id})").formats(attachment_format) do
@@ -43,8 +42,8 @@ Shindo.tests('Fog::Compute::RackspaceV2 | attachment_tests', ['rackspace']) do
       compute_service.list_attachments(server_id).body
     end
 
-    until block_storage_service.get_volume(volume_id).body['volume']['status'] == 'in-use'
-      sleep timeout
+    wait_for_request("Waiting for Volume to be ready") do
+      block_storage_service.get_volume(volume_id).body['volume']['status'] == 'in-use'
     end
 
     tests("#get_attachment(#{server_id}, #{volume_id})").formats(attachment_format) do

data/tests/rackspace/requests/compute_v2/flavor_tests.rb

@@ -18,7 +18,7 @@ Shindo.tests('Fog::Compute::RackspaceV2 | flavor_tests', ['rackspace']) do
 
   get_flavor_format = {
     'flavor' => flavor_format.merge({
-      'OS-FLV-DISABLED:disabled' => Fog::Boolean,
+      'OS-FLV-EXT-DATA:ephemeral' => Integer,
       'rxtx_factor' => Float,
       'swap' => Integer
     })

data/tests/rackspace/requests/compute_v2/metadata_tests.rb

@@ -12,7 +12,7 @@ Shindo.tests('Fog::Compute::RackspaceV2 | metadata_tests', ['rackspace']) do
                                           :flavor_id => 2,
                                           :image_id => '3afe97b2-26dc-49c5-a2cc-a2fc8d80c001',
                                           :metadata => metadata)
-        @server.wait_for(timeout = 1500) { ready? }
+        @server.wait_for { ready? }
         
         
         @server_id = @server.id
@@ -40,12 +40,12 @@ Shindo.tests('Fog::Compute::RackspaceV2 | metadata_tests', ['rackspace']) do
             @service.set_metadata_item("servers", @server_id, "environment", "test").body
           end
           tests('delete_metadata_item').succeeds do
-            @service.delete_metadata_item("servers", @server_id, "environment").body
+            @service.delete_metadata_item("servers", @server_id, "environment")
           end
         end
         
         tests("images") do
-          @image.wait_for(timeout = 1500) { ready? } unless Fog.mocking?
+          @image.wait_for { ready? } unless Fog.mocking?
           
           tests('list_metadata').returns(metadata) do
             h = @service.list_metadata("images", @image_id).body
@@ -66,7 +66,7 @@ Shindo.tests('Fog::Compute::RackspaceV2 | metadata_tests', ['rackspace']) do
             @service.set_metadata_item("images", @image_id, "environment", "test").body
           end
           tests('delete_metadata_item').succeeds do
-            @service.delete_metadata_item("images", @image_id, "environment").body
+            @service.delete_metadata_item("images", @image_id, "environment")
           end
         end
     ensure

data/tests/rackspace/requests/databases/database_tests.rb

@@ -4,33 +4,36 @@ Shindo.tests('Fog::Rackspace::Database | database_tests', ['rackspace']) do
 
   service = Fog::Rackspace::Databases.new
   instance_name = 'fog' + Time.now.to_i.to_s
-  instance_id = service.create_instance(instance_name, 1, 1).body['instance']['id']
 
-  until service.get_instance(instance_id).body["instance"]["status"] == 'ACTIVE'
-    sleep 10
-  end
-
-  tests('success') do
-    database_name = 'fogdb' + Time.now.to_i.to_s
+    begin
+    @instance_id = service.create_instance(instance_name, 1, 1).body['instance']['id']
 
-    tests("#create_database(#{instance_id}, #{database_name})").succeeds do
-      service.create_database(instance_id, database_name).body
+    wait_for_request("waiting for database to be created") do
+      service.get_instance(@instance_id).body["instance"]["status"] == 'ACTIVE'
     end
 
-    tests("#list_databases{#{instance_id})").formats(LIST_DATABASES_FORMAT) do
-      service.list_databases(instance_id).body
-    end
+    tests('success') do
+      database_name = 'fogdb' + Time.now.to_i.to_s
+
+      tests("#create_database(#{@instance_id}, #{database_name})").returns(202) do
+        service.create_database(@instance_id, database_name).status
+      end
 
-    tests("#delete_database(#{instance_id}, #{database_name})").succeeds do
-      service.delete_database(instance_id, database_name)
+      tests("#list_databases{#{@instance_id})").formats(LIST_DATABASES_FORMAT) do
+        service.list_databases(@instance_id).body
+      end
+
+      tests("#delete_database(#{@instance_id}, #{database_name})").returns(202) do
+        service.delete_database(@instance_id, database_name).status
+      end
     end
-  end
 
-  tests('failure') do
-    tests("#create_database(#{instance_id}, '') => Invalid Create Critera").raises(Fog::Rackspace::Databases::BadRequest) do
-      service.create_database(instance_id, '')
+    tests('failure') do
+      tests("#create_database(#{@instance_id}, '') => Invalid Create Critera").raises(Fog::Rackspace::Databases::BadRequest) do
+        service.create_database(@instance_id, '')
+      end
     end
+  ensure
+    service.delete_instance(@instance_id) if @instance_id
   end
-
-  service.delete_instance(instance_id)
 end

data/tests/rackspace/requests/databases/user_tests.rb

@@ -6,24 +6,24 @@ Shindo.tests('Fog::Rackspace::Database | user_tests', ['rackspace']) do
   instance_name = 'fog' + Time.now.to_i.to_s
   instance_id = service.create_instance(instance_name, 1, 1).body['instance']['id']
 
-  until service.get_instance(instance_id).body["instance"]["status"] == 'ACTIVE'
-    sleep 10
+  wait_for_request("Waiting for database to be created") do
+    service.get_instance(instance_id).body["instance"]["status"] == 'ACTIVE'
   end
 
   tests('success') do
     user_name = 'fog' + Time.now.to_i.to_s
     password = 'password1'
 
-    tests("#create_user(#{instance_id}, #{user_name}, #{password})").succeeds do
-      service.create_user(instance_id, user_name, password).body
+    tests("#create_user(#{instance_id}, #{user_name}, #{password})").returns(202) do
+      service.create_user(instance_id, user_name, password).status
     end
 
     tests("#list_users{#{instance_id})").formats(LIST_USERS_FORMAT) do
       service.list_users(instance_id).body
     end
 
-    tests("#delete_user(#{instance_id}, #{user_name})").succeeds do
-      service.delete_user(instance_id, user_name)
+    tests("#delete_user(#{instance_id}, #{user_name})").returns(202)  do
+      service.delete_user(instance_id, user_name).status
     end
   end
 

data/tests/rackspace/requests/identity/user_tests.rb

@@ -41,7 +41,7 @@ Shindo.tests('Fog::Rackspace::Identity | users', ['rackspace']) do
 
   service = Fog::Rackspace::Identity.new
   id = nil
-  username = 'foguser'
+  username = "fog#{Time.now.to_i.to_s}"
   email = 'fog_user@example.com'
   enabled = true
   password = 'Fog_password1'
@@ -57,6 +57,9 @@ Shindo.tests('Fog::Rackspace::Identity | users', ['rackspace']) do
       service.delete_user(id)
     end
 
+    # there appears to be a werid caching issue. It's just easier to create a new username and continue on
+    username = "fog#{Time.now.to_i.to_s}"
+
     tests('#create_user with password').succeeds do
       data = service.create_user(username, email, enabled, :password => password ).body
       id = data['user']['id']

data/tests/rackspace/requests/load_balancers/usage_tests.rb

@@ -6,11 +6,13 @@ Shindo.tests('Fog::Rackspace::LoadBalancers | usage', ['rackspace']) do
     tests('success') do
 
       tests("#get_usage()").formats(USAGE_FORMAT) do
-        @service.get_usage.body
+        pending
+        # @service.get_usage.body
       end
 
       tests("#get_usage(:start_time => '2010-05-10', :end_time => '2010-05-11')").formats(USAGE_FORMAT) do
-        @service.get_usage(:start_time => '2010-05-10', :end_time => '2010-05-11').body
+        pending
+        # @service.get_usage(:start_time => '2010-05-10', :end_time => '2010-05-11').body
       end
     end
   end

data/tests/rackspace/requests/storage/large_object_tests.rb

@@ -1,106 +1,350 @@
-Shindo.tests('Fog::Storage[:rackspace] | large object requests', ["rackspace"]) do
+Shindo.tests('Fog::Storage[:rackspace] | large object requests', ['rackspace']) do
 
   unless Fog.mocking?
-    @directory = Fog::Storage[:rackspace].directories.create(:key => 'foglargeobjecttests')
+    @directory  = Fog::Storage[:rackspace].directories.create(:key => 'foglargeobjecttests')
     @directory2 = Fog::Storage[:rackspace].directories.create(:key => 'foglargeobjecttests2')
+    @segments = {
+      :a => {
+        :container => @directory.identity,
+        :name      => 'fog_large_object/a',
+        :data      => 'a' * (1024**2 + 10),
+        :size      => 1024**2 + 10,
+        :etag      => 'c2e97007d59f0c19b850debdcb80cca5'
+      },
+      :b => {
+        :container => @directory.identity,
+        :name      => 'fog_large_object/b',
+        :data      => 'b' * (1024**2 + 20),
+        :size      => 1024**2 + 20,
+        :etag      => 'd35f50622a1259daad75ff7d5512c7ef'
+      },
+      :c => {
+        :container => @directory.identity,
+        :name      => 'fog_large_object2/a',
+        :data      => 'c' * (1024**2 + 30),
+        :size      => 1024**2 + 30,
+        :etag      => '901d3531a87d188041d4d5b43cb464c1'
+      },
+      :d => {
+        :container => @directory2.identity,
+        :name      => 'fog_large_object2/b',
+        :data      => 'd' * (1024**2 + 40),
+        :size      => 1024**2 + 40,
+        :etag      => '350c0e00525198813920a157df185c8d'
+      }
+    }
   end
 
   tests('success') do
 
-    tests("#put_object('foglargeobjecttests', 'fog_large_object/1', ('x' * 4 * 1024 * 1024))").succeeds do
+    tests('upload test segments').succeeds do
       pending if Fog.mocking?
-      Fog::Storage[:rackspace].put_object(@directory.identity, 'fog_large_object/1', ('x' * 4 * 1024 * 1024))
+
+      @segments.each_value do |segment|
+        Fog::Storage[:rackspace].put_object(segment[:container], segment[:name], segment[:data])
+      end
     end
 
-    tests("#put_object('foglargeobjecttests', 'fog_large_object/2', ('x' * 2 * 1024 * 1024))").succeeds do
+    tests('dynamic large object requests') do
       pending if Fog.mocking?
-      Fog::Storage[:rackspace].put_object(@directory.identity, 'fog_large_object/2', ('x' * 2 * 1024 * 1024))
+
+      tests('#put_object_manifest alias').succeeds do
+        Fog::Storage[:rackspace].put_object_manifest(@directory.identity, 'fog_large_object')
+      end
+
+      tests('using default X-Object-Manifest header') do
+
+        tests('#put_dynamic_obj_manifest').succeeds do
+          Fog::Storage[:rackspace].put_dynamic_obj_manifest(@directory.identity, 'fog_large_object')
+        end
+
+        tests('#get_object streams all segments matching the default prefix').succeeds do
+          expected = @segments[:a][:data] + @segments[:b][:data] + @segments[:c][:data]
+          Fog::Storage[:rackspace].get_object(@directory.identity, 'fog_large_object').body == expected
+        end
+
+        # When the manifest object name is equal to the segment prefix, OpenStack treats it as if it's the first segment.
+        # So you must prepend the manifest object's Etag - Digest::MD5.hexdigest('')
+        tests('#head_object returns Etag that includes manifest object in calculation').succeeds do
+          etags = ['d41d8cd98f00b204e9800998ecf8427e', @segments[:a][:etag], @segments[:b][:etag], @segments[:c][:etag]]
+          expected = "\"#{ Digest::MD5.hexdigest(etags.join) }\"" # returned in quotes "\"2577f38428e895c50de6ea78ccc7da2a"\"
+          Fog::Storage[:rackspace].head_object(@directory.identity, 'fog_large_object').headers['Etag'] == expected
+        end
+
+      end
+
+      tests('specifying X-Object-Manifest segment prefix') do
+
+        tests('#put_dynamic_obj_manifest').succeeds do
+          options = { 'X-Object-Manifest' => "#{ @directory.identity }/fog_large_object/" }
+          Fog::Storage[:rackspace].put_dynamic_obj_manifest(@directory.identity, 'fog_large_object', options)
+        end
+
+        tests('#get_object streams segments only matching the specified prefix').succeeds do
+          expected = @segments[:a][:data] + @segments[:b][:data]
+          Fog::Storage[:rackspace].get_object(@directory.identity, 'fog_large_object').body == expected
+        end
+
+        tests('#head_object returns Etag that does not include manifest object in calculation').succeeds do
+          etags = [@segments[:a][:etag], @segments[:b][:etag]]
+          expected = "\"#{ Digest::MD5.hexdigest(etags.join) }\"" # returned in quotes "\"0f035ed3cc38aa0ef46dda3478fad44d"\"
+          Fog::Storage[:rackspace].head_object(@directory.identity, 'fog_large_object').headers['Etag'] == expected
+        end
+
+      end
+
+      tests('storing manifest in a different container than the segments') do
+
+        tests('#put_dynamic_obj_manifest').succeeds do
+          options = { 'X-Object-Manifest' => "#{ @directory.identity }/fog_large_object/" }
+          Fog::Storage[:rackspace].put_dynamic_obj_manifest(@directory2.identity, 'fog_large_object', options)
+        end
+
+        tests('#get_object').succeeds do
+          expected = @segments[:a][:data] + @segments[:b][:data]
+          Fog::Storage[:rackspace].get_object(@directory2.identity, 'fog_large_object').body == expected
+        end
+
+      end
+
     end
 
-    tests("#put_object('foglargeobjecttests', 'fog_large_object2/1', ('x' * 1 * 1024 * 1024))").succeeds do
+    tests('static large object requests') do
       pending if Fog.mocking?
-      Fog::Storage[:rackspace].put_object(@directory.identity, 'fog_large_object2/1', ('x' * 1 * 1024 * 1024))
-    end
 
-    tests("using default X-Object-Manifest header") do
+      tests('single container') do
+
+        tests('#put_static_obj_manifest').succeeds do
+          segments = [
+            { :path => "#{ @segments[:a][:container] }/#{ @segments[:a][:name] }",
+              :etag => @segments[:a][:etag],
+              :size_bytes => @segments[:a][:size] },
+            { :path => "#{ @segments[:c][:container] }/#{ @segments[:c][:name] }",
+              :etag => @segments[:c][:etag],
+              :size_bytes => @segments[:c][:size] }
+          ]
+          Fog::Storage[:rackspace].put_static_obj_manifest(@directory.identity, 'fog_large_object', segments)
+        end
+
+        tests('#head_object') do
+          etags = [@segments[:a][:etag], @segments[:c][:etag]]
+          etag = "\"#{ Digest::MD5.hexdigest(etags.join) }\"" # "\"ad7e633a12e8a4915b45e6dd1d4b0b4b\""
+          content_length = (@segments[:a][:size] + @segments[:c][:size]).to_s
+          response = Fog::Storage[:rackspace].head_object(@directory.identity, 'fog_large_object')
+
+          returns(etag, 'returns ETag computed from segments') { response.headers['Etag'] }
+          returns(content_length , 'returns Content-Length for all segments') { response.headers['Content-Length'] }
+          returns('True', 'returns X-Static-Large-Object header') { response.headers['X-Static-Large-Object'] }
+        end
+
+        tests('#get_object').succeeds do
+          expected = @segments[:a][:data] + @segments[:c][:data]
+          Fog::Storage[:rackspace].get_object(@directory.identity, 'fog_large_object').body == expected
+        end
+
+        tests('#delete_static_large_object') do
+          expected = {
+            'Number Not Found'  => 0,
+            'Response Status'   => '200 OK',
+            'Errors'            => [],
+            'Number Deleted'    => 3,
+            'Response Body'     => ''
+          }
+          returns(expected, 'deletes manifest and segments') do
+            Fog::Storage[:rackspace].delete_static_large_object(@directory.identity, 'fog_large_object').body
+          end
+        end
 
-      tests("#put_object_manifest('foglargeobjecttests', 'fog_large_object')").succeeds do
-        pending if Fog.mocking?
-        Fog::Storage[:rackspace].put_object_manifest(@directory.identity, 'fog_large_object')
       end
 
-      tests("#get_object streams all segments matching the default prefix").succeeds do
-        pending if Fog.mocking?
-        Fog::Storage[:rackspace].get_object(@directory.identity, 'fog_large_object').body == ('x' * 7 * 1024 * 1024)
+      tests('multiple containers') do
+
+        tests('#put_static_obj_manifest').succeeds do
+          segments = [
+            { :path => "#{ @segments[:b][:container] }/#{ @segments[:b][:name] }",
+              :etag => @segments[:b][:etag],
+              :size_bytes => @segments[:b][:size] },
+            { :path => "#{ @segments[:d][:container] }/#{ @segments[:d][:name] }",
+              :etag => @segments[:d][:etag],
+              :size_bytes => @segments[:d][:size] }
+          ]
+          Fog::Storage[:rackspace].put_static_obj_manifest(@directory2.identity, 'fog_large_object', segments)
+        end
+
+        tests('#head_object') do
+          etags = [@segments[:b][:etag], @segments[:d][:etag]]
+          etag = "\"#{ Digest::MD5.hexdigest(etags.join) }\"" # "\"9801a4cc4472896a1e975d03f0d2c3f8\""
+          content_length = (@segments[:b][:size] + @segments[:d][:size]).to_s
+          response = Fog::Storage[:rackspace].head_object(@directory2.identity, 'fog_large_object')
+
+          returns(etag, 'returns ETag computed from segments') { response.headers['Etag'] }
+          returns(content_length , 'returns Content-Length for all segments') { response.headers['Content-Length'] }
+          returns('True', 'returns X-Static-Large-Object header') { response.headers['X-Static-Large-Object'] }
+        end
+
+        tests('#get_object').succeeds do
+          expected = @segments[:b][:data] + @segments[:d][:data]
+          Fog::Storage[:rackspace].get_object(@directory2.identity, 'fog_large_object').body == expected
+        end
+
+        tests('#delete_static_large_object') do
+          expected = {
+            'Number Not Found'  => 0,
+            'Response Status'   => '200 OK',
+            'Errors'            => [],
+            'Number Deleted'    => 3,
+            'Response Body'     => ''
+          }
+          returns(expected, 'deletes manifest and segments') do
+            Fog::Storage[:rackspace].delete_static_large_object(@directory2.identity, 'fog_large_object').body
+          end
+        end
+
       end
 
-      tests("#head_object returns Etag that includes manifest object in calculation").succeeds do
-        pending if Fog.mocking?
+    end
 
-        etags = []
-        # When the manifest object name is equal to the prefix, OpenStack treats it as if it's the first segment.
-        etags << Digest::MD5.hexdigest('') # Etag for manifest object => "d41d8cd98f00b204e9800998ecf8427e"
-        etags << Digest::MD5.hexdigest('x' * 4 * 1024 * 1024) # => "44981362d3ba9b5bacaf017c2f29d355"
-        etags << Digest::MD5.hexdigest('x' * 2 * 1024 * 1024) # => "67b2f816a30e8956149b2d7beb479e51"
-        etags << Digest::MD5.hexdigest('x' * 1 * 1024 * 1024) # => "b561f87202d04959e37588ee05cf5b10"
-        expected = Digest::MD5.hexdigest(etags.join) # => "42e92048bd2c8085e7072b0b55fd76ab"
-        actual = Fog::Storage[:rackspace].head_object(@directory.identity, 'fog_large_object').headers['Etag']
-        actual.gsub('"', '') == expected # actual is returned in quotes "\"42e92048bd2c8085e7072b0b55fd76abu"\"
+  end
+
+  tests('failure') do
+
+    tests('dynamic large object requests') do
+      pending if Fog.mocking?
+
+      tests('#put_dynamic_obj_manifest with missing container').raises(Fog::Storage::Rackspace::NotFound) do
+        Fog::Storage[:rackspace].put_dynamic_obj_manifest('fognoncontainer', 'fog_large_object')
       end
 
     end
 
-    tests("specifying X-Object-Manifest segment prefix") do
+    tests('static large object requests') do
+      pending if Fog.mocking?
 
-      tests("#put_object_manifest('foglargeobjecttests', 'fog_large_object', {'X-Object-Manifest' => 'foglargeobjecttests/fog_large_object/')").succeeds do
-        pending if Fog.mocking?
-        Fog::Storage[:rackspace].put_object_manifest(@directory.identity, 'fog_large_object', {'X-Object-Manifest' => "#{@directory.identity}/fog_large_object/"})
+      tests('upload test segments').succeeds do
+        Fog::Storage[:rackspace].put_object(@segments[:a][:container], @segments[:a][:name], @segments[:a][:data])
+        Fog::Storage[:rackspace].put_object(@segments[:b][:container], @segments[:b][:name], @segments[:b][:data])
       end
 
-      tests("#get_object streams segments only matching the specified prefix").succeeds do
-        pending if Fog.mocking?
-        Fog::Storage[:rackspace].get_object(@directory.identity, 'fog_large_object').body == ('x' * 6 * 1024 * 1024)
+      tests('#put_static_obj_manifest with missing container').raises(Fog::Storage::Rackspace::NotFound) do
+        Fog::Storage[:rackspace].put_static_obj_manifest('fognoncontainer', 'fog_large_object', [])
       end
 
-      tests("#head_object returns Etag that does not include manifest object in calculation").succeeds do
-        pending if Fog.mocking?
+      tests('#put_static_obj_manifest with missing object') do
+        segments = [
+          { :path => "#{ @segments[:c][:container] }/#{ @segments[:c][:name] }",
+            :etag => @segments[:c][:etag],
+            :size_bytes => @segments[:c][:size] }
+        ]
+        expected = { 'Errors' => [[segments[0][:path], '404 Not Found']] }
+
+        error = nil
+        begin
+          Fog::Storage[:rackspace].put_static_obj_manifest(@directory.identity, 'fog_large_object', segments)
+        rescue => err
+          error = err
+        end
 
-        etags = []
-        etags << Digest::MD5.hexdigest('x' * 4 * 1024 * 1024) # => "44981362d3ba9b5bacaf017c2f29d355"
-        etags << Digest::MD5.hexdigest('x' * 2 * 1024 * 1024) # => "67b2f816a30e8956149b2d7beb479e51"
-        expected = Digest::MD5.hexdigest(etags.join) # => "0b348495a774eaa4d4c4bbf770820f84"
-        actual = Fog::Storage[:rackspace].head_object(@directory.identity, 'fog_large_object').headers['Etag']
-        actual.gsub('"', '') == expected # actual is returned in quotes "\"0b348495a774eaa4d4c4bbf770820f84"\"
+        raises(Fog::Storage::Rackspace::BadRequest) do
+          raise error if error
+        end
+
+        expected['Errors'][0][0] = error.response_data['Errors'][0][0] rescue nil
+        returns(expected, 'returns error information') do
+          error.response_data
+        end
       end
 
-    end
+      tests('#put_static_obj_manifest with invalid etag') do
+        segments = [
+          { :path => "#{ @segments[:a][:container] }/#{ @segments[:a][:name] }",
+            :etag => @segments[:b][:etag],
+            :size_bytes => @segments[:a][:size] }
+        ]
+        expected = { 'Errors' => [[segments[0][:path], 'Etag Mismatch']] }
 
-    tests("storing manifest object in a different container than the segments") do
+        error = nil
+        begin
+          Fog::Storage[:rackspace].put_static_obj_manifest(@directory.identity, 'fog_large_object', segments)
+        rescue => err
+          error = err
+        end
 
-      tests("#put_object_manifest('foglargeobjecttests2', 'fog_large_object', {'X-Object-Manifest' => 'foglargeobjecttests/fog_large_object/'})").succeeds do
-        pending if Fog.mocking?
-        Fog::Storage[:rackspace].put_object_manifest(@directory2.identity, 'fog_large_object', {'X-Object-Manifest' => "#{@directory.identity}/fog_large_object/"})
+        raises(Fog::Storage::Rackspace::BadRequest) do
+          raise error if error
+        end
+
+        expected['Errors'][0][0] = error.response_data['Errors'][0][0] rescue nil
+        returns(expected, 'returns error information') do
+          error.response_data
+        end
       end
 
-      tests("#get_object('foglargeobjecttests2', 'fog_large_object').body").succeeds do
-        pending if Fog.mocking?
-        Fog::Storage[:rackspace].get_object(@directory2.identity, 'fog_large_object').body == ('x' * 6 * 1024 * 1024)
+      tests('#put_static_obj_manifest with invalid byte_size') do
+        segments = [
+          { :path => "#{ @segments[:a][:container] }/#{ @segments[:a][:name] }",
+            :etag => @segments[:a][:etag],
+            :size_bytes => @segments[:b][:size] }
+        ]
+        expected = { 'Errors' => [[segments[0][:path], 'Size Mismatch']] }
+
+        error = nil
+        begin
+          Fog::Storage[:rackspace].put_static_obj_manifest(@directory.identity, 'fog_large_object', segments)
+        rescue => err
+          error = err
+        end
+
+        raises(Fog::Storage::Rackspace::BadRequest) do
+          raise error if error
+        end
+
+        expected['Errors'][0][0] = error.response_data['Errors'][0][0] rescue nil
+        returns(expected, 'returns error information') do
+          error.response_data
+        end
       end
 
-    end
+      tests('#delete_static_large_object with missing container').raises(Fog::Storage::Rackspace::NotFound) do
+        Fog::Storage[:rackspace].delete_static_large_object('fognoncontainer', 'fog_large_object')
+      end
 
-    unless Fog.mocking?
-      ['fog_large_object', 'fog_large_object/1', 'fog_large_object/2', 'fog_large_object2/1'].each do |key|
-        @directory.files.new(:key => key).destroy
+      tests('#delete_static_large_object with missing manifest').raises(Fog::Storage::Rackspace::NotFound) do
+        Fog::Storage[:rackspace].delete_static_large_object(@directory.identity, 'fog_non_object')
       end
-      @directory2.files.new(:key => 'fog_large_object').destroy
-    end
 
-  end
+      tests('#delete_static_large_object with missing segment') do
 
-  tests('failure') do
+        tests('#put_static_obj_manifest for segments :a and :b').succeeds do
+          segments = [
+            { :path => "#{ @segments[:a][:container] }/#{ @segments[:a][:name] }",
+              :etag => @segments[:a][:etag],
+              :size_bytes => @segments[:a][:size] },
+            { :path => "#{ @segments[:b][:container] }/#{ @segments[:b][:name] }",
+              :etag => @segments[:b][:etag],
+              :size_bytes => @segments[:b][:size] }
+          ]
+          Fog::Storage[:rackspace].put_static_obj_manifest(@directory.identity, 'fog_large_object', segments)
+        end
+
+        tests('#delete_object segment :b').succeeds do
+          Fog::Storage[:rackspace].delete_object(@segments[:b][:container], @segments[:b][:name])
+        end
 
-    tests("put_object_manifest")
+        tests('#delete_static_large_object') do
+          expected = {
+            'Number Not Found'  => 1,
+            'Response Status'   => '200 OK',
+            'Errors'            => [],
+            'Number Deleted'    => 2,
+            'Response Body'     => ''
+          }
+          returns(expected, 'deletes manifest and segment :a, and reports missing segment :b') do
+            Fog::Storage[:rackspace].delete_static_large_object(@directory.identity, 'fog_large_object').body
+          end
+        end
+
+      end
+    end
 
   end