fog-maestrodev 1.15.0.20130927082724 → 1.18.0.20131111203459

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

@@ -17,18 +17,18 @@ Shindo.tests('Fog::Storage[:openstack] | object requests', ["openstack"]) do
       Fog::Storage[:openstack].put_object('fogobjecttests', 'fog_object', lorem_file)
     end
 
-    tests("#get_object('fogobjectests', 'fog_object')").returns(lorem_file.read) do
+    tests("#get_object('fogobjectests', 'fog_object')").succeeds do
       pending if Fog.mocking?
-      Fog::Storage[:openstack].get_object('fogobjecttests', 'fog_object').body
+      Fog::Storage[:openstack].get_object('fogobjecttests', 'fog_object').body == lorem_file.read
     end
 
-    tests("#get_object('fogobjecttests', 'fog_object', &block)").returns(lorem_file.read) do
+    tests("#get_object('fogobjecttests', 'fog_object', &block)").succeeds do
       pending if Fog.mocking?
       data = ''
       Fog::Storage[:openstack].get_object('fogobjecttests', 'fog_object') do |chunk, remaining_bytes, total_bytes|
         data << chunk
       end
-      data
+      data == lorem_file.read
     end
 
     tests("#head_object('fogobjectests', 'fog_object')").succeeds do
@@ -41,6 +41,20 @@ Shindo.tests('Fog::Storage[:openstack] | object requests', ["openstack"]) do
       Fog::Storage[:openstack].delete_object('fogobjecttests', 'fog_object')
     end
 
