fog 1.17.0 → 1.18.0

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

@@ -0,0 +1,69 @@
+Shindo.tests('HP::BlockStorageV2 | snapshot requests', ['hp', 'v2', 'block_storage', 'snapshots']) do
+
+  @snapshot_format = {
+    'status'              => String,
+    'display_description' => Fog::Nullable::String,
+    'display_name'        => Fog::Nullable::String,
+    'volume_id'           => String,
+    'size'                => Integer,
+    'id'                  => String,
+    'created_at'          => String,
+    'metadata'            => Fog::Nullable::Hash
+  }
+
+  tests('success') do
+
+    @snapshot_id = nil
+    @snapshot_name = 'fogsnapshot2tests'
+    @snapshot_desc = @snapshot_name + ' desc'
+
+    @volume = HP[:block_storage_v2].volumes.create(:name => 'fogvol2forsnap', :size => 1)
+    @volume.wait_for { ready? }
+
+    tests("#create_snapshot(#{@volume.id}, {'display_name' => #{@snapshot_name}, 'display_description' => #{@snapshot_desc} })").formats(@snapshot_format) do
+      data = HP[:block_storage_v2].create_snapshot(@volume.id, {'display_name' => @snapshot_name, 'display_description' => @snapshot_desc} ).body['snapshot']
+      @snapshot_id = data['id']
+      data
+    end
+
+    tests("#get_snapshot_details(#{@snapshot_id})").formats(@snapshot_format) do
+      HP[:block_storage_v2].get_snapshot_details(@snapshot_id).body['snapshot']
+    end
+
+    tests("#update_snapshot(#{@snapshot_id}, 'display_name' => '#{@snapshot_name} Updated')").formats(@snapshot_format) do
+      HP[:block_storage_v2].update_snapshot(@snapshot_id, 'display_name' => "#{@snapshot_name} Updated").body['snapshot']
+    end
+
+    tests('#list_snapshots').formats({'snapshots' => [@snapshot_format]}) do
+      HP[:block_storage_v2].list_snapshots.body
+    end
+
+    tests('#list_snapshots_detail').formats({'snapshots' => [@snapshot_format]}) do
+      HP[:block_storage_v2].list_snapshots_detail.body
+    end
+
+    tests("#delete_snapshot(#{@snapshot_id})").succeeds do
+      HP[:block_storage_v2].delete_snapshot(@snapshot_id)
+    end
+
+  end
+
+  tests('failure') do
+
+    tests('#get_snapshot_details(0)').raises(Fog::HP::BlockStorageV2::NotFound) do
+      HP[:block_storage_v2].get_snapshot_details(0)
+    end
+
+    tests('#update_snapshot(0)').raises(Fog::HP::BlockStorageV2::NotFound) do
+      HP[:block_storage_v2].update_snapshot(0)
+    end
+
+    tests('#delete_snapshot(0)').raises(Fog::HP::BlockStorageV2::NotFound) do
+      HP[:block_storage_v2].delete_snapshot(0)
+    end
+
+  end
+
+  @volume.destroy
+
+end

data/tests/hp/requests/block_storage_v2/volume_backup_tests.rb

