fog_tractical 1.1.3

data/tests/vcloud/models/compute/servers_tests.rb

@@ -0,0 +1,95 @@
+Shindo.tests("Vcloud::Compute | servers", ['vcloud']) do
+
+  tests("#server.new('#{Vcloud::Compute::TestSupport::template}')").returns(true) do
+    pending if Fog.mocking?
+    @svr = Vcloud.servers.create :catalog_item_uri => Vcloud::Compute::TestSupport::template, :name => 'fog_test_run', :password => 'password'
+    print "Waiting for server to be ready"
+    @svr.wait_for(1200) { print '.' ; ready? }
+    puts ""
+    @svr.ready?
+  end
+
+  tests("#svr.power_on()").returns(true) do
+    pending if Fog.mocking?
+    @svr.power_on
+    @svr.wait_for { on? }
+    @svr.wait_for { ready? }
+    @svr.on?
+  end
+
+  tests("#svr.description(\"testing\")").returns("testing") do
+    pending if Fog.mocking?
+    @svr.wait_for { ready? }
+    @svr.description = "testing"
+    @svr.save
+    @svr.wait_for { ready? }
+    @svr.description
+  end
+
+  # Power off only stops the OS, doesn't free up resources. #undeploy is for this.
+  tests("#svr.undeploy()").returns(true) do
+    pending if Fog.mocking?
+    @svr.undeploy
+    @svr.wait_for { off? }
+    @svr.wait_for { ready? }
+    @svr.off?
+  end
+
+  tests("#svr.memory(384)").returns(384) do
+    pending if Fog.mocking?
+    raise 'Server template memory already 384m - change to something different' if @svr.memory[:amount] == 384
+    @svr.wait_for { ready? }
+    @svr.memory = 384
+    @svr.save
+    @svr.wait_for { ready? }
+    # Can take a little while for the VM to know it has different ram, and not tied to a task..
+    (1..20).each do |i|
+      break if @svr.reload.memory[:amount] == '384'
+      sleep 1
+    end
+    @svr.reload.memory[:amount]
+  end
+
+  tests("#svr.add_disk(4096)").returns([2, "4096"]) do
+    pending if Fog.mocking?
+    raise 'Server template already has two disks' if @svr.disks.size == 2
+    @svr.wait_for { ready? }
+    @svr.add_disk(4096)
+    @svr.save
+    @svr.wait_for { ready? }
+    # Can take a little while for the VM to know it has different ram, and not tied to a task..
+    (1..20).each do |i|
+      break if @svr.reload.disks.size == 2
+      sleep 1
+    end
+    [
+     @svr.disks.size,
+     @svr.disks[1][:resource][:vcloud_capacity]
+    ]
+  end
+
+  tests("#svr.delete_disk(1)").returns(1) do
+    pending if Fog.mocking?
+    raise "Server doesn't have two disks - did previous step fail? " if @svr.disks.size != 2
+    @svr.wait_for { ready? }
+    sleep 5 # otherwise complains about being busy
+    @svr.delete_disk 1
+    @svr.save
+    @svr.wait_for { ready? }
+    # Can take a little while for the VM to know it has different ram, and not tied to a task..
+    (1..20).each do |i|
+      break if @svr.reload.disks.size == 1
+      sleep 1
+    end
+    @svr.disks.size
+  end
+
+  tests("#svr.destroy").raises(Excon::Errors::Forbidden) do
+    pending if Fog.mocking?
+    @svr.destroy
+    sleep 5 # allow cleanup..
+    Vcloud.servers.get(@svr.href) == nil
+  end
+
+
+end

data/tests/vcloud/requests/compute/disk_configure_tests.rb