+    tests("#get_object_http_url('directory.identity', 'fog_object', expiration timestamp)").returns(true) do
+      pending if Fog.mocking?
+      object_url = Fog::Storage[:openstack].get_object_http_url(@directory.identity, 'fog_object', (Time.now + 60))
+
+      (object_url =~ /http:\/\/\S+\/v1\/AUTH_\S+\/#{@directory.identity}\/fog_object\?temp_url_sig=\S+&temp_url_expires=\d+/) != nil
+    end
+
+    tests("#get_object_https_url('directory.identity', 'fog_object', expiration timestamp)").returns(true) do
+      pending if Fog.mocking?
+      object_url = Fog::Storage[:openstack].get_object_https_url(@directory.identity, 'fog_object', (Time.now + 60))
+
+      (object_url =~ /https:\/\/\S+\/v1\/AUTH_\S+\/#{@directory.identity}\/fog_object\?temp_url_sig=\S+&temp_url_expires=\d+/) != nil
+    end
+
     tests("put_object with block") do
       pending if Fog.mocking?
 
@@ -65,6 +79,30 @@ Shindo.tests('Fog::Storage[:openstack] | object requests', ["openstack"]) do
       end
     end
 
+    tests('#delete_multiple_objects') do
+      pending if Fog.mocking?
+
+      Fog::Storage[:openstack].put_object('fogobjecttests', 'fog_object', lorem_file)
+      Fog::Storage[:openstack].put_object('fogobjecttests', 'fog_object2', lorem_file)
+      Fog::Storage[:openstack].directories.create(:key => 'fogobjecttests2')
+      Fog::Storage[:openstack].put_object('fogobjecttests2', 'fog_object', lorem_file)
+
+      expected = {
+        "Number Not Found"  => 0,
+        "Response Status"   => "200 OK",
+        "Errors"            => [],
+        "Number Deleted"    => 2,
+        "Response Body"     => ""
+      }
+
+      returns(expected, 'deletes multiple objects') do
+        Fog::Storage[:openstack].delete_multiple_objects('fogobjecttests', ['fog_object', 'fog_object2']).body
+      end
+
+      returns(expected, 'deletes object and container') do
+        Fog::Storage[:openstack].delete_multiple_objects(nil, ['fogobjecttests2/fog_object', 'fogobjecttests2']).body
+      end
+    end
 
   end
 
@@ -100,6 +138,41 @@ Shindo.tests('Fog::Storage[:openstack] | object requests', ["openstack"]) do
       Fog::Storage[:openstack].delete_object('fognoncontainer', 'fog_non_object')
     end
 
+    tests('#delete_multiple_objects') do
+      pending if Fog.mocking?
+
+      expected = {
+        "Number Not Found"  => 2,
+        "Response Status"   => "200 OK",
+        "Errors"            => [],
+        "Number Deleted"    => 0,
+        "Response Body"     => ""
+      }
+
+      returns(expected, 'reports missing objects') do
+        Fog::Storage[:openstack].delete_multiple_objects('fogobjecttests', ['fog_non_object', 'fog_non_object2']).body
+      end
+
+      returns(expected, 'reports missing container') do
+        Fog::Storage[:openstack].delete_multiple_objects('fognoncontainer', ['fog_non_object', 'fog_non_object2']).body
+      end
+
+      tests('deleting non-empty container') do
+        Fog::Storage[:openstack].put_object('fogobjecttests', 'fog_object', lorem_file)
+
+        expected = {
+          "Number Not Found"  => 0,
+          "Response Status"   => "400 Bad Request",
+          "Errors"            => [['fogobjecttests', '409 Conflict']],
+          "Number Deleted"    => 1,
+          "Response Body"     => ""
+        }
+
+        returns(expected, 'deletes object but not container') do
+          Fog::Storage[:openstack].delete_multiple_objects(nil, ['fogobjecttests', 'fogobjecttests/fog_object']).body
+        end
+      end
+    end
   end
 
   unless Fog.mocking?

data/tests/rackspace/block_storage_tests.rb

@@ -79,7 +79,7 @@ Shindo.tests('Fog::Rackspace::BlockStorage', ['rackspace']) do
     pending if Fog.mocking?
 
     tests('no params').succeeds do
-      @service = Fog::Rackspace::BlockStorage.new
+      @service = Fog::Rackspace::BlockStorage.new :rackspace_region => nil
       returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
       returns(true) { (@service.instance_variable_get("@uri").host =~ /dfw/) != nil }
       @service.list_volumes

data/tests/rackspace/cdn_tests.rb

@@ -7,7 +7,7 @@ Shindo.tests('Fog::CDN::Rackspace', ['rackspace']) do
 
   tests('#authentication_method') do
     @service = Fog::CDN::Rackspace.new
-  
+
     assert_method nil, :authenticate_v2
 
     assert_method 'https://identity.api.rackspacecloud.com', :authenticate_v1
@@ -76,7 +76,7 @@ Shindo.tests('Fog::CDN::Rackspace', ['rackspace']) do
     pending if Fog.mocking?
     
     tests('no params').succeeds do
-      @service = Fog::CDN::Rackspace.new
+      @service = Fog::CDN::Rackspace.new :rackspace_region => nil
       returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
       returns(true, "uses DFW") { (@service.instance_variable_get("@uri").host =~ /cdn1/) != nil }
       @service.get_containers

data/tests/rackspace/compute_tests.rb

@@ -65,7 +65,7 @@ Shindo.tests('Rackspace | Compute', ['rackspace']) do
     pending if Fog.mocking?
 
     tests('no params').succeeds do
-      @service = Fog::Compute::Rackspace.new
+      @service = Fog::Compute::Rackspace.new :rackspace_region => nil
       returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
       returns(true) { (@service.instance_variable_get("@uri").host == 'servers.api.rackspacecloud.com') != nil }
       @service.list_flavors
@@ -81,11 +81,6 @@ Shindo.tests('Rackspace | Compute', ['rackspace']) do
       returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
       returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /my-custom-endpoint\.com/) != nil }
     end
-    tests('rackspace_servicenet') do
-      @service = Fog::Compute::Rackspace.new :rackspace_servicenet => true
-      returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
-      returns(true, "uses custom endpoint") { (@service.instance_variable_get("@uri").host =~ /snet-/) != nil }
-    end
   end
 
   tests('reauthentication') do

data/tests/rackspace/compute_v2_tests.rb

@@ -78,7 +78,7 @@ Shindo.tests('Fog::Compute::RackspaceV2', ['rackspace']) do
     pending if Fog.mocking?
 
     tests('no params').succeeds do
-      @service = Fog::Compute::RackspaceV2.new
+      @service = Fog::Compute::RackspaceV2.new :rackspace_region => nil
       returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
       returns(true) { (@service.instance_variable_get("@uri").host =~ /dfw/) != nil }
       @service.list_flavors

data/tests/rackspace/databases_tests.rb

