gapinc-fog 1.12.1.2.1 → 1.14.0

data/tests/rackspace/requests/monitoring/list_tests.rb

@@ -0,0 +1,60 @@
+Shindo.tests('Fog::Rackspace::Monitoring | list_tests', ['rackspace','rackspace_monitoring']) do
+  pending if Fog.mocking? 
+
+  account = Fog::Rackspace::Monitoring.new
+  entity_id = account.create_entity(:label => "Foo").data[:headers]["X-Object-ID"]
+  check_id = account.create_check(entity_id,CHECK_CREATE_OPTIONS).data[:headers]["X-Object-ID"]
+  metric_name = "idle_percent_average"
+  now = Time.now.to_i
+  SLEEP_TIME= 2
+  sleep(SLEEP_TIME) unless Fog.mocking?
+
+  tests('success') do
+    tests('#get list of checks').formats(LIST_HEADERS_FORMAT) do
+      account.list_checks(entity_id).data[:headers]
+    end
+    tests('#get list of check types').formats(LIST_HEADERS_FORMAT) do
+      account.list_check_types().data[:headers]
+    end
+    tests('#get list of entities').formats(LIST_HEADERS_FORMAT) do
+      account.list_entities().data[:headers]
+    end
+    tests('#get list of metrics').formats(LIST_HEADERS_FORMAT) do
+     account.list_metrics(entity_id,check_id).data[:headers]
+    end
+    tests('#get overview list').formats(LIST_HEADERS_FORMAT) do
+      account.list_overview().data[:headers]
+    end
+    tests('#list notification plans').formats(LIST_HEADERS_FORMAT) do
+      account.list_notification_plans().data[:headers]
+    end
+    tests('#get list of data points').formats(LIST_HEADERS_FORMAT) do
+      options = {
+        :points => 1,
+        :from => now,
+        :to => now+SLEEP_TIME
+      }
+      account.list_data_points(entity_id,check_id,metric_name,options).data[:headers]
+    end
+  end
+  tests('failure') do
+    tests('#fail to list checks').raises(Fog::Rackspace::Monitoring::NotFound) do
+      account.list_checks(-1)
+    end
+    tests('#fail to list check types').raises(ArgumentError) do
+      account.list_check_types(-1)
+    end
+    # This test has been put on hold due to a bug that incorrectly returns 200 OK to this request
+    #tests('#fail to list metrics').raises(Fog::Rackspace::Monitoring::NotFound) do
+      #account.list_metrics(-1,-1)
+    #end
+    tests('#fail: 1 argument instead of 0 for list_notification_plans').raises(ArgumentError) do
+      account.list_notification_plans('fail')
+    end
+    tests('#fail to get list of data points').raises(Fog::Rackspace::Monitoring::BadRequest) do
+      account.list_data_points(-1,-1,-1,-1).data
+    end
+  end
+  account.delete_check(entity_id,check_id)
+  account.delete_entity(entity_id)
+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