@@ -0,0 +1,117 @@
+Shindo.tests("Fog::HP::BlockStorageV2 | volume backup requests", ['hp', 'v2', 'block_storage', 'volume_backup']) do
+
+  @backup_details_format = {
+    'id'                  => String,
+    'status'              => String,
+    'name'                => Fog::Nullable::String,
+    'description'         => Fog::Nullable::String,
+    'container'           => String,
+    'availability_zone'   => String,
+    'created_at'          => String,
+    'volume_id'           => String,
+    'size'                => Integer,
+    'links'               => [Fog::Nullable::Hash],
+    'fail_reason'         => Fog::Nullable::String,
+    'object_count'        => Integer
+  }
+
+  @backup_format = {
+    'id'     => String,
+    'name'   => Fog::Nullable::String,
+    'links'  => [Fog::Nullable::Hash]
+  }
+
+  @restore_format = {
+    'backup_id' => String,
+    'volume_id' => String
+  }
+
+  tests('success') do
+
+    @backup_id = nil
+    @backup_name = 'fogvolbackup2tests'
+    @backup_desc = @backup_name + ' desc'
+
+    @volume = HP[:block_storage_v2].volumes.create(:name => 'fogvol2forbackup', :size => 1)
+    @volume.wait_for { ready? }
+
+    @target_volume = HP[:block_storage_v2].volumes.create(:name => 'fogtargetvolume', :size => 2)
+    @target_volume.wait_for { ready? }
+
+    tests("#create_volume_backup(#{@volume.id}, {'name' => #{@backup_name}, 'description' => #{@backup_desc}, 'container' => 'my_backups')").formats(@backup_format) do
+      data = HP[:block_storage_v2].create_volume_backup(@volume.id, {'name' => @backup_name, 'description' => @backup_desc, 'container' => 'my_backups'}).body['backup']
+      @backup_id = data['id']
+      data
+    end
+
+    tests("#get_volume_backup_details(#{@backup_id})").formats(@backup_details_format) do
+      HP[:block_storage_v2].get_volume_backup_details(@backup_id).body['backup']
+    end
+
+    tests('#list_volume_backups').formats({'backups' => [@backup_format]}) do
+      HP[:block_storage_v2].list_volume_backups.body
+    end
+
+    tests('#list_volume_backups_detail').formats({'backups' => [@backup_details_format]}) do
+      HP[:block_storage_v2].list_volume_backups_detail.body
+    end
+
+    # restore into new volume
+    tests("#restore_volume_backup(#{@backup_id}").formats(@restore_format) do
+      data = HP[:block_storage_v2].restore_volume_backup(@backup_id).body['restore']
+      restored_volume_id = data['volume_id']
+      restored_volume = HP[:block_storage_v2].get_volume_details(restored_volume_id).body['volume']
+      test ('should create a new volume with backup restored') do
+        restored_volume['display_name'] == @volume.name
+        restored_volume['display_description'] == @volume.description
+        restored_volume['availability_zone'] == @volume.availability_zone
+        restored_volume['size'] == @volume.size
+      end
+      data
+    end
+
+    ## restore into existing volume
+    tests("#restore_volume_backup(#{@backup_id}, {'volume_id' => #{@target_volume.id}}").formats(@restore_format) do
+      data = HP[:block_storage_v2].restore_volume_backup(@backup_id, {'volume_id' => @target_volume.id}).body['restore']
+      restored_volume_id = data['volume_id']
+      restored_volume = HP[:block_storage_v2].get_volume_details(restored_volume_id).body['volume']
+      test ('should overwrite the existing volume with backup restored') do
+        restored_volume['id'] == @target_volume.id
+        restored_volume['display_name'] == @volume.name
+        restored_volume['display_description'] == @volume.description
+        restored_volume['availability_zone'] == @volume.availability_zone
+        restored_volume['size'] == @volume.size
+      end
+      data
+    end
+    #
+    tests("#delete_volume_backup(#{@backup_id})").succeeds do
+      HP[:block_storage_v2].delete_volume_backup(@backup_id)
+    end
+
+  end
+
+  tests('failure') do
+
+    tests('#get_volume_backup_details("0")').raises(Fog::HP::BlockStorageV2::NotFound) do
+      HP[:block_storage_v2].get_volume_backup_details('0')
+    end
+
+    tests('#restore_volume_backup("0")').raises(Fog::HP::BlockStorageV2::NotFound) do
+      HP[:block_storage_v2].restore_volume_backup('0')
+    end
+
+    tests("#restore_volume_backup(#{@backup_id}, '0')").raises(Fog::HP::BlockStorageV2::NotFound) do
+      HP[:block_storage_v2].restore_volume_backup(@backup_id, '0')
+    end
+
+    tests('#delete_volume_backup("0")').raises(Fog::HP::BlockStorageV2::NotFound) do
+      HP[:block_storage_v2].delete_volume_backup('0')
+    end
+
+  end
+
+  @target_volume.destroy
+  @volume.destroy
+
+end

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

