From d1c86eaf9b8fc1945213dad009db1172dffac7f2 Mon Sep 17 00:00:00 2001
From: Gene Liverman <gene.liverman+06301990@puppet.com>
Date: Mon, 29 Nov 2021 16:09:15 -0500
Subject: [PATCH] Move vsphere provider to its own gem

---
 lib/vmpooler.rb                     |    1 -
 lib/vmpooler/pool_manager.rb        |    8 +-
 lib/vmpooler/providers/vsphere.rb   | 1172 ---------
 scripts/create_template_deltas.rb   |   98 -
 spec/rbvmomi_helper.rb              |  922 -------
 spec/spec_helper.rb                 |    2 -
 spec/unit/pool_manager_spec.rb      |   60 +-
 spec/unit/providers/vsphere_spec.rb | 3589 ---------------------------
 spec/unit/providers_spec.rb         |   25 +-
 vmpooler.gemspec                    |    1 -
 10 files changed, 21 insertions(+), 5857 deletions(-)
 delete mode 100644 lib/vmpooler/providers/vsphere.rb
 delete mode 100755 scripts/create_template_deltas.rb
 delete mode 100644 spec/rbvmomi_helper.rb
 delete mode 100644 spec/unit/providers/vsphere_spec.rb

diff --git a/lib/vmpooler.rb b/lib/vmpooler.rb
index 7d39f18..7bd7c22 100644
--- a/lib/vmpooler.rb
+++ b/lib/vmpooler.rb
@@ -7,7 +7,6 @@ module Vmpooler
   require 'net/ldap'
   require 'open-uri'
   require 'pickup'
-  require 'rbvmomi'
   require 'redis'
   require 'set'
   require 'sinatra/base'
diff --git a/lib/vmpooler/pool_manager.rb b/lib/vmpooler/pool_manager.rb
index 1c9551e..7c8c727 100644
--- a/lib/vmpooler/pool_manager.rb
+++ b/lib/vmpooler/pool_manager.rb
@@ -628,7 +628,7 @@ module Vmpooler
     end
 
     # @return [Array] - a list of used providers from the config file, defaults to the default providers
-    # ie. ["vsphere", "dummy"]
+    # ie. ["dummy"]
     def used_providers
       pools = config[:pools] || []
       @used_providers ||= (pools.map { |pool| pool[:provider] || pool['provider'] }.compact + default_providers).uniq
@@ -638,7 +638,7 @@ module Vmpooler
     # note: vsphere is the default if user does not specify although this should not be
     # if vsphere is to no longer be loaded by default please remove
     def default_providers
-      @default_providers ||= %w[vsphere dummy]
+      @default_providers ||= %w[dummy]
     end
 
     def get_pool_name_for_vm(vm_name, redis)
@@ -1561,8 +1561,8 @@ module Vmpooler
       # Set default provider for all pools that do not have one defined
       $config[:pools].each do |pool|
         if pool['provider'].nil?
-          $logger.log('d', "[!] Setting provider for pool '#{pool['name']}' to 'vsphere' as default")
-          pool['provider'] = 'vsphere'
+          $logger.log('d', "[!] Setting provider for pool '#{pool['name']}' to 'dummy' as default")
+          pool['provider'] = 'dummy'
         end
       end
 
