fog 1.36.0 → 1.37.0

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

@@ -1,15 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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/vsphere/requests/compute/get_network_tests.rb

@@ -1,48 +0,0 @@
-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/vsphere/requests/compute/list_child_snapshots_tests.rb

@@ -1,10 +0,0 @@
-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/vsphere/requests/compute/list_clusters_tests.rb

@@ -1,11 +0,0 @@
-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/vsphere/requests/compute/list_virtual_machines_tests.rb

@@ -1,38 +0,0 @@
-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/vsphere/requests/compute/list_vm_snapshots_tests.rb

@@ -1,10 +0,0 @@
-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/vsphere/requests/compute/revert_to_snapshot_tests.rb

@@ -1,15 +0,0 @@
-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/vsphere/requests/compute/set_vm_customvalue_tests.rb

@@ -1,20 +0,0 @@
-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/vsphere/requests/compute/vm_clone_tests.rb

@@ -1,50 +0,0 @@
-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/vsphere/requests/compute/vm_config_vnc_tests.rb

@@ -1,19 +0,0 @@
-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/vsphere/requests/compute/vm_destroy_tests.rb

@@ -1,17 +0,0 @@
-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/vsphere/requests/compute/vm_migrate_tests.rb

@@ -1,16 +0,0 @@
-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/vsphere/requests/compute/vm_power_off_tests.rb

@@ -1,26 +0,0 @@
-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/vsphere/requests/compute/vm_power_on_tests.rb

@@ -1,17 +0,0 @@
-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/vsphere/requests/compute/vm_reboot_tests.rb

@@ -1,26 +0,0 @@
-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

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

@@ -1,19 +0,0 @@
-Shindo.tests('Fog::Compute[:vsphere] | vm_reconfig_cpus request', ['vsphere']) do
-
-  compute = Fog::Compute[:vsphere]
-
-  reconfig_target = '50137835-88a1-436e-768e-9b2677076e67'
-  reconfig_spec = 2
-
-  tests('The response should') do
-    response = compute.vm_reconfig_cpus('instance_uuid' => reconfig_target, 'cpus' => reconfig_spec)
-    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_reconfig_cpus('cpus' => reconfig_spec) }
-    raises(ArgumentError, 'raises ArgumentError when cpus option is missing') { compute.vm_reconfig_cpus('instance_uuid' => reconfig_target) }
-  end
-
-end

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

@@ -1,19 +0,0 @@
-Shindo.tests('Fog::Compute[:vsphere] | vm_reconfig_hardware request', ['vsphere']) do
-
-  compute = Fog::Compute[:vsphere]
-
-  reconfig_target = '50137835-88a1-436e-768e-9b2677076e67'
-  reconfig_spec = {'guestId' => 'rhel5_64Guest'}
-
-  tests('The response should') do
-    response = compute.vm_reconfig_hardware('instance_uuid' => reconfig_target, 'hardware_spec' => reconfig_spec)
-    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_reconfig_hardware('hardware_spec' => reconfig_spec) }
-    raises(ArgumentError, 'raises ArgumentError when hardware_spec option is missing') { compute.vm_reconfig_hardware('instance_uuid' => reconfig_target) }
-  end
-
-end

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

@@ -1,19 +0,0 @@
-Shindo.tests('Fog::Compute[:vsphere] | vm_reconfig_memory request', ['vsphere']) do
-
-  compute = Fog::Compute[:vsphere]
-
-  reconfig_target = '50137835-88a1-436e-768e-9b2677076e67'
-  reconfig_spec = 4096
-
-  tests('The response should') do
-    response = compute.vm_reconfig_memory('instance_uuid' => reconfig_target, 'memory' => reconfig_spec)
-    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_reconfig_memory('memory' => reconfig_spec) }
-    raises(ArgumentError, 'raises ArgumentError when memory option is missing') { compute.vm_reconfig_memory('instance_uuid' => reconfig_target) }
-  end
-
-end

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

@@ -1,19 +0,0 @@
-Shindo.tests('Fog::Compute[:vsphere] | vm_take_snapshot request', ['vsphere']) do
-
-  compute = Fog::Compute[:vsphere]
-
-  powered_off_vm = nil
-
-  tests('The response should') do
-    response = compute.vm_take_snapshot('instance_uuid' => powered_off_vm, 'name' => 'foobar')
-    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 was_cancelled key') { response.key? 'was_cancelled' }
-  end
-
-  tests('The expected options') do
-    raises(ArgumentError, 'raises ArgumentError when instance_uuid option is missing') { compute.vm_take_snapshot('name' => 'foobar') }
-    raises(ArgumentError, 'raises ArgumentError when name option is missing') { compute.vm_take_snapshot('instance_uuid' => powered_off_vm) }
-  end
-
-end