@@ -0,0 +1,106 @@
+Shindo.tests("Fog::HP::BlockStorageV2 | volume requests", ['hp', 'v2', 'block_storage', 'volumes']) do
+
+  compute_service = Fog::Compute.new(:provider => 'HP', :version => :v2)
+
+  @volume_format = {
+    'id'                  => String,
+    'display_name'        => Fog::Nullable::String,
+    'display_description' => Fog::Nullable::String,
+    'size'                => Integer,
+    'status'              => String,
+    'volume_type'         => Fog::Nullable::String,
+    'snapshot_id'         => Fog::Nullable::String,
+    'source_volid'        => Fog::Nullable::String,
+    'bootable'            => Fog::Boolean,
+    'created_at'          => String,
+    'availability_zone'   => String,
+    'attachments'         => [Fog::Nullable::Hash],
+    'metadata'            => Fog::Nullable::Hash
+  }
+
+  @volume_attach_format = {
+    'device'    => String,
+    'serverId'  => String,
+    'volumeId'  => String,
+    'id'        => String
+  }
+
+  tests('success') do
+
+    @volume_id = nil
+    @volume_name = 'fogvolume2tests'
+    @volume_desc = @volume_name + ' desc'
+    @base_image_id = ENV['BASE_IMAGE_ID'] || '7f60b54c-cd15-433f-8bed-00acbcd25a17'
+
+    @server = compute_service.servers.create(:name => 'fogvoltests', :flavor_id => 100, :image_id => @base_image_id)
+    @server.wait_for { ready? }
+
+    tests("#create_volume('display_name' => #{@volume_name}, 'display_description' => #{@volume_desc}, 'size' => 1)").formats(@volume_format) do
+      data = HP[:block_storage_v2].create_volume('display_name' => @volume_name, 'display_description' => @volume_desc, 'size' => 1).body['volume']
+      @volume_id = data['id']
+      data
+    end
+
+    tests("#get_volume_details(#{@volume_id})").formats(@volume_format) do
+      HP[:block_storage_v2].get_volume_details(@volume_id).body['volume']
+    end
+
+    tests("#update_volume(#{@volume_id}, 'display_name' => #{@volume_name}+' Upd'").formats(@volume_format) do
+      data = HP[:block_storage_v2].update_volume(@volume_id, 'display_name' => @volume_name).body['volume']
+      @volume_id = data['id']
+      data
+    end
+
+    tests('#list_volumes').formats({'volumes' => [@volume_format]}) do
+      HP[:block_storage_v2].list_volumes.body
+    end
+
+    tests('#list_volumes_detail').formats({'volumes' => [@volume_format]}) do
+      HP[:block_storage_v2].list_volumes_detail.body
+    end
+
+    tests("#attach_volume(#{@server.id}, #{@volume_id}, '/dev/sdg')").formats(@volume_attach_format) do
+      compute_service.attach_volume(@server.id, @volume_id, "/dev/sdg").body['volumeAttachment']
+    end
+
+    tests("#detach_volume(#{@server.id}, #{@volume_id})").succeeds do
+      compute_service.detach_volume(@server.id, @volume_id)
+    end
+
+    tests("#delete_volume(#{@volume_id})").succeeds do
+      HP[:block_storage_v2].delete_volume(@volume_id)
+    end
+
+  end
+
+  tests('failure') do
+
+    tests('#get_volume_details(0)').raises(Fog::HP::BlockStorageV2::NotFound) do
+      HP[:block_storage_v2].get_volume_details(0)
+    end
+
+    tests("#attach_volume(0, 0, '/dev/sdg')").raises(Fog::Compute::HPV2::NotFound) do
+      compute_service.attach_volume(0, 0, "/dev/sdg")
+    end
+    tests("#attach_volume(#{@server.id}, 0, '/dev/sdg')").raises(Fog::HP::BlockStorageV2::NotFound) do
+      pending if Fog.mocking?
+      compute_service.attach_volume(@server.id, 0, "/dev/sdg")
+    end
+
+    tests('#detach_volume(0, 0)').raises(Fog::Compute::HPV2::NotFound) do
+      compute_service.detach_volume(0, 0)
+    end
+    tests("#detach_volume(#{@server.id}, 0)").raises(Fog::HP::BlockStorageV2::NotFound) do
+      pending if Fog.mocking?
+      compute_service.detach_volume(@server.id, 0)
+    end
+
+    tests('#delete_volume(0)').raises(Fog::HP::BlockStorageV2::NotFound) do
+      HP[:block_storage_v2].delete_volume(0)
+    end
+
+  end
+
+  @server.destroy
+
+end

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

