beaker-vmware 1.0.0 → 2.1.0

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

data/spec/beaker/hypervisor/vsphere_spec.rb

@@ -2,89 +2,77 @@ require 'spec_helper'
 
 module Beaker
   describe Vsphere do
-
-    before :each do
-      MockVsphereHelper.set_config( fog_file_contents )
-      MockVsphereHelper.set_vms( make_hosts() )
-     stub_const( "VsphereHelper", MockVsphereHelper )
+    before do
+      MockVsphereHelper.set_config(fog_file_contents)
+      MockVsphereHelper.set_vms(make_hosts)
+      stub_const('VsphereHelper', MockVsphereHelper)
     end
 
-    describe "#provision" do
-
-      it 'provisions hosts' do 
+    describe '#provision' do
+      it 'provisions hosts' do
         MockVsphereHelper.powerOff
-        vsphere = Beaker::Vsphere.new( make_hosts(), make_opts )
+        vsphere = Beaker::Vsphere.new(make_hosts, make_opts)
 
         vsphere.provision
 
-        hosts =  vsphere.instance_variable_get( :@hosts )
+        hosts = vsphere.instance_variable_get(:@hosts)
         hosts.each do |host|
-          expect( MockVsphereHelper.find_vm( host.name ).powerState ) == "poweredOn"
+          expect(MockVsphereHelper.find_vm(host.name).powerState)
         end
-        
       end
 
       it 'raises an error if a vm is missing in Vsphere' do
         MockVsphereHelper.powerOff
-        hosts = make_hosts()
+        hosts = make_hosts
         hosts[0][:vmname] = 'unknown'
-        vsphere = Beaker::Vsphere.new( hosts, make_opts )
-
-        expect{ vsphere.provision }.to raise_error
+        vsphere = Beaker::Vsphere.new(hosts, make_opts)
 
+        expect { vsphere.provision }.to raise_error
       end
 
       it 'raises an error if a vm does not have a given snapshot name' do
         MockVsphereHelper.powerOff
-        hosts = make_hosts()
-        hosts[0]["snapshot"] = 'unknown'
-        vsphere = Beaker::Vsphere.new( hosts, make_opts )
-
-        expect{ vsphere.provision }.to raise_error
+        hosts = make_hosts
+        hosts[0]['snapshot'] = 'unknown'
+        vsphere = Beaker::Vsphere.new(hosts, make_opts)
 
+        expect { vsphere.provision }.to raise_error
       end
 
       it 'provisions hosts if no snapshot is provided' do
         MockVsphereHelper.powerOff
-        hosts = make_hosts()
-        hosts[0]["snapshot"] = nil
-        vsphere = Beaker::Vsphere.new( hosts, make_opts )
+        hosts = make_hosts
+        hosts[0]['snapshot'] = nil
+        vsphere = Beaker::Vsphere.new(hosts, make_opts)
 
         vsphere.provision
 
         hosts.each do |host|
-          expect( MockVsphereHelper.find_vm( host.name ).powerState ) == "poweredOn"
+          expect(MockVsphereHelper.find_vm(host.name).powerState)
         end
-
       end
-
     end
 
-    describe "#cleanup" do
-
-      it "cleans up" do
+    describe '#cleanup' do
+      it 'cleans up' do
         MockVsphereHelper.powerOn
-        vsphere = Beaker::Vsphere.new( make_hosts(), make_opts )
+        vsphere = Beaker::Vsphere.new(make_hosts, make_opts)
         vsphere.cleanup
 
-        hosts =  vsphere.instance_variable_get( :@hosts )
+        hosts = vsphere.instance_variable_get(:@hosts)
         hosts.each do |host|
-          expect( MockVsphereHelper.find_vm( host.name ).powerState ) == "poweredOff"
+          expect(MockVsphereHelper.find_vm(host.name).powerState)
         end
       end
 
       it 'raises an error if a vm is missing in Vsphere' do
         MockVsphereHelper.powerOn
-        hosts = make_hosts()
+        hosts = make_hosts
         hosts[0][:vmname] = 'unknown'
-        vsphere = Beaker::Vsphere.new( hosts, make_opts )
-
-        expect{ vsphere.cleanup }.to raise_error
+        vsphere = Beaker::Vsphere.new(hosts, make_opts)
 
+        expect { vsphere.cleanup }.to raise_error
       end
-
     end
-
   end
-
 end

data/spec/mock_fission.rb

@@ -0,0 +1,63 @@
+class Response
+  attr_accessor :code, :message, :data
+
+  def initialize(code = 0, message = '', data = nil)
+    @code = code
+    @message = message
+    @data = data
+  end
+end
+
+class MockFissionVM
+  attr_accessor :name
+
+  @@snaps = []
+  def initialize(name)
+    @name = name
+    @running = true
+  end
+
+  def self.set_snapshots(snaps)
+    @@snaps = snaps
+  end
+
+  def snapshots
+    Response.new(0, '', @@snaps)
+  end
+
+  def revert_to_snapshot(_name)
+    @running = false
+  end
+
+  def running?
+    Response.new(0, '', @running)
+  end
+
+  def start(_opt)
+    @running = true
+  end
+
+  def exists?
+    true
+  end
+end
+
+class MockFission
+  @@vms = []
+  def self.presets(hosts)
+    snaps = []
+    hosts.each do |host|
+      @@vms << MockFissionVM.new(host.name)
+      snaps << host[:snapshot]
+    end
+    MockFissionVM.set_snapshots(snaps)
+  end
+
+  def self.all
+    Response.new(0, '', @@vms)
+  end
+
+  def self.new(name)
+    MockFissionVM.new(name)
+  end
+end