fog 1.9.0 → 1.10.0

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

@@ -0,0 +1,44 @@
+Shindo.tests("Fog::Storage[:hp] | directory", ['hp', 'storage']) do
+
+  file_attributes = {
+    :key => 'fog_file_tests',
+    :body => lorem_file,
+    :public => true
+  }
+
+  directory_attributes = {
+    :key => 'fogfilestests'
+  }
+
+  @directory = Fog::Storage[:hp].directories.create(directory_attributes)
+
+  model_tests(@directory.files, file_attributes, true) do
+
+    @file = @directory.files.get('fog_file_tests')
+
+    tests('success') do
+
+      tests("#directory").returns(@directory.key) do
+        @file.directory.key
+      end
+
+      tests("#cdn_public_url").succeeds do
+        pending if Fog.mocking?
+        @file.cdn_public_url
+      end
+
+      tests("#cdn_public_ssl_url").succeeds do
+        pending if Fog.mocking?
+        @file.cdn_public_ssl_url
+      end
+
+      tests("#temp_signed_url(60, 'GET')").succeeds do
+        @file.temp_signed_url(60, 'GET')
+      end
+
+    end
+  end
+
+  @directory.destroy
+
+end

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

@@ -0,0 +1,38 @@
+Shindo.tests("Fog::Storage[:hp] | files", ['hp', 'storage']) do
+
+  file_attributes = {
+    :key => 'fog_files_tests',
+    :body => lorem_file
+  }
+
+  directory_attributes = {
+    :key => 'fogfilestests'
+  }
+
+  collection_tests(Fog::Storage[:hp].directories.create(directory_attributes).files, file_attributes, true)
+
+  @directory = Fog::Storage[:hp].directories.create(directory_attributes)
+  @file = @directory.files.create(file_attributes)
+
+  tests('success') do
+
+    tests("#get_url('#{@directory.key}')").succeeds do
+      @directory.files.get_url(@directory.key)
+    end
+
+    tests("#get_cdn_url('#{@directory.key}')").succeeds do
+      pending if Fog.mocking?
+      @directory.files.get_cdn_url(@directory.key)
+    end
+
+    tests("#get_cdn_ssl_url('#{@directory.key}')").succeeds do
+      pending if Fog.mocking?
+      @directory.files.get_cdn_ssl_url(@directory.key)
+    end
+
+  end
+
+  @file.destroy
+  @directory.destroy
+
+end

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

@@ -0,0 +1,78 @@
+Shindo.tests("HP::BlockStorage | bootable volume requests", ['hp', 'block_storage', 'volumes']) do
+
+  @volume_format = {
+    'status'             => String,
+    'displayDescription' => Fog::Nullable::String,
+    'availabilityZone'   => String,
+    'displayName'        => Fog::Nullable::String,
+    'attachments'        => [Fog::Nullable::Hash],
+    'volumeType'         => Fog::Nullable::String,
+    'snapshotId'         => Fog::Nullable::String,
+    'size'               => Integer,
+    'id'                 => Integer,
+    'createdAt'          => String,
+    'metadata'           => Fog::Nullable::Hash
+  }
+
+  @boot_volume_format = {
+    'status'             => String,
+    'displayDescription' => Fog::Nullable::String,
+    'availabilityZone'   => String,
+    'displayName'        => Fog::Nullable::String,
+    'attachments'        => [Fog::Nullable::Hash],
+    'volumeType'         => Fog::Nullable::String,
+    'snapshotId'         => Fog::Nullable::String,
+    'source_image_id'    => Fog::Nullable::String,
+    'size'               => Integer,
+    'id'                 => Integer,
+    'createdAt'          => String,
+    'metadata'           => Fog::Nullable::Hash
+  }
+
+  @volume_attach_format = {
+    "volumeId" => Integer,
+    "id"       => Integer
+  }
+
+  tests('success') do
+
+    @volume_id = nil
+    @volume_name = "fogbvolumetests"
+    @volume_desc = @volume_name + " desc"
+    @base_image_id = ENV["BASE_IMAGE_ID"] || 1242
+
+    tests("#create_volume(#{@volume_name}, #{@volume_desc}, 10, {'imageRef' => '#{@base_image_id}'})").formats(@volume_format) do
+      data = HP[:block_storage].create_volume(@volume_name, @volume_desc, 10, {'imageRef' => "#{@base_image_id}"}).body['volume']
+      @volume_id = data['id']
+      data
+    end
+
+    HP[:block_storage].volumes.get(@volume_id).wait_for { ready? }
+    tests("#get_bootable_volume_details(#{@volume_id})").formats(@boot_volume_format) do
+      HP[:block_storage].get_bootable_volume_details(@volume_id).body['volume']
+    end
+
+    tests("#list_bootable_volumes").formats({'volumes' => [@boot_volume_format]}) do
+      HP[:block_storage].list_bootable_volumes.body
+    end
+
+    HP[:block_storage].volumes.get(@volume_id).wait_for { ready? }
+    tests("#delete_volume(#{@volume_id})").succeeds do
+      HP[:block_storage].delete_volume(@volume_id)
+    end
+
+  end
+
+  tests('failure') do
+
+    tests("#get_bootable_volume_details(0)").raises(Fog::HP::BlockStorage::NotFound) do
+      HP[:block_storage].get_bootable_volume_details(0)
+    end
+
+    tests("#delete_volume(0)").raises(Fog::HP::BlockStorage::NotFound) do
+      HP[:block_storage].delete_volume(0)
+    end
+
+  end
+
+end

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