diff --git a/lib/vmpooler/providers/vsphere.rb b/lib/vmpooler/providers/vsphere.rb
deleted file mode 100644
index 1933f64..0000000
--- a/lib/vmpooler/providers/vsphere.rb
+++ /dev/null
@@ -1,1172 +0,0 @@
-# frozen_string_literal: true
-
-require 'vmpooler/providers/base'
-require 'bigdecimal'
-require 'bigdecimal/util'
-
-module Vmpooler
-  class PoolManager
-    class Provider
-      class VSphere < Vmpooler::PoolManager::Provider::Base
-        # The connection_pool method is normally used only for testing
-        attr_reader :connection_pool
-
-        def initialize(config, logger, metrics, redis_connection_pool, name, options)
-          super(config, logger, metrics, redis_connection_pool, name, options)
-
-          task_limit = global_config[:config].nil? || global_config[:config]['task_limit'].nil? ? 10 : global_config[:config]['task_limit'].to_i
-          # The default connection pool size is:
-          # Whatever is biggest from:
-          #   - How many pools this provider services
-          #   - Maximum number of cloning tasks allowed
-          #   - Need at least 2 connections so that a pool can have inventory functions performed while cloning etc.
-          default_connpool_size = [provided_pools.count, task_limit, 2].max
-          connpool_size = provider_config['connection_pool_size'].nil? ? default_connpool_size : provider_config['connection_pool_size'].to_i
-          # The default connection pool timeout should be quite large - 60 seconds
-          connpool_timeout = provider_config['connection_pool_timeout'].nil? ? 60 : provider_config['connection_pool_timeout'].to_i
-          logger.log('d', "[#{name}] ConnPool - Creating a connection pool of size #{connpool_size} with timeout #{connpool_timeout}")
-          @connection_pool = Vmpooler::PoolManager::GenericConnectionPool.new(
-            metrics: metrics,
-            connpool_type: 'provider_connection_pool',
-            connpool_provider: name,
-            size: connpool_size,
-            timeout: connpool_timeout
-          ) do
-            logger.log('d', "[#{name}] Connection Pool - Creating a connection object")
-            # Need to wrap the vSphere connection object in another object. The generic connection pooler will preserve
-            # the object reference for the connection, which means it cannot "reconnect" by creating an entirely new connection
-            # object.  Instead by wrapping it in a Hash, the Hash object reference itself never changes but the content of the
-            # Hash can change, and is preserved across invocations.
-            new_conn = connect_to_vsphere
-            { connection: new_conn }
-          end
-          @provider_hosts = {}
-          @provider_hosts_lock = Mutex.new
-          @redis = redis_connection_pool
-        end
-
-        # name of the provider class
-        def name
-          'vsphere'
-        end
-
-        def folder_configured?(folder_title, base_folder, configured_folders, whitelist)
-          return true if whitelist&.include?(folder_title)
-          return false unless configured_folders.keys.include?(folder_title)
-          return false unless configured_folders[folder_title] == base_folder
-
-          true
-        end
-
-        def destroy_vm_and_log(vm_name, vm_object, pool, data_ttl)
-          try = 0 if try.nil?
-          max_tries = 3
-          @redis.with_metrics do |redis|
-            redis.multi
-            redis.srem("vmpooler__completed__#{pool}", vm_name)
-            redis.hdel("vmpooler__active__#{pool}", vm_name)
-            redis.hset("vmpooler__vm__#{vm_name}", 'destroy', Time.now)
-
-            # Auto-expire metadata key
-            redis.expire("vmpooler__vm__#{vm_name}", (data_ttl * 60 * 60))
-            redis.exec
-          end
-
-          start = Time.now
-
-          if vm_object.is_a? RbVmomi::VIM::Folder
-            logger.log('s', "[!] [#{pool}] '#{vm_name}' is a folder, bailing on destroying")
-            raise('Expected VM, but received a folder object')
-          end
-          vm_object.PowerOffVM_Task.wait_for_completion if vm_object.runtime&.powerState && vm_object.runtime.powerState == 'poweredOn'
-          vm_object.Destroy_Task.wait_for_completion
-
-          finish = format('%<time>.2f', time: Time.now - start)
-          logger.log('s', "[-] [#{pool}] '#{vm_name}' destroyed in #{finish} seconds")
-          metrics.timing("destroy.#{pool}", finish)
-        rescue RuntimeError
-          raise
-        rescue StandardError => e
-          try += 1
-          logger.log('s', "[!] [#{pool}] failed to destroy '#{vm_name}' with an error: #{e}")
-          try >= max_tries ? raise : retry
-        end
-
-        def destroy_folder_and_children(folder_object)
-          vms = {}
-          data_ttl = $config[:redis]['data_ttl'].to_i
-          folder_name = folder_object.name
-          unless folder_object.childEntity.count == 0
-            folder_object.childEntity.each do |vm|
-              vms[vm.name] = vm
-            end
-
-            vms.each do |vm_name, vm_object|
-              destroy_vm_and_log(vm_name, vm_object, folder_name, data_ttl)
-            end
-          end
-          destroy_folder(folder_object)
-        end
-
-        def destroy_folder(folder_object)
-          try = 0 if try.nil?
-          max_tries = 3
-          logger.log('s', "[-] [#{folder_object.name}] removing unconfigured folder")
-          folder_object.Destroy_Task.wait_for_completion
-        rescue StandardError
-          try += 1
-          try >= max_tries ? raise : retry
-        end
-
-        def purge_unconfigured_folders(base_folders, configured_folders, whitelist)
-          @connection_pool.with_metrics do |pool_object|
-            connection = ensured_vsphere_connection(pool_object)
-
-            base_folders.each do |base_folder|
-              folder_children = get_folder_children(base_folder, connection)
-              next if folder_children.empty?
-
-              folder_children.each do |folder_hash|
-                folder_hash.each do |folder_title, folder_object|
-                  destroy_folder_and_children(folder_object) unless folder_configured?(folder_title, base_folder, configured_folders, whitelist)
-                end
-              end
-            end
-          end
-        end
-
-        def get_folder_children(folder_name, connection)
-          folders = []
-
-          propSpecs = { # rubocop:disable Naming/VariableName
-            entity: self,
-            inventoryPath: folder_name
-          }
-          folder_object = connection.searchIndex.FindByInventoryPath(propSpecs) # rubocop:disable Naming/VariableName
-
-          return folders if folder_object.nil?
-
-          folder_object.childEntity.each do |folder|
-            next unless folder.is_a? RbVmomi::VIM::Folder
-
-            folders << { folder.name => folder }
-          end
-
-          folders
-        end
-
-        def vms_in_pool(pool_name)
-          vms = []
-          @connection_pool.with_metrics do |pool_object|
-            connection = ensured_vsphere_connection(pool_object)
-            folder_object = find_vm_folder(pool_name, connection)
-
-            return vms if folder_object.nil?
-
-            folder_object.childEntity.each do |vm|
-              vms << { 'name' => vm.name } if vm.is_a? RbVmomi::VIM::VirtualMachine
-            end
-          end
-          vms
-        end
-
-        def select_target_hosts(target, cluster, datacenter)
-          percentage = 100
-          dc = "#{datacenter}_#{cluster}"
-          @provider_hosts_lock.synchronize do
-            begin
-              target[dc] = {} unless target.key?(dc)
-              target[dc]['checking'] = true
-              hosts_hash = find_least_used_hosts(cluster, datacenter, percentage)
-              target[dc] = hosts_hash
-            rescue StandardError
-              target[dc] = {}
-              raise
-            ensure
-              target[dc]['check_time_finished'] = Time.now
-            end
-          end
-        end
-
-        def run_select_hosts(pool_name, target)
-          now = Time.now
-          max_age = @config[:config]['host_selection_max_age'] || 60
-          loop_delay = 5
-          datacenter = get_target_datacenter_from_config(pool_name)
-          cluster = get_target_cluster_from_config(pool_name)
-          raise("cluster for pool #{pool_name} cannot be identified") if cluster.nil?
-          raise("datacenter for pool #{pool_name} cannot be identified") if datacenter.nil?
-
-          dc = "#{datacenter}_#{cluster}"
-          unless target.key?(dc)
-            select_target_hosts(target, cluster, datacenter)
-            return
-          end
-          wait_for_host_selection(dc, target, loop_delay, max_age) if target[dc].key?('checking')
-          select_target_hosts(target, cluster, datacenter) if target[dc].key?('check_time_finished') && now - target[dc]['check_time_finished'] > max_age
-        end
-
-        def wait_for_host_selection(dc, target, maxloop = 0, loop_delay = 1, max_age = 60)
-          loop_count = 1
-          until target.key?(dc) && target[dc].key?('check_time_finished')
-            sleep(loop_delay)
-            unless maxloop == 0
-              break if loop_count >= maxloop
-
-              loop_count += 1
-            end
-          end
-          return unless target[dc].key?('check_time_finished')
-
-          loop_count = 1
-          while Time.now - target[dc]['check_time_finished'] > max_age
-            sleep(loop_delay)
-            unless maxloop == 0
-              break if loop_count >= maxloop
-
-              loop_count += 1
-            end
-          end
-        end
-
-        def select_next_host(pool_name, target, architecture = nil)
-          datacenter = get_target_datacenter_from_config(pool_name)
-          cluster = get_target_cluster_from_config(pool_name)
-          raise("cluster for pool #{pool_name} cannot be identified") if cluster.nil?
-          raise("datacenter for pool #{pool_name} cannot be identified") if datacenter.nil?
-
-          dc = "#{datacenter}_#{cluster}"
-          @provider_hosts_lock.synchronize do
-            if architecture
-              raise("there is no candidate in vcenter that meets all the required conditions, that the cluster has available hosts in a 'green' status, not in maintenance mode and not overloaded CPU and memory") unless target[dc].key?('architectures')
-
-              host = target[dc]['architectures'][architecture].shift
-              target[dc]['architectures'][architecture] << host
-              if target[dc]['hosts'].include?(host)
-                target[dc]['hosts'].delete(host)
-                target[dc]['hosts'] << host
-              end
-            else
-              raise("there is no candidate in vcenter that meets all the required conditions, that the cluster has available hosts in a 'green' status, not in maintenance mode and not overloaded CPU and memory") unless target[dc].key?('hosts')
-
-              host = target[dc]['hosts'].shift
-              target[dc]['hosts'] << host
-              target[dc]['architectures'].each do |arch|
-                target[dc]['architectures'][arch] = arch.partition { |v| v != host }.flatten if arch.include?(host)
-              end
-            end
-
-            return host
-          end
-        end
-
-        def vm_in_target?(pool_name, parent_host, architecture, target)
-          datacenter = get_target_datacenter_from_config(pool_name)
-          cluster = get_target_cluster_from_config(pool_name)
-          raise("cluster for pool #{pool_name} cannot be identified") if cluster.nil?
-          raise("datacenter for pool #{pool_name} cannot be identified") if datacenter.nil?
-
-          dc = "#{datacenter}_#{cluster}"
-          raise("there is no candidate in vcenter that meets all the required conditions, that the cluster has available hosts in a 'green' status, not in maintenance mode and not overloaded CPU and memory") unless target[dc].key?('hosts')
-          return true if target[dc]['hosts'].include?(parent_host)
-          return true if target[dc]['architectures'][architecture].include?(parent_host)
-
-          false
-        end
-
-        def get_vm(pool_name, vm_name)
-          vm_hash = nil
-          @connection_pool.with_metrics do |pool_object|
-            connection = ensured_vsphere_connection(pool_object)
-            vm_object = find_vm(pool_name, vm_name, connection)
-            return vm_hash if vm_object.nil?
-
-            vm_hash = generate_vm_hash(vm_object, pool_name)
-          end
-          vm_hash
-        end
-
-        def create_vm(pool_name, new_vmname)
-          pool = pool_config(pool_name)
-          raise("Pool #{pool_name} does not exist for the provider #{name}") if pool.nil?
-
-          vm_hash = nil
-          @connection_pool.with_metrics do |pool_object|
-            connection = ensured_vsphere_connection(pool_object)
-            # Assume all pool config is valid i.e. not missing
-            template_path = pool['template']
-            target_folder_path = pool['folder']
-            target_datastore = pool['datastore']
-            target_datacenter_name = get_target_datacenter_from_config(pool_name)
-
-            # Get the template VM object
-            raise("Pool #{pool_name} did not specify a full path for the template for the provider #{name}") unless valid_template_path? template_path
-
-            template_vm_object = find_template_vm(pool, connection)
-
-            extra_config = [
-              { key: 'guestinfo.hostname', value: new_vmname }
-            ]
-
-            if pool.key?('snapshot_mainMem_ioBlockPages')
-              ioblockpages = pool['snapshot_mainMem_ioBlockPages']
-              extra_config.push(
-                { key: 'mainMem.ioBlockPages', value: ioblockpages }
-              )
-            end
-            if pool.key?('snapshot_mainMem_iowait')
-              iowait = pool['snapshot_mainMem_iowait']
-              extra_config.push(
-                { key: 'mainMem.iowait', value: iowait }
-              )
-            end
-
-            # Annotate with creation time, origin template, etc.
-            # Add extraconfig options that can be queried by vmtools
-            config_spec = create_config_spec(new_vmname, template_path, extra_config)
-
-            # Check if alternate network configuration is specified and add configuration
-            if pool.key?('network')
-              template_vm_network_device = template_vm_object.config.hardware.device.grep(RbVmomi::VIM::VirtualEthernetCard).first
-              network_name = pool['network']
-              network_device = set_network_device(target_datacenter_name, template_vm_network_device, network_name, connection)
-              config_spec.deviceChange = [{ operation: 'edit', device: network_device }]
-            end
-
-            # Put the VM in the specified folder and resource pool
-            relocate_spec = create_relocate_spec(target_datastore, target_datacenter_name, pool_name, connection)
-
-            # Create a clone spec
-            clone_spec = create_clone_spec(relocate_spec, config_spec)
-
-            begin
-              vm_target_folder = find_vm_folder(pool_name, connection)
-              vm_target_folder ||= create_folder(connection, target_folder_path, target_datacenter_name) if @config[:config].key?('create_folders') && (@config[:config]['create_folders'] == true)
-            rescue StandardError
-              if @config[:config].key?('create_folders') && (@config[:config]['create_folders'] == true)
-                vm_target_folder = create_folder(connection, target_folder_path, target_datacenter_name)
-              else
-                raise
-              end
-            end
-            raise ArgumentError, "Cannot find the configured folder for #{pool_name} #{target_folder_path}" unless vm_target_folder
-
-            # Create the new VM
-            new_vm_object = template_vm_object.CloneVM_Task(
-              folder: vm_target_folder,
-              name: new_vmname,
-              spec: clone_spec
-            ).wait_for_completion
-
-            vm_hash = generate_vm_hash(new_vm_object, pool_name)
-          end
-          vm_hash
-        end
-
-        def create_config_spec(vm_name, template_name, extra_config)
-          RbVmomi::VIM.VirtualMachineConfigSpec(
-            annotation: JSON.pretty_generate(
-              name: vm_name,
-              created_by: provider_config['username'],
-              base_template: template_name,
-              creation_timestamp: Time.now.utc
-            ),
-            extraConfig: extra_config
-          )
-        end
-
-        def create_relocate_spec(target_datastore, target_datacenter_name, pool_name, connection)
-          pool = pool_config(pool_name)
-          target_cluster_name = get_target_cluster_from_config(pool_name)
-
-          relocate_spec = RbVmomi::VIM.VirtualMachineRelocateSpec(
-            datastore: find_datastore(target_datastore, connection, target_datacenter_name),
-            diskMoveType: get_disk_backing(pool)
-          )
-          manage_host_selection = @config[:config]['manage_host_selection'] if @config[:config].key?('manage_host_selection')
-          if manage_host_selection
-            run_select_hosts(pool_name, @provider_hosts)
-            target_host = select_next_host(pool_name, @provider_hosts)
-            host_object = find_host_by_dnsname(connection, target_host)
-            relocate_spec.host = host_object
-          else
-            # Choose a cluster/host to place the new VM on
-            target_cluster_object = find_cluster(target_cluster_name, connection, target_datacenter_name)
-            relocate_spec.pool = target_cluster_object.resourcePool
-          end
-          relocate_spec
-        end
-
-        def create_clone_spec(relocate_spec, config_spec)
-          RbVmomi::VIM.VirtualMachineCloneSpec(
-            location: relocate_spec,
-            config: config_spec,
-            powerOn: true,
-            template: false
-          )
-        end
-
-        def set_network_device(datacenter_name, template_vm_network_device, network_name, connection)
-          # Retrieve network object
-          datacenter = connection.serviceInstance.find_datacenter(datacenter_name)
-          new_network = datacenter.network.find { |n| n.name == network_name }
-
-          raise("Cannot find network #{network_name} in datacenter #{datacenter_name}") unless new_network
-
-          # Determine network device type
-          # All possible device type options here: https://vdc-download.vmware.com/vmwb-repository/dcr-public/98d63b35-d822-47fe-a87a-ddefd469df06/2e3c7b58-f2bd-486e-8bb1-a75eb0640bee/doc/vim.vm.device.VirtualEthernetCard.html
-          network_device =
-            if template_vm_network_device.instance_of? RbVmomi::VIM::VirtualVmxnet2
-              RbVmomi::VIM.VirtualVmxnet2
-            elsif template_vm_network_device.instance_of? RbVmomi::VIM::VirtualVmxnet3
-              RbVmomi::VIM.VirtualVmxnet3
-            elsif template_vm_network_device.instance_of? RbVmomi::VIM::VirtualE1000
-              RbVmomi::VIM.VirtualE1000
-            elsif template_vm_network_device.instance_of? RbVmomi::VIM::VirtualE1000e
-              RbVmomi::VIM.VirtualE1000e
-            elsif template_vm_network_device.instance_of? RbVmomi::VIM::VirtualSriovEthernetCard
-              RbVmomi::VIM.VirtualSriovEthernetCard
-            else
-              RbVmomi::VIM.VirtualPCNet32
-            end
-
-          # Set up new network device attributes
-          network_device.key = template_vm_network_device.key
-          network_device.deviceInfo = RbVmomi::VIM.Description(
-            label: template_vm_network_device.deviceInfo.label,
-            summary: network_name
-          )
-          network_device.backing = RbVmomi::VIM.VirtualEthernetCardNetworkBackingInfo(
-            deviceName: network_name,
-            network: new_network,
-            useAutoDetect: false
-          )
-          network_device.addressType = 'assigned'
-          network_device.connectable = RbVmomi::VIM.VirtualDeviceConnectInfo(
-            allowGuestControl: true,
-            startConnected: true,
-            connected: true
-          )
-          network_device
-        end
-
-        def create_disk(pool_name, vm_name, disk_size)
-          pool = pool_config(pool_name)
-          raise("Pool #{pool_name} does not exist for the provider #{name}") if pool.nil?
-
-          datastore_name = pool['datastore']
-          raise("Pool #{pool_name} does not have a datastore defined for the provider #{name}") if datastore_name.nil?
-
-          @connection_pool.with_metrics do |pool_object|
-            connection = ensured_vsphere_connection(pool_object)
-            vm_object = find_vm(pool_name, vm_name, connection)
-            raise("VM #{vm_name} in pool #{pool_name} does not exist for the provider #{name}") if vm_object.nil?
-
-            add_disk(vm_object, disk_size, datastore_name, connection, get_target_datacenter_from_config(pool_name))
-          end
-          true
-        end
-
-        def create_snapshot(pool_name, vm_name, new_snapshot_name)
-          @connection_pool.with_metrics do |pool_object|
-            connection = ensured_vsphere_connection(pool_object)
-            vm_object = find_vm(pool_name, vm_name, connection)
-            raise("VM #{vm_name} in pool #{pool_name} does not exist for the provider #{name}") if vm_object.nil?
-
-            old_snap = find_snapshot(vm_object, new_snapshot_name)
-            raise("Snapshot #{new_snapshot_name} for VM #{vm_name} in pool #{pool_name} already exists for the provider #{name}") unless old_snap.nil?
-
-            vm_object.CreateSnapshot_Task(
-              name: new_snapshot_name,
-              description: 'vmpooler',
-              memory: true,
-              quiesce: true
-            ).wait_for_completion
-          end
-          true
-        end
-
-        def revert_snapshot(pool_name, vm_name, snapshot_name)
-          @connection_pool.with_metrics do |pool_object|
-            connection = ensured_vsphere_connection(pool_object)
-            vm_object = find_vm(pool_name, vm_name, connection)
-            raise("VM #{vm_name} in pool #{pool_name} does not exist for the provider #{name}") if vm_object.nil?
-
-            snapshot_object = find_snapshot(vm_object, snapshot_name)
-            raise("Snapshot #{snapshot_name} for VM #{vm_name} in pool #{pool_name} does not exist for the provider #{name}") if snapshot_object.nil?
-
-            snapshot_object.RevertToSnapshot_Task.wait_for_completion
-          end
-          true
-        end
-
-        def destroy_vm(pool_name, vm_name)
-          @connection_pool.with_metrics do |pool_object|
-            connection = ensured_vsphere_connection(pool_object)
-            vm_object = find_vm(pool_name, vm_name, connection)
-            # If a VM doesn't exist then it is effectively deleted
-            return true if vm_object.nil?
-
-            # Poweroff the VM if it's running
-            vm_object.PowerOffVM_Task.wait_for_completion if vm_object.runtime&.powerState && vm_object.runtime.powerState == 'poweredOn'
-
-            # Kill it with fire
-            vm_object.Destroy_Task.wait_for_completion
-          end
-          true
-        end
-
-        def vm_ready?(_pool_name, vm_name)
-          begin
-            open_socket(vm_name, global_config[:config]['domain'])
-          rescue StandardError => _e
-            return false
-          end
-
-          true
-        end
-
-        # VSphere Helper methods
-
-        def get_target_cluster_from_config(pool_name)
-          pool = pool_config(pool_name)
-          return nil if pool.nil?
-
-          return pool['clone_target'] unless pool['clone_target'].nil?
-          return global_config[:config]['clone_target'] unless global_config[:config]['clone_target'].nil?
-
-          nil
-        end
-
-        def get_target_datacenter_from_config(pool_name)
-          pool = pool_config(pool_name)
-          return nil if pool.nil?
-
-          return pool['datacenter']            unless pool['datacenter'].nil?
-          return provider_config['datacenter'] unless provider_config['datacenter'].nil?
-
-          nil
-        end
-
-        # Return a hash of VM data
-        # Provides vmname, hostname, template, poolname, boottime and powerstate information
-        def generate_vm_hash(vm_object, pool_name)
-          pool_configuration = pool_config(pool_name)
-          return nil if pool_configuration.nil?
-
-          hostname = vm_object.summary.guest.hostName if vm_object.summary&.guest && vm_object.summary.guest.hostName
-          boottime = vm_object.runtime.bootTime if vm_object.runtime&.bootTime
-          powerstate = vm_object.runtime.powerState if vm_object.runtime&.powerState
-
-          {
-            'name' => vm_object.name,
-            'hostname' => hostname,
-            'template' => pool_configuration['template'],
-            'poolname' => pool_name,
-            'boottime' => boottime,
-            'powerstate' => powerstate
-          }
-        end
-
-        # vSphere helper methods
-        ADAPTER_TYPE = 'lsiLogic'
-        DISK_TYPE = 'thin'
-        DISK_MODE = 'persistent'
-
-        def ensured_vsphere_connection(connection_pool_object)
-          connection_pool_object[:connection] = connect_to_vsphere unless vsphere_connection_ok?(connection_pool_object[:connection])
-          connection_pool_object[:connection]
-        end
-
-        def vsphere_connection_ok?(connection)
-          _result = connection.serviceInstance.CurrentTime
-          true
-        rescue StandardError
-          false
-        end
-
-        def connect_to_vsphere
-          max_tries = global_config[:config]['max_tries'] || 3
-          retry_factor = global_config[:config]['retry_factor'] || 10
-          try = 1
-          begin
-            connection = RbVmomi::VIM.connect host: provider_config['server'],
-                                              user: provider_config['username'],
-                                              password: provider_config['password'],
-                                              insecure: provider_config['insecure'] || false
-            metrics.increment('connect.open')
-            connection
-          rescue StandardError => e
-            metrics.increment('connect.fail')
-            raise e if try >= max_tries
-
-            sleep(try * retry_factor)
-            try += 1
-            retry
-          end
-        end
-
-        # This should supercede the open_socket method in the Pool Manager
-        def open_socket(host, domain = nil, timeout = 5, port = 22, &_block)
-          Timeout.timeout(timeout) do
-            target_host = host
-            target_host = "#{host}.#{domain}" if domain
-            sock = TCPSocket.new target_host, port
-            begin
-              yield sock if block_given?
-            ensure
-              sock.close
-            end
-          end
-        end
-
-        def get_vm_folder_path(vm_object)
-          # This gives an array starting from the root Datacenters folder all the way to the VM
-          # [ [Object, String], [Object, String ] ... ]
-          # It's then reversed so that it now goes from the VM to the Datacenter
-          full_path = vm_object.path.reverse
-
-          # Find the Datacenter object
-          dc_index = full_path.index { |p| p[0].is_a?(RbVmomi::VIM::Datacenter) }
-          return nil if dc_index.nil?
-          # The Datacenter should be at least 2 otherwise there's something
-          # wrong with the array passed in
-          # This is the minimum:
-          # [ VM (0), VM ROOT FOLDER (1), DC (2)]
-          return nil if dc_index <= 1
-
-          # Remove the VM name (Starting position of 1 in the slice)
-          # Up until the Root VM Folder of DataCenter Node (dc_index - 2)
-          full_path = full_path.slice(1..dc_index - 2)
-
-          # Reverse the array back to normal and
-          # then convert the array of paths into a '/' seperated string
-          (full_path.reverse.map { |p| p[1] }).join('/')
-        end
-
-        def add_disk(vm, size, datastore, connection, datacentername)
-          return false unless size.to_i > 0
-
-          vmdk_datastore = find_datastore(datastore, connection, datacentername)
-          raise("Datastore '#{datastore}' does not exist in datacenter '#{datacentername}'") if vmdk_datastore.nil?
-
-          datacenter = connection.serviceInstance.find_datacenter(datacentername)
-          controller = find_disk_controller(vm)
-          disk_unit_number = find_disk_unit_number(vm, controller)
-          disk_count = vm.config.hardware.device.grep(RbVmomi::VIM::VirtualDisk).count
-          vmdk_file_name = "#{vm['name']}/#{vm['name']}_#{disk_count}.vmdk"
-
-          vmdk_spec = RbVmomi::VIM::FileBackedVirtualDiskSpec(
-            capacityKb: size.to_i * 1024 * 1024,
-            adapterType: ADAPTER_TYPE,
-            diskType: DISK_TYPE
-          )
-
-          vmdk_backing = RbVmomi::VIM::VirtualDiskFlatVer2BackingInfo(
-            datastore: vmdk_datastore,
-            diskMode: DISK_MODE,
-            fileName: "[#{datastore}] #{vmdk_file_name}"
-          )
-
-          device = RbVmomi::VIM::VirtualDisk(
-            backing: vmdk_backing,
-            capacityInKB: size.to_i * 1024 * 1024,
-            controllerKey: controller.key,
-            key: -1,
-            unitNumber: disk_unit_number
-          )
-
-          device_config_spec = RbVmomi::VIM::VirtualDeviceConfigSpec(
-            device: device,
-            operation: RbVmomi::VIM::VirtualDeviceConfigSpecOperation('add')
-          )
-
-          vm_config_spec = RbVmomi::VIM::VirtualMachineConfigSpec(
-            deviceChange: [device_config_spec]
-          )
-
-          connection.serviceContent.virtualDiskManager.CreateVirtualDisk_Task(
-            datacenter: datacenter,
-            name: "[#{datastore}] #{vmdk_file_name}",
-            spec: vmdk_spec
-          ).wait_for_completion
-
-          vm.ReconfigVM_Task(spec: vm_config_spec).wait_for_completion
-
-          true
-        end
-
-        def find_datastore(datastorename, connection, datacentername)
-          datacenter = connection.serviceInstance.find_datacenter(datacentername)
-          raise("Datacenter #{datacentername} does not exist") if datacenter.nil?
-
-          datacenter.find_datastore(datastorename)
-        end
-
-        def find_device(vm, device_name)
-          vm.config.hardware.device.each do |device|
-            return device if device.deviceInfo.label == device_name
-          end
-
-          nil
-        end
-
-        def find_disk_controller(vm)
-          devices = find_disk_devices(vm)
-
-          devices.keys.sort.each do |device|
-            return find_device(vm, devices[device]['device'].deviceInfo.label) if devices[device]['children'].length < 15
-          end
-
-          nil
-        end
-
-        def find_disk_devices(vm)
-          devices = {}
-
-          vm.config.hardware.device.each do |device|
-            if device.is_a? RbVmomi::VIM::VirtualSCSIController
-              if devices[device.controllerKey].nil?
-                devices[device.key] = {}
-                devices[device.key]['children'] = []
-              end
-
-              devices[device.key]['device'] = device
-            end
-
-            if device.is_a? RbVmomi::VIM::VirtualDisk
-              if devices[device.controllerKey].nil?
-                devices[device.controllerKey] = {}
-                devices[device.controllerKey]['children'] = []
-              end
-
-              devices[device.controllerKey]['children'].push(device)
-            end
-          end
-
-          devices
-        end
-
-        def find_disk_unit_number(vm, controller)
-          used_unit_numbers = []
-          available_unit_numbers = []
-
-          devices = find_disk_devices(vm)
-
-          devices.keys.sort.each do |c|
-            next unless controller.key == devices[c]['device'].key
-
-            used_unit_numbers.push(devices[c]['device'].scsiCtlrUnitNumber)
-            devices[c]['children'].each do |disk|
-              used_unit_numbers.push(disk.unitNumber)
-            end
-          end
-
-          (0..15).each do |scsi_id|
-            available_unit_numbers.push(scsi_id) if used_unit_numbers.grep(scsi_id).length <= 0
-          end
-
-          available_unit_numbers.min
-        end
-
-        # Finds a folder object by inventory path
-        # Params:
-        # +pool_name+:: the pool to find the folder for
-        # +connection+:: the vsphere connection object
-        # returns a ManagedObjectReference for the folder found or nil if not found
-        def find_vm_folder(pool_name, connection)
-          # Find a folder by its inventory path and return the object
-          # Returns nil when the object found is not a folder
-          pool_configuration = pool_config(pool_name)
-          return nil if pool_configuration.nil?
-
-          folder = pool_configuration['folder']
-          datacenter = get_target_datacenter_from_config(pool_name)
-          return nil if datacenter.nil?
-
-          propSpecs = { # rubocop:disable Naming/VariableName
-            entity: self,
-            inventoryPath: "#{datacenter}/vm/#{folder}"
-          }
-
-          folder_object = connection.searchIndex.FindByInventoryPath(propSpecs) # rubocop:disable Naming/VariableName
-          return nil unless folder_object.instance_of? RbVmomi::VIM::Folder
-
-          folder_object
-        end
-
-        # Returns an array containing cumulative CPU and memory utilization of a host, and its object reference
-        # Params:
-        # +model+:: CPU arch version to match on
-        # +limit+:: Hard limit for CPU or memory utilization beyond which a host is excluded for deployments
-        # returns nil if one on these conditions is true:
-        #    the model param is defined and cannot be found
-        #    the host is in maintenance mode
-        #    the host status is not 'green'
-        #    the cpu or memory utilization is bigger than the limit param
-        def get_host_utilization(host, model = nil, limit = 90)
-          limit = @config[:config]['utilization_limit'] if @config[:config].key?('utilization_limit')
-          return nil if model && !host_has_cpu_model?(host, model)
-          return nil if host.runtime.inMaintenanceMode
-          return nil unless host.overallStatus == 'green'
-          return nil unless host.configIssue.empty?
-
-          cpu_utilization = cpu_utilization_for host
-          memory_utilization = memory_utilization_for host
-
-          return nil if cpu_utilization.nil?
-          return nil if cpu_utilization.to_d == 0.0.to_d
-          return nil if memory_utilization.nil?
-          return nil if memory_utilization.to_d == 0.0.to_d
-
-          return nil if cpu_utilization > limit
-          return nil if memory_utilization > limit
-
-          [cpu_utilization, host]
-        end
-
-        def host_has_cpu_model?(host, model)
-          get_host_cpu_arch_version(host) == model
-        end
-
-        def get_host_cpu_arch_version(host)
-          cpu_model = host.hardware.cpuPkg[0].description
-          cpu_model_parts = cpu_model.split
-          cpu_model_parts[4]
-        end
-
-        def cpu_utilization_for(host)
-          cpu_usage = host.summary.quickStats.overallCpuUsage
-          return nil if cpu_usage.nil?
-
-          cpu_size = host.summary.hardware.cpuMhz * host.summary.hardware.numCpuCores
-          cpu_usage.fdiv(cpu_size) * 100
-        end
-
-        def memory_utilization_for(host)
-          memory_usage = host.summary.quickStats.overallMemoryUsage
-          return nil if memory_usage.nil?
-
-          memory_size = host.summary.hardware.memorySize / 1024 / 1024
-          memory_usage.fdiv(memory_size) * 100
-        end
-
-        def get_average_cluster_utilization(hosts)
-          utilization_counts = hosts.map { |host| host[0] }
-          utilization_counts.inject(:+) / hosts.count
-        end
-
-        def build_compatible_hosts_lists(hosts, percentage)
-          hosts_with_arch_versions = hosts.map do |h|
-            {
-              'utilization' => h[0],
-              'host_object' => h[1],
-              'architecture' => get_host_cpu_arch_version(h[1])
-            }
-          end
-          versions = hosts_with_arch_versions.map { |host| host['architecture'] }.uniq
-          architectures = {}
-          versions.each do |version|
-            architectures[version] = []
-          end
-
-          hosts_with_arch_versions.each do |h|
-            architectures[h['architecture']] << [h['utilization'], h['host_object'], h['architecture']]
-          end
-
-          versions.each do |version|
-            targets = select_least_used_hosts(architectures[version], percentage)
-            architectures[version] = targets
-          end
-          architectures
-        end
-
-        def select_least_used_hosts(hosts, percentage)
-          raise('Provided hosts list to select_least_used_hosts is empty') if hosts.empty?
-
-          average_utilization = get_average_cluster_utilization(hosts)
-          least_used_hosts = []
-          hosts.each do |host|
-            least_used_hosts << host if host[0] <= average_utilization
-          end
-          hosts_to_select = (hosts.count * (percentage / 100.0)).to_int
-          hosts_to_select = hosts.count - 1 if percentage == 100
-          least_used_hosts.sort[0..hosts_to_select].map { |host| host[1].name }
-        end
-
-        def find_least_used_hosts(cluster, datacentername, percentage)
-          @connection_pool.with_metrics do |pool_object|
-            connection = ensured_vsphere_connection(pool_object)
-            cluster_object = find_cluster(cluster, connection, datacentername)
-            raise("Cluster #{cluster} cannot be found") if cluster_object.nil?
-
-            target_hosts = get_cluster_host_utilization(cluster_object)
-            raise("there is no candidate in vcenter that meets all the required conditions, that the cluster has available hosts in a 'green' status, not in maintenance mode and not overloaded CPU and memory'") if target_hosts.empty?
-
-            architectures = build_compatible_hosts_lists(target_hosts, percentage)
-            least_used_hosts = select_least_used_hosts(target_hosts, percentage)
-            {
-              'hosts' => least_used_hosts,
-              'architectures' => architectures
-            }
-          end
-        end
-
-        def find_host_by_dnsname(connection, dnsname)
-          host_object = connection.searchIndex.FindByDnsName(dnsName: dnsname, vmSearch: false)
-          return nil if host_object.nil?
-
-          host_object
-        end
-
-        def find_least_used_host(cluster, connection, datacentername)
-          cluster_object = find_cluster(cluster, connection, datacentername)
-          target_hosts = get_cluster_host_utilization(cluster_object)
-          raise("There is no host candidate in vcenter that meets all the required conditions, check that the cluster has available hosts in a 'green' status, not in maintenance mode and not overloaded CPU and memory'") if target_hosts.empty?
-
-          target_hosts.min[1]
-        end
-
-        def find_cluster(cluster, connection, datacentername)
-          datacenter = connection.serviceInstance.find_datacenter(datacentername)
-          raise("Datacenter #{datacentername} does not exist") if datacenter.nil?
-
-          # In the event the cluster is not a direct descendent of the
-          # datacenter, we use a ContainerView to leverage its recursive
-          # search. This will find clusters which are, for example, in
-          # folders under the datacenter. This will also find standalone
-          # hosts which are not part of a cluster.
-          cv = connection.serviceContent.viewManager.CreateContainerView(
-            container: datacenter.hostFolder,
-            type: ['ComputeResource', 'ClusterComputeResource'],
-            recursive: true
-          )
-          cluster = cv.view.find { |cluster_object| cluster_object.name == cluster }
-          cv.DestroyView
-          cluster
-        end
-
-        def get_cluster_host_utilization(cluster, model = nil)
-          cluster_hosts = []
-          cluster.host.each do |host|
-            host_usage = get_host_utilization(host, model)
-            cluster_hosts << host_usage if host_usage
-          end
-          cluster_hosts
-        end
-
-        def find_least_used_vpshere_compatible_host(vm)
-          source_host = vm.summary.runtime.host
-          model = get_host_cpu_arch_version(source_host)
-          cluster = source_host.parent
-          target_hosts = get_cluster_host_utilization(cluster, model)
-          raise("There is no host candidate in vcenter that meets all the required conditions, check that the cluster has available hosts in a 'green' status, not in maintenance mode and not overloaded CPU and memory'") if target_hosts.empty?
-
-          target_host = target_hosts.min[1]
-          [target_host, target_host.name]
-        end
-
-        def find_snapshot(vm, snapshotname)
-          get_snapshot_list(vm.snapshot.rootSnapshotList, snapshotname) if vm.snapshot
-        end
-
-        def build_propSpecs(datacenter, folder, vmname) # rubocop:disable Naming/MethodName
-          {
-            entity => self,
-            :inventoryPath => "#{datacenter}/vm/#{folder}/#{vmname}"
-          }
-        end
-
-        def find_vm(pool_name, vmname, connection)
-          # Find a VM by its inventory path and return the VM object
-          # Returns nil when a VM, or pool configuration, cannot be found
-          pool_configuration = pool_config(pool_name)
-          return nil if pool_configuration.nil?
-
-          folder = pool_configuration['folder']
-          datacenter = get_target_datacenter_from_config(pool_name)
-          return nil if datacenter.nil?
-
-          propSpecs = { # rubocop:disable Naming/VariableName
-            entity: self,
-            inventoryPath: "#{datacenter}/vm/#{folder}/#{vmname}"
-          }
-
-          connection.searchIndex.FindByInventoryPath(propSpecs) # rubocop:disable Naming/VariableName
-        end
-
-        def get_base_vm_container_from(connection)
-          view_manager = connection.serviceContent.viewManager
-          view_manager.CreateContainerView(
-            container: connection.serviceContent.rootFolder,
-            recursive: true,
-            type: ['VirtualMachine']
-          )
-        end
-
-        def get_snapshot_list(tree, snapshotname)
-          snapshot = nil
-
-          tree.each do |child|
-            if child.name == snapshotname
-              snapshot ||= child.snapshot
-            else
-              snapshot ||= get_snapshot_list(child.childSnapshotList, snapshotname)
-            end
-          end
-
-          snapshot
-        end
-
-        def get_vm_details(pool_name, vm_name, connection)
-          vm_object = find_vm(pool_name, vm_name, connection)
-          return nil if vm_object.nil?
-
-          parent_host_object = vm_object.summary.runtime.host if vm_object.summary&.runtime && vm_object.summary.runtime.host
-          raise('Unable to determine which host the VM is running on') if parent_host_object.nil?
-
-          parent_host = parent_host_object.name
-          architecture = get_host_cpu_arch_version(parent_host_object)
-          {
-            'host_name' => parent_host,
-            'object' => vm_object,
-            'architecture' => architecture
-          }
-        end
-
-        def migration_enabled?(config)
-          migration_limit = config[:config]['migration_limit']
-          return false unless migration_limit.is_a? Integer
-          return true if migration_limit > 0
-
-          false
-        end
-
-        def migrate_vm(pool_name, vm_name)
-          @connection_pool.with_metrics do |pool_object|
-            begin
-              connection = ensured_vsphere_connection(pool_object)
-              vm_hash = get_vm_details(pool_name, vm_name, connection)
-              @redis.with_metrics do |redis|
-                redis.hset("vmpooler__vm__#{vm_name}", 'host', vm_hash['host_name'])
-                migration_count = redis.scard('vmpooler__migration')
-                migration_limit = @config[:config]['migration_limit'] if @config[:config].key?('migration_limit')
-                if migration_enabled? @config
-                  if migration_count >= migration_limit
-                    logger.log('s', "[ ] [#{pool_name}] '#{vm_name}' is running on #{vm_hash['host_name']}. No migration will be evaluated since the migration_limit has been reached")
-                    break
-                  end
-                  run_select_hosts(pool_name, @provider_hosts)
-                  if vm_in_target?(pool_name, vm_hash['host_name'], vm_hash['architecture'], @provider_hosts)
-                    logger.log('s', "[ ] [#{pool_name}] No migration required for '#{vm_name}' running on #{vm_hash['host_name']}")
-                  else
-                    migrate_vm_to_new_host(pool_name, vm_name, vm_hash, connection)
-                  end
-                else
-                  logger.log('s', "[ ] [#{pool_name}] '#{vm_name}' is running on #{vm_hash['host_name']}")
-                end
-              end
-            rescue StandardError
-              logger.log('s', "[!] [#{pool_name}] '#{vm_name}' is running on #{vm_hash['host_name']}")
-              raise
-            end
-          end
-        end
-
-        def migrate_vm_to_new_host(pool_name, vm_name, vm_hash, connection)
-          @redis.with_metrics do |redis|
-            redis.sadd('vmpooler__migration', vm_name)
-          end
-          target_host_name = select_next_host(pool_name, @provider_hosts, vm_hash['architecture'])
-          target_host_object = find_host_by_dnsname(connection, target_host_name)
-          finish = migrate_vm_and_record_timing(pool_name, vm_name, vm_hash, target_host_object, target_host_name)
-          @redis.with_metrics do |redis|
-            redis.multi
-            redis.hset("vmpooler__vm__#{vm_name}", 'host', target_host_name)
-            redis.hset("vmpooler__vm__#{vm_name}", 'migrated', true)
-            redis.exec
-          end
-          logger.log('s', "[>] [#{pool_name}] '#{vm_name}' migrated from #{vm_hash['host_name']} to #{target_host_name} in #{finish} seconds")
-        ensure
-          @redis.with_metrics do |redis|
-            redis.srem('vmpooler__migration', vm_name)
-          end
-        end
-
-        def migrate_vm_and_record_timing(pool_name, vm_name, vm_hash, target_host_object, dest_host_name)
-          start = Time.now
-          migrate_vm_host(vm_hash['object'], target_host_object)
-          finish = format('%<time>.2f', time: Time.now - start)
-          metrics.timing("migrate.#{pool_name}", finish)
-          metrics.increment("migrate_from.#{vm_hash['host_name']}")
-          metrics.increment("migrate_to.#{dest_host_name}")
-          @redis.with_metrics do |redis|
-            checkout_to_migration = format('%<time>.2f', time: Time.now - Time.parse(redis.hget("vmpooler__vm__#{vm_name}", 'checkout')))
-            redis.multi
-            redis.hset("vmpooler__vm__#{vm_name}", 'migration_time', finish)
-            redis.hset("vmpooler__vm__#{vm_name}", 'checkout_to_migration', checkout_to_migration)
-            redis.exec
-          end
-          finish
-        end
-
-        def migrate_vm_host(vm_object, host)
-          relospec = RbVmomi::VIM.VirtualMachineRelocateSpec(host: host)
-          vm_object.RelocateVM_Task(spec: relospec).wait_for_completion
-        end
-
-        def create_folder(connection, new_folder, datacenter)
-          dc = connection.serviceInstance.find_datacenter(datacenter)
-          folder_object = dc.vmFolder.traverse(new_folder, RbVmomi::VIM::Folder, true)
-          raise("Cannot create folder #{new_folder}") if folder_object.nil?
-
-          folder_object
-        end
-
-        def find_template_vm(pool, connection)
-          datacenter = get_target_datacenter_from_config(pool['name'])
-          raise('cannot find datacenter') if datacenter.nil?
-
-          propSpecs = { # rubocop:disable Naming/VariableName
-            entity: self,
-            inventoryPath: "#{datacenter}/vm/#{pool['template']}"
-          }
-
-          template_vm_object = connection.searchIndex.FindByInventoryPath(propSpecs) # rubocop:disable Naming/VariableName
-          raise("Pool #{pool['name']} specifies a template VM of #{pool['template']} which does not exist for the provider #{name}") if template_vm_object.nil?
-
-          template_vm_object
-        end
-
-        def create_template_delta_disks(pool)
-          @connection_pool.with_metrics do |pool_object|
-            connection = ensured_vsphere_connection(pool_object)
-            template_vm_object = find_template_vm(pool, connection)
-
-            template_vm_object.add_delta_disk_layer_on_all_disks
-          end
-        end
-
-        def valid_template_path?(template)
-          return false unless template.include?('/')
-          return false if template[0] == '/'
-          return false if template[-1] == '/'
-
-          true
-        end
-
-        def get_disk_backing(pool)
-          return :moveChildMostDiskBacking if linked_clone?(pool)
-
-          :moveAllDiskBackingsAndConsolidate
-        end
-
-        def linked_clone?(pool)
-          return if pool['create_linked_clone'] == false
-          return true if pool['create_linked_clone']
-          return true if @config[:config]['create_linked_clones']
-        end
-      end
-    end
-  end
-end
diff --git a/scripts/create_template_deltas.rb b/scripts/create_template_deltas.rb
deleted file mode 100755
index f03ce39..0000000
--- a/scripts/create_template_deltas.rb
+++ /dev/null
@@ -1,98 +0,0 @@
-#!/usr/bin/ruby
-
-require 'rubygems'
-require 'rbvmomi'
-require 'yaml'
-
-def load_configuration( file_array )
-  file_array.each do |file|
-    file = File.expand_path( file )
-
-    if File.exists?( file )
-      return YAML.load_file( file )
-    end
-  end
-
-  return false
-end
-
-def create_template_deltas( folder )
-  config = load_configuration( [ 'vmpooler.yaml', '~/.vmpooler' ] ) || nil
-
-  abort 'No config file (./vmpooler.yaml or ~/.vmpooler) found!' unless config
-
-  vim = RbVmomi::VIM.connect(
-    :host     => config[ :providers ][ :vsphere ][ "server" ],
-    :user     => config[ :providers ][ :vsphere ][ "username" ],
-    :password => config[ :providers ][ :vsphere ][ "password" ],
-    :ssl      => true,
-    :insecure => true,
-  ) or abort "Unable to connect to #{config[ :vsphere ][ "server" ]}!"
-
-  containerView = vim.serviceContent.viewManager.CreateContainerView( {
-    :container => vim.serviceContent.rootFolder,
-    :recursive => true,
-    :type      => [ 'VirtualMachine' ]
-  } )
-
-  datacenter = vim.serviceInstance.find_datacenter
-  base = datacenter.vmFolder
-
-  case base
-    when RbVmomi::VIM::Folder
-      base = base.childEntity.find { |f| f.name == folder }
-    else
-      abort "Unexpected object type encountered (#{base.class}) while finding folder!"
-  end
-
-  unless base
-    abort "Folder #{ARGV[0]} not found!"
-  end
-
-  base.childEntity.each do |vm|
-    print vm.name
-
-    begin
-      disks = vm.config.hardware.device.grep( RbVmomi::VIM::VirtualDisk )
-    rescue
-      puts ' !'
-      next
-    end
-
-    begin
-      disks.select { |d| d.backing.parent == nil }.each do |disk|
-        linkSpec = {
-          :deviceChange => [
-            {
-              :operation => :remove,
-              :device => disk
-            },
-            {
-              :operation => :add,
-              :fileOperation => :create,
-              :device => disk.dup.tap { |x|
-                x.backing = x.backing.dup
-                x.backing.fileName = "[#{disk.backing.datastore.name}]"
-                x.backing.parent = disk.backing
-              }
-            }
-          ]
-        }
-
-        vm.ReconfigVM_Task( :spec => linkSpec ).wait_for_completion
-      end
-
-      puts " \u2713"
-    rescue
-      puts ' !'
-    end
-  end
-
-  vim.close
-end
-
-if ARGV[0]
-  create_template_deltas( ARGV[0] )
-else
-  puts "Usage: #{$0} <folder>"
-end
diff --git a/spec/rbvmomi_helper.rb b/spec/rbvmomi_helper.rb
deleted file mode 100644
index e0acbaf..0000000
--- a/spec/rbvmomi_helper.rb
+++ /dev/null
@@ -1,922 +0,0 @@
-# -----------------------------------------------------------------------------------------------------------------
-# Managed Objects (https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/index-mo_types.html)
-# -----------------------------------------------------------------------------------------------------------------
-
-MockClusterComputeResource = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.ClusterComputeResource.html
-  # From MockClusterComputeResource
-  :actionHistory, :configuration, :drsFault, :drsRecommendation, :migrationHistory, :recommendation,
-  # From ComputeResource
-  :resourcePool,
-  # From ManagedEntity
-  :name
-)
-
-MockComputeResource = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.ComputeResource.html
-  # From ComputeResource
-  :configurationEx, :datastore, :host, :network, :resourcePool, :summary,
-  # From ManagedEntity
-  :name
-)
-
-MockContainerView = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.view.ContainerView.html
-  # From ContainerView
-  :container, :recursive, :type
-) do
-  def _search_tree(layer)
-    results = []
-
-    layer.children.each do |child|
-      if type.any? { |t| child.is_a?(RbVmomi::VIM.const_get(t)) }
-        results << child
-      end
-
-      if recursive && child.respond_to?(:children)
-          results += _search_tree(child)
-      end
-    end
-    results
-  end
-
-  def view
-    _search_tree(container)
-  end
-
-  def DestroyView
-  end
-end
-
-MockDatacenter = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.Datacenter.html
-  # From Datacenter
-  :datastore, :datastoreFolder, :hostFolder, :network, :networkFolder, :vmFolder,
-  # From ManagedEntity
-  :name
-) do
-  # From RBVMOMI::VIM::Datacenter https://github.com/vmware/rbvmomi/blob/master/lib/rbvmomi/vim/Datacenter.rb
-
-  # Find the Datastore with the given +name+.
-  def find_datastore name
-    datastore.find { |x| x.name == name }
-  end
-end
-
-MockNetwork = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.Network.html
-  # From Network
-  :host, :name, :summary, :vm
-)
-
-MockVirtualVmxnet3 = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.vm.device.VirtualVmxnet.html
-  # From VirtualEthenetCard
-  :addressType,
-  # From VirtualDevice
-  :key, :deviceInfo, :backing, :connectable
-)
-
-MockDatastore = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.Datastore.html
-  # From Datastore
-  :browser, :capability, :host, :info, :iormConfiguration, :summary, :vm,
-  # From ManagedEntity
-  :name
-)
-
-MockFolder = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.Folder.html
-  # From Folder
-  :childEntity, :childType,
-  # From ManagedEntity
-  :name
-) do
-  # From RBVMOMI::VIM::Folder https://github.com/vmware/rbvmomi/blob/master/lib/rbvmomi/vim/Folder.rb#L107-L110
-  def children
-    childEntity
-  end
-
-  # https://github.com/vmware/rbvmomi/blob/master/lib/rbvmomi/vim/Folder.rb#L9-L12
-  def find(name, type=Object)
-    # Fake the searchIndex
-    childEntity.each do |child|
-      if child.name == name
-        if child.kind_of?(type)
-          return child
-        else
-          return nil
-        end
-      end
-    end
-
-    nil
-  end
-end
-
-MockHostSystem = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.HostSystem.html
-  # From HostSystem
-  :capability, :config, :configManager, :datastore, :datastoreBrowser, :hardware, :network, :runtime, :summary, :systemResources, :vm,
-  # From ManagedEntity
-  :overallStatus, :name, :parent,
-  # From ManagedObject
-  :configIssue
-)
-
-MockPropertyCollector = Struct.new(
-  # https://pubs.vmware.com/vsphere-55/index.jsp?topic=%2Fcom.vmware.wssdk.apiref.doc%2Fvmodl.query.PropertyCollector.html
-  # PropertyCollector
-  :filter
-)
-
-MockResourcePool = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.ResourcePool.html
-  # From ResourcePool
-  :childConfiguration, :config, :owner, :resourcePool, :runtime, :summary, :vm,
-  # From ManagedEntity
-  :name
-)
-
-MockSearchIndex = Object
-# https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.SearchIndex.html
-
-MockServiceInstance = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.ServiceInstance.html
-  # From ServiceInstance
-  :capability, :content, :serverClock
-) do
-  # From ServiceInstance 
-  # Mock the CurrentTime method so that it appears the ServiceInstance is valid.
-  def CurrentTime
-    Time.now
-  end
-
-  # From RBVMOMI::VIM::ServiceInstance https://github.com/vmware/rbvmomi/blob/master/lib/rbvmomi/vim/ServiceInstance.rb
-  def find_datacenter(path=nil)
-    # In our mocked instance, DataCenters are always in the root Folder.
-    # If path is nil the first DC is returned otherwise match by name
-    content.rootFolder.childEntity.each do |child|
-      if child.is_a?(RbVmomi::VIM::Datacenter)
-        return child if path.nil? || child.name == path
-      end
-    end
-    nil
-  end
-end
-
-MockTask = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.Task.html
-  # From Task
-  :info,
-) do
-  # From RBVMOMI https://github.com/vmware/rbvmomi/blob/master/lib/rbvmomi/vim/Task.rb
-  # Mock the with 'Not Implemented'
-  def wait_for_completion
-    raise(RuntimeError,'Not Implemented')
-  end
-end
-
-MockViewManager = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.view.ViewManager.html
-  # From ViewManager
-  :viewList,
-) do
-  # From ViewManager 
-  def CreateContainerView(options)
-    mock_RbVmomi_VIM_ContainerView({
-      :container => options[:container],
-      :recursive => options[:recursive],
-      :type => options[:type],
-    })
-  end
-end
-
-MockVirtualDiskManager = Object
-# https://pubs.vmware.com/vsphere-55/index.jsp#com.vmware.wssdk.apiref.doc/vim.VirtualDiskManager.html
-
-MockVirtualMachine = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.VirtualMachine.html
-  # From VirtualMachine
-  :config, :runtime, :snapshot, :summary,
-  # From ManagedEntity
-  :name,
-  # From RbVmomi::VIM::ManagedEntity
-  # https://github.com/vmware/rbvmomi/blob/master/lib/rbvmomi/vim/ManagedEntity.rb
-  :path
-)
-
-MockVirtualMachineSnapshot = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.vm.Snapshot.html
-  # From VirtualMachineSnapshot
-  :config
-)
-
-# -------------------------------------------------------------------------------------------------------------
-# Data Objects (https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/index-do_types.html)
-# -------------------------------------------------------------------------------------------------------------
-
-MockDescription = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.Description.html
-  # From Description
-  :label, :summary
-)
-
-MockVirtualEthernetCardNetworkBackingInfo = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.vm.device.VirtualEthernetCard.NetworkBackingInfo.html
-  # From VirtualEthernetCardNetworkBackingInfo
-  :network,
-
-  # From VirtualDeviceBackingInfo
-  :deviceName, :useAutoDetect
-)
-
-MockVirtualDeviceConnectInfo = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.vm.device.VirtualDevice.ConnectInfo.html
-  # From VirtualDeviceConnectInfo
-  :allowGuestControl, :connected, :startConnected
-)
-
-MockVirtualMachineConfigSpec = Struct.new(
-  # https://pubs.vmware.com/vi3/sdk/ReferenceGuide/vim.vm.ConfigSpec.html
-  # From VirtualMachineConfigSpec
-  :deviceChange, :annotation, :extraConfig
-)
-
-MockVirtualMachineRelocateSpec = Struct.new(
-  # https://pubs.vmware.com/vi3/sdk/ReferenceGuide/vim.vm.RelocateSpec.html
-  # From VirtualMachineRelocateSpec
-  :datastore, :diskMoveType, :pool
-)
-
-MockDynamicProperty = Struct.new(
-  # https://pubs.vmware.com/vsphere-55/index.jsp?topic=%2Fcom.vmware.wssdk.apiref.doc%2Fvmodl.DynamicProperty.html
-  # From DynamicProperty
-  :name, :val
-)
-
-MockHostCpuPackage = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.host.CpuPackage.html
-  # From HostCpuPackage
-  :busHz, :cpuFeature, :description, :hz, :index, :threadId, :vendor
-)
-
-MockHostHardwareSummary = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.host.Summary.HardwareSummary.html
-  # From HostHardwareSummary
-  :cpuMhz, :numCpuCores, :numCpuPkgs, :memorySize
-)
-
-MockHostListSummary = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.host.Summary.html
-  # From HostListSummary
-  :quickStats, :hardware
-)
-
-MockHostListSummaryQuickStats = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.host.Summary.QuickStats.html
-  # From HostListSummaryQuickStats
-  :overallCpuUsage, :overallMemoryUsage
-)
-
-MockHostRuntimeInfo = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.host.RuntimeInfo.html
-  # From HostRuntimeInfo
-  :bootTime, :connectionState, :healthSystemRuntime, :inMaintenanceMode, :powerState, :tpmPcrValues
-)
-
-MockHostSystemHostHardwareInfo = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.host.HardwareInfo.html
-  # From HostHardwareInfo
-  :biosInfo, :cpuFeature, :cpuInfo, :cpuPkg, :cpuPowerManagementInfo, :memorySize, :numaInfo, :pciDevice, :systemInfo
-)
-
-MockObjectContent = Struct.new(
-  # https://pubs.vmware.com/vsphere-55/index.jsp?topic=%2Fcom.vmware.wssdk.apiref.doc%2Fvmodl.query.PropertyCollector.ObjectContent.html
-  # From ObjectContent
-  :missingSet, :obj, :propSet
-)
-
-MockRetrieveResult = Struct.new(
-  # https://pubs.vmware.com/vsphere-55/index.jsp?topic=%2Fcom.vmware.wssdk.apiref.doc%2Fvmodl.query.PropertyCollector.RetrieveResult.html
-  # From RetrieveResult
-  :objects, :token
-)
-
-MockServiceContent = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.ServiceInstanceContent.html#field_detail
-  # From ServiceContent
-  :propertyCollector, :rootFolder, :searchIndex, :viewManager, :virtualDiskManager
-)
-
-MockVirtualDevice = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.vm.device.VirtualDevice.html
-  # From VirtualDevice
-  :deviceInfo, :controllerKey, :key, :backing, :connectable, :unitNumber
-)
-
-MockVirtualDisk = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.vm.device.VirtualDisk.html
-  # From VirtualDisk
-  :capacityInKB, :shares,
-  # From VirtualDevice
-  :deviceInfo, :controllerKey, :key, :backing, :connectable, :unitNumber
-)
-
-MockVirtualHardware = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.vm.VirtualHardware.html
-  # From VirtualHardware
-  :device
-)
-
-MockVirtualMachineConfigInfo = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.vm.ConfigInfo.html
-  # From VirtualMachineConfigInfo
-  :hardware
-)
-
-MockVirtualMachineFileLayoutExFileInfo = Struct.new(
-  # https://pubs.vmware.com/vsphere-55/index.jsp?topic=%2Fcom.vmware.wssdk.apiref.doc%2Fvim.vm.FileLayoutEx.FileInfo.html
-  # From VirtualMachineFileLayoutExFileInfo
-  :key, :name, :size, :type, :uniqueSize
-)
-
-MockVirtualMachineGuestSummary = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.vm.Summary.GuestSummary.html
-  # From VirtualMachineGuestSummary
-  :hostName
-)
-
-MockVirtualMachineRuntimeInfo = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.vm.RuntimeInfo.html
-  # From VirtualMachineRuntimeInfo
-  :bootTime, :cleanPowerOff, :connectionState, :faultToleranceState, :host, :maxCpuUsage, :maxMemoryUsage, :memoryOverhead,
-  :needSecondaryReason, :numMksConnections, :powerState, :question, :recordReplayState, :suspendInterval, :suspendTime, :toolsInstallerMounted
-)
-
-MockVirtualMachineSnapshotInfo = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.vm.SnapshotInfo.html
-  # From MockVirtualMachineSnapshotInfo
-  :currentSnapshot, :rootSnapshotList
-)
-
-MockVirtualMachineSnapshotTree = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.vm.SnapshotTree.html
-  # From VirtualMachineSnapshotTree
-  :backupManifest, :childSnapshotList, :createTime, :description, :id, :name, :quiesced, :replaySupported,
-  :snapshot, :state, :vm
-)
-
-MockVirtualMachineSummary = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.vm.Summary.html
-  # From VirtualMachineSummary
-  :config, :customValue, :guest, :quickStats, :runtime, :storage, :vm
-)
-
-MockVirtualSCSIController = Struct.new(
-  # https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.vm.device.VirtualSCSIController.html
-  # From VirtualSCSIController
-  :hotAddRemove, :scsiCtlrUnitNumber, :sharedBus,
-  # From VirtualDevice
-  :deviceInfo, :controllerKey, :key, :backing, :connectable, :unitNumber
-)
-
-# --------------------
-# RBVMOMI only Objects
-# --------------------
-MockRbVmomiVIMConnection = Struct.new(
-  # https://github.com/vmware/rbvmomi/blob/master/lib/rbvmomi/vim.rb
-  :serviceInstance, :serviceContent, :rootFolder, :root
-) do
-  # From https://github.com/vmware/rbvmomi/blob/master/lib/rbvmomi/vim.rb
-  # Alias to serviceContent.searchIndex
-  def searchIndex
-    serviceContent.searchIndex
-  end
-  # Alias to serviceContent.propertyCollector
-  def propertyCollector
-    serviceContent.propertyCollector
-  end
-end
-
-# -------------------------------------------------------------------------------------------------------------
-# Mocking Methods
-# -------------------------------------------------------------------------------------------------------------
-
-# https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.ClusterComputeResource.html
-def mock_RbVmomi_VIM_ClusterComputeResource(options = {})
-  options[:name]  = 'Cluster' + rand(65536).to_s if options[:name].nil?
-
-  mock = MockClusterComputeResource.new()
-
-  mock.name = options[:name]
-  # All cluster compute resources have a root Resource Pool
-  mock.resourcePool = mock_RbVmomi_VIM_ResourcePool({:name => options[:name]})
-
-  allow(mock).to receive(:is_a?) do |expected_type|
-    expected_type == RbVmomi::VIM::ClusterComputeResource
-  end
-
-  mock
-end
-
-# https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.view.ContainerView.html
-def mock_RbVmomi_VIM_ContainerView(options = {})
-  mock = MockContainerView.new()
-  mock.container = options[:container]
-  mock.recursive = options[:recursive]
-  mock.type = options[:type]
-
-  mock
-end
-
-# https://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.ComputeResource.html
-def mock_RbVmomi_VIM_ComputeResource(options = {})
-  options[:name]  = 'Compute' + rand(65536).to_s if options[:name].nil?
-  options[:hosts] = [{}] if options[:hosts].nil?
-
-  mock = MockComputeResource.new()
-
-  mock.name = options[:name]
-  mock.host = []
-
-  # A compute resource must have at least one host.
-  options[:hosts].each do |host_options|
-    mock_host = mock_RbVmomi_VIM_HostSystem(host_options)
-    mock_host.parent = mock
-    mock.host << mock_host
-  end
-
-  allow(mock).to receive(:is_a?) do |expected_type|
-    expected_type == RbVmomi::VIM::ComputeResource
-  end
-
-  mock
-end
-
-# https://github.com/vmware/rbvmomi/blob/master/lib/rbvmomi/vim.rb
-def mock_RbVmomi_VIM_Connection(options = {})
-  options[:serviceInstance] = {} if options[:serviceInstance].nil?
-  options[:serviceContent]  = {} if options[:serviceContent].nil?
-
-  mock = MockRbVmomiVIMConnection.new()
-  mock.serviceContent = mock_RbVmomi_VIM_ServiceContent(options[:serviceContent])
-  options[:serviceInstance][:servicecontent] = mock.serviceContent if options[:serviceInstance][:servicecontent].nil?
-  mock.serviceInstance = mock_RbVmomi_VIM_ServiceInstance(options[:serviceInstance])
-
-  mock
-end
-
-# https://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.Datastore.html
-def mock_RbVmomi_VIM_Datacenter(options = {})
-  options[:hostfolder_tree] = {} if options[:hostfolder_tree].nil?
-  options[:vmfolder_tree]   = {} if options[:vmfolder_tree].nil?
-  # Currently don't support mocking datastore tree
-  options[:datastores]      = [] if options[:datastores].nil?
-  options[:name]            = 'Datacenter' + rand(65536).to_s if options[:name].nil?
-  options[:networks]        = [] if options[:networks].nil?
-
-  mock = MockDatacenter.new()
-
-  mock.name = options[:name]
-  mock.hostFolder = mock_RbVmomi_VIM_Folder({ :name => 'hostFolderRoot'})
-  mock.vmFolder = mock_RbVmomi_VIM_Folder({ :name => 'vmFolderRoot'})
-  mock.datastore = []
-  mock.network = []
-
-  # Create vmFolder hierarchy
-  recurse_folder_tree(options[:vmfolder_tree],mock.vmFolder.childEntity)
-
-  # Create hostFolder hierarchy
-  recurse_folder_tree(options[:hostfolder_tree],mock.hostFolder.childEntity)
-
-  # Create mock Datastores
-  options[:datastores].each do |datastorename|
-    mock_ds = mock_RbVmomi_VIM_Datastore({ :name => datastorename })
-    mock.datastore << mock_ds
-  end
-
-  # Create mock Networks
-  options[:networks].each do |networkname|
-    mock_nw = mock_RbVmomi_VIM_Network({ :name => networkname })
-    mock.network << mock_nw
-  end
-
-  allow(mock).to receive(:is_a?) do |expected_type|
-    expected_type == RbVmomi::VIM::Datacenter
-  end
-
-  mock
-end
-
-def recurse_folder_tree(tree, root_object)
-  tree.keys.each do |foldername|
-    folder_options = tree[foldername].nil? ? {} : tree[foldername]
-    folder_options[:name] = foldername if folder_options[:name].nil?
-
-    case folder_options[:object_type]
-    when 'vm'
-      child_object = mock_RbVmomi_VIM_VirtualMachine({ :name => folder_options[:name]})
-    when 'compute_resource'
-      child_object = mock_RbVmomi_VIM_ComputeResource({ :name => folder_options[:name]})
-    when 'cluster_compute_resource'
-      child_object = mock_RbVmomi_VIM_ClusterComputeResource({ :name => folder_options[:name]})
-    when 'resource_pool'
-      child_object =  mock_RbVmomi_VIM_ResourcePool({ :name => folder_options[:name]})
-    else
-      child_object = mock_RbVmomi_VIM_Folder({:name => foldername})
-    end
-
-    # Recursively create children - Default is the child_object is a Folder
-    case folder_options[:object_type]
-    when 'cluster_compute_resource'
-      # Append children into the root Resource Pool for a cluster, instead of directly into the cluster itself.
-      recurse_folder_tree(folder_options[:children],child_object.resourcePool.resourcePool) unless folder_options[:children].nil?
-    when 'resource_pool'
-      recurse_folder_tree(folder_options[:children],child_object.resourcePool) unless folder_options[:children].nil?
-    else
-      recurse_folder_tree(folder_options[:children],child_object.childEntity) unless folder_options[:children].nil?
-    end
-
-    root_object << child_object
-  end
-end
-
-# https://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.Datastore.html
-def mock_RbVmomi_VIM_Datastore(options = {})
-  options[:name] = 'Datastore' + rand(65536).to_s if options[:name].nil?
-
-  mock = MockDatastore.new()
-
-  mock.name = options[:name]
-
-  allow(mock).to receive(:is_a?) do |expected_type|
-    expected_type == RbVmomi::VIM::Datastore
-  end
-
-  mock
-end
-
-# https://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.Network.html
-def mock_RbVmomi_VIM_Network(options = {})
-  options[:name] = 'Network' + rand(65536).to_s if options[:name].nil?
-
-  mock = MockNetwork.new()
-
-  mock.name = options[:name]
-
-  allow(mock).to receive(:is_a?) do |expected_type|
-    expected_type == RbVmomi::VIM::Network
-  end
-
-  mock
-end
-
-# https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.vm.device.VirtualVmxnet3.html
-def mock_RbVmomi_VIM_VirtualVmxnet3(options = {})
-  options[:key] = rand(65536) if options[:key].nil?
-  options[:deviceInfo] = MockDescription.new()
-  options[:backing] = MockVirtualEthernetCardNetworkBackingInfo.new()
-  options[:addressType] = 'assigned'
-  options[:connectable] = MockVirtualDeviceConnectInfo.new()
-
-  mock = MockVirtualVmxnet3.new()
-
-  mock.key = options[:key]
-  mock.deviceInfo = options[:deviceInfo]
-  mock.backing = options[:backing]
-  mock.addressType = options[:addressType]
-  mock.connectable = options[:connectable]
-
-  allow(mock).to receive(:instance_of?) do |expected_type|
-    expected_type == RbVmomi::VIM::VirtualVmxnet3
-  end
-
-  mock
-end
-
-# https://pubs.vmware.com/vi3/sdk/ReferenceGuide/vim.vm.RelocateSpec.html
-def mock_RbVmomi_VIM_VirtualMachineRelocateSpec(options = {})
-  options[:datastore] = 'Datastore' + rand(65536).to_s if options[:datastore].nil?
-  options[:diskMoveType] = :moveChildMostDiskBacking
-  options[:pool] = 'Pool' + rand(65536).to_s if options[:pool].nil?
-
-  mock = MockVirtualMachineRelocateSpec.new
-
-  mock.datastore = mock_RbVmomi_VIM_Datastore({ :name => options[:datastore]})
-  mock.diskMoveType = options[:diskMoveType]
-  mock.pool = mock_RbVmomi_VIM_ResourcePool({:name => options[:pool]})
-  allow(mock).to receive(:is_a?).and_return(RbVmomi::VIM::VirtualMachineRelocateSpec)
-  mock
-end
-
-# https://pubs.vmware.com/vi3/sdk/ReferenceGuide/vim.vm.ConfigSpec.html
-def mock_RbVmomi_VIM_VirtualMachineConfigSpec(options = {})
-  options[:device] = mock_RbVmomi_VIM_VirtualVmxnet3()
-
-
-  mock = MockVirtualMachineConfigSpec.new
-
-  mock.deviceChange = []
-  mock.deviceChange << { operation: :edit, device: options[:device]}
-
-  mock
-end
-
-# https://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.Datastore.html
-def mock_RbVmomi_VIM_Folder(options = {})
-  options[:name] = 'Folder' + rand(65536).to_s if options[:name].nil?
-
-  mock = MockFolder.new()
-
-  mock.name = options[:name]
-  mock.childEntity = []
-  allow(mock).to receive(:is_a?) do |expected_type|
-    expected_type == RbVmomi::VIM::Folder
-  end
-
-  mock
-end
-
-# https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.HostSystem.html
-def mock_RbVmomi_VIM_HostSystem(options = {})
-  options[:memory_size]          = 4294967296 if options[:memory_size].nil? # 4GB RAM
-  options[:num_cpu]              = 1 if options[:num_cpu].nil?
-  options[:num_cores_per_cpu]    = 1 if options[:num_cores_per_cpu].nil?
-  options[:cpu_speed]            = 2048 if options[:cpu_speed].nil? # 2.0 GHz 
-  options[:cpu_model]            = 'Intel(R) Xeon(R) CPU E5-2697 v4 @ 2.0GHz' if options[:cpu_model].nil?
-  options[:maintenance_mode]     = false if options[:maintenance_mode].nil?
-  options[:overall_status]       = 'green' if options[:overall_status].nil?
-  options[:overall_cpu_usage]    = 1 if options[:overall_cpu_usage].nil?
-  options[:overall_memory_usage] = 1 if options[:overall_memory_usage].nil?
-  options[:name]                 = 'HOST' + rand(65536).to_s if options[:name].nil?
-  options[:config_issue]         = [] if options[:config_issue].nil?
-
-  mock = MockHostSystem.new()
-  mock.name = options[:name]
-  mock.summary = MockHostListSummary.new()
-  mock.summary.quickStats = MockHostListSummaryQuickStats.new()
-  mock.summary.hardware = MockHostHardwareSummary.new()
-  mock.hardware = MockHostSystemHostHardwareInfo.new()
-  mock.runtime = MockHostRuntimeInfo.new()
-
-  mock.hardware.cpuPkg = []
-  (1..options[:num_cpu]).each do |cpuid|
-    mockcpu = MockHostCpuPackage.new()
-    mockcpu.hz = options[:cpu_speed] * 1024 * 1024
-    mockcpu.description = options[:cpu_model]
-    mockcpu.index = 0
-    mock.hardware.cpuPkg << mockcpu
-  end
-
-  mock.runtime.inMaintenanceMode = options[:maintenance_mode]
-  mock.overallStatus = options[:overall_status]
-  mock.configIssue = options[:config_issue]
-
-  mock.summary.hardware.memorySize = options[:memory_size]
-  mock.hardware.memorySize = options[:memory_size]
-
-  mock.summary.hardware.cpuMhz = options[:cpu_speed]
-  mock.summary.hardware.numCpuCores = options[:num_cpu] * options[:num_cores_per_cpu]
-  mock.summary.hardware.numCpuPkgs = options[:num_cpu]
-  mock.summary.quickStats.overallCpuUsage = options[:overall_cpu_usage]
-  mock.summary.quickStats.overallMemoryUsage = options[:overall_memory_usage]
-
-  mock
-end
-
-# https://pubs.vmware.com/vsphere-55/index.jsp?topic=%2Fcom.vmware.wssdk.apiref.doc%2Fvmodl.query.PropertyCollector.RetrieveResult.html
-def mock_RbVmomi_VIM_RetrieveResult(options = {})
-  options[:response] = [] if options[:response].nil?
-  mock = MockRetrieveResult.new()
-
-  mock.objects = []
-
-  options[:response].each do |response|
-    mock_objectdata = MockObjectContent.new()
-
-    mock_objectdata.propSet = []
-
-    mock_objectdata.obj = response[:object] 
-
-    # Mock the object properties
-    response.each do |key,value|
-      unless key == :object
-        mock_property = MockDynamicProperty.new()
-        mock_property.name = key
-        mock_property.val = value
-        mock_objectdata.propSet << mock_property
-      end
-    end
-    mock.objects << mock_objectdata
-  end
-
-  mock
-end
-
-# https://pubs.vmware.com/vsphere-55/index.jsp?topic=%2Fcom.vmware.wssdk.apiref.doc%2Fvmodl.query.PropertyCollector.html
-def mock_RbVmomi_VIM_PropertyCollector(options = {})
-  mock = MockPropertyCollector.new()
-
-  mock
-end
-
-# https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.ServiceInstanceContent.html#field_detail
-def mock_RbVmomi_VIM_ServiceContent(options = {})
-  options[:propertyCollector] = {} if options[:propertyCollector].nil?
-  options[:datacenters]       = [] if options[:datacenters].nil?
-
-  mock = MockServiceContent.new()
-
-  mock.searchIndex = MockSearchIndex.new()
-  mock.viewManager = MockViewManager.new()
-  mock.virtualDiskManager = MockVirtualDiskManager.new()
-  mock.rootFolder = mock_RbVmomi_VIM_Folder({ :name => 'RootFolder' })
-
-  mock.propertyCollector = mock_RbVmomi_VIM_PropertyCollector(options[:propertyCollector])
-
-  # Create the DCs in this ServiceContent
-  options[:datacenters].each do |dc_options|
-    mock_dc = mock_RbVmomi_VIM_Datacenter(dc_options)
-    mock.rootFolder.childEntity << mock_dc
-  end
-
-  mock
-end
-
-# https://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.ServiceInstance.html
-def mock_RbVmomi_VIM_ServiceInstance(options = {})
-  mock = MockServiceInstance.new()
-
-  mock.content = options[:servicecontent]
-
-  mock
-end
-
-# https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.Task.html
-def mock_RbVmomi_VIM_Task(options = {})
-  mock = MockTask.new()
-
-  mock
-end
-
-# https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.ResourcePool.html
-def mock_RbVmomi_VIM_ResourcePool(options = {})
-  options[:name] = 'ResourcePool' + rand(65536).to_s if options[:name].nil?
-
-  mock = MockResourcePool.new()
-
-  mock.name = options[:name]
-  mock.resourcePool = []
-  allow(mock).to receive(:is_a?) do |expected_type|
-    expected_type == RbVmomi::VIM::ResourcePool
-  end
-
-  mock
-end
-
-# https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.vm.device.VirtualDisk.html
-def mock_RbVmomi_VIM_VirtualDisk(options = {})
-  options[:controllerKey] = rand(65536) if options[:controllerKey].nil?
-  options[:key]           = rand(65536) if options[:key].nil?
-  options[:label]         = 'SCSI' + rand(65536).to_s if options[:label].nil?
-  options[:unitNumber]    = rand(65536) if options[:unitNumber].nil?
-
-  mock = MockVirtualDisk.new()
-  mock.deviceInfo = MockDescription.new()
-
-  mock.deviceInfo.label = options[:label]
-  mock.controllerKey = options[:controllerKey]
-  mock.key = options[:key]
-  mock.unitNumber = options[:unitNumber]
-
-  allow(mock).to receive(:is_a?) do |expected_type|
-    expected_type == RbVmomi::VIM::VirtualDisk
-  end
-
-  mock
-end
-
-# https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.VirtualMachine.html
-def mock_RbVmomi_VIM_VirtualMachine(options = {})
-  options[:snapshot_tree] = nil if options[:snapshot_tree].nil?
-  options[:name] = 'VM' + rand(65536).to_s if options[:name].nil?
-  options[:path] = [] if options[:path].nil?
-
-  mock = MockVirtualMachine.new()
-  mock.config = MockVirtualMachineConfigInfo.new()
-  mock.config.hardware = MockVirtualHardware.new([])
-  mock.summary = MockVirtualMachineSummary.new()
-  mock.summary.runtime = MockVirtualMachineRuntimeInfo.new()
-  mock.summary.guest = MockVirtualMachineGuestSummary.new()
-  mock.runtime = mock.summary.runtime
-
-  mock.name = options[:name]
-  mock.summary.guest.hostName = options[:hostname]
-  mock.runtime.bootTime = options[:boottime]
-  mock.runtime.powerState = options[:powerstate]
-
-  unless options[:snapshot_tree].nil?
-    mock.snapshot = MockVirtualMachineSnapshotInfo.new()
-    mock.snapshot.rootSnapshotList = []
-    index = 0
-
-    # Create a recursive snapshot tree
-    recurse_snapshot_tree(options[:snapshot_tree],mock.snapshot.rootSnapshotList,index)
-  end
-
-  # Create an array of items that describe the path of the VM from the root folder
-  # all the way to the VM itself
-  mock.path = []
-  options[:path].each do |path_item|
-    mock_item = nil
-    case path_item[:type]
-    when 'folder'
-      mock_item = mock_RbVmomi_VIM_Folder({ :name => path_item[:name] })
-    when 'datacenter'
-      mock_item = mock_RbVmomi_VIM_Datacenter({ :name => path_item[:name] })
-    else
-      raise("Unknown mock type #{path_item[:type]} for mock_RbVmomi_VIM_VirtualMachine")
-    end
-    mock.path << [mock_item,path_item[:name]]
-  end
-  mock.path << [mock,options[:name]]
-
-  allow(mock).to receive(:is_a?) do |expected_type|
-    expected_type == RbVmomi::VIM::VirtualMachine
-  end
-
-  mock
-end
-
-def recurse_snapshot_tree(tree, root_object, index)
-  tree.keys.each do |snapshotname|
-    snap_options = tree[snapshotname].nil? ? {} : tree[snapshotname]
-    snap = MockVirtualMachineSnapshotTree.new()
-    snap.id = index
-    snap.name = snapshotname
-    snap.childSnapshotList = []
-    snap.description = "Snapshot #{snapshotname}"
-    snap.snapshot = snap_options[:ref] unless snap_options[:ref].nil?
-
-    # Recursively create chilren
-    recurse_snapshot_tree(snap_options[:children],snap.childSnapshotList,index) unless snap_options[:children].nil?
-
-    root_object << snap
-    index += 1
-  end
-end
-
-# https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.vm.device.VirtualDevice.html
-def mock_RbVmomi_VIM_VirtualMachineDevice(options = {})
-  mock = MockVirtualDevice.new()
-  mock.deviceInfo = MockDescription.new()
-
-  mock.deviceInfo.label = options[:label]
-
-  mock
-end
-
-# https://pubs.vmware.com/vsphere-55/index.jsp?topic=%2Fcom.vmware.wssdk.apiref.doc%2Fvim.vm.FileLayoutEx.FileInfo.html
-def mock_RbVmomi_VIM_VirtualMachineFileLayoutExFileInfo(options = {})
-  options[:key] = rand(65536).to_s if options[:key].nil?
-
-  mock = MockVirtualMachineFileLayoutExFileInfo.new()
-
-  mock.key = options[:key]
-  mock.name = options[:name]
-  mock.size = options[:size]
-  mock.type = options[:type]
-  mock.uniqueSize = options[:uniqueSize]
-
-  mock
-end
-
-# https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.vm.Snapshot.html
-def mock_RbVmomi_VIM_VirtualMachineSnapshot(options = {})
-  mock = MockVirtualMachineSnapshot.new()
-  
-  mock
-end
-
-# https://www.vmware.com/support/developer/vc-sdk/visdk400pubs/ReferenceGuide/vim.vm.device.VirtualSCSIController.html
-def mock_RbVmomi_VIM_VirtualSCSIController(options = {})
-  options[:controllerKey]      = rand(65536) if options[:controllerKey].nil?
-  options[:key]                = rand(65536) if options[:key].nil?
-  options[:label]              = 'SCSI' + rand(65536).to_s if options[:label].nil?
-  options[:scsiCtlrUnitNumber] = 7 if options[:scsiCtlrUnitNumber].nil?
-
-  mock = MockVirtualSCSIController.new()
-  mock.deviceInfo = MockDescription.new()
-
-  mock.deviceInfo.label = options[:label]
-  mock.controllerKey = options[:controllerKey]
-  mock.key = options[:key]
-  mock.scsiCtlrUnitNumber = options[:scsiCtlrUnitNumber]
-
-  allow(mock).to receive(:is_a?) do |expected_type|
-    expected_type == RbVmomi::VIM::VirtualSCSIController
-  end
-
-  mock
-end
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index 080f797..dc94ee7 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -3,8 +3,6 @@ SimpleCov.start do
   add_filter '/spec/'
 end
 require 'helpers'