@@ -0,0 +1,114 @@
+require 'spec'
+require 'spec/mocks'
+
+Shindo.tests("Vcloud::Compute | disk_requests", ['vcloud']) do
+
+  @xmlns = {
+    "xmlns" => "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData",
+    "xmlns:vcloud" => "http://www.vmware.com/vcloud/v1"
+  }
+
+  def disk_hash
+    [{:"rasd:AddressOnParent"=>"0",
+       :"rasd:Description"=>"Hard disk",
+       :"rasd:ElementName"=>"Hard disk 1",
+       :"rasd:HostResource"=>
+       {:vcloud_capacity=>"8192",
+         :vcloud_busType=>"6",
+         :vcloud_busSubType=>"lsilogic"},
+       :"rasd:InstanceID"=>"2000",
+       :"rasd:Parent"=>"2",
+       :"rasd:ResourceType"=>"17"}]
+  end
+
+  def nokogiri_load
+    Nokogiri::XML(MockDiskResponse.new.body)
+  end
+
+  class MockDiskResponse
+    def body
+      <<EOF
+<RasdItemsList xmlns="http://www.vmware.com/vcloud/v1" xmlns:rasd="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData" type="application/vnd.vmware.vcloud.rasdItemsList+xml" href="https://vcd01.esx.dev.int.realestate.com.au/api/v1.0/vApp/vm-329805878/virtualHardwareSection/disks" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2.22.0/CIM_ResourceAllocationSettingData.xsd http://www.vmware.com/vcloud/v1 http://vcd01.esx.dev.int.realestate.com.au/api/v1.0/schema/master.xsd">
+    <Link rel="edit" type="application/vnd.vmware.vcloud.rasdItemsList+xml" href="https://vcd01.esx.dev.int.realestate.com.au/api/v1.0/vApp/vm-329805878/virtualHardwareSection/disks"/>
+    <Item>
+        <rasd:Address>0</rasd:Address>
+        <rasd:Description>SCSI Controller</rasd:Description>
+        <rasd:ElementName>SCSI Controller 0</rasd:ElementName>
+        <rasd:InstanceID>2</rasd:InstanceID>
+        <rasd:ResourceSubType>lsilogic</rasd:ResourceSubType>
+        <rasd:ResourceType>6</rasd:ResourceType>
+    </Item>
+    <Item>
+        <rasd:AddressOnParent>0</rasd:AddressOnParent>
+        <rasd:Description>Hard disk</rasd:Description>
+        <rasd:ElementName>Hard disk 1</rasd:ElementName>
+        <rasd:HostResource xmlns:vcloud="http://www.vmware.com/vcloud/v1" vcloud:capacity="8192" vcloud:busType="6" vcloud:busSubType="lsilogic"></rasd:HostResource>
+        <rasd:InstanceID>2000</rasd:InstanceID>
+        <rasd:Parent>2</rasd:Parent>
+        <rasd:ResourceType>17</rasd:ResourceType>
+    </Item>
+    <Item>
+        <rasd:Address>0</rasd:Address>
+        <rasd:Description>IDE Controller</rasd:Description>
+        <rasd:ElementName>IDE Controller 0</rasd:ElementName>
+        <rasd:InstanceID>3</rasd:InstanceID>
+        <rasd:ResourceType>5</rasd:ResourceType>
+    </Item>
+</RasdItemsList>
+EOF
+    end
+  end
+
+  unless Fog.mocking?
+    Vcloud[:compute].stub!(:request).and_return(MockDiskResponse.new)
+  end
+
+  tests("Call to generate config returns string").returns(true) do
+    pending if Fog.mocking?
+    Vcloud[:compute].generate_configure_vm_disks_request('http://blah', disk_hash).kind_of? String
+  end
+
+  tests("Call to generate config with no changes returns input data").returns(true) do
+    pending if Fog.mocking?
+    Nokogiri::XML(Vcloud[:compute].generate_configure_vm_disks_request('http://blah', disk_hash)).to_s ==
+      Nokogiri::XML(MockDiskResponse.new.body).to_s
+  end
+
+  tests("Call to generate config with no disks removes disk").returns(true) do
+    pending if Fog.mocking?
+    xml = Vcloud[:compute].generate_configure_vm_disks_request('http://blah', [])
+    ng = Nokogiri::XML(xml)
+    # Should have 2 controllers, but no disks.
+    ng.xpath("//xmlns:ResourceType", @xmlns).size == 2 &&
+    ng.xpath("//xmlns:ResourceType[ .='17']", @xmlns).size == 0
+  end
+
+  tests("Call to generate config adding a disk").returns(['4096', true, true]) do
+    pending if Fog.mocking?
+    disks = disk_hash
+    disks << {
+      :"rasd:AddressOnParent"=>"1",
+      :"rasd:Description"=>"Hard disk",
+      :"rasd:ElementName"=>"Hard disk 2",
+      :"rasd:HostResource"=>
+      {:vcloud_capacity=>"4096",
+        :vcloud_busType=>"6",
+        :vcloud_busSubType=>"lsilogic"},
+      :"rasd:InstanceID"=>"2000",
+      :"rasd:Parent"=>"2",
+      :"rasd:ResourceType"=>"17"}
+    xml = Vcloud[:compute].generate_configure_vm_disks_request('http://blah', disks)
+    ng = Nokogiri::XML(xml)
+    [
+     # should be 4096mb
+     ng.at("//xmlns:ResourceType[ .='17']/../xmlns:AddressOnParent[.='-1']/../xmlns:HostResource", @xmlns)["capacity"],
+     # Should have 2 controllers, and 2 disks
+     ng.xpath("//xmlns:ResourceType", @xmlns).size == 4,
+     ng.xpath("//xmlns:ResourceType[ .='17']", @xmlns).size == 2
+    ]
+  end
+  
+  unless Fog.mocking?
+    Vcloud[:compute].unstub!(:request)
+  end
+end

