fog-rackspace 0.1.0

data/tests/rackspace/requests/compute/resize_tests.rb

@@ -0,0 +1,35 @@
+Shindo.tests('Fog::Compute[:rackspace] | resize request', ['rackspace']) do
+
+    @service = Fog::Compute.new(:provider => :rackspace, :version => :v1)
+
+    @confirm_server =  @service.servers.create(:flavor_id => 1, :image_id => 19)
+
+    @revert_server =  @service.servers.create(:flavor_id => 1, :image_id => 19)
+
+    @confirm_server.wait_for { ready? }
+    tests("#resize_server(#{@confirm_server.id}, 2) # to confirm").succeeds do
+       @service.resize_server(@confirm_server.id, 2)
+    end
+
+    @revert_server.wait_for { ready? }
+    tests("#resize_server(#{@revert_server.id}, 2) # to revert").succeeds do
+       @service.resize_server(@revert_server.id, 2)
+    end
+
+    @confirm_server.wait_for { state == 'VERIFY_RESIZE' }
+    tests("#confirm_resized_server(#{@confirm_server.id})").succeeds do
+       @service.confirm_resized_server(@confirm_server.id)
+    end
+
+    @revert_server.wait_for { state == 'VERIFY_RESIZE' }
+    tests("#revert_resized_server(#{@revert_server.id})").succeeds do
+       @service.revert_resized_server(@revert_server.id)
+    end
+
+    @confirm_server.wait_for { ready? }
+    @confirm_server.destroy
+
+    @revert_server.wait_for { ready? }
+    @revert_server.destroy
+
+end

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

@@ -0,0 +1,94 @@
+Shindo.tests('Fog::Compute[:rackspace] | server requests', ['rackspace']) do
+
+  @server_format = {
+    'addresses' => {
+      'private' => [String],
+      'public'  => [String]
+    },
+    'flavorId'  => Integer,
+    'hostId'    => String,
+    'id'        => Integer,
+    'imageId'   => Integer,
+    'metadata'  => {},
+    'name'      => String,
+    'progress'  => Integer,
+    'status'    => String
+  }
+
+  @service = Fog::Compute.new(:provider => :rackspace, :version => :v1)
+
+  tests('success') do
+
+    @server_id = nil
+
+    tests('#create_server(1, 19)').formats(@server_format.merge('adminPass' => String)) do
+      # 1 => 256MB, 19 => Gentoo
+      data =  @service.create_server(1, 19).body['server']
+      @server_id = data['id']
+      data
+    end
+
+     @service.servers.get(@server_id).wait_for { ready? }
+
+    tests("#get_server_details(#{@server_id})").formats(@server_format) do
+       @service.get_server_details(@server_id).body['server']
+    end
+
+    tests('#list_servers').formats({'servers' => [Rackspace::Compute::Formats::SUMMARY]}) do
+       @service.list_servers.body
+    end
+
+    tests('#list_servers_detail').formats({'servers' => [@server_format]}) do
+       @service.list_servers_detail.body
+    end
+
+     @service.servers.get(@server_id).wait_for { ready? }
+
+    tests("#update_server(#{@server_id}, :name => 'fogupdatedserver', :adminPass => 'fogupdatedserver')").succeeds do
+       @service.update_server(@server_id, :name => 'fogupdatedserver', :adminPass => 'fogupdatedserver')
+    end
+
+     @service.servers.get(@server_id).wait_for { ready? }
+
+    tests("#reboot_server(#{@server_id}, 'HARD')").succeeds do
+      pending if Fog.mocking?
+       @service.reboot_server(@server_id, 'HARD')
+    end
+
+     @service.servers.get(@server_id).wait_for { ready? }
+
+    tests("#reboot_server(#{@server_id}, 'SOFT')").succeeds do
+      pending if Fog.mocking?
+       @service.reboot_server(@server_id, 'SOFT')
+    end
+
+     @service.servers.get(@server_id).wait_for { ready? }
+
+    tests("#delete_server(#{@server_id})").succeeds do
+       @service.delete_server(@server_id)
+    end
+
+  end
+
+  tests('failure') do
+
+    tests('#delete_server(0)').raises(Fog::Compute::Rackspace::NotFound) do
+       @service.delete_server(0)
+    end
+
+    tests('#get_server_details(0)').raises(Fog::Compute::Rackspace::NotFound) do
+       @service.get_server_details(0)
+    end
+
+    tests("#update_server(0, :name => 'fogupdatedserver', :adminPass => 'fogupdatedserver')").raises(Fog::Compute::Rackspace::NotFound) do
+       @service.update_server(0, :name => 'fogupdatedserver', :adminPass => 'fogupdatedserver')
+    end
+
+    tests('#reboot_server(0)').raises(Fog::Compute::Rackspace::NotFound) do
+      pending if Fog.mocking?
+       @service.reboot_server(0)
+    end
+
+  end
+
+end

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

