rackspace-fog 1.4.2

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/ibm/models/compute/image_tests.rb

@@ -0,0 +1,25 @@
+Shindo.tests('Fog::Compute[:ibm] | image', ['ibm']) do
+
+  @image_id = '20010001'
+  @clone_name = 'fog-test-clone-image-' + Time.now.to_i.to_s(32)
+
+  tests('success') do
+
+    tests("Fog::Compute[:ibm].images.get('#{@image_id}')") do
+      @image = Fog::Compute[:ibm].images.get(@image_id)
+      returns(@image_id) { @image.id }
+    end
+
+    tests("Fog::Compute::Image#clone") do
+      clone_id = @image.clone(@clone_name, @clone_name)
+      @clone = Fog::Compute[:ibm].images.get(clone_id)
+      returns(@clone_name) { @clone.name }
+    end
+
+    tests("Fog::Compute::Image#destroy") do
+      returns(true) { @clone.destroy }
+    end
+
+  end
+
+end

data/tests/ibm/models/compute/key_tests.rb

@@ -0,0 +1,23 @@
+Shindo.tests('Fog::Compute[:ibm] | key', ['ibm']) do
+
+  tests('success') do
+
+    @key_name = 'fog-test-key-' + Time.now.to_i.to_s(32)
+    @key      = nil
+
+    tests("Fog::Compute::IBM::Key.create(:name => '#{@key_name}')") do
+      @key = Fog::Compute[:ibm].keys.create(:name => @key_name)
+      returns(@key_name) { @key.name }
+    end
+
+    tests("Fog::Compute::IBM::Key#instances") do
+      returns([]) { @key.instances }
+    end
+
+    tests('Fog::Compute::IBM::Key#destroy') do
+      returns(true) { @key.destroy }
+    end
+
+  end
+
+end

data/tests/ibm/models/compute/keys_tests.rb

@@ -0,0 +1,35 @@
+Shindo.tests('Fog::Compute[:ibm] | keys', ['ibm']) do
+
+  tests('success') do
+
+    @key_name = 'fog-test-key' + Time.now.to_i.to_s(32)
+    @key      = nil
+
+    tests("Fog::Compute[:ibm].keys.create(:name => '#{@key_name}')") do
+      @key = Fog::Compute[:ibm].keys.create(:name => @key_name)
+      returns(@key_name) { @key.name }
+    end
+
+    tests('Fog::Compute[:ibm].keys') do
+      returns(true) { Fog::Compute[:ibm].keys.length > 0 }
+    end
+
+    tests("Fog::Compute[:ibm].keys.default = '#{@key_name}'") do
+      returns(@key_name) { Fog::Compute[:ibm].keys.default = @key_name }
+    end
+
+    tests("Fog::Compute[:ibm].keys.default") do
+      @key = Fog::Compute[:ibm].keys.get(@key_name)
+      returns(@key.name) { Fog::Compute[:ibm].keys.default.name }
+    end
+
+    tests("Fog::Compute[:ibm].keys.get('#{@key_name}')") do
+      key = Fog::Compute[:ibm].keys.get(@key_name)
+      returns(@key_name) { key.name }
+    end
+
+    @key.destroy
+
+  end
+
+end

data/tests/ibm/models/compute/locations_tests.rb

@@ -0,0 +1,18 @@
+Shindo.tests('Fog::Compute[:ibm] | locations', ['ibm']) do
+
+  tests('success') do
+
+    @location_id = '41'
+
+    tests('Fog::Compute[:ibm].locations') do
+      returns(true) { Fog::Compute[:ibm].locations.length > 0 }
+    end
+
+    tests('Fog::Compute[:ibm].locations.get("#{@location_id}")') do
+      @location = Fog::Compute[:ibm].locations.get(@location_id)
+      returns(@location_id) { @location.id }
+    end
+
+  end
+
+end

data/tests/ibm/models/compute/server_tests.rb

@@ -0,0 +1,88 @@
+Shindo.tests('Fog::Compute[:ibm] | server', ['ibm']) do
+
+  tests('success') do
+    # TODO: Fix this for non-mock tests
+    @server         = nil
+    @instance_id    = nil
+
+    @name           = "fog-test-instance-" + Time.now.to_i.to_s(32)
+    @image_id       = "20010001"
+    @instance_type  = "BRZ32.1/2048/60*175"
+    @location_id    = "41"
+
+    @key_name       = "fog-test-key-" + Time.now.to_i.to_s(32)
+    @key            = Fog::Compute[:ibm].keys.create(:name => @key_name)
+
+    tests('Fog::Compute::IBM::Server.new') do
+      @server = Fog::Compute[:ibm].servers.new(
+        :name           => @name,
+        :image_id       => @image_id,
+        :instance_type  => @instance_type,
+        :location_id    => @location,
+        :key_name       => @key_name
+      )
+      returns(@name) { @server.name }
+    end
+
+    tests('Fog::Compute::IBM::Server#save') do
+      returns(true)   { @server.save }
+      returns(String) { @server.id.class }
+      @instance_id = @server.id
+    end
+
+    tests('Fog::Compute::IBM::Server#wait_for { ready? }') do
+      @server = Fog::Compute[:ibm].servers.get(@instance_id)
+      @server.wait_for(Fog::IBM.timeout) { ready? }
+    end
+
+    tests('Fog::Compute::IBM::Server#id') do
+      returns(@instance_id) { @server.id }
+    end
+
+    tests('Fog::Compute::IBM::Server#ready?') do
+      returns(true) { @server.ready? }
+    end
+
+    tests('Fog::Compute::IBM::Server#state') do
+      returns("Active") { @server.state }
+    end
+
+    # TODO: make this work
+    # tests('Fog::Compute::IBM::Server#reboot') do
+    #   returns(true) { @server.reboot }
+    # end
+
+    tests('Fog::Compute::IBM::Server#rename("name")') do
+      name = @server.name + "-rename"
+      returns(true) { @server.rename(name) }
+      returns(name) { @server.name }
+    end
+
+    tests('Fog::Compute::IBM::Server#image') do
+      returns(@image_id) { @server.image.id }
+    end
+
+    tests('Fog::Compute::IBM::Server#to_image') do
+      body = @server.to_image(:name => @server.name)
+      returns(@server.name) { body['name'] }
+      image = Fog::Compute[:ibm].images.get(body['id'])
+      image.wait_for(Fog::IBM.timeout) { ready? || state == 'New' }
+      unless image.state == 'Capturing'
+        returns(true) { Fog::Compute[:ibm].delete_image(image.id).body['success'] }
+      end
+    end
+
+    tests('Fog::Compute::IBM::Server#expire_at') do
+      returns(true) { @server.expire_at(Time.now + 60) }
+    end
+
+    tests('Fog::Compute::IBM::Server#destroy') do
+      returns(true) { @server.destroy }
+    end
+
+    @key.wait_for(Fog::IBM.timeout) { instance_ids.empty? }
+    @key.destroy
+
+  end
+
+end