fog-vsphere 2.1.1 → 2.2.0

data/lib/fog/vsphere/requests/compute/vm_relocate.rb

@@ -15,15 +15,15 @@ module Fog
         #       hash with diskId wich is key attribute of volume,
         #       and datastore to relocate to.
         def vm_relocate(options = {})
-          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
 
           # Find the VM Object
           search_filter = { :uuid => options['instance_uuid'], 'vmSearch' => true, 'instanceUuid' => true }
           vm_mob_ref = connection.searchIndex.FindAllByUuid(search_filter).first
 
-          unless vm_mob_ref.kind_of? RbVmomi::VIM::VirtualMachine
+          unless vm_mob_ref.is_a? RbVmomi::VIM::VirtualMachine
             raise Fog::Vsphere::Errors::NotFound,
-              "Could not find VirtualMachine with instance uuid #{options['instance_uuid']}"
+                  "Could not find VirtualMachine with instance uuid #{options['instance_uuid']}"
           end
           options['host'] = get_raw_host(options['host'], options['cluster'], options['datacenter']) if options['host']
           if options['disks']
@@ -33,11 +33,11 @@ module Fog
             end
           end
           spec = RbVmomi::VIM::VirtualMachineRelocateSpec(
-            :pool => options['pool'],
-            :host => options['host'],
-            :disk => options['disks']
+            pool: options['pool'],
+            host: options['host'],
+            disk: options['disks']
           )
-          task = vm_mob_ref.RelocateVM_Task(:spec => spec, :priority => options["priority"])
+          task = vm_mob_ref.RelocateVM_Task(spec: spec, priority: options['priority'])
           task.wait_for_completion
           { 'task_state' => task.info.state }
         end
@@ -45,7 +45,7 @@ module Fog
 
       class Mock
         def vm_relocate(options = {})
-          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
           { 'task_state' => 'success' }
         end
       end

data/lib/fog/vsphere/requests/compute/vm_remove_snapshot.rb

@@ -5,7 +5,7 @@ module Fog
         def vm_remove_snapshot(vm_id, snapshot_id, remove_children = false)
           vm = servers.get(vm_id)
           snapshot = vm.snapshots.get(snapshot_id).mo_ref
-          task = snapshot.RemoveSnapshot_Task(:removeChildren => remove_children)
+          task = snapshot.RemoveSnapshot_Task(removeChildren: remove_children)
 
           task.wait_for_completion
 
@@ -17,7 +17,7 @@ module Fog
       end
 
       class Mock