@@ -0,0 +1,80 @@
+Shindo.tests("Fog::Compute::HPV2 | address requests", ['hp', 'v2', 'compute', 'address']) do
+
+  service = Fog::Compute.new(:provider => 'HP', :version => :v2)
+
+  @floating_ips_format = {
+    'instance_id' => Fog::Nullable::String,
+    'ip'          => Fog::Nullable::String,
+    'fixed_ip'    => Fog::Nullable::String,
+    'id'          => String
+  }
+
+  @base_image_id = ENV["BASE_IMAGE_ID"] || "7f60b54c-cd15-433f-8bed-00acbcd25a17"
+
+  tests('success') do
+
+    @server_name = 'fogservertest'
+    @server_id = nil
+
+    @server = service.servers.create(:name => @server_name, :flavor_id => 100, :image_id => @base_image_id)
+    @server.wait_for { ready? }
+    #data = service.create_server(@server_name, 100, @base_image_id).body['server']
+    #@server_id = data['id']
+
+    tests("#list_addresses").formats({'floating_ips' => [@floating_ips_format]}) do
+      service.list_addresses.body
+    end
+
+    tests("#allocate_address").formats(@floating_ips_format) do
+      data = service.allocate_address.body['floating_ip']
+      @address_id = data['id']
+      @ip_address = data['ip']
+      data
+    end
+
+    tests("#get_address('#{@address_id}')").formats(@floating_ips_format) do
+      service.get_address(@address_id).body['floating_ip']
+    end
+
+    tests("#associate_address('#{@server.id}', '#{@ip_address}')").succeeds do
+      service.associate_address(@server.id, @ip_address)
+      #tests("#get_address").returns(@ip_address, "server has associated ip address") do
+      #  @server.reload
+      #  @server.addresses['custom'][0]['addr']
+      #end
+    end
+
+    #tests("#disassociate_address('#{@server.id}', '#{@ip_address}')").succeeds do
+    #  service.disassociate_address(@server.id, @ip_address)
+    #end
+
+    tests("#release_address('#{@address_id}')").succeeds do
+      service.release_address(@address_id)
+    end
+
+    @server.destroy
+    #service.delete_server(@server_id)
+
+  end
+
+  tests('failure') do
+
+    tests("#get_address('invalidaddress', 'invalidip')").raises(Fog::Compute::HPV2::NotFound) do
+      service.get_address('invalidaddress')
+    end
+
+    tests("#associate_address('invalidserver', 'invalidip')").raises(Excon::Errors::InternalServerError) do
+      service.associate_address('invalidserver', 'invalidip')
+    end
+
+    tests("#disassociate_address('invalidserver', 'invalidip')").raises(Excon::Errors::InternalServerError) do
+      service.disassociate_address('invalidserver', 'invalidip')
+    end
+
+    tests("#release_address('invalidaddress')").raises(Fog::Compute::HPV2::NotFound) do
+      service.release_address('invalidaddress')
+    end
+
+  end
+
+end

data/tests/hp/requests/compute_v2/availability_zone_tests.rb

@@ -0,0 +1,19 @@
+Shindo.tests("Fog::Compute::HPV2 | availability_zone requests", ['hp', 'v2', 'compute']) do
+
+  service = Fog::Compute.new(:provider => 'HP', :version => :v2)
+
+  @zone_format = {
+    'zoneName'    => String,
+    'zoneState'   => Hash,
+    'hosts'       => nil
+  }
+
+  tests('success') do
+
+    tests('#list_availability_zones').formats([@zone_format]) do
+      service.list_availability_zones.body['availabilityZoneInfo']
+    end
+
+  end
+
+end

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