data/tests/voxel/requests/compute/image_tests.rb

@@ -0,0 +1,52 @@
+Shindo.tests('Fog::Compute[:voxel] | image requests', ['voxel']) do
+
+  @images_format = {
+    'images' => [{
+      'id'      => Integer,
+      'summary' => String
+    }],
+    'stat' => String
+  }
+
+  @image_format = {
+    'images' => [{
+      'description'       => String,
+      'id'                => Integer,
+      'filesystem'        => {
+        'size'  => Integer,
+        'type'  => String,
+        'units' => String,
+      },
+      'operating_system'  => {
+        'admin_username'  => String,
+        'architecture'    => Integer,
+        'family'          => String,
+        'product_family'  => String,
+        'product_version' => String,
+        'version'         => String
+      },
+      'summary'           => String
+    }],
+    'stat' => String
+  }
+
+  tests('success') do
+    tests('#images_list').formats(@images_format) do
+      pending if Fog.mocking?
+      Fog::Compute[:voxel].images_list.body
+    end
+
+    tests('#images_list(1)').formats(@image_format) do
+      pending if Fog.mocking?
+      Fog::Compute[:voxel].images_list(1).body
+    end
+  end
+
+  tests('failure') do
+    tests('#images_list(0)').raises(Fog::Compute::Voxel::Error) do
+      pending if Fog.mocking?
+      Fog::Compute[:voxel].images_list(0).body
+    end
+  end
+
+end

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

@@ -0,0 +1,123 @@
+Shindo.tests('Fog::Compute[:voxel] | server requests', ['voxel']) do
+
+  @server_format = {
+    'device'  => {
+      'id'                => String,
+      'last_update'       => Time
+    },
+    'stat'    => String
+  }
+
+  @devices_format = {
+    'devices'   => [{
+      'access_methods'    => [],
+      'description'       => String,
+      'drives'            => [{
+        'position'  => Fog::Nullable::String,
+        'size'      => Integer
+      }],
+      'id'                => String,
+      'ipassignments'     => [{
+        'description' => String,
+        'id'          => String,
+        'type'        => String,
+        'value'       => String
+      }],
+      'label'             => String,
+      'location'          => {
+        'cage'      => {
+          'id'    => String,
+          'value' => String
+        },
+        'facility'  => {
+          'code'  => String,
+          'id'    => String,
+          'value' => String
+        },
+        'position'  => Fog::Nullable::String,
+        'rack'      => {
+          'id'    => String,
+          'value' => String
+        },
+        'row'       => {
+          'id'    => String,
+          'value' => String
+        },
+        'zone'      => {
+          'id'    => String,
+          'value' => String
+        }
+      },
+      'memory'            => { 'size' => Integer },
+      'model'             => {
+        'id'    => String,
+        'value' => String
+      },
+      'operating_system'  => {
+        'architecture'      => Integer,
+        'name'              => String
+      },
+      'power_consumption' => String,
+      'processor'         => {
+        'cores'   => Integer
+      },
+      'status'            => String,
+      'type'              => {
+        'id'    => String,
+        'value' => String
+      },
+    }],
+    'stat'  => String,
+  }
+
+  tests('success') do
+
+    @server_id = nil
+    @name = "fog.#{Time.now.to_i}"
+
+    tests("#voxcloud_create( :hostname => '#{@name}', :disk_size => 10, :processing_cores => 1, :image_id => 55, :facility => 'LDJ1' )").formats(@server_format) do
+      pending if Fog.mocking?
+      data = Fog::Compute[:voxel].voxcloud_create( :hostname => @name, :disk_size => 10, :processing_cores => 1, :image_id => 55, :facility => "LDJ1" ).body
+      @server_id = data['device']['id']
+      data
+    end
+
+    unless Fog.mocking?
+      Fog::Compute[:voxel].servers.get(@server_id).wait_for { ready? }
+    end
+
+    tests('#devices_list').formats(@devices_format) do
+      pending if Fog.mocking?
+      Fog::Compute[:voxel].devices_list.body
+    end
+
+    tests('#devices_list(@server_id)').formats(@devices_format) do
+      pending if Fog.mocking?
+      Fog::Compute[:voxel].devices_list(@server_id).body
+    end
+
+    tests("#voxcloud_delete(#{@server_id})").succeeds do
+      pending if Fog.mocking?
+      Fog::Compute[:voxel].voxcloud_delete(@server_id)
+    end
+
+  end
+
+  tests('failure') do
+    tests('#voxcloud_delete(0)').raises(Fog::Compute::Voxel::Error) do
+      pending if Fog.mocking?
+      Fog::Compute[:voxel].voxcloud_delete(0)
+    end
+
+    tests('#voxcloud_status(0)').raises(Fog::Compute::Voxel::Error) do
+      pending if Fog.mocking?
+      Fog::Compute[:voxel].voxcloud_status(0)
+    end
+
+    tests('#devices_list(0)').raises(Fog::Compute::Voxel::Error) do
+      pending if Fog.mocking?
+      Fog::Compute[:voxel].devices_list(0)
+    end
+  end
+
+end

