fog-rackspace 0.1.0

data/tests/rackspace/requests/networking/virtual_interface_tests.rb

@@ -0,0 +1,49 @@
+Shindo.tests('Fog::Rackspace::Networking | virtual_interface_tests', ['rackspace']) do
+  @service = Fog::Rackspace::Networking.new
+
+  virtual_interface_format = {
+    "virtual_interfaces"=> [{
+      "ip_addresses"=> [{
+        "network_id"=> String,
+        "network_label"=> String,
+        "address"=> String
+      }],
+      "id"=> String,
+      "mac_address"=> String
+    }]
+  }
+
+  begin
+    unless Fog.mocking?
+      network_id = nil
+
+      @server = @service.servers.create(:name => "fog_virtual_interface_test_#{Time.now.to_i.to_s}",
+                                        :flavor_id => rackspace_test_flavor_id(@service),
+                                        :image_id => rackspace_test_image_id(@service))
+      @server.wait_for { ready? }
+
+      @network = @service.networks.create(:label => "fog_#{Time.now.to_i.to_s}", :cidr => '192.168.0.0/24')
+    end
+
+    tests('success') do
+      pending if Fog.mocking?
+
+      tests('#create_virtual_interface').formats(virtual_interface_format) do
+        response = @service.create_virtual_interface @server.id, @network.id
+        body = response.body
+        @virtual_network_interface_id = body["virtual_interfaces"].first["id"]
+        body
+      end
+        tests('#list_virtual_interfaces').formats(virtual_interface_format) do
+          @service.list_virtual_interfaces(@server.id).body
+        end
+
+        tests('#delete_virtual_interfaces').succeeds do
+          @service.delete_virtual_interface(@server.id, @virtual_network_interface_id)
+        end
+      end
+  ensure
+    @server.destroy if @server
+    delete_test_network @network
+  end
+end

data/tests/rackspace/requests/queues/claim_tests.rb

@@ -0,0 +1,60 @@
+Shindo.tests('Fog::Rackspace::Queues | claim_tests', ['rackspace']) do
+
+  service = Fog::Rackspace::Queues.new
+
+  queue_name = 'fog' + Time.now.to_i.to_s
+  client_id = service.client_id
+  claim_id = nil
+
+  service.create_queue(queue_name)
+
+  tests('success') do
+
+    tests("#create_claim(#{queue_name}, #{VALID_TTL}, #{VALID_GRACE}) => No Messages").returns(204) do
+      service.create_claim(queue_name, VALID_TTL, VALID_GRACE).status
+    end
+
+    tests('with messages in the queue') do
+
+      before do
+        service.create_message(client_id, queue_name, { :message => "message-body"}, 300)
+      end
+
+      #TODO - Fix it so simple text bodies pass validation
+      tests("#create_claim(#{queue_name}, #{VALID_TTL}, #{VALID_GRACE})").formats(CREATE_CLAIM_FORMAT) do
+        response = service.create_claim(queue_name, VALID_TTL, VALID_GRACE)
+        claim_id = response.headers['Location'].split('/').last
+        response.body
+      end
+
+      tests("#get_claim(#{queue_name}, #{claim_id})").formats(CLAIM_FORMAT) do
+        service.get_claim(queue_name, claim_id).body
+      end
+
+      tests("#update_claim(#{queue_name}, #{claim_id}, 500)").succeeds do
+        service.update_claim(queue_name, claim_id, 500)
+      end
+
+      tests("#delete_claim(#{queue_name}, #{claim_id})").succeeds do
+        service.delete_claim(queue_name, claim_id)
+      end
+
+      tests("#create_claim(#{queue_name}, #{VALID_TTL}, #{VALID_GRACE}, { :limit => 1})") do
+        response = service.create_claim(queue_name, VALID_TTL, VALID_GRACE,  { :limit => 1})
+
+        formats(CREATE_CLAIM_FORMAT) { response.body }
+        returns(1) { response.body.length }
+      end
+    end
+  end
+
+  tests('failure') do
+    tests("#get_claim('queue_name', 'nonexistentclaim') => Does not exist").raises(Fog::Rackspace::Queues::NotFound) do
+      service.get_claim(queue_name, 'nonexistentclaim')
+    end
+
+  end
+
+  service.delete_queue(queue_name)
+
+end

data/tests/rackspace/requests/queues/helper.rb

