beaker-vcloud 1.0.0 → 2.0.0

data/spec/beaker/hypervisor/vcloud_spec.rb

@@ -2,43 +2,41 @@ require 'spec_helper'
 
 module Beaker
   describe Vcloud do
-
-    before :each do
-      MockVsphereHelper.set_config( fog_file_contents )
-      MockVsphereHelper.set_vms( make_hosts() )
-      stub_const( "VsphereHelper", MockVsphereHelper )
-      stub_const( "Net", MockNet )
-      json = double( 'json' )
-      allow( json ).to receive( :parse ) do |arg|
+    before do
+      MockVsphereHelper.set_config(fog_file_contents)
+      MockVsphereHelper.set_vms(make_hosts)
+      stub_const('VsphereHelper', MockVsphereHelper)
+      stub_const('Net', MockNet)
+      json = double('json')
+      allow(json).to receive(:parse) do |arg|
         arg
       end
-      stub_const( "JSON", json )
-      allow( Socket ).to receive( :getaddrinfo ).and_return( true )
-      allow_any_instance_of( Beaker::Shared ).to receive( :get_fog_credentials ).and_return( fog_file_contents )
-      allow_any_instance_of( VsphereHelper ).to receive( :new ).and_return (MockVsphereHelper)
+      stub_const('JSON', json)
+      allow(Socket).to receive(:getaddrinfo).and_return(true)
+      allow_any_instance_of(Beaker::Shared).to receive(:get_fog_credentials).and_return(fog_file_contents)
+      allow_any_instance_of(VsphereHelper).to receive(:new).and_return(MockVsphereHelper)
     end
 
-    describe "#provision" do
-
+    describe '#provision' do
       it 'warns about deprecated behavior if pooling_api is provided' do
         opts = make_opts
         opts[:pooling_api] = 'testpool'
-        expect( opts[:logger] ).to receive( :warn ).once
-        expect{ Beaker::Vcloud.new( make_hosts, opts ) }.to raise_error( /datacenter/ )
+        expect(opts[:logger]).to receive(:warn).once
+        expect { Beaker::Vcloud.new(make_hosts, opts) }.to raise_error(/datacenter/)
       end
 
       it 'does not instantiate vmpooler if pooling_api is provided' do
         opts = make_opts
         opts[:pooling_api] = 'testpool'
-        expect{ Beaker::Vcloud.new( make_hosts, opts ) }.to raise_error( /datacenter/ )
+        expect { Beaker::Vcloud.new(make_hosts, opts) }.to raise_error(/datacenter/)
       end
 
       it 'ignores pooling_api and instantiates self' do
         opts = make_opts
         opts[:pooling_api] = 'testpool'
         opts[:datacenter] = 'testdatacenter'
-        hypervisor = Beaker::Vcloud.new( make_hosts, opts)
-        expect( hypervisor.class ).to be Beaker::Vcloud
+        hypervisor = Beaker::Vcloud.new(make_hosts, opts)
+        expect(hypervisor.class).to be Beaker::Vcloud
       end
 
       it 'provisions hosts and add them to the pool' do
@@ -48,18 +46,17 @@ module Beaker
         opts[:pooling_api] = nil
         opts[:datacenter] = 'testdc'
 
-        vcloud = Beaker::Vcloud.new( make_hosts, opts )
-        allow( vcloud ).to receive( :require ).and_return( true )
-        allow( vcloud ).to receive( :sleep ).and_return( true )
+        vcloud = Beaker::Vcloud.new(make_hosts, opts)
+        allow(vcloud).to receive(:require).and_return(true)
+        allow(vcloud).to receive(:sleep).and_return(true)
         vcloud.provision
 
-        hosts = vcloud.instance_variable_get( :@hosts )
-        hosts.each do | host |
+        hosts = vcloud.instance_variable_get(:@hosts)
+        hosts.each do |host|
           name = host['vmhostname']
-          vm = MockVsphereHelper.find_vm( name )
-          expect( vm.toolsRunningStatus ).to be === "guestToolsRunning"
+          vm = MockVsphereHelper.find_vm(name)
+          expect(vm.toolsRunningStatus).to be === 'guestToolsRunning'
         end
-
       end
 
       it 'does not run enable_root on cygwin hosts' do
@@ -71,44 +68,37 @@ module Beaker
 
         hosts = make_hosts
         hosts.each do |host|
