fog-maestrodev 1.8.0.20130114204828 → 1.14.0.20130806165225

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')
+  
+  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 => 2,
+                                          :image_id => '3afe97b2-26dc-49c5-a2cc-a2fc8d80c001',
+                                          :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
+
+

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

@@ -0,0 +1,49 @@
+Shindo.tests('Fog::Compute::RackspaceV2 | network_tests', ['rackspace']) do
+  service   = Fog::Compute.new(:provider => 'Rackspace', :version => 'V2')
+
+  network_format = {
+    'id' => String,
+    'label' => String,
+    'cidr' => Fog::Nullable::String
+  }
+
+  get_network_format = {
+    'network' => network_format
+  }
+
+  list_networks_format = {
+    'networks' => [network_format]
+  }
+
+  tests('success') do
+    network_id = nil
+
+    tests('#create_network').formats(get_network_format) do
+      service.create_network("fog_#{Time.now.to_i.to_s}", '192.168.0.0/24').body.tap do |r|
+        network_id = r['network']['id']
+      end
+    end
+
+    tests('#list_networks').formats(list_networks_format) do
+      service.list_networks.body
+    end
+
+    tests('#get_network').formats(get_network_format) do
+      service.get_network(network_id).body
+    end
+
+    tests('#delete_network').succeeds do
+      service.delete_network(network_id)
+    end
+  end
+
+  test('failure') do
+    tests('#get_network').raises(Fog::Compute::RackspaceV2::NotFound) do
+      service.get_network(0)
+    end
+
+    tests('#delete_network').raises(Fog::Compute::RackspaceV2::NotFound) do
+      service.delete_network(0)
+    end
+  end
+end

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

@@ -1,13 +1,15 @@
 Shindo.tests('Fog::Compute::RackspaceV2 | server_tests', ['rackspace']) do
+  service   = Fog::Compute.new(:provider => 'Rackspace', :version => 'V2')
+  image_id  = Fog.credentials[:rackspace_image_id]
+  image_id ||= Fog.mocking? ? service.images.first.id : service.images.find {|image| image.name =~ /Ubuntu/}.id # use the first Ubuntu image
+  flavor_id = Fog.credentials[:rackspace_flavor_id] || service.flavors.first.id
 