@@ -0,0 +1,50 @@
+VALID_TTL = 300
+VALID_GRACE = 300
+
+METADATA_FORMAT = {
+}
+
+QUEUE_FORMAT = {
+  'metadata' => METADATA_FORMAT
+}
+
+LIST_QUEUES_FORMAT = {
+  'queues' => [
+    QUEUE_FORMAT.merge({
+      'name' => String,
+      'href' => String,
+    })
+  ],
+  'links' => LINKS_FORMAT
+}
+
+MESSAGE_FORMAT = {
+  'href' => String,
+  'ttl' => Integer,
+  'age' => Integer,
+  'body' => Hash
+}
+
+LIST_MESSAGES_FORMAT = {
+ 'messages' => [MESSAGE_FORMAT],
+ 'links' => LINKS_FORMAT
+}
+
+CREATE_CLAIM_FORMAT = [
+  MESSAGE_FORMAT
+]
+
+CLAIM_FORMAT = {
+  'ttl' => Integer,
+  'age' => Integer,
+  'messages' => [
+    MESSAGE_FORMAT
+  ]
+}
+
+QUEUE_STATS_FORMAT = {
+  'messages' => {
+    'free' => Integer,
+    'claimed' => Integer
+  }
+}

data/tests/rackspace/requests/queues/messages_tests.rb

@@ -0,0 +1,54 @@
+Shindo.tests('Fog::Rackspace::Queues | messages_tests', ['rackspace']) do
+  service = Fog::Rackspace::Queues.new
+
+  queue_name = 'fog' + Time.now.to_i.to_s
+  client_id = service.client_id
+  message_id = nil
+
+  service.create_queue(queue_name)
+
+  begin
+    tests('success') do
+      tests("#list_message(#{client_id}, #{queue_name}, {:echo => true}) => No Content").returns(204) do
+        service.list_messages(client_id, queue_name, {:echo => true}).status
+      end
+
+      tests("#create_message(#{client_id}, #{queue_name}, '{ :blah => 'blah' }', 300)").succeeds do
+        response = service.create_message(client_id, queue_name, { :blah => 'blah' }, 300)
+        message_id = response.body['resources'][0].split('/').last
+      end
+
+      tests("#list_message(#{client_id}, #{queue_name}, {:echo => true}) => With Content").formats(LIST_MESSAGES_FORMAT) do
+        service.list_messages(client_id, queue_name, {:echo => true}).body
+      end
+
+      tests("#get_message(#{client_id}, #{queue_name}, #{message_id})").formats(MESSAGE_FORMAT) do
+        service.get_message(client_id, queue_name, message_id).body
+      end
+
+      tests("#delete_message(#{queue_name}, #{message_id}, { :claim_id => '10' })").raises(Fog::Rackspace::Queues::ServiceError) do
+        #API team should be changing this
+        pending
+        service.delete_message(queue_name, message_id, { :claim_id => '10' })
+      end
+
+      tests("#delete_message(#{queue_name}, #{message_id})").succeeds do
+        service.delete_message(queue_name, message_id)
+      end
+    end
+
+     tests('failure') do
+       tests("#create_message('') => Invalid Create Critera").raises(Fog::Rackspace::Queues::BadRequest) do
+         service.create_message(client_id, queue_name, '', 0)
+       end
+
+       tests("#get_message('queue_name', 'nonexistentmessage') => Does not exist").raises(Fog::Rackspace::Queues::NotFound) do
+         service.get_message(client_id, queue_name, 'nonexistentmessage')
+       end
+
+     end
+  ensure
+    service.delete_queue(queue_name)
+  end
+
+end

data/tests/rackspace/requests/queues/queues_tests.rb

@@ -0,0 +1,38 @@
+Shindo.tests('Fog::Rackspace::Queues | queue_tests', ['rackspace']) do
+  service = Fog::Rackspace::Queues.new
+
+  tests('success') do
+    queue_name = 'fog' + Time.now.to_i.to_s
+
+    tests("#create_queue(#{queue_name})").succeeds do
+      service.create_queue(queue_name)
+    end
+
+    tests("#list_queues").formats(LIST_QUEUES_FORMAT) do
+      response = service.list_queues
+      response.body
+    end
+
+    tests("#get_queue(#{queue_name})").formats(QUEUE_FORMAT) do
+      service.get_queue(queue_name).body
+    end
+
+    tests("#get_queue_stats(#{queue_name})").formats(QUEUE_STATS_FORMAT) do
+      service.get_queue_stats(queue_name).body
+    end
+
+    tests("#delete_queue(#{queue_name})").succeeds do
+      service.delete_queue(queue_name)
+    end
+  end
+
+  tests('failure') do
+    tests("#create_queue('') => Invalid Create Critera").raises(Fog::Rackspace::Queues::MethodNotAllowed) do
+      service.create_queue('')
+    end
+
+    tests("#get_queue('nonexistentqueue') => Does not exist").raises(Fog::Rackspace::Queues::NotFound) do
+      service.get_queue('nonexistentqueue')
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+Shindo.tests('Fog::Storage[:rackspace] | account requests', ["rackspace"]) do
+
+  tests('success') do
+
+    tests("#post_set_meta_temp_url_key('super_secret_key')").succeeds do
+      Fog::Storage[:rackspace].post_set_meta_temp_url_key('super_secret_key')
+    end
+
+  end
+
+  tests('failure') do
+
+  end
+
+end

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

