fog 1.3.1 → 1.4.0

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

@@ -0,0 +1,64 @@
+Shindo.tests('Fog::Compute[:hp] | security group requests', [:hp]) do
+
+  @security_groups_format = {
+    'security_groups' => [{
+      'rules'       => [Fog::Nullable::Hash],
+      'tenant_id'   => String,
+      'id'          => Integer,
+      'name'        => String,
+      'description' => String
+    }]
+  }
+
+  @security_group_format = {
+    'rules'       => [Fog::Nullable::Hash],
+    'tenant_id'   => String,
+    'id'          => Integer,
+    'name'        => String,
+    'description' => String
+  }
+
+  tests('success') do
+
+    tests("#create_security_group('fog_security_group', 'tests group')").formats({'security_group' => @security_group_format}) do
+      data = Fog::Compute[:hp].create_security_group('fog_security_group', 'tests group').body
+      @sec_group_id = data['security_group']['id']
+      data
+    end
+
+    tests("#get_security_group('#{@sec_group_id}')").formats({'security_group' => @security_group_format}) do
+      Fog::Compute[:hp].get_security_group(@sec_group_id).body
+    end
+
+    tests("#list_security_groups").formats(@security_groups_format) do
+      Fog::Compute[:hp].list_security_groups.body
+    end
+
+
+    tests("#delete_security_group('#{@sec_group_id}')").succeeds do
+      Fog::Compute[:hp].delete_security_group(@sec_group_id).body
+    end
+
+  end
+
+  tests('failure') do
+
+    @security_group = Fog::Compute[:hp].security_groups.create(:name => 'fog_security_group_fail', :description => 'tests group')
+
+    tests("duplicate #create_security_group(#{@security_group.name}, #{@security_group.description})").raises(Excon::Errors::BadRequest) do
+      Fog::Compute[:hp].create_security_group(@security_group.name, @security_group.description)
+    end
+
+    tests("#get_security_group(0)").raises(Fog::Compute::HP::NotFound) do
+      Fog::Compute[:hp].get_security_group(0)
+    end
+
+    tests("#delete_security_group(0)").raises(Fog::Compute::HP::NotFound) do
+      Fog::Compute[:hp].delete_security_group(0)
+    end
+
+    @security_group.destroy
+
+  end
+
+end

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

@@ -0,0 +1,45 @@
+Shindo.tests('Fog::Compute[:hp] | address requests', [:hp]) do
+
+  @base_image_id = ENV["BASE_IMAGE_ID"] || 1242
+
+  tests('success') do
+    @server = Fog::Compute[:hp].servers.create(:name => 'fogaddresstests', :flavor_id => 100, :image_id => @base_image_id)
+    @server.wait_for { ready? }
+    @address = Fog::Compute[:hp].addresses.create
+    @address.server = @server
+
+    # the network name is currently named 'private'
+    tests("#list_server_addresses(#{@server.id})").formats({'addresses' => {"private" => [{'version' => Integer, 'addr' => String}]}}) do
+      Fog::Compute[:hp].list_server_addresses(@server.id).body
+    end
+
+    tests("#list_server_private_addresses(#{@server.id}, 'private')").formats({'private' => [{'version' => Integer, 'addr' => String}]}) do
+      Fog::Compute[:hp].list_server_private_addresses(@server.id, 'private').body
+    end
+
+    tests("#list_server_public_addresses(#{@server.id}, 'private')").formats({'public' => [{'version' => Integer, 'addr' => String}]}) do
+      Fog::Compute[:hp].list_server_public_addresses(@server.id, 'private').body
+    end
+
+    @address.destroy
+    @server.destroy
+
+  end
+
+  tests('failure') do
+
+    tests("#list_server_addresses(0)").raises(Fog::Compute::HP::NotFound) do
+      Fog::Compute[:hp].list_server_addresses(0)
+    end
+
+    tests("#list_server_private_addresses(0, 'private')").raises(Fog::Compute::HP::NotFound) do
+      Fog::Compute[:hp].list_server_private_addresses(0, 'private')
+    end
+
+    tests("#list_server_public_addresses(0, 'private')").raises(Fog::Compute::HP::NotFound) do
+      Fog::Compute[:hp].list_server_public_addresses(0, 'private')
+    end
+
+  end
+
+end

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

