fog-vsphere 3.6.4 → 3.6.6

data/tests/requests/compute/list_virtual_machines_tests.rb

@@ -0,0 +1,34 @@
+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.is_a? 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].is_a? 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_cdroms_tests.rb

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

data/tests/requests/compute/list_vm_snapshots_tests.rb

@@ -0,0 +1,9 @@
+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.is_a? Array }
+    test('it should contains Hashes') { response.all? { |i| Hash === i } }
+  end
+end

data/tests/requests/compute/modify_vm_cdrom_tests.rb

@@ -0,0 +1,20 @@
+Shindo.tests('Fog::Compute[:vsphere] | modify_vm_cdrom request', ['vsphere']) do
+  compute = Fog::Compute[:vsphere]
+
+  modify_target = '5032c8a5-9c5e-ba7a-3804-832a03e16381'
+  modify_cdrom = compute.cdroms.new(
+    instance_uuid: modify_target
+  )
+
+  tests('When adding a cdrom the response should') do
+    response = compute.add_vm_cdrom(modify_cdrom)
+    test('be a kind of Hash') { response.is_a? Hash }
+    test('should have a task_state key') { response.key? 'task_state' }
+  end
+
+  tests('When destroying a cdrom the response should') do
+    response = compute.destroy_vm_cdrom(modify_cdrom)
+    test('be a kind of Hash') { response.is_a? Hash }
+    test('should have a task_state key') { response.key? 'task_state' }
+  end
+end

data/tests/requests/compute/revert_to_snapshot_tests.rb