-          allow( host ).to receive( :is_cygwin? ).and_return( true )
+          allow(host).to receive(:is_cygwin?).and_return(true)
         end
-        vcloud = Beaker::Vcloud.new( hosts, opts )
-        allow( vcloud ).to receive( :require ).and_return( true )
-        allow( vcloud ).to receive( :sleep ).and_return( true )
-        expect( vcloud ).to receive( :enable_root ).never
+        vcloud = Beaker::Vcloud.new(hosts, opts)
+        allow(vcloud).to receive(:require).and_return(true)
+        allow(vcloud).to receive(:sleep).and_return(true)
+        expect(vcloud).not_to receive(:enable_root)
         vcloud.provision
-
       end
-
     end
 
-    describe "#cleanup" do
-
-      it "cleans up hosts not in the pool" do
+    describe '#cleanup' do
+      it 'cleans up hosts not in the pool' do
         MockVsphereHelper.powerOn
 
         opts = make_opts
         opts[:pooling_api] = nil
         opts[:datacenter] = 'testdc'
 
-        vcloud = Beaker::Vcloud.new( make_hosts, opts )
-        allow( vcloud ).to receive( :require ).and_return( true )
-        allow( vcloud ).to receive( :sleep ).and_return( true )
+        vcloud = Beaker::Vcloud.new(make_hosts, opts)
+        allow(vcloud).to receive(:require).and_return(true)
+        allow(vcloud).to receive(:sleep).and_return(true)
         vcloud.provision
         vcloud.cleanup
 
-        hosts = vcloud.instance_variable_get( :@hosts )
-        vm_names = hosts.map {|h| h['vmhostname'] }.compact
-        vm_names.each do | name |
-          vm = MockVsphereHelper.find_vm( name )
-          expect( vm.runtime.powerState ).to be === "poweredOff"
+        hosts = vcloud.instance_variable_get(:@hosts)
+        vm_names = hosts.map { |h| h['vmhostname'] }.compact
+        vm_names.each do |name|
+          vm = MockVsphereHelper.find_vm(name)
+          expect(vm.runtime.powerState).to be === 'poweredOff'
         end
-
       end
-
     end
-
   end
-
 end

data/spec/mock_vsphere.rb