@@ -0,0 +1,45 @@
+Shindo.tests('Fog::Compute::RackspaceV2 | address requests', ['rackspace']) do
+
+  @service = Fog::Compute.new(:provider => 'Rackspace', :version => 'V2')
+  image_id  = rackspace_test_image_id(@service)
+  flavor_id = rackspace_test_flavor_id(@service)
+
+  tests('success') do
+    unless Fog.mocking?
+      @server = @service.servers.create(:flavor_id => flavor_id, :image_id => image_id, :name => "address-tests-#{Time.now.to_i}")
+      @server.wait_for { ready? }
+      @server_id = @server.id
+    else
+      @server_id = 42
+    end
+
+    address_format =  { "addresses"=> {
+      "private" => [{"addr" => String, "version" => Integer}],
+      "public" => [{"addr" => String, "version" => Integer }, {"addr"=> String, "version" => Integer}]}
+    }
+
+    begin
+      tests("#list_addresses(#{@server_id})").formats(address_format) do
+         @service.list_addresses(@server_id).body
+      end
+
+      tests("#list_addresses_by_network(#{@server_id}, 'private')").formats(address_format["addresses"].reject {|k,v| k != "private"}) do
+        @service.list_addresses_by_network(@server_id, "private").body
+      end
+    ensure
+      @server.destroy if @server
+    end
+
+  end
+
+  tests('failure') do
+    tests('#list_addresses(0)').raises(Fog::Compute::RackspaceV2::NotFound) do
+       @service.list_addresses(0)
+    end
+    tests("#list_addresses_by_network(0, 'private')").raises(Fog::Compute::RackspaceV2::NotFound) do
+      @service.list_addresses_by_network(0, 'private')
+    end
+
+  end
+
+end

data/tests/rackspace/requests/compute_v2/attachment_tests.rb