-require 'rbvmomi_helper'
-require 'rbvmomi'
 require 'rspec'
 require 'vmpooler'
 require 'redis'
diff --git a/spec/unit/pool_manager_spec.rb b/spec/unit/pool_manager_spec.rb
index 3bc9c68..8bbdb56 100644
--- a/spec/unit/pool_manager_spec.rb
+++ b/spec/unit/pool_manager_spec.rb
@@ -70,14 +70,13 @@ EOT
     )
     }
     it do
-      files = ["#{project_root_dir}/lib/vmpooler/providers/vsphere.rb",
-               "#{project_root_dir}/lib/vmpooler/providers/dummy.rb"]
+      files = ["#{project_root_dir}/lib/vmpooler/providers/dummy.rb"]
       expect(subject.load_used_providers).to eq(files)
     end
   end
 
   it '#default_providers' do
-    expect(subject.default_providers).to eq(['vsphere', 'dummy'])
+    expect(subject.default_providers).to eq(['dummy'])
   end
 
   describe '#check_pending_vm' do
@@ -2728,13 +2727,14 @@ EOT
   :vsphere: {}
 :pools:
   - name: #{pool}
+    provider: 'vsphere'
   - name: 'dummy'
     provider: 'vsphere'
 EOT
         )}
 
         it 'should call create_provider_object idempotently' do