@@ -0,0 +1,56 @@
+Shindo.tests('HP::BlockStorage | snapshot requests', ['hp', 'block_storage', 'snapshots']) do
+
+  @snapshot_format = {
+    'status'             => String,
+    'displayDescription' => Fog::Nullable::String,
+    'displayName'        => Fog::Nullable::String,
+    'volumeId'           => Integer,
+    'size'               => Integer,
+    'id'                 => Integer,
+    'createdAt'          => String
+  }
+
+  tests('success') do
+
+    @snapshot_id = nil
+    @snapshot_name = "fogsnapshottests"
+    @snapshot_desc = @snapshot_name + " desc"
+
+    @volume = HP[:block_storage].volumes.create(:name => 'fogvolforsnap', :size => 1)
+    @volume.wait_for { ready? }
+
+    tests("#create_snapshot(#{@snapshot_name}, #{@snapshot_desc}, #{@volume.id})").formats(@snapshot_format) do
+      data = HP[:block_storage].create_snapshot(@snapshot_name, @snapshot_desc, @volume.id).body['snapshot']
+      @snapshot_id = data['id']
+      data
+    end
+
+    tests("#get_snapshot_details(#{@snapshot_id})").formats(@snapshot_format) do
+      HP[:block_storage].get_snapshot_details(@snapshot_id).body['snapshot']
+    end
+
+    tests('#list_snapshots').formats({'snapshots' => [@snapshot_format]}) do
+      HP[:block_storage].list_snapshots.body
+    end
+
+    tests("#delete_snapshot(#{@snapshot_id})").succeeds do
+      HP[:block_storage].delete_snapshot(@snapshot_id)
+    end
+
+  end
+
+  tests('failure') do
+
+    tests('#get_snapshot_details(0)').raises(Fog::HP::BlockStorage::NotFound) do
+      HP[:block_storage].get_snapshot_details(0)
+    end
+
+    tests("#delete_snapshot(0)").raises(Fog::HP::BlockStorage::NotFound) do
+      HP[:block_storage].delete_snapshot(0)
+    end
+
+  end
+
+  @volume.destroy
+
+end

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

