fog-vsphere 0.1.0

data/tests/helpers/succeeds_helper.rb

@@ -0,0 +1,9 @@
+module Shindo
+  class Tests
+    def succeeds
+      test('succeeds') do
+        !!instance_eval(&Proc.new)
+      end
+    end
+  end
+end

data/tests/models/compute/server_tests.rb

@@ -0,0 +1,70 @@
+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
+      test('guest_processes') { server.respond_to? 'guest_processes' }
+      test('take_snapshot') do
+        test('responds') { server.respond_to? 'take_snapshot'}
+        test('returns successfully') { server.take_snapshot('name' => 'foobar').kind_of? Hash }
+      end
+      test('snapshots') do
+        test('responds') { server.respond_to? 'snapshots'}
+        test('returns successfully') { server.snapshots.kind_of? Fog::Compute::Vsphere::Snapshots }
+      end
+      test('find_snapshot') do
+        test('responds') { server.respond_to? 'find_snapshot'}
+        test('returns successfully') do
+          server.find_snapshot('snapshot-0101').kind_of? Fog::Compute::Vsphere::Snapshot
+        end
+        test('returns correct snapshot') do
+          server.find_snapshot('snapshot-0101').ref == 'snapshot-0101'
+        end
+      end
+      tests('revert_snapshot') do
+        test('responds') { server.respond_to? 'revert_snapshot'}
+        tests('returns correctly') do
+          test('when correct input given') { server.revert_snapshot('snapshot-0101').kind_of? Hash }
+          test('when incorrect input given') do
+            raises(ArgumentError) { server.revert_snapshot(1) }
+          end
+        end
+      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,
+        :public_ip_address]
+      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.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/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/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.key? 'current_time' }
+    test('have a current_time key with a Time value') { response['current_time'].kind_of? Time }
+  end
+
+end

data/tests/requests/compute/get_network_tests.rb

@@ -0,0 +1,50 @@
+require 'ostruct'
+
+Shindo.tests('Fog::Compute[:vsphere] | get_network request', ['vsphere']) do
+
+  compute = Fog::Compute[:vsphere]
+
+
+  class DistributedVirtualPortgroup
+    attr_accessor :name, :dvs_name
+
+    def initialize attrs
+      @name = attrs.fetch(:name)
+      @dvs_name = attrs.fetch(:dvs_name)
+    end
+
+    def config
+      OpenStruct.new( :distributedVirtualSwitch => OpenStruct.new(:name => dvs_name))
+    end
+  end
+
+  fake_networks = [OpenStruct.new(:name => 'non-dvs'),
+                   DistributedVirtualPortgroup.new( :name => 'web1', :dvs_name => 'dvs5'),
+                   DistributedVirtualPortgroup.new( :name => 'web1', :dvs_name => 'dvs11'),
+                   DistributedVirtualPortgroup.new( :name => 'other', :dvs_name => 'other'),
+                  ]
+
+
+  tests('#choose_finder should') do
+    test('choose the network based on network name and dvs name'){
+      finder = compute.send(:choose_finder, 'web1', 'dvs11')
+      found_network = fake_networks.find{ |n| finder.call(n) }
+      found_network.name == 'web1' && found_network.dvs_name == 'dvs11'
+    }
+    test('choose the network based on network name and any dvs'){
+      finder = compute.send(:choose_finder, 'web1', :dvs)
+      found_network = fake_networks.find{ |n| finder.call(n) }
+      found_network.name == 'web1' && found_network.dvs_name == 'dvs5'
+    }
+    test('choose the network based on network name only'){
+      finder = compute.send(:choose_finder, 'other', nil)
+      found_network = fake_networks.find{ |n| finder.call(n) }
+      found_network.name == 'other' && found_network.dvs_name == 'other'
+    }
+    test('choose the network based on network name only for non-dvs'){
+      finder = compute.send(:choose_finder, 'non-dvs', nil)
+      found_network = fake_networks.find{ |n| finder.call(n) }
+      found_network.name == 'non-dvs' && found_network.class.name.to_s == 'OpenStruct'
+    }
+  end
+end

data/tests/requests/compute/list_child_snapshots_tests.rb