@@ -0,0 +1,66 @@
+Shindo.tests('Fog::Compute::RackspaceV2 | attachment_tests', ['rackspace']) do
+  compute_service       = Fog::Compute::RackspaceV2.new
+  block_storage_service = Fog::Rackspace::BlockStorage.new
+  image_id              = rackspace_test_image_id(compute_service)
+  flavor_id             = rackspace_test_flavor_id(compute_service)
+
+  attachment_format = {
+    'volumeAttachment' => {
+      'id' => String,
+      'serverId' => String,
+      'volumeId' => String,
+      'device' => Fog::Nullable::String
+    }
+  }
+
+  list_attachments_format = {
+    'volumeAttachments' => [attachment_format['volumeAttachment']]
+  }
+
+  name = 'fog' + Time.now.to_i.to_s
+  image_id = image_id
+  flavor_id = flavor_id
+  server_id = compute_service.create_server(name, image_id, flavor_id, 1, 1).body['server']['id']
+  volume_id = block_storage_service.create_volume(100).body['volume']['id']
+  device_id = '/dev/xvde'
+
+  tests('success') do
+    wait_for_request("Waiting for server to become ready") do
+      compute_service.get_server(server_id).body['server']['status'] == 'ACTIVE'
+    end
+
+    wait_for_request("Waiting for Volume to be ready") do
+      block_storage_service.get_volume(volume_id).body['volume']['status'] == 'available'
+    end
+
+    tests("#attach_volume(#{server_id}, #{volume_id}, #{device_id})").formats(attachment_format) do
+      compute_service.attach_volume(server_id, volume_id, device_id).body
+    end
+
+    tests("#list_attachments(#{server_id})").formats(list_attachments_format) do
+      compute_service.list_attachments(server_id).body
+    end
+
+    wait_for_request("Waiting for Volume to be ready") do
+      block_storage_service.get_volume(volume_id).body['volume']['status'] == 'in-use'
+    end
+
+    tests("#get_attachment(#{server_id}, #{volume_id})").formats(attachment_format) do
+      compute_service.get_attachment(server_id, volume_id).body
+    end
+
+    tests("#delete_attachment(#{server_id}, #{volume_id})").succeeds do
+      compute_service.delete_attachment(server_id, volume_id)
+    end
+  end
+
+  tests('failure') do
+    tests("#attach_volume('', #{volume_id}, #{device_id})").raises(Fog::Compute::RackspaceV2::NotFound) do
+      compute_service.attach_volume('', volume_id, device_id)
+    end
+
+    tests("#delete_attachment('', #{volume_id})").raises(Fog::Compute::RackspaceV2::NotFound) do
+      compute_service.delete_attachment('', volume_id)
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+Shindo.tests('Fog::Compute::RackspaceV2 | flavor_tests', ['rackspace']) do
+
+  flavor_format = {
+    'id' => String,
+    'name' => String,
+    'ram' => Fog::Nullable::Integer,
+    'disk' => Fog::Nullable::Integer,
+    'vcpus' => Fog::Nullable::Integer,
+    'links' => [{
+      'rel' => String,
+      'href' => String
+    }]
+  }
+
+  list_flavor_format = {
+    'flavors' => [flavor_format]
+  }
+
+  get_flavor_format = {
+    'flavor' => flavor_format.merge({
+      'OS-FLV-EXT-DATA:ephemeral' => Integer,
+      'rxtx_factor' => Float,
+      'swap' => Integer
+    })
+  }
+
+  service = Fog::Compute.new(:provider => 'Rackspace', :version => 'V2')
+  flavor_id = nil
+
+  tests('success') do
+    tests('#list_flavors').formats(list_flavor_format) do
+      body = service.list_flavors.body
+      flavor_id = body['flavors'][0]['id']
+      body
+    end
+
+    tests('#list_flavors_detail').formats(list_flavor_format) do
+      body = service.list_flavors_detail.body
+      flavor_id = body['flavors'][0]['id']
+      body
+    end
+
+    tests('#get_flavor').formats(get_flavor_format) do
+      service.get_flavor(flavor_id).body
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+Shindo.tests('Fog::Compute::RackspaceV2 | image_tests', ['rackspace']) do
+  service   = Fog::Compute.new(:provider => 'Rackspace', :version => 'V2')
+
+  image_format = {
+    'id' => String,
+    'name' => String,
+    'created' => Fog::Nullable::String,
+    'updated' => Fog::Nullable::String,
+    'status' => Fog::Nullable::String,
+    'user_id' => Fog::Nullable::String,
+    'tenant_id' => Fog::Nullable::String,
+    'progress' => Fog::Nullable::Integer,
+    'minDisk' => Fog::Nullable::Integer,
+    'minRam' => Fog::Nullable::Integer,
+    'metadata' => Fog::Nullable::Hash,
+    'OS-DCF:diskConfig' => Fog::Nullable::String,
+    'links' => [{
+      'rel' => String,
+      'href' => String,
+      'type' => Fog::Nullable::String
+    }]
+  }
+
+  list_image_format = {
+    'images' => [image_format]
+  }
+
+  get_image_format = {
+    'image' => image_format
+  }
+
+  begin
+    test_time = Time.now.to_i.to_s
+    @server = service.servers.create(:name => "fog-image-tests_#{test_time}",
+     :flavor_id => rackspace_test_flavor_id(service),
+     :image_id => rackspace_test_image_id(service))
+    @server.wait_for { ready? }
+    @image_id = nil
+
+    tests('success') do
+
+      tests("#create_image(#{@server.id}, 'fog-test-image')").succeeds do
+        response = service.create_image(@server.id, "fog-test-image_#{test_time}")
+        @image_id = response.headers["Location"].match(/\/([^\/]+$)/)[1]
+      end
+
+      tests('#list_images').formats(list_image_format) do
+        service.list_images.body
+      end
+
+      tests('#list_images_detail').formats(list_image_format) do
+        service.list_images_detail.body
+      end
+
+      tests('#get_image').formats(get_image_format, false) do
+        service.get_image(@image_id).body
+      end
+
+      tests('#delete_image').succeeds do
+        service.delete_image(@image_id)
+      end
+    end
+
+    tests('failure') do
+      tests('#delete_image').raises(Fog::Compute::RackspaceV2::NotFound) do
+        service.delete_image(Fog::Rackspace::MockData::NOT_FOUND_ID)
+      end
+
+      tests('#get_image').raises(Fog::Compute::RackspaceV2::NotFound) do
+        service.get_image(Fog::Rackspace::MockData::NOT_FOUND_ID)
+      end
+    end
+  ensure
+    @image.destroy if @image
+    @server.destroy if @server
+  end
+end

