fog-vsphere 1.7.0 → 1.7.0.1

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,66 +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 start 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('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.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

@@ -0,0 +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') { !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

data/tests/models/compute/tickets_tests.rb

@@ -0,0 +1,8 @@
+Shindo.tests('Fog::Compute[:vsphere] | hosts collection', ['vsphere']) do
+  service = Fog::Compute[:vsphere]
+  server = service.servers.last
+
+  tests('The tickets collection') do
+    test('should create a ticket for a server') { service.tickets(server: server).create.is_a? Fog::Compute::Vsphere::Ticket }
+  end
+end

data/tests/requests/compute/current_time_tests.rb

@@ -1,12 +1,10 @@
 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('be a kind of Hash') { response.is_a? 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 }
+    test('have a current_time key with a Time value') { response['current_time'].is_a? Time }
   end
-
 end

data/tests/requests/compute/folder_destroy_tests.rb

@@ -1,21 +1,19 @@
 Shindo.tests('Fog::Compute[:vsphere] | folder_destroy request', ['vsphere']) do
-
   compute = Fog::Compute[:vsphere]
 
-  empty_folder = "/Solutions/empty"
-  full_folder  = "/Solutions/wibble"
-  datacenter   = "Solutions"
+  empty_folder = '/Solutions/empty'
+  full_folder  = '/Solutions/wibble'
+  datacenter   = 'Solutions'
 
   tests('The response should') do
     response = compute.folder_destroy(empty_folder, datacenter)
-    test('be a kind of Hash') { response.kind_of? Hash }
+    test('be a kind of Hash') { response.is_a? Hash }
     test('should have a task_state key') { response.key? 'task_state' }
   end
-  
+
   tests('When folder is not empty') do
     raises(Fog::Vsphere::Errors::ServiceError, 'raises ServiceError') do
       compute.folder_destroy(full_folder, datacenter)
     end
   end
-
 end

data/tests/requests/compute/get_network_tests.rb

@@ -1,50 +1,46 @@
 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
+    def initialize(attrs)
       @name = attrs.fetch(:name)
       @dvs_name = attrs.fetch(:dvs_name)
     end
 
     def config
-      OpenStruct.new( :distributedVirtualSwitch => OpenStruct.new(:name => dvs_name))
+      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'),
-                  ]
-
+  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'){
+    test('choose the network based on network name and dvs name') do
       finder = compute.send(:choose_finder, 'web1', 'dvs11')
-      found_network = fake_networks.find{ |n| finder.call(n) }
+      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'){
+    end
+    test('choose the network based on network name and any dvs') do
       finder = compute.send(:choose_finder, 'web1', :dvs)
-      found_network = fake_networks.find{ |n| finder.call(n) }
+      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'){
+    end
+    test('choose the network based on network name only') do
       finder = compute.send(:choose_finder, 'other', nil)
-      found_network = fake_networks.find{ |n| finder.call(n) }
+      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'){
+    end
+    test('choose the network based on network name only for non-dvs') do
       finder = compute.send(:choose_finder, 'non-dvs', nil)
-      found_network = fake_networks.find{ |n| finder.call(n) }
+      found_network = fake_networks.find { |n| finder.call(n) }
       found_network.name == 'non-dvs' && found_network.class.name.to_s == 'OpenStruct'
-    }
+    end
   end
 end

data/tests/requests/compute/list_child_snapshots_tests.rb