-  pending if Fog.mocking?
-
-  LINK_FORMAT = {
+  link_format = {
     'href' => String,
     'rel' => String
   }
 
-  SERVER_FORMAT = {
+  server_format = {
     'id' => String,
     'name' => String,
     'hostId' => Fog::Nullable::String,
@@ -17,16 +19,16 @@ Shindo.tests('Fog::Compute::RackspaceV2 | server_tests', ['rackspace']) do
     'progress' => Fog::Nullable::Integer,
     'user_id' => Fog::Nullable::String,
     'tenant_id' => Fog::Nullable::String,
-    'links' => [LINK_FORMAT],
+    'links' => [link_format],
     'metadata' => Fog::Nullable::Hash
   }
 
-  LIST_SERVERS_FORMAT = {
-    'servers' => [SERVER_FORMAT]
+  list_servers_format = {
+    'servers' => [server_format]
   }
 
-  GET_SERVER_FORMAT = {
-    'server' => SERVER_FORMAT.merge({
+  get_server_format = {
+    'server' => server_format.merge({
       'accessIPv4' => String,
       'accessIPv6' => String,
       'OS-DCF:diskConfig' => String,
@@ -34,114 +36,109 @@ Shindo.tests('Fog::Compute::RackspaceV2 | server_tests', ['rackspace']) do
       'addresses' => Fog::Nullable::Hash,
       'flavor' => {
         'id' => String,
-        'links' => [LINK_FORMAT]
+        'links' => [link_format]
       },
       'image' => {
         'id' => String,
-        'links' => [LINK_FORMAT]
+        'links' => [link_format]
       }
     })
   }
 
-  CREATE_SERVER_FORMAT = {
+  create_server_format = {
     'server' => {
       'id' => String,
       'adminPass' => String,
-      'links' => [LINK_FORMAT],
+      'links' => [link_format],
       'OS-DCF:diskConfig' => String
     }
   }
 
-  service = Fog::Compute.new(:provider => 'Rackspace', :version => 'V2')
+  rescue_server_format = {
+    'adminPass' => Fog::Nullable::String
+  }
 
   tests('success') do
 
     server_id = nil
-    server_name = 'fog' + Time.now.to_i.to_s
-    image_id = '3afe97b2-26dc-49c5-a2cc-a2fc8d80c001' # Ubuntu 11.10
-    flavor_id = '2' # 512 MB
+    server_name = "fog#{Time.now.to_i.to_s}"
+    image_id = image_id
+    flavor_id = flavor_id
 
-    tests("#create_server(#{server_name}, #{image_id}, #{flavor_id}, 1, 1)").formats(CREATE_SERVER_FORMAT) do
+    tests("#create_server(#{server_name}, #{image_id}, #{flavor_id}, 1, 1)").formats(create_server_format) do
       body = service.create_server(server_name, image_id, flavor_id, 1, 1).body
       server_id = body['server']['id']
       body
     end
-
-    tests('#list_servers').formats(LIST_SERVERS_FORMAT) do
+    wait_for_server_state(service, server_id, 'ACTIVE', 'ERROR')
+    
+    tests('#list_servers').formats(list_servers_format, false) do
       service.list_servers.body
     end
 
-    tests('#get_server').formats(GET_SERVER_FORMAT) do
+    tests('#get_server').formats(get_server_format, false) do
       service.get_server(server_id).body
     end
 
-    until service.get_server(server_id).body['server']['status'] == 'ACTIVE'
-      sleep 10
-    end
-
-    tests("#update_server(#{server_id}, #{server_name}_update)").formats(GET_SERVER_FORMAT) do
+    tests("#update_server(#{server_id}, #{server_name}_update) LEGACY").formats(get_server_format) do
       service.update_server(server_id, "#{server_name}_update").body
     end
+    
+    tests("#update_server(#{server_id}, { 'name' => #{server_name}_update)} ").formats(get_server_format) do
+      service.update_server(server_id, 'name' => "#{server_name}_update").body
+    end    
 
     tests('#change_server_password').succeeds do
       service.change_server_password(server_id, 'some_server_password')
     end
-
-    sleep 60
+    wait_for_server_state(service, server_id, 'ACTIVE', 'ERROR')
 
     tests('#reboot_server').succeeds do
       service.reboot_server(server_id, 'SOFT')
     end
-
-    until service.get_server(server_id).body['server']['status'] == 'ACTIVE'
-      sleep 10
-    end
+    wait_for_server_state(service, server_id, 'ACTIVE')
 
     tests('#rebuild_server').succeeds do
-      rebuild_image_id = "5cebb13a-f783-4f8c-8058-c4182c724ccd" # Ubuntu 12.04
+      rebuild_image_id = image_id
       service.rebuild_server(server_id, rebuild_image_id)
     end
-
-    until service.get_server(server_id).body['server']['status'] == 'ACTIVE'
-      sleep 10
-    end
-
+    wait_for_server_state(service, server_id, 'ACTIVE', 'ERROR')
+    sleep 120 unless Fog.mocking?
+    
     tests('#resize_server').succeeds do
-      resize_flavor_id = 3 # 1GB
+      resize_flavor_id = flavor_id
       service.resize_server(server_id, resize_flavor_id)
     end
-
-    until service.get_server(server_id).body['server']['status'] == 'VERIFY_RESIZE'
-      sleep 10
-    end
-
-    tests('#confirm_resize_server').succeeds do
+    wait_for_server_state(service, server_id, 'VERIFY_RESIZE', 'ACTIVE')
+    
+   tests('#confirm_resize_server').succeeds do
       service.confirm_resize_server(server_id)
     end
-
-    until service.get_server(server_id).body['server']['status'] == 'ACTIVE'
-      sleep 10
-    end
+    wait_for_server_state(service, server_id, 'ACTIVE', 'ERROR')
 
     tests('#resize_server').succeeds do
-      resize_flavor_id = 2 # 1GB
+      resize_flavor_id = flavor_id
       service.resize_server(server_id, resize_flavor_id)
     end
-
-    until service.get_server(server_id).body['server']['status'] == 'VERIFY_RESIZE'
-      sleep 10
-    end
+    wait_for_server_state(service, server_id, 'VERIFY_RESIZE', 'ACTIVE')
 
     tests('#revert_resize_server').succeeds do
       service.revert_resize_server(server_id)
     end
+    wait_for_server_state(service, server_id, 'ACTIVE', 'ERROR')
 
-    until service.get_server(server_id).body['server']['status'] == 'ACTIVE'
-      sleep 10
+    tests('#rescue_server').formats(rescue_server_format, false) do
+      service.rescue_server(server_id)
     end
+    wait_for_server_state(service, server_id, 'RESCUE', 'ACTIVE')
+
+    tests('#unrescue_server').succeeds do
+      service.unrescue_server(server_id)
+    end
+    wait_for_server_state(service, server_id, 'ACTIVE', 'ERROR')
 
     tests('#delete_server').succeeds do
       service.delete_server(server_id)
-    end
-  end
+    end    
+  end 
 end

data/tests/rackspace/requests/databases/database_tests.rb

@@ -4,33 +4,36 @@ Shindo.tests('Fog::Rackspace::Database | database_tests', ['rackspace']) do
 
   service = Fog::Rackspace::Databases.new
   instance_name = 'fog' + Time.now.to_i.to_s
-  instance_id = service.create_instance(instance_name, 1, 1).body['instance']['id']
 
-  until service.get_instance(instance_id).body["instance"]["status"] == 'ACTIVE'
-    sleep 10
-  end
-
-  tests('success') do
-    database_name = 'fogdb' + Time.now.to_i.to_s
+    begin
+    @instance_id = service.create_instance(instance_name, 1, 1).body['instance']['id']
 
-    tests("#create_database(#{instance_id}, #{database_name})").succeeds do
-      service.create_database(instance_id, database_name).body
+    wait_for_request("waiting for database to be created") do
+      service.get_instance(@instance_id).body["instance"]["status"] == 'ACTIVE'
     end
 
-    tests("#list_databases{#{instance_id})").formats(LIST_DATABASES_FORMAT) do
-      service.list_databases(instance_id).body
-    end
+    tests('success') do
+      database_name = 'fogdb' + Time.now.to_i.to_s
+
+      tests("#create_database(#{@instance_id}, #{database_name})").returns(202) do
+        service.create_database(@instance_id, database_name).status
+      end
 
-    tests("#delete_database(#{instance_id}, #{database_name})").succeeds do
-      service.delete_database(instance_id, database_name)
+      tests("#list_databases{#{@instance_id})").formats(LIST_DATABASES_FORMAT) do
+        service.list_databases(@instance_id).body
+      end
+
+      tests("#delete_database(#{@instance_id}, #{database_name})").returns(202) do
+        service.delete_database(@instance_id, database_name).status
+      end
     end
-  end
 
-  tests('failure') do
-    tests("#create_database(#{instance_id}, '') => Invalid Create Critera").raises(Fog::Rackspace::Databases::BadRequest) do
-      service.create_database(instance_id, '')
+    tests('failure') do
+      tests("#create_database(#{@instance_id}, '') => Invalid Create Critera").raises(Fog::Rackspace::Databases::BadRequest) do
+        service.create_database(@instance_id, '')
+      end
     end
+  ensure
+    service.delete_instance(@instance_id) if @instance_id
   end
-
-  service.delete_instance(instance_id)
 end