data/tests/rackspace/requests/compute_v2/keypair_tests.rb

@@ -0,0 +1,55 @@
+Shindo.tests('Fog::Compute::RackspaceV2 | keypair_tests', ['rackspace']) do
+
+  keypair_format = {
+    'name'        => String,
+    'public_key'  => String,
+    'fingerprint' => String,
+  }
+
+  create_keypair_format = {
+    'keypair' => keypair_format.merge({
+        'user_id'     => String,
+        'private_key' => String
+    })
+  }
+
+  list_keypair_format = {
+    'keypairs' => [ 'keypair' => keypair_format ]
+  }
+
+  get_keypair_format = {
+    'keypair' => keypair_format
+  }
+
+  service = Fog::Compute.new(:provider => 'Rackspace', :version => 'V2')
+  keypair_name = Fog::Mock.random_letters(32)
+
+  tests('success') do
+    tests('#create_keypair').formats(create_keypair_format) do
+      service.create_keypair(keypair_name).body
+    end
+
+    tests('#list_keypairs').formats(list_keypair_format) do
+      service.list_keypairs.body
+    end
+
+    tests('#get_keypair').formats(get_keypair_format) do
+      service.get_keypair(keypair_name).body
+    end
+
+    tests('#delete_keypair') do
+      service.delete_keypair(keypair_name).body
+    end
+  end
+
+  unknown_keypair_name = Fog::Mock.random_letters(32)
+  tests('failure') do
+    tests('#get_unknown_keypair').raises(Fog::Compute::RackspaceV2::NotFound) do
+      service.get_keypair(unknown_keypair_name).body
+    end
+
+    tests('#delete_unknown_keypair').raises(Fog::Compute::RackspaceV2::NotFound) do
+      service.delete_keypair(unknown_keypair_name).body
+    end
+  end
+end

data/tests/rackspace/requests/compute_v2/metadata_tests.rb

