RubyGems - fog - Versions diffs - 1.37.0 → 1.38.0 - Mend

fog 1.37.0 → 1.38.0

Files changed (1936) hide show

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

@@ -1,60 +0,0 @@
-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 DELETED

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

@@ -1,54 +0,0 @@
-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 DELETED

@@ -1,38 +0,0 @@
-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 DELETED

@@ -1,15 +0,0 @@
-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 DELETED

@@ -1,67 +0,0 @@
-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 DELETED

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