data/tests/vsphere/compute_tests.rb

@@ -0,0 +1,55 @@
+Shindo.tests('Fog::Compute[:vsphere]', ['vsphere']) do
+
+  compute = Fog::Compute[:vsphere]
+
+  tests("| convert_vm_mob_ref_to_attr_hash") do
+    # Mock the RbVmomi::VIM::ManagedObject class
+    class MockManagedObject
+
+      attr_reader :parent, :_ref
+
+      def initialize
+        @parent = @_ref = 'vm-123'
+      end
+
+      def collect! *pathSet
+        { '_ref' => 'vm-123', 'name' => 'fakevm' }
+      end
+    end
+
+    fake_vm_mob_ref = MockManagedObject.new
+
+    tests("When converting an incomplete vm object") do
+      test("it should return a Hash") do
+        compute.convert_vm_mob_ref_to_attr_hash(fake_vm_mob_ref).kind_of? Hash
+      end
+      tests("The converted Hash should") do
+        attr_hash = compute.convert_vm_mob_ref_to_attr_hash(fake_vm_mob_ref)
+        test("have a name") { attr_hash['name'] == 'fakevm' }
+        test("have a mo_ref") {attr_hash['mo_ref'] == 'vm-123' }
+        test("have an id") { attr_hash['id'] == 'vm-123' }
+        test("not have a instance_uuid") { attr_hash['instance_uuid'].nil? }
+      end
+    end
+
+    tests("When passed a nil object") do
+      attr_hash = compute.convert_vm_mob_ref_to_attr_hash(nil)
+      test("it should return a nil object") do
+        attr_hash.nil?
+      end
+    end
+  end
+
+  tests("Compute attributes") do
+    %w{ vsphere_is_vcenter vsphere_rev vsphere_username vsphere_server }.each do |attr|
+      test("it should respond to #{attr}") { compute.respond_to? attr }
+    end
+  end
+
+  tests("Compute collections") do
+    %w{ servers }.each do |collection|
+      test("it should respond to #{collection}") { compute.respond_to? collection }
+    end
+  end
+end
+

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