@@ -0,0 +1,13 @@
+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::Vsphere::Compute::Snapshot.new(service: 1))
+    test('be a kind of Hash') { response.is_a? 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,18 @@
+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/update_vm_tests.rb

@@ -0,0 +1,13 @@
+require 'ostruct'
+
+Shindo.tests('Fog::Compute[:vsphere] | update_vm request', 'vsphere') do
+  compute = Fog::Compute[:vsphere]
+  server = Fog::Vsphere::Compute::Server.new
+
+  tests('UPDATE vm | The return value should') do
+    response = compute.update_vm(server)
+    test('be a kind of Hash') { response.is_a? Hash }
+    test('should have a task_state key') { response.key? 'task_state' }
+    test('be a kind of Hash') { response.is_a? Hash }
+  end
+end

data/tests/requests/compute/vm_clone_tests.rb

@@ -0,0 +1,55 @@
+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'
+  default_params = {
+    'datacenter' => datacenter,
+    'template_path' => template,
+    'resource_pool' => ['Solutionscluster', 'Resources']
+  }
+
+  tests('Standard Clone | The return value should') do
+    servers_size = compute.servers.size
+    response = compute.vm_clone(default_params.merge('name' => 'cloning_vm', 'wait' => true))
+    test('be a kind of Hash') { response.is_a? 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(default_params.merge('name' => 'cloning_vm', 'memoryMB' => '8192', 'numCPUs' => '8', 'wait' => true))
+    test('be a kind of Hash') { response.is_a? 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(default_params.merge('name' => 'cloning_vm_linked', 'wait' => 1, 'linked_clone' => true))
+    test('be a kind of Hash') { response.is_a? 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::Vsphere::Compute::NotFound, 'it should raise Fog::Vsphere::Compute::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,18 @@
+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.is_a? 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.is_a? Hash }
+    test('should have a port key') { response.key? :port }
+  end
+end

data/tests/requests/compute/vm_destroy_tests.rb

@@ -0,0 +1,14 @@
+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.is_a? 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,15 @@
+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.is_a? 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,24 @@
+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.is_a? 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,15 @@
+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.is_a? 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,24 @@
+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.is_a? 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/requests/compute/vm_reconfig_cdrom_tests.rb

@@ -0,0 +1,14 @@
+Shindo.tests('Fog::Compute[:vsphere] | vm_reconfig_cdrom request', ['vsphere']) do
+  compute = Fog::Compute[:vsphere]
+
+  reconfig_target = '5032c8a5-9c5e-ba7a-3804-832a03e16381'
+  reconfig_spec = {
+    'start_connected' => false
+  }
+
+  tests('the response should') do
+    response = compute.vm_reconfig_cdrom('instance_uuid' => reconfig_target, 'hardware_spec' => reconfig_spec)
+    test('be a kind of Hash') { response.is_a? Hash }
+    test('should have a task_state key') { response.key? 'task_state' }
+  end
+end

data/tests/requests/compute/vm_reconfig_cpus_tests.rb

@@ -0,0 +1,17 @@
+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.is_a? 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/requests/compute/vm_reconfig_hardware_tests.rb

@@ -0,0 +1,17 @@
+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.is_a? 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/requests/compute/vm_reconfig_memory_tests.rb

@@ -0,0 +1,17 @@
+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.is_a? 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/requests/compute/vm_suspend_tests.rb

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

data/tests/requests/compute/vm_take_snapshot_tests.rb

@@ -0,0 +1,17 @@
+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.is_a? 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

data/tests/test_helper.rb

@@ -0,0 +1,74 @@
+require 'mocha/minitest'
+require 'vcr'
+require 'webmock/minitest'
+
+VCR.configure do |config|
+  config.cassette_library_dir = "tests/fixtures/vcr_cassettes/6_7"
+  config.hook_into :webmock
+  config.default_cassette_options = { match_requests_on: [:body] }
+end
+
+# Makes these parameters available to the cassettes for easier recording
+module Fog
+  module Vsphere
+    # Allows to skip writing of shared examples.
+    module VCRCasseteFilterShared
+      def record_http_interaction(interaction)
+        @shared_cassette ||= VCR::Cassette.new('shared', erb: TestConfig.load.to_h)
+        return if @shared_cassette.http_interactions.has_interaction_matching?(interaction.request)
+        interaction.request.uri = "https://<%= vsphere_server %>/sdk"
+        super(interaction)
+      end
+    end
+    ::VCR::Cassette.send(:prepend, VCRCasseteFilterShared)
+
+    module TestHelper
+      def prepare_compute
+        Fog::Compute.new(TestConfig.load.to_h.merge(provider: 'vsphere'))
+      end
+
+      # Records new cassette, but before writing removes the examples already in *shared* cassette.
+      def recording_webmock_cassette(name, options = {}, &block)
+        WebMock::Config.instance.net_http_connect_on_start = true
+        VCR.use_cassette(name, options, &block)
+      ensure
+        WebMock::Config.instance.net_http_connect_on_start = false
+      end
+
+      def with_webmock_cassette(name, options = {}, &block)
+        VCR.use_cassette('shared', erb: TestConfig.load.to_h, allow_playback_repeats: true) do
+          VCR.use_cassette(name, options.merge(erb: TestConfig.load.to_h), &block)
+        end
+      end
+    end
+
+    class TestConfig
+      FILE = File.join(File.dirname(__FILE__), 'vsphere_config.yml')
+      ATTRIBUTES = %w[server username password rev expected_pubkey_hash].freeze
+      DEFAULTS = {
+        vsphere_server: '127.0.0.1',
+        vsphere_username: 'Administrator@example.com',
+        vsphere_password: 'StrongAdminPassword'
+      }.freeze
+
+      def self.load
+        @loaded ||= new(File.exist?(FILE) ? YAML.load_file(FILE) : DEFAULTS)
+      end
+
+      def initialize(config = {})
+        @config = parse(config)
+      end
+
+      def to_h
+        @config.dup
+      end
+
+      def parse(config, prefix = 'vsphere')
+        ATTRIBUTES.each_with_object({}) do |attr_name, parsed|
+          full_name = "#{prefix}_#{attr_name}"
+          parsed[full_name.to_sym] = config[full_name.to_sym] || config[full_name] || config[attr_name]
+        end
+      end
+    end
+  end
+end