@@ -0,0 +1,45 @@
+Shindo.tests("Fog::Compute::HPV2 | flavor requests", ['hp', 'v2', 'compute']) do
+
+  service = Fog::Compute.new(:provider => 'HP', :version => :v2)
+
+  @flavor_format = {
+    'id'         => String,
+    'name'       => String,
+    'vcpus'      => Integer,
+    'disk'       => Integer,
+    'ram'        => Integer,
+    'OS-FLV-EXT-DATA:ephemeral' => Integer,
+    'links'      => [Hash]
+  }
+
+  @list_flavors_format = {
+    'id'    => String,
+    'name'  => String,
+    'links' => [Hash]
+  }
+
+  tests('success') do
+
+    tests('#list_flavors').formats({'flavors' => [@list_flavors_format]}) do
+      service.list_flavors.body
+    end
+
+    tests('#get_flavor_details("1")').formats(@flavor_format) do
+      service.get_flavor_details("1").body['flavor']
+    end
+
+    tests('#list_flavors_detail').formats({'flavors' => [@flavor_format]}) do
+      service.list_flavors_detail.body
+    end
+
+  end
+
+  tests('failure') do
+
+    tests('#get_flavor_details("9999")').raises(Fog::Compute::HPV2::NotFound) do
+      service.get_flavor_details('9999')
+    end
+
+  end
+
+end

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

@@ -0,0 +1,86 @@
+Shindo.tests("Fog::Compute::HPV2 | image requests", ['hp', 'v2', 'compute']) do
+
+  service = Fog::Compute.new(:provider => 'HP', :version => :v2)
+
+  @image_format = {
+    'id'        => String,
+    'links'     => [Hash],
+    'metadata'  => Fog::Nullable::Hash,
+    'server'    => Fog::Nullable::Hash,
+    'name'      => String,
+    'progress'  => Fog::Nullable::Integer,
+    'minDisk'   => Fog::Nullable::Integer,
+    'minRam'    => Fog::Nullable::Integer,
+    'status'    => String,
+    'created'   => Fog::Nullable::String,
+    'updated'   => Fog::Nullable::String
+  }
+
+  @list_images_format = {
+    'id'        => String,
+    'links'     => Fog::Nullable::Array,
+    'name'      => String
+  }
+
+  @base_image_id = ENV["BASE_IMAGE_ID"] || "7f60b54c-cd15-433f-8bed-00acbcd25a17"
+
+  tests('success') do
+    @server_name = 'fogservertest'
+    @image_name  = 'fogimagetest'
+    @image_id = nil
+    @server_id = nil
+
+    # check to see if there are any existing servers, otherwise create one
+    if (data = service.list_servers(:status => 'ACTIVE').body['servers'][0])
+      @server_id = data['id']
+    else
+      #@server = service.servers.create(:name => @server_name, :flavor_id => 100, :image_id => @base_image_id)
+      #@server.wait_for { ready? }
+      data = service.create_server(@server_name, 100, @base_image_id).body['server']
+      @server_id = data['id']
+    end
+
+    tests("#create_image(#{@server_id}, #{@image_name})").formats({}) do
+      response = service.create_image(@server_id, @image_name)
+      # no data is returned for the call, so get id off the header
+      @image_id = response.headers["Location"].split("/")[5]
+      {}
+    end
+
+    #unless Fog.mocking?
+    #  service.images.get(@image_id).wait_for { ready? }
+    #end
+
+    tests("#get_image_details(#{@image_id})").formats(@image_format) do
+      service.get_image_details(@image_id).body['image']
+    end
+
+    tests('#list_images').formats({'images' => [@list_images_format]}) do
+      service.list_images.body
+    end
+
+    tests('#list_images_detail').formats({'images' => [@image_format]}) do
+      service.list_images_detail.body
+    end
+
+    tests("#delete_image(#{@image_id})").succeeds do
+      service.delete_image(@image_id)
+    end
+
+    service.delete_server(@server_id)
+
+  end
+
+  tests('failure') do
+
+    tests('#delete_image("0")').raises(Fog::Compute::HPV2::NotFound) do
+      service.delete_image('0')
+    end
+
+    tests('#get_image_details("0")').raises(Fog::Compute::HPV2::NotFound) do
+      service.get_image_details('0')
+    end
+
+  end
+
+end