-        def vm_remove_snapshot(vm_id, snapshot_id)
+        def vm_remove_snapshot(_vm_id, _snapshot_id)
           {
             'task_state' => 'success',
             'was_cancelled' => false

data/lib/fog/vsphere/requests/compute/vm_rename.rb

@@ -3,10 +3,10 @@ module Fog
     class Vsphere
       class Real
         def vm_rename(options = {})
-          raise ArgumentError, "name is a required parameter" unless options.key? 'name'
-          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          raise ArgumentError, 'name is a required parameter' unless options.key? 'name'
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
           vm_mob_ref = get_vm_ref(options['instance_uuid'])
-          task = vm_mob_ref.Rename_Task(:newName => options['name'])
+          task = vm_mob_ref.Rename_Task(newName: options['name'])
           task.wait_for_completion
           { 'task_state' => task.info.state }
         end
@@ -14,8 +14,8 @@ module Fog
 
       class Mock
         def vm_rename(options = {})
-          raise ArgumentError, "name is a required parameter" unless options.key? 'name'
-          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
+          raise ArgumentError, 'name is a required parameter' unless options.key? 'name'
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
           { 'task_state' => 'success' }
         end
       end

data/lib/fog/vsphere/requests/compute/vm_revert_snapshot.rb

@@ -17,7 +17,7 @@ module Fog
       end
 
       class Mock
-        def vm_revert_snapshot(vm_id, snapshot_id)
+        def vm_revert_snapshot(_vm_id, _snapshot_id)
           {
             'task_state' => 'success',
             'was_cancelled' => false

data/lib/fog/vsphere/requests/compute/vm_take_snapshot.rb

@@ -3,14 +3,14 @@ module Fog
     class Vsphere
       class Real
         def vm_take_snapshot(options = {})
-          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
-          raise ArgumentError, "name is a required parameter" unless options.key? 'name'
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
+          raise ArgumentError, 'name is a required parameter' unless options.key? 'name'
           vm = get_vm_ref(options['instance_uuid'])
           task = vm.CreateSnapshot_Task(
-            :name => options['name'],
-            :description => options['description'] || '',
-            :memory => options['memory'] || true,
-            :quiesce => options['quiesce'] || false
+            name: options['name'],
+            description: options['description'] || '',
+            memory: options['memory'] || true,
+            quiesce: options['quiesce'] || false
           )
 
           task.wait_for_completion
@@ -24,8 +24,8 @@ module Fog
 
       class Mock
         def vm_take_snapshot(options = {})
-          raise ArgumentError, "instance_uuid is a required parameter" unless options.key? 'instance_uuid'
-          raise ArgumentError, "name is a required parameter" unless options.key? 'name'
+          raise ArgumentError, 'instance_uuid is a required parameter' unless options.key? 'instance_uuid'
+          raise ArgumentError, 'name is a required parameter' unless options.key? 'name'
           {
             'task_state' => 'success',
             'was_cancelled' => false

data/lib/fog/vsphere/version.rb

@@ -1,5 +1,5 @@
 module Fog
   module Vsphere
-    VERSION = '2.1.1'.freeze
+    VERSION = '2.2.0'.freeze
   end
 end

data/tests/compute_tests.rb

@@ -1,8 +1,7 @@
 Shindo.tests('Fog::Compute[:vsphere]', ['vsphere']) do
-
   compute = Fog::Compute[:vsphere]
 
-  tests("| convert_vm_mob_ref_to_attr_hash") do
+  tests('| convert_vm_mob_ref_to_attr_hash') do
     # Mock the RbVmomi::VIM::ManagedObject class
     class MockManagedObject
       attr_reader :parent, :_ref
@@ -11,42 +10,42 @@ Shindo.tests('Fog::Compute[:vsphere]', ['vsphere']) do
         @parent = @_ref = 'vm-123'
       end
 
-      def collect! *pathSet
+      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.send(:convert_vm_mob_ref_to_attr_hash, fake_vm_mob_ref).kind_of? Hash
+    tests('When converting an incomplete vm object') do
+      test('it should return a Hash') do
+        compute.send(:convert_vm_mob_ref_to_attr_hash, fake_vm_mob_ref).is_a? Hash
       end
-      tests("The converted Hash should") do
+      tests('The converted Hash should') do
         attr_hash = compute.send(: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? }
+        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
+    tests('When passed a nil object') do
       attr_hash = compute.send :convert_vm_mob_ref_to_attr_hash, nil
-      test("it should return a nil object") do
+      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|
+  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|
+  tests('Compute collections') do
+    %w[servers].each do |collection|
       test("it should respond to #{collection}") { compute.respond_to? collection }
     end
   end

data/tests/helpers/mock_helper.rb

@@ -2,8 +2,8 @@ Fog.mock! if ENV['FOG_MOCK'] == 'true'
 
 if Fog.mock?
   Fog.credentials = {
-    :vsphere_server   => 'fake_vsphere_server',
-    :vsphere_username => 'fake_vsphere_username',
-    :vsphere_password => 'fake_vsphere_password'
+    vsphere_server: 'fake_vsphere_server',
+    vsphere_username: 'fake_vsphere_username',
+    vsphere_password: 'fake_vsphere_password'
   }.merge(Fog.credentials)
 end

data/tests/models/compute/cluster_tests.rb

@@ -1,19 +1,18 @@
 Shindo.tests('Fog::Compute[:vsphere] | cluster collection', ['vsphere']) do
-
   compute = Fog::Compute[:vsphere]
 
   tests('Cluster collection') do
     clusters = compute.datacenters.first.clusters
 
-    test('should not be empty') { not clusters.empty? }
-    test('should be a kind of Fog::Compute::Vsphere::Clusters') { clusters.kind_of? Fog::Compute::Vsphere::Clusters }
+    test('should not be empty') { !clusters.empty? }
+    test('should be a kind of Fog::Compute::Vsphere::Clusters') { clusters.is_a? Fog::Compute::Vsphere::Clusters }
     test('should get a cluster') { clusters.get('Solutionscluster').id == '1d4d9a3f-e4e8-4c40-b7fc-263850068fa4' }
   end
 
   tests('A cluster should') do
     cluster = compute.datacenters.first.clusters.get('Solutionscluster')
 
-    test('have datastores') { cluster.datastores.first.kind_of? Fog::Compute::Vsphere::Datastore }
-    test('have networks') { cluster.networks.first.kind_of? Fog::Compute::Vsphere::Network }
+    test('have datastores') { cluster.datastores.first.is_a? Fog::Compute::Vsphere::Datastore }
+    test('have networks') { cluster.networks.first.is_a? Fog::Compute::Vsphere::Network }
   end
 end

data/tests/models/compute/hosts_tests.rb

@@ -1,13 +1,11 @@
 Shindo.tests('Fog::Compute[:vsphere] | hosts collection', ['vsphere']) do
-
   compute = Fog::Compute[:vsphere]
   cluster = compute.datacenters.first.clusters.get('Solutionscluster')
   hosts = cluster.hosts
 
   tests('The hosts collection') do
-    test('should not be empty') { not hosts.empty? }
-    test('should be a kind of Fog::Compute::Vsphere::Hosts') { hosts.kind_of? Fog::Compute::Vsphere::Hosts }
+    test('should not be empty') { !hosts.empty? }
+    test('should be a kind of Fog::Compute::Vsphere::Hosts') { hosts.is_a? Fog::Compute::Vsphere::Hosts }
     test('should get hosts') { hosts.get('host1.example.com').name == 'host1.example.com' }
   end
-
 end

data/tests/models/compute/rules_tests.rb

@@ -1,34 +1,28 @@
 Shindo.tests('Fog::Compute[:vsphere] | rules collection', ['vsphere']) do
-  
   compute = Fog::Compute[:vsphere]
   cluster = compute.datacenters.first.clusters.get('Solutionscluster')
   servers = compute.servers
   rules = cluster.rules
-  
+
   tests('The rules collection') do
-    test('should not be empty') { not rules.empty? }
-    test('should be a kind of Fog::Compute::Vsphere::Rules') { rules.kind_of? Fog::Compute::Vsphere::Rules }
+    test('should not be empty') { !rules.empty? }
+    test('should be a kind of Fog::Compute::Vsphere::Rules') { rules.is_a? Fog::Compute::Vsphere::Rules }
     test('should get rules') { rules.get('anti-affinity-foo').key == 4242 }
     test('should destroy rules') { rules.first.destroy; rules.reload; rules.empty? }
     test('should create rules') do
-      r = rules.new({
-        name: 'affinity-foo',
-        enabled: true,
-        type: RbVmomi::VIM::ClusterAffinityRuleSpec
-      })
+      r = rules.new(name: 'affinity-foo',
+                    enabled: true,
+                    type: RbVmomi::VIM::ClusterAffinityRuleSpec)
       r.vms = [servers.get('5032c8a5-9c5e-ba7a-3804-832a03e16381'), servers.get('502916a3-b42e-17c7-43ce-b3206e9524dc')]
       r.save
       rules.reload
       rules.get('affinity-foo').key > 0
     end
     raises(ArgumentError, 'should not create rules with <2 vms') do
-      rules.create({
-        name: 'affinity-foo',
-        enabled: true,
-        type: RbVmomi::VIM::ClusterAffinityRuleSpec,
-        vm_ids: ['5032c8a5-9c5e-ba7a-3804-832a03e16381']
-      })
+      rules.create(name: 'affinity-foo',
+                   enabled: true,
+                   type: RbVmomi::VIM::ClusterAffinityRuleSpec,
+                   vm_ids: ['5032c8a5-9c5e-ba7a-3804-832a03e16381'])
     end
   end
-  
 end

data/tests/models/compute/server_tests.rb

@@ -5,71 +5,70 @@ Shindo.tests('Fog::Compute[:vsphere] | server model', ['vsphere']) do
   tests('The server model should') do
     tests('have the action') do
       test('reload') { server.respond_to? 'reload' }
-      %w(stop suspend destroy reboot).each do |action|
+      %w[stop suspend destroy reboot].each do |action|
         test(action) { server.respond_to? action }
         test("#{action} returns successfully") { server.send(action.to_sym) ? true : false }
       end
       test('start') { server.respond_to?('start') }
-      test("start returns false, because it is already poweredOn") { server.start ? true : false }
+      test('start returns false, because it is already poweredOn') { server.start ? true : false }
       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 }
+        test('responds') { server.respond_to? 'take_snapshot' }
+        test('returns successfully') { server.take_snapshot('name' => 'foobar').is_a? Hash }
       end
       test('snapshots') do
-        test('responds') { server.respond_to? 'snapshots'}
-        test('returns successfully') { server.snapshots.kind_of? Fog::Compute::Vsphere::Snapshots }
+        test('responds') { server.respond_to? 'snapshots' }
+        test('returns successfully') { server.snapshots.is_a? Fog::Compute::Vsphere::Snapshots }
       end
       test('find_snapshot') do
-        test('responds') { server.respond_to? 'find_snapshot'}
+        test('responds') { server.respond_to? 'find_snapshot' }
         test('returns successfully') do
-          server.find_snapshot('snapshot-0101').kind_of? Fog::Compute::Vsphere::Snapshot
+          server.find_snapshot('snapshot-0101').is_a? 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'}
+        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 correct input given') { server.revert_snapshot('snapshot-0101').is_a? Hash }
           test('when incorrect input given') do
             raises(ArgumentError) { server.revert_snapshot(1) }
           end
         end
       end
       test('tickets') do
-        test('acquire ticket successfully') { server.acquire_ticket.kind_of? Fog::Compute::Vsphere::Ticket }
+        test('acquire ticket successfully') { server.acquire_ticket.is_a? Fog::Compute::Vsphere::Ticket }
       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 = %i[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 }
+          test(attribute.to_s) { server.respond_to? attribute }
         end
       end
-      tests("The attributes hash should have key") do
+      tests('The attributes hash should have key') do
         attributes.each do |attribute|
-          test("#{attribute}") { model_attribute_hash.key? attribute }
+          test(attribute.to_s) { model_attribute_hash.key? attribute }
         end
       end
     end
-    test('be a kind of Fog::Compute::Vsphere::Server') { server.kind_of? Fog::Compute::Vsphere::Server }
+    test('be a kind of Fog::Compute::Vsphere::Server') { server.is_a? Fog::Compute::Vsphere::Server }
   end
-
 end

data/tests/models/compute/servers_tests.rb

@@ -1,15 +1,13 @@
 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 }
+    test('should not be empty') { !servers.empty? }
+    test('should be a kind of Fog::Compute::Vsphere::Servers') { servers.is_a? 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 'jefftest' }
       tests('by instance uuid').succeeds { servers.get '5032c8a5-9c5e-ba7a-3804-832a03e16381' }
     end
   end
-
 end

data/tests/models/compute/ticket_tests.rb

@@ -1,14 +1,12 @@
 Shindo.tests('Fog::Compute[:vsphere] | hosts collection', ['vsphere']) do
-
   servers = Fog::Compute[:vsphere].servers
   server = servers.last
   ticket = server.acquire_ticket
 
   tests('A ticket') do
-    test('should have a ticket') { not ticket.ticket.empty? }
-    test('should have a host') { not ticket.host.empty? }
-    test('should have a port') { ticket.port.kind_of?(Integer) }
-    test('should have a ssl ssl_thumbprint') { not ticket.ssl_thumbprint.empty? }
+    test('should have a ticket') { !ticket.ticket.empty? }
+    test('should have a host') { !ticket.host.empty? }
+    test('should have a port') { ticket.port.is_a?(Integer) }
+    test('should have a ssl ssl_thumbprint') { !ticket.ssl_thumbprint.empty? }
   end
-
 end