beaker-vmware 0.3.0 → 2.0.0

data/lib/beaker/hypervisor/vsphere_helper.rb

@@ -3,12 +3,12 @@ require 'rbvmomi'
 require 'beaker/logger'
 
 class VsphereHelper
-  def initialize vInfo
+  def initialize(vInfo)
     @logger = vInfo[:logger] || Beaker::Logger.new
-    @connection = RbVmomi::VIM.connect :host     => vInfo[:server],
-                                       :user     => vInfo[:user],
-                                       :password => vInfo[:pass],
-                                       :insecure => true
+    @connection = RbVmomi::VIM.connect host: vInfo[:server],
+                                       user: vInfo[:user],
+                                       password: vInfo[:pass],
+                                       insecure: true
   end
 
   def self.load_config(dot_fog = '.fog')
@@ -19,121 +19,121 @@ class VsphereHelper
     vsphere_credentials[:user]   = default[:vsphere_username]
     vsphere_credentials[:pass]   = default[:vsphere_password]
 
-    return vsphere_credentials
+    vsphere_credentials
   end
 
-  def find_snapshot vm, snapname
-    if vm.snapshot
-      search_child_snaps vm.snapshot.rootSnapshotList, snapname
-    else
-      raise "vm #{vm.name} has no snapshots to revert to"
-    end
+  def find_snapshot(vm, snapname)
+    raise "vm #{vm.name} has no snapshots to revert to" unless vm.snapshot
+
+    search_child_snaps vm.snapshot.rootSnapshotList, snapname
   end
 
-  def search_child_snaps tree, snapname
+  def search_child_snaps(tree, snapname)
     snapshot = nil
     tree.each do |child|
-      if child.name == snapname
-        snapshot ||= child.snapshot
-      else
-        snapshot ||= search_child_snaps child.childSnapshotList, snapname
-      end
+      snapshot ||= if child.name == snapname
+                     child.snapshot
+                   else
+                     search_child_snaps child.childSnapshotList, snapname
+                   end
     end
     snapshot
   end
 
-  def find_customization name
+  def find_customization(name)
     csm = @connection.serviceContent.customizationSpecManager
 
     begin
-      customizationSpec = csm.GetCustomizationSpec({:name => name}).spec
-    rescue
+      customizationSpec = csm.GetCustomizationSpec({ name: name }).spec
+    rescue StandardError
       customizationSpec = nil
     end
 
-    return customizationSpec
+    customizationSpec
   end
 
   # an easier wrapper around the horrid PropertyCollector interface,
   # necessary for searching VMs in all Datacenters that may be nested
   # within folders of arbitrary depth
   # returns a hash array of <name> => <VirtualMachine ManagedObjects>
-  def find_vms names, connection = @connection
-    names = names.is_a?(Array) ? names : [ names ]
+  def find_vms(names, connection = @connection)
+    names = [names] unless names.is_a?(Array)
     containerView = get_base_vm_container_from connection
     propertyCollector = connection.propertyCollector
 
     objectSet = [{
-      :obj => containerView,
-      :skip => true,
-      :selectSet => [ RbVmomi::VIM::TraversalSpec.new({
-          :name => 'gettingTheVMs',
-          :path => 'view',
-          :skip => false,
-          :type => 'ContainerView'
-      }) ]
+      obj: containerView,
+      skip: true,
+      selectSet: [RbVmomi::VIM::TraversalSpec.new({
+                                                    name: 'gettingTheVMs',
+                                                    path: 'view',
+                                                    skip: false,
+                                                    type: 'ContainerView',
+                                                  })],
     }]
 
     propSet = [{
-      :pathSet => [ 'name' ],
-      :type => 'VirtualMachine'
+      pathSet: ['name'],
+      type: 'VirtualMachine',
     }]
 
     results = propertyCollector.RetrievePropertiesEx({
-      :specSet => [{
-        :objectSet => objectSet,
-        :propSet   => propSet
-      }],
-      :options => { :maxObjects => nil }
-    })
+                                                       specSet: [{
+                                                         objectSet: objectSet,
+                                                         propSet: propSet,
+                                                       }],
+                                                       options: { maxObjects: nil },
+                                                     })
 
     vms = {}
     results.objects.each do |result|
       name = result.propSet.first.val
       next unless names.include? name
+
       vms[name] = result.obj
     end
 
-    while results.token do
-      results = propertyCollector.ContinueRetrievePropertiesEx({:token => results.token})
+    while results.token
+      results = propertyCollector.ContinueRetrievePropertiesEx({ token: results.token })
       results.objects.each do |result|
         name = result.propSet.first.val
         next unless names.include? name