@@ -0,0 +1,10 @@
+Shindo.tests('Fog::Compute[:vsphere] | list_child_snapshots request', ['vsphere']) do
+
+  compute = Fog::Compute[:vsphere]
+
+  tests('The response should') do
+    response = compute.list_child_snapshots('snapshot-0101')
+    test('be a kind of Array') { response.kind_of? Array }
+    test('it should contains Hashes') { response.all? { |i| Hash === i } }
+  end
+end

data/tests/requests/compute/list_clusters_tests.rb

@@ -0,0 +1,11 @@
+Shindo.tests('Fog::Compute[:vsphere] | list_clusters request', ['vsphere']) do
+  tests("When listing all clusters") do
+
+    response = Fog::Compute[:vsphere].list_clusters
+    test("Clusters extracted from folders... ") {response.length == 4}
+
+    tests("The response data format ...") do
+      test("be a kind of Hash") { response.kind_of? Array }
+    end
+  end
+end

data/tests/requests/compute/list_virtual_machines_tests.rb

@@ -0,0 +1,38 @@
+Shindo.tests('Fog::Compute[:vsphere] | list_virtual_machines request', ['vsphere']) do
+
+  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? Array }
+    end
+  end
+
+  tests("When providing an instance_uuid") do
+
+    # pending unless Fog.mock?
+
+    tests("that does exist") do
+      uuid = "5029c440-85ee-c2a1-e9dd-b63e39364603"
+      response = Fog::Compute[:vsphere].list_virtual_machines({'instance_uuid' => uuid})
+
+      tests("The response should") do
+        test("contain one vm") { response.length == 1 }
+        test("contain that is an attribute hash") { response[0].kind_of? Hash }
+        test("find jefftest") { response.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.empty? }
+        end
+      end
+    end
+  end
+
+end

data/tests/requests/compute/list_vm_snapshots_tests.rb

@@ -0,0 +1,10 @@
+Shindo.tests('Fog::Compute[:vsphere] | list_vm_snapshots request', ['vsphere']) do
+
+  compute = Fog::Compute[:vsphere]
+
+  tests('The response should') do
+    response = compute.list_vm_snapshots('5032c8a5-9c5e-ba7a-3804-832a03e16381')
+    test('be a kind of Array') { response.kind_of? Array }
+    test('it should contains Hashes') { response.all? { |i| Hash === i } }
+  end
+end

data/tests/requests/compute/revert_to_snapshot_tests.rb

@@ -0,0 +1,15 @@
+Shindo.tests('Fog::Compute[:vsphere] | revert_to_snapshot request', ['vsphere']) do
+
+  compute = Fog::Compute[:vsphere]
+
+  tests('The response should') do
+    response = compute.revert_to_snapshot(Fog::Compute::Vsphere::Snapshot.new(:service => 1))
+    test('be a kind of Hash') { response.kind_of? Hash }
+    test('should have a task_state key') { response.key? 'state' }
+  end
+
+  tests('The expected options') do
+    raises(ArgumentError, 'raises ArgumentError when input param is missing') { compute.revert_to_snapshot(nil) }
+  end
+
+end

data/tests/requests/compute/set_vm_customvalue_tests.rb

@@ -0,0 +1,20 @@
+Shindo.tests('Fog::Compute[:vsphere] | set_vm_customvalue request', ['vsphere']) do
+
+  compute = Fog::Compute[:vsphere]
+
+  instance_uuid = '50137835-88a1-436e-768e-9b2677076e67'
+  custom_key = nil
+  custom_value = nil
+
+  tests('The response should') do
+    response = compute.set_vm_customvalue(instance_uuid, custom_key, custom_value)
+    test('be nil') { response.nil? }
+  end
+
+  tests('The expected options') do
+    raises(ArgumentError, 'raises ArgumentError when instance_uuid option is missing') { compute.set_vm_customvalue }
+    raises(ArgumentError, 'raises ArgumentError when custom_key option is missing') { compute.set_vm_customvalue(instance_uuid) }
+    raises(ArgumentError, 'raises ArgumentError when custom_value option is missing') { compute.set_vm_customvalue(instance_uuid, custom_key) }
+  end
+
+end

data/tests/requests/compute/vm_clone_tests.rb

