diff --git a/README.md b/README.md
index 66b9bd9..0b7116c 100644
--- a/README.md
+++ b/README.md
@@ -1,41 +1,38 @@
-![vmpooler](https://raw.github.com/sschneid/vmpooler/master/lib/vmpooler/public/img/logo.gif)
+![VMPooler](https://raw.github.com/sschneid/vmpooler/master/lib/vmpooler/public/img/logo.gif)
 
-# vmpooler
-
-vmpooler provides configurable 'pools' of instantly-available (running) virtual machines.
+# VMPooler
 
+VMPooler provides configurable 'pools' of instantly-available (pre-provisioned) and/or on-demand (provisioned on request) virtual machines.
 
 ## Usage
 
-At [Puppet, Inc.](http://puppet.com) we run acceptance tests on thousands of disposable VMs every day. Vmpooler manages the lifecycle of these VMs from request through deletion, with options available to pool ready instances, and provision on demand.
+At [Puppet, Inc.](http://puppet.com) we run acceptance tests on thousands of disposable VMs every day. VMPooler manages the life cycle of these VMs from request through deletion, with options available to pool ready instances, and provision on demand.
 
 ## Installation
 
 ### Prerequisites
 
-vmpooler is available as a gem
-
-To use the gem `gem install vmpooler`
+VMPooler is available as a gem. To use the gem run `gem install vmpooler` or add it to your Gemfile and install via bundler.
 
 ### Dependencies
 
-Vmpooler requires a [Redis](http://redis.io/) server. This is the datastore used for vmpooler's inventory and queueing services.
+VMPooler requires a [Redis](http://redis.io/) server. This is the data store used for VMPooler's inventory and queuing services.
 
 ### Configuration
 
-Configuration for vmpooler may be provided via environment variables, or a configuration file.
+Configuration for VMPooler may be provided via environment variables, or a configuration file.
 
-Note on jruby 9.2.11.x: We have found when running vmpooler on jruby 9.2.11.x we occasionally encounter a stack overflow error that causes the pool\_manager application component to fail and stop doing work. To address this issue on jruby 9.2.11.x we recommend setting the jruby option 'invokedynamic.yield=false'. To set this with jruby 9.2.11.1 you can specify the environment variable 'JRUBY\_OPTS' with the value '-Xinvokedynamic.yield=false'.
+**Note on JRuby 9.2.11.x:** We have found when running VMPooler on JRuby 9.2.11.x we occasionally encounter a stack overflow error that causes the pool\_manager application component to fail and stop doing work. To address this issue on JRuby 9.2.11.x we recommend setting the JRuby option 'invokedynamic.yield=false'. To set this with JRuby 9.2.11.1 you can specify the environment variable 'JRUBY\_OPTS' with the value '-Xinvokedynamic.yield=false'.
 
-The provided configuration defaults are reasonable for  small vmpooler instances with a few pools. If you plan to run a large vmpooler instance it is important to consider configuration values appropriate for the instance of your size in order to avoid starving the provider, or redis, of connections.
+The provided configuration defaults are reasonable for  small VMPooler instances with a few pools. If you plan to run a large VMPooler instance it is important to consider configuration values appropriate for the instance of your size in order to avoid starving the provider, or Redis, of connections.
 
-As of vmpooler 0.13.x redis uses a connection pool to improve efficiency and ensure thread safe usage. At Puppet, we run an instance with about 100 pools at any given time. We have to provide it with 200 redis connections to the redis connection pool, and a timeout for connections of 40 seconds, to avoid timeouts. Because metrics are generated for connection available and waited your metrics provider will need to be able to cope with this volume. Statsd is recommended to ensure metrics get delivered reliably.
+As of VMPooler 0.13.x Redis uses a connection pool to improve efficiency and ensure thread safe usage. At Puppet, we run an instance with about 100 pools at any given time. We have to provide it with 200 Redis connections to the Redis connection pool, and a timeout for connections of 40 seconds, to avoid timeouts. Because metrics are generated for connection available and waited your metrics provider will need to be able to cope with this volume. Prometheus or StatsD is recommended to ensure metrics get delivered reliably.
 
-Please see this [configuration](docs/configuration.md) document for more details about configuring vmpooler via environment variables.
+Please see this [configuration](docs/configuration.md) document for more details about configuring VMPooler via environment variables.
 
 The following YAML configuration sets up two pools, `debian-7-i386` and `debian-7-x86_64`, which contain 5 running VMs each:
 
-```
+```yaml
 ---
 :providers:
   :vsphere:
@@ -70,43 +67,43 @@ See the provided YAML configuration example, [vmpooler.yaml.example](vmpooler.ya
 
 ### Running via Docker
 
-A [Dockerfile](/docker/Dockerfile) is included in this repository to allow running vmpooler inside a Docker container. A configuration file can be used via volume mapping, and specifying the destination as the configuration file via environment variables, or the application can be configured with environment variables alone. The Dockerfile provides an entrypoint so you may choose whether to run API, or manager services. The default behavior will run both. To build and run:
+A [Dockerfile](/docker/Dockerfile) is included in this repository to allow running VMPooler inside a Docker container. A configuration file can be used via volume mapping, and specifying the destination as the configuration file via environment variables, or the application can be configured with environment variables alone. The Dockerfile provides an entrypoint so you may choose whether to run API, or manager services. The default behavior will run both. To build and run:
 
-```
+```bash
 docker build -t vmpooler . && docker run -e VMPOOLER_CONFIG -p 80:4567 -it vmpooler
 ```
 
-To run only the API and dashboard
+To run only the API and dashboard:
 
-```
+```bash
 docker run -p 80:4567 -it vmpooler api
 ```
 
-To run only the manager component
+To run only the manager component:
 
-```
+```bash
 docker run -it vmpooler manager
 ```
 
 ### docker-compose
 
-A docker-compose file is provided to support running vmpooler easily via docker-compose. This is useful for development because your local code is used to build the gem used in the docker-compose environment.
+A docker-compose file is provided to support running VMPooler easily via docker-compose. This is useful for development because your local code is used to build the gem used in the docker-compose environment.
 
-```
+```bash
 docker-compose -f docker/docker-compose.yml up
 ```
 
 ### Running Docker inside Vagrant
 
-A vagrantfile is included in this repository. Please see [vagrant instructions](docs/vagrant.md) for details.
+A Vagrantfile is included in this repository. Please see [vagrant instructions](docs/vagrant.md) for details.
 
 ## API and Dashboard
 
-vmpooler provides an API and web front-end (dashboard) on port `:4567`.  See the provided YAML configuration example, [vmpooler.yaml.example](vmpooler.yaml.example), to specify an alternative port to listen on.
+VMPooler provides an API and web front-end (dashboard) on port `:4567`.  See the provided YAML configuration example, [vmpooler.yaml.example](vmpooler.yaml.example), to specify an alternative port to listen on.
 
 ### API
 
-vmpooler provides a REST API for VM management.  See the [API documentation](docs/API.md) for more information.
+VMPooler provides a REST API for VM management.  See the [API documentation](docs/API.md) for more information.
 
 ### Dashboard
 
@@ -122,17 +119,16 @@ A dashboard is provided to offer real-time statistics and historical graphs.  It
 
 ## Vagrant plugin
 
-- [vagrant-vmpooler](https://github.com/briancain/vagrant-vmpooler) Use Vagrant to create and manage your vmpooler instances.
+- [vagrant-vmpooler](https://github.com/briancain/vagrant-vmpooler) Use Vagrant to create and manage your VMPooler instances.
 
 ## Development and further documentation
 
-For more information about setting up a development instance of vmpooler or other subjects, see the [docs/](docs) directory.
+For more information about setting up a development instance of VMPooler or other subjects, see the [docs/](docs) directory.
 
 ## Build status
 
 [![Build Status](https://travis-ci.org/puppetlabs/vmpooler.png?branch=master)](https://travis-ci.org/puppetlabs/vmpooler)
 
-
 ## License
 
-vmpooler is distributed under the [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.html).  See the [LICENSE](LICENSE) file for more details.
+VMPooler is distributed under the [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.html).  See the [LICENSE](LICENSE) file for more details.
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'