fog 1.9.0 → 1.10.0

data/tests/helpers/mock_helper.rb

@@ -11,6 +11,8 @@ if Fog.mock?
   Fog.credentials = {
     :aws_access_key_id                => 'aws_access_key_id',
     :aws_secret_access_key            => 'aws_secret_access_key',
+    :ia_access_key_id                 => 'aws_access_key_id',
+    :ia_secret_access_key             => 'aws_secret_access_key',
     :atmos_storage_token              => 'atmos_token',
     :atmos_storage_secret             => 'atmos_secret',
     :atmos_storage_endpoint           => 'http://atmos.is.cool:1000/test1.0',
@@ -39,9 +41,10 @@ if Fog.mock?
     :go_grid_shared_secret            => 'go_grid_shared_secret',
     :google_storage_access_key_id     => 'google_storage_access_key_id',
     :google_storage_secret_access_key => 'google_storage_secret_access_key',
-    :hp_account_id                    => 'hp_account_id',
+    :hp_access_key                    => 'hp_access_key',
     :hp_secret_key                    => 'hp_secret_key',
     :hp_tenant_id                     => 'hp_tenant_id',
+    :hp_avl_zone                      => 'hp_avl_zone',
     :ibm_username                     => 'ibm_username',
     :ibm_password                     => 'ibm_password',
     :joyent_username                  => "joyentuser",

data/tests/helpers/schema_validator_tests.rb

@@ -0,0 +1,107 @@
+Shindo.tests('Fog::Schema::DataValidator', 'meta') do
+
+  validator = Fog::Schema::DataValidator.new
+
+  tests('#validate') do
+
+    tests('returns true') do
+
+      returns(true, 'when value matches schema expectation') do
+        validator.validate({"key" => "Value"}, {"key" => String})
+      end
+
+      returns(true, 'when values within an array all match schema expectation') do
+        validator.validate({"key" => [1, 2]}, {"key" => [Integer]})
+      end
+
+      returns(true, 'when nested values match schema expectation') do
+        validator.validate({"key" => {:nested_key => "Value"}}, {"key" => {:nested_key => String}})
+      end
+
+      returns(true, 'when collection of values all match schema expectation') do
+        validator.validate([{"key" => "Value"}, {"key" => "Value"}], [{"key" => String}])
+      end
+
+      returns(true, 'when collection is empty although schema covers optional members') do
+        validator.validate([], [{"key" => String}])
+      end
+
+      returns(true, 'when additional keys are passed and not strict') do
+        validator.validate({"key" => "Value", :extra => "Bonus"}, {"key" => String}, {:allow_extra_keys => true})
+      end
+
+      returns(true, 'when value is nil and schema expects NilClass') do
+        validator.validate({"key" => nil}, {"key" => NilClass})
+      end
+
+      returns(true, 'when value and schema match as hashes') do
+        validator.validate({}, {})
+      end
+
+      returns(true, 'when value and schema match as arrays') do
+        validator.validate([], [])
+      end
+
+      returns(true, 'when value is a Time') do
+        validator.validate({"time" => Time.now}, {"time" => Time})
+      end
+
+      returns(true, 'when key is missing but value should be NilClass (#1477)') do
+        validator.validate({}, {"key" => NilClass}, {:allow_optional_rules => true})
+      end
+
+      returns(true, 'when key is missing but value is nullable (#1477)') do
+        validator.validate({}, {"key" => Fog::Nullable::String}, {:allow_optional_rules => true})
+      end
+
+    end
+
+    tests('returns false') do
+
+      returns(false, 'when value does not match schema expectation') do
+        validator.validate({"key" => nil}, {"key" => String})
+      end
+
+      returns(false, 'when key formats do not match') do
+        validator.validate({"key" => "Value"}, {:key => String})
+      end
+
+      returns(false, 'when additional keys are passed and strict') do
+        validator.validate({"key" => "Missing"}, {})
+      end
+
+      returns(false, 'when some keys do not appear') do
+        validator.validate({}, {"key" => String})
+      end
+
+      returns(false, 'when collection contains a member that does not match schema') do
+        validator.validate([{"key" => "Value"}, {"key" => 5}], [{"key" => String}])
+      end
+
+      returns(false, 'when collection has multiple schema patterns') do
+        validator.validate([{"key" => "Value"}], [{"key" => Integer}, {"key" => String}])
+      end
+
+      returns(false, 'when hash and array are compared') do
+        validator.validate({}, [])
+      end
+
+      returns(false, 'when array and hash are compared') do
+        validator.validate([], {})
+      end
+
+      returns(false, 'when a hash is expected but another data type is found') do
+        validator.validate({"key" => {:nested_key => []}}, {"key" => {:nested_key => {}}})
+      end
+
+      returns(false, 'when key is missing but value should be NilClass (#1477)') do
+        validator.validate({}, {"key" => NilClass}, {:allow_optional_rules => false})
+      end
+
+      returns(false, 'when key is missing but value is nullable (#1477)') do
+        validator.validate({}, {"key" => Fog::Nullable::String}, {:allow_optional_rules => false})
+      end
+
+    end
+  end
+end

data/tests/hp/models/block_storage/bootable_volume_tests.rb

@@ -0,0 +1,23 @@
+Shindo.tests("HP::BlockStorage | bootable volumes", ['hp', 'block_storage', 'volumes']) do
+
+  @base_image_id = ENV["BASE_IMAGE_ID"] || 1242
+
+  model_tests(HP[:block_storage].bootable_volumes, {:name => "fogbvoltests", :description => "fogbvoltests-desc", :size => 10, :image_id => @base_image_id}, true)
+
+  tests("new volume") do
+    @volume = HP[:block_storage].bootable_volumes.create(:name => "testbvol", :size => 10, :image_id => @base_image_id)
+    @volume.wait_for { ready? } unless Fog.mocking?
+
+    test("get(#{@volume.id})") do
+      HP[:block_storage].bootable_volumes.get(@volume.id) != nil?
+    end
+
+    test("has_attachments?") do
+      @volume.has_attachments? == false
+    end
+    after do
+      @volume.destroy
+    end
+  end
+
+end

data/tests/hp/models/block_storage/snapshot_tests.rb

@@ -0,0 +1,23 @@
+Shindo.tests("HP::BlockStorage | snapshots", ['hp', 'block_storage', 'snapshots']) do
+
+  @volume = HP[:block_storage].volumes.create(:name => "testsnapvol", :size => 1)
+  @volume.wait_for { ready? } unless Fog.mocking?
+
+  model_tests(HP[:block_storage].snapshots, {:name => "fogsnaptests", :description => "fogsnaptests-desc", :volume_id => @volume.id}, true)
+
+  tests("new snapshot") do
+    @snapshot = HP[:block_storage].snapshots.create(:name => "testvol", :volume_id => @volume.id)
+    @snapshot.wait_for { ready? } unless Fog.mocking?
+
+    test("get(#{@snapshot.id})") do
+      HP[:block_storage].snapshots.get(@snapshot.id) != nil?
+    end
+
+    after do
+      @snapshot.destroy
+    end
+  end
+
+  @volume.destroy
+
+end

data/tests/hp/models/block_storage/volume_tests.rb

@@ -0,0 +1,21 @@
+Shindo.tests("HP::BlockStorage | volumes", ['hp', 'block_storage', 'volumes']) do
+
+  model_tests(HP[:block_storage].volumes, {:name => "fogvoltests", :description => "fogvoltests-desc", :size => 1}, true)
+
+  tests("new volume") do
+    @volume = HP[:block_storage].volumes.create(:name => "testvol", :size => 1)
+    @volume.wait_for { ready? } unless Fog.mocking?
+
+    test("get(#{@volume.id})") do
+      HP[:block_storage].volumes.get(@volume.id) != nil?
+    end
+
+    test("has_attachments?") do
+      @volume.has_attachments? == false
+    end
+    after do
+      @volume.destroy
+    end
+  end
+
+end

data/tests/hp/models/compute/address_tests.rb

@@ -1,4 +1,4 @@
-Shindo.tests("Fog::Compute[:hp] | address", ["hp"]) do
+Shindo.tests("Fog::Compute[:hp] | address", ['hp']) do
 
   @base_image_id = ENV["BASE_IMAGE_ID"] || 1242
 

data/tests/hp/models/compute/addresses_tests.rb

@@ -1,4 +1,4 @@
-Shindo.tests("Fog::Compute[:hp] | addresses", ["hp"]) do
+Shindo.tests("Fog::Compute[:hp] | addresses", ['hp']) do
 
   collection_tests(Fog::Compute[:hp].addresses, {}, true)
 

data/tests/hp/models/compute/key_pair_tests.rb

@@ -1,4 +1,4 @@
-Shindo.tests("Fog::Compute[:hp] | key_pair", ["hp"]) do
+Shindo.tests("Fog::Compute[:hp] | key_pair", ['hp']) do
 
   model_tests(Fog::Compute[:hp].key_pairs, {:name => 'fogkeyname'}, true)
 

data/tests/hp/models/compute/key_pairs_tests.rb

@@ -1,4 +1,4 @@
-Shindo.tests("Fog::Compute[:hp] | key_pairs", ["hp"]) do
+Shindo.tests("Fog::Compute[:hp] | key_pairs", ['hp']) do
 
   collection_tests(Fog::Compute[:hp].key_pairs, {:name => 'fogkeyname'}, true)
 

data/tests/hp/models/compute/metadata_image_tests.rb

@@ -0,0 +1,60 @@
+Shindo.tests("Fog::Compute[:hp] | metadata for images", ['hp']) do
+
+  @base_image_id = ENV["BASE_IMAGE_ID"] || 1242
+
+  @server = Fog::Compute[:hp].servers.create(:name => "fogsermdtests", :flavor_id => 100, :image_id => @base_image_id)
+  @server.wait_for { ready? }
+  response = @server.create_image("fogimgmetadatatests", :metadata => {'Meta1' => 'MetaValue1', 'Meta2' => 'MetaValue2'})
+  unless Fog.mocking?
+    sleep(10)
+  end
+  new_image_id = response.headers["Location"].split("/")[5]
+  @image = Fog::Compute[:hp].images.get(new_image_id)
+  tests('success') do
+
+    tests("#all").succeeds do
+      @image.metadata.all
+    end
+
+    tests("#get('Meta1')").succeeds do
+      pending if Fog.mocking?
+      @image.metadata.get('Meta1')
+    end
+
+    tests("#update({'Meta3' => 'MetaValue3'})").succeeds do
+      @data = @image.metadata.update({'Meta3' => 'MetaValue3'})
+      test("metadata has updated correctly") do
+        @image.metadata.get('Meta3').value == "MetaValue3"
+      end
+    end
+
+    tests("#set({'Meta4' => 'MetaValue4'})").succeeds do
+      @data = @image.metadata.set({'Meta4' => 'MetaValue4'})
+      test("metadata has set correctly") do
+        @image.metadata.get('Meta4').value == "MetaValue4"
+      end
+    end
+
+    tests("#save").succeeds do
+      m = @image.metadata.new(:key => 'Meta5', :value => 'MetaValue5')
+      @data = m.save
+      test("metadata has saved correctly") do
+        @image.metadata.get('Meta5').value == "MetaValue5"
+      end
+    end
+
+    tests("#destroy('Meta5')").succeeds do
+      @image.metadata.destroy('Meta5')
+      test("metadata has been destroyed") do
+        @image.metadata.get('Meta5') == nil
+      end
+    end
+
+  end
+
+  unless Fog.mocking?
+    @image.destroy
+  end
+  @server.destroy
+
+end

data/tests/hp/models/compute/metadata_server_tests.rb

@@ -0,0 +1,54 @@
+Shindo.tests("Fog::Compute[:hp] | metadata for servers", ['hp']) do
+
+  @base_image_id = ENV["BASE_IMAGE_ID"] || 1242
+
+  @server = Fog::Compute[:hp].servers.create(:name => "fogsermetadatatests", :flavor_id => 100, :image_id => @base_image_id, :metadata => {'Meta1' => 'MetaValue1', 'Meta2' => 'MetaValue2'})
+  @server.wait_for { ready? }
+
+  tests('success') do
+
+    tests("#all").succeeds do
+      @server.metadata.all
+    end
+
+    tests("#get('Meta1')").succeeds do
+      @data = @server.metadata.get('Meta1')
+      test("metadata gets correct value") do
+        @data.value == "MetaValue1"
+      end
+    end
+
+    tests("#update({'Meta3' => 'MetaValue3'})").succeeds do
+      @data = @server.metadata.update({'Meta3' => 'MetaValue3'})
+      test("metadata has updated correctly") do
+        @server.metadata.get('Meta3').value == "MetaValue3"
+      end
+    end
+
+    tests("#set({'Meta4' => 'MetaValue4'})").succeeds do
+      @data = @server.metadata.set({'Meta4' => 'MetaValue4'})
+      test("metadata has set correctly") do
+        @server.metadata.get('Meta4').value == "MetaValue4"
+      end
+    end
+
+    tests("#save").succeeds do
+      m = @server.metadata.new(:key => 'Meta5', :value => 'MetaValue5')
+      @data = m.save
+      test("metadata has saved correctly") do
+        @server.metadata.get('Meta5').value == "MetaValue5"
+      end
+    end
+
+    tests("#destroy('Meta5')").succeeds do
+      @data = @server.metadata.destroy('Meta5')
+      test("metadata has been destroyed") do
+        @server.metadata.get('Meta5') == nil
+      end
+    end
+
+  end
+
+  @server.destroy
+
+end

data/tests/hp/models/compute/security_group_tests.rb

@@ -1,4 +1,6 @@
-Shindo.tests("Fog::Compute[:hp] | security_group", ["hp"]) do
+Shindo.tests("Fog::Compute[:hp] | security_group", ['hp']) do
+  # Disabled due to https://github.com/fog/fog/1546
+  pending
 
   model_tests(Fog::Compute[:hp].security_groups, {:name => 'foggroupname', :description => 'foggroupdescription'}, true)
 

data/tests/hp/models/compute/security_groups_tests.rb

@@ -1,4 +1,4 @@
-Shindo.tests("Fog::Compute[:hp] | security_groups", ["hp"]) do
+Shindo.tests("Fog::Compute[:hp] | security_groups", ['hp']) do
 
   collection_tests(Fog::Compute[:hp].security_groups, {:name => 'foggroupname', :description => 'foggroupdescription'}, true)
 

data/tests/hp/models/storage/directories_tests.rb

@@ -0,0 +1,23 @@
+Shindo.tests("Fog::Storage[:hp] | directories", ['hp', 'storage']) do
+
+  collection_tests(Fog::Storage[:hp].directories, {:key => "fogdirtests"}, true)
+
+  tests('success') do
+
+    tests("#create('fogdirtests')").succeeds do
+      Fog::Storage[:hp].directories.create(:key => 'fogdirtests')
+    end
+
+    tests("#head('fogdirtests')").succeeds do
+      Fog::Storage[:hp].directories.head('fogdirtests')
+    end
+
+    tests("#get('fogdirtests')").succeeds do
+      @directory = Fog::Storage[:hp].directories.get('fogdirtests')
+    end
+
+    @directory.destroy
+
+  end
+
+end

data/tests/hp/models/storage/directory_tests.rb

@@ -0,0 +1,62 @@
+Shindo.tests("Fog::Storage[:hp] | directory", ['hp', 'storage']) do
+
+  model_tests(Fog::Storage[:hp].directories, {:key => "fogdirtests"}, true) do
+
+    tests('success') do
+
+      tests("#grant('pr')").succeeds do
+        @instance.grant('pr')
+        tests("public?").returns(true) do
+          @instance.public?
+        end
+      end
+
+      tests("#revoke('pr')").succeeds do
+        @instance.revoke('pr')
+        tests("public?").returns(false) do
+          @instance.public?
+        end
+      end
+
+      @instance.files.create(:key => 'sample.txt', :body => lorem_file)
+      tests("#files").succeeds do
+        @instance.files
+      end
+      @instance.files.get('sample.txt').destroy
+
+      tests("#cdn_enable=(true)").succeeds do
+        pending if Fog.mocking?
+        @instance.cdn_enable=(true)
+        tests("cdn_enabled?").returns(true) do
+          pending if Fog.mocking?
+          @instance.cdn_enable?
+        end
+      end
+
+      tests("#cdn_public_url").succeeds do
+        pending if Fog.mocking?
+        @instance.cdn_public_url
+      end
+
+      tests("#cdn_public_ssl_url").succeeds do
+        pending if Fog.mocking?
+        @instance.cdn_public_ssl_url
+      end
+
+    end
+
+    tests('failure') do
+
+      tests("#grant('invalid-acl')").raises(ArgumentError) do
+        @instance.grant('invalid-acl')
+      end
+
+      tests("#revoke('invalid-acl')").raises(ArgumentError) do
+        @instance.revoke('invalid-acl')
+      end
+
+    end
+
+  end
+
+end