@@ -0,0 +1,45 @@
+Shindo.tests('Fog::Compute[:vsphere] | server model', ['vsphere']) do
+
+  servers = Fog::Compute[:vsphere].servers
+  server = servers.last
+
+  tests('The server model should') do
+    tests('have the action') do
+      test('reload') { server.respond_to? 'reload' }
+      %w{ stop start destroy reboot }.each do |action|
+        test(action) { server.respond_to? action }
+        test("#{action} returns successfully") { server.send(action.to_sym) ? true : false }
+      end
+    end
+    tests('have attributes') do
+      model_attribute_hash = server.attributes
+      attributes = [ :id,
+        :instance_uuid,
+        :uuid,
+        :power_state,
+        :tools_state,
+        :mo_ref,
+        :tools_version,
+        :hostname,
+        :mac_addresses,
+        :operatingsystem,
+        :connection_state,
+        :hypervisor,
+        :name,
+        :ipaddress,
+        :is_a_template]
+      tests("The server model should respond to") do
+        attributes.each do |attribute|
+          test("#{attribute}") { server.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::Vsphere::Server') { server.kind_of? Fog::Compute::Vsphere::Server }
+  end
+
+end

data/tests/vsphere/models/compute/servers_tests.rb

@@ -0,0 +1,15 @@
+Shindo.tests('Fog::Compute[:vsphere] | servers collection', ['vsphere']) do
+
+  servers = Fog::Compute[:vsphere].servers
+
+  tests('The servers collection') do
+    test('should not be empty') { not servers.empty? }
+    test('should be a kind of Fog::Compute::Vsphere::Servers') { servers.kind_of? Fog::Compute::Vsphere::Servers }
+    tests('should be able to reload itself').succeeds { servers.reload }
+    tests('should be able to get a model') do
+      tests('by managed object reference').succeeds { servers.get 'vm-715' }
+      tests('by instance uuid').succeeds { servers.get '5032c8a5-9c5e-ba7a-3804-832a03e16381' }
+    end
+  end
+
+end

data/tests/vsphere/requests/compute/current_time_tests.rb

@@ -0,0 +1,12 @@
+Shindo.tests('Fog::Compute[:vsphere] | current_time request', ['vsphere']) do
+
+  compute = Fog::Compute[:vsphere]
+
+  tests('The response should') do
+    response = compute.current_time
+    test('be a kind of Hash') { response.kind_of? Hash }
+    test('have a current_time key') { response.has_key? 'current_time' }
+    test('have a current_time key with a Time value') { response['current_time'].kind_of? Time }
+  end
+
+end

data/tests/vsphere/requests/compute/find_vm_by_ref_tests.rb

@@ -0,0 +1,26 @@
+Shindo.tests('Fog::Compute[:vsphere] | find_vm_by_ref request', ['vsphere']) do
+
+  compute = Fog::Compute[:vsphere]
+
+  tests("When missing arguments") do
+    raises(ArgumentError, "Should raise ArgumentError when missing :vm_ref") do
+      compute.find_vm_by_ref
+    end
+    raises(Fog::Compute::Vsphere::NotFound, "Should raise Fog::Compute::Vsphere::NotFound when the vm does not exist") do
+      compute.find_vm_by_ref('vm_ref' => 'vm-000')
+    end
+  end
+
+  # centos56gm is a template
+  existing_vms = { 'vm-715' => 'jefftest', 'vm-698' => 'centos56gm' }
+
+  tests("When looking for existing VM's the response") do
+    existing_vms.each do |ref,name|
+      response = compute.find_vm_by_ref('vm_ref' => ref)
+      test("should be a kind of Hash") { response.kind_of? Hash }
+      test("should have virtual_machine key") { response.has_key? 'virtual_machine' }
+      returns(name, "#{ref} should return #{name}") { response['virtual_machine']['name'] }
+    end
+  end
+
+end

data/tests/vsphere/requests/compute/list_virtual_machines_tests.rb

@@ -0,0 +1,46 @@
+Shindo.tests('Fog::Compute[:vsphere] | list_virtual_machines request', ['vsphere']) do
+
+  key = 'virtual_machines'
+
+  tests("When listing all machines") do
+
+    response = Fog::Compute[:vsphere].list_virtual_machines
+
+    tests("The response data format ...") do
+      test("be a kind of Hash") { response.kind_of? Hash }
+      test("have a #{key} key") do
+        response.has_key? key
+      end
+      test("it should be a kind of Array") do
+        response[key].kind_of? Array
+      end
+    end
+  end
+
+  tests("When providing an instance_uuid") do
+
+    # pending unless Fog.mock?
+
+    tests("that does exist") do
+      uuid = "5032c8a5-9c5e-ba7a-3804-832a03e16381"
+      response = Fog::Compute[:vsphere].list_virtual_machines({'instance_uuid' => uuid})
+
+      tests("The response should") do
+        test("contain one vm") { response[key].length == 1 }
+        test("contain that is an attribute hash") { response[key][0].kind_of? Hash }
+        test("find jefftest") { response[key].first['name'] == 'jefftest' }
+      end
+    end
+
+    tests("that does not exist or is a template") do
+      %w{ does-not-exist-and-is-not-a-uuid 50323f93-6835-1178-8b8f-9e2109890e1a }.each do |uuid|
+        response = Fog::Compute[:vsphere].list_virtual_machines({'instance_uuid' => uuid})
+
+        tests("The response should") do
+          test("be empty") { response[key].empty? }
+        end
+      end
+    end
+  end
+
+end

data/tests/vsphere/requests/compute/vm_clone_tests.rb

@@ -0,0 +1,20 @@
+Shindo.tests("Fog::Compute[:vsphere] | vm_clone request", 'vsphere') do
+  #require 'guid'
+  template = "/Datacenters/Solutions/vm/Jeff/Templates/centos56gm2"
+  compute = Fog::Compute[:vsphere]
+
+  tests("The return value should") do
+    response = compute.vm_clone('path' => template, 'name' => 'cloning_vm')
+    test("be a kind of Hash") { response.kind_of? Hash }
+    %w{ vm_ref task_ref }.each do |key|
+      test("have a #{key} key") { response.has_key? key }
+    end
+  end
+  tests("When invalid input is presented") do
+    raises(ArgumentError, 'it should raise ArgumentError') { compute.vm_clone(:foo => 1) }
+    raises(Fog::Compute::Vsphere::NotFound, 'it should raise Fog::Compute::Vsphere::NotFound when the UUID is not a string') do
+      pending # require 'guid'
+      compute.vm_clone('instance_uuid' => Guid.from_s(template), 'name' => 'jefftestfoo')
+    end
+  end
+end

data/tests/vsphere/requests/compute/vm_destroy_tests.rb

@@ -0,0 +1,17 @@
+Shindo.tests('Fog::Compute[:vsphere] | vm_destroy request', ['vsphere']) do
+
+  compute = Fog::Compute[:vsphere]
+
+  booted_vm = '5032c8a5-9c5e-ba7a-3804-832a03e16381'
+
+  tests('The response should') do
+    response = compute.vm_destroy('instance_uuid' => booted_vm)
+    test('be a kind of Hash') { response.kind_of? Hash }
+    test('should have a task_state key') { response.has_key? 'task_state' }
+
+  end
+  tests('The expected options') do
+    raises(ArgumentError, 'raises ArgumentError when instance_uuid option is missing') { compute.vm_destroy }
+  end
+
+end

data/tests/vsphere/requests/compute/vm_power_off_tests.rb

@@ -0,0 +1,26 @@
+Shindo.tests('Fog::Compute[:vsphere] | vm_power_off request', ['vsphere']) do
+
+  compute = Fog::Compute[:vsphere]
+
+  powered_on_vm = '5032c8a5-9c5e-ba7a-3804-832a03e16381'
+
+  tests('The response should') do
+    response = compute.vm_power_off('instance_uuid' => powered_on_vm)
+    test('be a kind of Hash') { response.kind_of? Hash }
+    test('should have a task_state key') { response.has_key? 'task_state' }
+    test('should have a power_off_type key') { response.has_key? 'power_off_type' }
+  end
+
+  # When forcing the shutdown, we expect the result to be
+  { true => 'cut_power', false => 'shutdown_guest'}.each do |force, expected|
+    tests("When 'force' => #{force}") do
+      response = compute.vm_power_off('instance_uuid' => powered_on_vm, 'force' => force)
+      test('should retur power_off_type of #{expected}') { response['power_off_type'] == expected }
+    end
+  end
+
+  tests('The expected options') do
+    raises(ArgumentError, 'raises ArgumentError when instance_uuid option is missing') { compute.vm_power_off }
+  end
+
+end

data/tests/vsphere/requests/compute/vm_power_on_tests.rb

@@ -0,0 +1,17 @@
+Shindo.tests('Fog::Compute[:vsphere] | vm_power_on request', ['vsphere']) do
+
+  compute = Fog::Compute[:vsphere]
+
+  powered_off_vm = nil
+
+  tests('The response should') do
+    response = compute.vm_power_off('instance_uuid' => powered_off_vm)
+    test('be a kind of Hash') { response.kind_of? Hash }
+    test('should have a task_state key') { response.has_key? 'task_state' }
+  end
+
+  tests('The expected options') do
+    raises(ArgumentError, 'raises ArgumentError when instance_uuid option is missing') { compute.vm_power_on }
+  end
+
+end