@@ -0,0 +1,67 @@
+Shindo.tests('Fog::Storage[:rackspace] | container requests', ["rackspace"]) do
+
+  @container_format = [{
+    'hash' => String,
+    'last_modified' => String,
+    'bytes' => Integer,
+    'name' => String,
+    'content_type' => String
+  }]
+
+  @containers_format = [{
+    'bytes' => Integer,
+    'count' => Integer,
+    'name'  => String
+  }]
+
+  tests('success') do
+
+    tests("#put_container('fogcontainertests', {})").succeeds do
+      Fog::Storage[:rackspace].put_container('fogcontainertests')
+    end
+
+    tests("#put_container('fogcontainertests', 'X-Container-Meta-Color'=>'green')").succeeds do
+      Fog::Storage[:rackspace].put_container('fogcontainertests', 'X-Container-Meta-Color'=>'green')
+      response = Fog::Storage[:rackspace].head_container('fogcontainertests')
+      returns('green') { response.headers['X-Container-Meta-Color'] }
+    end
+
+    tests("#get_container('fogcontainertests')").formats(@container_format) do
+      Fog::Storage[:rackspace].get_container('fogcontainertests').body
+    end
+
+    tests("#get_containers").formats(@containers_format) do
+      Fog::Storage[:rackspace].get_containers.body
+    end
+
+    tests("#head_container('fogcontainertests')").succeeds do
+      Fog::Storage[:rackspace].head_container('fogcontainertests')
+    end
+
+    tests("#head_containers").succeeds do
+      Fog::Storage[:rackspace].head_containers
+    end
+
+    tests("#delete_container('fogcontainertests')").succeeds do
+      Fog::Storage[:rackspace].delete_container('fogcontainertests')
+    end
+
+  end
+
+  tests('failure') do
+
+    tests("#get_container('fognoncontainer')").raises(Fog::Storage::Rackspace::NotFound) do
+      Fog::Storage[:rackspace].get_container('fognoncontainer')
+    end
+
+    tests("#head_container('fognoncontainer')").raises(Fog::Storage::Rackspace::NotFound) do
+      Fog::Storage[:rackspace].head_container('fognoncontainer')
+    end
+
+    tests("#delete_container('fognoncontainer')").raises(Fog::Storage::Rackspace::NotFound) do
+      Fog::Storage[:rackspace].delete_container('fognoncontainer')
+    end
+
+  end
+
+end

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

@@ -0,0 +1,355 @@
+Shindo.tests('Fog::Storage[:rackspace] | large object requests', ['rackspace']) do
+
+  @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'
+    }
+  }
+
+  tests('success') do
+
+    tests('upload test segments').succeeds do
+      @segments.each_value do |segment|
+        Fog::Storage[:rackspace].put_object(segment[:container], segment[:name], segment[:data])
+      end
+    end
+
+    tests('dynamic large object requests') do
+
+      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('static large object requests') 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
+
+      end
+
+      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
+
+    end
+
+  end
+
+  tests('failure') do
+
+    tests('dynamic large object requests') do
+
+      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('static large object requests') do
+
+      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('#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('#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
+
+        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('#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']] }
+
+        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
+
+      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
+
+      tests('#delete_static_large_object with missing container') do
+        response = Fog::Storage[:rackspace].delete_static_large_object('fognoncontainer', 'fog_large_object')
+
+        returns(200) { response.status }
+        returns(1) { response.body["Number Not Found"] }
+        returns("200 OK") { response.body["Response Status"]}
+        returns("") { response.body["Response Body"]}
+      end
+
+      tests('#delete_static_large_object with missing manifest') do
+        response = Fog::Storage[:rackspace].delete_static_large_object(@directory.identity, 'fog_non_object')
+
+        returns(200) { response.status }
+        returns(1) { response.body["Number Not Found"] }
+        returns("200 OK") { response.body["Response Status"]}
+        returns("") { response.body["Response Body"]}
+      end
+
+      tests('#delete_static_large_object with missing segment') 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('#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
+
+  @directory.destroy
+  @directory2.destroy
+end