@@ -79,7 +79,7 @@ Shindo.tests('Fog::Rackspace::Databases', ['rackspace']) do |variable|
     pending if Fog.mocking?
 
     tests('no params').succeeds do
-      @service = Fog::Rackspace::Databases.new
+      @service = Fog::Rackspace::Databases.new :rackspace_region => nil
       returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
       returns(true) { (@service.instance_variable_get("@uri").host =~ /dfw/) != nil }
       @service.flavors

data/tests/rackspace/dns_tests.rb

@@ -69,7 +69,7 @@ Shindo.tests('Fog::DNS::Rackspace', ['rackspace']) do
     pending if Fog.mocking?
 
     tests('no params').succeeds do
-      @service = Fog::DNS::Rackspace.new
+      @service = Fog::DNS::Rackspace.new :rackspace_region => nil
       returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
       returns(false, "path populated") { @service.instance_variable_get("@uri").host.nil? }
       returns(true, "contains tenant id") {  (@service.instance_variable_get("@uri").path =~ /\/v1\.0\/\d+$/) != nil} #dns does not error if tenant id is missing

data/tests/rackspace/helper.rb

@@ -1,3 +1,8 @@
+LINKS_FORMAT = [{
+  'href' => String,
+  'rel' => String
+}]
+
 module Shindo
   class Tests
 
@@ -49,17 +54,22 @@ module Shindo
       until current_state == state
         current_state = service.get_server(server_id).body['server']['status']
         if error_states
-          error_states = Array(error_states)           
-          raise "ERROR! Server should have transitioned to '#{state}' not '#{current_state}'" if error_states.include?(current_state)
+          error_states = Array(error_states)
+          if error_states.include?(current_state)
+            Fog::Logger.warning caller
+            Fog::Logger.warning "ERROR! Server should have transitioned to '#{state}' not '#{current_state}'"
+            return
+          end
         end
         sleep 10 unless Fog.mocking?
       end
       sleep 30 unless Fog.mocking?
     end
 
-    def rackspace_test_image_id(service) 
+    def rackspace_test_image_id(service)
+      image_id  = Fog.credentials[:rackspace_image_id]
       # I chose to use the first Ubuntu because it will work with the smallest flavor and it doesn't require a license
-      @image_id ||= Fog.credentials[:rackspace_image_id] || service.images.find {|img| img.name =~ /Ubuntu/ }.id
+      image_id ||= Fog.mocking? ? @service.images.first.id : @service.images.find {|image| image.name =~ /Ubuntu/}.id # use the first Ubuntu image
     end
 
     def rackspace_test_flavor_id(service)

data/tests/rackspace/load_balancer_tests.rb

@@ -78,7 +78,7 @@ Shindo.tests('Fog::Rackspace::LoadBalancers', ['rackspace']) do
     pending if Fog.mocking?
 
     tests('no params').succeeds do
-      @service = Fog::Rackspace::LoadBalancers.new
+      @service = Fog::Rackspace::LoadBalancers.new :rackspace_region => nil
       returns(true, "auth token populated") { !@service.send(:auth_token).nil? }
       returns(true) { (@service.instance_variable_get("@uri").host =~ /dfw/) != nil }
       @service.list_load_balancers

data/tests/rackspace/models/auto_scale/group_builder_tests.rb