@@ -0,0 +1,284 @@
+class MockRbVmomiSnapshot
+  attr_accessor :name, :rootSnapshotList, :childSnapshotList
+
+  def initialize
+    @name = nil
+    @rootSnapshotList = []
+    @childSnapshotList = []
+  end
+
+  def print_nested_array(arg)
+    str = '[ '
+    arg.each do |arry|
+      if arry.is_a?(Array)
+        str += print_nested_array(arry)
+      elsif arry.is_a?(MockRbVmomiSnapshot)
+        str += arry.to_s + ', '
+      end
+    end
+    str + ' ]'
+  end
+
+  def to_s
+    "Snapshot(name: #{@name}, rootSnapshotlist: #{print_nested_array(@rootSnapshotList)}, childSnapshotList: #{print_nested_array(@childSnapshotList)})"
+  end
+
+  def snapshot
+    self
+  end
+end
+
+class MockRbVmomiVM
+  attr_accessor :snapshot, :name, :state
+
+  def info
+    self
+  end
+
+  def process_snaphash(snaphash)
+    shotlist = []
+    snaphash.each do |name, subsnaps|
+      new_snap = MockRbVmomiSnapshot.new
+      new_snap.name = name
+      new_snap.childSnapshotList = process_snaphash(subsnaps) if subsnaps.is_a?(Hash)
+      shotlist << new_snap
+    end
+    shotlist
+  end
+
+  def get_snapshot(name, snaplist = @snapshot.rootSnapshotList)
+    snapshot = nil
+    snaplist.each do |snap|
+      if snap.is_a?(Array)
+        snapshot = get_snapshot(snap, name)
+      elsif snap.name == name
+        snapshot = snap.snapshot
+      end
+    end
+    snapshot
+  end
+
+  def initialize(name, snaphash)
+    @name = name
+    @snapshot = MockRbVmomiSnapshot.new
+    @snapshot.name = name
+    @snapshot.rootSnapshotList = process_snaphash(snaphash)
+  end
+end
+
+class MockRbVmomiConnection
+  class CustomizationSpecManager
+    class CustomizationSpec
+      def spec
+        true
+      end
+    end
+
+    def initialize
+      @customizationspec = CustomizationSpec.new
+    end
+
+    def GetCustomizationSpec(_arg)
+      @customizationspec
+    end
+  end
+
+  class PropertyCollector
+    class Result
+      def initialize(name, object)
+        @name = name
+        @object = object
+      end
+
+      def val
+        @name
+      end
+
+      def obj
+        @object
+      end
+
+      def propSet
+        [self]
+      end
+    end
+
+    class ResultContainer
+      attr_accessor :token
+
+      def initialize
+        @results = []
+      end
+
+      def objects
+        @results
+      end
+
+      def add_object(obj)
+        @results << obj
+      end
+    end
+
+    def initialize
+      @results = ResultContainer.new
+    end
+
+    def RetrievePropertiesEx(_hash)
+      @results.token = true
+      @results
+    end
+
+    def ContinueRetrievePropertiesEx(_token)
+      @results.token = false
+      @results
+    end
+
+    def add_result(name, object)
+      @results.add_object(Result.new(name, object))
+    end
+
+    def WaitForUpdates(_arg)
+      result = OpenStruct.new
+      result.version = 'version'
+      result
+    end
+
+    def CreateFilter(_arg)
+      filter = OpenStruct.new
+      filter.DestroyPropertyFilter = true
+      filter
+    end
+  end
+
+  class ServiceInstance
+    class Datacenter
+      attr_accessor :vmFolder, :hostFolder
+
+      def initialize
+        @vmFolder = MockRbVmomi::VIM::Folder.new
+        @vmFolder.name = '/root'
+      end
+
+      def find_datastore(_arg)
+        true
+      end
+    end
+
+    def initialize
+      @datacenter = Datacenter.new
+    end
+
+    def find_datacenter(_dc)
+      @datacenter
+    end
+  end
+
+  class ServiceManager
+    class ViewManager
+      def CreateContainerView(hash)
+        @view = hash
+      end
+    end
+
+    def initialize
+      @customizationspecmanager = CustomizationSpecManager.new
+      @viewmanager = ViewManager.new
+    end
+
+    def customizationSpecManager
+      @customizationspecmanager
+    end
+
+    def viewManager
+      @viewmanager
+    end
+
+    def rootFolder
+      '/root'
+    end
+  end
+
+  def initialize(opts)
+    @host = opts[:host]
+    @user = opts[:user]
+    @password = opts[:password]
+    @insecure = opts[:insecure]
+    @serviceinstance = ServiceInstance.new
+    @servicemanager = ServiceManager.new
+    @propertycollector = PropertyCollector.new
+  end
+
+  def serviceInstance
+    @serviceinstance
+  end
+
+  def serviceContent
+    @servicemanager
+  end
+
+  def propertyCollector
+    @propertycollector
+  end
+
+  def set_info(vms)
+    vms.each do |vm|
+      @propertycollector.add_result(vm.name, vm)
+    end
+  end
+end
+
+class MockRbVmomi
+  class VIM
+    class Folder
+      attr_accessor :name
+
+      def find
+        self
+      end
+
+      def childEntity
+        self
+      end
+
+      def resourcePool
+        self
+      end
+
+      def traverse(_path, _type = Object, _create = false)
+        self
+      end
+    end
+
+    class ResourcePool
+      attr_accessor :name
+
+      def find
+        self
+      end
+
+      def resourcePool
+        self
+      end
+    end
+
+    class ClusterComputeResource
+      attr_accessor :name
+
+      def find
+        self
+      end
+
+      def resourcePool
+        self
+      end
+    end
+
+    class TraversalSpec
+      def initialize(hash); end
+    end
+
+    def self.connect(opts)
+      MockRbVmomiConnection.new(opts)
+    end
+  end
+end

data/spec/mock_vsphere_helper.rb