@@ -1,10 +1,9 @@
 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('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_clusters_tests.rb

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

data/tests/requests/compute/list_datastores_tests.rb

@@ -1,18 +1,17 @@
 Shindo.tests('Fog::Compute[:vsphere] | list_datastores request', ['vsphere']) do
-
   compute = Fog::Compute[:vsphere]
 
   tests('The response with datastore filter should') do
-    response = compute.list_datastores(:datacenter => 'Solutions')
-    test('be a kind of Array') { response.kind_of? Array }
+    response = compute.list_datastores(datacenter: 'Solutions')
+    test('be a kind of Array') { response.is_a? Array }
     test('contain Hashes') { response.all? { |i| Hash === i } }
-    test("have 2 elements") {response.length == 2}
+    test('have 2 elements') { response.length == 2 }
   end
 
   tests('The response with cluster filter should') do
-    response = compute.list_datastores(:datacenter => 'Solutions', :cluster => 'Solutionscluster')
-    test('be a kind of Array') { response.kind_of? Array }
+    response = compute.list_datastores(datacenter: 'Solutions', cluster: 'Solutionscluster')
+    test('be a kind of Array') { response.is_a? Array }
     test('contain Hashes') { response.all? { |i| Hash === i } }
-    test("have a single element") {response.length == 1}
+    test('have a single element') { response.length == 1 }
   end
 end

data/tests/requests/compute/list_hosts_tests.rb

@@ -1,11 +1,10 @@
 Shindo.tests('Fog::Compute[:vsphere] | list_hosts request', ['vsphere']) do
-
   compute = Fog::Compute[:vsphere]
 
   tests('The response should') do
-    response = compute.list_hosts(:datacenter => 'Solutions', :cluster => 'Solutionscluster')
-    test('be a kind of Array') { response.kind_of? Array }
+    response = compute.list_hosts(datacenter: 'Solutions', cluster: 'Solutionscluster')
+    test('be a kind of Array') { response.is_a? Array }
     test('contain Hashes') { response.all? { |i| Hash === i } }
-    test("have 1 element") {response.length == 1}
+    test('have 1 element') { response.length == 1 }
   end
 end

data/tests/requests/compute/list_networks_tests.rb

@@ -1,18 +1,17 @@
 Shindo.tests('Fog::Compute[:vsphere] | list_networks request', ['vsphere']) do
-
   compute = Fog::Compute[:vsphere]
 
   tests('The response with datastore filter should') do
-    response = compute.list_networks(:datacenter => 'Solutions')
-    test('be a kind of Array') { response.kind_of? Array }
+    response = compute.list_networks(datacenter: 'Solutions')
+    test('be a kind of Array') { response.is_a? Array }
     test('contain Hashes') { response.all? { |i| Hash === i } }
-    test("have 2 elements") {response.length == 2}
+    test('have 2 elements') { response.length == 2 }
   end
 
   tests('The response with cluster filter should') do
-    response = compute.list_networks(:datacenter => 'Solutions', :cluster => 'Solutionscluster')
-    test('be a kind of Array') { response.kind_of? Array }
+    response = compute.list_networks(datacenter: 'Solutions', cluster: 'Solutionscluster')
+    test('be a kind of Array') { response.is_a? Array }
     test('contain Hashes') { response.all? { |i| Hash === i } }
-    test("have a single element") {response.length == 1}
+    test('have a single element') { response.length == 1 }
   end
 end

data/tests/requests/compute/list_storage_pods_test.rb

@@ -1,10 +1,9 @@
 Shindo.tests('Fog::Compute[:vsphere] | list_storage_pods request', ['vsphere']) do
-  tests("When listing all storage pods") do
-
+  tests('When listing all storage pods') do
     response = Fog::Compute[:vsphere].list_storage_pods
 
-    tests("The response data format ...") do
-      test("be a kind of Hash") { response.kind_of? Array }
+    tests('The response data format ...') do
+      test('be a kind of Hash') { response.is_a? Array }
     end
   end
 end

data/tests/requests/compute/list_virtual_machines_tests.rb

@@ -1,38 +1,34 @@
 Shindo.tests('Fog::Compute[:vsphere] | list_virtual_machines request', ['vsphere']) do
-
-  tests("When listing all machines") 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 }
+    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
-
+  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('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' }
+      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('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? }
+        tests('The response should') do
+          test('be empty') { response.empty? }
         end
       end
     end
   end
-
 end