@@ -0,0 +1,145 @@
+require 'fog/rackspace/models/auto_scale/group_builder'
+require 'fog/rackspace/models/auto_scale/group'
+require 'fog/rackspace/models/compute_v2/flavor'
+require 'fog/rackspace/models/load_balancers/load_balancer'
+
+Shindo.tests('Fog::Rackspace::AutoScale | group builder', ['rackspace', 'rackspace_autoscale']) do
+  builder = Fog::Rackspace::AutoScale::GroupBuilder
+
+  tests('#get_id') do
+    tests('widget_id').returns(5) do
+      builder.send(:get_id, 'widget', {:widget_id => 5, :noise => 3})
+    end
+    tests('widget').returns(5) do
+      Fog::Rackspace::AutoScale::GroupBuilder.send(:get_id, 'widget', {:widget => 5, :noise => 3})
+    end
+    tests('Flavor object').returns(2) do
+      flavor = Fog::Compute::RackspaceV2::Flavor.new(:id => 2)
+      builder.send(:get_id, 'flavor', {:flavor => flavor, :noise => 3})
+    end
+  end
+
+  tests('networks_to_hash').returns([{"uuid" => '00000000-0000-0000-0000-000000000000'}]) do
+    builder.send(:networks_to_hash, ['00000000-0000-0000-0000-000000000000'])
+  end
+
+  tests('#build_server_template').returns(LAUNCH_CONFIG_OPTIONS["args"]["server"]) do
+    attributes = {
+      :server_name => "autoscale_server",
+      :image => "0d589460-f177-4b0f-81c1-8ab8903ac7d8",
+      :flavor => "2",
+      :disk_config => "AUTO",
+      :server_metadata => {
+        "build_config" => "core",
+        "meta_key_1" => "meta_value_1",
+        "meta_key_2" => "meta_value_2"
+      },
+      :networks => ["11111111-1111-1111-1111-111111111111", "00000000-0000-0000-0000-000000000000"],
+      :personality => [
+        {
+          "path" => "/root/.csivh",
+          "contents" => "VGhpcyBpcyBhIHRlc3QgZmlsZS4="
+        }
+      ]
+    }
+    builder.send(:build_server_template, attributes)
+  end
+
+  tests('#load_balancer_to_hash') do
+    lb_test_hash = {
+      "port" =>  80,
+      "loadBalancerId" => 1234
+    }
+    tests('hash').raises(ArgumentError, "Expected LoadBalancer") do
+      builder.send(:load_balancer_to_hash, lb_test_hash)
+    end
+    tests('LoadBalancer').returns(lb_test_hash) do
+      lb = Fog::Rackspace::LoadBalancers::LoadBalancer.new :port => 80, :id => 1234
+      builder.send(:load_balancer_to_hash, lb)
+    end
+  end
+
+  tests('build_load_balancers') do
+    lb_test_hash = {
+      "port" =>  80,
+      "loadBalancerId" => 1234
+    }
+    tests('nil').returns(nil) do
+      builder.send(:build_load_balancers, {})
+    end
+    tests('hash').returns([lb_test_hash]) do
+      builder.send(:build_load_balancers, :load_balancers => [lb_test_hash])
+    end
+    tests('LoadBalancer').returns([lb_test_hash]) do
+      lb = Fog::Rackspace::LoadBalancers::LoadBalancer.new :port => 80, :id => 1234
+      builder.send(:build_load_balancers, :load_balancers => [lb])
+    end
+    tests('multiple lbs').returns([lb_test_hash, lb_test_hash]) do
+      lb = Fog::Rackspace::LoadBalancers::LoadBalancer.new :port => 80, :id => 1234
+      builder.send(:build_load_balancers, :load_balancers => [lb, lb])
+    end
+  end
+
+  tests('build_server_launch_config') do
+    tests('no launch_config_type').returns(nil) do
+      builder.build_server_launch_config({:pancakes => true})
+    end
+    tests('wrong launch_config_type').returns(nil) do
+      builder.build_server_launch_config({:launch_config_type => :something_else})
+    end
+    tests('valid launch config').returns(LAUNCH_CONFIG_OPTIONS["args"]) do
+      attributes = {
+        :server_name => "autoscale_server",
+        :image => "0d589460-f177-4b0f-81c1-8ab8903ac7d8",
+        :flavor => "2",
+        :disk_config => "AUTO",
+        :server_metadata => {
+          "build_config" => "core",
+          "meta_key_1" => "meta_value_1",
+          "meta_key_2" => "meta_value_2"
+        },
+        :networks => ["11111111-1111-1111-1111-111111111111", "00000000-0000-0000-0000-000000000000"],
+        :personality => [
+          {
+            "path" => "/root/.csivh",
+            "contents" => "VGhpcyBpcyBhIHRlc3QgZmlsZS4="
+          }
+        ],
+        :launch_config_type => :launch_server,
+        :load_balancers => { "port" => 8080, "loadBalancerId" => 9099}
+      }
+
+      builder.build_server_launch_config(attributes).args
+    end
+  end
+
+  tests('#build_group_config') do
+    attributes = {
+      :max_entities => 3,
+      :min_entities => 0,
+      :cooldown => 360,
+      :name => "testscalinggroup198547",
+      :metadata => {
+        "gc_meta_key_2" => "gc_meta_value_2",
+        "gc_meta_key_1" => "gc_meta_value_1"
+      }
+    }
+
+    config = builder.build_group_config(attributes)
+    returns(3) { config.max_entities }
+    returns(0) { config.min_entities }
+    returns(360) { config.cooldown }
+    returns("testscalinggroup198547") { config.name }
+    returns(attributes[:metadata]) { config.metadata }
+  end
+
+  tests('build') do
+    pending if Fog.mocking?
+    service = Fog::Rackspace::AutoScale.new :rackspace_region => :ord
+
+    group = builder.build(service, :launch_config_type => :launch_server, :server_name => 'test', :cooldown => 500)
+    returns(500) { group.group_config.cooldown }
+    returns('test') { group.launch_config.args["server"]["name"]}
+  end
+
+end