@@ -0,0 +1,127 @@
+Shindo.tests('Fog::Compute[:hp] | server requests', [:hp]) do
+
+  @server_format = {
+    'addresses'   => Fog::Nullable::Hash,
+    'flavor'      => Hash,
+    'id'          => Integer,
+    'image'       => Hash,
+    '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
+  }
+
+  @list_servers_format = {
+    'uuid'  => Fog::Nullable::String,
+    'links' => [Hash],
+    'name'  => String,
+    'id'    => Integer
+  }
+
+  @get_console_output_format = {
+
+  }
+
+  @base_image_id = ENV["BASE_IMAGE_ID"] || 1242
+
+  tests('success') do
+
+    @server_id = nil
+    @server_name = "fogservertests"
+
+    tests("#create_server(#{@server_name}, 100, #{@base_image_id})").formats(@server_format.merge('adminPass' => String)) do
+      data = Fog::Compute[:hp].create_server(@server_name, 100, @base_image_id).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('#list_servers').formats({'servers' => [@list_servers_format]}) do
+      Fog::Compute[:hp].list_servers.body
+    end
+
+    tests('#list_servers_detail').formats({'servers' => [@server_format]}) do
+      Fog::Compute[:hp].list_servers_detail.body
+    end
+
+    Fog::Compute[:hp].servers.get(@server_id).wait_for { ready? }
+
+    tests("#update_server(#{@server_id}, :name => 'fogupdateserver')").succeeds do
+      Fog::Compute[:hp].update_server(@server_id, :name => 'fogupdateserver')
+    end
+
+    Fog::Compute[:hp].servers.get(@server_id).wait_for { ready? }
+
+    tests("#reboot_server(#{@server_id}, 'SOFT')").succeeds do
+      Fog::Compute[:hp].reboot_server(@server_id, 'SOFT')
+    end
+
+    Fog::Compute[:hp].servers.get(@server_id).wait_for { ready? }
+
+    tests("#reboot_server(#{@server_id}, 'HARD')").succeeds do
+      Fog::Compute[:hp].reboot_server(@server_id, 'HARD')
+    end
+
+    Fog::Compute[:hp].servers.get(@server_id).wait_for { ready? }
+
+    tests("#change_password_server(#{@server_id}, 'new_password')").succeeds do
+      Fog::Compute[:hp].change_password_server(@server_id, 'new_password')
+    end
+
+    Fog::Compute[:hp].servers.get(@server_id).wait_for { ready? }
+
+    tests("#get_console_output('#{@server_id}')").formats(@get_console_output_format) do
+      pending
+      Fog::Compute[:hp].get_console_output(@server_id).body
+    end
+
+    Fog::Compute[:hp].servers.get(@server_id).wait_for { ready? }
+
+    tests("#delete_server(#{@server_id})").succeeds do
+      Fog::Compute[:hp].delete_server(@server_id)
+    end
+
+  end
+
+  tests('failure') do
+
+    tests('#delete_server(0)').raises(Fog::Compute::HP::NotFound) do
+      Fog::Compute[:hp].delete_server(0)
+    end
+
+    tests('#get_server_details(0)').raises(Fog::Compute::HP::NotFound) do
+      Fog::Compute[:hp].get_server_details(0)
+    end
+
+    tests("#update_server(0, :name => 'fognonserver')").raises(Fog::Compute::HP::NotFound) do
+      Fog::Compute[:hp].update_server(0, :name => 'fognonserver')
+    end
+
+    tests('#reboot_server(0)').raises(Fog::Compute::HP::NotFound) do
+      Fog::Compute[:hp].reboot_server(0)
+    end
+
+    tests("#change_password_server(0}, 'new_password')").raises(Excon::Errors::InternalServerError) do
+      Fog::Compute[:hp].change_password_server(0, 'new_password')
+    end
+
+  end
+
+end

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