@@ -0,0 +1,104 @@
+Shindo.tests('Fog::Compute::RackspaceV2 | metadata_tests', ['rackspace']) do
+
+  @service = Fog::Compute.new(:provider => 'Rackspace', :version => 'V2')
+  image_id  = rackspace_test_image_id(@service)
+  flavor_id = rackspace_test_flavor_id(@service)
+
+  tests('success') do
+    begin
+      metadata = {"tag" => "database"}
+
+      unless Fog.mocking?
+        name = "fog-server-metadata-#{Time.now.to_i}"
+        @server = @service.servers.create(:name => name,
+                                          :flavor_id => flavor_id,
+                                          :image_id => image_id,
+                                          :metadata => metadata)
+        @server.wait_for { ready? }
+
+
+        @server_id = @server.id
+        @image  = @server.create_image(name, :metadata => metadata)
+        @image_id = @image.id
+      else
+        @image_id = 1
+        @server_id = 1
+      end
+
+        tests("servers") do
+          tests('list_metadata').returns("metadata" => metadata) do
+            @service.list_metadata("servers", @server_id).body
+          end
+          tests('set_metadata').returns("metadata" => {"environment" => "dev"}) do
+            @service.set_metadata("servers", @server_id, {"environment" => "dev"}).body
+          end
+          tests('update_metadata').returns("metadata" => {"environment" => "dev", "tag" => "database"}) do
+            @service.update_metadata("servers", @server_id, {"environment" => "dev", "tag" => "database"}).body
+          end
+          tests('get_metadata_item').returns("meta" => {"environment" => "dev"}) do
+            @service.get_metadata_item("servers", @server_id, "environment").body
+          end
+          tests('set_metadata_item').returns("meta" => {"environment" => "test"}) do
+            @service.set_metadata_item("servers", @server_id, "environment", "test").body
+          end
+          tests('delete_metadata_item').succeeds do
+            @service.delete_metadata_item("servers", @server_id, "environment")
+          end
+        end
+
+        tests("images") do
+          @image.wait_for { ready? } unless Fog.mocking?
+
+          tests('list_metadata').returns(metadata) do
+            h = @service.list_metadata("images", @image_id).body
+            h["metadata"].reject {|k,v| k.downcase != "tag"} #only look at the metadata we created
+          end
+          tests('set_metadata').returns({"environment" => "dev"}) do
+            h = @service.set_metadata("images", @image_id, {"environment" => "dev"}).body
+            h["metadata"].reject {|k,v| k.downcase != "environment"} #only look at the metadata we created
+          end
+          tests('update_metadata').returns({"environment" => "dev", "tag" => "database"}) do
+            h = @service.update_metadata("images", @image_id, {"environment" => "dev", "tag" => "database"}).body
+            h["metadata"].reject {|k,v| !['environment', 'tag'].include?(k.downcase)} #only look at the metadata we created
+          end
+          tests('get_metadata_item').returns("meta" => {"environment" => "dev"}) do
+            @service.get_metadata_item("images", @image_id, "environment").body
+          end
+          tests('set_metadata_item').returns("meta" => {"environment" => "test"}) do
+            @service.set_metadata_item("images", @image_id, "environment", "test").body
+          end
+          tests('delete_metadata_item').succeeds do
+            @service.delete_metadata_item("images", @image_id, "environment")
+          end
+        end
+    ensure
+      @image.destroy if @image
+      @server.destroy if @server
+    end
+  end
+
+  tests('failure') do
+    ['server', 'image'].each do |collection|
+      tests(collection) do
+        tests('list_metadata').raises(Fog::Compute::RackspaceV2::NotFound)  do
+          @service.list_metadata(collection, 0)
+        end
+        tests('set_server_metadata').raises(Fog::Compute::RackspaceV2::NotFound)  do
+          @service.set_metadata(collection, 0, {"environment" => "dev"})
+        end
+        tests('update_server_metadata').raises(Fog::Compute::RackspaceV2::NotFound)  do
+          @service.update_metadata(collection, 0, {"environment" => "dev", "tag" => "database"})
+        end
+        tests('get_server_metadata_item').raises(Fog::Compute::RackspaceV2::NotFound)  do
+          @service.get_metadata_item(collection, 0, "environment")
+        end
+        tests('set_server_metadata_item').raises(Fog::Compute::RackspaceV2::NotFound) do
+          @service.set_metadata_item(collection, 0, "environment", "test")
+        end
+        tests('delete_server_metadata_item').raises(Fog::Compute::RackspaceV2::NotFound)  do
+          @service.delete_metadata_item(collection, 0, "environment")
+        end
+      end
+    end
+  end
+end