+
         vms[name] = result.obj
       end
     end
     vms
   end
 
-  def find_datastore(dc,datastorename)
+  def find_datastore(dc, datastorename)
     datacenter = @connection.serviceInstance.find_datacenter(dc)
     datacenter.find_datastore(datastorename)
   end
 
-  def find_folder(dc,foldername)
+  def find_folder(dc, foldername)
     datacenter = @connection.serviceInstance.find_datacenter(dc)
     base = datacenter.vmFolder.traverse(foldername)
-    if base != nil
-      base
-    else
+    if base.nil?
       abort "Failed to find folder #{foldername}"
+    else
+      base
     end
   end
 
-  def find_pool(dc,poolname)
+  def find_pool(dc, poolname)
     datacenter = @connection.serviceInstance.find_datacenter(dc)
     base = datacenter.hostFolder
     pools = poolname.split('/')
     pools.each do |pool|
       case base
-        when RbVmomi::VIM::Folder
-          base = base.childEntity.find { |f| f.name == pool }
-        when RbVmomi::VIM::ClusterComputeResource
-          base = base.resourcePool.resourcePool.find { |f| f.name == pool }
-        when RbVmomi::VIM::ResourcePool
-          base = base.resourcePool.find { |f| f.name == pool }
-        else
-          abort "Unexpected object type encountered (#{base.class}) while finding resource pool"
+      when RbVmomi::VIM::Folder
+        base = base.childEntity.find { |f| f.name == pool }
+      when RbVmomi::VIM::ClusterComputeResource
+        base = base.resourcePool.resourcePool.find { |f| f.name == pool }
+      when RbVmomi::VIM::ResourcePool
+        base = base.resourcePool.find { |f| f.name == pool }
+      else
+        abort "Unexpected object type encountered (#{base.class}) while finding resource pool"
       end
     end
 
@@ -141,43 +141,41 @@ class VsphereHelper
     base
   end
 
-  def get_base_vm_container_from connection
+  def get_base_vm_container_from(connection)
     viewManager = connection.serviceContent.viewManager
     viewManager.CreateContainerView({
-      :container => connection.serviceContent.rootFolder,
-      :recursive => true,
-      :type      => [ 'VirtualMachine' ]
-    })
+                                      container: connection.serviceContent.rootFolder,
+                                      recursive: true,
+                                      type: ['VirtualMachine'],
+                                    })
   end
 