@@ -0,0 +1,167 @@
+class MockVsphereSnapshot
+  attr_accessor :name
+
+  def RevertToSnapshot_Task
+    self
+  end
+
+  def wait_for_completion
+    true
+  end
+end
+
+class MockVsphereVM
+  attr_accessor :name, :powerState, :snapshot, :template, :toolsRunningStatus
+
+  def initialize
+    @powerState = 'poweredOff'
+    @toolsRunningStatus = 'guestToolsStopped'
+    @first = true
+  end
+
+  def runtime
+    self
+  end
+
+  attr_reader :powerState
+
+  def toolsRunningStatus
+    prev = @toolsRunningStatus
+    @toolsRunningStatus = 'guestToolsRunning'
+    prev
+  end
+
+  def PowerOnVM_Task
+    @powerState = 'poweredOn'
+    self
+  end
+
+  def PowerOffVM_Task
+    @powerState = 'poweredOff'
+    self
+  end
+
+  def summary
+    self
+  end
+
+  def guest
+    self
+  end
+
+  def ipAddress
+    @toolsRunningStatus = 'guestToolsRunning'
+    "#{@name}.ip.address"
+  end
+
+  def CloneVM_Task(opts)
+    clone = MockVsphereVM.new
+    clone.name = opts[:name]
+    clone.snapshot = snapshot
+    clone.template = template
+    clone.PowerOnVM_Task
+    MockVsphereHelper.add_vm(opts[:name], clone)
+    clone
+  end
+
+  def wait_for_completion
+    true
+  end
+
+  def Destroy_Task
+    true
+  end
+end
+
+class MockVsphereHelper
+  @@fog_file = {}
+  @@vms = {}
+
+  def initialize(arg); end
+
+  def self.add_vm(name, vm)
+    @@vms[name] = vm
+  end
+
+  def self.set_config(conf)
+    @@fog_file = conf
+  end
+
+  def self.powerOn
+    @@vms.each do |_name, vm|
+      vm.powerState = 'poweredOn'
+    end
+  end
+
+  def self.powerOff
+    @@vms.each do |_name, vm|
+      vm.powerState = 'poweredOff'
+    end
+  end
+
+  def self.set_vms(hosts)
+    @@vms = {}
+    hosts.each do |host|
+      vm = MockVsphereVM.new
+      vm.name = host.name
+      vm.snapshot = MockVsphereSnapshot.new
+      vm.snapshot.name = host[:snapshot]
+      @@vms[host.name] = vm
+      template = MockVsphereVM.new
+      template.name = host[:template]
+      template.snapshot = MockVsphereSnapshot.new
+      template.snapshot.name = host[:snapshot]
+      @@vms[host[:template]] = template
+    end
+  end
+
+  def self.load_config(_file)
+    @@fog_file
+  end
+
+  def find_vms(keys)
+    found = {}
+    keys = ([] << keys)
+    keys.flatten!
+    keys.each do |key|
+      found[key] = @@vms[key] if @@vms.has_key?(key)
+    end
+    found
+  end
+
+  def self.find_vm(key)
+    return unless @@vms.has_key?(key)
+
+    @@vms[key]
+  end
+
+  def find_snapshot(vm, snap)
+    return unless @@vms[vm.name].snapshot.name == snap
+
+    @@vms[vm.name].snapshot
+  end
+
+  def find_customization(_template)
+    nil
+  end
+
+  def find_datastore(_dc, datastore)
+    datastore
+  end
+
+  def find_pool(_dc, pool)
+    pool
+  end
+
+  def find_folder(_dc, folder)
+    folder
+  end
+
+  def wait_for_tasks(_tasks, _try, _attempts)
+    true
+  end
+
+  def close
+    true
+  end
+end

data/spec/spec_helper.rb

@@ -1,7 +1,32 @@
-require 'simplecov'
-require 'rspec/its'
 require 'beaker'
-require 'beaker/hypervisor/vcloud'
+require 'mock_vsphere'
+require 'mock_vsphere_helper'
+
+begin
+  require 'simplecov'
+  require 'simplecov-console'
+  require 'codecov'
+rescue LoadError
+  # Do nothing if no required gem installed
+else
+  SimpleCov.start do
+    track_files 'lib/**/*.rb'
+
+    add_filter '/spec'
+    # do not track vendored files
+    add_filter '/vendor'
+    add_filter '/.vendor'
+
+    enable_coverage :branch
+  end
+
+  SimpleCov.formatters = [
+    SimpleCov::Formatter::Console,
+    SimpleCov::Formatter::Codecov,
+  ]
+end
+
+Dir['./lib/beaker/hypervisor/*.rb'].sort.each { |file| require file }
 
 # setup & require beaker's spec_helper.rb
 beaker_gem_spec = Gem::Specification.find_by_name('beaker')