@@ -0,0 +1,50 @@
+Shindo.tests("Fog::Compute[:vsphere] | vm_clone request", 'vsphere') do
+  # require 'guid'
+  compute = Fog::Compute[:vsphere]
+  response = nil
+  response_linked = nil
+
+  template = "rhel64"
+  datacenter = "Solutions"
+
+  tests("Standard Clone | The return value should") do
+    servers_size = compute.servers.size
+    response = compute.vm_clone('datacenter' => datacenter, 'template_path' => template, 'name' => 'cloning_vm', 'wait' => true)
+    test("be a kind of Hash") { response.kind_of? Hash }
+    %w{ vm_ref new_vm task_ref }.each do |key|
+      test("have a #{key} key") { response.key? key }
+    end
+    test("creates a new server") { compute.servers.size == servers_size+1 }
+    test("new server name is set") { compute.get_virtual_machine(response['new_vm']['id'])['name'] == 'cloning_vm' }
+  end
+
+  tests("Standard Clone setting ram and cpu | The return value should") do
+    servers_size = compute.servers.size
+    response = compute.vm_clone('datacenter' => datacenter, 'template_path' => template, 'name' => 'cloning_vm', 'memoryMB' => '8192', 'numCPUs' => '8', 'wait' => true)
+    test("be a kind of Hash") { response.kind_of? Hash }
+    %w{ vm_ref new_vm task_ref }.each do |key|
+      test("have a #{key} key") { response.key? key }
+    end
+    test("creates a new server") { compute.servers.size == servers_size+1 }
+    test("new server name is set") { compute.get_virtual_machine(response['new_vm']['id'])['name'] == 'cloning_vm' }
+  end
+
+  tests("Linked Clone | The return value should") do
+    servers_size = compute.servers.size
+    response = compute.vm_clone('datacenter' => datacenter, 'template_path' => template, 'name' => 'cloning_vm_linked', 'wait' => 1, 'linked_clone' => true)
+    test("be a kind of Hash") { response.kind_of? Hash }
+    %w{ vm_ref new_vm task_ref }.each do |key|
+      test("have a #{key} key") { response.key? key }
+    end
+    test("creates a new server") { compute.servers.size == servers_size+1 }
+    test("new server name is set") { compute.get_virtual_machine(response['new_vm']['id'])['name'] == 'cloning_vm_linked' }
+  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/requests/compute/vm_config_vnc_tests.rb

@@ -0,0 +1,19 @@
+Shindo.tests('Fog::Compute[:vsphere] | vm_config_vnc request', ['vsphere']) do
+
+  compute = Fog::Compute[:vsphere]
+
+  reconfig_target = '50137835-88a1-436e-768e-9b2677076e67'
+  vnc_spec = {:port => '5900', :password => 'ssaaa', :enabled => 'true'}
+
+  tests('The response should') do
+    response = compute.vm_config_vnc('instance_uuid' => reconfig_target).merge(vnc_spec)
+    test('be a kind of Hash') { response.kind_of? Hash }
+    test('should have a task_state key') { response.key? 'task_state' }
+  end
+
+  tests('VNC attrs response should') do
+    response = compute.vm_get_vnc(reconfig_target)
+    test('be a kind of Hash') { response.kind_of? Hash }
+    test('should have a port key') { response.key? :port }
+  end
+end

data/tests/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.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/requests/compute/vm_migrate_tests.rb

@@ -0,0 +1,16 @@
+Shindo.tests('Fog::Compute[:vsphere] | vm_migrate request', ['vsphere']) do
+
+  compute = Fog::Compute[:vsphere]
+
+  powered_on_vm = '50137835-88a1-436e-768e-9b2677076e67'
+
+  tests('The response should') do
+    response = compute.vm_migrate('instance_uuid' => powered_on_vm)
+    test('be a kind of Hash') { response.kind_of? Hash }
+    test('should have a task_state key') { response.key? 'task_state' }
+  end
+
+  tests('The expected options') do
+    raises(ArgumentError, 'raises ArgumentError when instance_uuid option is missing') { compute.vm_migrate }
+  end
+end

data/tests/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.key? 'task_state' }
+    test('should have a power_off_type key') { response.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/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_on('instance_uuid' => powered_off_vm)
+    test('be a kind of Hash') { response.kind_of? Hash }
+    test('should have a task_state key') { response.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

data/tests/requests/compute/vm_reboot_tests.rb

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