@@ -0,0 +1,94 @@
+Shindo.tests("HP::BlockStorage | volume requests", ['hp', 'block_storage', 'volumes']) do
+
+  @volume_format = {
+    'status'             => String,
+    'displayDescription' => Fog::Nullable::String,
+    'availabilityZone'   => String,
+    'displayName'        => Fog::Nullable::String,
+    'attachments'        => [Fog::Nullable::Hash],
+    'volumeType'         => Fog::Nullable::String,
+    'snapshotId'         => Fog::Nullable::String,
+    'size'               => Integer,
+    'id'                 => Integer,
+    'createdAt'          => String,
+    'metadata'           => Fog::Nullable::Hash
+  }
+
+  @volume_attach_format = {
+    "volumeId" => Integer,
+    "id"       => Integer
+  }
+
+  tests('success') do
+
+    @volume_id = nil
+    @volume_name = "fogvolumetests"
+    @volume_desc = @volume_name + " desc"
+    @base_image_id = ENV["BASE_IMAGE_ID"] || 1242
+
+    @server = Fog::Compute[:hp].servers.create(:name => 'fogvoltests', :flavor_id => 100, :image_id => @base_image_id)
+    @server.wait_for { ready? }
+
+    tests("#create_volume(#{@volume_name}, #{@volume_desc}, 1)").formats(@volume_format) do
+      data = HP[:block_storage].create_volume(@volume_name, @volume_desc, 1).body['volume']
+      @volume_id = data['id']
+      data
+    end
+
+    HP[:block_storage].volumes.get(@volume_id).wait_for { ready? }
+    tests("#get_volume_details(#{@volume_id})").formats(@volume_format) do
+      HP[:block_storage].get_volume_details(@volume_id).body['volume']
+    end
+
+    tests('#list_volumes').formats({'volumes' => [@volume_format]}) do
+      HP[:block_storage].list_volumes.body
+    end
+
+    HP[:block_storage].volumes.get(@volume_id).wait_for { ready? }
+    tests("#attach_volume(#{@server.id}, #{@volume_id}, '/dev/sdg')").formats(@volume_attach_format) do
+      Fog::Compute[:hp].attach_volume(@server.id, @volume_id, "/dev/sdg").body['volumeAttachment']
+    end
+
+    HP[:block_storage].volumes.get(@volume_id).wait_for { in_use? } unless Fog.mocking?
+    tests("#detach_volume(#{@server.id}, #{@volume_id})").succeeds do
+      Fog::Compute[:hp].detach_volume(@server.id, @volume_id)
+    end
+
+    HP[:block_storage].volumes.get(@volume_id).wait_for { ready? }
+    tests("#delete_volume(#{@volume_id})").succeeds do
+      HP[:block_storage].delete_volume(@volume_id)
+    end
+
+  end
+
+  tests('failure') do
+
+    tests('#get_volume_details(0)').raises(Fog::HP::BlockStorage::NotFound) do
+      HP[:block_storage].get_volume_details(0)
+    end
+
+    tests("#attach_volume(0, 0, '/dev/sdg')").raises(Fog::Compute::HP::NotFound) do
+      Fog::Compute[:hp].attach_volume(0, 0, "/dev/sdg")
+    end
+    tests("#attach_volume(#{@server.id}, 0, '/dev/sdg')").raises(Fog::HP::BlockStorage::NotFound) do
+      pending if Fog.mocking?
+      Fog::Compute[:hp].attach_volume(@server.id, 0, "/dev/sdg")
+    end
+
+    tests("#detach_volume(0, 0)").raises(Fog::Compute::HP::NotFound) do
+      Fog::Compute[:hp].detach_volume(0, 0)
+    end
+    tests("#detach_volume(#{@server.id}, 0)").raises(Fog::HP::BlockStorage::NotFound) do
+      pending if Fog.mocking?
+      Fog::Compute[:hp].detach_volume(@server.id, 0)
+    end
+
+    tests("#delete_volume(0)").raises(Fog::HP::BlockStorage::NotFound) do
+      HP[:block_storage].delete_volume(0)
+    end
+
+  end
+
+  @server.destroy
+
+end

data/tests/hp/requests/cdn/container_tests.rb