-          # Even though there are two pools using the vsphere provider (the default), it should only
+          # Even though there are two pools using the vsphere provider, it should only
           # create the provider object once.
           expect(subject).to receive(:create_provider_object).with(Object, Object, Object, redis_connection_pool, 'vsphere', 'vsphere', Object).and_return(vsphere_provider)
 
@@ -2756,50 +2756,6 @@ EOT
       end
     end
 
-    context 'creating multiple vsphere Providers' do
-      let(:vsphere_provider) { double('vsphere_provider') }
-      let(:vsphere_provider2) { double('vsphere_provider') }
-      let(:provider1) { Vmpooler::PoolManager::Provider::Base.new(config, logger, metrics, redis_connection_pool, 'vsphere', provider_options) }
-      let(:provider2) { Vmpooler::PoolManager::Provider::Base.new(config, logger, metrics, redis_connection_pool, 'secondvsphere', provider_options) }
-      let(:config) {
-        YAML.load(<<-EOT
----
-:providers:
-  :vsphere:
-    server: 'blah1'
-    provider_class: 'vsphere'
-  :secondvsphere:
-    server: 'blah2'
-    provider_class: 'vsphere'
-:pools:
-  - name: #{pool}
-    provider: 'vsphere'
-  - name: 'secondpool'
-    provider: 'secondvsphere'
-EOT
-        )}
-
-      it 'should call create_provider_object twice' do
-        # The two pools use a different provider name, but each provider_class is vsphere
-        expect(subject).to receive(:create_provider_object).with(Object, Object, Object, redis_connection_pool, "vsphere", "vsphere", Object).and_return(vsphere_provider)
-        expect(subject).to receive(:create_provider_object).with(Object, Object, Object, redis_connection_pool, "vsphere", "secondvsphere", Object).and_return(vsphere_provider2)
-        subject.execute!(1,0)
-      end
-
-      it 'should have vsphere providers with different servers' do
-        allow(subject).to receive(:get_provider_for_pool).with(pool).and_return(provider1)
-        result = subject.get_provider_for_pool(pool)
-        allow(provider1).to receive(:provider_config).and_call_original
-        expect(result.provider_config['server']).to eq('blah1')
-
-        allow(subject).to receive(:get_provider_for_pool).with('secondpool').and_return(provider2)
-        result = subject.get_provider_for_pool('secondpool')
-        allow(provider1).to receive(:provider_config).and_call_original
-        expect(result.provider_config['server']).to eq('blah2')
-        subject.execute!(1,0)
-      end
-    end
-
     context 'modify configuration on startup' do
       context 'move vSphere configuration to providers location' do
         let(:config) {
@@ -2830,7 +2786,7 @@ EOT
       end
 
 
-      context 'default to the vphere provider' do
+      context 'default to the dummy provider' do
         let(:config) {
         YAML.load(<<-EOT
 ---
@@ -2841,18 +2797,18 @@ EOT
 EOT
         )}
 
-        it 'should set providers with no provider to vsphere' do
+        it 'should set providers with no provider to dummy' do
           expect(subject.config[:pools][0]['provider']).to be_nil
           expect(subject.config[:pools][1]['provider']).to eq('dummy')
 
           subject.execute!(1,0)
 
-          expect(subject.config[:pools][0]['provider']).to eq('vsphere')
+          expect(subject.config[:pools][0]['provider']).to eq('dummy')
           expect(subject.config[:pools][1]['provider']).to eq('dummy')
         end
 
         it 'should log a message' do
-          expect(logger).to receive(:log).with('d', "[!] Setting provider for pool '#{pool}' to 'vsphere' as default")
+          expect(logger).to receive(:log).with('d', "[!] Setting provider for pool '#{pool}' to 'dummy' as default")
 
           subject.execute!(1,0)
         end
diff --git a/spec/unit/providers/vsphere_spec.rb b/spec/unit/providers/vsphere_spec.rb
deleted file mode 100644
index eaf4e09..0000000
--- a/spec/unit/providers/vsphere_spec.rb
+++ /dev/null
@@ -1,3589 +0,0 @@
-require 'spec_helper'
-require 'mock_redis'
-require 'vmpooler/providers/vsphere'
-
-RSpec::Matchers.define :relocation_spec_with_host do |value|
-  match { |actual| actual[:spec].host == value }
-end
-
-RSpec::Matchers.define :create_virtual_disk_with_size do |value|
-  match { |actual| actual[:spec].capacityKb == value * 1024 * 1024 }
-end
-
-RSpec::Matchers.define :create_vm_spec do |new_name,target_folder_name,datastore|
-  match { |actual|
-    # Should have the correct new name
-    actual[:name] == new_name &&
-    # Should be in the new folder
-    actual[:folder].name == target_folder_name &&
-    # Should be poweredOn after clone
-    actual[:spec].powerOn == true &&
-    # Should be on the correct datastore
-    actual[:spec][:location].datastore.name == datastore &&
-    # Should contain annotation data
-    actual[:spec][:config].annotation != '' &&
-    # Should contain VIC information
-    actual[:spec][:config].extraConfig[0][:key] == 'guestinfo.hostname' &&
-    actual[:spec][:config].extraConfig[0][:value] == new_name
-  }
-end
-
-RSpec::Matchers.define :create_snapshot_spec do |new_snapshot_name|
-  match { |actual|
-    # Should have the correct new name
-    actual[:name] == new_snapshot_name &&
-    # Should snapshot the memory too
-    actual[:memory] == true &&
-    # Should quiesce the disk
-    actual[:quiesce] == true
-  }
-end
-
-describe 'Vmpooler::PoolManager::Provider::VSphere' do
-  let(:logger) { MockLogger.new }
-  let(:metrics) { Vmpooler::Metrics::DummyStatsd.new }
-  let(:poolname) { 'pool1'}
-  let(:provider_options) { { 'param' => 'value' } }
-  let(:datacenter_name) { 'MockDC' }
-  let(:config) { YAML.load(<<-EOT
----
-:config:
-  max_tries: 3
-  retry_factor: 10
-:providers:
-  :vsphere:
-    server: "vcenter.domain.local"
-    username: "vcenter_user"
-    password: "vcenter_password"
-    insecure: true
-    # Drop the connection pool timeout way down for spec tests so they fail fast
-    connection_pool_timeout: 1
-    datacenter: MockDC
-    create_linked_clones: true
-:pools:
-  - name: '#{poolname}'
-    alias: [ 'mockpool' ]
-    template: 'Templates/pool1'
-    folder: 'Pooler/pool1'
-    datastore: 'datastore0'
-    size: 5
-    timeout: 10
-    ready_ttl: 1440
-    clone_target: 'cluster1'
-EOT
-    )
-  }
-
-  let(:connection_options) {{}}
-  let(:connection) { mock_RbVmomi_VIM_Connection(connection_options) }
-  let(:vmname) { 'vm1' }
-  let(:redis_connection_pool) { Vmpooler::PoolManager::GenericConnectionPool.new(
-    metrics: metrics,
-    connpool_type: 'redis_connection_pool',
-    connpool_provider: 'testprovider',
-    size: 1,
-    timeout: 5
-  ) { MockRedis.new }
-  }
-
-  subject { Vmpooler::PoolManager::Provider::VSphere.new(config, logger, metrics, redis_connection_pool, 'vsphere', provider_options) }
-
-  before(:each) do
-    allow(subject).to receive(:vsphere_connection_ok?).and_return(true)
-  end
-
-  describe '#name' do
-    it 'should be vsphere' do
-      expect(subject.name).to eq('vsphere')
-    end
-  end
-
-  describe '#folder_configured?' do
-    let(:folder_title) { 'folder1' }
-    let(:other_folder) { 'folder2' }
-    let(:base_folder) { 'dc1/vm/base' }
-    let(:configured_folders) { { folder_title => base_folder } }
-    let(:whitelist) { nil }
-    it 'should return true when configured_folders includes the folder_title' do
-      expect(subject.folder_configured?(folder_title, base_folder, configured_folders, whitelist)).to be true
-    end
-
-    it 'should return false when title is not in configured_folders' do
-      expect(subject.folder_configured?(other_folder, base_folder, configured_folders, whitelist)).to be false
-    end
-
-    context 'with another base folder' do
-      let(:base_folder) { 'dc2/vm/base' }
-      let(:configured_folders) { { folder_title => 'dc1/vm/base' } }
-      it 'should return false' do
-        expect(subject.folder_configured?(folder_title, base_folder, configured_folders, whitelist)).to be false
-      end
-    end
-
-    context 'with a whitelist set' do
-      let(:whitelist) { [ other_folder ] }
-      it 'should return true' do
-        expect(subject.folder_configured?(other_folder, base_folder, configured_folders, whitelist)).to be true
-      end
-    end
-
-    context 'with string whitelist value' do
-      let(:whitelist) { 'whitelist' }
-      it 'should raise an error' do
-        expect(whitelist).to receive(:include?).and_raise('mockerror')
-
-        expect{ subject.folder_configured?(other_folder, base_folder, configured_folders, whitelist) }.to raise_error(RuntimeError, 'mockerror')
-      end
-    end
-  end
-
-  describe '#destroy_vm_and_log' do
-    let(:vm_object) { mock_RbVmomi_VIM_VirtualMachine({
-        :name => vmname,
-        :powerstate => 'poweredOn',
-      })
-    }
-    let(:pool) { 'pool1' }
-    let(:power_off_task) { mock_RbVmomi_VIM_Task() }
-    let(:destroy_task) { mock_RbVmomi_VIM_Task() }
-    let(:data_ttl) { 1 }
-    let(:finish) { '0.00' }
-    let(:now) { Time.now }
-
-    context 'when destroying a vm' do
-      before(:each) do
-        allow(power_off_task).to receive(:wait_for_completion)
-        allow(destroy_task).to receive(:wait_for_completion)
-        allow(vm_object).to receive(:PowerOffVM_Task).and_return(power_off_task)
-        allow(vm_object).to receive(:Destroy_Task).and_return(destroy_task)
-      end
-
-      it 'should log a message that the vm is destroyed' do
-        # Ensure Time returns a consistent value so finish is predictable
-        # Otherwise finish occasionally increases to 0.01 and causes a failure
-        allow(Time).to receive(:now).and_return(Time.now)
-        expect(logger).to receive(:log).with('s', "[-] [#{pool}] '#{vmname}' destroyed in #{finish} seconds")
-
-        subject.destroy_vm_and_log(vmname, vm_object, pool, data_ttl)
-      end
-
-      it 'should record metrics' do
-        expect(metrics).to receive(:timing).with('connection_waited.redis_connection_pool.testprovider', 0)
-        expect(metrics).to receive(:timing).with("destroy.#{pool}", finish)
-
-        subject.destroy_vm_and_log(vmname, vm_object, pool, data_ttl)
-      end
-
-      it 'should power off and destroy the vm' do
-        allow(destroy_task).to receive(:wait_for_completion)
-        expect(vm_object).to receive(:PowerOffVM_Task).and_return(power_off_task)
-        expect(vm_object).to receive(:Destroy_Task).and_return(destroy_task)
-
-        subject.destroy_vm_and_log(vmname, vm_object, pool, data_ttl)
-      end
-    end
-
-    context 'with a powered off vm' do
-      before(:each) do
-        vm_object.runtime.powerState = 'poweredOff'
-      end
-
-      it 'should destroy the vm without attempting to power it off' do
-        allow(destroy_task).to receive(:wait_for_completion)
-        expect(vm_object).to_not receive(:PowerOffVM_Task)
-        expect(vm_object).to receive(:Destroy_Task).and_return(destroy_task)
-
-        subject.destroy_vm_and_log(vmname, vm_object, pool, data_ttl)
-      end
-    end
-
-    context 'with a folder object' do
-      let(:folder_object) { mock_RbVmomi_VIM_Folder({ :name => vmname }) }
-
-      it 'should log that a folder object was received' do
-        expect(logger).to receive(:log).with('s', "[!] [#{pool}] '#{vmname}' is a folder, bailing on destroying")
-
-        expect{ subject.destroy_vm_and_log(vmname, folder_object, pool, data_ttl) }.to raise_error(RuntimeError, 'Expected VM, but received a folder object')
-      end
-
-      it 'should raise an error' do
-        expect{ subject.destroy_vm_and_log(vmname, folder_object, pool, data_ttl) }.to raise_error(RuntimeError, 'Expected VM, but received a folder object')
-      end
-    end
-
-    context 'with an error that is not a RuntimeError' do
-      it 'should retry three times' do
-        expect(vm_object).to receive(:PowerOffVM_Task).and_throw(:powerofffailed, 'failed').exactly(3).times
-
-        expect{ subject.destroy_vm_and_log(vmname, vm_object, pool, data_ttl) }.to raise_error(/failed/)
-      end
-    end
-  end
-
-  describe '#destroy_folder_and_children' do
-    let(:data_ttl) { 1 }
-    let(:config) {
-      {
-        redis: {
-          'data_ttl' => data_ttl
-        }
-      }
-    }
-    let(:foldername) { 'pool1' }
-    let(:folder_object) { mock_RbVmomi_VIM_Folder({ :name => foldername }) }
-
-    before(:each) do
-      $config = config
-    end
-
-    context 'with an empty folder' do
-      it 'should destroy the folder' do
-        expect(subject).to_not receive(:destroy_vm_and_log)
-        expect(subject).to receive(:destroy_folder).with(folder_object).and_return(nil)
-
-        subject.destroy_folder_and_children(folder_object)
-      end
-    end
-
-    context 'with a folder containing vms' do
-      let(:vm_object) { mock_RbVmomi_VIM_VirtualMachine({ :name => vmname }) }
-      before(:each) do
-        folder_object.childEntity << vm_object
-      end
-
-      it 'should destroy the vms' do
-        allow(subject).to receive(:destroy_vm_and_log).and_return(nil)
-        allow(subject).to receive(:destroy_folder).and_return(nil)
-        expect(subject).to receive(:destroy_vm_and_log).with(vmname, vm_object, foldername, data_ttl)
-
-        subject.destroy_folder_and_children(folder_object)
-      end
-    end
-
-    it 'should raise any errors' do
-      expect(subject).to receive(:destroy_folder).and_throw('mockerror')
-
-      expect{ subject.destroy_folder_and_children(folder_object) }.to raise_error(/mockerror/)
-    end
-  end
-
-  describe '#destroy_folder' do
-    let(:foldername) { 'pool1' }
-    let(:folder_object) { mock_RbVmomi_VIM_Folder({ :name => foldername }) }
-    let(:destroy_task) { mock_RbVmomi_VIM_Task() }
-
-    before(:each) do
-      allow(folder_object).to receive(:Destroy_Task).and_return(destroy_task)
-      allow(destroy_task).to receive(:wait_for_completion)
-    end
-
-    it 'should destroy the folder' do
-      expect(folder_object).to receive(:Destroy_Task).and_return(destroy_task)
-
-      subject.destroy_folder(folder_object)
-    end
-
-    it 'should log that the folder is being destroyed' do
-      expect(logger).to receive(:log).with('s', "[-] [#{foldername}] removing unconfigured folder")
-
-      subject.destroy_folder(folder_object)
-    end
-
-    it 'should retry three times when failing' do
-      expect(folder_object).to receive(:Destroy_Task).and_throw('mockerror').exactly(3).times
-
-      expect{ subject.destroy_folder(folder_object) }.to raise_error(/mockerror/)
-    end
-  end
-
-  describe '#purge_unconfigured_folders' do
-    let(:folder_title) { 'folder1' }
-    let(:base_folder) { 'dc1/vm/base' }
-    let(:folder_object) { mock_RbVmomi_VIM_Folder({ :name => base_folder }) }
-    let(:child_folder) { mock_RbVmomi_VIM_Folder({ :name => folder_title }) }
-    let(:whitelist) { nil }
-    let(:base_folders) { [ base_folder ] }
-    let(:configured_folders) { { folder_title => base_folder } }
-    let(:folder_children) { [ folder_title => child_folder ] }
-    let(:empty_list) { [] }
-
-    before(:each) do
-      allow(subject).to receive(:connect_to_vsphere).and_return(connection)
-    end
-
-    context 'with an empty folder' do
-      it 'should not attempt to destroy any folders' do
-        expect(subject).to receive(:get_folder_children).with(base_folder, connection).and_return(empty_list)
-        expect(subject).to_not receive(:destroy_folder_and_children)
-
-        subject.purge_unconfigured_folders(base_folders, configured_folders, whitelist)
-      end
-    end
-
-    it 'should retrieve the folder children' do
-      expect(subject).to receive(:get_folder_children).with(base_folder, connection).and_return(folder_children)
-      allow(subject).to receive(:folder_configured?).and_return(true)
-
-      subject.purge_unconfigured_folders(base_folders, configured_folders, whitelist)
-    end
-
-    context 'with a folder that is not configured' do
-      before(:each) do
-        expect(subject).to receive(:get_folder_children).with(base_folder, connection).and_return(folder_children)
-        allow(subject).to receive(:folder_configured?).and_return(false)
-      end
-
-      it 'should destroy the folder and children' do
-        expect(subject).to receive(:destroy_folder_and_children).with(child_folder).and_return(nil)
-
-        subject.purge_unconfigured_folders(base_folders, configured_folders, whitelist)
-      end
-    end
-
-    it 'should raise any errors' do
-      expect(subject).to receive(:get_folder_children).and_throw('mockerror')
-
-      expect{ subject.purge_unconfigured_folders(base_folders, configured_folders, whitelist) }.to raise_error(/mockerror/)
-    end
-  end
-
-  describe '#get_folder_children' do
-    let(:base_folder) { 'dc1/vm/base' }
-    let(:base_folder_object) { mock_RbVmomi_VIM_Folder({ :name => base_folder }) }
-    let(:foldername) { 'folder1' }
-    let(:folder_object) { mock_RbVmomi_VIM_Folder({ :name => foldername }) }
-    let(:folder_return) { [ { foldername => folder_object } ] }
-
-    before(:each) do
-      base_folder_object.childEntity << folder_object
-    end
-
-    it 'should return an array of configured folder hashes' do
-      expect(connection.searchIndex).to receive(:FindByInventoryPath).and_return(base_folder_object)
-
-      result = subject.get_folder_children(foldername, connection)
-
-      expect(result).to eq(folder_return)
-    end
-
-    it 'should raise any errors' do
-      expect(connection.searchIndex).to receive(:FindByInventoryPath).and_throw('mockerror')
-
-      expect{ subject.get_folder_children(foldername, connection) }.to raise_error(/mockerror/)
-    end
-  end
-
-  describe '#vms_in_pool' do
-    let(:folder_object) { mock_RbVmomi_VIM_Folder({ :name => 'pool1'}) }
-    let(:pool_config) { config[:pools][0] }
-
-    before(:each) do
-      allow(subject).to receive(:connect_to_vsphere).and_return(connection)
-    end
-
-    context 'Given a pool folder that is missing' do
-      before(:each) do
-        expect(subject).to receive(:find_vm_folder).with(poolname,connection).and_return(nil)
-      end
-
-      it 'should get a connection' do
-        expect(subject).to receive(:connect_to_vsphere).and_return(connection)
-
-        subject.vms_in_pool(poolname)
-      end
-
-      it 'should return an empty array' do
-        result = subject.vms_in_pool(poolname)
-
-        expect(result).to eq([])
-      end
-    end
-
-    context 'Given an empty pool folder' do
-      before(:each) do
-        expect(subject).to receive(:find_vm_folder).with(poolname,connection).and_return(folder_object)
-      end
-
-      it 'should get a connection' do
-        expect(subject).to receive(:connect_to_vsphere).and_return(connection)
-
-        subject.vms_in_pool(poolname)
-      end
-
-      it 'should return an empty array' do
-        result = subject.vms_in_pool(poolname)
-
-        expect(result).to eq([])
-      end
-    end
-
-    context 'Given a pool folder with many VMs' do
-      let(:expected_vm_list) {[
-        { 'name' => 'vm1'},
-        { 'name' => 'vm2'},
-        { 'name' => 'vm3'}
-      ]}
-      before(:each) do
-        expected_vm_list.each do |vm_hash|
-          mock_vm = mock_RbVmomi_VIM_VirtualMachine({ :name => vm_hash['name'] })
-          # Add the mocked VM to the folder
-          folder_object.childEntity << mock_vm
-        end
-
-        expect(subject).to receive(:find_vm_folder).with(poolname,connection).and_return(folder_object)
-      end
-
-      it 'should get a connection' do
-        expect(subject).to receive(:connect_to_vsphere).and_return(connection)
-
-        subject.vms_in_pool(poolname)
-      end
-
-      it 'should list all VMs in the VM folder for the pool' do
-        result = subject.vms_in_pool(poolname)
-
-        expect(result).to eq(expected_vm_list)
-      end
-    end
-
-    context 'given a pool folder with a folder and vms' do
-      let(:expected_vm_list) {[
-        { 'name' => 'vm1'},
-        { 'name' => 'vm2'},
-        { 'name' => 'vm3'}
-      ]}
-      let(:folder_object2) { mock_RbVmomi_VIM_Folder({ :name => 'pool2'}) }
-      before(:each) do
-        expected_vm_list.each do |vm_hash|
-          mock_vm = mock_RbVmomi_VIM_VirtualMachine({ :name => vm_hash['name'] })
-          # Add the mocked VM to the folder
-          folder_object.childEntity << mock_vm
-        end
-        folder_object.childEntity << folder_object2
-        expect(subject).to receive(:find_vm_folder).with(poolname,connection).and_return(folder_object)
-      end
-
-      it 'should return the vms without the folder' do
-        result = subject.vms_in_pool(poolname)
-
-        expect(result).to eq(expected_vm_list)
-      end
-    end
-  end
-
-  describe '#get_vm' do
-    let(:vm_object) { nil }
-    before(:each) do
-      allow(subject).to receive(:connect_to_vsphere).and_return(connection)
-      expect(subject).to receive(:find_vm).with(poolname,vmname,connection).and_return(vm_object)
-    end
-
-    context 'when VM does not exist' do
-      it 'should return nil' do
-        expect(subject.get_vm(poolname,vmname)).to be_nil
-      end
-    end
-
-    context 'when VM exists but is missing information' do
-      let(:vm_object) { mock_RbVmomi_VIM_VirtualMachine({
-          :name => vmname,
-        })
-      }
-
-      it 'should return a hash' do
-        expect(subject.get_vm(poolname,vmname)).to be_kind_of(Hash)
-      end
-
-      it 'should return the VM name' do
-        result = subject.get_vm(poolname,vmname)
-
-        expect(result['name']).to eq(vmname)
-      end
-
-      ['hostname','boottime','powerstate'].each do |testcase|
-        it "should return nil for #{testcase}" do
-          result = subject.get_vm(poolname,vmname)
-
-          expect(result[testcase]).to be_nil
-        end
-      end
-    end
-
-    context 'when VM exists and contains all information' do
-      let(:vm_hostname) { "#{vmname}.demo.local" }
-      let(:boot_time) { Time.now }
-      let(:power_state) { 'MockPowerState' }
-
-      let(:vm_object) { mock_RbVmomi_VIM_VirtualMachine({
-          :name => vmname,
-          :hostname => vm_hostname,
-          :powerstate => power_state,
-          :boottime => boot_time,
-          # This path should match the folder in the mocked pool in the config above
-          :path => [
-            { :type => 'folder',     :name => 'Datacenters' },
-            { :type => 'datacenter', :name => 'DC01' },
-            { :type => 'folder',     :name => 'vm' },
-            { :type => 'folder',     :name => 'Pooler' },
-            { :type => 'folder',     :name => 'pool1'},
-          ]
-        })
-      }
-      let(:pool_info) { config[:pools][0]}
-
-      it 'should return a hash' do
-        expect(subject.get_vm(poolname,vmname)).to be_kind_of(Hash)
-      end
-
-      it 'should return the VM name' do
-        result = subject.get_vm(poolname,vmname)
-
-        expect(result['name']).to eq(vmname)
-      end
-
-      it 'should return the VM hostname' do
-        result = subject.get_vm(poolname,vmname)
-
-        expect(result['hostname']).to eq(vm_hostname)
-      end
-
-      it 'should return the template name' do
-        result = subject.get_vm(poolname,vmname)
-
-        expect(result['template']).to eq(pool_info['template'])
-      end
-
-      it 'should return the pool name' do
-        result = subject.get_vm(poolname,vmname)
-
-        expect(result['poolname']).to eq(pool_info['name'])
-      end
-
-      it 'should return the boot time' do
-        result = subject.get_vm(poolname,vmname)
-
-        expect(result['boottime']).to eq(boot_time)
-      end
-
-      it 'should return the powerstate' do
-        result = subject.get_vm(poolname,vmname)
-
-        expect(result['powerstate']).to eq(power_state)
-      end
-
-    end
-  end
-
-  describe '#create_vm' do
-    let(:datacenter_object) { mock_RbVmomi_VIM_Datacenter({
-      :datastores => ['datastore0'],
-      :vmfolder_tree => {
-        'Templates' => { :children => {
-          'pool1' => { :object_type => 'vm', :name => 'pool1' },
-        }},
-        'Pooler' => { :children => {
-          'pool1' => nil,
-        }},
-      },
-      :hostfolder_tree => {
-        'cluster1' =>  {:object_type => 'compute_resource'},
-      }
-    })
-    }
-
-    let(:clone_vm_task) { mock_RbVmomi_VIM_Task() }
-    let(:new_vm_object)  { mock_RbVmomi_VIM_VirtualMachine({ :name => vmname }) }
-    let(:new_template_object)  { mock_RbVmomi_VIM_VirtualMachine({ :name => vmname }) }
-
-    before(:each) do
-      allow(subject).to receive(:connect_to_vsphere).and_return(connection)
-      allow(connection.serviceInstance).to receive(:find_datacenter).and_return(datacenter_object)
-    end
-
-    context 'Given an invalid pool name' do
-      it 'should raise an error' do
-        expect{ subject.create_vm('missing_pool', vmname) }.to raise_error(/missing_pool does not exist/)
-      end
-    end
-
-    context 'Given an invalid template path in the pool config' do
-      before(:each) do
-        config[:pools][0]['template'] = 'bad_template'
-      end
-
-      it 'should raise an error' do
-        expect{ subject.create_vm(poolname, vmname) }.to raise_error(/did not specify a full path for the template/)
-      end
-    end
-
-    context 'Given a template that starts with /' do
-      before(:each) do
-        config[:pools][0]['template'] = '/bad_template'
-      end
-
-      it 'should raise an error' do
-        expect{ subject.create_vm(poolname, vmname) }.to raise_error(/did not specify a full path for the template/)
-      end
-    end
-
-    context 'Given a template that ends with /' do
-      before(:each) do
-        config[:pools][0]['template'] = 'bad_template/'
-      end
-
-      it 'should raise an error' do
-        expect{ subject.create_vm(poolname, vmname) }.to raise_error(/did not specify a full path for the template/)
-      end
-    end
-
-    context 'Given a template VM that does not exist' do
-      before(:each) do
-        config[:pools][0]['template'] = 'Templates/missing_template'
-        expect(subject).to receive(:find_template_vm).and_raise("specifies a template VM of #{vmname} which does not exist")
-      end
-
-      it 'should raise an error' do
-        expect{ subject.create_vm(poolname, vmname) }.to raise_error(/specifies a template VM of .+ which does not exist/)
-      end
-    end
-
-    context 'when create_vm_folder returns nil' do
-      before(:each) do
-        allow(subject).to receive(:find_template_vm).and_return(new_template_object)
-        expect(subject).to receive(:find_vm_folder).and_return(nil)
-      end
-
-      it 'should raise an error' do
-        expect{ subject.create_vm(poolname, vmname) }.to raise_error(ArgumentError)
-      end
-    end
-
-    context 'Given a successful creation' do
-      let(:folder_object) { mock_RbVmomi_VIM_Folder({ :name => 'pool1'}) }
-      before(:each) do
-        template_vm = new_template_object
-        allow(subject).to receive(:find_template_vm).and_return(new_template_object)
-        allow(template_vm).to receive(:CloneVM_Task).and_return(clone_vm_task)
-        allow(clone_vm_task).to receive(:wait_for_completion).and_return(new_vm_object)
-        allow(subject).to receive(:find_vm_folder).and_return(folder_object)
-      end
-
-      it 'should return a hash' do
-        result = subject.create_vm(poolname, vmname)
-
-        expect(result.is_a?(Hash)).to be true
-      end
-
-      it 'should use the appropriate Create_VM spec' do
-        template_vm = new_template_object
-        expect(template_vm).to receive(:CloneVM_Task)
-          .with(create_vm_spec(vmname,'pool1','datastore0'))
-          .and_return(clone_vm_task)
-
-        subject.create_vm(poolname, vmname)
-      end
-
-      it 'should have the new VM name' do
-        result = subject.create_vm(poolname, vmname)
-
-        expect(result['name']).to eq(vmname)
-      end
-    end
-
-    context 'Given valid snapshot tuning settings' do
-      let(:folder_object) { mock_RbVmomi_VIM_Folder({ :name => 'pool1'}) }
-      let(:now) { Time.now }
-      let(:config_spec) {
-        [
-          { key: 'guestinfo.hostname', value: vmname },
-          { key: 'mainMem.ioBlockPages', value: '300' },
-          { key: 'mainMem.iowait', value: '2' }
-        ]
-      }
-
-      before(:each) do
-        template_vm = new_template_object
-        allow(subject).to receive(:find_template_vm).and_return(new_template_object)
-        allow(template_vm).to receive(:CloneVM_Task).and_return(clone_vm_task)
-        allow(clone_vm_task).to receive(:wait_for_completion).and_return(new_vm_object)
-        allow(subject).to receive(:find_vm_folder).and_return(folder_object)
-        allow(Time).to receive(:now).and_return(Time.now)
-        config[:pools][0]['snapshot_mainMem_ioBlockPages'] = '300'
-        config[:pools][0]['snapshot_mainMem_iowait'] = '2'
-      end
-
-      it 'should apply the appropriate extraConfig settings' do
-        result = subject.create_config_spec(vmname, "template1", config_spec)
-        expect(result.extraConfig).to include(
-          { :key => 'mainMem.ioBlockPages', :value => '300' },
-          { :key => 'mainMem.iowait', :value => '2'}
-        )
-      end
-    end
-  end
-
-  describe '#set_network_device' do
-    let(:datacenter_object) { mock_RbVmomi_VIM_Datacenter({
-      :datastores => ['datastore0'],
-      :networks => ['network0'],
-    })
-    }
-    let(:template_vm_network_device)  { mock_RbVmomi_VIM_VirtualVmxnet3() }
-
-    before(:each) do
-      allow(subject).to receive(:connect_to_vsphere).and_return(connection)
-      allow(connection.serviceInstance).to receive(:find_datacenter).and_return(datacenter_object)
-    end
-
-    context 'Given an invalid network name' do
-      network_name = "invalid_network"
-
-      it 'should raise an error' do
-        expect { subject.set_network_device("datacenter_name", template_vm_network_device, network_name, connection)}.to raise_error(/Cannot find network/)
-      end
-    end
-
-    context 'Given a valid network name' do
-      network_name = "network0"
-      it 'should return the network device' do
-        result = subject.set_network_device("datacenter_name", template_vm_network_device, network_name, connection)
-        expect(result).to be_instance_of(RbVmomi::VIM::VirtualVmxnet3)
-        expect(result.deviceInfo).to be_instance_of(RbVmomi::VIM::Description)
-        expect(result.deviceInfo.summary).to eq('network0')
-        expect(result.backing).to be_instance_of(RbVmomi::VIM::VirtualEthernetCardNetworkBackingInfo)
-        expect(result.backing.network.is_a?(RbVmomi::VIM::Network)).to be true
-        expect(result.backing.network.name).to eq('network0')
-        expect(result.connectable).to be_instance_of(RbVmomi::VIM::VirtualDeviceConnectInfo)
-        expect(result.addressType).to eq('assigned')
-      end
-    end
-  end
-
-  describe '#create_disk' do
-    let(:vm_object) { mock_RbVmomi_VIM_VirtualMachine({ :name => vmname }) }
-    let(:datastorename) { 'datastore0' }
-    let(:disk_size) { 10 }
-    before(:each) do
-      allow(subject).to receive(:connect_to_vsphere).and_return(connection)
-      allow(subject).to receive(:find_vm).with(poolname, vmname, connection).and_return(vm_object)
-    end
-
-    context 'Given an invalid pool name' do
-      it 'should raise an error' do
-        expect{ subject.create_disk('missing_pool',vmname,disk_size) }.to raise_error(/missing_pool does not exist/)
-      end
-    end
-
-    context 'Given a missing datastore in the pool config' do
-      before(:each) do
-        config[:pools][0]['datastore'] = nil
-      end
-
-      it 'should raise an error' do
-        expect{ subject.create_disk(poolname,vmname,disk_size) }.to raise_error(/does not have a datastore defined/)
-      end
-    end
-
-    context 'when VM does not exist' do
-      before(:each) do
-        expect(subject).to receive(:find_vm).with(poolname, vmname, connection).and_return(nil)
-      end
-
-      it 'should raise an error' do
-        expect{ subject.create_disk(poolname,vmname,disk_size) }.to raise_error(/VM #{vmname} .+ does not exist/)
-      end
-    end
-
-    context 'when adding the disk raises an error' do
-      before(:each) do
-        expect(subject).to receive(:add_disk).and_raise(RuntimeError,'Mock Disk Error')
-      end
-
-      it 'should raise an error' do
-        expect{ subject.create_disk(poolname,vmname,disk_size) }.to raise_error(/Mock Disk Error/)
-      end
-    end
-
-    context 'when adding the disk succeeds' do
-      before(:each) do
-        expect(subject).to receive(:add_disk).with(vm_object, disk_size, datastorename, connection, datacenter_name)
-      end
-
-      it 'should return true' do
-        expect(subject.create_disk(poolname,vmname,disk_size)).to be true
-      end
-    end
-  end
-
-  describe '#create_snapshot' do
-    let(:snapshot_task) { mock_RbVmomi_VIM_Task() }
-    let(:snapshot_name) { 'snapshot' }
-    let(:snapshot_tree) {{}}
-    let(:vm_object) { mock_RbVmomi_VIM_VirtualMachine({ :name => vmname, :snapshot_tree => snapshot_tree }) }
-
-    before(:each) do
-      allow(subject).to receive(:connect_to_vsphere).and_return(connection)
-      allow(subject).to receive(:find_vm).with(poolname, vmname,connection).and_return(vm_object)
-    end
-
-    context 'when VM does not exist' do
-      before(:each) do
-        expect(subject).to receive(:find_vm).with(poolname, vmname, connection).and_return(nil)
-      end
-
-      it 'should raise an error' do
-        expect{ subject.create_snapshot(poolname,vmname,snapshot_name) }.to raise_error(/VM #{vmname} .+ does not exist/)
-      end
-    end
-
-    context 'when snapshot already exists' do
-      let(:snapshot_object) { mock_RbVmomi_VIM_VirtualMachineSnapshot() }
-      let(:snapshot_tree) { { snapshot_name => { :ref => snapshot_object } } }
-
-      it 'should raise an error' do
-        expect{ subject.create_snapshot(poolname,vmname,snapshot_name) }.to raise_error(/Snapshot #{snapshot_name} .+ already exists /)
-      end
-    end
-
-    context 'when snapshot raises an error' do
-      before(:each) do
-        expect(vm_object).to receive(:CreateSnapshot_Task).and_raise(RuntimeError,'Mock Snapshot Error')
-      end
-
-      it 'should raise an error' do
-        expect{ subject.create_snapshot(poolname,vmname,snapshot_name) }.to raise_error(/Mock Snapshot Error/)
-      end
-    end
-
-    context 'when snapshot succeeds' do
-      before(:each) do
-        expect(vm_object).to receive(:CreateSnapshot_Task)
-          .with(create_snapshot_spec(snapshot_name))
-          .and_return(snapshot_task)
-        expect(snapshot_task).to receive(:wait_for_completion).and_return(nil)
-      end
-
-      it 'should return true' do
-        expect(subject.create_snapshot(poolname,vmname,snapshot_name)).to be true
-      end
-    end
-  end
-
-  describe '#revert_snapshot' do
-    let(:snapshot_task) { mock_RbVmomi_VIM_Task() }
-    let(:snapshot_name) { 'snapshot' }
-    let(:snapshot_tree) { { snapshot_name => { :ref => snapshot_object } } }
-    let(:snapshot_object) { mock_RbVmomi_VIM_VirtualMachineSnapshot() }
-    let(:vm_object) { mock_RbVmomi_VIM_VirtualMachine({ :name => vmname, :snapshot_tree => snapshot_tree }) }
-
-    before(:each) do
-      allow(subject).to receive(:connect_to_vsphere).and_return(connection)
-      allow(subject).to receive(:find_vm).with(poolname,vmname,connection).and_return(vm_object)
-    end
-
-    context 'when VM does not exist' do
-      before(:each) do
-        expect(subject).to receive(:find_vm).with(poolname,vmname,connection).and_return(nil)
-      end
-
-      it 'should raise an error' do
-        expect{ subject.revert_snapshot(poolname,vmname,snapshot_name) }.to raise_error(/VM #{vmname} .+ does not exist/)
-      end
-    end
-
-    context 'when snapshot does not exist' do
-      let(:snapshot_tree) {{}}
-
-      it 'should raise an error' do
-        expect{ subject.revert_snapshot(poolname,vmname,snapshot_name) }.to raise_error(/Snapshot #{snapshot_name} .+ does not exist /)
-      end
-    end
-
-    context 'when revert to snapshot raises an error' do
-      before(:each) do
-        expect(snapshot_object).to receive(:RevertToSnapshot_Task).and_raise(RuntimeError,'Mock Snapshot Error')
-      end
-
-      it 'should raise an error' do
-        expect{ subject.revert_snapshot(poolname,vmname,snapshot_name) }.to raise_error(/Mock Snapshot Error/)
-      end
-    end
-
-    context 'when revert to snapshot succeeds' do
-      before(:each) do
-        expect(snapshot_object).to receive(:RevertToSnapshot_Task).and_return(snapshot_task)
-        expect(snapshot_task).to receive(:wait_for_completion).and_return(nil)
-      end
-
-      it 'should return true' do
-        expect(subject.revert_snapshot(poolname,vmname,snapshot_name)).to be true
-      end
-    end
-  end
-
-  describe '#destroy_vm' do
-    let(:power_off_task) { mock_RbVmomi_VIM_Task() }
-    let(:destroy_task) { mock_RbVmomi_VIM_Task() }
-
-    before(:each) do
-      allow(subject).to receive(:connect_to_vsphere).and_return(connection)
-    end
-
-    context 'Given a missing VM name' do
-      before(:each) do
-        expect(subject).to receive(:find_vm).and_return(nil)
-      end
-
-      it 'should return true' do
-        expect(subject.destroy_vm(poolname, 'missing_vm')).to be true
-      end
-    end
-
-    context 'Given a powered on VM' do
-      let(:vm_object) { mock_RbVmomi_VIM_VirtualMachine({
-          :name => vmname,
-          :powerstate => 'poweredOn',
-        })
-      }
-
-      before(:each) do
-        expect(subject).to receive(:find_vm).and_return(vm_object)
-        allow(vm_object).to receive(:PowerOffVM_Task).and_return(power_off_task)
-        allow(vm_object).to receive(:Destroy_Task).and_return(destroy_task)
-
-        allow(power_off_task).to receive(:wait_for_completion)
-        allow(destroy_task).to receive(:wait_for_completion)
-      end
-
-      it 'should call PowerOffVM_Task on the VM' do
-        expect(vm_object).to receive(:PowerOffVM_Task).and_return(power_off_task)
-
-        subject.destroy_vm(poolname, vmname)
-      end
-
-      it 'should call Destroy_Task on the VM' do
-        expect(vm_object).to receive(:Destroy_Task).and_return(destroy_task)
-
-        subject.destroy_vm(poolname, vmname)
-      end
-
-      it 'should return true' do
-        expect(subject.destroy_vm(poolname, vmname)).to be true
-      end
-    end
-
-    context 'Given a powered off VM' do
-      let(:vm_object) { mock_RbVmomi_VIM_VirtualMachine({
-          :name => vmname,
-          :powerstate => 'poweredOff',
-        })
-      }
-
-      before(:each) do
-        expect(subject).to receive(:find_vm).and_return(vm_object)
-        allow(vm_object).to receive(:Destroy_Task).and_return(destroy_task)
-
-        allow(destroy_task).to receive(:wait_for_completion)
-      end
-
-      it 'should not call PowerOffVM_Task on the VM' do
-        expect(vm_object).to receive(:PowerOffVM_Task).exactly(0).times
-
-        subject.destroy_vm(poolname, vmname)
-      end
-
-      it 'should call Destroy_Task on the VM' do
-        expect(vm_object).to receive(:Destroy_Task).and_return(destroy_task)
-
-        subject.destroy_vm(poolname, vmname)
-      end
-
-      it 'should return true' do
-        expect(subject.destroy_vm(poolname, vmname)).to be true
-      end
-    end
-  end
-
-  describe '#vm_ready?' do
-    let(:domain) { nil }
-    context 'When a VM is ready' do
-      before(:each) do
-        expect(subject).to receive(:open_socket).with(vmname, domain)
-      end
-
-      it 'should return true' do
-        expect(subject.vm_ready?(poolname,vmname)).to be true
-      end
-    end
-
-    context 'When a VM is ready but the pool does not exist' do
-      # TODO not sure how to handle a VM that is passed in but
-      # not located in the pool.  Is that ready or not?
-      before(:each) do
-        expect(subject).to receive(:open_socket).with(vmname, domain)
-      end
-
-      it 'should return true' do
-        expect(subject.vm_ready?('missing_pool',vmname)).to be true
-      end
-    end
-
-    context 'When an error occurs connecting to the VM' do
-      # TODO not sure how to handle a VM that is passed in but
-      # not located in the pool.  Is that ready or not?
-      before(:each) do
-        expect(subject).to receive(:open_socket).and_raise(RuntimeError,'MockError')
-      end
-
-      it 'should return false' do
-        expect(subject.vm_ready?(poolname,vmname)).to be false
-      end
-    end
-  end
-
-  describe '#vm_exists?' do
-    it 'should return true when get_vm returns an object' do
-      allow(subject).to receive(:get_vm).with(poolname,vmname).and_return(mock_RbVmomi_VIM_VirtualMachine({ :name => vmname }))
-
-      expect(subject.vm_exists?(poolname,vmname)).to eq(true)
-    end
-
-    it 'should return false when get_vm returns nil' do
-      allow(subject).to receive(:get_vm).with(poolname,vmname).and_return(nil)
-
-      expect(subject.vm_exists?(poolname,vmname)).to eq(false)
-    end
-  end
-
-  # vSphere helper methods
-  describe '#get_target_datacenter_from_config' do
-    let(:pool_dc) { 'PoolDC'}
-    let(:provider_dc) { 'ProvDC'}
-
-    context 'when not specified' do
-      let(:config) { YAML.load(<<-EOT
----
-:config:
-:providers:
-  :vsphere:
-    server: "vcenter.domain.local"
-    username: "vcenter_user"
-    password: "vcenter_password"
-:pools:
-  - name: '#{poolname}'
-EOT
-        )
-      }
-      it 'returns nil' do
-        expect(subject.get_target_datacenter_from_config(poolname)).to be_nil
-      end
-    end
-
-    context 'when specified only in the pool' do
-      let(:config) { YAML.load(<<-EOT
----
-:config:
-:providers:
-  :vsphere:
-    server: "vcenter.domain.local"
-    username: "vcenter_user"
-    password: "vcenter_password"
-:pools:
-  - name: '#{poolname}'
-    datacenter: '#{pool_dc}'
-EOT
-        )
-      }
-      it 'returns the pool datacenter' do
-        expect(subject.get_target_datacenter_from_config(poolname)).to eq(pool_dc)
-      end
-    end
-
-    context 'when specified only in the provider' do
-      let(:config) { YAML.load(<<-EOT
----
-:config:
-:providers:
-  :vsphere:
-    server: "vcenter.domain.local"
-    username: "vcenter_user"
-    password: "vcenter_password"
-    datacenter: '#{provider_dc}'
-:pools:
-  - name: '#{poolname}'
-EOT
-        )
-      }
-      it 'returns the provider datacenter' do
-        expect(subject.get_target_datacenter_from_config(poolname)).to eq(provider_dc)
-      end
-    end
-
-    context 'when specified in the provider and pool' do
-      let(:config) { YAML.load(<<-EOT
----
-:config:
-:providers:
-  :vsphere:
-    server: "vcenter.domain.local"
-    username: "vcenter_user"
-    password: "vcenter_password"
-    datacenter: '#{provider_dc}'
-:pools:
-  - name: '#{poolname}'
-    datacenter: '#{pool_dc}'
-EOT
-        )
-      }
-      it 'returns the pool datacenter' do
-        expect(subject.get_target_datacenter_from_config(poolname)).to eq(pool_dc)
-      end
-    end
-  end
-
-  # vSphere helper methods
-  describe '#ensured_vsphere_connection' do
-    let(:config) { YAML.load(<<-EOT
----
-:config:
-:providers:
-  :vsphere:
-    # Drop the connection pool timeout way down for spec tests so they fail fast
-    connection_pool_timeout: 1
-    connection_pool_size: 1
-:pools:
-EOT
-      )
-    }
-    let(:connection1) { mock_RbVmomi_VIM_Connection(connection_options) }
-    let(:connection2) { mock_RbVmomi_VIM_Connection(connection_options) }
-
-    before(:each) do
-      allow(subject).to receive(:connect_to_vsphere).and_return(connection1)
-    end
-
-    # This is to ensure that the pool_size of 1 is in effect
-    it 'should return the same connection object when calling the pool multiple times' do
-      subject.connection_pool.with_metrics do |pool_object|
-        expect(pool_object[:connection]).to be(connection1)
-      end
-      subject.connection_pool.with_metrics do |pool_object|
-        expect(pool_object[:connection]).to be(connection1)
-      end
-      subject.connection_pool.with_metrics do |pool_object|
-        expect(pool_object[:connection]).to be(connection1)
-      end
-    end
-
-    context 'when the connection breaks' do
-      before(:each) do
-        # Emulate the connection state being good, then bad, then good again
-        expect(subject).to receive(:vsphere_connection_ok?).and_return(true, false, true)
-        expect(subject).to receive(:connect_to_vsphere).and_return(connection1, connection2)
-      end
-
-      it 'should restore the connection' do
-        subject.connection_pool.with_metrics do |pool_object|
-          # This line needs to be added to all instances of the connection_pool allocation
-          connection = subject.ensured_vsphere_connection(pool_object)
-
-          expect(connection).to be(connection1)
-        end
-
-        subject.connection_pool.with_metrics do |pool_object|
-          connection = subject.ensured_vsphere_connection(pool_object)
-          # The second connection would have failed.  This test ensures that a
-          # new connection object was created.
-          expect(connection).to be(connection2)
-        end
-
-        subject.connection_pool.with_metrics do |pool_object|
-          connection = subject.ensured_vsphere_connection(pool_object)
-          expect(connection).to be(connection2)
-        end
-      end
-    end
-  end
-
-  describe '#connect_to_vsphere' do
-    before(:each) do
-      allow(RbVmomi::VIM).to receive(:connect).and_return(connection)
-    end
-
-    let (:credentials) { config[:providers][:vsphere] }
-
-    context 'successful connection' do
-      it 'should use the supplied credentials' do
-        expect(RbVmomi::VIM).to receive(:connect).with({
-          :host     => credentials['server'],
-          :user     => credentials['username'],
-          :password => credentials['password'],
-          :insecure => credentials['insecure']
-        }).and_return(connection)
-        subject.connect_to_vsphere
-      end
-
-      it 'should honor the insecure setting' do
-        config[:providers][:vsphere][:insecure] = true
-
-        expect(RbVmomi::VIM).to receive(:connect).with({
-          :host     => credentials['server'],
-          :user     => credentials['username'],
-          :password => credentials['password'],
-          :insecure => true,
-        }).and_return(connection)
-        subject.connect_to_vsphere
-      end
-
-      it 'should default to an insecure connection' do
-        config[:providers][:vsphere][:insecure] = nil
-
-        expect(RbVmomi::VIM).to receive(:connect).with({
-          :host     => credentials['server'],
-          :user     => credentials['username'],
-          :password => credentials['password'],
-          :insecure => true
-        }).and_return(connection)
-
-        subject.connect_to_vsphere
-      end
-
-      it 'should return the connection object' do
-        result = subject.connect_to_vsphere
-
-        expect(result).to be(connection)
-      end
-
-      it 'should increment the connect.open counter' do
-        expect(metrics).to receive(:increment).with('connect.open')
-        subject.connect_to_vsphere
-      end
-    end
-
-    context 'connection is initially unsuccessful' do
-      before(:each) do
-        # Simulate a failure and then success
-        expect(RbVmomi::VIM).to receive(:connect).and_raise(RuntimeError,'MockError').ordered
-        expect(RbVmomi::VIM).to receive(:connect).and_return(connection).ordered
-
-        allow(subject).to receive(:sleep)
-      end
-
-      it 'should return the connection object' do
-        result = subject.connect_to_vsphere
-
-        expect(result).to be(connection)
-      end
-
-      it 'should increment the connect.fail and then connect.open counter' do
-        expect(metrics).to receive(:increment).with('connect.fail').exactly(1).times
-        expect(metrics).to receive(:increment).with('connect.open').exactly(1).times
-        subject.connect_to_vsphere
-      end
-    end
-
-    context 'connection is always unsuccessful' do
-      before(:each) do
-        allow(RbVmomi::VIM).to receive(:connect).and_raise(RuntimeError,'MockError')
-        allow(subject).to receive(:sleep)
-      end
-
-      it 'should retry the connection attempt config.max_tries times' do
-        expect(RbVmomi::VIM).to receive(:connect).exactly(config[:config]['max_tries']).times
-
-        begin
-          # Swallow any errors
-          subject.connect_to_vsphere
-        rescue
-        end
-      end
-
-      it 'should increment the connect.fail counter config.max_tries times' do
-        expect(metrics).to receive(:increment).with('connect.fail').exactly(config[:config]['max_tries']).times
-
-        begin
-          # Swallow any errors
-          subject.connect_to_vsphere
-        rescue
-        end
-      end
-
-      [{:max_tries => 5, :retry_factor => 1},
-      {:max_tries => 8, :retry_factor => 5},
-      ].each do |testcase|
-        context "Configuration set for max_tries of #{testcase[:max_tries]} and retry_facter of #{testcase[:retry_factor]}" do
-          it "should sleep #{testcase[:max_tries] - 1} times between attempts with increasing timeout" do
-            config[:config]['max_tries'] = testcase[:max_tries]
-            config[:config]['retry_factor'] = testcase[:retry_factor]
-
-            (1..testcase[:max_tries] - 1).each do |try|
-              expect(subject).to receive(:sleep).with(testcase[:retry_factor] * try).ordered
-            end
-
-            begin
-              # Swallow any errors
-              subject.connect_to_vsphere
-            rescue
-            end
-          end
-        end
-      end
-    end
-  end
-
-  describe '#open_socket' do
-    let(:TCPSocket) { double('tcpsocket') }
-    let(:socket) { double('tcpsocket') }
-    let(:hostname) { 'host' }
-    let(:domain) { 'domain.local'}
-    let(:default_socket) { 22 }
-
-    before do
-      expect(subject).not_to be_nil
-      allow(socket).to receive(:close)
-    end
-
-    it 'opens socket with defaults' do
-      expect(TCPSocket).to receive(:new).with(hostname,default_socket).and_return(socket)
-
-      expect(subject.open_socket(hostname)).to eq(nil)
-    end
-
-    it 'yields the socket if a block is given' do
-      expect(TCPSocket).to receive(:new).with(hostname,default_socket).and_return(socket)
-
-      expect{ |socket| subject.open_socket(hostname,nil,nil,default_socket,&socket) }.to yield_control.exactly(1).times 
-    end
-
-    it 'closes the opened socket' do
-      expect(TCPSocket).to receive(:new).with(hostname,default_socket).and_return(socket)
-      expect(socket).to receive(:close)
-
-      expect(subject.open_socket(hostname)).to eq(nil)
-    end
-
-    it 'opens a specific socket' do
-      expect(TCPSocket).to receive(:new).with(hostname,80).and_return(socket)
-
-      expect(subject.open_socket(hostname,nil,nil,80)).to eq(nil)
-    end
-
-    it 'uses a specific domain with the hostname' do
-      expect(TCPSocket).to receive(:new).with("#{hostname}.#{domain}",default_socket).and_return(socket)
-
-      expect(subject.open_socket(hostname,domain)).to eq(nil)
-    end
-
-    it 'raises error if host is not resolvable' do
-      expect(TCPSocket).to receive(:new).with(hostname,default_socket).and_raise(SocketError,'getaddrinfo: No such host is known')
-
-      expect { subject.open_socket(hostname,nil,1) }.to raise_error(SocketError)
-    end
-
-    it 'raises error if socket is not listening' do
-      expect(TCPSocket).to receive(:new).with(hostname,default_socket).and_raise(SocketError,'No connection could be made because the target machine actively refused it')
-
-      expect { subject.open_socket(hostname,nil,1) }.to raise_error(SocketError)
-    end
-  end
-
-  describe '#get_vm_folder_path' do
-    [
-      { :path_description => 'Datacenters/DC01/vm/Pooler/pool1/vm1',
-        :expected_path => 'Pooler/pool1',
-        :vm_object_path => [
-          { :type => 'folder',     :name => 'Datacenters' },
-          { :type => 'datacenter', :name => 'DC01' },
-          { :type => 'folder',     :name => 'vm' },
-          { :type => 'folder',     :name => 'Pooler' },
-          { :type => 'folder',     :name => 'pool1'},
-        ],
-      },
-      { :path_description => 'Datacenters/DC01/vm/something/subfolder/pool/vm1',
-        :expected_path => 'something/subfolder/pool',
-        :vm_object_path => [
-          { :type => 'folder',     :name => 'Datacenters' },
-          { :type => 'datacenter', :name => 'DC01' },
-          { :type => 'folder',     :name => 'vm' },
-          { :type => 'folder',     :name => 'something' },
-          { :type => 'folder',     :name => 'subfolder' },
-          { :type => 'folder',     :name => 'pool'},
-        ],
-      },
-      { :path_description => 'Datacenters/DC01/vm/vm1',
-        :expected_path => '',
-        :vm_object_path => [
-          { :type => 'folder',     :name => 'Datacenters' },
-          { :type => 'datacenter', :name => 'DC01' },
-          { :type => 'folder',     :name => 'vm' },
-        ],
-      },
-    ].each do |testcase|
-      context "given a path of #{testcase[:path_description]}" do
-        it "should return '#{testcase[:expected_path]}'" do
-          vm_object = mock_RbVmomi_VIM_VirtualMachine({
-            :name => 'vm1',
-            :path => testcase[:vm_object_path],
-          })
-          expect(subject.get_vm_folder_path(vm_object)).to eq(testcase[:expected_path])
-        end
-      end
-    end
-
-    [
-      { :path_description => 'a path missing a Datacenter',
-        :vm_object_path => [
-          { :type => 'folder',     :name => 'Datacenters' },
-          { :type => 'folder',     :name => 'vm' },
-          { :type => 'folder',     :name => 'Pooler' },
-          { :type => 'folder',     :name => 'pool1'},
-        ],
-      },
-      { :path_description => 'a path missing root VM folder',
-        :vm_object_path => [
-          { :type => 'folder',     :name => 'Datacenters' },
-          { :type => 'datacenter', :name => 'DC01' },
-        ],
-      },
-    ].each do |testcase|
-      context "given #{testcase[:path_description]}" do
-        it "should return nil" do
-          vm_object = mock_RbVmomi_VIM_VirtualMachine({
-            :name => 'vm1',
-            :path => testcase[:vm_object_path],
-          })
-          expect(subject.get_vm_folder_path(vm_object)).to be_nil
-        end
-      end
-    end
-  end
-
-  describe '#add_disk' do
-    let(:datastorename) { 'datastore' }
-    let(:disk_size) { 30 }
-    let(:collectMultiple_response) { {} }
-
-    let(:vm_scsi_controller) { mock_RbVmomi_VIM_VirtualSCSIController() }
-
-    # Require at least one SCSI Controller
-    let(:vm_object) {
-      mock_vm = mock_RbVmomi_VIM_VirtualMachine({
-        :name => vmname,
-      })
-      mock_vm.config.hardware.device << vm_scsi_controller
-
-      mock_vm
-    }
-
-    # Require at least one DC with the required datastore
-    let(:connection_options) {{
-      :serviceContent => {
-        :datacenters => [
-          { :name => datacenter_name, :datastores => [datastorename] }
-        ]
-      }
-    }}
-
-    let(:create_virtual_disk_task) { mock_RbVmomi_VIM_Task() }
-    let(:reconfig_vm_task) { mock_RbVmomi_VIM_Task() }
-
-    before(:each) do
-      # Mocking for find_vmdks
-      allow(connection.serviceContent.propertyCollector).to receive(:collectMultiple).and_return(collectMultiple_response)
-
-      # Mocking for creating the disk
-      allow(connection.serviceContent.virtualDiskManager).to receive(:CreateVirtualDisk_Task) do |options|
-        if options[:datacenter][:name] == datacenter_name
-          create_virtual_disk_task
-        end
-      end
-      allow(create_virtual_disk_task).to receive(:wait_for_completion).and_return(true)
-
-      # Mocking for adding disk to the VM
-      allow(vm_object).to receive(:ReconfigVM_Task).and_return(reconfig_vm_task)
-      allow(reconfig_vm_task).to receive(:wait_for_completion).and_return(true)
-    end
-
-    context 'Successfully adding disk' do
-      it 'should return true' do
-        expect(subject.add_disk(vm_object,disk_size,datastorename,connection,datacenter_name)).to be true
-      end
-
-      it 'should request a disk of appropriate size' do
-        expect(connection.serviceContent.virtualDiskManager).to receive(:CreateVirtualDisk_Task)
-          .with(create_virtual_disk_with_size(disk_size))
-          .and_return(create_virtual_disk_task)
-
-
-        subject.add_disk(vm_object,disk_size,datastorename,connection,datacenter_name)
-      end
-    end
-
-    context 'Requested disk size is 0' do
-      it 'should raise an error' do
-        expect(subject.add_disk(vm_object,0,datastorename,connection,datacenter_name)).to be false
-      end
-    end
-
-    context 'No datastores or datastore missing' do
-      let(:connection_options) {{
-        :serviceContent => {
-          :datacenters => [
-            { :name => datacenter_name, :datastores => ['missing_datastore'] }
-          ]
-        }
-      }}
-
-      it 'should raise error' do
-        expect{ subject.add_disk(vm_object,disk_size,datastorename,connection,datacenter_name) }.to raise_error(/does not exist/)
-      end
-    end
-
-    context 'Multiple datacenters with multiple datastores' do
-      let(:connection_options) {{
-        :serviceContent => {
-          :datacenters => [
-            { :name => 'AnotherDC', :datastores => ['dc1','dc2'] },
-            { :name => datacenter_name, :datastores => ['dc3',datastorename,'dc4'] },
-          ]
-        }
-      }}
-
-      it 'should return true' do
-        expect(subject.add_disk(vm_object,disk_size,datastorename,connection,datacenter_name)).to be true
-      end
-    end
-
-    context 'VM does not have a SCSI Controller' do
-      let(:vm_object) {
-        mock_vm = mock_RbVmomi_VIM_VirtualMachine({
-          :name => vmname,
-        })
-
-        mock_vm
-      }
-
-      it 'should raise an error' do
-        expect{ subject.add_disk(vm_object,disk_size,datastorename,connection,datacenter_name) }.to raise_error(NoMethodError)
-      end
-    end
-  end
-
-  describe '#create_clone_spec' do
-    let(:relocate_spec) { mock_RbVmomi_VIM_VirtualMachineRelocateSpec({
-      :datastore => 'datastore0',
-      :diskMoveType => :moveChildMostDiskBacking,
-      :pool => 'pool0'
-    })
-    }
-
-    let(:config_spec) { mock_RbVmomi_VIM_VirtualMachineConfigSpec()}
-
-    it 'should return the configured clone spec' do
-      result = subject.create_clone_spec(relocate_spec, config_spec)
-      expect(result.location.pool.name).to eq('pool0')
-      expect(result.location.datastore.name).to eq('datastore0')
-      expect(result.location.diskMoveType).to eq(:moveChildMostDiskBacking)
-      expect(result.config.deviceChange.first[:operation]).to eq(:edit)
-      expect(result.config.deviceChange.first[:device].instance_of?(RbVmomi::VIM::VirtualVmxnet3)).to be true
-    end
-  end
-
-  describe '#find_datastore' do
-    let(:datastorename) { 'datastore' }
-    let(:datastore_list) { [] }
-
-    context 'No datastores in the datacenter' do
-      let(:connection_options) {{
-        :serviceContent => {
-          :datacenters => [
-            { :name => datacenter_name, :datastores => [] }
-          ]
-        }
-      }}
-
-      it 'should return nil if the datastore is not found' do
-        result = subject.find_datastore(datastorename,connection,datacenter_name)
-        expect(result).to be_nil
-      end
-    end
-
-    context 'Many datastores in the datacenter' do
-      let(:connection_options) {{
-        :serviceContent => {
-          :datacenters => [
-            { :name => datacenter_name, :datastores => ['ds1','ds2',datastorename,'ds3'] }
-          ]
-        }
-      }}
-
-      it 'should return nil if the datastore is not found' do
-        result = subject.find_datastore('missing_datastore',connection,datacenter_name)
-        expect(result).to be_nil
-      end
-
-      it 'should find the datastore in the datacenter' do
-        result = subject.find_datastore(datastorename,connection,datacenter_name)
-        
-        expect(result).to_not be_nil
-        expect(result.is_a?(RbVmomi::VIM::Datastore)).to be true
-        expect(result.name).to eq(datastorename)
-      end
-    end
-
-    context 'Many datastores in many datacenters' do
-      let(:connection_options) {{
-        :serviceContent => {
-          :datacenters => [
-            { :name => 'AnotherDC', :datastores => ['ds1','ds2','ds3'] },
-            { :name => datacenter_name, :datastores => ['ds3','ds4',datastorename,'ds5'] },
-          ]
-        }
-      }}
-
-      it 'should return nil if the datastore is not found' do
-        result = subject.find_datastore(datastorename,connection,'AnotherDC')
-        expect(result).to be_nil
-      end
-
-      it 'should find the datastore in the datacenter' do
-        result = subject.find_datastore(datastorename,connection,datacenter_name)
-        
-        expect(result).to_not be_nil
-        expect(result.is_a?(RbVmomi::VIM::Datastore)).to be true
-        expect(result.name).to eq(datastorename)
-      end
-    end
-  end
-
-  describe '#find_device' do
-    let(:devicename) { 'device1' }
-    let(:vm_object) {
-      mock_vm = mock_RbVmomi_VIM_VirtualMachine()
-      mock_vm.config.hardware.device << mock_RbVmomi_VIM_VirtualMachineDevice({:label => 'device1'})
-      mock_vm.config.hardware.device << mock_RbVmomi_VIM_VirtualMachineDevice({:label => 'device2'})
-
-      mock_vm
-    }
-
-    it 'should return a device if the device name matches' do
-      result = subject.find_device(vm_object,devicename)
-
-      expect(result.deviceInfo.label).to eq(devicename)
-    end
-
-    it 'should return nil if the device name does not match' do
-      result = subject.find_device(vm_object,'missing_device')
-
-      expect(result).to be_nil
-    end
-  end
-
-  describe '#find_disk_controller' do
-    let(:vm_object) {
-      mock_vm = mock_RbVmomi_VIM_VirtualMachine()
-
-      mock_vm
-    }
-
-    it 'should return nil when there are no devices' do
-      result = subject.find_disk_controller(vm_object)
-
-      expect(result).to be_nil
-    end
-
-    [0,1,14].each do |testcase|
-      it "should return a device for a single VirtualSCSIController with #{testcase} attached disks" do
-        mock_scsi = mock_RbVmomi_VIM_VirtualSCSIController()
-        vm_object.config.hardware.device << mock_scsi
-        vm_object.config.hardware.device << mock_RbVmomi_VIM_VirtualMachineDevice({:label => 'device1'})
-        vm_object.config.hardware.device << mock_RbVmomi_VIM_VirtualMachineDevice({:label => 'device2'})
-
-        # Add the disks
-        (1..testcase).each do
-          vm_object.config.hardware.device << mock_RbVmomi_VIM_VirtualDisk({ :controllerKey => mock_scsi.key })
-        end
-
-        result = subject.find_disk_controller(vm_object)
-
-        expect(result).to eq(mock_scsi)
-      end
-    end
-
-    [15].each do |testcase|
-      it "should return nil for a single VirtualSCSIController with #{testcase} attached disks" do
-        mock_scsi = mock_RbVmomi_VIM_VirtualSCSIController()
-        vm_object.config.hardware.device << mock_scsi
-        vm_object.config.hardware.device << mock_RbVmomi_VIM_VirtualMachineDevice({:label => 'device1'})
-        vm_object.config.hardware.device << mock_RbVmomi_VIM_VirtualMachineDevice({:label => 'device2'})
-
-        # Add the disks
-        (1..testcase).each do
-          vm_object.config.hardware.device << mock_RbVmomi_VIM_VirtualDisk({ :controllerKey => mock_scsi.key })
-        end
-
-        result = subject.find_disk_controller(vm_object)
-
-        expect(result).to be_nil
-      end
-    end
-
-    it 'should raise if a VirtualDisk is missing a controller' do
-      # Note - Typically this is not possible as a VirtualDisk requires a controller (SCSI, PVSCSI or IDE)
-      mock_scsi = mock_RbVmomi_VIM_VirtualDisk()
-      vm_object.config.hardware.device << mock_scsi
-      vm_object.config.hardware.device << mock_RbVmomi_VIM_VirtualMachineDevice({:label => 'device1'})
-      vm_object.config.hardware.device << mock_RbVmomi_VIM_VirtualMachineDevice({:label => 'device2'})
-
-      expect{subject.find_disk_controller(vm_object)}.to raise_error(NoMethodError)
-    end
-  end
-
-  describe '#find_disk_devices' do
-    let(:vm_object) {
-      mock_vm = mock_RbVmomi_VIM_VirtualMachine()
-
-      mock_vm
-    }
-
-    it 'should return empty hash when there are no devices' do
-      result = subject.find_disk_devices(vm_object)
-
-      expect(result).to eq({})
-    end
-
-    it 'should return empty hash when there are no VirtualSCSIController or VirtualDisk devices' do
-      vm_object.config.hardware.device << mock_RbVmomi_VIM_VirtualMachineDevice({:label => 'device1'})
-      vm_object.config.hardware.device << mock_RbVmomi_VIM_VirtualMachineDevice({:label => 'device2'})
-
-      result = subject.find_disk_devices(vm_object)
-
-      expect(result).to eq({})
-    end
-
-    it 'should return a device for a VirtualSCSIController device with no children' do
-      mock_scsi = mock_RbVmomi_VIM_VirtualSCSIController()
-      vm_object.config.hardware.device << mock_scsi
-      vm_object.config.hardware.device << mock_RbVmomi_VIM_VirtualMachineDevice({:label => 'device1'})
-
-      result = subject.find_disk_devices(vm_object)
-
-      expect(result.count).to eq(1)
-      expect(result[mock_scsi.key]).to_not be_nil
-      expect(result[mock_scsi.key]['children']).to eq([])
-      expect(result[mock_scsi.key]['device']).to eq(mock_scsi)
-    end
-
-    it 'should return a device for a VirtualDisk device' do
-      mock_disk = mock_RbVmomi_VIM_VirtualDisk()
-      vm_object.config.hardware.device << mock_disk
-      vm_object.config.hardware.device << mock_RbVmomi_VIM_VirtualMachineDevice({:label => 'device1'})
-
-      result = subject.find_disk_devices(vm_object)
-
-      expect(result.count).to eq(1)
-      expect(result[mock_disk.controllerKey]).to_not be_nil
-      expect(result[mock_disk.controllerKey]['children'][0]).to eq(mock_disk)
-    end
-
-    it 'should return one device for many VirtualDisk devices on the same controller' do
-      controller1Key = rand(2000)
-      controller2Key = controller1Key + 1
-      mock_disk1 = mock_RbVmomi_VIM_VirtualDisk({:controllerKey => controller1Key})
-      mock_disk2 = mock_RbVmomi_VIM_VirtualDisk({:controllerKey => controller1Key})
-      mock_disk3 = mock_RbVmomi_VIM_VirtualDisk({:controllerKey => controller2Key})
-
-      vm_object.config.hardware.device << mock_disk2
-      vm_object.config.hardware.device << mock_disk1
-      vm_object.config.hardware.device << mock_disk3
-
-      result = subject.find_disk_devices(vm_object)
-
-      expect(result.count).to eq(2)
-
-      expect(result[controller1Key]).to_not be_nil
-      expect(result[controller2Key]).to_not be_nil
-
-      expect(result[controller1Key]['children']).to contain_exactly(mock_disk1,mock_disk2)
-      expect(result[controller2Key]['children']).to contain_exactly(mock_disk3)
-    end
-  end
-
-  describe '#find_disk_unit_number' do
-    let(:vm_object) {
-      mock_vm = mock_RbVmomi_VIM_VirtualMachine()
-
-      mock_vm
-    }
-    let(:controller) { mock_RbVmomi_VIM_VirtualSCSIController() }
-
-    it 'should return 0 when there are no devices' do
-      result = subject.find_disk_unit_number(vm_object,controller)
-
-      expect(result).to eq(0)
-    end
-
-    context 'with a single SCSI Controller' do
-      before(:each) do
-        vm_object.config.hardware.device << controller
-      end
-
-      it 'should return 1 when the host bus controller is at 0' do
-        controller.scsiCtlrUnitNumber = 0
-
-        result = subject.find_disk_unit_number(vm_object,controller)
-
-        expect(result).to eq(1)
-      end
-
-      it 'should return the next lowest id when disks are attached' do
-        expected_id = 9
-        controller.scsiCtlrUnitNumber = 0
-
-        (1..expected_id-1).each do |disk_id|
-          mock_disk = mock_RbVmomi_VIM_VirtualDisk({
-            :controllerKey => controller.key,
-            :unitNumber => disk_id,
-          })
-          vm_object.config.hardware.device << mock_disk
-        end
-        result = subject.find_disk_unit_number(vm_object,controller)
-
-        expect(result).to eq(expected_id)
-      end
-
-      it 'should return nil when there are no spare units' do
-        controller.scsiCtlrUnitNumber = 0
-
-        (1..15).each do |disk_id|
-          mock_disk = mock_RbVmomi_VIM_VirtualDisk({
-            :controllerKey => controller.key,
-            :unitNumber => disk_id,
-          })
-          vm_object.config.hardware.device << mock_disk
-        end
-        result = subject.find_disk_unit_number(vm_object,controller)
-
-        expect(result).to eq(nil)
-      end
-    end
-  end
-
-  describe '#find_vm_folder' do
-    let(:foldername) { 'folder'}
-
-    context 'with no folder hierarchy' do
-
-      it 'should return nil if the folder is not found' do
-        allow(connection.searchIndex).to receive(:FindByInventoryPath).and_return(nil)
-        expect(subject.find_vm_folder(poolname,connection)).to be_nil
-      end
-    end
-
-    context 'with a single layer folder hierarchy' do
-      let(:folder_object) { mock_RbVmomi_VIM_Folder({ :name => foldername}) }
-
-      it 'should return the folder when found' do
-        allow(connection.searchIndex).to receive(:FindByInventoryPath).and_return(folder_object)
-        allow(folder_object).to receive(:instance_of?).and_return(RbVmomi::VIM::Folder)
-        result = subject.find_vm_folder(poolname,connection)
-        expect(result.name).to eq(foldername)
-      end
-
-      it 'should return nil if the folder is not found' do
-        allow(connection.searchIndex).to receive(:FindByInventoryPath).and_return(nil)
-        expect(subject.find_vm_folder(poolname,connection)).to be_nil
-      end
-    end
-
-    context 'with a single layer folder hierarchy in many datacenters' do
-      let(:folder_object) { mock_RbVmomi_VIM_Folder({ :name => foldername}) }
-
-      it 'should return the folder when found' do
-        allow(connection.searchIndex).to receive(:FindByInventoryPath).and_return(folder_object)
-        allow(folder_object).to receive(:instance_of?).and_return(RbVmomi::VIM::Folder)
-        result = subject.find_vm_folder(poolname,connection)
-        expect(result.name).to eq(foldername)
-      end
-
-      it 'should return nil if the folder is not found' do
-        allow(connection.searchIndex).to receive(:FindByInventoryPath).and_return(nil)
-        expect(subject.find_vm_folder(poolname,connection)).to be_nil
-      end
-    end
-
-    context 'with a multi layer folder hierarchy' do
-      let(:foldername) { 'folder2/folder4/folder' }
-      let(:folder_object) { mock_RbVmomi_VIM_Folder({ :name => foldername}) }
-
-      it 'should return the folder when found' do
-        allow(connection.searchIndex).to receive(:FindByInventoryPath).and_return(folder_object)
-        allow(folder_object).to receive(:instance_of?).and_return(RbVmomi::VIM::Folder)
-        result = subject.find_vm_folder(poolname,connection)
-        expect(result.name).to eq(foldername)
-      end
-
-      it 'should return nil if the folder is not found' do
-        allow(connection.searchIndex).to receive(:FindByInventoryPath).and_return(nil)
-        expect(subject.find_vm_folder(poolname,connection)).to be_nil
-      end
-    end
-  end
-
-  describe '#get_host_utilization' do
-    let(:cpu_model) { 'vendor line type sku v4 speed' }
-    let(:model) { 'v4' }
-    let(:different_model) { 'different_model' }
-    let(:limit) { 75 }
-    let(:default_limit) { 90 }
-
-    context "host with a different model" do
-      let(:host) { mock_RbVmomi_VIM_HostSystem() }
-      it 'should return nil' do
-        expect(subject.get_host_utilization(host,different_model,limit)).to be_nil
-      end
-    end
-
-    context "host in maintenance mode" do
-      let(:host) { mock_RbVmomi_VIM_HostSystem({
-        :maintenance_mode => true,
-        })
-      }
-      it 'should return nil' do
-        host.runtime.inMaintenanceMode = true
-
-        expect(subject.get_host_utilization(host,model,limit)).to be_nil
-      end
-    end
-
-    context "host with status of not green" do
-      let(:host) { mock_RbVmomi_VIM_HostSystem({
-        :overall_status => 'purple_alert',
-        })
-      }
-      it 'should return nil' do
-        expect(subject.get_host_utilization(host,model,limit)).to be_nil
-      end
-    end
-
-    context "host with configuration issue" do
-      let(:host) { mock_RbVmomi_VIM_HostSystem({
-        :config_issue => 'No quickstats',
-      })
-      }
-      it 'should return nil' do
-        expect(subject.get_host_utilization(host,model,limit)).to be_nil
-      end
-    end
-
-    # CPU utilization
-    context "host which exceeds limit in CPU utilization" do
-      let(:host) { mock_RbVmomi_VIM_HostSystem({
-        :overall_cpu_usage => 100,
-        :overall_memory_usage => 1,
-        :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024,
-        })
-      }
-      it 'should return nil' do
-        expect(subject.get_host_utilization(host,model,limit)).to be_nil
-      end
-    end
-
-    context "host which exceeds default limit in CPU utilization" do
-      let(:host) { mock_RbVmomi_VIM_HostSystem({
-        :overall_cpu_usage => default_limit + 1.0,
-        :overall_memory_usage => 1,
-        :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024,
-        })
-      }
-      it 'should return nil' do
-        expect(subject.get_host_utilization(host,model)).to be_nil
-      end
-    end
-
-    context "host which does not exceed default limit in CPU utilization" do
-      let(:host) { mock_RbVmomi_VIM_HostSystem({
-        :overall_cpu_usage => default_limit,
-        :overall_memory_usage => 1,
-        :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024,
-        })
-      }
-      it 'should not return nil' do
-        expect(subject.get_host_utilization(host,model)).to_not be_nil
-      end
-    end
-
-    # Memory utilization
-    context "host which exceeds limit in Memory utilization" do
-      let(:host) { mock_RbVmomi_VIM_HostSystem({
-        :overall_cpu_usage => 1,
-        :overall_memory_usage => 100,
-        :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024,
-        })
-      }
-      it 'should return nil' do
-        # Set the Memory Usage to 100%
-        expect(subject.get_host_utilization(host,model,limit)).to be_nil
-      end
-    end
-
-    context "host which exceeds default limit in Memory utilization" do
-      let(:host) { mock_RbVmomi_VIM_HostSystem({
-        :overall_cpu_usage => 1,
-        :overall_memory_usage => default_limit + 1.0,
-        :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024,
-        })
-      }
-      it 'should return nil' do
-        expect(subject.get_host_utilization(host,model)).to be_nil
-      end
-    end
-
-    context "host which does not exceed default limit in Memory utilization" do
-      let(:host) { mock_RbVmomi_VIM_HostSystem({
-        :overall_cpu_usage => 1,
-        :overall_memory_usage => default_limit,
-        :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024,
-        })
-      }
-      it 'should not return nil' do
-        expect(subject.get_host_utilization(host,model)).to_not be_nil
-      end
-    end
-
-    context "host which does not exceed limits" do
-      # Set CPU to 10%
-      # Set Memory to 20%
-      let(:host) { mock_RbVmomi_VIM_HostSystem({
-        :overall_cpu_usage => 10,
-        :overall_memory_usage => 20,
-        :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024,
-        })
-      }
-      it 'should return the sum of CPU and Memory utilization' do
-        expect(subject.get_host_utilization(host,model,limit)[0]).to eq(10)
-      end
-
-      it 'should return the host' do
-        expect(subject.get_host_utilization(host,model,limit)[1]).to eq(host)
-      end
-    end
-
-    context 'host with no quickstats' do
-      let(:host) { mock_RbVmomi_VIM_HostSystem({
-        :cpu_speed => 100,
-        :num_cores_per_cpu => 1,
-        :num_cpu => 1,
-        :memory_size => 100.0 * 1024 * 1024
-        })
-      }
-      before(:each) do
-        host.summary.quickStats.overallCpuUsage = nil
-      end
-
-      it 'should return nil' do
-        result = subject.get_host_utilization(host,model,limit)
-        expect(result).to be nil
-      end
-    end
-  end
-
-  describe '#host_has_cpu_model?' do
-    let(:cpu_model) { 'vendor line type sku v4 speed' }
-    let(:model) { 'v4' }
-    let(:different_model) { 'different_model' }
-    let(:host) { mock_RbVmomi_VIM_HostSystem({
-      :cpu_model => cpu_model,
-      })
-    }
-
-    it 'should return true if the model matches' do
-      expect(subject.host_has_cpu_model?(host,model)).to eq(true)
-    end
-
-    it 'should return false if the model is different' do
-      expect(subject.host_has_cpu_model?(host,different_model)).to eq(false)
-    end
-  end
-
-  describe '#get_host_cpu_arch_version' do
-    let(:cpu_model) { 'vendor line type sku v4 speed' }
-    let(:model) { 'v4' }
-    let(:different_model) { 'different_model' }
-    let(:host) { mock_RbVmomi_VIM_HostSystem({
-      :cpu_model => cpu_model,
-      :num_cpu => 2,
-      })
-    }
-
-    it 'should return the fifth element in the string delimited by spaces' do
-      expect(subject.get_host_cpu_arch_version(host)).to eq(model)
-    end
-
-    it 'should use the description of the first CPU' do
-      host.hardware.cpuPkg[0].description = 'vendor line type sku v6 speed'
-      expect(subject.get_host_cpu_arch_version(host)).to eq('v6')
-    end
-  end
-
-  describe '#cpu_utilization_for' do
-    [{ :cpu_usage => 10.0,
-      :core_speed => 10.0,
-      :num_cores => 2,
-      :expected_value => 50.0,
-    },
-    { :cpu_usage => 10.0,
-      :core_speed => 10.0,
-      :num_cores => 4,
-      :expected_value => 25.0,
-    },
-    { :cpu_usage => 14.0,
-      :core_speed => 12.0,
-      :num_cores => 5,
-      :expected_value => 23.0 + 1.0/3.0,
-    },
-    ].each do |testcase|
-      context "CPU Usage of #{testcase[:cpu_usage]}MHz with #{testcase[:num_cores]} x #{testcase[:core_speed]}MHz cores" do
-        it "should be #{testcase[:expected_value]}%" do
-          host = mock_RbVmomi_VIM_HostSystem({
-            :num_cores_per_cpu => testcase[:num_cores],
-            :cpu_speed         => testcase[:core_speed],
-            :overall_cpu_usage => testcase[:cpu_usage],
-          })
-
-          expect(subject.cpu_utilization_for(host)).to eq(testcase[:expected_value])
-        end
-      end
-    end
-  end
-
-  describe '#memory_utilization_for' do
-    [{ :memory_usage_gigbytes => 10.0,
-      :memory_size_bytes => 10.0 * 1024 * 1024,
-      :expected_value => 100.0,
-    },
-    { :memory_usage_gigbytes => 15.0,
-      :memory_size_bytes => 25.0 * 1024 * 1024,
-      :expected_value => 60.0,
-    },
-    { :memory_usage_gigbytes => 9.0,
-      :memory_size_bytes => 31.0 * 1024 * 1024,
-      :expected_value => 29.03225806451613,
-    },
-    ].each do |testcase|
-      context "Memory Usage of #{testcase[:memory_usage_gigbytes]}GBytes with #{testcase[:memory_size_bytes]}Bytes of total memory" do
-        it "should be #{testcase[:expected_value]}%" do
-          host = mock_RbVmomi_VIM_HostSystem({
-            :memory_size          => testcase[:memory_size_bytes],
-            :overall_memory_usage => testcase[:memory_usage_gigbytes],
-          })
-
-          expect(subject.memory_utilization_for(host)).to eq(testcase[:expected_value])
-        end
-      end
-    end
-  end
-
-  describe '#select_target_hosts' do
-    let(:target) { {} }
-    let(:cluster) { 'cluster1' }
-    let(:missing_cluster_name) { 'missing_cluster' }
-    let(:datacenter) { 'dc1' }
-    let(:architecture) { 'v3' }
-    let(:host) { 'host1' }
-    let(:hosts_hash) {
-      {
-        'hosts' => [host],
-        'architectures' => {
-          architecture => [host]
-        }
-      }
-    }
-
-    it 'returns a hash of the least used hosts by cluster and architecture' do
-      expect(subject).to receive(:find_least_used_hosts).and_return(hosts_hash)
-
-      subject.select_target_hosts(target, cluster, datacenter)
-      expect(target["#{datacenter}_#{cluster}"]).to eq(hosts_hash)
-    end
-
-    context 'with a cluster specified that does not exist' do
-      it 'raises an error' do
-        expect(subject).to receive(:find_least_used_hosts).with(missing_cluster_name, datacenter, 100).and_raise("Cluster #{cluster} cannot be found")
-        expect{subject.select_target_hosts(target, missing_cluster_name, datacenter)}.to raise_error(RuntimeError,/Cluster #{cluster} cannot be found/)
-      end
-    end
-  end
-
-  describe '#get_average_cluster_utilization' do
-    let(:hosts) {
-      [
-        [60, 'host1'],
-        [100, 'host2'],
-        [200, 'host3']
-      ]
-    }
-    it 'returns the average utilization for a given set of host utilizations assuming the first member of the list for each host is the utilization value' do
-      expect(subject.get_average_cluster_utilization(hosts)).to eq(120)
-    end
-  end
-
-  describe '#build_compatible_hosts_lists' do
-    let(:host1) { mock_RbVmomi_VIM_HostSystem({ :name => 'HOST1' })}
-    let(:host2) { mock_RbVmomi_VIM_HostSystem({ :name => 'HOST2' })}
-    let(:host3) { mock_RbVmomi_VIM_HostSystem({ :name => 'HOST3' })}
-    let(:architecture) { 'v4' }
-    let(:percentage) { 100 }
-    let(:hosts) {
-      [
-        [60, host1],
-        [100, host2],
-        [200, host3]
-      ]
-    }
-    let(:result) {
-      {
-          architecture => ['HOST1','HOST2']
-      }
-    }
-
-    it 'returns a hash of target host architecture versions containing lists of target hosts' do
-
-      expect(subject.build_compatible_hosts_lists(hosts, percentage)).to eq(result)
-    end
-  end
-
-  describe '#select_least_used_hosts' do
-    let(:percentage) { 100 }
-    let(:host1) { mock_RbVmomi_VIM_HostSystem({ :name => 'HOST1' })}
-    let(:host2) { mock_RbVmomi_VIM_HostSystem({ :name => 'HOST2' })}
-    let(:host3) { mock_RbVmomi_VIM_HostSystem({ :name => 'HOST3' })}
-    let(:hosts) {
-      [
-        [60, host1],
-        [100, host2],
-        [200, host3]
-      ]
-    }
-    let(:result) { ['HOST1','HOST2'] }
-    it 'returns the percentage specified of the least used hosts in the cluster determined by selecting from less than or equal to average cluster utilization' do
-      expect(subject.select_least_used_hosts(hosts, percentage)).to eq(result)
-    end
-
-    context 'when selecting 20 percent of hosts below average' do
-      let(:percentage) { 20 }
-      let(:result) { ['HOST1'] }
-
-      it 'should return the result' do
-        expect(subject.select_least_used_hosts(hosts, percentage)).to eq(result)
-      end
-    end
-
-    it 'should raise' do
-      expect{subject.select_least_used_hosts([], percentage)}.to raise_error(RuntimeError,/Provided hosts list to select_least_used_hosts is empty/)
-    end
-  end
-
-  describe '#run_select_hosts' do
-    let(:target) { {} }
-    let(:cluster) { 'cluster1' }
-    let(:missing_cluster_name) { 'missing_cluster' }
-    let(:datacenter) { 'dc1' }
-    let(:architecture) { 'v3' }
-    let(:host) { 'host1' }
-    let(:loop_delay) { 5 }
-    let(:max_age) { 60 }
-    let(:dc) { "#{datacenter}_#{cluster}" }
-    let(:hosts_hash) {
-      {
-       dc => {
-          'hosts' => [host],
-          'architectures' => {
-            architecture => [host]
-          }
-        }
-      }
-    }
-    let(:config) { YAML.load(<<-EOT
----
-:config:
-  max_age: 60
-:pools:
-  - name: '#{poolname}'
-    datacenter: '#{datacenter}'
-    clone_target: '#{cluster}'
-EOT
-      )
-    }
-
-    before(:each) do
-      allow(subject).to receive(:connect_to_vsphere).and_return(connection)
-    end
-
-    context 'target does not have key dc' do
-      let(:hosts_hash) { { } }
-      it 'should run select_target_hosts' do
-        expect(subject).to receive(:select_target_hosts).with(hosts_hash, cluster, datacenter)
-        subject.run_select_hosts(poolname, hosts_hash)
-      end
-    end
-
-    context 'when check_time_finished is greater than max_age' do
-      before(:each) do
-        hosts_hash[dc]['check_time_finished'] = Time.now - (max_age + 10)
-      end
-
-      it 'should run select_target_hosts' do
-        expect(subject).to receive(:select_target_hosts).with(hosts_hash, cluster, datacenter)
-        subject.run_select_hosts(poolname, hosts_hash)
-      end
-    end
-
-    context 'when check_time_finished is not greater than max_age' do
-      before(:each) do
-        hosts_hash[dc]['check_time_finished'] = Time.now - (max_age / 2)
-      end
-
-      it 'should not run select_target_hosts' do
-        expect(subject).to_not receive(:select_target_hosts).with(hosts_hash, cluster, datacenter)
-        subject.run_select_hosts(poolname, hosts_hash)
-      end
-    end
-
-    context 'when hosts are being selected' do
-      before(:each) do
-        hosts_hash[dc]['checking'] = true
-      end
-
-      it 'should run wait_for_host_selection' do
-        expect(subject).to receive(:wait_for_host_selection).with(dc, hosts_hash, loop_delay, max_age)
-        subject.run_select_hosts(poolname, hosts_hash)
-      end
-
-    end
-
-    context 'with no clone_target' do
-      before(:each) do
-        config[:pools][0].delete('clone_target')
-      end
-
-      it 'should raise an error' do
-        expect{subject.run_select_hosts(poolname, hosts_hash)}.to raise_error(/cluster for pool #{poolname} cannot be identified/)
-      end
-    end
-
-    context 'with no datacenter' do
-      before(:each) do
-        config[:pools][0].delete('datacenter')
-      end
-
-      it 'should raise an error' do
-        expect{subject.run_select_hosts(poolname, hosts_hash)}.to raise_error(/datacenter for pool #{poolname} cannot be identified/)
-      end
-    end
-  end
-
-  describe '#wait_for_host_selection' do
-    let(:datacenter) { 'dc1' }
-    let(:cluster) { 'cluster1' }
-    let(:dc) { "#{datacenter}_#{cluster}" }
-    let(:maxloop) { 1 }
-    let(:loop_delay) { 1 }
-    let(:max_age) { 60 }
-    let(:target) {
-      {
-        dc => { }
-      }
-    }
-
-    context 'when target does not have key check_time_finished' do
-      it 'should sleep for loop_delay maxloop times' do
-        expect(subject).to receive(:sleep).with(loop_delay).once
-
-        subject.wait_for_host_selection(dc, target, maxloop, loop_delay, max_age)
-      end
-    end
-
-    context 'when target has dc and check_time_finished is greater than max_age' do
-      before(:each) do
-        target[dc]['check_time_finished'] = Time.now - (max_age + 10)
-      end
-
-      it 'should sleep for loop_delay maxloop times' do
-        expect(subject).to receive(:sleep).with(loop_delay).once
-
-        subject.wait_for_host_selection(dc, target, maxloop, loop_delay, max_age)
-      end
-    end
-
-    context 'when target has dc and check_time_finished difference from now is less than max_age' do
-      before(:each) do
-        target[dc]['check_time_finished'] = Time.now - (max_age / 2)
-      end
-
-      it 'should not wait' do
-        expect(subject).to_not receive(:sleep).with(loop_delay)
-
-        subject.wait_for_host_selection(dc, target, maxloop, loop_delay, max_age)
-      end
-    end
-  end
-
-  describe '#select_next_host' do
-    let(:cluster) { 'cluster1' }
-    let(:datacenter) { 'dc1' }
-    let(:architecture) { 'v3' }
-    let(:host) { 'host1' }
-    let(:loop_delay) { 5 }
-    let(:max_age) { 60 }
-    let(:dc) { "#{datacenter}_#{cluster}" }
-    let(:hosts_hash) {
-      {
-       dc => {
-          'hosts' => [host, 'host2'],
-          'architectures' => {
-            architecture => ['host3', 'host4']
-          }
-        }
-      }
-    }
-    let(:config) { YAML.load(<<-EOT
----
-:config:
-  max_age: 60
-:pools:
-  - name: '#{poolname}'
-    datacenter: '#{datacenter}'
-    clone_target: '#{cluster}'
-EOT
-      )
-    }
-
-    context 'when host is requested' do
-      it 'should return the first host' do
-        result = subject.select_next_host(poolname, hosts_hash)
-        expect(result).to eq(host)
-      end
-
-      it 'should return the second host if called twice' do
-        subject.select_next_host(poolname, hosts_hash)
-        result2 = subject.select_next_host(poolname, hosts_hash)
-        expect(result2).to eq('host2')
-      end
-    end
-
-    context 'when host and architecture are requested' do
-      it 'should return the first host' do
-        result = subject.select_next_host(poolname, hosts_hash, architecture)
-        expect(result).to eq('host3')
-      end
-
-      it 'should return the second host if called twice' do
-        subject.select_next_host(poolname, hosts_hash, architecture)
-        result2 = subject.select_next_host(poolname, hosts_hash, architecture)
-        expect(result2).to eq('host4')
-      end
-    end
-
-    context 'with no hosts available' do
-      before(:each) do
-        hosts_hash[dc].delete('hosts')
-        hosts_hash[dc].delete('architectures')
-      end
-      it 'should raise an error' do
-        expect{subject.select_next_host(poolname, hosts_hash)}.to raise_error("there is no candidate in vcenter that meets all the required conditions, that the cluster has available hosts in a 'green' status, not in maintenance mode and not overloaded CPU and memory")
-      end
-
-      it 'should raise an error when selecting with architecture' do
-        expect{subject.select_next_host(poolname, hosts_hash, architecture)}.to raise_error("there is no candidate in vcenter that meets all the required conditions, that the cluster has available hosts in a 'green' status, not in maintenance mode and not overloaded CPU and memory")
-      end
-    end
-
-    context 'with no datacenter set for pool' do
-      before(:each) do
-        config[:pools][0].delete('datacenter')
-      end
-
-      it 'should raise an error' do
-        expect{subject.select_next_host(poolname, hosts_hash)}.to raise_error("datacenter for pool #{poolname} cannot be identified")
-      end
-    end
-
-    context 'with no clone_target set for pool' do
-      before(:each) do
-        config[:pools][0].delete('clone_target')
-      end
-
-      it 'should raise an error' do
-        expect{subject.select_next_host(poolname, hosts_hash)}.to raise_error("cluster for pool #{poolname} cannot be identified")
-      end
-    end
-  end
-
-  describe '#vm_in_target?' do
-    let(:parent_host) { 'host1' }
-    let(:architecture) { 'v3' }
-    let(:datacenter) { 'dc1' }
-    let(:cluster) { 'cluster1' }
-    let(:dc) { "#{datacenter}_#{cluster}" }
-    let(:maxloop) { 1 }
-    let(:loop_delay) { 1 }
-    let(:max_age) { 60 }
-    let(:target) {
-      {
-        dc => {
-          'hosts' => [parent_host],
-          'architectures' => {
-            architecture => [parent_host]
-          }
-        }
-      }
-    }
-    let(:config) { YAML.load(<<-EOT
----
-:pools:
-  - name: '#{poolname}'
-    datacenter: '#{datacenter}'
-    clone_target: '#{cluster}'
-EOT
-      )
-    }
-
-    it 'returns true when parent_host is in hosts' do
-      result = subject.vm_in_target?(poolname, parent_host, architecture, target)
-      expect(result).to be true
-    end
-
-    context 'with parent_host only in architectures' do
-      before(:each) do
-        target[dc]['hosts'] = ['host2']
-      end
-
-      it 'returns true when parent_host is in architectures' do
-        result = subject.vm_in_target?(poolname, parent_host, architecture, target)
-        expect(result).to be true
-      end
-    end
-
-    it 'returns false when parent_host is not in hosts or architectures' do
-      result = subject.vm_in_target?(poolname, 'host3', architecture, target)
-      expect(result).to be false
-    end
-
-    context 'with no hosts key' do
-      before(:each) do
-        target[dc].delete('hosts')
-      end
-
-      it 'should raise an error' do
-        expect{subject.vm_in_target?(poolname, parent_host, architecture, target)}.to raise_error("there is no candidate in vcenter that meets all the required conditions, that the cluster has available hosts in a 'green' status, not in maintenance mode and not overloaded CPU and memory")
-      end
-    end
-  end
-
-  describe '#get_vm_details' do
-    let(:parent_host) { 'host1' }
-    let(:host_object) { mock_RbVmomi_VIM_HostSystem({ :name => parent_host })}
-    let(:vm_object) { mock_RbVmomi_VIM_VirtualMachine({ :name => vmname })}
-    let(:architecture) { 'v4' }
-    let(:vm_details) {
-      {
-        'host_name' => parent_host,
-        'object' => vm_object,
-        'architecture' => architecture
-      }
-    }
-
-    before(:each) do
-      allow(subject).to receive(:connect_to_vsphere).and_return(connection)
-    end
-
-    it 'returns nil when vm_object is not found' do
-      expect(subject).to receive(:find_vm).with(poolname, vmname, connection).and_return(nil)
-      result = subject.get_vm_details(poolname, vmname, connection)
-      expect(result).to be nil
-    end
-
-    it 'raises an error when unable to determine parent_host' do
-      expect(subject).to receive(:find_vm).with(poolname, vmname, connection).and_return(vm_object)
-      expect{subject.get_vm_details(poolname, vmname, connection)}.to raise_error('Unable to determine which host the VM is running on')
-    end
-
-    context 'when it can find parent host' do
-      before(:each) do
-        # This mocking is a little fragile but hard to do without a real vCenter instance
-        vm_object.summary.runtime.host = host_object
-      end
-
-      it 'returns vm details hash' do
-        expect(subject).to receive(:find_vm).with(poolname, vmname, connection).and_return(vm_object)
-        result = subject.get_vm_details(poolname, vmname, connection)
-        expect(result).to eq(vm_details)
-      end
-    end
-  end
-
-  describe '#migrate_vm' do
-    let(:parent_host) { 'host1' }
-    let(:new_host) { 'host2' }
-    let(:datacenter) { 'dc1' }
-    let(:architecture) { 'v4' }
-    let(:cluster) { 'cluster1' }
-    let(:vm_details) {
-      {
-        'host_name' => parent_host,
-        'object' => vm_object,
-        'architecture' => architecture
-      }
-    }
-    let(:host_object) { mock_RbVmomi_VIM_HostSystem({ :name => parent_host })}
-    let(:new_host_object) { mock_RbVmomi_VIM_HostSystem({ :name => new_host })}
-    let(:vm_object) { mock_RbVmomi_VIM_VirtualMachine({ :name => vmname })}
-    let(:config) { YAML.load(<<-EOT
----
-:config:
-  migration_limit: 5
-:pools:
-  - name: '#{poolname}'
-    datacenter: '#{datacenter}'
-    clone_target: '#{cluster}'
-EOT
-      )
-    }
-    let(:dc) { "#{datacenter}_#{cluster}" }
-    let(:provider_hosts) {
-      {
-        dc => {
-          'hosts' => [new_host],
-          'architectures' => {
-            architecture => [new_host]
-          },
-          'check_time_finished' => Time.now
-        }
-      }
-    }
-
-    before(:each) do
-      allow(subject).to receive(:connect_to_vsphere).and_return(connection)
-    end
-
-    context 'when vm should be migrated' do
-      before(:each) do
-        subject.connection_pool.with_metrics do |pool_object|
-          expect(subject).to receive(:ensured_vsphere_connection).with(pool_object).and_return(connection)
-          expect(subject).to receive(:get_vm_details).and_return(vm_details)
-          expect(subject).to receive(:run_select_hosts).with(poolname, {})
-          expect(subject).to receive(:vm_in_target?).and_return false
-          expect(subject).to receive(:migration_enabled?).and_return true
-          redis_connection_pool.with do |redis|
-            redis.hset("vmpooler__vm__#{vmname}", 'checkout', Time.now)
-          end
-        end
-        vm_object.summary.runtime.host = host_object
-      end
-
-      it 'logs a message' do
-        expect(subject).to receive(:select_next_host).and_return(new_host)
-        expect(subject).to receive(:find_host_by_dnsname).and_return(new_host_object)
-        expect(subject).to receive(:migrate_vm_host).with(vm_object, new_host_object)
-        expect(logger).to receive(:log).with('s', "[>] [#{poolname}] '#{vmname}' migrated from #{parent_host} to #{new_host} in 0.00 seconds")
-
-        subject.migrate_vm(poolname, vmname)
-      end
-
-      it 'migrates a vm' do
-        expect(subject).to receive(:migrate_vm_to_new_host).with(poolname, vmname, vm_details, connection)
-
-        subject.migrate_vm(poolname, vmname)
-      end
-    end
-
-    context 'current host is in the list of target hosts' do
-      before(:each) do
-        subject.connection_pool.with_metrics do |pool_object|
-          expect(subject).to receive(:ensured_vsphere_connection).with(pool_object).and_return(connection)
-          expect(subject).to receive(:get_vm_details).and_return(vm_details)
-          expect(subject).to receive(:run_select_hosts).with(poolname, {})
-          expect(subject).to receive(:vm_in_target?).and_return true
-          expect(subject).to receive(:migration_enabled?).and_return true
-        end
-        vm_object.summary.runtime.host = host_object
-      end
-
-      it 'logs a message that no migration is required' do
-        expect(logger).to receive(:log).with('s', "[ ] [#{poolname}] No migration required for '#{vmname}' running on #{parent_host}")
-
-        subject.migrate_vm(poolname, vmname)
-      end
-    end
-
-    context 'with migration limit exceeded' do
-      before(:each) do
-        subject.connection_pool.with_metrics do |pool_object|
-          expect(subject).to receive(:ensured_vsphere_connection).with(pool_object).and_return(connection)
-          expect(subject).to receive(:get_vm_details).and_return(vm_details)
-          expect(subject).to_not receive(:run_select_hosts)
-          expect(subject).to_not receive(:vm_in_target?)
-          expect(subject).to receive(:migration_enabled?).and_return true
-          redis_connection_pool.with do |redis|
-            expect(redis).to receive(:scard).with('vmpooler__migration').and_return(5)
-          end
-        end
-        vm_object.summary.runtime.host = host_object
-      end
-
-      it 'should log the current host' do
-        expect(logger).to receive(:log).with('s', "[ ] [#{poolname}] '#{vmname}' is running on #{parent_host}. No migration will be evaluated since the migration_limit has been reached")
-
-        subject.migrate_vm(poolname, vmname)
-      end
-    end
-
-    context 'when an error occurs' do
-      before(:each) do
-        subject.connection_pool.with_metrics do |pool_object|
-          expect(subject).to receive(:ensured_vsphere_connection).with(pool_object).and_return(connection)
-          expect(subject).to receive(:get_vm_details).and_return(vm_details)
-          expect(subject).to receive(:run_select_hosts)
-          expect(subject).to receive(:vm_in_target?).and_return false
-          expect(subject).to receive(:migration_enabled?).and_return true
-          expect(subject).to receive(:select_next_host).and_raise(RuntimeError,'Mock migration error')
-        end
-        vm_object.summary.runtime.host = host_object
-      end
-      it 'should log the current host' do
-        expect(logger).to receive(:log).with('s', "[!] [#{poolname}] '#{vmname}' is running on #{parent_host}")
-
-        expect{subject.migrate_vm(poolname, vmname)}.to raise_error(RuntimeError, 'Mock migration error')
-      end
-    end
-  end
-
-  describe '#migrate_vm_to_new_host' do
-    let(:parent_host) { 'host1' }
-    let(:new_host) { 'host2' }
-    let(:datacenter) { 'dc1' }
-    let(:cluster) { 'cluster1' }
-    let(:architecture) { 'v4' }
-    let(:host_object) { mock_RbVmomi_VIM_HostSystem({ :name => parent_host })}
-    let(:new_host_object) { mock_RbVmomi_VIM_HostSystem({ :name => new_host })}
-    let(:vm_object) { mock_RbVmomi_VIM_VirtualMachine({ :name => vmname })}
-    let(:config) { YAML.load(<<-EOT
----
-:config:
-  migration_limit: 5
-:pools:
-  - name: '#{poolname}'
-    datacenter: '#{datacenter}'
-    clone_target: '#{cluster}'
-EOT
-      )
-    }
-    let(:vm_details) {
-      {
-        'host_name' => parent_host,
-        'object' => vm_object,
-        'architecture' => architecture
-      }
-    }
-
-    before(:each) do
-      allow(subject).to receive(:connect_to_vsphere).and_return(connection)
-    end
-
-    it' migrates a vm' do
-      expect(subject).to receive(:select_next_host).and_return(new_host)
-      expect(subject).to receive(:find_host_by_dnsname).and_return(new_host_object)
-      expect(subject).to receive(:migrate_vm_and_record_timing).and_return(format('%.2f', (Time.now - (Time.now - 15))))
-      expect(logger).to receive(:log).with('s', "[>] [#{poolname}] '#{vmname}' migrated from host1 to host2 in 15.00 seconds")
-      subject.migrate_vm_to_new_host(poolname, vmname, vm_details, connection)
-    end
-  end
-
-  describe '#create_folder' do
-    let(:datacenter) { 'dc1' }
-    let(:datacenter_object) { mock_RbVmomi_VIM_Datacenter() }
-    let(:folder_object) { mock_RbVmomi_VIM_Folder({ :name => 'pool1'}) }
-    let(:new_folder) { poolname }
-
-    before(:each) do
-      allow(subject).to receive(:connect_to_vsphere).and_return(connection)
-    end
-
-    it 'creates a folder' do
-      expect(connection.serviceInstance).to receive(:find_datacenter).with(datacenter).and_return(datacenter_object)
-      expect(datacenter_object.vmFolder).to receive(:traverse).with(new_folder, RbVmomi::VIM::Folder, true).and_return(folder_object)
-
-      result = subject.create_folder(connection, new_folder, datacenter)
-      expect(result).to eq(folder_object)
-    end
-
-    context 'with folder_object returning nil' do
-      it 'shoud raise an error' do
-        expect(connection.serviceInstance).to receive(:find_datacenter).with(datacenter).and_return(datacenter_object)
-        expect(datacenter_object.vmFolder).to receive(:traverse).with(new_folder, RbVmomi::VIM::Folder, true).and_return(nil)
-
-        expect{subject.create_folder(connection, new_folder, datacenter)}.to raise_error("Cannot create folder #{new_folder}")
-      end
-    end
-  end
-
-  describe '#migration_enabled?' do
-    let(:config) {
-      { :config => { 'migration_limit' => 5 } }
-    }
-    it 'returns true if migration is enabled' do
-      result = subject.migration_enabled?(config)
-      expect(result).to be true
-    end
-
-    context 'with migration disabled' do
-      let(:config) {
-        { :config => { } }
-      }
-      it 'should return false' do
-        result = subject.migration_enabled?(config)
-        expect(result).to be false
-      end
-    end
-
-    context 'with non-integer value for migration limit' do
-      let(:config) {
-        { :config => { 'migration_limit' => 1.0 } }
-      }
-      it 'should return false' do
-        result = subject.migration_enabled?(config)
-        expect(result).to be false
-      end
-    end
-  end
-
-  describe '#find_least_used_hosts' do
-    let(:cluster_name) { 'cluster' }
-    let(:missing_cluster_name) { 'missing_cluster' }
-    let(:datacenter_object) { mock_RbVmomi_VIM_Datacenter() }
-    let(:percentage) { 100 }
-
-    before(:each) do
-      # This mocking is a little fragile but hard to do without a real vCenter instance
-      allow(subject).to receive(:connect_to_vsphere).and_return(connection)
-      allow(connection.serviceInstance).to receive(:find_datacenter).and_return(datacenter_object)
-      datacenter_object.hostFolder.childEntity = [cluster_object]
-    end
-
-    context 'missing cluster' do
-      let(:cluster_object) { mock_RbVmomi_VIM_ComputeResource({
-        :name => cluster_name,
-        :hosts => [{
-          :name => cluster_name,
-      }]})}
-      let(:expected_host) { cluster_object.host[0] }
-#,datacenter_name
-      it 'should raise an error' do
-        expect{subject.find_least_used_hosts(missing_cluster_name,datacenter_name,percentage)}.to raise_error(RuntimeError,/Cluster #{missing_cluster_name} cannot be found/)
-      end
-    end
-
-    context 'standalone host within limits' do
-      let(:cluster_object) { mock_RbVmomi_VIM_ComputeResource({
-        :name => cluster_name,
-        :hosts => [{
-          :name => cluster_name,
-      }]})}
-      let(:expected_host) { cluster_object.host[0][:name] }
-
-      it 'should return the standalone host' do
-        result = subject.find_least_used_hosts(cluster_name,datacenter_name,percentage)
-
-        expect(result['hosts'][0]).to be(expected_host)
-      end
-    end
-
-    context 'standalone host outside the limits' do
-      let(:cluster_object) { mock_RbVmomi_VIM_ComputeResource({
-        :name => cluster_name,
-        :hosts => [{
-          :name => cluster_name,
-          :overall_cpu_usage => 100, :overall_memory_usage => 100, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024,
-      }]})}
-      let(:expected_host) { cluster_object.host[0] }
-
-      it 'should raise an error' do
-        expect{subject.find_least_used_hosts(missing_cluster_name,datacenter_name,percentage)}.to raise_error(RuntimeError,/Cluster #{missing_cluster_name} cannot be found/)
-      end
-    end
-
-    context 'cluster of 3 hosts within limits' do
-      let(:cluster_object) { mock_RbVmomi_VIM_ComputeResource({
-        :name => cluster_name,
-        :hosts => [
-          { :overall_cpu_usage => 11, :overall_memory_usage => 11, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-          { :overall_cpu_usage => 1, :overall_memory_usage => 1, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-          { :overall_cpu_usage => 21, :overall_memory_usage => 21, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-      ]}) }
-      let(:expected_host) { cluster_object.host[1].name }
-
-      it 'should return the standalone host' do
-        result = subject.find_least_used_hosts(cluster_name,datacenter_name,percentage)
-
-        expect(result['hosts'][0]).to be(expected_host)
-      end
-    end
-
-    context 'cluster of 3 hosts all outside of the limits' do
-      let(:cluster_object) { mock_RbVmomi_VIM_ComputeResource({
-        :name => cluster_name,
-        :hosts => [
-          { :overall_cpu_usage => 100, :overall_memory_usage => 100, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-          { :overall_cpu_usage => 100, :overall_memory_usage => 100, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-          { :overall_cpu_usage => 100, :overall_memory_usage => 100, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-      ]}) }
-      let(:expected_host) { cluster_object.host[1] }
-
-      it 'should raise an error' do
-        expect{subject.find_least_used_hosts(missing_cluster_name,datacenter_name,percentage)}.to raise_error(RuntimeError,/Cluster #{missing_cluster_name} cannot be found/)
-      end
-    end
-
-    context 'cluster of 5 hosts of which one is out of limits and one has wrong CPU type' do
-      let(:cluster_object) { mock_RbVmomi_VIM_ComputeResource({
-        :name => cluster_name,
-        :hosts => [
-          { :overall_cpu_usage => 31, :overall_memory_usage => 31, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-          { :cpu_model => 'different cpu model', :overall_cpu_usage => 1, :overall_memory_usage => 1, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-          { :overall_cpu_usage => 11, :overall_memory_usage => 11, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-          { :overall_cpu_usage => 100, :overall_memory_usage => 100, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-          { :overall_cpu_usage => 21, :overall_memory_usage => 21, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-      ]}) }
-      let(:expected_host) { cluster_object.host[1].name }
-
-      it 'should return the standalone host' do
-        result = subject.find_least_used_hosts(cluster_name,datacenter_name,percentage)
-
-        expect(result['hosts'][0]).to be(expected_host)
-      end
-    end
-
-    context 'cluster of 3 hosts all outside of the limits' do
-      let(:cluster_object) { mock_RbVmomi_VIM_ComputeResource({
-        :name => cluster_name,
-        :hosts => [
-          { :overall_cpu_usage => 10, :overall_memory_usage => 10, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-          { :overall_cpu_usage => 10, :overall_memory_usage => 10, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-          { :overall_cpu_usage => 10, :overall_memory_usage => 10, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-      ]}) }
-      let(:expected_host) { cluster_object.host[1] }
-
-      it 'should return a host' do
-        pending('https://github.com/puppetlabs/vmpooler/issues/206')
-        result = subject.find_least_used_hosts(missing_cluster_name,datacenter_name,percentage)
-        expect(result).to_not be_nil
-      end
-    end
-  end
-
-  describe '#find_cluster' do
-    let(:cluster) {'cluster'}
-    let(:host) { 'host' }
-    let(:missing_cluster) {'missing_cluster'}
-
-    context 'no clusters in the datacenter' do
-      let(:connection_options) {{
-        :serviceContent => {
-          :datacenters => [
-            { :name => datacenter_name }
-          ]
-        }
-      }}
-
-      it 'should return nil if the cluster is not found' do
-        expect(subject.find_cluster(missing_cluster,connection,datacenter_name)).to be_nil
-      end
-    end
-
-    context 'with a single layer folder hierarchy' do
-      let(:connection_options) {{
-        :serviceContent => {
-          :datacenters => [
-            { :name => datacenter_name,
-              :hostfolder_tree => {
-                'cluster1' =>  {:object_type => 'cluster_compute_resource'},
-                'cluster2' => {:object_type => 'cluster_compute_resource'},
-                cluster => {:object_type => 'cluster_compute_resource'},
-                'cluster3' => {:object_type => 'cluster_compute_resource'},
-                host => {:object_type => 'compute_resource'},
-              }
-            }
-          ]
-        }
-      }}
-
-      it 'should return the cluster when found' do
-        result = subject.find_cluster(cluster,connection,datacenter_name)
-
-        expect(result).to_not be_nil
-        expect(result.name).to eq(cluster)
-      end
-
-      it 'should return the single host when found' do
-        result = subject.find_cluster(host,connection,datacenter_name)
-
-        expect(result).to_not be_nil
-        expect(result.name).to eq(host)
-      end
-
-      it 'should return nil if the cluster is not found' do
-        expect(subject.find_cluster(missing_cluster,connection,datacenter_name)).to be_nil
-      end
-    end
-
-    context 'with a single layer folder hierarchy with multiple datacenters' do
-      let(:connection_options) {{
-        :serviceContent => {
-          :datacenters => [
-            { :name => 'AnotherDC',
-              :hostfolder_tree => {
-                'cluster1' =>  {:object_type => 'cluster_compute_resource'},
-                'cluster2' => {:object_type => 'cluster_compute_resource'},
-              }
-            },
-            { :name => datacenter_name,
-              :hostfolder_tree => {
-                cluster => {:object_type => 'cluster_compute_resource'},
-                'cluster3' => {:object_type => 'cluster_compute_resource'},
-                host => {:object_type => 'compute_resource'}
-              }
-            }
-          ]
-        }
-      }}
-
-      it 'should return the cluster when found' do
-        result = subject.find_cluster(cluster,connection,datacenter_name)
-
-        expect(result).to_not be_nil
-        expect(result.name).to eq(cluster)
-      end
-
-      it 'should return the single host when found' do
-        result = subject.find_cluster(host,connection,datacenter_name)
-
-        expect(result).to_not be_nil
-        expect(result.name).to eq(host)
-      end
-
-      it 'should return nil if the cluster is not found' do
-        expect(subject.find_cluster(missing_cluster,connection,'AnotherDC')).to be_nil
-      end
-    end
-
-    context 'with a multi layer folder hierarchy' do
-      let(:connection_options) {{
-        :serviceContent => {
-          :datacenters => [
-            { :name => datacenter_name,
-              :hostfolder_tree => {
-                'cluster1' =>  {:object_type => 'cluster_compute_resource'},
-                'folder2' => {
-                  :children => {
-                    cluster => {:object_type => 'cluster_compute_resource'},
-                  }
-                },
-                'cluster3' => {:object_type => 'cluster_compute_resource'},
-                'folder4' => {
-                  :children => {
-                    host => {:object_type => 'compute_resource'},
-                  }
-                }
-              }
-            }
-          ]
-        }
-      }}
-
-      it 'should return the cluster when found' do
-        result = subject.find_cluster(cluster,connection,datacenter_name)
-
-        expect(result).to_not be_nil
-        expect(result.name).to eq(cluster)
-      end
-
-      it 'should return the host when found' do
-        result = subject.find_cluster(host,connection,datacenter_name)
-
-        expect(result).to_not be_nil
-        expect(result.name).to eq(host)
-      end
-
-      it 'should return nil if the cluster is not found' do
-        expect(subject.find_cluster(missing_cluster,connection,datacenter_name)).to be_nil
-      end
-    end
-  end
-
-  describe '#get_cluster_host_utilization' do
-    context 'standalone host within limits' do
-      let(:cluster_object) { mock_RbVmomi_VIM_ComputeResource({:hosts => [{}]}) }
-      
-      it 'should return array with one element' do
-        result = subject.get_cluster_host_utilization(cluster_object)
-        expect(result).to_not be_nil
-        expect(result.count).to eq(1)
-      end
-    end
-
-    context 'standalone host which is out the limits' do
-      let(:cluster_object) { mock_RbVmomi_VIM_ComputeResource({:hosts => [
-        { :overall_cpu_usage => 100, :overall_memory_usage => 100, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-      ]}) }
-      
-      it 'should return array with 0 elements' do
-        result = subject.get_cluster_host_utilization(cluster_object)
-        expect(result).to_not be_nil
-        expect(result.count).to eq(0)
-      end
-    end
-
-    context 'cluster with 3 hosts within limits' do
-      let(:cluster_object) { mock_RbVmomi_VIM_ComputeResource({:hosts => [
-        { :overall_cpu_usage => 1, :overall_memory_usage => 1, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-        { :overall_cpu_usage => 11, :overall_memory_usage => 11, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-        { :overall_cpu_usage => 21, :overall_memory_usage => 21, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-      ]}) }
-      
-      it 'should return array with 3 elements' do
-        result = subject.get_cluster_host_utilization(cluster_object)
-        expect(result).to_not be_nil
-        expect(result.count).to eq(3)
-      end
-    end
-
-    context 'cluster with 5 hosts of which 3 within limits' do
-      let(:cluster_object) { mock_RbVmomi_VIM_ComputeResource({:hosts => [
-        { :overall_cpu_usage => 1, :overall_memory_usage => 1, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-        { :overall_cpu_usage => 100, :overall_memory_usage => 100, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-        { :overall_cpu_usage => 11, :overall_memory_usage => 11, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-        { :overall_cpu_usage => 21, :overall_memory_usage => 21, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-        { :overall_cpu_usage => 100, :overall_memory_usage => 100, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-      ]}) }
-      
-      it 'should return array with 3 elements' do
-        result = subject.get_cluster_host_utilization(cluster_object)
-        expect(result).to_not be_nil
-        expect(result.count).to eq(3)
-      end
-    end
-
-    context 'cluster with 3 hosts of which none are within the limits' do
-      let(:cluster_object) { mock_RbVmomi_VIM_ComputeResource({:hosts => [
-        { :overall_cpu_usage => 100, :overall_memory_usage => 100, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-        { :overall_cpu_usage => 100, :overall_memory_usage => 100, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-        { :overall_cpu_usage => 100, :overall_memory_usage => 100, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-      ]}) }
-      
-      it 'should return array with 0 elements' do
-        result = subject.get_cluster_host_utilization(cluster_object)
-        expect(result).to_not be_nil
-        expect(result.count).to eq(0)
-      end
-    end
-  end
-
-  describe '#find_least_used_vpshere_compatible_host' do
-    let(:vm) { mock_RbVmomi_VIM_VirtualMachine() }
-
-    context 'standalone host within limits' do
-      let(:cluster_object) { mock_RbVmomi_VIM_ComputeResource({:hosts => [{}]}) }
-      let(:standalone_host) { cluster_object.host[0] }
-
-      before(:each) do
-        # This mocking is a little fragile but hard to do without a real vCenter instance
-        vm.summary.runtime.host = standalone_host
-      end
-
-      it 'should return the standalone host' do
-        result = subject.find_least_used_vpshere_compatible_host(vm)
-
-        expect(result).to_not be_nil
-        expect(result[0]).to be(standalone_host)
-        expect(result[1]).to eq(standalone_host.name)
-      end
-    end
-
-    context 'standalone host outside of limits' do
-      let(:cluster_object) { mock_RbVmomi_VIM_ComputeResource({:hosts => [
-        { :overall_cpu_usage => 100, :overall_memory_usage => 100, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-      ]}) }
-      let(:standalone_host) { cluster_object.host[0] }
-
-      before(:each) do
-        # This mocking is a little fragile but hard to do without a real vCenter instance
-        vm.summary.runtime.host = standalone_host
-      end
-
-      it 'should raise error' do
-        expect{subject.find_least_used_vpshere_compatible_host(vm)}.to raise_error(/There is no host candidate in vcenter that meets all the required conditions/)
-      end
-    end
-
-    context 'cluster of 3 hosts within limits' do
-      let(:cluster_object) { mock_RbVmomi_VIM_ComputeResource({:hosts => [
-        { :overall_cpu_usage => 11, :overall_memory_usage => 11, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-        { :overall_cpu_usage => 1, :overall_memory_usage => 1, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-        { :overall_cpu_usage => 21, :overall_memory_usage => 21, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-      ]}) }
-      let(:expected_host) { cluster_object.host[1] }
-
-      before(:each) do
-        # This mocking is a little fragile but hard to do without a real vCenter instance
-        vm.summary.runtime.host = expected_host
-      end
-
-      it 'should return the least used host' do
-        result = subject.find_least_used_vpshere_compatible_host(vm)
-
-        expect(result).to_not be_nil
-        expect(result[0]).to be(expected_host)
-        expect(result[1]).to eq(expected_host.name)
-      end
-    end
-
-    context 'cluster of 3 hosts all outside of the limits' do
-      let(:cluster_object) { mock_RbVmomi_VIM_ComputeResource({:hosts => [
-        { :overall_cpu_usage => 100, :overall_memory_usage => 100, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-        { :overall_cpu_usage => 100, :overall_memory_usage => 100, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-        { :overall_cpu_usage => 100, :overall_memory_usage => 100, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-      ]}) }
-      let(:expected_host) { cluster_object.host[1] }
-
-      before(:each) do
-        # This mocking is a little fragile but hard to do without a real vCenter instance
-        vm.summary.runtime.host = expected_host
-      end
-
-      it 'should raise error' do
-        expect{subject.find_least_used_vpshere_compatible_host(vm)}.to raise_error(/There is no host candidate in vcenter that meets all the required conditions/)
-      end
-    end
-
-    context 'cluster of 5 hosts of which one is out of limits and one has wrong CPU type' do
-      let(:cluster_object) { mock_RbVmomi_VIM_ComputeResource({:hosts => [
-        { :overall_cpu_usage => 31, :overall_memory_usage => 31, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-        { :cpu_model => 'different cpu model', :overall_cpu_usage => 1, :overall_memory_usage => 1, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-        { :overall_cpu_usage => 11, :overall_memory_usage => 11, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-        { :overall_cpu_usage => 100, :overall_memory_usage => 100, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-        { :overall_cpu_usage => 21, :overall_memory_usage => 21, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-      ]}) }
-      let(:expected_host) { cluster_object.host[2] }
-
-      before(:each) do
-        # This mocking is a little fragile but hard to do without a real vCenter instance
-        vm.summary.runtime.host = expected_host
-      end
-
-      it 'should return the least used host' do
-        result = subject.find_least_used_vpshere_compatible_host(vm)
-
-        expect(result).to_not be_nil
-        expect(result[0]).to be(expected_host)
-        expect(result[1]).to eq(expected_host.name)
-      end
-    end
-
-    context 'cluster of 3 hosts all with the same utilisation' do
-      let(:cluster_object) { mock_RbVmomi_VIM_ComputeResource({:hosts => [
-        { :overall_cpu_usage => 10, :overall_memory_usage => 10, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-        { :overall_cpu_usage => 10, :overall_memory_usage => 10, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-        { :overall_cpu_usage => 10, :overall_memory_usage => 10, :cpu_speed => 100, :num_cores_per_cpu => 1, :num_cpu => 1, :memory_size => 100.0 * 1024 * 1024 },
-      ]}) }
-      let(:expected_host) { cluster_object.host[1] }
-
-      before(:each) do
-        # This mocking is a little fragile but hard to do without a real vCenter instance
-        vm.summary.runtime.host = expected_host
-      end
-
-      it 'should return a host' do
-        pending('https://github.com/puppetlabs/vmpooler/issues/206 is fixed')
-        result = subject.find_least_used_vpshere_compatible_host(vm)
-
-        expect(result).to_not be_nil
-      end
-    end
-  end
-
-  describe '#find_snapshot' do
-    let(:snapshot_name) {'snapshot'}
-    let(:missing_snapshot_name) {'missing_snapshot'}
-    let(:vm) { mock_RbVmomi_VIM_VirtualMachine(mock_options) }
-    let(:snapshot_object) { mock_RbVmomi_VIM_VirtualMachineSnapshot() }
-
-    context 'VM with no snapshots' do
-      let(:mock_options) {{ :snapshot_tree => nil }}
-      it 'should return nil' do
-        expect(subject.find_snapshot(vm,snapshot_name)).to be_nil
-      end
-    end
-
-    context 'VM with a single layer of snapshots' do
-      let(:mock_options) {{
-        :snapshot_tree => {
-          'snapshot1' => nil,
-          'snapshot2' => nil,
-          'snapshot3'  => nil,
-          'snapshot4' => nil,
-          snapshot_name => { :ref => snapshot_object},
-        }
-      }}
-
-      it 'should return snapshot which matches the name' do
-        result = subject.find_snapshot(vm,snapshot_name)
-        expect(result).to be(snapshot_object)
-      end
-
-      it 'should return nil which no matches are found' do
-        result = subject.find_snapshot(vm,missing_snapshot_name)
-        expect(result).to be_nil
-      end
-    end
-
-    context 'VM with a nested layers of snapshots' do
-      let(:mock_options) {{
-        :snapshot_tree => {
-          'snapshot1' => nil,
-          'snapshot2' => nil,
-          'snapshot3'  => { :children => {
-            'snapshot4' => nil,
-            'snapshot5' => { :children => {
-              snapshot_name => { :ref => snapshot_object},
-            }},
-          }},
-          'snapshot6' => nil,
-        }
-      }}
-
-      it 'should return snapshot which matches the name' do
-        result = subject.find_snapshot(vm,snapshot_name)
-        expect(result).to be(snapshot_object)
-      end
-
-      it 'should return nil which no matches are found' do
-        result = subject.find_snapshot(vm,missing_snapshot_name)
-        expect(result).to be_nil
-      end
-    end
-  end
-
-  describe '#find_vm' do
-    let(:missing_vm) { 'missing_vm' }
-    let(:folder) { 'Pooler/pool1' }
-    let(:vm_object) { mock_RbVmomi_VIM_VirtualMachine() }
-
-    before(:each) do
-      allow(connection.searchIndex).to receive(:FindByInventoryPath)
-    end
-
-    it 'should call FindByInventoryPath with the correct parameters' do
-      expect(connection.searchIndex).to receive(:FindByInventoryPath)
-
-      subject.find_vm(poolname,vmname,connection)
-    end
-
-    it 'should return the VM object when found' do
-      expect(connection.searchIndex).to receive(:FindByInventoryPath).and_return(vm_object)
-
-      expect(subject.find_vm(poolname,vmname,connection)).to be(vm_object)
-    end
-
-    it 'should return nil if the VM is not found' do
-      expect(connection.searchIndex).to receive(:FindByInventoryPath).and_return(nil)
-
-      expect(subject.find_vm(poolname,missing_vm,connection)).to be_nil
-    end
-  end
-
-  describe '#get_base_vm_container_from' do
-    it 'should return a recursive view of type VirtualMachine' do
-      result = subject.get_base_vm_container_from(connection)
-
-      expect(result.recursive).to be true
-      expect(result.type).to eq(['VirtualMachine'])
-    end
-  end
-
-  describe '#get_snapshot_list' do
-    let(:snapshot_name) {'snapshot'}
-    let(:snapshot_tree) { mock_RbVmomi_VIM_VirtualMachine(mock_options).snapshot.rootSnapshotList }
-    let(:snapshot_object) { mock_RbVmomi_VIM_VirtualMachine() }
-
-    it 'should raise if the snapshot tree is nil' do
-      expect{ subject.get_snapshot_list(nil,snapshot_name)}.to raise_error(NoMethodError)
-    end
-
-    context 'VM with a single layer of snapshots' do
-      let(:mock_options) {{
-        :snapshot_tree => {
-          'snapshot1' => nil,
-          'snapshot2' => nil,
-          'snapshot3'  => nil,
-          'snapshot4' => nil,
-          snapshot_name => { :ref => snapshot_object},
-        }
-      }}
-
-      it 'should return snapshot which matches the name' do
-        result = subject.get_snapshot_list(snapshot_tree,snapshot_name)
-        expect(result).to be(snapshot_object)
-      end
-    end
-
-    context 'VM with a nested layers of snapshots' do
-      let(:mock_options) {{
-        :snapshot_tree => {
-          'snapshot1' => nil,
-          'snapshot2' => nil,
-          'snapshot3'  => { :children => {
-            'snapshot4' => nil,
-            'snapshot5' => { :children => {
-              snapshot_name => { :ref => snapshot_object},
-            }},
-          }},
-          'snapshot6' => nil,
-        }
-      }}
-
-      it 'should return snapshot which matches the name' do
-        result = subject.get_snapshot_list(snapshot_tree,snapshot_name)
-        expect(result).to be(snapshot_object)
-      end
-    end
-  end
-
-  describe '#migrate_vm_host' do
-    let(:vm_object) { mock_RbVmomi_VIM_VirtualMachine({ :name => vmname })}
-    let(:host_object) { mock_RbVmomi_VIM_HostSystem({ :name => 'HOST' })}
-    let(:relocate_task) { mock_RbVmomi_VIM_Task() }
-
-    before(:each) do
-      allow(vm_object).to receive(:RelocateVM_Task).and_return(relocate_task)
-      allow(relocate_task).to receive(:wait_for_completion)
-    end
-
-    it 'should call RelocateVM_Task' do
-      expect(vm_object).to receive(:RelocateVM_Task).and_return(relocate_task)
-
-      subject.migrate_vm_host(vm_object,host_object)
-    end
-
-    it 'should use a Relocation Spec object with correct host' do
-      expect(vm_object).to receive(:RelocateVM_Task).with(relocation_spec_with_host(host_object))
-
-      subject.migrate_vm_host(vm_object,host_object)
-    end
-
-    it 'should wait for the relocation to complete' do
-      expect(relocate_task).to receive(:wait_for_completion)
-
-      subject.migrate_vm_host(vm_object,host_object)
-    end
-
-    it 'should return the result of the relocation' do
-      expect(relocate_task).to receive(:wait_for_completion).and_return('RELOCATE_RESULT')
-
-      expect(subject.migrate_vm_host(vm_object,host_object)).to eq('RELOCATE_RESULT')
-    end
-  end
-
-  describe 'find_template_vm' do
-    let(:vm_object) { mock_RbVmomi_VIM_VirtualMachine() }
-
-    before(:each) do
-      allow(connection.searchIndex).to receive(:FindByInventoryPath)
-    end
-    it 'should raise an error when the datacenter cannot be found' do
-      config[:providers][:vsphere]['datacenter'] = nil
-
-      expect{ subject.find_template_vm(config[:pools][0],connection) }.to raise_error('cannot find datacenter')
-    end
-
-    it 'should raise an error when the template specified cannot be found' do
-      expect(connection.searchIndex).to receive(:FindByInventoryPath).and_return(nil)
-
-      expect{ subject.find_template_vm(config[:pools][0],connection) }.to raise_error("Pool #{poolname} specifies a template VM of #{config[:pools][0]['template']} which does not exist for the provider vsphere")
-    end
-
-    it 'should return the vm object' do
-      expect(connection.searchIndex).to receive(:FindByInventoryPath).and_return(vm_object)
-
-      subject.find_template_vm(config[:pools][0],connection)
-    end
-  end
-
-  describe 'valid_template_path?' do
-
-    it 'should return true with a valid template path' do
-      expect(subject.valid_template_path?('test/template')).to eq(true)
-    end
-
-    it 'should return false when no / is found' do
-      expect(subject.valid_template_path?('testtemplate')).to eq(false)
-    end
-
-    it 'should return false when template path begins with /' do
-      expect(subject.valid_template_path?('/testtemplate')).to eq(false)
-    end
-
-    it 'should return false when template path ends with /' do
-      expect(subject.valid_template_path?('testtemplate/')).to eq(false)
-    end
-  end
-
-  describe 'create_template_delta_disks' do
-    let(:template_object) { mock_RbVmomi_VIM_VirtualMachine({
-        :name => vmname,
-      })
-    }
-
-    before(:each) do
-      allow(subject).to receive(:connect_to_vsphere).and_return(connection)
-    end
-
-    context 'with a template VM found' do
-
-      before(:each) do
-        expect(subject).to receive(:find_template_vm).and_return(template_object)
-      end
-
-      it 'should reconfigure the VM creating delta disks' do
-        expect(template_object).to receive(:add_delta_disk_layer_on_all_disks)
-
-        subject.create_template_delta_disks(config[:pools][0])
-      end
-    end
-  end
-
-  describe 'get_disk_backing' do
-
-    it 'should return moveChildMostDiskBacking when linked clone enabled' do
-      expect( subject.get_disk_backing({'create_linked_clone' => true}) ).to eq(:moveChildMostDiskBacking)
-    end
-
-    it 'should return moveAllDiskBackingsAndConsolidate when no preference is specified' do
-      expect( subject.get_disk_backing({})).to eq(:moveAllDiskBackingsAndConsolidate)
-    end
-
-    it 'should return moveAllDiskBackingsAndConsolidate when linked clone is false' do
-      expect( subject.get_disk_backing({create_linked_clone: false})).to eq(:moveAllDiskBackingsAndConsolidate)
-    end
-  end
-
-  describe 'linked_clone?' do
-    it 'should return true when linked clone is enabled on the pool' do
-      expect( subject.linked_clone?({'create_linked_clone' => true}) ).to be true
-    end
-
-    it 'should return nil when linked clone is not enabled on the pool' do
-      expect( subject.linked_clone?({}) ).to be nil
-    end
-  end
-end
diff --git a/spec/unit/providers_spec.rb b/spec/unit/providers_spec.rb
index 0ccc7f0..91045f2 100644
--- a/spec/unit/providers_spec.rb
+++ b/spec/unit/providers_spec.rb
@@ -12,12 +12,8 @@ describe 'providers' do
   end
 
   it '#load_all_providers' do
-    p = [
-        File.join(project_root_dir, 'lib', 'vmpooler', 'providers', 'base.rb'),
-        File.join(project_root_dir, 'lib', 'vmpooler', 'providers', 'dummy.rb'),
-        File.join(project_root_dir, 'lib', 'vmpooler', 'providers', 'vsphere.rb')
-    ]
-    expect(Vmpooler::Providers.load_all_providers).to match_array(p)
+    expect(Vmpooler::Providers.load_all_providers.join(', ')).to match(%r{#{project_root_dir}/lib/vmpooler/providers/base.rb})
+    expect(Vmpooler::Providers.load_all_providers.join(', ')).to match(%r{#{project_root_dir}/lib/vmpooler/providers/dummy.rb})
   end
 
   it '#installed_providers' do
@@ -30,21 +26,18 @@ describe 'providers' do
   end
 
   it '#load_by_name' do
-    expect(Vmpooler::Providers.load_by_name('vsphere')).to eq([File.join(project_root_dir, 'lib', 'vmpooler', 'providers', 'vsphere.rb')])
+    expect(Vmpooler::Providers.load_by_name('dummy').join(', ')).to match(%r{#{project_root_dir}/lib/vmpooler/providers/dummy.rb})
+    expect(Vmpooler::Providers.load_by_name('dummy').join(', ')).to_not match(%r{,})
   end
 
-  it '#load only vpshere' do
-    expect(providers.load_from_gems('vsphere')).to eq([File.join(project_root_dir, 'lib', 'vmpooler', 'providers', 'vsphere.rb')])
+  it '#load only dummy' do
+    expect(providers.load_from_gems('dummy').join(', ')).to match(%r{#{project_root_dir}/lib/vmpooler/providers/dummy.rb})
+    expect(providers.load_from_gems('dummy').join(', ')).to_not match(%r{,})
   end
 
   it '#load all providers from gems' do
-    p = [
-        File.join(project_root_dir, 'lib', 'vmpooler', 'providers', 'base.rb'),
-        File.join(project_root_dir, 'lib', 'vmpooler', 'providers', 'dummy.rb'),
-        File.join(project_root_dir, 'lib', 'vmpooler', 'providers', 'vsphere.rb')
-    ]
-    expect(providers.load_from_gems).to match_array(p)
-
+    expect(providers.load_from_gems.join(', ')).to match(%r{#{project_root_dir}/lib/vmpooler/providers/base.rb})
+    expect(providers.load_from_gems.join(', ')).to match(%r{#{project_root_dir}/lib/vmpooler/providers/dummy.rb})
   end
 
 
diff --git a/vmpooler.gemspec b/vmpooler.gemspec
index 20e35fe..75eb67c 100644
--- a/vmpooler.gemspec
+++ b/vmpooler.gemspec
@@ -32,7 +32,6 @@ Gem::Specification.new do |s|
   s.add_dependency 'puma', '~> 5.0', '>= 5.0.4'
   s.add_dependency 'rack', '~> 2.2'
   s.add_dependency 'rake', '~> 13.0'
-  s.add_dependency 'rbvmomi', '>= 2.1', '< 4.0'
   s.add_dependency 'redis', '~> 4.1'
   s.add_dependency 'sinatra', '~> 2.0'
   s.add_dependency 'spicy-proton', '~> 2.1'