-  def wait_for_tasks tasks, try, attempts
-    obj_set = tasks.map { |task| { :obj => task } }
+  def wait_for_tasks(tasks, try, attempts)
+    obj_set = tasks.map { |task| { obj: task } }
     filter = @connection.propertyCollector.CreateFilter(
-      :spec => {
-        :propSet => [{ :type => 'Task',
-                       :all  => false,
-                       :pathSet => ['info.state']}],
-        :objectSet => obj_set
+      spec: {
+        propSet: [{ type: 'Task',
+                    all: false,
+                    pathSet: ['info.state'], }],
+        objectSet: obj_set,
       },
-      :partialUpdates => false
+      partialUpdates: false,
     )
     ver = ''
     while true
-      result = @connection.propertyCollector.WaitForUpdates(:version => ver)
+      result = @connection.propertyCollector.WaitForUpdates(version: ver)
       ver = result.version
       complete = 0
       tasks.each do |task|
-        if ['success', 'error'].member? task.info.state
-          complete += 1
-        end
-      end
-      break if (complete == tasks.length)
-      if try <= attempts
-        sleep 5
-        try += 1
-      else
-        raise "unable to complete Vsphere tasks before timeout"
+        complete += 1 if %w[success error].member? task.info.state
       end
+      break if complete == tasks.length
+
+      raise 'unable to complete Vsphere tasks before timeout' unless try <= attempts
+
+      sleep 5
+      try += 1
+
     end
 
     filter.DestroyPropertyFilter
@@ -188,4 +186,3 @@ class VsphereHelper
     @connection.close
   end
 end
-

data/lib/beaker-vmware/version.rb

@@ -1,3 +1,3 @@
 module BeakerVmware
-  VERSION = '0.3.0'
+  VERSION = '2.0.0'
 end

data/spec/beaker/hypervisor/fusion_spec.rb

@@ -2,40 +2,38 @@ require 'spec_helper'
 
 module Beaker
   describe Fusion do
-    let( :fusion ) { Beaker::Fusion.new( @hosts, make_opts ) }
-
-    before :each do
-     stub_const( "Fission::VM", true )
-      @hosts = make_hosts()
-      MockFission.presets( @hosts )
-      allow_any_instance_of( Fusion ).to receive( :require ).with( 'fission' ).and_return( true )
-      fusion.instance_variable_set( :@fission, MockFission ) 
+    let(:fusion) { Beaker::Fusion.new(@hosts, make_opts) }
+
+    before do
+      stub_const('Fission::VM', true)
+      @hosts = make_hosts
+      MockFission.presets(@hosts)
+      allow_any_instance_of(Fusion).to receive(:require).with('fission').and_return(true)
+      fusion.instance_variable_set(:@fission, MockFission)
     end
 
-    it "can interoperate with the fission library to provision hosts"  do
+    it 'can interoperate with the fission library to provision hosts' do
       fusion.provision
     end
 
-    it "raises an error if unknown snapshot name is used" do
+    it 'raises an error if unknown snapshot name is used' do
       @hosts[0][:snapshot] = 'unknown'
-      expect{ fusion.provision }.to raise_error
+      expect { fusion.provision }.to raise_error
     end
 
     it 'raises an error if snapshots is nil' do
       MockFissionVM.set_snapshots(nil)
-      expect{ fusion.provision }.to raise_error(/No snapshots available/)
+      expect { fusion.provision }.to raise_error(/No snapshots available/)
     end
 
     it 'raises an error if snapshots are empty' do
       MockFissionVM.set_snapshots([])
-      expect{ fusion.provision }.to raise_error(/No snapshots available/)
+      expect { fusion.provision }.to raise_error(/No snapshots available/)
     end
 
     it 'host fails init with nil snapshot' do
       @hosts[0][:snapshot] = nil
-      expect{ Beaker::Fusion.new( @hosts, make_opts) }.to raise_error(/specify a snapshot/)
+      expect { Beaker::Fusion.new(@hosts, make_opts) }.to raise_error(/specify a snapshot/)
     end
-
   end
-
 end

data/spec/beaker/hypervisor/vsphere_helper_spec.rb

@@ -2,162 +2,158 @@ require 'spec_helper'
 
 module Beaker
   describe VsphereHelper do
-    let( :logger )         { double('logger').as_null_object }
-    let( :vInfo )          { { :server => "vsphere.labs.net", :user => "vsphere@labs.com", :pass => "supersekritpassword" } }
-    let( :vsphere_helper ) { VsphereHelper.new ( vInfo.merge( { :logger => logger } ) ) }
-    let( :snaplist )       { { 'snap1' => { 'snap1sub1' => nil ,
-                                            'snap1sub2' => nil },
-                               'snap2' => nil,
-                               'snap3' => { 'snap3sub1' => nil ,
-                                            'snap3sub2' => nil ,
-                                            'snap3sub3' => nil } } }
-    let( :vms )            {  [ MockRbVmomiVM.new( 'mockvm1', snaplist ),
-                                MockRbVmomiVM.new( 'mockvm2', snaplist ),
-                                MockRbVmomiVM.new( 'mockvm3', snaplist ) ] }
-
-    before :each do
-     stub_const( "RbVmomi", MockRbVmomi )
+    let(:logger) { double('logger').as_null_object }
+    let(:vInfo) do
+      { server: 'vsphere.labs.net', user: 'vsphere@labs.com', pass: 'supersekritpassword' }
+    end
+    let(:vsphere_helper) { VsphereHelper.new(vInfo.merge({ logger: logger })) }
+    let(:snaplist)       do
+      { 'snap1' => { 'snap1sub1' => nil,
+                     'snap1sub2' => nil, },
+        'snap2' => nil,
+        'snap3' => { 'snap3sub1' => nil,
+                     'snap3sub2' => nil,
+                     'snap3sub3' => nil, }, }
+    end
+    let(:vms) do
+      [MockRbVmomiVM.new('mockvm1', snaplist),
+       MockRbVmomiVM.new('mockvm2', snaplist),
+       MockRbVmomiVM.new('mockvm3', snaplist),]
     end
 
-    describe "#load_config" do
+    before do
+      stub_const('RbVmomi', MockRbVmomi)
+    end
 
+    describe '#load_config' do
       it 'can load a .fog file' do
-        allow( File ).to receive( :exist? ).and_return( true )
-        allow( YAML ).to receive( :load_file ).and_return( fog_file_contents )
-
-        expect( VsphereHelper.load_config ).to be === vInfo
+        allow(File).to receive(:exist?).and_return(true)
+        allow(YAML).to receive(:load_file).and_return(fog_file_contents)
 
+        expect(VsphereHelper.load_config).to be === vInfo
       end
 
       it 'raises an error when the .fog file is missing' do
-        allow( File ).to receive( :exist? ).and_return( false )
-
-        expect{ VsphereHelper.load_config }.to raise_error( ArgumentError )
+        allow(File).to receive(:exist?).and_return(false)
 
+        expect { VsphereHelper.load_config }.to raise_error(ArgumentError)
       end
-
     end
 
-   describe "#find_snapshot" do
-     it 'can find a given snapshot name' do
-       mockvm = MockRbVmomiVM.new( 'mockvm', snaplist )
-
-       expect( vsphere_helper.find_snapshot( mockvm, 'snap2' ) ).to be === mockvm.get_snapshot( 'snap2' )
-
-     end
-
-   end
+    describe '#find_snapshot' do
+      it 'can find a given snapshot name' do
+        mockvm = MockRbVmomiVM.new('mockvm', snaplist)
 
-   describe "#find_customization" do
-     it 'returns the customization spec' do
-
-       expect( vsphere_helper.find_customization( 'name' ) ).to be === true
-
-     end
-
-   end
-
-   describe "#find_vms" do
-     it 'finds the list of vms' do
-       connection = vsphere_helper.instance_variable_get( :@connection )
-       connection.set_info( vms )
-
-       expect( vsphere_helper.find_vms( 'mockvm1' ) ).to be === {vms[0].name => vms[0]}
-     end
+        expect(vsphere_helper.find_snapshot(mockvm, 'snap2')).to be === mockvm.get_snapshot('snap2')
+      end
+    end
 
-     it 'returns {} when no vm is found' do
-       connection = vsphere_helper.instance_variable_get( :@connection )
-       connection.set_info( vms )
+    describe '#find_customization' do
+      it 'returns the customization spec' do
+        expect(vsphere_helper.find_customization('name')).to be === true
+      end
+    end
 
-       expect( vsphere_helper.find_vms( 'novm' ) ).to be === {}
-     end
+    describe '#find_vms' do
+      it 'finds the list of vms' do
+        connection = vsphere_helper.instance_variable_get(:@connection)
+        connection.set_info(vms)
 
-   end
+        expect(vsphere_helper.find_vms('mockvm1')).to be === { vms[0].name => vms[0] }
+      end
 
-   describe "#find_datastore" do
-     it 'finds the datastore from the connection object' do
-       connection = vsphere_helper.instance_variable_get( :@connection )
-       dc = connection.serviceInstance.find_datacenter('testdc')
-       expect(vsphere_helper.find_datastore( dc,'datastorename' ) ).to be === true
-     end
+      it 'returns {} when no vm is found' do
+        connection = vsphere_helper.instance_variable_get(:@connection)
+        connection.set_info(vms)
 
-   end
+        expect(vsphere_helper.find_vms('novm')).to be === {}
+      end
+    end
 
-   describe "#find_folder" do
-     it 'can find a folder in the datacenter' do
-       connection = vsphere_helper.instance_variable_get( :@connection )
-       expect(vsphere_helper.find_folder( 'testdc','root' ) ).to be === connection.serviceInstance.find_datacenter('testdc').vmFolder
-     end
+    describe '#find_datastore' do
+      it 'finds the datastore from the connection object' do
+        connection = vsphere_helper.instance_variable_get(:@connection)
+        dc = connection.serviceInstance.find_datacenter('testdc')
+        expect(vsphere_helper.find_datastore(dc, 'datastorename')).to be === true
+      end
+    end
 
-   end
+    describe '#find_folder' do
+      it 'can find a folder in the datacenter' do
+        connection = vsphere_helper.instance_variable_get(:@connection)
+        expect(vsphere_helper.find_folder('testdc',
+                                          'root')).to be === connection.serviceInstance.find_datacenter('testdc').vmFolder
+      end
+    end
 
-   describe "#find_pool" do
-     it 'can find a pool in a folder in the datacenter' do
-       connection = vsphere_helper.instance_variable_get( :@connection )
-       dc = connection.serviceInstance.find_datacenter('testdc')
-       dc.hostFolder = MockRbVmomi::VIM::Folder.new
-       dc.hostFolder.name = "/root"
+    describe '#find_pool' do
+      it 'can find a pool in a folder in the datacenter' do
+        connection = vsphere_helper.instance_variable_get(:@connection)
+        dc = connection.serviceInstance.find_datacenter('testdc')
+        dc.hostFolder = MockRbVmomi::VIM::Folder.new
+        dc.hostFolder.name = '/root'
 
-       expect(vsphere_helper.find_pool( 'testdc','root' ) ).to be === connection.serviceInstance.find_datacenter('testdc').hostFolder
+        expect(vsphere_helper.find_pool('testdc',
+                                        'root')).to be === connection.serviceInstance.find_datacenter('testdc').hostFolder
+      end
 
-     end
-     it 'can find a pool in a clustercomputeresource in the datacenter' do
-       connection = vsphere_helper.instance_variable_get( :@connection )
-       dc = connection.serviceInstance.find_datacenter('testdc')
-       dc.hostFolder = MockRbVmomi::VIM::ClusterComputeResource.new
-       dc.hostFolder.name = "/root"
+      it 'can find a pool in a clustercomputeresource in the datacenter' do
+        connection = vsphere_helper.instance_variable_get(:@connection)
+        dc = connection.serviceInstance.find_datacenter('testdc')
+        dc.hostFolder = MockRbVmomi::VIM::ClusterComputeResource.new
+        dc.hostFolder.name = '/root'
 
-       expect(vsphere_helper.find_pool( 'testdc','root' ) ).to be === connection.serviceInstance.find_datacenter('testdc').hostFolder
-     end
-     it 'can find a pool in a resourcepool in the datacenter' do
-       connection = vsphere_helper.instance_variable_get( :@connection )
-       dc = connection.serviceInstance.find_datacenter('testdc')
-       dc.hostFolder = MockRbVmomi::VIM::ResourcePool.new
-       dc.hostFolder.name = "/root"
+        expect(vsphere_helper.find_pool('testdc',
+                                        'root')).to be === connection.serviceInstance.find_datacenter('testdc').hostFolder
+      end
 
-       expect(vsphere_helper.find_pool( 'testdc','root' ) ).to be === connection.serviceInstance.find_datacenter('testdc').hostFolder
-     end
+      it 'can find a pool in a resourcepool in the datacenter' do
+        connection = vsphere_helper.instance_variable_get(:@connection)
+        dc = connection.serviceInstance.find_datacenter('testdc')
+        dc.hostFolder = MockRbVmomi::VIM::ResourcePool.new
+        dc.hostFolder.name = '/root'
 
-   end
+        expect(vsphere_helper.find_pool('testdc',
+                                        'root')).to be === connection.serviceInstance.find_datacenter('testdc').hostFolder
+      end
+    end
 
-   describe "#wait_for_tasks" do
-     it "can wait for tasks to error" do
-       allow( vsphere_helper ).to receive( :sleep ).and_return( true )
-       vms.each do |vm|
-         vm.info.state = 'error'
-       end
+    describe '#wait_for_tasks' do
+      it 'can wait for tasks to error' do
+        allow(vsphere_helper).to receive(:sleep).and_return(true)
+        vms.each do |vm|
+          vm.info.state = 'error'
+        end
 
-       expect(vsphere_helper.wait_for_tasks( vms, 0, 5 ) ).to be === vms
-     end
+        expect(vsphere_helper.wait_for_tasks(vms, 0, 5)).to be === vms
+      end
 
-     it "can wait for tasks to succeed" do
-       allow( vsphere_helper ).to receive( :sleep ).and_return( true )
-       vms.each do |vm|
-         vm.info.state = 'success'
-       end
+      it 'can wait for tasks to succeed' do
+        allow(vsphere_helper).to receive(:sleep).and_return(true)
+        vms.each do |vm|
+          vm.info.state = 'success'
+        end
 
-       expect(vsphere_helper.wait_for_tasks( vms, 0, 5 ) ).to be === vms
-     end
+        expect(vsphere_helper.wait_for_tasks(vms, 0, 5)).to be === vms
+      end
 
-     it "errors when tasks fail to error/success before timing out" do
-       allow( vsphere_helper ).to receive( :sleep ).and_return( true )
-       vms.each do |vm|
-         vm.info.state = 'nope'
-       end
+      it 'errors when tasks fail to error/success before timing out' do
+        allow(vsphere_helper).to receive(:sleep).and_return(true)
+        vms.each do |vm|
+          vm.info.state = 'nope'
+        end
 
-       expect{ vsphere_helper.wait_for_tasks( vms, 0, 5 ) }.to raise_error
-     end
+        expect { vsphere_helper.wait_for_tasks(vms, 0, 5) }.to raise_error
+      end
+    end
 
-   end
+    describe '#close' do
+      it 'closes the connection' do
+        connection = vsphere_helper.instance_variable_get(:@connection)
+        expect(connection).to receive(:close).once
 
-   describe "#close" do
-     it 'closes the connection' do
-       connection = vsphere_helper.instance_variable_get( :@connection )
-       expect( connection ).to receive( :close ).once
-       
-       vsphere_helper.close
-     end
-   end
-
- end
+        vsphere_helper.close
+      end
+    end
+  end
 end