data/tests/rackspace/models/auto_scale/group_tests.rb

@@ -0,0 +1,36 @@
+Shindo.tests('Fog::Rackspace::AutoScale | group', ['rackspace', 'rackspace_autoscale']) do
+
+	service = Fog::Rackspace::AutoScale.new :rackspace_region => :ord
+
+	options = {
+		:name => "fog_#{Time.now.to_i.to_s}",
+		:policies => POLICIES_OPTIONS,
+		:launch_config => LAUNCH_CONFIG_OPTIONS,
+		:group_config => GROUP_CONFIG_OPTIONS
+	}
+
+
+	model_tests(service.groups, options, false) do
+    pending if Fog.mocking?
+		tests('#policies').succeeds do
+			@instance.policies
+		end
+
+		tests('#launch_config').succeeds do
+      @instance.launch_config
+	  end
+
+	  tests('#group_config').succeeds do
+      @instance.group_config
+    end
+
+    tests('#state').succeeds do
+      @instance.state
+    end
+
+    tests('deactive scaling group').succeeds do
+      deactive_auto_scale_group(@instance)
+    end
+	end
+
+end

data/tests/rackspace/models/auto_scale/{groups.rb → groups_tests.rb}

@@ -1,4 +1,4 @@
-Shindo.tests('Fog::Rackspace::AutoScale | groups', ['rackspace', 'rackspace_autoscale']) do 
+Shindo.tests('Fog::Rackspace::AutoScale | groups', ['rackspace', 'rackspace_autoscale']) do
   pending if Fog.mocking?
   service = Fog::Rackspace::AutoScale.new :rackspace_region => :ord
 