@@ -1,4 +1,4 @@
-Shindo.tests('Fog::CDN[:hp] | container requests', ["hp"]) do
+Shindo.tests("Fog::CDN[:hp] | container requests", ['hp']) do
 
   @cdn_containers_format = [{
     'x-cdn-ssl-uri' => String,

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

@@ -1,4 +1,4 @@
-Shindo.tests('Fog::Compute[:hp] | address requests', ["hp"]) do
+Shindo.tests("Fog::Compute[:hp] | address requests", ['hp', 'address']) do
 
   @floating_ips_format = {
     'instance_id' => Fog::Nullable::Integer,
@@ -30,12 +30,11 @@ Shindo.tests('Fog::Compute[:hp] | address requests', ["hp"]) do
     @server.wait_for { ready? }
 
     tests("#associate_address('#{@server.id}', '#{@ip_address}')").succeeds do
-      result = Fog::Compute[:hp].associate_address(@server.id, @ip_address)
-      tests("#get_address").returns(@server.id, "associated to valid instance id") do
-        pending if Fog.mocking?
-        Fog::Compute[:hp].get_address(@address_id).body['floating_ip']['instance_id']
+      Fog::Compute[:hp].associate_address(@server.id, @ip_address)
+      tests("#get_address").returns(@ip_address, "server has associated ip address") do
+        @server.reload
+        @server.addresses['private'][1]['addr']
       end
-      result
     end
 
     tests("#disassociate_address('#{@server.id}', '#{@ip_address}')").succeeds do

data/tests/hp/requests/compute/flavor_tests.rb

@@ -1,4 +1,4 @@
-Shindo.tests('Fog::Compute[:hp] | flavor requests', ["hp"]) do
+Shindo.tests("Fog::Compute[:hp] | flavor requests", ['hp']) do
 
   @flavor_format = {
     'rxtx_quota' => Integer,

data/tests/hp/requests/compute/image_tests.rb

@@ -1,4 +1,4 @@
-Shindo.tests('Fog::Compute[:hp] | image requests', ["hp"]) do
+Shindo.tests("Fog::Compute[:hp] | image requests", ['hp']) do
 
   @image_format = {
     'id'        => String,

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

@@ -1,4 +1,4 @@
-Shindo.tests('Fog::Compute[:hp] | key pair requests', ["hp"]) do
+Shindo.tests("Fog::Compute[:hp] | key pair requests", ['hp']) do
 
   tests('success') do
 

data/tests/hp/requests/compute/metadata_tests.rb

@@ -0,0 +1,70 @@
+Shindo.tests("Fog::Compute[:hp] | metadata requests", ['hp']) do
+
+  @metadata_format = {
+    'metadata'  => Fog::Nullable::Hash
+  }
+  @metaitem_format = {
+    'meta'  => Fog::Nullable::Hash
+  }
+
+  @base_image_id = ENV["BASE_IMAGE_ID"] || 1242
+
+  tests('success') do
+    @server_name = "fogmetadatatest"
+    @server = Fog::Compute[:hp].servers.create(:name => @server_name, :flavor_id => 100, :image_id => @base_image_id, :metadata => {'Meta1' => 'MetaValue1', 'Meta2' => 'MetaValue2'} )
+    @server.wait_for { ready? }
+
+    tests("#list_metadata('servers', #{@server.id})").formats(@metadata_format) do
+      metadata = Fog::Compute[:hp].list_metadata('servers', @server.id).body
+      test ("metadata exists") do
+        metadata['metadata']['Meta1'] == "MetaValue1"
+      end
+      metadata
+    end
+
+    tests("#set_metadata('servers', #{@server.id}, {'MetaNew3' => 'MetaNewValue3'})").formats(@metadata_format) do
+      data = Fog::Compute[:hp].set_metadata('servers', @server.id, {'MetaNew3' => 'MetaNewValue3'}).body
+      test ("metadata set correctly") do
+        metadata = Fog::Compute[:hp].list_metadata('servers', @server.id).body
+        metadata['metadata']['MetaNew3'] == "MetaNewValue3"
+      end
+      data
+    end
+
+    tests("#update_metadata('servers', #{@server.id}, {'MetaUpd4' => 'MetaUpdValue4'})").formats(@metadata_format) do
+      data = Fog::Compute[:hp].update_metadata('servers', @server.id, {'MetaUpd4' => 'MetaUpdValue4'}).body
+      test ("metadata updated correctly") do
+        metadata = Fog::Compute[:hp].list_metadata('servers', @server.id).body
+        metadata['metadata']['MetaUpd4'] == "MetaUpdValue4"
+      end
+      data
+    end
+
+    tests("#get_meta('servers', #{@server.id}, 'MetaNew3')").formats(@metaitem_format) do
+      mitem = Fog::Compute[:hp].get_meta('servers', @server.id, 'MetaNew3').body
+      test ("metadata item exists") do
+        mitem['meta']['MetaNew3'] == "MetaNewValue3"
+      end
+      mitem
+    end
+
+    tests("#update_meta('servers', #{@server.id}, 'MetaNew3', 'MetaUpdValue3')").formats(@metaitem_format) do
+      mitem = Fog::Compute[:hp].update_meta('servers', @server.id, 'MetaNew3', 'MetaUpdValue3').body
+      test ("metadata item updated correctly") do
+        mitem['meta']['MetaNew3'] == "MetaUpdValue3"
+      end
+      mitem
+    end
+
+    tests("#delete_meta('servers', #{@server.id}, 'MetaNew3')").succeeds do
+      data = Fog::Compute[:hp].delete_meta('servers', @server.id, 'MetaNew3').body
+      test ("metadata item deleted correctly") do
+        metadata = Fog::Compute[:hp].list_metadata('servers', @server.id).body
+        metadata['metadata'].fetch('MetaNew3', nil) == nil
+      end
+      data
+    end
+
+    @server.destroy
+  end
+end

data/tests/hp/requests/compute/persistent_server_tests.rb

@@ -0,0 +1,66 @@
+Shindo.tests("Fog::Compute[:hp] | persistent server requests", ['hp', 'compute']) do
+
+  @server_format = {
+    'addresses'   => Fog::Nullable::Hash,
+    'flavor'      => Hash,
+    'id'          => Integer,
+    'links'       => [Hash],
+    'hostId'      => String,
+    'metadata'    => Fog::Nullable::Hash,
+    'name'        => String,
+    'accessIPv4'  => Fog::Nullable::String,
+    'accessIPv6'  => Fog::Nullable::String,
+    'progress'    => Fog::Nullable::Integer,
+    'status'      => String,
+    'created'     => String,
+    'updated'     => String,
+    'user_id'     => String,
+    'tenant_id'   => String,
+    'uuid'        => String,
+    'config_drive' => Fog::Nullable::String,
+    'security_groups' => [Hash],
+    'key_name'    => Fog::Nullable::String
+  }
+
+  @volume = HP[:block_storage].volumes.create(:name => 'fogvoltests', :description => 'fog vol test desc', :size => 1)
+  @volume.wait_for { ready? }
+
+  tests('success') do
+
+    @server_id = nil
+    @server_name = "fogpersservertests"
+    @block_device_mapping = [{ 'volume_size' => '',
+                               'volume_id' => "#{@volume.id}",
+                               'delete_on_termination' => '0',
+                               'device_name' => 'vda'
+                            }]
+
+    tests("#create_persistent_server(#{@server_name}, 100, #{@block_device_mapping})").formats(@server_format.merge('adminPass' => String)) do
+      data = Fog::Compute[:hp].create_persistent_server(@server_name, 100, @block_device_mapping).body['server']
+      @server_id = data['id']
+      data
+    end
+
+    Fog::Compute[:hp].servers.get(@server_id).wait_for { ready? }
+
+    tests("#get_server_details(#{@server_id})").formats(@server_format) do
+      Fog::Compute[:hp].get_server_details(@server_id).body['server']
+    end
+
+    tests("#delete_server(#{@server_id})").succeeds do
+      Fog::Compute[:hp].delete_server(@server_id)
+    end
+
+  end
+
+  tests('failure') do
+
+    tests("#create_persistent_server(#{@server_name}, 100, nil)").raises(Excon::Errors::BadRequest) do
+      Fog::Compute[:hp].create_persistent_server(@server_name, 100, nil)
+    end
+
+  end
+
+  HP[:block_storage].delete_volume(@volume.id)
+
+end