@@ -0,0 +1,78 @@
+Shindo.tests('Fog::Storage[:hp] | container requests', [:hp]) do
+
+  @container_format = [String]
+
+  @containers_format = [{
+    'bytes' => Integer,
+    'count' => Integer,
+    'name'  => String
+  }]
+
+  tests('success') do
+
+    tests("#put_container('fogcontainertests')").succeeds do
+      Fog::Storage[:hp].put_container('fogcontainertests')
+    end
+
+    tests("#get_container('fogcontainertests')").formats(@container_format) do
+      Fog::Storage[:hp].get_container('fogcontainertests').body
+    end
+
+    tests("#get_containers").formats(@containers_format) do
+      Fog::Storage[:hp].get_containers.body
+    end
+
+    tests("#head_container('fogcontainertests')").succeeds do
+      Fog::Storage[:hp].head_container('fogcontainertests')
+    end
+
+    tests("#head_containers").succeeds do
+      Fog::Storage[:hp].head_containers
+    end
+
+    tests("#delete_container('fogcontainertests')").succeeds do
+      Fog::Storage[:hp].delete_container('fogcontainertests')
+    end
+
+    tests("#put_container('fogacltests', {'X-Container-Read' => 'private'})").succeeds do
+      Fog::Storage[:hp].put_container('fogacltests', {'X-Container-Read' => 'private'})
+    end
+    Fog::Storage[:hp].delete_container('fogacltests')
+
+    tests("#put_container('fogacltests', {'X-Container-Read' => 'public-read'})").succeeds do
+      Fog::Storage[:hp].put_container('fogacltests', {'X-Container-Read' => 'public-read'})
+    end
+    Fog::Storage[:hp].delete_container('fogacltests')
+
+    tests("#put_container('fogacltests', {'X-Container-Read' => 'invalid'})").succeeds do
+      Fog::Storage[:hp].put_container('fogacltests', {'X-Container-Read' => 'invalid'})
+    end
+    Fog::Storage[:hp].delete_container('fogacltests')
+
+  end
+
+  tests('failure') do
+
+    tests("#get_container('fognoncontainer')").raises(Fog::Storage::HP::NotFound) do
+      Fog::Storage[:hp].get_container('fognoncontainer')
+    end
+
+    tests("#head_container('fognoncontainer')").raises(Fog::Storage::HP::NotFound) do
+      Fog::Storage[:hp].head_container('fognoncontainer')
+    end
+
+    tests("#delete_container('fognoncontainer')").raises(Fog::Storage::HP::NotFound) do
+      Fog::Storage[:hp].delete_container('fognoncontainer')
+    end
+
+    @container = Fog::Storage[:hp].directories.create(:key => 'fognonempty')
+    @file = @container.files.create(:key => 'foo', :body => 'bar')
+    tests("#delete_container('fognonempty')").raises(Excon::Errors::Conflict) do
+      Fog::Storage[:hp].delete_container('fognonempty')
+    end
+    @file.destroy
+    @container.destroy
+
+  end
+
+end

data/tests/hp/requests/storage/object_tests.rb

@@ -0,0 +1,81 @@
+Shindo.tests('Fog::Storage[:hp] | object requests', [:hp]) do
+
+  @directory = Fog::Storage[:hp].directories.create(:key => 'fogobjecttests')
+  @dir_name = @directory.identity
+
+  tests('success') do
+
+    tests("#put_object('#{@dir_name}', 'fog_object')").succeeds do
+      Fog::Storage[:hp].put_object(@dir_name, 'fog_object', lorem_file)
+    end
+
+    tests("#get_object('#{@dir_name}', 'fog_object')").succeeds do
+      Fog::Storage[:hp].get_object(@dir_name, 'fog_object')
+    end
+
+    tests("#get_object('#{@dir_name}', 'fog_object', &block)").returns(lorem_file.read) do
+      data = ''
+      Fog::Storage[:hp].get_object(@dir_name, 'fog_object') do |chunk, remaining_bytes, total_bytes|
+        data << chunk
+      end
+      data
+    end
+
+    tests("#head_object('#{@dir_name}', 'fog_object')").succeeds do
+      Fog::Storage[:hp].head_object(@dir_name, 'fog_object')
+    end
+
+    # copy a file within the same container
+    tests("#put_object('#{@dir_name}', 'fog_other_object', nil, {'X-Copy-From' => '/#{@dir_name}/fog_object'})" ).succeeds do
+      Fog::Storage[:hp].put_object(@dir_name, 'fog_other_object', nil, {'X-Copy-From' => "/#{@dir_name}/fog_object"})
+    end
+    @directory.files.get('fog_other_object').destroy
+
+    # copy a file from one container to another
+    @another_dir = Fog::Storage[:hp].directories.create(:key => 'fogobjecttests2')
+    tests("#put_object('#{@another_dir.identity}', 'fog_another_object', nil, {'X-Copy-From' => '/#{@dir_name}/fog_object'})" ).succeeds do
+      Fog::Storage[:hp].put_object(@another_dir.identity, 'fog_another_object', nil, {'X-Copy-From' => "/#{@dir_name}/fog_object"})
+    end
+    @another_dir.files.get('fog_another_object').destroy
+    @another_dir.destroy
+
+    tests("#delete_object('#{@dir_name}', 'fog_object')").succeeds do
+      Fog::Storage[:hp].delete_object(@dir_name, 'fog_object')
+    end
+  end
+
+  tests('failure') do
+
+    tests("#put_object('fognoncontainer', 'fog_object')").raises(Fog::Storage::HP::NotFound) do
+      Fog::Storage[:hp].put_object('fognoncontainer', 'fog_object', lorem_file)
+    end
+
+    tests("#get_object('#{@dir_name}', 'fog_non_object')").raises(Fog::Storage::HP::NotFound) do
+      Fog::Storage[:hp].get_object(@dir_name, 'fog_non_object')
+    end
+
+    tests("#get_object('fognoncontainer', 'fog_non_object')").raises(Fog::Storage::HP::NotFound) do
+      Fog::Storage[:hp].get_object('fognoncontainer', 'fog_non_object')
+    end
+
+    tests("#head_object('#{@dir_name}', 'fog_non_object')").raises(Fog::Storage::HP::NotFound) do
+      Fog::Storage[:hp].head_object(@dir_name, 'fog_non_object')
+    end
+
+    tests("#head_object('fognoncontainer', 'fog_non_object')").raises(Fog::Storage::HP::NotFound) do
+      Fog::Storage[:hp].head_object('fognoncontainer', 'fog_non_object')
+    end
+
+    tests("#delete_object('#{@dir_name}', 'fog_non_object')").raises(Fog::Storage::HP::NotFound) do
+      Fog::Storage[:hp].delete_object(@dir_name, 'fog_non_object')
+    end
+
+    tests("#delete_object('fognoncontainer', 'fog_non_object')").raises(Fog::Storage::HP::NotFound) do
+      Fog::Storage[:hp].delete_object('fognoncontainer', 'fog_non_object')
+    end
+
+  end
+
+  @directory.destroy
+
+end