@@ -8,6 +8,10 @@ Shindo.tests('Fog::Rackspace::AutoScale | groups', ['rackspace', 'rackspace_auto
     :launch_config => LAUNCH_CONFIG_OPTIONS
   }
 
-  collection_tests(service.groups, options, false)
+  collection_tests(service.groups, options, false) do
+    tests('deactive scaling group').succeeds do
+      deactive_auto_scale_group(@instance)
+    end
+  end
 
 end

data/tests/rackspace/models/auto_scale/policies_tests.rb

@@ -0,0 +1,25 @@
+Shindo.tests('Fog::Rackspace::AutoScale | policies', ['rackspace', 'rackspace_autoscale']) do
+  pending if Fog.mocking?
+  service = Fog::Rackspace::AutoScale.new :rackspace_region => :ord
+
+
+  begin
+    group = service.groups.create({
+      :policies => POLICIES_OPTIONS,
+      :group_config => GROUP_CONFIG_OPTIONS,
+      :launch_config => LAUNCH_CONFIG_OPTIONS
+    })
+
+    options = {
+      :name => "policy 2",
+      :change => 5,
+      :cooldown => 100,
+      :type => 'webhook'
+    }
+
+    collection_tests(group.policies, options, false)
+  ensure
+    deactive_auto_scale_group(group)
+    group.destroy if group
+  end
+end

data/tests/rackspace/models/auto_scale/policy_tests.rb

@@ -0,0 +1,35 @@
+Shindo.tests('Fog::Rackspace::AutoScale | policy', ['rackspace', 'rackspace_autoscale']) do
+
+  service = Fog::Rackspace::AutoScale.new :rackspace_region => :ord
+
+  pending if Fog.mocking?
+
+  begin
+    group = service.groups.create({
+      :policies => POLICIES_OPTIONS,
+      :group_config => GROUP_CONFIG_OPTIONS,
+      :launch_config => LAUNCH_CONFIG_OPTIONS
+    })
+
+    options = {
+      :name => "policy 2",
+      :change => 1,
+      :cooldown => 100,
+      :type => 'webhook',
+      :group => group
+    }
+
+    model_tests(group.policies, options, false) do
+      tests('#execute').succeeds do
+        @instance.execute
+      end
+      tests('#webhooks').succeeds do
+        @instance.webhooks
+      end
+    end
+  ensure
+    deactive_auto_scale_group(group)
+    group.destroy if group
+  end
+
+end

data/tests/rackspace/models/auto_scale/webhook_tests.rb

@@ -0,0 +1,42 @@
+Shindo.tests('Fog::Rackspace::AutoScale | webhook', ['rackspace', 'rackspace_autoscale']) do
+
+  service = Fog::Rackspace::AutoScale.new :rackspace_region => :ord
+
+  pending if Fog.mocking?
+
+  begin
+    group = service.groups.create({
+      :policies => POLICIES_OPTIONS,
+      :group_config => GROUP_CONFIG_OPTIONS,
+      :launch_config => LAUNCH_CONFIG_OPTIONS
+    })
+
+    policy = group.policies.create({
+      :name => "set group to 5 servers",
+      :desired_capacity => 5,
+      :cooldown => 1800,
+      :type => "webhook",
+      :group => group
+    })
+
+    options = {
+      :name => 'webhook name',
+      :metadata => {
+        'owner' => 'me'
+      },
+      :group => group,
+      :policy => policy
+    }
+
+    model_tests(policy.webhooks, options, false) do
+      tests('#execution_url').succeeds do
+        @instance.execution_url
+      end
+    end
+  ensure
+    policy.destroy if policy
+    deactive_auto_scale_group(group)
+    group.destroy if group
+  end
+
+end

data/tests/rackspace/models/auto_scale/webhooks_tests.rb

@@ -0,0 +1,28 @@
+Shindo.tests('Fog::Rackspace::AutoScale | webhooks', ['rackspace', 'rackspace_autoscale']) do
+  pending if Fog.mocking?
+  service = Fog::Rackspace::AutoScale.new :rackspace_region => :ord
+
+  begin
+    group = service.groups.create({
+      :policies => POLICIES_OPTIONS,
+      :group_config => GROUP_CONFIG_OPTIONS,
+      :launch_config => LAUNCH_CONFIG_OPTIONS
+    })
+
+    policy = group.policies.create({
+      :name => "policy 2",
+      :change => 5,
+      :cooldown => 100,
+      :type => 'webhook',
+      :group => group
+    })
+
+    options = {:name => 'New webhook', :group => group, :policy => policy }
+    collection_tests(policy.webhooks, options, false)
+  ensure
+    policy.destroy if policy
+    deactive_auto_scale_group(group)
+    group.destroy if group
+  end
+
+end

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

@@ -12,7 +12,7 @@ Shindo.tests('Fog::Compute::RackspaceV2 | metadata', ['rackspace']) do
       :image_id => rackspace_test_image_id(service))
       
       @server.wait_for { ready? }
-      
+
       tests('server') do
         collection_tests(@server.metadata, {:key => 'my_key', :value => 'my_value'}) do
           @server.wait_for { ready? }

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

@@ -9,7 +9,7 @@ Shindo.tests('Fog::Compute::RackspaceV2 | server', ['rackspace']) do
   options = {
     :name => "fog_server_#{Time.now.to_i.to_s}",
     :flavor_id => rackspace_test_flavor_id(service),
-    :image_id => rackspace_test_image_id(service), 
+    :image_id => rackspace_test_image_id(service),
     :metadata => { 'fog_test' => 'true' },
     :networks => [@network.id]
   }
@@ -76,6 +76,13 @@ Shindo.tests('Fog::Compute::RackspaceV2 | server', ['rackspace']) do
        @instance.addresses.keys.include?(@network.label)
      end
 
+    tests('#create').succeeds do
+      pending unless Fog.mocking?
+      original_options = Marshal.load(Marshal.dump(options))
+      @instance.create(options)
+      returns(true) { original_options == options }
+    end
+
     tests('#update').succeeds do
       new_name = "fog_server_update#{Time.now.to_i.to_s}"
       @instance.name = new_name