data/tests/libvirt/compute_tests.rb

@@ -0,0 +1,17 @@
+Shindo.tests('Fog::Compute[:libvirt]', ['libvirt']) do
+
+  compute = Fog::Compute[:libvirt]
+
+  tests("Compute collections") do
+    %w{ servers interfaces networks nics nodes pools volumes}.each do |collection|
+      test("it should respond to #{collection}") { compute.respond_to? collection }
+    end
+  end
+
+  tests("Compute requests") do
+    %w{ create_domain create_volume define_domain define_pool destroy_interface destroy_network get_node_info list_domains
+        list_interfaces list_networks list_pools list_pool_volumes list_volumes pool_action vm_action volume_action }.each do |request|
+      test("it should respond to #{request}") { compute.respond_to? request }
+    end
+  end
+end

data/tests/libvirt/models/compute/interface_tests.rb

@@ -0,0 +1,27 @@
+Shindo.tests('Fog::Compute[:libvirt] | interface model', ['libvirt']) do
+
+  interfaces = Fog::Compute[:libvirt].interfaces
+  interface = interfaces.last
+
+  tests('The interface model should') do
+    tests('have the action') do
+      test('reload') { interface.respond_to? 'reload' }
+    end
+    tests('have attributes') do
+      model_attribute_hash = interface.attributes
+      attributes = [ :name, :mac, :active]
+      tests("The interface model should respond to") do
+        attributes.each do |attribute|
+          test("#{attribute}") { interface.respond_to? attribute }
+        end
+      end
+      tests("The attributes hash should have key") do
+        attributes.each do |attribute|
+          test("#{attribute}") { model_attribute_hash.has_key? attribute }
+        end
+      end
+    end
+    test('be a kind of Fog::Compute::Libvirt::Interface') { interface.kind_of? Fog::Compute::Libvirt::Interface }
+  end
+
+end

data/tests/libvirt/models/compute/interfaces_tests.rb

@@ -0,0 +1,14 @@
+Shindo.tests('Fog::Compute[:libvirt] | interfaces collection', ['libvirt']) do
+
+  interfaces = Fog::Compute[:libvirt].interfaces
+
+  tests('The interfaces collection') do
+    test('should not be empty') { not interfaces.empty? }
+    test('should be a kind of Fog::Compute::Libvirt::Interfaces') { interfaces.kind_of? Fog::Compute::Libvirt::Interfaces }
+    tests('should be able to reload itself').succeeds { interfaces.reload }
+    tests('should be able to get a model') do
+      tests('by instance name').succeeds { interfaces.get interfaces.first.name }
+    end
+  end
+
+end