commit a08cba099f867b1db01a50940ec3ae9239245db5
Author: Gene Liverman <gene.liverman+06301990@puppet.com>
Date:   Mon Nov 29 15:14:42 2021 -0500

    Initial commit migrating from VMPooler proper
    
    This copies in all needed files from the main VMPooler repo. Version
    1.3.0 of VMPooler was used as the basis for this code.

diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 0000000..c8f8016
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,8 @@
+version: 2
+updates:
+- package-ecosystem: bundler
+  directory: "/"
+  schedule:
+    interval: daily
+    time: "13:00"
+  open-pull-requests-limit: 10
diff --git a/.github/workflows/testing.yml b/.github/workflows/testing.yml
new file mode 100644
index 0000000..501403f
--- /dev/null
+++ b/.github/workflows/testing.yml
@@ -0,0 +1,47 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
+
+name: Testing
+
+on:
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  rubocop:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version:
+          - '2.5.8'
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - name: Run Rubocop
+      run: bundle exec rake rubocop
+
+  spec_tests:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version:
+          - '2.5.8'
+          - 'jruby-9.2.12.0'
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - name: Run spec tests
+      run: bundle exec rake test
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..41f92b9
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,10 @@
+.bundle/
+.vagrant/
+coverage/
+vendor/
+.dccache
+.ruby-version
+Gemfile.local
+results.xml
+/vmpooler.yaml
+
diff --git a/CODEOWNERS b/CODEOWNERS
new file mode 100644
index 0000000..9c4ecfc
--- /dev/null
+++ b/CODEOWNERS
@@ -0,0 +1,10 @@
+
+# This will cause DIO to be assigned review of any opened PRs against
+# the branches containing this file.
+# See https://help.github.com/en/articles/about-code-owners for info on how to
+# take ownership of parts of the code base that should be reviewed by another
+# team.
+
+# DIO will be the default owners for everything in the repo.
+*                                     @puppetlabs/dio
+
diff --git a/Gemfile b/Gemfile
new file mode 100644
index 0000000..122d6b5
--- /dev/null
+++ b/Gemfile
@@ -0,0 +1,13 @@
+source ENV['GEM_SOURCE'] || 'https://rubygems.org'
+
+gemspec
+
+# Evaluate Gemfile.local if it exists
+if File.exists? "#{__FILE__}.local"
+  instance_eval(File.read("#{__FILE__}.local"))
+end
+
+# Evaluate ~/.gemfile if it exists
+if File.exists?(File.join(Dir.home, '.gemfile'))
+  instance_eval(File.read(File.join(Dir.home, '.gemfile')))
+end
diff --git a/Gemfile.lock b/Gemfile.lock
new file mode 100644
index 0000000..83f626e
--- /dev/null
+++ b/Gemfile.lock
@@ -0,0 +1,191 @@
+PATH
+  remote: .
+  specs:
+    vmpooler-vsphere-provider (1.3.0)
+      rbvmomi (>= 2.1, < 4.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    bindata (2.4.10)
+    builder (3.2.4)
+    climate_control (1.0.1)
+    coderay (1.1.3)
+    concurrent-ruby (1.1.9)
+    connection_pool (2.2.5)
+    diff-lcs (1.4.4)
+    docile (1.4.0)
+    faraday (1.8.0)
+      faraday-em_http (~> 1.0)
+      faraday-em_synchrony (~> 1.0)
+      faraday-excon (~> 1.1)
+      faraday-httpclient (~> 1.0.1)
+      faraday-net_http (~> 1.0)
+      faraday-net_http_persistent (~> 1.1)
+      faraday-patron (~> 1.0)
+      faraday-rack (~> 1.0)
+      multipart-post (>= 1.2, < 3)
+      ruby2_keywords (>= 0.0.4)
+    faraday-em_http (1.0.0)
+    faraday-em_synchrony (1.0.0)
+    faraday-excon (1.1.0)
+    faraday-httpclient (1.0.1)
+    faraday-net_http (1.0.1)
+    faraday-net_http_persistent (1.2.0)
+    faraday-patron (1.0.0)
+    faraday-rack (1.0.0)
+    google-cloud-env (1.5.0)
+      faraday (>= 0.17.3, < 2.0)
+    json (2.6.1)
+    method_source (1.0.0)
+    mock_redis (0.29.0)
+      ruby2_keywords
+    multipart-post (2.1.1)
+    mustermann (1.1.1)
+      ruby2_keywords (~> 0.0.1)
+    net-ldap (0.17.0)
+    nio4r (2.5.8)
+    nokogiri (1.12.5-x86_64-linux)
+      racc (~> 1.4)
+    opentelemetry-api (0.17.0)
+    opentelemetry-common (0.17.0)
+      opentelemetry-api (~> 0.17.0)
+    opentelemetry-exporter-jaeger (0.17.0)
+      opentelemetry-api (~> 0.17.0)
+      opentelemetry-common (~> 0.17.0)
+      opentelemetry-sdk (~> 0.17.0)
+      thrift
+    opentelemetry-instrumentation-base (0.17.0)
+      opentelemetry-api (~> 0.17.0)
+    opentelemetry-instrumentation-concurrent_ruby (0.17.0)
+      opentelemetry-api (~> 0.17.0)
+      opentelemetry-instrumentation-base (~> 0.17.0)
+    opentelemetry-instrumentation-redis (0.17.0)
+      opentelemetry-api (~> 0.17.0)
+      opentelemetry-common (~> 0.17.0)
+      opentelemetry-instrumentation-base (~> 0.17.0)
+    opentelemetry-instrumentation-sinatra (0.17.0)
+      opentelemetry-api (~> 0.17.0)
+      opentelemetry-instrumentation-base (~> 0.17.0)
+    opentelemetry-resource_detectors (0.17.0)
+      google-cloud-env
+      opentelemetry-sdk
+    opentelemetry-sdk (0.17.0)
+      opentelemetry-api (~> 0.17.0)
+      opentelemetry-common (~> 0.17.0)
+      opentelemetry-instrumentation-base (~> 0.17.0)
+    optimist (3.0.1)
+    parallel (1.21.0)
+    parser (3.0.3.1)
+      ast (~> 2.4.1)
+    pickup (0.0.11)
+    prometheus-client (2.1.0)
+    pry (0.14.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    puma (5.5.2)
+      nio4r (~> 2.0)
+    racc (1.6.0)
+    rack (2.2.3)
+    rack-protection (2.1.0)
+      rack
+    rack-test (1.1.0)
+      rack (>= 1.0, < 3)
+    rainbow (3.0.0)
+    rake (13.0.6)
+    rbvmomi (3.0.0)
+      builder (~> 3.2)
+      json (~> 2.3)
+      nokogiri (~> 1.10)
+      optimist (~> 3.0)
+    redis (4.5.1)
+    regexp_parser (2.1.1)
+    rexml (3.2.5)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.3)
+    rubocop (1.1.0)
+      parallel (~> 1.10)
+      parser (>= 2.7.1.5)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8)
+      rexml
+      rubocop-ast (>= 1.0.1)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 2.0)
+    rubocop-ast (1.13.0)
+      parser (>= 3.0.1.1)
+    ruby-progressbar (1.11.0)
+    ruby2_keywords (0.0.5)
+    simplecov (0.21.2)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-html (0.12.3)
+    simplecov_json_formatter (0.1.3)
+    sinatra (2.1.0)
+      mustermann (~> 1.0)
+      rack (~> 2.2)
+      rack-protection (= 2.1.0)
+      tilt (~> 2.0)
+    spicy-proton (2.1.13)
+      bindata (~> 2.3)
+    statsd-ruby (1.5.0)
+    thor (1.1.0)
+    thrift (0.15.0)
+    tilt (2.0.10)
+    unicode-display_width (1.8.0)
+    vmpooler (1.3.0)
+      concurrent-ruby (~> 1.1)
+      connection_pool (~> 2.2)
+      net-ldap (~> 0.16)
+      nokogiri (~> 1.10)
+      opentelemetry-exporter-jaeger (= 0.17.0)
+      opentelemetry-instrumentation-concurrent_ruby (= 0.17.0)
+      opentelemetry-instrumentation-redis (= 0.17.0)
+      opentelemetry-instrumentation-sinatra (= 0.17.0)
+      opentelemetry-resource_detectors (= 0.17.0)
+      opentelemetry-sdk (= 0.17.0)
+      pickup (~> 0.0.11)
+      prometheus-client (~> 2.0)
+      puma (~> 5.0, >= 5.0.4)
+      rack (~> 2.2)
+      rake (~> 13.0)
+      rbvmomi (>= 2.1, < 4.0)
+      redis (~> 4.1)
+      sinatra (~> 2.0)
+      spicy-proton (~> 2.1)
+      statsd-ruby (~> 1.4)
+    yarjuf (2.0.0)
+      builder
+      rspec (~> 3)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  climate_control (>= 0.2.0)
+  mock_redis (>= 0.17.0)
+  pry
+  rack-test (>= 0.6)
+  rspec (>= 3.2)
+  rubocop (~> 1.1.0)
+  simplecov (>= 0.11.2)
+  thor (~> 1.0, >= 1.0.1)
+  vmpooler (~> 1.3, >= 1.3.0)
+  vmpooler-vsphere-provider!
+  yarjuf (>= 2.0)
+
+BUNDLED WITH
+   2.2.22
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..8cbda60
--- /dev/null
+++ b/README.md
@@ -0,0 +1,3 @@
+# vmpooler-vsphere-provider
+
+This is a WIP - do not use yet. The goal is to extract the vSphere provider from the main VMPooler codebase. Force pushes to this repo may happen while initial development is happening.
diff --git a/Rakefile b/Rakefile
new file mode 100644
index 0000000..76d6a80
--- /dev/null
+++ b/Rakefile
@@ -0,0 +1,25 @@
+require 'rspec/core/rake_task'
+
+rubocop_available = Gem::Specification::find_all_by_name('rubocop').any?
+require 'rubocop/rake_task' if rubocop_available
+
+desc 'Run rspec tests with coloring.'
+RSpec::Core::RakeTask.new(:test) do |t|
+  t.rspec_opts = %w[--color --format documentation]
+  t.pattern    = 'spec/'
+end
+
+desc 'Run rspec tests and save JUnit output to results.xml.'
+RSpec::Core::RakeTask.new(:junit) do |t|
+  t.rspec_opts = %w[-r yarjuf -f JUnit -o results.xml]
+  t.pattern    = 'spec/'
+end
+
+if rubocop_available
+  desc 'Run RuboCop'
+  RuboCop::RakeTask.new(:rubocop) do |task|
+    task.options << '--display-cop-names'
+  end
+end
+
+task :default => [:test]
diff --git a/lib/vmpooler-vsphere-provider/version.rb b/lib/vmpooler-vsphere-provider/version.rb
new file mode 100644
index 0000000..e9c9fad
--- /dev/null
+++ b/lib/vmpooler-vsphere-provider/version.rb
@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module VmpoolerVsphereProvider
+  VERSION = '1.3.0'
+end
diff --git a/lib/vmpooler/providers/vsphere.rb b/lib/vmpooler/providers/vsphere.rb
new file mode 100644
index 0000000..b860743
--- /dev/null
+++ b/lib/vmpooler/providers/vsphere.rb
@@ -0,0 +1,1173 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+require 'bigdecimal/util'
+require 'rbvmomi'
+require 'vmpooler/providers/base'
+
+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
new file mode 100755
index 0000000..f03ce39
--- /dev/null
+++ b/scripts/create_template_deltas.rb
@@ -0,0 +1,98 @@
+#!/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/fixtures/vmpooler.yaml b/spec/fixtures/vmpooler.yaml
new file mode 100644
index 0000000..c5c0522
--- /dev/null
+++ b/spec/fixtures/vmpooler.yaml
@@ -0,0 +1,43 @@
+---
+:providers:
+  :dummy:
+
+:redis:
+  server: 'localhost'
+
+:auth:
+   provider: dummy
+
+:tagfilter:
+  url: '(.*)\/'
+
+:config:
+  site_name: 'vmpooler'
+  # Need to change this on Windows
+  logfile: '/var/log/vmpooler.log'
+  task_limit: 10
+  timeout: 15
+  vm_checktime: 1
+  vm_lifetime: 12
+  vm_lifetime_auth: 24
+  allowed_tags:
+    - 'created_by'
+    - 'project'
+  domain: 'example.com'
+  prefix: 'poolvm-'
+
+# Uncomment the lines below to suppress metrics to STDOUT
+# :statsd:
+#   server: 'localhost'
+#   prefix: 'vmpooler'
+#   port: 8125
+
+:pools:
+  - name: 'pool01'
+    size: 5
+    provider: dummy
+    ready_ttl: 5
+  - name: 'pool02'
+    size: 5
+    provider: dummy
+    ready_ttl: 5
diff --git a/spec/fixtures/vmpooler2.yaml b/spec/fixtures/vmpooler2.yaml
new file mode 100644
index 0000000..a016d30
--- /dev/null
+++ b/spec/fixtures/vmpooler2.yaml
@@ -0,0 +1,43 @@
+---
+:providers:
+  :dummy:
+
+:redis:
+  server: 'localhost'
+
+:auth:
+   provider: dummy
+
+:tagfilter:
+  url: '(.*)\/'
+
+:config:
+  site_name: 'vmpooler'
+  # Need to change this on Windows
+  logfile: '/var/log/vmpooler.log'
+  task_limit: 10
+  timeout: 15
+  vm_checktime: 1
+  vm_lifetime: 12
+  vm_lifetime_auth: 24
+  allowed_tags:
+    - 'created_by'
+    - 'project'
+  domain: 'example.com'
+  prefix: 'poolvm-'
+
+# Uncomment the lines below to suppress metrics to STDOUT
+# :statsd:
+#   server: 'localhost'
+#   prefix: 'vmpooler'
+#   port: 8125
+
+:pools:
+  - name: 'pool03'
+    size: 5
+    provider: dummy
+    ready_ttl: 5
+  - name: 'pool04'
+    size: 5
+    provider: dummy
+    ready_ttl: 5
diff --git a/spec/helpers.rb b/spec/helpers.rb
new file mode 100644
index 0000000..87245db
--- /dev/null
+++ b/spec/helpers.rb
@@ -0,0 +1,154 @@
+require 'mock_redis'
+
+def redis
+  unless @redis
+    @redis = MockRedis.new
+  end
+  @redis
+end
+
+# Mock an object which represents a Logger.  This stops the proliferation
+# of allow(logger).to .... expectations in tests.
+class MockLogger
+  def log(_level, string)
+  end
+end
+
+def expect_json(ok = true, http = 200)
+  expect(last_response.header['Content-Type']).to eq('application/json')
+
+  if (ok == true) then
+    expect(JSON.parse(last_response.body)['ok']).to eq(true)
+  else
+    expect(JSON.parse(last_response.body)['ok']).to eq(false)
+  end
+
+  expect(last_response.status).to eq(http)
+end
+
+def create_token(token, user, timestamp)
+  redis.hset("vmpooler__token__#{token}", 'user', user)
+  redis.hset("vmpooler__token__#{token}", 'created', timestamp)
+end
+
+def get_token_data(token)
+  redis.hgetall("vmpooler__token__#{token}")
+end
+
+def token_exists?(token)
+  result = get_token_data
+  result && !result.empty?
+end
+
+def create_ready_vm(template, name, redis, token = nil)
+  create_vm(name, redis, token)
+  redis.sadd("vmpooler__ready__#{template}", name)
+  redis.hset("vmpooler__vm__#{name}", "template", template)
+end
+
+def create_running_vm(template, name, redis, token = nil, user = nil)
+  create_vm(name, redis, token, user)
+  redis.sadd("vmpooler__running__#{template}", name)
+  redis.hset("vmpooler__vm__#{name}", 'template', template)
+  redis.hset("vmpooler__vm__#{name}", 'checkout', Time.now)
+  redis.hset("vmpooler__vm__#{name}", 'host', 'host1')
+end
+
+def create_pending_vm(template, name, redis, token = nil)
+  create_vm(name, redis, token)
+  redis.sadd("vmpooler__pending__#{template}", name)
+  redis.hset("vmpooler__vm__#{name}", "template", template)
+end
+
+def create_vm(name, redis, token = nil, user = nil)
+  redis.hset("vmpooler__vm__#{name}", 'checkout', Time.now)
+  redis.hset("vmpooler__vm__#{name}", 'clone', Time.now)
+  redis.hset("vmpooler__vm__#{name}", 'token:token', token) if token
+  redis.hset("vmpooler__vm__#{name}", 'token:user', user) if user
+end
+
+def create_completed_vm(name, pool, redis, active = false)
+  redis.sadd("vmpooler__completed__#{pool}", name)
+  redis.hset("vmpooler__vm__#{name}", 'checkout', Time.now)
+  redis.hset("vmpooler__active__#{pool}", name, Time.now) if active
+end
+
+def create_discovered_vm(name, pool, redis)
+  redis.sadd("vmpooler__discovered__#{pool}", name)
+end
+
+def create_migrating_vm(name, pool, redis)
+  redis.hset("vmpooler__vm__#{name}", 'checkout', Time.now)
+  redis.sadd("vmpooler__migrating__#{pool}", name)
+end
+
+def create_tag(vm, tag_name, tag_value, redis)
+  redis.hset("vmpooler__vm__#{vm}", "tag:#{tag_name}", tag_value)
+end
+
+def add_vm_to_migration_set(name, redis)
+  redis.sadd('vmpooler__migration', name)
+end
+
+def fetch_vm(vm)
+  redis.hgetall("vmpooler__vm__#{vm}")
+end
+
+def set_vm_data(vm, key, value, redis)
+  redis.hset("vmpooler__vm__#{vm}", key, value)
+end
+
+def snapshot_revert_vm(vm, snapshot = '12345678901234567890123456789012', redis)
+  redis.sadd('vmpooler__tasks__snapshot-revert', "#{vm}:#{snapshot}")
+  redis.hset("vmpooler__vm__#{vm}", "snapshot:#{snapshot}", "1")
+end
+
+def snapshot_vm(vm, snapshot = '12345678901234567890123456789012', redis)
+  redis.sadd('vmpooler__tasks__snapshot', "#{vm}:#{snapshot}")
+  redis.hset("vmpooler__vm__#{vm}", "snapshot:#{snapshot}", "1")
+end
+
+def disk_task_vm(vm, disk_size = '10', redis)
+  redis.sadd('vmpooler__tasks__disk', "#{vm}:#{disk_size}")
+end
+
+def has_vm_snapshot?(vm, redis)
+  redis.smembers('vmpooler__tasks__snapshot').any? do |snapshot|
+    instance, _sha = snapshot.split(':')
+    vm == instance
+  end
+end
+
+def vm_reverted_to_snapshot?(vm, redis, snapshot = nil)
+  redis.smembers('vmpooler__tasks__snapshot-revert').any? do |action|
+    instance, sha = action.split(':')
+    instance == vm and (snapshot ? (sha == snapshot) : true)
+  end
+end
+
+def pool_has_ready_vm?(pool, vm, redis)
+  !!redis.sismember('vmpooler__ready__' + pool, vm)
+end
+
+def create_ondemand_request_for_test(request_id, score, platforms_string, redis, user = nil, token = nil)
+  redis.zadd('vmpooler__provisioning__request', score, request_id)
+  redis.hset("vmpooler__odrequest__#{request_id}", 'requested', platforms_string)
+  redis.hset("vmpooler__odrequest__#{request_id}", 'token:token', token) if token
+  redis.hset("vmpooler__odrequest__#{request_id}", 'token:user', user) if user
+end
+
+def set_ondemand_request_status(request_id, status, redis)
+  redis.hset("vmpooler__odrequest__#{request_id}", 'status', status)
+end
+
+def create_ondemand_vm(vmname, request_id, pool, pool_alias, redis)
+  redis.sadd("vmpooler__#{request_id}__#{pool_alias}__#{pool}", vmname)
+end
+
+def create_ondemand_creationtask(request_string, score, redis)
+  redis.zadd('vmpooler__odcreate__task', score, request_string)
+end
+
+def create_ondemand_processing(request_id, score, redis)
+  redis.zadd('vmpooler__provisioning__processing', score, request_id)
+end
diff --git a/spec/rbvmomi_helper.rb b/spec/rbvmomi_helper.rb
new file mode 100644
index 0000000..e0acbaf
--- /dev/null
+++ b/spec/rbvmomi_helper.rb
@@ -0,0 +1,922 @@
+# -----------------------------------------------------------------------------------------------------------------
+# 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
new file mode 100644
index 0000000..080f797
--- /dev/null
+++ b/spec/spec_helper.rb
@@ -0,0 +1,19 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter '/spec/'
+end
+require 'helpers'
+require 'rbvmomi_helper'
+require 'rbvmomi'
+require 'rspec'
+require 'vmpooler'
+require 'redis'
+require 'vmpooler/metrics'
+
+def project_root_dir
+  File.dirname(File.dirname(__FILE__))
+end
+
+def fixtures_dir
+  File.join(project_root_dir, 'spec', 'fixtures')
+end
diff --git a/spec/unit/pool_manager_spec.rb b/spec/unit/pool_manager_spec.rb
new file mode 100644
index 0000000..24dae84
--- /dev/null
+++ b/spec/unit/pool_manager_spec.rb
@@ -0,0 +1,5027 @@
+require 'spec_helper'
+require 'time'
+require 'mock_redis'
+
+# Custom RSpec :Matchers
+
+# Match a Hashtable['name'] is an expected value
+RSpec::Matchers.define :a_pool_with_name_of do |value|
+  match { |actual| actual['name'] == value }
+end
+describe 'Pool Manager' do
+  let(:logger) { MockLogger.new }
+  let(:metrics) { Vmpooler::Metrics::DummyStatsd.new }
+  let(:pool) { 'pool1' }
+  let(:vm) { 'vm1' }
+  let(:timeout) { 5 }
+  let(:host) { double('host') }
+  let(:token) { 'token1234' }
+  let(:request_id) { '1234' }
+  let(:current_time) { Time.now }
+
+  let(:provider_options) { {} }
+  let(:redis_connection_pool) { Vmpooler::PoolManager::GenericConnectionPool.new(
+    metrics: metrics,
+    connpool_type: 'redis_connection_pool',
+    connpool_provider: 'testprovider',
+    size: 1,
+    timeout: 5
+  ) { MockRedis.new }
+  }
+
+  let(:provider) { Vmpooler::PoolManager::Provider::Base.new(config, logger, metrics, redis_connection_pool, 'mock_provider', provider_options) }
+
+  let(:config) { YAML.load(<<-EOT
+---
+:config: {}
+:providers:
+  :mock:
+:redis: {}
+:pools:
+  - name: '#{pool}'
+    size: 1
+EOT
+    )
+  }
+
+  subject { Vmpooler::PoolManager.new(config, logger, redis_connection_pool, metrics) }
+
+  describe '#config' do
+    before do
+      expect(subject).not_to be_nil
+    end
+
+    it 'should return the current configuration' do
+      expect(subject.config).to eq(config)
+    end
+  end
+
+  describe '#load_used_providers' do
+    let(:config) { YAML.load(<<-EOT
+---
+:config:
+:providers:
+  :mock:
+:pools:
+  - name: '#{pool}'
+    size: 1
+    provider: 'spoof'
+  - name: 'vsphere-pool'
+    size: 1
+    provider: 'vsphere'
+    EOT
+    )
+    }
+    it do
+      expect(subject.load_used_providers.join(', ')).to match(%r{#{project_root_dir}/lib/vmpooler/providers/vsphere.rb})
+      expect(subject.load_used_providers.join(', ')).to match(%r{/lib/vmpooler/providers/dummy.rb})
+    end
+  end
+
+  describe '#check_pending_vm' do
+    before do
+      expect(subject).not_to be_nil
+    end
+
+    it 'calls _check_pending_vm' do
+      expect(Thread).to receive(:new).and_yield
+      expect(subject).to receive(:_check_pending_vm).with(vm,pool,timeout,provider)
+
+      subject.check_pending_vm(vm, pool, timeout, provider)
+    end
+  end
+
+  describe '#_check_pending_vm' do
+    before do
+      expect(subject).not_to be_nil
+    end
+
+    context 'host is in pool' do
+
+      it 'calls move_pending_vm_to_ready if host is ready' do
+        expect(provider).to receive(:vm_ready?).with(pool,vm).and_return(true)
+        redis_connection_pool.with do |redis|
+          expect(subject).to receive(:move_pending_vm_to_ready).with(vm, pool, redis, nil)
+        end
+
+        subject._check_pending_vm(vm, pool, timeout, provider)
+      end
+
+      it 'calls fail_pending_vm if host is not ready' do
+        expect(provider).to receive(:vm_ready?).with(pool,vm).and_return(false)
+        redis_connection_pool.with do |redis|
+          expect(subject).to receive(:fail_pending_vm).with(vm, pool, timeout, redis)
+        end
+
+        subject._check_pending_vm(vm, pool, timeout, provider)
+      end
+    end
+
+    context 'with a locked vm mutex' do
+      let(:mutex) { Mutex.new }
+      before(:each) do
+        mutex.lock
+      end
+
+      it 'should return' do
+        expect(subject).to receive(:vm_mutex).and_return(mutex)
+
+        expect(subject._check_pending_vm(vm, pool, timeout, provider)).to be_nil
+      end
+    end
+  end
+
+  describe '#remove_nonexistent_vm' do
+    before do
+      expect(subject).not_to be_nil
+    end
+
+    it 'removes VM from pending in redis' do
+      redis_connection_pool.with do |redis|
+        create_pending_vm(pool,vm,redis)
+
+        subject.remove_nonexistent_vm(vm, pool, redis)
+        expect(redis.sismember("vmpooler__pending__#{pool}", vm)).to be(false)
+      end
+    end
+
+    it 'logs msg' do
+      expect(logger).to receive(:log).with('d', "[!] [#{pool}] '#{vm}' no longer exists. Removing from pending.")
+
+      redis_connection_pool.with do |redis|
+        subject.remove_nonexistent_vm(vm, pool, redis)
+      end
+    end
+  end
+
+ describe '#fail_pending_vm' do
+    before do
+      expect(subject).not_to be_nil
+    end
+
+    before(:each) do
+      redis_connection_pool.with do |redis|
+        create_pending_vm(pool,vm,redis)
+        config[:config]['vm_checktime'] = 15
+      end
+    end
+
+    it 'takes no action if VM is not cloning' do
+      redis_connection_pool.with do |redis|
+        expect(subject.fail_pending_vm(vm, pool, timeout, redis)).to eq(true)
+      end
+    end
+
+    it 'takes no action if VM is within timeout' do
+      redis_connection_pool.with do |redis|
+        redis.hset("vmpooler__vm__#{vm}", 'clone',Time.now.to_s)
+        expect(subject.fail_pending_vm(vm, pool, timeout, redis)).to eq(true)
+        expect(redis.sismember("vmpooler__pending__#{pool}", vm)).to be(true)
+      end
+    end
+
+    it 'moves VM to completed queue if VM has exceeded timeout and exists' do
+      redis_connection_pool.with do |redis|
+        redis.hset("vmpooler__vm__#{vm}", 'clone',Date.new(2001,1,1).to_s)
+        expect(subject.fail_pending_vm(vm, pool, timeout, redis, exists: true)).to eq(true)
+        expect(redis.sismember("vmpooler__pending__#{pool}", vm)).to be(false)
+        expect(redis.sismember("vmpooler__completed__#{pool}", vm)).to be(true)
+      end
+    end
+
+    it 'logs message if VM has exceeded timeout and exists' do
+      redis_connection_pool.with do |redis|
+        redis.hset("vmpooler__vm__#{vm}", 'clone',Date.new(2001,1,1).to_s)
+        expect(logger).to receive(:log).with('d', "[!] [#{pool}] '#{vm}' marked as 'failed' after #{timeout} minutes")
+        expect(subject.fail_pending_vm(vm, pool, timeout, redis, exists: true)).to eq(true)
+      end
+    end
+
+    it 'calls remove_nonexistent_vm if VM has exceeded timeout and does not exist' do
+      redis_connection_pool.with do |redis|
+        redis.hset("vmpooler__vm__#{vm}", 'clone',Date.new(2001,1,1).to_s)
+        expect(subject).to receive(:remove_nonexistent_vm).with(vm, pool, redis)
+        expect(subject.fail_pending_vm(vm, pool, timeout, redis, exists: false)).to eq(true)
+      end
+    end
+
+    it 'swallows error if an error is raised' do
+      redis_connection_pool.with do |redis|
+        redis.hset("vmpooler__vm__#{vm}", 'clone','iamnotparsable_asdate')
+        expect(subject.fail_pending_vm(vm, pool, timeout, redis, exists: true)).to eq(false)
+      end
+    end
+
+    it 'logs message if an error is raised' do
+      redis_connection_pool.with do |redis|
+        redis.hset("vmpooler__vm__#{vm}", 'clone','iamnotparsable_asdate')
+        expect(logger).to receive(:log).with('d', String)
+
+        subject.fail_pending_vm(vm, pool, timeout, redis, exists: true)
+      end
+    end
+
+    context 'with request_id' do
+
+      it 'creates a new odcreate task' do
+        redis_connection_pool.with do |redis|
+          redis.hset("vmpooler__vm__#{vm}", 'clone',(Time.now - 900).to_s)
+          redis.hset("vmpooler__vm__#{vm}", 'pool_alias', pool)
+          redis.hset("vmpooler__vm__#{vm}", 'request_id', request_id)
+          subject.fail_pending_vm(vm, pool, timeout, redis, exists: true)
+          expect(redis.zrange('vmpooler__odcreate__task', 0, -1)).to eq(["#{pool}:#{pool}:1:#{request_id}"])
+        end
+      end
+    end
+  end
+
+  describe '#move_pending_vm_to_ready' do
+    let(:host) { { 'hostname' => vm }}
+
+    before do
+      expect(subject).not_to be_nil
+    end
+
+    before(:each) do
+      redis_connection_pool.with do |redis|
+        create_pending_vm(pool,vm,redis)
+      end
+    end
+
+    context 'when hostname matches VM name' do
+      it 'should move the VM from pending to ready pool' do
+        redis_connection_pool.with do |redis|
+          expect(redis.sismember("vmpooler__pending__#{pool}", vm)).to be(true)
+          expect(redis.sismember("vmpooler__ready__#{pool}", vm)).to be(false)
+          subject.move_pending_vm_to_ready(vm, pool, redis)
+          expect(redis.sismember("vmpooler__pending__#{pool}", vm)).to be(false)
+          expect(redis.sismember("vmpooler__ready__#{pool}", vm)).to be(true)
+        end
+      end
+
+      it 'should log a message' do
+        expect(logger).to receive(:log).with('s', "[>] [#{pool}] '#{vm}' moved from 'pending' to 'ready' queue")
+
+        redis_connection_pool.with do |redis|
+          subject.move_pending_vm_to_ready(vm, pool, redis)
+        end
+      end
+
+      it 'should receive time_to_ready_state metric' do
+        redis_connection_pool.with do |redis|
+          redis.hset("vmpooler__vm__#{vm}", 'clone',Time.now.to_s)
+          expect(metrics).to receive(:timing).with(/time_to_ready_state\./,/0/)
+
+          subject.move_pending_vm_to_ready(vm, pool, redis)
+        end
+      end
+
+
+      it 'should set the boot time in redis' do
+        redis_connection_pool.with do |redis|
+          redis.hset("vmpooler__vm__#{vm}", 'clone',Time.now.to_s)
+          expect(redis.hget('vmpooler__boot__' + Date.today.to_s, pool + ':' + vm)).to be_nil
+          subject.move_pending_vm_to_ready(vm, pool, redis)
+          expect(redis.hget('vmpooler__boot__' + Date.today.to_s, pool + ':' + vm)).to_not be_nil
+          # TODO Should we inspect the value to see if it's valid?
+        end
+      end
+
+      it 'should not determine boot timespan if clone start time not set' do
+        redis_connection_pool.with do |redis|
+          expect(redis.hget('vmpooler__boot__' + Date.today.to_s, pool + ':' + vm)).to be_nil
+          subject.move_pending_vm_to_ready(vm, pool, redis)
+          expect(redis.hget('vmpooler__boot__' + Date.today.to_s, pool + ':' + vm)).to match(/\d\.\d{2}/)
+        end
+      end
+
+      it 'should raise error if clone start time is not parsable' do
+        redis_connection_pool.with do |redis|
+          redis.hset("vmpooler__vm__#{vm}", 'clone','iamnotparsable_asdate')
+          expect{subject.move_pending_vm_to_ready(vm, pool, redis)}.to raise_error(/iamnotparsable_asdate/)
+        end
+      end
+
+      it 'should save the last boot time' do
+        redis_connection_pool.with do |redis|
+          expect(redis.hget('vmpooler__lastboot', pool)).to be(nil)
+          subject.move_pending_vm_to_ready(vm, pool, redis)
+          expect(redis.hget('vmpooler__lastboot', pool)).to_not be(nil)
+        end
+      end
+    end
+
+    context 'with request_id' do
+      context 'with a pending request' do
+        before(:each) do
+          allow(subject).to receive(:check_ondemand_request_ready)
+          config[:config]['ondemand_request_ttl'] = 20
+        end
+
+        it 'sets the vm as active' do
+          redis_connection_pool.with do |redis|
+            expect(Time).to receive(:now).and_return(current_time).at_least(:once)
+            redis.hset("vmpooler__vm__#{vm}", 'pool_alias', pool)
+            subject.move_pending_vm_to_ready(vm, pool, redis, request_id)
+            expect(redis.hget("vmpooler__active__#{pool}", vm)).to eq(current_time.to_s)
+            expect(redis.hget("vmpooler__vm__#{vm}", 'checkout')).to eq(current_time.to_s)
+            expect(redis.sismember("vmpooler__#{request_id}__#{pool}__#{pool}", vm)).to be true
+          end
+        end
+
+        it 'logs that the vm is ready for the request' do
+          redis_connection_pool.with do |redis|
+            redis.hset("vmpooler__vm__#{vm}", 'pool_alias', pool)
+            expect(logger).to receive(:log).with('s', "[>] [#{pool}] '#{vm}' is 'ready' for request '#{request_id}'")
+
+            subject.move_pending_vm_to_ready(vm, pool, redis, request_id)
+          end
+        end
+      end
+
+      context 'when the request has been marked as failed' do
+        before(:each) do
+          redis_connection_pool.with do |redis|
+            redis.hset("vmpooler__odrequest__#{request_id}", 'status', 'failed')
+          end
+        end
+
+        it 'moves the vm to completed' do
+          redis_connection_pool.with do |redis|
+            expect(subject).to receive(:move_vm_queue).with(pool, vm, 'pending', 'completed', redis, "moved to completed queue. '#{request_id}' could not be filled in time")
+            subject.move_pending_vm_to_ready(vm, pool, redis, request_id)
+          end
+        end
+
+        it 'returns nil' do
+          redis_connection_pool.with do |redis|
+            result = subject.move_pending_vm_to_ready(vm, pool, redis, request_id)
+            expect(result).to be nil
+          end
+        end
+      end
+
+      context 'when the request has been marked as deleted' do
+        before(:each) do
+          redis_connection_pool.with do |redis|
+            redis.hset("vmpooler__odrequest__#{request_id}", 'status', 'deleted')
+          end
+        end
+
+        it 'moves the vm to completed' do
+          redis_connection_pool.with do |redis|
+            expect(subject).to receive(:move_vm_queue).with(pool, vm, 'pending', 'completed', redis, "moved to completed queue. '#{request_id}' has been deleted")
+            subject.move_pending_vm_to_ready(vm, pool, redis, request_id)
+          end
+        end
+
+        it 'returns nil' do
+          redis_connection_pool.with do |redis|
+            result = subject.move_pending_vm_to_ready(vm, pool, redis, request_id)
+            expect(result).to be nil
+          end
+        end
+      end
+
+      context 'with auth on the request' do
+        let(:user) { 'vmpuser' }
+        let(:platform_alias) { pool }
+        let(:platforms_string) { "#{platform_alias}:#{pool}:1" }
+        let(:score) { current_time.to_i }
+        before(:each) do
+          config[:config]['ondemand_request_ttl'] = 20
+          allow(subject).to receive(:check_ondemand_request_ready)
+          redis_connection_pool.with do |redis|
+            create_ondemand_request_for_test(request_id, score, platforms_string, redis, user, token)
+          end
+        end
+
+        it 'should specify auth data on the vm' do
+          redis_connection_pool.with do |redis|
+            allow(redis).to receive(:hset)
+            expect(redis).to receive(:hset).with("vmpooler__vm__#{vm}", 'token:token', token)
+            expect(redis).to receive(:hset).with("vmpooler__vm__#{vm}", 'token:user', user)
+
+            subject.move_pending_vm_to_ready(vm, pool, redis, request_id)
+          end
+        end
+      end
+    end
+  end
+
+  describe '#check_ready_vm' do
+    let(:ttl) { 5 }
+    let(:poolconfig) { config[:pools][0] }
+
+    before do
+      expect(subject).not_to be_nil
+    end
+
+    it 'calls _check_ready_vm' do
+      expect(Thread).to receive(:new).and_yield
+      expect(subject).to receive(:_check_ready_vm).with(vm, poolconfig, ttl, provider)
+
+      subject.check_ready_vm(vm, poolconfig, ttl, provider)
+    end
+  end
+
+  describe '#_check_ready_vm' do
+    let(:ttl) { 5 }
+    let(:host) { {} }
+    let(:config) { YAML.load(<<-EOT
+---
+:config: {}
+:providers:
+  :mock:
+:pools:
+  - name: '#{pool}'
+    size: 1
+:pool_index:
+  '#{pool}': 0
+EOT
+      )
+    }
+
+    before(:each) do
+      redis_connection_pool.with do |redis|
+        create_ready_vm(pool,vm,redis)
+      end
+      config[:config]['vm_checktime'] = 15
+
+      # Create a VM which is powered on
+      host['hostname'] = vm
+      host['powerstate'] = 'PoweredOn'
+      allow(provider).to receive(:get_vm).with(pool,vm).and_return(host)
+    end
+
+    context 'a VM that does not need to be checked' do
+      it 'should do nothing' do
+        redis_connection_pool.with do |redis|
+          check_stamp = (Time.now - 60).to_s
+          redis.hset("vmpooler__vm__#{vm}", 'check', check_stamp)
+          expect(provider).to receive(:get_vm).exactly(0).times
+          subject._check_ready_vm(vm, pool, ttl, provider)
+          expect(redis.hget("vmpooler__vm__#{vm}", 'check')).to eq(check_stamp)
+        end
+      end
+    end
+
+    context 'a VM that has never been checked' do
+      it 'should set the current check timestamp' do
+        redis_connection_pool.with do |redis|
+          expect(redis.hget("vmpooler__vm__#{vm}", 'check')).to be_nil
+          subject._check_ready_vm(vm, pool, ttl, provider)
+          expect(redis.hget("vmpooler__vm__#{vm}", 'check')).to_not be_nil
+        end
+      end
+    end
+
+    context 'a VM that needs to be checked' do
+      let(:last_check_date) { Time.now - 901 }
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          redis.hset("vmpooler__vm__#{vm}", 'check',last_check_date)
+        end
+      end
+
+      it 'should set the current check timestamp' do
+        redis_connection_pool.with do |redis|
+          expect(redis.hget("vmpooler__vm__#{vm}", 'check')).to eq(last_check_date.to_s)
+          subject._check_ready_vm(vm, pool, ttl, provider)
+          expect(redis.hget("vmpooler__vm__#{vm}", 'check')).to_not eq(last_check_date.to_s)
+        end
+      end
+
+      context 'and is ready' do
+        it 'should only set the next check interval' do
+          subject._check_ready_vm(vm, pool, ttl, provider)
+        end
+      end
+
+      context 'has correct name and is not ready' do
+        before(:each) do
+          redis_connection_pool.with do |redis|
+            redis.hset("vmpooler__vm__#{vm}", 'ready', Time.now - 200)
+            redis.sadd("vmpooler__ready__#{pool}", vm)
+          end
+        end
+
+        it 'should move the VM to the completed queue' do
+          redis_connection_pool.with do |redis|
+            expect(redis).to receive(:smove).with("vmpooler__ready__#{pool}", "vmpooler__completed__#{pool}", vm)
+
+            subject._check_ready_vm(vm, pool, ttl, provider)
+          end
+        end
+
+        it 'should move the VM to the completed queue in Redis' do
+          redis_connection_pool.with do |redis|
+            subject._check_ready_vm(vm, pool, ttl, provider)
+            expect(redis.sismember("vmpooler__completed__#{pool}", vm)).to be(true)
+          end
+        end
+
+        it 'should log messages about being unreachable' do
+          expect(logger).to receive(:log).with('d', "[!] [#{pool}] '#{vm}' is unreachable, removed from 'ready' queue")
+
+          subject._check_ready_vm(vm, pool, ttl, provider)
+        end
+      end
+
+      context 'with hostname mismatch checking enabled' do
+
+        context 'when less than 60 seconds since a VM moved to ready' do
+          before(:each) do
+            redis_connection_pool.with do |redis|
+              redis.hset("vmpooler__vm__#{vm}", 'ready', Time.now)
+            end
+          end
+
+          it 'should return nil' do
+            expect(subject._check_ready_vm(vm, pool, ttl, provider)).to be_nil
+          end
+        end
+
+        context 'with a hostname mismatch' do
+          let(:different_hostname) { 'different_name' }
+          let(:longer_ttl) { 20 }
+          before(:each) do
+            host['hostname'] = different_hostname
+            redis_connection_pool.with do |redis|
+              expect(subject).to receive(:mismatched_hostname?).with(vm, pool, provider, redis).and_return(true)
+              redis.hset("vmpooler__vm__#{vm}", 'ready', Time.now - 300)
+            end
+          end
+
+          it 'should not run vm_still_ready?' do
+            expect(subject).to_not receive(:vm_still_ready?)
+
+            subject._check_ready_vm(vm, pool, longer_ttl, provider)
+          end
+        end
+      end
+
+      context 'with hostname mismatch checking disabled on the pool' do
+        before(:each) do
+          config[:pools][0]['check_hostname_for_mismatch'] = false
+        end
+
+        it 'should not run get_vm' do
+          expect(provider).to_not receive(:get_vm)
+
+          subject._check_ready_vm(vm, pool, ttl, provider)
+        end
+      end
+
+      context 'with hostname mismatch checking disabled in config' do
+        before(:each) do
+          config[:config]['check_ready_vm_hostname_for_mismatch'] = false
+        end
+
+        it 'should not run get_vm' do
+          expect(provider).to_not receive(:get_vm)
+
+          subject._check_ready_vm(vm, pool, ttl, provider)
+        end
+      end
+    end
+
+    context 'with a locked vm mutex' do
+      let(:mutex) { Mutex.new }
+      before(:each) do
+        mutex.lock
+      end
+
+      it 'should return' do
+        expect(subject).to receive(:vm_mutex).and_return(mutex)
+
+        expect(subject._check_ready_vm(vm, pool, ttl, provider)).to be_nil
+      end
+    end
+  end
+
+  describe '#check_running_vm' do
+    let(:provider) { double('provider') }
+    let (:ttl) { 5 }
+
+    before do
+      expect(subject).not_to be_nil
+    end
+
+    it 'calls _check_running_vm' do
+      expect(Thread).to receive(:new).and_yield
+      expect(subject).to receive(:_check_running_vm).with(vm, pool, ttl, provider)
+
+      subject.check_running_vm(vm, pool, ttl, provider)
+    end
+  end
+
+  describe '#_check_running_vm' do
+    let(:host) { {} }
+
+    before do
+      expect(subject).not_to be_nil
+    end
+
+    before(:each) do
+      redis_connection_pool.with do |redis|
+        create_running_vm(pool,vm, redis)
+      end
+
+      # Create a VM which is powered on
+      host['hostname'] = vm
+      host['powerstate'] = 'PoweredOn'
+      allow(provider).to receive(:get_vm).with(pool,vm).and_return(host)
+    end
+
+    it 'moves a missing VM to the completed queue' do
+      redis_connection_pool.with do |redis|
+        expect(provider).to receive(:vm_ready?).and_return(false)
+        expect(provider).to receive(:get_vm).with(pool,vm).and_return(nil)
+        expect(redis.sismember("vmpooler__running__#{pool}", vm)).to be(true)
+        subject._check_running_vm(vm, pool, timeout, provider)
+        expect(redis.sismember("vmpooler__running__#{pool}", vm)).to be(false)
+      end
+    end
+
+    context 'valid host' do
+      it 'should kill a VM if it has no checkout time' do
+        redis_connection_pool.with do |redis|
+          expect(provider).to receive(:vm_ready?).and_return(true)
+          expect(redis.sismember("vmpooler__running__#{pool}", vm)).to be(true)
+          subject._check_running_vm(vm, pool, 0, provider)
+          expect(redis.sismember("vmpooler__running__#{pool}", vm)).to be(false)
+        end
+      end
+
+      it 'should log a message when the machine is removed due to no active data' do
+        redis_connection_pool.with do |redis|
+          expect(provider).to receive(:vm_ready?).and_return(true)
+          expect(logger).to receive(:log).with('d',"[!] [#{pool}] '#{vm}' is listed as running, but has no checkouttime data. Removing from running")
+          subject._check_running_vm(vm, pool, 0, provider)
+        end
+      end
+
+      it 'should not move VM if TTL is zero' do
+        redis_connection_pool.with do |redis|
+          expect(provider).to receive(:vm_ready?).and_return(true)
+          redis.hset("vmpooler__active__#{pool}", vm,(Time.now - timeout*60*60).to_s)
+          expect(redis.sismember("vmpooler__running__#{pool}", vm)).to be(true)
+          subject._check_running_vm(vm, pool, 0, provider)
+          expect(redis.sismember("vmpooler__running__#{pool}", vm)).to be(true)
+        end
+      end
+
+      it 'should move VM when past TTL' do
+        redis_connection_pool.with do |redis|
+          redis.hset("vmpooler__active__#{pool}", vm,(Time.now - timeout*60*60).to_s)
+          expect(redis.sismember("vmpooler__running__#{pool}", vm)).to be(true)
+          expect(redis.sismember("vmpooler__completed__#{pool}", vm)).to be(false)
+          subject._check_running_vm(vm, pool, timeout, provider)
+          expect(redis.sismember("vmpooler__running__#{pool}", vm)).to be(false)
+          expect(redis.sismember("vmpooler__completed__#{pool}", vm)).to be(true)
+        end
+      end
+    end
+
+    context 'with a locked vm mutex' do
+      let(:mutex) { Mutex.new }
+      before(:each) do
+        mutex.lock
+      end
+
+      it 'should return' do
+        expect(subject).to receive(:vm_mutex).and_return(mutex)
+
+        expect(subject._check_running_vm(vm, pool, timeout, provider)).to be_nil
+      end
+    end
+  end
+
+  describe '#move_vm_queue' do
+    let(:queue_from) { 'pending' }
+    let(:queue_to) { 'completed' }
+    let(:message) { 'message' }
+
+    before do
+      expect(subject).not_to be_nil
+    end
+
+    before(:each) do
+      redis_connection_pool.with do |redis|
+        create_pending_vm(pool, vm, redis, token)
+      end
+    end
+
+    it 'VM should be in the "from queue" before the move' do
+      redis_connection_pool.with do |redis|
+        expect(redis.sismember("vmpooler__#{queue_from}__#{pool}",vm))
+      end
+    end
+
+    it 'VM should not be in the "from queue" after the move' do
+      redis_connection_pool.with do |redis|
+        subject.move_vm_queue(pool, vm, queue_from, queue_to, redis, message)
+        expect(!redis.sismember("vmpooler__#{queue_from}__#{pool}",vm))
+      end
+    end
+
+    it 'VM should not be in the "to queue" before the move' do
+      redis_connection_pool.with do |redis|
+        expect(!redis.sismember("vmpooler__#{queue_to}__#{pool}",vm))
+      end
+    end
+
+    it 'VM should be in the "to queue" after the move' do
+      redis_connection_pool.with do |redis|
+        subject.move_vm_queue(pool, vm, queue_from, queue_to, redis, message)
+        expect(redis.sismember("vmpooler__#{queue_to}__#{pool}",vm))
+      end
+    end
+
+    it 'should log a message' do
+      allow(logger).to receive(:log).with('d', "[!] [#{pool}] '#{vm}' #{message}")
+
+      redis_connection_pool.with do |redis|
+        subject.move_vm_queue(pool, vm, queue_from, queue_to, redis, message)
+      end
+    end
+  end
+
+  describe '#clone_vm' do
+    let (:pool_object) { { 'name' => pool } }
+
+    before do
+      expect(subject).not_to be_nil
+      expect(Thread).to receive(:new).and_yield
+    end
+
+    it 'calls _clone_vm' do
+      expect(subject).to receive(:_clone_vm).with(pool_object,provider,nil,nil)
+
+      subject.clone_vm(pool_object,provider)
+    end
+
+    it 'logs a message if an error is raised' do
+      allow(logger).to receive(:log)
+      expect(logger).to receive(:log).with('s',"[!] [#{pool}] failed while cloning VM with an error: MockError")
+      expect(subject).to receive(:_clone_vm).with(pool,provider,nil,nil).and_raise('MockError')
+
+      expect{subject.clone_vm(pool,provider)}.to raise_error(/MockError/)
+    end
+  end
+
+  describe '#_clone_vm' do
+    let (:pool_object) { { 'name' => pool } }
+    let (:redis_ttl) { 1 }
+
+    before do
+      expect(subject).not_to be_nil
+    end
+
+    let(:config) {
+      YAML.load(<<-EOT
+---
+:config:
+  prefix: "prefix"
+:redis:
+  ttl: #{redis_ttl}
+EOT
+      )
+    }
+
+    context 'with no errors during cloning' do
+      before(:each) do
+        allow(metrics).to receive(:timing)
+        expect(metrics).to receive(:timing).with(/clone\./,/0/)
+        expect(provider).to receive(:create_vm).with(pool, String)
+        allow(logger).to receive(:log)
+        redis_connection_pool.with do |redis|
+          expect(subject).to receive(:find_unique_hostname).with(pool).and_return(vm)
+        end
+      end
+
+      it 'should create a cloning VM' do
+        redis_connection_pool.with do |redis|
+          expect(redis.scard("vmpooler__pending__#{pool}")).to eq(0)
+
+          subject._clone_vm(pool,provider)
+
+          expect(redis.scard("vmpooler__pending__#{pool}")).to eq(1)
+          expect(redis.hget("vmpooler__vm__#{vm}", 'clone')).to_not be_nil
+          expect(redis.hget("vmpooler__vm__#{vm}", 'template')).to eq(pool)
+          expect(redis.hget("vmpooler__clone__#{Date.today.to_s}", "#{pool}:#{vm}")).to_not be_nil
+          expect(redis.hget("vmpooler__vm__#{vm}", 'clone_time')).to_not be_nil
+        end
+      end
+
+      it 'should decrement the clone tasks counter' do
+        redis_connection_pool.with do |redis|
+          redis.incr('vmpooler__tasks__clone')
+          redis.incr('vmpooler__tasks__clone')
+          expect(redis.get('vmpooler__tasks__clone')).to eq('2')
+          subject._clone_vm(pool,provider)
+          expect(redis.get('vmpooler__tasks__clone')).to eq('1')
+        end
+      end
+
+      it 'should log a message that is being cloned from a template' do
+        expect(logger).to receive(:log).with('d',/\[ \] \[#{pool}\] Starting to clone '(.+)'/)
+
+        subject._clone_vm(pool,provider)
+      end
+
+      it 'should log a message that it completed being cloned' do
+        expect(logger).to receive(:log).with('s',/\[\+\] \[#{pool}\] '(.+)' cloned in [0-9.]+ seconds/)
+
+        subject._clone_vm(pool,provider)
+      end
+    end
+
+    context 'with an error during cloning' do
+      before(:each) do
+        expect(provider).to receive(:create_vm).with(pool, String).and_raise('MockError')
+        allow(logger).to receive(:log)
+        redis_connection_pool.with do |redis|
+          expect(subject).to receive(:find_unique_hostname).with(pool).and_return(vm)
+        end
+      end
+
+      it 'should not create a cloning VM' do
+        redis_connection_pool.with do |redis|
+          expect(redis.scard("vmpooler__pending__#{pool}")).to eq(0)
+
+          expect{subject._clone_vm(pool,provider)}.to raise_error(/MockError/)
+
+          expect(redis.scard("vmpooler__pending__#{pool}")).to eq(0)
+          # Get the new VM Name from the pending pool queue as it should be the only entry
+          vm_name = redis.smembers("vmpooler__pending__#{pool}")[0]
+          expect(vm_name).to be_nil
+        end
+      end
+
+      it 'should decrement the clone tasks counter' do
+        redis_connection_pool.with do |redis|
+          redis.incr('vmpooler__tasks__clone')
+          redis.incr('vmpooler__tasks__clone')
+          expect(redis.get('vmpooler__tasks__clone')).to eq('2')
+          expect{subject._clone_vm(pool,provider)}.to raise_error(/MockError/)
+          expect(redis.get('vmpooler__tasks__clone')).to eq('1')
+        end
+      end
+
+      it 'should expire the vm metadata' do
+        redis_connection_pool.with do |redis|
+          expect(redis).to receive(:expire)
+          expect{subject._clone_vm(pool,provider)}.to raise_error(/MockError/)
+        end
+      end
+
+      it 'should raise the error' do
+        expect{subject._clone_vm(pool,provider)}.to raise_error(/MockError/)
+      end
+
+    end
+
+    context 'with request_id' do
+      before(:each) do
+        allow(metrics).to receive(:timing)
+        expect(metrics).to receive(:timing).with(/clone\./,/0/)
+        expect(provider).to receive(:create_vm).with(pool, String)
+        allow(logger).to receive(:log)
+        redis_connection_pool.with do |redis|
+          expect(subject).to receive(:find_unique_hostname).with(pool).and_return(vm)
+        end
+      end
+
+      it 'should set request_id and pool_alias on the vm data' do
+        redis_connection_pool.with do |redis|
+          subject._clone_vm(pool,provider,request_id,pool)
+          expect(redis.hget("vmpooler__vm__#{vm}", 'pool_alias')).to eq(pool)
+          expect(redis.hget("vmpooler__vm__#{vm}", 'request_id')).to eq(request_id)
+        end
+      end
+
+      it 'should reduce the clone count' do
+        redis_connection_pool.with do |redis|
+          expect(redis).to receive(:decr).with('vmpooler__tasks__ondemandclone')
+          subject._clone_vm(pool,provider,request_id,pool)
+        end
+      end
+    end
+
+    context 'with #check_dns_available' do
+      before(:each) do
+        allow(logger).to receive(:log)
+      end
+      it 'should error out if DNS already exists' do
+        vm_name = "foo"
+        resolv = class_double("Resolv").as_stubbed_const(:transfer_nested_constants => true)
+        expect(subject).to receive(:generate_and_check_hostname).exactly(3).times.and_return([vm_name, true]) #skip this, make it available all times
+        expect(resolv).to receive(:getaddress).exactly(3).times.and_return("1.2.3.4")
+        expect(metrics).to receive(:increment).with("errors.staledns.#{pool}").exactly(3).times
+        expect{subject._clone_vm(pool,provider)}.to raise_error(/Unable to generate a unique hostname after/)
+      end
+      it 'should be successful if DNS does not exist' do
+        vm_name = "foo"
+        resolv = class_double("Resolv").as_stubbed_const(:transfer_nested_constants => true)
+        expect(subject).to receive(:generate_and_check_hostname).and_return([vm_name, true])
+        expect(resolv).to receive(:getaddress).exactly(1).times.and_raise(Resolv::ResolvError)
+        expect(provider).to receive(:create_vm).with(pool, String)
+        subject._clone_vm(pool,provider)
+      end
+    end
+  end
+
+  describe '#destroy_vm' do
+    before do
+      expect(subject).not_to be_nil
+      expect(Thread).to receive(:new).and_yield
+    end
+
+    it 'calls _destroy_vm' do
+      expect(subject).to receive(:_destroy_vm).with(vm,pool,provider)
+
+      subject.destroy_vm(vm,pool,provider)
+    end
+
+    it 'logs a message if an error is raised' do
+      allow(logger).to receive(:log)
+      expect(logger).to receive(:log).with('d',"[!] [#{pool}] '#{vm}' failed while destroying the VM with an error: MockError")
+      expect(subject).to receive(:_destroy_vm).with(vm,pool,provider).and_raise('MockError')
+
+      expect{subject.destroy_vm(vm,pool,provider)}.to raise_error(/MockError/)
+    end
+  end
+
+  describe "#_destroy_vm" do
+    before(:each) do
+      expect(subject).not_to be_nil
+
+      redis_connection_pool.with do |redis|
+        create_completed_vm(vm,pool,redis,true)
+      end
+
+      allow(provider).to receive(:destroy_vm).with(pool,vm).and_return(true)
+
+      # Set redis configuration
+      config[:redis] = {}
+      config[:redis]['data_ttl'] = 168
+    end
+
+    context 'when redis data_ttl is not specified in the configuration' do
+      before(:each) do
+        config[:redis]['data_ttl'] = nil
+      end
+
+      it 'should call redis expire with 0' do
+        redis_connection_pool.with do |redis|
+          expect(redis).to receive(:expire).with("vmpooler__vm__#{vm}", 0)
+          subject._destroy_vm(vm,pool,provider)
+        end
+      end
+    end
+
+    context 'when there is no redis section in the configuration' do
+      before(:each) do
+        config[:redis] = nil
+      end
+
+      it 'should raise an error' do
+        expect{ subject._destroy_vm(vm,pool,provider) }.to raise_error(NoMethodError)
+      end
+    end
+
+    context 'when a VM does not exist' do
+      before(:each) do
+        # As per base_spec, destroy_vm will return true if the VM does not exist
+        expect(provider).to receive(:destroy_vm).with(pool,vm).and_return(true)
+      end
+
+      it 'should not raise an error' do
+        subject._destroy_vm(vm,pool,provider)
+      end
+    end
+
+    context 'when the VM is destroyed without error' do
+      it 'should log a message the VM was destroyed' do
+        expect(logger).to receive(:log).with('s', /\[-\] \[#{pool}\] '#{vm}' destroyed in [0-9.]+ seconds/)
+        allow(logger).to receive(:log)
+
+        subject._destroy_vm(vm,pool,provider)
+      end
+
+      it 'should emit a timing metric' do
+        allow(subject).to receive(:get_vm_usage_labels)
+        allow(metrics).to receive(:timing)
+        expect(metrics).to receive(:timing).with("destroy.#{pool}", String)
+
+        subject._destroy_vm(vm,pool,provider)
+      end
+
+      it 'should dereference the mutex' do
+        expect(subject).to receive(:dereference_mutex)
+
+        subject._destroy_vm(vm,pool,provider)
+      end
+    end
+
+    context 'when the VM destruction raises an eror' do
+      before(:each) do
+        # As per base_spec, destroy_vm will return true if the VM does not exist
+        expect(provider).to receive(:destroy_vm).with(pool,vm).and_raise('MockError')
+      end
+
+      it 'should not log a message the VM was destroyed' do
+        expect(logger).to receive(:log).with('s', /\[-\] \[#{pool}\] '#{vm}' destroyed in [0-9.]+ seconds/).exactly(0).times
+        allow(logger).to receive(:log)
+
+        expect{ subject._destroy_vm(vm,pool,provider) }.to raise_error(/MockError/)
+      end
+
+      it 'should not emit a timing metric' do
+        expect(metrics).to receive(:timing).with("destroy.#{pool}", String).exactly(0).times
+
+        expect{ subject._destroy_vm(vm,pool,provider) }.to raise_error(/MockError/)
+      end
+    end
+
+    context 'when the VM mutex is locked' do
+      let(:mutex) { Mutex.new }
+      before(:each) do
+        mutex.lock
+      end
+
+      it 'should return' do
+        expect(subject).to receive(:vm_mutex).with(vm).and_return(mutex)
+
+        expect(subject._destroy_vm(vm,pool,provider)).to eq(nil)
+      end
+    end
+  end
+
+  describe '#purge_unused_vms_and_folders' do
+    let(:config) { YAML.load(<<-EOT
+---
+:config: {}
+:providers:
+  :mock: {}
+:pools:
+  - name: '#{pool}'
+    size: 1
+EOT
+      )
+    }
+
+    it 'should return when purging is not enabled' do
+      expect(subject.purge_unused_vms_and_folders).to be_nil
+    end
+
+    context 'with purging enabled globally' do
+      before(:each) do
+        config[:config]['purge_unconfigured_folders'] = true
+        expect(Thread).to receive(:new).and_yield
+      end
+
+      it 'should run a purge for each provider' do
+        expect(subject).to receive(:purge_vms_and_folders)
+
+        subject.purge_unused_vms_and_folders
+      end
+
+      it 'should log when purging fails' do
+        expect(subject).to receive(:purge_vms_and_folders).and_raise(RuntimeError,'MockError')
+        expect(logger).to receive(:log).with('s', '[!] failed while purging provider mock VMs and folders with an error: MockError')
+
+        subject.purge_unused_vms_and_folders
+      end
+    end
+
+    context 'with purging enabled on the provider' do
+      before(:each) do
+        config[:providers][:mock]['purge_unconfigured_folders'] = true
+        expect(Thread).to receive(:new).and_yield
+      end
+
+      it 'should run a purge for the provider' do
+        expect(subject).to receive(:purge_vms_and_folders)
+
+        subject.purge_unused_vms_and_folders
+      end
+    end
+  end
+
+  describe '#pool_folders' do
+    let(:folder_name) { 'myinstance' }
+    let(:folder_base) { 'vmpooler' }
+    let(:folder) { [folder_base,folder_name].join('/') }
+    let(:datacenter) { 'dc1' }
+    let(:provider_name) { 'mock_provider' }
+    let(:expected_response) {
+      {
+        folder_name => "#{datacenter}/vm/#{folder_base}"
+      }
+    }
+    let(:config) { YAML.load(<<-EOT
+---
+:providers:
+  :mock:
+:pools:
+  - name: '#{pool}'
+    folder: '#{folder}'
+    size: 1
+    datacenter: '#{datacenter}'
+    provider: '#{provider_name}'
+  - name: '#{pool}2'
+    folder: '#{folder}'
+    size: 1
+    datacenter: '#{datacenter}'
+    provider: '#{provider_name}2'
+EOT
+      )
+    }
+
+    context 'when evaluating pool folders' do
+      before do
+        expect(subject).not_to be_nil
+        # Inject mock provider into global variable - Note this is a code smell
+        $providers = { provider_name => provider }
+      end
+
+      it 'should return a list of pool folders' do
+        expect(provider).to receive(:get_target_datacenter_from_config).with(pool).and_return(datacenter)
+
+        expect(subject.pool_folders(provider_name)).to eq(expected_response)
+      end
+
+      it 'should raise an error when the provider fails to get the datacenter' do
+        expect(provider).to receive(:get_target_datacenter_from_config).with(pool).and_raise('mockerror')
+
+        expect{ subject.pool_folders(provider_name) }.to raise_error(RuntimeError, 'mockerror')
+      end
+    end
+  end
+
+  describe '#purge_vms_and_folders' do
+    let(:folder_name) { 'myinstance' }
+    let(:folder_base) { 'vmpooler' }
+    let(:datacenter) { 'dc1' }
+    let(:full_folder_path) { "#{datacenter}/vm/folder_base" }
+    let(:configured_folders) { { folder_name => full_folder_path } }
+    let(:base_folders) { [ full_folder_path ] }
+    let(:folder) { [folder_base,folder_name].join('/') }
+    let(:provider_name) { 'mock_provider' }
+    let(:whitelist) { nil }
+    let(:config) { YAML.load(<<-EOT
+---
+:config: {}
+:providers:
+  :mock_provider: {}
+:pools:
+  - name: '#{pool}'
+    folder: '#{folder}'
+    size: 1
+    datacenter: '#{datacenter}'
+    provider: '#{provider_name}'
+EOT
+      )
+    }
+
+    context 'when purging folders' do
+      before do
+        expect(subject).not_to be_nil
+        # Inject mock provider into global variable - Note this is a code smell
+        $providers = { provider_name => provider }
+      end
+
+      it 'should run purge_unconfigured_folders' do
+        expect(subject).to receive(:pool_folders).and_return(configured_folders)
+        expect(provider).to receive(:purge_unconfigured_folders).with(base_folders, configured_folders, whitelist)
+        expect(provider).to receive(:provider_config).and_return({})
+
+        subject.purge_vms_and_folders(provider_name)
+      end
+
+      it 'should raise any errors' do
+        expect(subject).to receive(:pool_folders).and_return(configured_folders)
+        expect(provider).to receive(:purge_unconfigured_folders).with(base_folders, configured_folders, whitelist).and_raise('mockerror')
+        expect(provider).to receive(:provider_config).and_return({})
+
+        expect{ subject.purge_vms_and_folders(provider_name) }.to raise_error(RuntimeError, 'mockerror')
+      end
+    end
+  end
+
+  describe '#create_vm_disk' do
+    let(:provider) { double('provider') }
+    let(:disk_size) { 15 }
+
+    before do
+      expect(subject).not_to be_nil
+    end
+
+    it 'calls _create_vm_disk' do
+      expect(Thread).to receive(:new).and_yield
+      expect(subject).to receive(:_create_vm_disk).with(pool, vm, disk_size, provider)
+
+      subject.create_vm_disk(pool, vm, disk_size, provider)
+    end
+  end
+
+  describe "#_create_vm_disk" do
+    let(:disk_size) { '15' }
+
+    before(:each) do
+      expect(subject).not_to be_nil
+      allow(logger).to receive(:log)
+
+      redis_connection_pool.with do |redis|
+        create_running_vm(pool,vm,redis,token)
+      end
+    end
+
+    context 'Given a VM that does not exist' do
+      before(:each) do
+        # As per base_spec, create_disk will raise if the VM does not exist
+        expect(provider).to receive(:create_disk).with(pool,vm,disk_size.to_i).and_raise("VM #{vm} does not exist")
+      end
+
+      it 'should not update redis if the VM does not exist' do
+        redis_connection_pool.with do |redis|
+          expect(redis).to receive(:hset).exactly(0).times
+          expect{ subject._create_vm_disk(pool, vm, disk_size, provider) }.to raise_error(RuntimeError)
+        end
+      end
+    end
+
+    context 'Given an invalid disk size' do
+      [{ :description => 'is nil',                            :value => nil },
+       { :description => 'is an empty string',                :value => '' },
+       { :description => 'is less than 1',                    :value => '0' },
+       { :description => 'cannot be converted to an integer', :value => 'abc123' },
+      ].each do |testcase|
+        it "should not attempt the create the disk if the disk size #{testcase[:description]}" do
+          expect(provider).to receive(:create_disk).exactly(0).times
+          expect{ subject._create_vm_disk(pool, vm, testcase[:value], provider) }.to raise_error(/Invalid disk size/)
+        end
+      end
+
+      it 'should raise an error if the disk size is a Fixnum' do
+        redis_connection_pool.with do |redis|
+          expect(redis).to receive(:hset).exactly(0).times
+          expect{ subject._create_vm_disk(pool, vm, 10, provider) }.to raise_error(NoMethodError,/empty?/)
+        end
+      end
+    end
+
+    context 'Given a successful disk creation' do
+      before(:each) do
+        expect(provider).to receive(:create_disk).with(pool,vm,disk_size.to_i).and_return(true)
+      end
+
+      it 'should log a message' do
+        expect(logger).to receive(:log).with('s', "[ ] [disk_manager] '#{vm}' is attaching a #{disk_size}gb disk")
+        expect(logger).to receive(:log).with('s', /\[\+\] \[disk_manager\] '#{vm}' attached #{disk_size}gb disk in 0.[\d]+ seconds/)
+
+        subject._create_vm_disk(pool, vm, disk_size, provider)
+      end
+
+      it 'should update redis information when attaching the first disk' do
+        redis_connection_pool.with do |redis|
+          subject._create_vm_disk(pool, vm, disk_size, provider)
+          expect(redis.hget("vmpooler__vm__#{vm}", 'disk')).to eq("+#{disk_size}gb")
+        end
+      end
+
+      it 'should update redis information when attaching the additional disks' do
+        redis_connection_pool.with do |redis|
+          initial_disks = '+10gb:+20gb'
+          redis.hset("vmpooler__vm__#{vm}", 'disk', initial_disks)
+
+          subject._create_vm_disk(pool, vm, disk_size, provider)
+          expect(redis.hget("vmpooler__vm__#{vm}", 'disk')).to eq("#{initial_disks}:+#{disk_size}gb")
+        end
+      end
+    end
+
+    context 'Given a failed disk creation' do
+      before(:each) do
+        expect(provider).to receive(:create_disk).with(pool,vm,disk_size.to_i).and_return(false)
+      end
+
+      it 'should not update redis information' do
+        redis_connection_pool.with do |redis|
+          expect(redis).to receive(:hset).exactly(0).times
+
+          subject._create_vm_disk(pool, vm, disk_size, provider)
+          expect(redis.hget("vmpooler__vm__#{vm}", 'disk')).to be_nil
+        end
+      end
+
+      it 'should log a message' do
+        expect(logger).to receive(:log).with('s', "[+] [disk_manager] '#{vm}' failed to attach disk")
+
+        subject._create_vm_disk(pool, vm, disk_size, provider)
+      end
+    end
+  end
+
+  describe '#create_vm_snapshot' do
+    let(:snapshot_name) { 'snapshot' }
+
+    before do
+      expect(subject).not_to be_nil
+    end
+
+    it 'calls _create_vm_snapshot' do
+      expect(Thread).to receive(:new).and_yield
+      expect(subject).to receive(:_create_vm_snapshot).with(pool, vm, snapshot_name, provider)
+
+      subject.create_vm_snapshot(pool, vm, snapshot_name, provider)
+    end
+  end
+
+  describe '#_create_vm_snapshot' do
+    let(:snapshot_name) { 'snapshot1' }
+
+    before do
+      expect(subject).not_to be_nil
+    end
+
+    before(:each) do
+      redis_connection_pool.with do |redis|
+        create_running_vm(pool,vm,redis,token)
+      end
+    end
+
+    context 'Given a Pool that does not exist' do
+      let(:missing_pool) { 'missing_pool' }
+
+      before(:each) do
+        expect(provider).to receive(:create_snapshot).with(missing_pool, vm, snapshot_name).and_raise("Pool #{missing_pool} not found")
+      end
+
+      it 'should not update redis' do
+        redis_connection_pool.with do |redis|
+          expect(redis.hget("vmpooler__vm__#{vm}", "snapshot:#{snapshot_name}")).to be_nil
+          expect{ subject._create_vm_snapshot(missing_pool, vm, snapshot_name, provider) }.to raise_error("Pool #{missing_pool} not found")
+          expect(redis.hget("vmpooler__vm__#{vm}", "snapshot:#{snapshot_name}")).to be_nil
+        end
+      end
+    end
+
+    context 'Given a VM that does not exist' do
+      let(:missing_vm) { 'missing_vm' }
+      before(:each) do
+        expect(provider).to receive(:create_snapshot).with(pool, missing_vm, snapshot_name).and_raise("VM #{missing_vm} not found")
+      end
+
+      it 'should not update redis' do
+        redis_connection_pool.with do |redis|
+          expect(redis.hget("vmpooler__vm__#{vm}", "snapshot:#{snapshot_name}")).to be_nil
+          expect{ subject._create_vm_snapshot(pool, missing_vm, snapshot_name, provider) }.to raise_error("VM #{missing_vm} not found")
+          expect(redis.hget("vmpooler__vm__#{vm}", "snapshot:#{snapshot_name}")).to be_nil
+        end
+      end
+    end
+
+    context 'Given a snapshot creation that succeeds' do
+      before(:each) do
+        expect(provider).to receive(:create_snapshot).with(pool, vm, snapshot_name).and_return(true)
+      end
+
+      it 'should log messages' do
+        expect(logger).to receive(:log).with('s', "[ ] [snapshot_manager] 'Attempting to snapshot #{vm} in pool #{pool}")
+        expect(logger).to receive(:log).with('s', /\[\+\] \[snapshot_manager\] '#{vm}' snapshot created in 0.[\d]+ seconds/)
+
+        subject._create_vm_snapshot(pool, vm, snapshot_name, provider)
+      end
+
+      it 'should add snapshot redis information' do
+        redis_connection_pool.with do |redis|
+          expect(redis.hget("vmpooler__vm__#{vm}", "snapshot:#{snapshot_name}")).to be_nil
+          subject._create_vm_snapshot(pool, vm, snapshot_name, provider)
+          expect(redis.hget("vmpooler__vm__#{vm}", "snapshot:#{snapshot_name}")).to_not be_nil
+        end
+      end
+    end
+
+    context 'Given a snapshot creation that fails' do
+      before(:each) do
+        expect(provider).to receive(:create_snapshot).with(pool, vm, snapshot_name).and_return(false)
+      end
+
+      it 'should log messages' do
+        expect(logger).to receive(:log).with('s', "[ ] [snapshot_manager] 'Attempting to snapshot #{vm} in pool #{pool}")
+        expect(logger).to receive(:log).with('s', "[+] [snapshot_manager] Failed to snapshot '#{vm}'")
+
+        subject._create_vm_snapshot(pool, vm, snapshot_name, provider)
+      end
+
+      it 'should not update redis' do
+        redis_connection_pool.with do |redis|
+          expect(redis.hget("vmpooler__vm__#{vm}", "snapshot:#{snapshot_name}")).to be_nil
+          subject._create_vm_snapshot(pool, vm, snapshot_name, provider)
+          expect(redis.hget("vmpooler__vm__#{vm}", "snapshot:#{snapshot_name}")).to be_nil
+        end
+      end
+    end
+  end
+
+  describe '#revert_vm_snapshot' do
+    let(:snapshot_name) { 'snapshot' }
+
+    before do
+      expect(subject).not_to be_nil
+    end
+
+    it 'calls _revert_vm_snapshot' do
+      expect(Thread).to receive(:new).and_yield
+      expect(subject).to receive(:_revert_vm_snapshot).with(pool, vm, snapshot_name, provider)
+
+      subject.revert_vm_snapshot(pool, vm, snapshot_name, provider)
+    end
+  end
+
+  describe '#_revert_vm_snapshot' do
+    let(:snapshot_name) { 'snapshot1' }
+
+    before do
+      expect(subject).not_to be_nil
+    end
+
+    context 'Given a Pool that does not exist' do
+      let(:missing_pool) { 'missing_pool' }
+
+      before(:each) do
+        expect(provider).to receive(:revert_snapshot).with(missing_pool, vm, snapshot_name).and_raise("Pool #{missing_pool} not found")
+      end
+
+      it 'should not log a result message' do
+        expect(logger).to receive(:log).with('s', /\[\+\] \[snapshot_manager\] '#{vm}' reverted to snapshot '#{snapshot_name}' in 0.[\d]+ seconds/).exactly(0).times
+        expect(logger).to receive(:log).with('s', "[+] [snapshot_manager] Failed to revert #{vm}' in pool #{missing_pool} to snapshot '#{snapshot_name}'").exactly(0).times
+
+        expect{ subject._revert_vm_snapshot(missing_pool, vm, snapshot_name, provider) }.to raise_error("Pool #{missing_pool} not found")
+      end
+    end
+
+    context 'Given a VM that does not exist' do
+      let(:missing_vm) { 'missing_vm' }
+      before(:each) do
+        expect(provider).to receive(:revert_snapshot).with(pool, missing_vm, snapshot_name).and_raise("VM #{missing_vm} not found")
+      end
+
+      it 'should not log a result message' do
+        expect(logger).to receive(:log).with('s', /\[\+\] \[snapshot_manager\] '#{missing_vm}' reverted to snapshot '#{snapshot_name}' in 0.[\d]+ seconds/).exactly(0).times
+        expect(logger).to receive(:log).with('s', "[+] [snapshot_manager] Failed to revert #{missing_vm}' in pool #{pool} to snapshot '#{snapshot_name}'").exactly(0).times
+
+        expect{ subject._revert_vm_snapshot(pool, missing_vm, snapshot_name, provider) }.to raise_error("VM #{missing_vm} not found")
+      end
+    end
+
+    context 'Given a snapshot revert that succeeds' do
+      before(:each) do
+        expect(provider).to receive(:revert_snapshot).with(pool, vm, snapshot_name).and_return(true)
+      end
+
+      it 'should log success messages' do
+        expect(logger).to receive(:log).with('s', "[ ] [snapshot_manager] 'Attempting to revert #{vm}' in pool #{pool} to snapshot '#{snapshot_name}'")
+        expect(logger).to receive(:log).with('s', /\[\+\] \[snapshot_manager\] '#{vm}' reverted to snapshot '#{snapshot_name}' in 0.[\d]+ seconds/)
+
+        subject._revert_vm_snapshot(pool, vm, snapshot_name, provider)
+      end
+
+      it 'should return true' do
+        expect(subject._revert_vm_snapshot(pool, vm, snapshot_name, provider)).to be true
+      end
+    end
+
+    context 'Given a snapshot creation that fails' do
+      before(:each) do
+        expect(provider).to receive(:revert_snapshot).with(pool, vm, snapshot_name).and_return(false)
+      end
+
+      it 'should log failure messages' do
+        expect(logger).to receive(:log).with('s', "[ ] [snapshot_manager] 'Attempting to revert #{vm}' in pool #{pool} to snapshot '#{snapshot_name}'")
+        expect(logger).to receive(:log).with('s', "[+] [snapshot_manager] Failed to revert #{vm}' in pool #{pool} to snapshot '#{snapshot_name}'")
+
+        subject._revert_vm_snapshot(pool, vm, snapshot_name, provider)
+      end
+
+      it 'should return false' do
+        expect(subject._revert_vm_snapshot(pool, vm, snapshot_name, provider)).to be false
+      end
+    end
+  end
+
+  describe '#get_pool_name_for_vm' do
+    context 'Given a valid VM' do
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          create_running_vm(pool, vm, redis, token)
+        end
+      end
+
+      it 'should return the pool name' do
+        redis_connection_pool.with do |redis|
+          expect(subject.get_pool_name_for_vm(vm,redis)).to eq(pool)
+        end
+      end
+    end
+
+    context 'Given an invalid VM' do
+      it 'should return nil' do
+        redis_connection_pool.with do |redis|
+          expect(subject.get_pool_name_for_vm('does_not_exist',redis)).to be_nil
+        end
+      end
+    end
+  end
+
+  describe '#get_provider_for_pool' do
+    let(:provider_name) { 'mock_provider' }
+
+    before do
+      expect(subject).not_to be_nil
+      # Inject mock provider into global variable - Note this is a code smell
+      $providers = { provider_name => provider }
+    end
+
+    after(:each) do
+      # Reset the global variable - Note this is a code smell
+      $providers = nil
+    end
+
+    context 'Given a pool name which does not exist' do
+      let(:config) { YAML.load(<<-EOT
+---
+:config:
+:providers:
+  :mock:
+:pools:
+  - name: '#{pool}'
+    size: 1
+EOT
+      )}
+
+      it 'should return nil' do
+        expect(subject.get_provider_for_pool('pool_does_not_exist')).to be_nil
+      end
+    end
+
+    context 'Given a pool which does not have a provider' do
+      let(:config) { YAML.load(<<-EOT
+---
+:config:
+:providers:
+  :mock:
+:pools:
+  - name: '#{pool}'
+    size: 1
+EOT
+      )}
+
+      it 'should return nil' do
+        expect(subject.get_provider_for_pool(pool)).to be_nil
+      end
+    end
+
+    context 'Given a pool which uses an invalid provider' do
+      let(:config) { YAML.load(<<-EOT
+---
+:config:
+:providers:
+  :mock:
+:pools:
+  - name: '#{pool}'
+    size: 1
+    provider: 'does_not_exist'
+EOT
+      )}
+
+      it 'should return nil' do
+        expect(subject.get_provider_for_pool(pool)).to be_nil
+      end
+    end
+
+    context 'Given a pool which uses a valid provider' do
+      let(:config) { YAML.load(<<-EOT
+---
+:config:
+:providers:
+  :mock:
+:pools:
+  - name: '#{pool}'
+    size: 1
+    provider: #{provider_name}
+EOT
+      )}
+
+      it 'should return a provider object' do
+        result = subject.get_provider_for_pool(pool)
+        expect(result).to_not be_nil
+        expect(result.name).to eq(provider_name)
+      end
+    end
+  end
+
+  describe '#check_disk_queue' do
+    let(:threads) {[]}
+
+    before(:each) do
+      expect(Thread).to receive(:new).and_yield
+      allow(subject).to receive(:_check_disk_queue)
+    end
+
+    it 'should log the disk manager is starting' do
+      expect(logger).to receive(:log).with('d', "[*] [disk_manager] starting worker thread")
+
+      expect($threads.count).to be(0)
+      subject.check_disk_queue(1,0)
+      expect($threads.count).to be(1)
+    end
+
+    it 'should add the manager to the global thread list' do
+      # Note - Ruby core types are not necessarily thread safe
+      expect($threads.count).to be(0)
+      subject.check_disk_queue(1,0)
+      expect($threads.count).to be(1)
+    end
+
+    it 'should call _check_disk_queue' do
+      expect(subject).to receive(:_check_disk_queue).with(no_args)
+
+      subject.check_disk_queue(1,0)
+    end
+
+    context 'delays between loops' do
+      let(:maxloop) { 2 }
+      let(:loop_delay) { 1 }
+      # Note a maxloop of zero can not be tested as it never terminates
+
+      it 'defaults to 5 second loop delay' do
+        expect(subject).to receive(:sleep).with(5).exactly(maxloop).times
+        subject.check_disk_queue(maxloop)
+      end
+
+      it 'when a non-default loop delay is specified' do
+        expect(subject).to receive(:sleep).with(loop_delay).exactly(maxloop).times
+
+        subject.check_disk_queue(maxloop,loop_delay)
+      end
+    end
+
+    context 'loops specified number of times (5)' do
+      let(:maxloop) { 5 }
+      # Note a maxloop of zero can not be tested as it never terminates
+
+      after(:each) do
+        # Reset the global variable - Note this is a code smell
+        $threads = nil
+      end
+
+      it 'should call _check_disk_queue 5 times' do
+        expect(subject).to receive(:_check_disk_queue).with(no_args).exactly(maxloop).times
+
+        subject.check_disk_queue(maxloop,0)
+      end
+    end
+  end
+
+  describe '#_check_disk_queue' do
+    before do
+      expect(subject).not_to be_nil
+    end
+
+    context 'when no VMs in the queue' do
+      it 'should not call create_vm_disk' do
+        expect(subject).to receive(:create_vm_disk).exactly(0).times
+        subject._check_disk_queue
+      end
+    end
+
+    context 'when VM in the queue does not exist' do
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          disk_task_vm(vm,"snapshot_#{vm}",redis)
+        end
+      end
+
+      it 'should log an error' do
+        expect(logger).to receive(:log).with('s', /Unable to determine which pool #{vm} is a member of/)
+
+        subject._check_disk_queue
+      end
+
+      it 'should not call create_vm_disk' do
+        expect(subject).to receive(:create_vm_disk).exactly(0).times
+
+        subject._check_disk_queue
+      end
+    end
+
+    context 'when specified provider does not exist' do
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          disk_task_vm(vm,"snapshot_#{vm}",redis)
+          create_running_vm(pool, vm, redis, token)
+          expect(subject).to receive(:get_provider_for_pool).and_return(nil)
+        end
+      end
+
+      it 'should log an error' do
+        expect(logger).to receive(:log).with('s', /Missing Provider for/)
+
+        subject._check_disk_queue
+      end
+
+      it 'should not call create_vm_disk' do
+        expect(subject).to receive(:create_vm_disk).exactly(0).times
+
+        subject._check_disk_queue
+      end
+    end
+
+    context 'when multiple VMs in the queue' do
+      before(:each) do
+        ['vm1', 'vm2', 'vm3'].each do |vm_name|
+          redis_connection_pool.with do |redis|
+            disk_task_vm(vm_name,"snapshot_#{vm_name}",redis)
+            create_running_vm(pool, vm_name, redis, token)
+          end
+        end
+
+        allow(subject).to receive(:get_provider_for_pool).with(pool).and_return(provider)
+      end
+
+      it 'should call create_vm_disk once' do
+        expect(subject).to receive(:create_vm_disk).exactly(1).times
+        subject._check_disk_queue
+      end
+
+      it 'should create the disk for the first VM in the queue' do
+        expect(subject).to receive(:create_vm_disk).with(pool,'vm1','snapshot_vm1',provider)
+        subject._check_disk_queue
+      end
+
+      it 'should log an error if one occurs' do
+        expect(subject).to receive(:create_vm_disk).and_raise(RuntimeError,'MockError')
+        expect(logger).to receive(:log).with('s', "[!] [disk_manager] disk creation appears to have failed: MockError")
+        subject._check_disk_queue
+      end
+    end
+  end
+
+  describe '#check_snapshot_queue' do
+    let(:threads) {[]}
+
+    before(:each) do
+      expect(Thread).to receive(:new).and_yield
+      allow(subject).to receive(:_check_snapshot_queue).with(no_args)
+    end
+
+    it 'should log the snapshot manager is starting' do
+      expect(logger).to receive(:log).with('d', "[*] [snapshot_manager] starting worker thread")
+
+      expect($threads.count).to be(0)
+      subject.check_snapshot_queue(1,0)
+      expect($threads.count).to be(1)
+    end
+
+    it 'should add the manager to the global thread list' do
+      # Note - Ruby core types are not necessarily thread safe
+      expect($threads.count).to be(0)
+      subject.check_snapshot_queue(1,0)
+      expect($threads.count).to be(1)
+    end
+
+    it 'should call _check_snapshot_queue' do
+      expect(subject).to receive(:_check_snapshot_queue).with(no_args)
+
+      subject.check_snapshot_queue(1,0)
+    end
+
+    context 'delays between loops' do
+      let(:maxloop) { 2 }
+      let(:loop_delay) { 1 }
+      # Note a maxloop of zero can not be tested as it never terminates
+
+      it 'defaults to 5 second loop delay' do
+        expect(subject).to receive(:sleep).with(5).exactly(maxloop).times
+        subject.check_snapshot_queue(maxloop)
+      end
+
+      it 'when a non-default loop delay is specified' do
+        expect(subject).to receive(:sleep).with(loop_delay).exactly(maxloop).times
+
+        subject.check_snapshot_queue(maxloop,loop_delay)
+      end
+    end
+
+    context 'loops specified number of times (5)' do
+      let(:maxloop) { 5 }
+      # Note a maxloop of zero can not be tested as it never terminates
+
+      after(:each) do
+        # Reset the global variable - Note this is a code smell
+        $threads = nil
+      end
+
+      it 'should call _check_snapshot_queue 5 times' do
+        expect(subject).to receive(:_check_snapshot_queue).with(no_args).exactly(maxloop).times
+
+        subject.check_snapshot_queue(maxloop,0)
+      end
+    end
+  end
+
+  describe '#_check_snapshot_queue' do
+    before do
+      expect(subject).not_to be_nil
+    end
+
+    context 'vmpooler__tasks__snapshot queue' do
+      context 'when no VMs in the queue' do
+        it 'should not call create_vm_snapshot' do
+          expect(subject).to receive(:create_vm_snapshot).exactly(0).times
+          subject._check_snapshot_queue
+        end
+      end
+
+      context 'when VM in the queue does not exist' do
+        before(:each) do
+          redis_connection_pool.with do |redis|
+            snapshot_vm(vm,"snapshot_#{vm}",redis)
+          end
+        end
+
+        it 'should log an error' do
+          expect(logger).to receive(:log).with('s', /Unable to determine which pool #{vm} is a member of/)
+
+          subject._check_snapshot_queue
+        end
+
+        it 'should not call create_vm_snapshot' do
+          expect(subject).to receive(:create_vm_snapshot).exactly(0).times
+
+          subject._check_snapshot_queue
+        end
+      end
+
+      context 'when specified provider does not exist' do
+        before(:each) do
+          redis_connection_pool.with do |redis|
+            snapshot_vm(vm,"snapshot_#{vm}",redis)
+            create_running_vm(pool, vm, redis, token)
+            expect(subject).to receive(:get_provider_for_pool).and_return(nil)
+          end
+        end
+
+        it 'should log an error' do
+          expect(logger).to receive(:log).with('s', /Missing Provider for/)
+
+          subject._check_snapshot_queue
+        end
+
+        it 'should not call create_vm_snapshot' do
+          expect(subject).to receive(:create_vm_snapshot).exactly(0).times
+
+          subject._check_snapshot_queue
+        end
+      end
+
+      context 'when multiple VMs in the queue' do
+        before(:each) do
+          ['vm1', 'vm2', 'vm3'].each do |vm_name|
+            redis_connection_pool.with do |redis|
+              snapshot_vm(vm_name,"snapshot_#{vm_name}",redis)
+              create_running_vm(pool, vm_name, redis, token)
+            end
+          end
+
+          allow(subject).to receive(:get_provider_for_pool).with(pool).and_return(provider)
+        end
+
+        it 'should call create_vm_snapshot once' do
+          expect(subject).to receive(:create_vm_snapshot).exactly(1).times
+          subject._check_snapshot_queue
+        end
+
+        it 'should snapshot the first VM in the queue' do
+          expect(subject).to receive(:create_vm_snapshot).with(pool,'vm1','snapshot_vm1',provider)
+          subject._check_snapshot_queue
+        end
+
+        it 'should log an error if one occurs' do
+          expect(subject).to receive(:create_vm_snapshot).and_raise(RuntimeError,'MockError')
+          expect(logger).to receive(:log).with('s', "[!] [snapshot_manager] snapshot create appears to have failed: MockError")
+          subject._check_snapshot_queue
+        end
+      end
+    end
+
+    context 'vmpooler__tasks__snapshot-revert queue' do
+      context 'when no VMs in the queue' do
+        it 'should not call revert_vm_snapshot' do
+          expect(subject).to receive(:revert_vm_snapshot).exactly(0).times
+          subject._check_snapshot_queue
+        end
+      end
+
+      context 'when VM in the queue does not exist' do
+        before(:each) do
+          redis_connection_pool.with do |redis|
+            snapshot_revert_vm(vm,"snapshot_#{vm}",redis)
+          end
+        end
+
+        it 'should log an error' do
+          expect(logger).to receive(:log).with('s', /Unable to determine which pool #{vm} is a member of/)
+
+          subject._check_snapshot_queue
+        end
+
+        it 'should not call revert_vm_snapshot' do
+          expect(subject).to receive(:revert_vm_snapshot).exactly(0).times
+
+          subject._check_snapshot_queue
+        end
+      end
+
+      context 'when specified provider does not exist' do
+        before(:each) do
+          redis_connection_pool.with do |redis|
+            snapshot_revert_vm(vm,"snapshot_#{vm}",redis)
+            create_running_vm(pool, vm, redis, token)
+            expect(subject).to receive(:get_provider_for_pool).and_return(nil)
+          end
+        end
+
+        it 'should log an error' do
+          expect(logger).to receive(:log).with('s', /Missing Provider for/)
+
+          subject._check_snapshot_queue
+        end
+
+        it 'should not call revert_vm_snapshot' do
+          expect(subject).to receive(:revert_vm_snapshot).exactly(0).times
+
+          subject._check_snapshot_queue
+        end
+      end
+
+      context 'when multiple VMs in the queue' do
+        before(:each) do
+          ['vm1', 'vm2', 'vm3'].each do |vm_name|
+            redis_connection_pool.with do |redis|
+              snapshot_revert_vm(vm_name,"snapshot_#{vm_name}",redis)
+              create_running_vm(pool, vm_name, redis, token)
+            end
+          end
+
+          allow(subject).to receive(:get_provider_for_pool).with(pool).and_return(provider)
+        end
+
+        it 'should call revert_vm_snapshot once' do
+          expect(subject).to receive(:revert_vm_snapshot).exactly(1).times
+          subject._check_snapshot_queue
+        end
+
+        it 'should snapshot the first VM in the queue' do
+          expect(subject).to receive(:revert_vm_snapshot).with(pool,'vm1','snapshot_vm1',provider)
+          subject._check_snapshot_queue
+        end
+
+        it 'should log an error if one occurs' do
+          expect(subject).to receive(:revert_vm_snapshot).and_raise(RuntimeError,'MockError')
+          expect(logger).to receive(:log).with('s', "[!] [snapshot_manager] snapshot revert appears to have failed: MockError")
+          subject._check_snapshot_queue
+        end
+      end
+    end
+  end
+
+  describe '#migrate_vm' do
+    before(:each) do
+      expect(subject).not_to be_nil
+      expect(Thread).to receive(:new).and_yield
+    end
+
+    it 'calls migrate_vm' do
+      expect(provider).to receive(:migrate_vm).with(pool, vm)
+
+      subject.migrate_vm(vm, pool, provider)
+    end
+
+    context 'When an error is raised' do
+      before(:each) do
+        expect(provider).to receive(:migrate_vm).with(pool, vm).and_raise('MockError')
+      end
+
+      it 'logs a message' do
+        allow(logger).to receive(:log)
+        expect(logger).to receive(:log).with('s', "[x] [#{pool}] '#{vm}' migration failed with an error: MockError")
+
+        subject.migrate_vm(vm, pool, provider)
+      end
+    end
+
+    context 'with a locked vm mutex' do
+      let(:mutex) { Mutex.new }
+      before(:each) do
+        mutex.lock
+      end
+
+      it 'should return' do
+        expect(subject).to receive(:vm_mutex).and_return(mutex)
+
+        expect(subject.migrate_vm(vm, pool, provider)).to be_nil
+      end
+    end
+  end
+
+  describe '#vm_mutex' do
+    it 'should return a mutex' do
+      expect(subject.vm_mutex(vm)).to be_a(Mutex)
+    end
+
+    it 'should return the same mutex when called twice' do
+      first = subject.vm_mutex(vm)
+      second = subject.vm_mutex(vm)
+      expect(first).to be(second)
+    end
+  end
+
+  describe '#dereference_mutex' do
+    it 'should return nil when no mutex is dereferenced' do
+      expect(subject.dereference_mutex(vm)).to be_nil
+    end
+
+    it 'should return true when a mutex is dereferenced' do
+      subject.vm_mutex(vm)
+      expect(subject.dereference_mutex(vm)).to be true
+    end
+
+    it 'should dereference the mutex' do
+      mutex = subject.vm_mutex(vm)
+
+      subject.dereference_mutex(vm)
+
+      result = subject.vm_mutex(vm)
+      expect(result).to_not eq(mutex)
+    end
+  end
+
+  describe 'sync_pool_template' do
+    let(:old_template) { 'templates/old-template' }
+    let(:new_template) { 'templates/new-template' }
+    let(:config) { YAML.load(<<-EOT
+---
+:pools:
+  - name: '#{pool}'
+    size: 1
+    template: old_template
+EOT
+      )
+    }
+
+    it 'returns when a template is not set in redis' do
+      expect(subject.sync_pool_template(config[:pools][0])).to be_nil
+    end
+
+    it 'returns when a template is set and matches the configured template' do
+      redis_connection_pool.with do |redis|
+        redis.hset('vmpooler__config__template', pool, old_template)
+      end
+      subject.sync_pool_template(config[:pools][0])
+
+      expect(config[:pools][0]['template']).to eq(old_template)
+    end
+
+    it 'updates a pool template when the redis provided value is different' do
+      redis_connection_pool.with do |redis|
+        redis.hset('vmpooler__config__template', pool, new_template)
+      end
+
+      subject.sync_pool_template(config[:pools][0])
+
+      expect(config[:pools][0]['template']).to eq(new_template)
+    end
+  end
+
+  describe 'pool_mutex' do
+    it 'should return a mutex' do
+      expect(subject.pool_mutex(pool)).to be_a(Mutex)
+    end
+
+    it 'should return the same mutex when called twice' do
+      first = subject.pool_mutex(pool)
+      second = subject.pool_mutex(pool)
+      expect(first).to be(second)
+    end
+  end
+
+  describe 'update_pool_template' do
+    let(:current_template) { 'templates/pool_template' }
+    let(:new_template) { 'templates/new_pool_template' }
+    let(:config) {
+      YAML.load(<<-EOT
+---
+:config: {}
+:pools:
+  - name: #{pool}
+    template: "#{current_template}"
+EOT
+      )
+    }
+    let(:poolconfig) { config[:pools][0] }
+
+    before(:each) do
+      allow(logger).to receive(:log)
+    end
+
+    it 'should set the pool template to match the configured template' do
+      redis_connection_pool.with do |redis|
+        subject.update_pool_template(poolconfig, provider, new_template, current_template, redis)
+      end
+
+      expect(poolconfig['template']).to eq(new_template)
+    end
+
+    it 'should log that the template is updated' do
+      expect(logger).to receive(:log).with('s', "[*] [#{pool}] template updated from #{current_template} to #{new_template}")
+
+      redis_connection_pool.with do |redis|
+        subject.update_pool_template(poolconfig, provider, new_template, current_template, redis)
+      end
+    end
+
+    it 'should run drain_pool' do
+      redis_connection_pool.with do |redis|
+        expect(subject).to receive(:drain_pool).with(pool, redis)
+
+        subject.update_pool_template(poolconfig, provider, new_template, current_template, redis)
+      end
+    end
+
+    it 'should log that a template is being prepared' do
+      expect(logger).to receive(:log).with('s', "[*] [#{pool}] preparing pool template for deployment")
+
+      redis_connection_pool.with do |redis|
+        subject.update_pool_template(poolconfig, provider, new_template, current_template, redis)
+      end
+    end
+
+    it 'should run prepare_template' do
+      redis_connection_pool.with do |redis|
+        expect(subject).to receive(:prepare_template).with(poolconfig, provider, redis)
+
+        subject.update_pool_template(poolconfig, provider, new_template, current_template, redis)
+      end
+    end
+
+    it 'should log that the pool is ready for use' do
+      expect(logger).to receive(:log).with('s', "[*] [#{pool}] is ready for use")
+
+      redis_connection_pool.with do |redis|
+        subject.update_pool_template(poolconfig, provider, new_template, current_template, redis)
+      end
+    end
+  end
+
+  describe '#remove_excess_vms' do
+    let(:config) {
+      YAML.load(<<-EOT
+---
+:pools:
+  - name: #{pool}
+    size: 2
+EOT
+      )
+    }
+
+    before(:each) do
+      expect(subject).not_to be_nil
+    end
+
+    context 'with a 0 total value' do
+      let(:ready) { 0 }
+      let(:total) { 0 }
+      it 'should return nil' do
+        expect(subject.remove_excess_vms(config[:pools][0])).to be_nil
+      end
+    end
+
+    context 'when the mutex is locked' do
+      let(:mutex) { Mutex.new }
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          create_ready_vm(pool,'vm1',redis)
+          create_ready_vm(pool,'vm2',redis)
+          create_pending_vm(pool,'vm3',redis)
+        end
+        mutex.lock
+        expect(subject).to receive(:pool_mutex).with(pool).and_return(mutex)
+      end
+
+      it 'should return nil' do
+        expect(subject.remove_excess_vms(config[:pools][0])).to be_nil
+      end
+    end
+
+    context 'with a total size less than the pool size' do
+      it 'should return nil' do
+        redis_connection_pool.with do |redis|
+          expect(redis).to receive(:scard).with("vmpooler__pending__#{pool}").and_return(1)
+          expect(redis).to receive(:scard).with("vmpooler__ready__#{pool}").and_return(1)
+        end
+        expect(subject.remove_excess_vms(config[:pools][0])).to be_nil
+      end
+    end
+
+    context 'with a total size greater than the pool size' do
+      it 'should remove excess ready vms' do
+        redis_connection_pool.with do |redis|
+          ['vm1','vm2','vm3','vm4'].each do |v|
+            create_ready_vm(pool,v,redis)
+          end
+        end
+        expect(subject).to receive(:move_vm_queue).exactly(2).times
+
+        subject.remove_excess_vms(config[:pools][0])
+      end
+
+      it 'should remove excess pending vms' do
+        redis_connection_pool.with do |redis|
+          create_pending_vm(pool,'vm1',redis)
+          create_pending_vm(pool,'vm2',redis)
+          create_ready_vm(pool,'vm3',redis)
+          create_ready_vm(pool,'vm4',redis)
+          create_ready_vm(pool,'vm5',redis)
+          expect(subject).to receive(:move_vm_queue).exactly(3).times
+        end
+
+        subject.remove_excess_vms(config[:pools][0])
+      end
+    end
+  end
+
+  describe 'prepare_template' do
+    let(:config) { YAML.load(<<-EOT
+---
+:config:
+  create_template_delta_disks: true
+:providers:
+  :mock:
+:pools:
+  - name: '#{pool}'
+    size: 1
+    template: 'templates/pool1'
+EOT
+      )
+    }
+
+    context 'when creating the template delta disks' do
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          allow(redis).to receive(:hset)
+        end
+        allow(provider).to receive(:create_template_delta_disks)
+      end
+
+      it 'should run create template delta disks' do
+        redis_connection_pool.with do |redis|
+          expect(provider).to receive(:create_template_delta_disks).with(config[:pools][0])
+
+          subject.prepare_template(config[:pools][0], provider, redis)
+        end
+      end
+
+      it 'should mark the template as prepared' do
+        redis_connection_pool.with do |redis|
+          expect(redis).to receive(:hset).with('vmpooler__template__prepared', pool, config[:pools][0]['template'])
+
+          subject.prepare_template(config[:pools][0], provider, redis)
+        end
+      end
+    end
+
+    context 'when template delta disk creation fails' do
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          allow(redis).to receive(:hset)
+        end
+        expect(provider).to receive(:create_template_delta_disks).and_raise("MockError")
+      end
+
+      it 'should log a message when delta disk creation returns an error' do
+        redis_connection_pool.with do |redis|
+          expect(logger).to receive(:log).with('s', "[!] [#{pool}] failed while preparing a template with an error. As a result vmpooler could not create the template delta disks. Either a template delta disk already exists, or the template delta disk creation failed. The error is: MockError")
+
+          subject.prepare_template(config[:pools][0], provider, redis)
+        end
+      end
+    end
+  end
+
+  describe 'evaluate_template' do
+    let(:mutex) { Mutex.new }
+    let(:current_template) { 'templates/template1' }
+    let(:new_template) { 'templates/template2' }
+    let(:config) { YAML.load(<<-EOT
+---
+:config:
+  task_limit: 5
+:providers:
+  :mock:
+:pools:
+  - name: '#{pool}'
+    size: 1
+    template: '#{current_template}'
+EOT
+      )
+    }
+
+    before(:each) do
+      redis_connection_pool.with do |redis|
+        allow(redis).to receive(:hget)
+      end
+      expect(subject).to receive(:pool_mutex).with(pool).and_return(mutex)
+    end
+
+    it 'should retreive the prepared template' do
+      redis_connection_pool.with do |redis|
+        expect(redis).to receive(:hget).with('vmpooler__template__prepared', pool).and_return(current_template)
+      end
+
+      subject.evaluate_template(config[:pools][0], provider)
+    end
+
+    it 'should retrieve the redis configured template' do
+      redis_connection_pool.with do |redis|
+        expect(redis).to receive(:hget).with('vmpooler__config__template', pool).and_return(new_template)
+      end
+
+      subject.evaluate_template(config[:pools][0], provider)
+    end
+
+    context 'when the mutex is locked' do
+      before(:each) do
+        mutex.lock
+      end
+
+      it 'should return' do
+        expect(subject.evaluate_template(config[:pools][0], provider)).to be_nil
+      end
+    end
+
+    context 'when prepared template is nil' do
+
+      it 'should prepare the template' do
+        redis_connection_pool.with do |redis|
+          expect(redis).to receive(:hget).with('vmpooler__template__prepared', pool).and_return(nil)
+          expect(subject).to receive(:prepare_template).with(config[:pools][0], provider, redis)
+        end
+
+        subject.evaluate_template(config[:pools][0], provider)
+      end
+
+      it 'should not prepare the template again' do
+        redis_connection_pool.with do |redis|
+          expect(redis).to receive(:hget).with('vmpooler__template__prepared', pool).and_return(current_template)
+        end
+        expect(subject).to_not receive(:prepare_template).with(config[:pools][0], provider)
+
+        subject.evaluate_template(config[:pools][0], provider)
+      end
+    end
+
+    context 'when the configured pool template does not match the prepared template' do
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          config[:pools][0]['template'] = new_template
+          expect(redis).to receive(:hget).with('vmpooler__template__prepared', pool).and_return(current_template)
+        end
+      end
+
+      it 'should prepare the template' do
+        redis_connection_pool.with do |redis|
+          expect(subject).to receive(:prepare_template).with(config[:pools][0], provider, redis)
+        end
+
+        subject.evaluate_template(config[:pools][0], provider)
+      end
+
+      context 'if configured_template is provided' do
+        it 'should not run prepare_template' do
+          redis_connection_pool.with do |redis|
+            expect(redis).to receive(:hget).with('vmpooler__config__template', pool).and_return(current_template)
+          end
+          expect(subject).to_not receive(:prepare_template)
+
+          subject.evaluate_template(config[:pools][0], provider)
+        end
+      end
+    end
+
+    context 'when a new template is requested' do
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          expect(redis).to receive(:hget).with('vmpooler__template__prepared', pool).and_return(current_template)
+          expect(redis).to receive(:hget).with('vmpooler__config__template', pool).and_return(new_template)
+        end
+      end
+
+      it 'should update the template' do
+        redis_connection_pool.with do |redis|
+          expect(subject).to receive(:update_pool_template).with(config[:pools][0], provider, new_template, current_template, redis)
+        end
+
+        subject.evaluate_template(config[:pools][0], provider)
+      end
+    end
+  end
+
+  describe 'drain_pool' do
+    before(:each) do
+      allow(logger).to receive(:log)
+    end
+
+    context 'with no vms' do
+      it 'should return nil' do
+        redis_connection_pool.with do |redis|
+          expect(subject.drain_pool(pool, redis)).to be_nil
+        end
+      end
+
+      it 'should not log any messages' do
+        expect(logger).to_not receive(:log)
+
+        redis_connection_pool.with do |redis|
+          subject.drain_pool(pool, redis)
+        end
+      end
+
+      it 'should not try to move any vms' do
+        expect(subject).to_not receive(:move_vm_queue)
+
+        redis_connection_pool.with do |redis|
+          subject.drain_pool(pool, redis)
+        end
+      end
+    end
+
+    context 'with ready vms' do
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          create_ready_vm(pool, 'vm1', redis)
+          create_ready_vm(pool, 'vm2', redis)
+        end
+      end
+
+      it 'removes the ready instances' do
+        expect(subject).to receive(:move_vm_queue).twice
+
+        redis_connection_pool.with do |redis|
+          subject.drain_pool(pool, redis)
+        end
+      end
+
+      it 'logs that ready instances are being removed' do
+        expect(logger).to receive(:log).with('s', "[*] [#{pool}] removing ready instances")
+
+        redis_connection_pool.with do |redis|
+          subject.drain_pool(pool, redis)
+        end
+      end
+    end
+
+    context 'with pending instances' do
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          create_pending_vm(pool, 'vm1', redis)
+          create_pending_vm(pool, 'vm2', redis)
+        end
+      end
+
+      it 'removes the pending instances' do
+        expect(subject).to receive(:move_vm_queue).twice
+
+        redis_connection_pool.with do |redis|
+          subject.drain_pool(pool, redis)
+        end
+      end
+
+      it 'logs that pending instances are being removed' do
+        expect(logger).to receive(:log).with('s', "[*] [#{pool}] removing pending instances")
+
+        redis_connection_pool.with do |redis|
+          subject.drain_pool(pool, redis)
+        end
+      end
+    end
+  end
+
+  describe 'update_pool_size' do
+    let(:newsize) { '3' }
+    let(:config) {
+      YAML.load(<<-EOT
+---
+:pools:
+  - name: #{pool}
+    size: 2
+EOT
+      )
+    }
+    let(:poolconfig) { config[:pools][0] }
+
+    context 'with a locked mutex' do
+
+      let(:mutex) { Mutex.new }
+      before(:each) do
+        mutex.lock
+        expect(subject).to receive(:pool_mutex).with(pool).and_return(mutex)
+      end
+
+      it 'should return nil' do
+        expect(subject.update_pool_size(poolconfig)).to be_nil
+      end
+    end
+
+    it 'should get the pool size configuration from redis' do
+      redis_connection_pool.with do |redis|
+        expect(redis).to receive(:hget).with('vmpooler__config__poolsize', pool)
+      end
+
+      subject.update_pool_size(poolconfig)
+    end
+
+    it 'should return when poolsize is not set in redis' do
+      redis_connection_pool.with do |redis|
+        expect(redis).to receive(:hget).with('vmpooler__config__poolsize', pool).and_return(nil)
+      end
+
+      expect(subject.update_pool_size(poolconfig)).to be_nil
+    end
+
+    it 'should return when no change in configuration is required' do
+      redis_connection_pool.with do |redis|
+        expect(redis).to receive(:hget).with('vmpooler__config__poolsize', pool).and_return('2')
+      end
+
+      expect(subject.update_pool_size(poolconfig)).to be_nil
+    end
+
+    it 'should update the pool size' do
+      redis_connection_pool.with do |redis|
+        expect(redis).to receive(:hget).with('vmpooler__config__poolsize', pool).and_return(newsize)
+      end
+
+      subject.update_pool_size(poolconfig)
+
+      expect(poolconfig['size']).to eq(Integer(newsize))
+    end
+  end
+
+  describe 'update_clone_target' do
+    let(:newtarget) { 'cluster2' }
+    let(:config) {
+      YAML.load(<<-EOT
+---
+:pools:
+  - name: #{pool}
+    clone_target: 'cluster1'
+EOT
+      )
+    }
+    let(:poolconfig) { config[:pools][0] }
+
+    context 'with a locked mutex' do
+
+      let(:mutex) { Mutex.new }
+      before(:each) do
+        mutex.lock
+        expect(subject).to receive(:pool_mutex).with(pool).and_return(mutex)
+      end
+
+      it 'should return nil' do
+        expect(subject.update_clone_target(poolconfig)).to be_nil
+      end
+    end
+
+    it 'should get the pool clone target configuration from redis' do
+      redis_connection_pool.with do |redis|
+        expect(redis).to receive(:hget).with('vmpooler__config__clone_target', pool)
+      end
+
+      subject.update_clone_target(poolconfig)
+    end
+
+    it 'should return when clone_target is not set in redis' do
+      redis_connection_pool.with do |redis|
+        expect(redis).to receive(:hget).with('vmpooler__config__clone_target', pool).and_return(nil)
+      end
+
+      expect(subject.update_clone_target(poolconfig)).to be_nil
+    end
+
+    it 'should return when no change in configuration is required' do
+      redis_connection_pool.with do |redis|
+        expect(redis).to receive(:hget).with('vmpooler__config__clone_target', pool).and_return('cluster1')
+      end
+
+      expect(subject.update_clone_target(poolconfig)).to be_nil
+    end
+
+    it 'should update the clone target' do
+      redis_connection_pool.with do |redis|
+        expect(redis).to receive(:hget).with('vmpooler__config__clone_target', pool).and_return(newtarget)
+      end
+
+      subject.update_clone_target(poolconfig)
+
+      expect(poolconfig['clone_target']).to eq(newtarget)
+    end
+  end
+
+  describe "#execute!" do
+    let(:config) {
+      YAML.load(<<-EOT
+---
+:pools:
+  - name: #{pool}
+EOT
+      )
+    }
+
+    before(:each) do
+      expect(subject).not_to be_nil
+
+      allow(subject).to receive(:check_disk_queue)
+      allow(subject).to receive(:check_snapshot_queue)
+      allow(subject).to receive(:check_pool)
+      allow(subject).to receive(:check_ondemand_requests)
+
+      allow(logger).to receive(:log)
+    end
+
+    after(:each) do
+      # Reset the global variable - Note this is a code smell
+      $threads = nil
+    end
+
+    context 'on startup' do
+      it 'should log a message that VMPooler has started' do
+        expect(logger).to receive(:log).with('d', 'starting vmpooler')
+
+        subject.execute!(1,0)
+      end
+
+      it 'should set clone tasks to zero' do
+        redis_connection_pool.with do |redis|
+          redis.set('vmpooler__tasks__clone', 1)
+          subject.execute!(1,0)
+          expect(redis.get('vmpooler__tasks__clone')).to eq('0')
+        end
+      end
+
+      it 'should clear migration tasks' do
+        redis_connection_pool.with do |redis|
+          redis.set('vmpooler__migration', 1)
+          subject.execute!(1,0)
+          expect(redis.get('vmpooler__migration')).to be_nil
+        end
+      end
+
+      it 'should run the check_disk_queue method' do
+        expect(subject).to receive(:check_disk_queue)
+
+        subject.execute!(1,0)
+      end
+
+      it 'should run the check_snapshot_queue method' do
+        expect(subject).to receive(:check_snapshot_queue)
+
+        subject.execute!(1,0)
+      end
+
+      it 'should check the pools in the config' do
+        expect(subject).to receive(:check_pool).with(a_pool_with_name_of(pool))
+
+        subject.execute!(1,0)
+      end
+
+      it 'should run the check_ondemand_requests method' do
+        expect(subject).to receive(:check_ondemand_requests)
+
+        subject.execute!(1,0)
+      end
+
+      context 'creating Providers' do
+        let(:vsphere_provider) { double('vsphere_provider') }
+        let(:config) {
+        YAML.load(<<-EOT
+---
+:providers:
+  :vsphere: {}
+:pools:
+  - name: #{pool}
+    provider: 'vsphere'
+  - name: 'vsphere-pool-2'
+    provider: 'vsphere'
+EOT
+        )}
+
+        it 'should call create_provider_object idempotently' do
+          # 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)
+
+          subject.execute!(1,0)
+        end
+
+        it 'should raise an error if the provider can not be created' do
+          expect(subject).to receive(:create_provider_object).and_raise(RuntimeError, "MockError")
+
+          expect{ subject.execute!(1,0) }.to raise_error(/MockError/)
+        end
+
+        it 'should log a message if the provider can not be created' do
+          expect(subject).to receive(:create_provider_object).and_raise(RuntimeError, "MockError")
+          expect(logger).to receive(:log).with('s',"Error while creating provider for pool #{pool}: MockError")
+
+          expect{ subject.execute!(1,0) }.to raise_error(/MockError/)
+        end
+      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) {
+        YAML.load(<<-EOT
+:vsphere:
+  server: 'vsphere.example.com'
+  username: 'vmpooler'
+  password: 'password'
+:pools:
+  - name: #{pool}
+EOT
+        )}
+
+        it 'should set providers with no provider to vsphere' do
+          expect(subject.config[:providers]).to be nil
+
+          subject.execute!(1,0)
+          expect(subject.config[:providers][:vsphere]['server']).to eq('vsphere.example.com')
+          expect(subject.config[:providers][:vsphere]['username']).to eq('vmpooler')
+          expect(subject.config[:providers][:vsphere]['password']).to eq('password')
+        end
+
+        it 'should log a message' do
+          expect(logger).to receive(:log).with('d', "[!] Detected an older configuration file. Copying the settings from ':vsphere:' to ':providers:/:vsphere:'")
+
+          subject.execute!(1,0)
+        end
+      end
+    end
+
+    context 'with dead disk_manager thread' do
+      let(:disk_manager_thread) { double('thread', :alive? => false) }
+
+      before(:each) do
+        # Reset the global variable - Note this is a code smell
+        $threads = {}
+        $threads['disk_manager'] = disk_manager_thread
+      end
+
+      it 'should run the check_disk_queue method and log a message' do
+        expect(subject).to receive(:check_disk_queue)
+        expect(logger).to receive(:log).with('d', "[!] [disk_manager] worker thread died, restarting")
+
+        subject.execute!(1,0)
+      end
+    end
+
+    context 'with dead snapshot_manager thread' do
+      let(:snapshot_manager_thread) { double('thread', :alive? => false) }
+      before(:each) do
+        # Reset the global variable - Note this is a code smell
+        $threads = {}
+        $threads['snapshot_manager'] = snapshot_manager_thread
+      end
+
+      it 'should run the check_snapshot_queue method and log a message' do
+        expect(subject).to receive(:check_snapshot_queue)
+        expect(logger).to receive(:log).with('d', "[!] [snapshot_manager] worker thread died, restarting")
+        $threads['snapshot_manager'] = snapshot_manager_thread
+
+        subject.execute!(1,0)
+      end
+    end
+
+    context 'with dead pool thread' do
+      context 'without check_loop_delay_xxx settings' do
+        let(:pool_thread) { double('thread', :alive? => false) }
+        let(:default_check_loop_delay_min) { 5 }
+        let(:default_check_loop_delay_max) { 60 }
+        let(:default_check_loop_delay_decay) { 2.0 }
+        before(:each) do
+          # Reset the global variable - Note this is a code smell
+          $threads = {}
+          $threads[pool] = pool_thread
+        end
+
+        it 'should run the check_pool method and log a message' do
+          expect(subject).to receive(:check_pool).with(a_pool_with_name_of(pool),
+                                                       default_check_loop_delay_min,
+                                                       default_check_loop_delay_max,
+                                                       default_check_loop_delay_decay)
+          expect(logger).to receive(:log).with('d', "[!] [#{pool}] worker thread died, restarting")
+
+          subject.execute!(1,0)
+        end
+      end
+
+      context 'with dead ondemand provisioner thread' do
+        let(:ondemand_provisioner_thread) { double('thread', :alive? => false) }
+        let(:default_check_loop_delay_min) { 5 }
+        let(:default_check_loop_delay_max) { 60 }
+        let(:default_check_loop_delay_decay) { 2.0 }
+        before(:each) do
+          # Reset the global variable - Note this is a code smell
+          $threads = {}
+          $threads['ondemand_provisioner'] = ondemand_provisioner_thread
+        end
+
+        it 'should run the process_ondemand_requests method' do
+          expect(subject).to receive(:check_ondemand_requests).with(default_check_loop_delay_min, default_check_loop_delay_max, default_check_loop_delay_decay)
+          subject.execute!(1,0)
+        end
+
+      end
+
+      context 'with check_loop_delay_xxx settings' do
+        let(:pool_thread) { double('thread', :alive? => false) }
+        let(:check_loop_delay_min) { 7 }
+        let(:check_loop_delay_max) { 20 }
+        let(:check_loop_delay_decay) { 2.1 }
+
+        let(:config) {
+      YAML.load(<<-EOT
+---
+:config:
+  check_loop_delay_min: #{check_loop_delay_min}
+  check_loop_delay_max: #{check_loop_delay_max}
+  check_loop_delay_decay: #{check_loop_delay_decay}
+:pools:
+  - name: #{pool}
+EOT
+          )
+        }
+        before(:each) do
+          # Reset the global variable - Note this is a code smell
+          $threads = {}
+          $threads[pool] = pool_thread
+        end
+
+        it 'should run the check_pool method and log a message' do
+          expect(subject).to receive(:check_pool).with(a_pool_with_name_of(pool),
+                                                       check_loop_delay_min,
+                                                       check_loop_delay_max,
+                                                       check_loop_delay_decay)
+          expect(logger).to receive(:log).with('d', "[!] [#{pool}] worker thread died, restarting")
+
+          subject.execute!(1,0)
+        end
+      end
+    end
+
+    context 'delays between loops' do
+      let(:maxloop) { 2 }
+      let(:loop_delay) { 1 }
+      # Note a maxloop of zero can not be tested as it never terminates
+      before(:each) do
+
+        allow(subject).to receive(:check_disk_queue)
+        allow(subject).to receive(:check_snapshot_queue)
+        allow(subject).to receive(:check_pool)
+        allow(subject).to receive(:check_ondemand_requests)
+      end
+
+      it 'when a non-default loop delay is specified' do
+        expect(subject).to receive(:sleep).with(loop_delay).exactly(maxloop).times
+
+        subject.execute!(maxloop,loop_delay)
+      end
+    end
+
+    context 'loops specified number of times (5)' do
+      let(:alive_thread) { double('thread', :alive? => true) }
+      let(:maxloop) { 5 }
+      # Note a maxloop of zero can not be tested as it never terminates
+      before(:each) do
+        end
+
+      it 'should run startup tasks only once' do
+        redis_connection_pool.with do |redis|
+          expect(redis).to receive(:set).with('vmpooler__tasks__clone', 0).once
+          expect(redis).to receive(:set).with('vmpooler__tasks__ondemandclone', 0).once
+          expect(redis).to receive(:del).with('vmpooler__migration').once
+        end
+
+        subject.execute!(maxloop,0)
+      end
+
+      it 'should run per thread tasks 5 times when threads are not remembered' do
+        expect(subject).to receive(:check_disk_queue).exactly(maxloop).times
+        expect(subject).to receive(:check_snapshot_queue).exactly(maxloop).times
+        expect(subject).to receive(:check_pool).exactly(maxloop).times
+        expect(subject).to receive(:check_ondemand_requests).exactly(maxloop).times
+
+        subject.execute!(maxloop,0)
+      end
+
+      it 'should not run per thread tasks when threads are alive' do
+        expect(subject).to receive(:check_disk_queue).exactly(0).times
+        expect(subject).to receive(:check_snapshot_queue).exactly(0).times
+        expect(subject).to receive(:check_pool).exactly(0).times
+        expect(subject).to receive(:check_ondemand_requests).exactly(0).times
+
+        $threads[pool] = alive_thread
+        $threads['disk_manager'] = alive_thread
+        $threads['snapshot_manager'] = alive_thread
+        $threads['ondemand_provisioner'] = alive_thread
+
+        subject.execute!(maxloop,0)
+      end
+    end
+
+    context 'when redis server connection is not available' do
+      let(:maxloop) { 2 }
+      it 'should log a failure and raise the error' do
+        redis_connection_pool.with do |redis|
+          expect(redis).to receive(:set).with('vmpooler__tasks__clone', 0).and_raise(Redis::CannotConnectError)
+        end
+        expect(logger).to receive(:log).with('s', 'Cannot connect to the redis server: Redis::CannotConnectError')
+
+        expect{subject.execute!(maxloop,0)}.to raise_error Redis::CannotConnectError
+      end
+    end
+  end
+
+  describe "#sleep_with_wakeup_events" do
+    let(:loop_delay) { 10 }
+    before(:each) do
+      allow(Kernel).to receive(:sleep).and_raise("sleep should not be called")
+      allow(subject).to receive(:time_passed?).with(:wakeup_by, Time).and_call_original
+      allow(subject).to receive(:time_passed?).with(:exit_by, Time).and_call_original
+    end
+
+    it 'should not sleep if the loop delay is negative' do
+      expect(subject).to receive(:sleep).exactly(0).times
+
+      subject.sleep_with_wakeup_events(-1)
+    end
+
+    it 'should sleep until the loop delay is exceeded' do
+      # This test is a little brittle as it requires knowledge of the implementation
+      # Basically the number of sleep delays will dictate how often the time_passed? method is called
+
+      expect(subject).to receive(:sleep).exactly(2).times
+      expect(subject).to receive(:time_passed?).with(:exit_by, Time).and_return(false, false, false, true)
+
+      subject.sleep_with_wakeup_events(loop_delay)
+    end
+
+    describe 'with the pool_size_change wakeup option' do
+      let(:wakeup_option) {{
+        :pool_size_change => true,
+        :poolname => pool,
+      }}
+      let(:wakeup_period) { -1 } # A negative number forces the wakeup evaluation to always occur
+
+      it 'should check the number of VMs ready in Redis' do
+        redis_connection_pool.with do |redis|
+          expect(subject).to receive(:time_passed?).with(:exit_by, Time).and_return(false, true)
+          expect(redis).to receive(:scard).with("vmpooler__ready__#{pool}").once
+        end
+
+        subject.sleep_with_wakeup_events(loop_delay, wakeup_period, wakeup_option)
+      end
+
+      it 'should sleep until the number of VMs ready in Redis increases' do
+        redis_connection_pool.with do |redis|
+          expect(subject).to receive(:sleep).exactly(3).times
+          expect(redis).to receive(:scard).with("vmpooler__ready__#{pool}").and_return(1,1,1,2)
+        end
+
+        subject.sleep_with_wakeup_events(loop_delay, wakeup_period, wakeup_option)
+      end
+
+      it 'should sleep until the number of VMs ready in Redis decreases' do
+        redis_connection_pool.with do |redis|
+          expect(subject).to receive(:sleep).exactly(3).times
+          expect(redis).to receive(:scard).with("vmpooler__ready__#{pool}").and_return(2,2,2,1)
+        end
+
+        subject.sleep_with_wakeup_events(loop_delay, wakeup_period, wakeup_option)
+      end
+    end
+
+    describe 'with the pool_template_change wakeup option' do
+      let(:wakeup_option) {{
+        :pool_template_change => true,
+        :poolname => pool
+      }}
+      let(:new_template) { 'templates/newtemplate' }
+      let(:wakeup_period) { -1 } # A negative number forces the wakeup evaluation to always occur
+
+      context 'with a template configured' do
+        before(:each) do
+          redis_connection_pool.with do |redis|
+            redis.hset('vmpooler__config__template', pool, new_template)
+            allow(redis).to receive(:hget)
+          end
+        end
+
+        it 'should check if a template is configured in redis' do
+          redis_connection_pool.with do |redis|
+            expect(subject).to receive(:time_passed?).with(:exit_by, Time).and_return(false, true)
+            expect(redis).to receive(:hget).with('vmpooler__template__prepared', pool).once
+          end
+
+          subject.sleep_with_wakeup_events(loop_delay, wakeup_period, wakeup_option)
+        end
+
+        it 'should sleep until a template change is detected' do
+          redis_connection_pool.with do |redis|
+            expect(subject).to receive(:sleep).exactly(3).times
+            expect(redis).to receive(:hget).with('vmpooler__config__template', pool).and_return(nil,nil,new_template)
+          end
+
+          subject.sleep_with_wakeup_events(loop_delay, wakeup_period, wakeup_option)
+        end
+      end
+    end
+
+    describe 'with the pool_reset wakeup option' do
+      let(:wakeup_option) {{
+        :pool_reset => true,
+        :poolname => pool
+      }}
+
+      let(:wakeup_period) { -1 } # A negative number forces the wakeup evaluation to always occur
+
+      context 'when a pool reset is requested' do
+
+        it 'should sleep until the reset request is detected' do
+          redis_connection_pool.with do |redis|
+            expect(subject).to receive(:sleep).exactly(3).times
+            expect(redis).to receive(:sismember).with('vmpooler__poolreset', pool).and_return(false,false,true)
+          end
+
+          subject.sleep_with_wakeup_events(loop_delay, wakeup_period, wakeup_option)
+        end
+      end
+    end
+
+    describe 'with the undo_override wakeup option' do
+      let(:wakeup_option) {{
+        :undo_override => true,
+        :poolname => pool
+      }}
+
+      let(:wakeup_period) { -1 } # A negative number forces the wakeup evaluation to always occur
+
+      context 'when a undoing a template override is requested' do
+        before(:each) do
+          redis_connection_pool.with do |redis|
+            redis.sadd('vmpooler__pool__undo_template_override', pool)
+            allow(redis).to receive(:hget)
+          end
+        end
+
+        it 'should sleep until the undo override request is detected' do
+          redis_connection_pool.with do |redis|
+            expect(subject).to receive(:sleep).at_least(2).times
+            expect(subject).to receive(:sleep).at_most(3).times
+            expect(redis).to receive(:sismember).with('vmpooler__pool__undo_template_override', pool).and_return(false,false,true)
+            expect(redis).to receive(:sismember).with('vmpooler__pool__undo_size_override', pool).and_return(false,false)
+          end
+
+          subject.sleep_with_wakeup_events(loop_delay, wakeup_period, wakeup_option)
+        end
+      end
+
+      context 'when a undoing a size override is requested' do
+        before(:each) do
+          redis_connection_pool.with do |redis|
+            redis.sadd('vmpooler__pool__undo_size_override', pool)
+            allow(redis).to receive(:hget)
+          end
+        end
+
+        it 'should sleep until the undo override request is detected' do
+          redis_connection_pool.with do |redis|
+            expect(subject).to receive(:sleep).exactly(3).times
+            expect(redis).to receive(:sismember).with('vmpooler__pool__undo_template_override', pool).and_return(false,false,false)
+            expect(redis).to receive(:sismember).with('vmpooler__pool__undo_size_override', pool).and_return(false,false,true)
+          end
+
+          subject.sleep_with_wakeup_events(loop_delay, wakeup_period, wakeup_option)
+        end
+      end
+    end
+
+    describe 'with the pending_vm wakeup option' do
+      let(:wakeup_option) {{
+        :pending_vm => true,
+        :poolname => pool
+      }}
+
+      let(:wakeup_period) { -1 } # A negative number forces the wakeup evaluation to always occur
+
+      context 'when a pending_vm is detected' do
+
+        it 'should sleep until the pending instance' do
+          redis_connection_pool.with do |redis|
+            expect(subject).to receive(:sleep).exactly(3).times
+            expect(redis).to receive(:scard).with("vmpooler__pending__#{pool}").and_return(0,0,1)
+          end
+
+          subject.sleep_with_wakeup_events(loop_delay, wakeup_period, wakeup_option)
+        end
+      end
+    end
+
+    describe 'with the ondemand_request wakeup option' do
+      let(:wakeup_option) {{ :ondemand_request => true }}
+
+      let(:wakeup_period) { -1 } # A negative number forces the wakeup evaluation to always occur
+
+      it 'should sleep until the provisioning request is detected' do
+        redis_connection_pool.with do |redis|
+          expect(subject).to receive(:sleep).exactly(3).times
+          expect(redis).to receive(:multi).and_return('OK').exactly(3).times
+          expect(redis).to receive(:exec).and_return([0,0,0],[0,0,0],[1,0,0])
+        end
+
+        subject.sleep_with_wakeup_events(loop_delay, wakeup_period, wakeup_option)
+      end
+
+      it 'should sleep until provisioning processing is detected' do
+        redis_connection_pool.with do |redis|
+          expect(subject).to receive(:sleep).exactly(3).times
+          expect(redis).to receive(:multi).and_return('OK').exactly(3).times
+          expect(redis).to receive(:exec).and_return([0,0,0],[0,0,0],[0,1,0])
+        end
+        subject.sleep_with_wakeup_events(loop_delay, wakeup_period, wakeup_option)
+      end
+
+      it 'should sleep until ondemand creation task is detected' do
+        redis_connection_pool.with do |redis|
+          expect(subject).to receive(:sleep).exactly(3).times
+          expect(redis).to receive(:multi).and_return('OK').exactly(3).times
+          expect(redis).to receive(:exec).and_return([0,0,0],[0,0,0],[0,0,1])
+        end
+
+        subject.sleep_with_wakeup_events(loop_delay, wakeup_period, wakeup_option)
+      end
+    end
+  end
+
+  describe "#check_pool" do
+    let(:threads) {{}}
+    let(:provider_name) { 'mock_provider' }
+    let(:config) {
+      YAML.load(<<-EOT
+---
+:pools:
+  - name: #{pool}
+    provider: #{provider_name}
+EOT
+      )
+    }
+
+    let(:pool_object) { config[:pools][0] }
+    let(:check_pool_response) {{
+        :discovered_vms      => 0,
+        :checked_running_vms => 0,
+        :checked_ready_vms   => 0,
+        :checked_pending_vms => 0,
+        :destroyed_vms       => 0,
+        :migrated_vms        => 0,
+        :cloned_vms          => 0,
+    }}
+
+    before do
+      expect(subject).not_to be_nil
+      expect(Thread).to receive(:new).and_yield
+      allow(subject).to receive(:get_provider_for_pool).with(pool).and_return(provider)
+    end
+
+    context 'on startup' do
+      before(:each) do
+        allow(subject).to receive(:_check_pool).and_return(check_pool_response)
+        expect(logger).to receive(:log).with('d', "[*] [#{pool}] starting worker thread")
+      end
+
+      after(:each) do
+        # Reset the global variable - Note this is a code smell
+        $threads = nil
+      end
+
+      it 'should log a message the worker thread is starting' do
+        subject.check_pool(pool_object,1,0)
+      end
+
+      it 'should populate the threads global variable' do
+        subject.check_pool(pool_object,1,0)
+
+        # Unable to test for nil as the Thread is mocked
+        expect($threads.keys.include?(pool))
+      end
+    end
+
+    context 'delays between loops' do
+      let(:maxloop) { 2 }
+      let(:loop_delay) { 1 }
+      # Note a maxloop of zero can not be tested as it never terminates
+
+      before(:each) do
+        allow(logger).to receive(:log)
+        allow(subject).to receive(:_check_pool).and_return(check_pool_response)
+      end
+
+      after(:each) do
+        # Reset the global variable - Note this is a code smell
+        $threads = nil
+      end
+
+      it 'when a non-default loop delay is specified' do
+        expect(subject).to receive(:sleep_with_wakeup_events).with(loop_delay, Numeric, Hash).exactly(maxloop).times
+
+        subject.check_pool(pool_object,maxloop,loop_delay,loop_delay)
+      end
+
+      it 'specifies a wakeup option for pool size change' do
+        expect(subject).to receive(:sleep_with_wakeup_events).with(loop_delay, Numeric, hash_including(:pool_size_change => true)).exactly(maxloop).times
+
+        subject.check_pool(pool_object,maxloop,loop_delay,loop_delay)
+      end
+
+      it 'specifies a wakeup option for poolname' do
+        expect(subject).to receive(:sleep_with_wakeup_events).with(loop_delay, Numeric, hash_including(:poolname => pool)).exactly(maxloop).times
+
+        subject.check_pool(pool_object,maxloop,loop_delay,loop_delay)
+      end
+    end
+
+    context 'when redis connection fails' do
+      let(:maxloop) { 2 }
+      let(:loop_delay) { 1 }
+
+      it 'should raise the error' do
+        allow(subject).to receive(:_check_pool).and_raise(Redis::CannotConnectError)
+        expect(logger).to receive(:log).with('d', "[*] [#{pool}] starting worker thread")
+
+        expect{subject.check_pool(pool_object,maxloop,loop_delay,loop_delay)}.to raise_error Redis::CannotConnectError
+      end
+    end
+
+    context 'delays between loops configured in the pool configuration' do
+      let(:maxloop) { 2 }
+      let(:loop_delay) { 1 }
+      let(:pool_loop_delay) { 2 }
+      let(:config) {
+        YAML.load(<<-EOT
+---
+:pools:
+  - name: #{pool}
+    provider: #{provider_name}
+    check_loop_delay_min: #{pool_loop_delay}
+    check_loop_delay_max: #{pool_loop_delay}
+EOT
+        )
+      }
+
+      before(:each) do
+        allow(logger).to receive(:log)
+        allow(subject).to receive(:_check_pool).and_return(check_pool_response)
+      end
+
+      after(:each) do
+        # Reset the global variable - Note this is a code smell
+        $threads = nil
+      end
+
+      it 'when a non-default loop delay is specified' do
+        expect(subject).to receive(:sleep_with_wakeup_events).with(pool_loop_delay, pool_loop_delay, Hash).exactly(maxloop).times
+
+        subject.check_pool(pool_object,maxloop,loop_delay)
+      end
+    end
+
+    context 'delays between loops with a specified min and max value' do
+      let(:maxloop) { 5 }
+      let(:loop_delay_min) { 1 }
+      let(:loop_delay_max) { 60 }
+      # Note a maxloop of zero can not be tested as it never terminates
+
+      before(:each) do
+        allow(logger).to receive(:log)
+        allow(subject).to receive(:_check_pool).and_return(check_pool_response)
+      end
+
+      after(:each) do
+        # Reset the global variable - Note this is a code smell
+        $threads = nil
+      end
+
+      [:checked_pending_vms, :discovered_vms, :cloned_vms].each do |testcase|
+        describe "when #{testcase} is greater than zero" do
+          it "delays the minimum delay time" do
+            expect(subject).to receive(:sleep_with_wakeup_events).with(loop_delay_min, loop_delay_min, Hash).exactly(maxloop).times
+            check_pool_response[testcase] = 1
+
+            subject.check_pool(pool_object,maxloop,loop_delay_min,loop_delay_max)
+          end
+        end
+      end
+
+      [:checked_running_vms, :checked_ready_vms, :destroyed_vms, :migrated_vms].each do |testcase|
+        describe "when #{testcase} is greater than zero" do
+          let(:loop_decay) { 3.0 }
+          it "delays increases with a decay" do
+            expect(subject).to receive(:sleep_with_wakeup_events).with(3, Numeric, Hash).once
+            expect(subject).to receive(:sleep_with_wakeup_events).with(9, Numeric, Hash).once
+            expect(subject).to receive(:sleep_with_wakeup_events).with(27, Numeric, Hash).once
+            expect(subject).to receive(:sleep_with_wakeup_events).with(60, Numeric, Hash).twice
+            check_pool_response[testcase] = 1
+
+            subject.check_pool(pool_object,maxloop,loop_delay_min,loop_delay_max,loop_decay)
+          end
+        end
+      end
+    end
+
+    context 'delays between loops with a specified min and max value configured in the pool configuration' do
+      let(:maxloop) { 5 }
+      let(:loop_delay_min) { 1 }
+      let(:loop_delay_max) { 60 }
+      let(:loop_decay) { 3.0 }
+      let(:pool_loop_delay_min) { 3 }
+      let(:pool_loop_delay_max) { 70 }
+      let(:pool_loop_delay_decay) { 2.5 }
+      let(:config) {
+        YAML.load(<<-EOT
+---
+:pools:
+  - name: #{pool}
+    provider: #{provider_name}
+    check_loop_delay_min: #{pool_loop_delay_min}
+    check_loop_delay_max: #{pool_loop_delay_max}
+    check_loop_delay_decay: #{pool_loop_delay_decay}
+EOT
+        )
+      }
+
+      before(:each) do
+        allow(logger).to receive(:log)
+        allow(subject).to receive(:_check_pool).and_return(check_pool_response)
+      end
+
+      after(:each) do
+        # Reset the global variable - Note this is a code smell
+        $threads = nil
+      end
+
+      [:checked_pending_vms, :discovered_vms, :cloned_vms].each do |testcase|
+        describe "when #{testcase} is greater than zero" do
+          it "delays the minimum delay time" do
+            expect(subject).to receive(:sleep_with_wakeup_events).with(pool_loop_delay_min, Numeric, Hash).exactly(maxloop).times
+            check_pool_response[testcase] = 1
+
+            subject.check_pool(pool_object,maxloop,loop_delay_min,loop_delay_max,loop_decay)
+          end
+        end
+      end
+
+      [:checked_running_vms, :checked_ready_vms, :destroyed_vms, :migrated_vms].each do |testcase|
+        describe "when #{testcase} is greater than zero" do
+          it "delays increases with a decay" do
+            expect(subject).to receive(:sleep_with_wakeup_events).with(7, Numeric, Hash).once
+            expect(subject).to receive(:sleep_with_wakeup_events).with(17, Numeric, Hash).once
+            expect(subject).to receive(:sleep_with_wakeup_events).with(42, Numeric, Hash).once
+            expect(subject).to receive(:sleep_with_wakeup_events).with(70, Numeric, Hash).twice
+            check_pool_response[testcase] = 1
+
+            subject.check_pool(pool_object,maxloop,loop_delay_min,loop_delay_max,loop_decay)
+          end
+        end
+      end
+    end
+
+
+    context 'loops specified number of times (5)' do
+      let(:maxloop) { 5 }
+      # Note a maxloop of zero can not be tested as it never terminates
+      before(:each) do
+        allow(logger).to receive(:log)
+        allow(subject).to receive(:_check_pool).and_return(check_pool_response)
+      end
+
+      after(:each) do
+        # Reset the global variable - Note this is a code smell
+        $threads = nil
+        $provider = nil
+      end
+
+      it 'should run startup tasks only once' do
+        expect(logger).to receive(:log).with('d', "[*] [#{pool}] starting worker thread")
+
+        subject.check_pool(pool_object,maxloop,0)
+      end
+
+      it 'should run per thread tasks 5 times' do
+        expect(subject).to receive(:_check_pool).exactly(maxloop).times
+
+        subject.check_pool(pool_object,maxloop,0)
+      end
+    end
+  end
+
+  describe 'undo_override' do
+    let(:mutex) { Mutex.new }
+    let(:original_template) { 'templates/template1' }
+    let(:override_template) { 'templates/template2' }
+    let(:original_size) { 2 }
+    let(:override_size) { 10 }
+    let(:config) { YAML.load(<<-EOT
+---
+:config:
+  task_limit: 5
+:providers:
+  :mock:
+:pools:
+  - name: '#{pool}'
+    size: #{override_size}
+    template: '#{override_template}'
+:pool_index:
+  '#{pool}': 0
+:pools_at_startup:
+  - name: '#{pool}'
+    size: #{original_size}
+    template: '#{original_template}'
+EOT
+      )
+    }
+
+    before(:each) do
+      redis_connection_pool.with do |redis|
+        redis.sadd('vmpooler__pool__undo_template_override', pool)
+        redis.sadd('vmpooler__pool__undo_size_override', pool)
+        # allow(redis).to receive(:hget)
+      end
+    end
+
+    it 'should revert to the original template and pool size' do
+      redis_connection_pool.with do |redis|
+        expect(redis).to receive(:sismember).with('vmpooler__pool__undo_template_override', pool).and_return(true)
+        expect(redis).to receive(:srem).with('vmpooler__pool__undo_template_override', pool).and_return(true)
+        expect(subject).to receive(:update_pool_template).with(config[:pools][0], provider, original_template, override_template, redis)
+
+        expect(redis).to receive(:sismember).with('vmpooler__pool__undo_size_override', pool).and_return(true)
+        expect(redis).to receive(:srem).with('vmpooler__pool__undo_size_override', pool).and_return(true)
+      end
+
+      subject.undo_override(config[:pools][0], provider)
+    end
+  end
+
+  describe '#create_inventory' do
+
+    it 'should log an error if one occurs' do
+      allow(provider).to receive(:vms_in_pool).and_raise(
+        RuntimeError,'Mock Error'
+      )
+
+      expect {
+        subject.create_inventory(config[:pools].first, provider, {})
+      }.to raise_error(RuntimeError, 'Mock Error')
+    end
+  end
+
+  describe '#check_running_pool_vms' do
+    let(:pool_object) { config[:pools][0] }
+    let(:pool_check_response) {
+      {:checked_running_vms => 0}
+    }
+    context 'Running VM not in the inventory' do
+      let(:inventory) {
+        # mock response from create_inventory
+        {}
+      }
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          create_running_vm(pool,vm,redis,token)
+        end
+      end
+
+      it 'should not call check_running_vm' do
+        expect(subject).to receive(:check_running_vm).exactly(0).times
+
+        subject.check_running_pool_vms(pool, provider, pool_check_response, inventory)
+      end
+
+      it 'should move the VM to completed queue' do
+        redis_connection_pool.with do |redis|
+          expect(subject).to receive(:move_vm_queue).with(pool,vm,'running','completed',redis,String).and_call_original
+        end
+
+        subject.check_running_pool_vms(pool,provider, pool_check_response, inventory)
+      end
+    end
+
+    context 'Running VM in the inventory' do
+      let(:provider) { double('provider') }
+      let(:inventory) {
+        # mock response from create_inventory
+        { vm => 1 }
+      }
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          allow(subject).to receive(:check_running_vm)
+          create_running_vm(pool,vm,redis,token)
+        end
+      end
+
+      it 'should log an error if one occurs' do
+        expect(subject).to receive(:check_running_vm).and_raise(RuntimeError,'MockError')
+        expect(logger).to receive(:log).with('d', "[!] [#{pool}] _check_pool with an error while evaluating running VMs: MockError")
+
+        subject.check_running_pool_vms(pool, provider, pool_check_response, inventory)
+      end
+
+      it 'should return the number of checked running VMs' do
+        subject.check_running_pool_vms(pool, provider, pool_check_response, inventory)
+
+        expect(pool_check_response[:checked_running_vms]).to be(1)
+      end
+
+      it 'should use the VM lifetime in preference to defaults' do
+        big_lifetime = 2000
+        redis_connection_pool.with do |redis|
+          redis.hset("vmpooler__vm__#{vm}", 'lifetime',big_lifetime)
+        end
+        # The lifetime comes in as string
+        expect(subject).to receive(:check_running_vm).with(vm,pool,"#{big_lifetime}",provider)
+
+        subject.check_running_pool_vms(pool, provider, pool_check_response, inventory)
+      end
+
+      it 'should use the configuration default if the VM lifetime is not set' do
+        config[:config]['vm_lifetime'] = 50
+        expect(subject).to receive(:check_running_vm).with(vm,pool,50,provider)
+
+        subject.check_running_pool_vms(pool, provider, pool_check_response, inventory)
+      end
+
+      it 'should use a lifetime of 12 if nothing is set' do
+        expect(subject).to receive(:check_running_vm).with(vm,pool,12,provider)
+
+        subject.check_running_pool_vms(pool, provider, pool_check_response, inventory)
+      end
+    end
+  end
+
+  describe '#check_ready_pool_vms' do
+    let(:provider) { double('provider') }
+    let(:pool_ttl) { 5 }
+    let(:pool_check_response) {
+      {:checked_ready_vms => 0}
+    }
+
+    context 'Ready VM not in the inventory' do
+      let(:inventory) {
+        # mock response from create_inventory
+        {}
+      }
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          create_ready_vm(pool,vm,redis,token)
+        end
+      end
+
+      it 'should not call check_ready_vm' do
+        expect(subject).to receive(:check_ready_vm).exactly(0).times
+
+        subject.check_ready_pool_vms(pool, provider, pool_check_response, inventory, pool_ttl)
+      end
+
+      it 'should move the VM to completed queue' do
+        redis_connection_pool.with do |redis|
+          expect(subject).to receive(:move_vm_queue).with(pool,vm,'ready','completed',redis,String).and_call_original
+        end
+
+        subject.check_ready_pool_vms(pool, provider, pool_check_response, inventory, pool_ttl)
+      end
+    end
+
+    context 'Ready VM in the inventory' do
+      let(:inventory) {
+        # mock response from create_inventory
+        {vm => 1}
+      }
+      let(:big_lifetime) { 2000 }
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          allow(subject).to receive(:check_ready_vm)
+          create_ready_vm(pool,vm,redis,token)
+        end
+      end
+
+      it 'should return the number of checked ready VMs' do
+        subject.check_ready_pool_vms(pool, provider, pool_check_response, inventory, pool_ttl)
+
+        expect(pool_check_response[:checked_ready_vms]).to be(1)
+      end
+
+      it 'should log an error if one occurs' do
+        expect(subject).to receive(:check_ready_vm).and_raise(RuntimeError,'MockError')
+        expect(logger).to receive(:log).with('d', "[!] [#{pool}] _check_pool failed with an error while evaluating ready VMs: MockError")
+
+        subject.check_ready_pool_vms(pool, provider, pool_check_response, inventory, big_lifetime)
+      end
+
+      it 'should use the pool TTL if set' do
+        expect(subject).to receive(:check_ready_vm).with(vm,pool,big_lifetime,provider)
+
+        subject.check_ready_pool_vms(pool, provider, pool_check_response, inventory, big_lifetime)
+      end
+
+      it 'should use a pool TTL of zero if none set' do
+        expect(subject).to receive(:check_ready_vm).with(vm,pool,pool_ttl,provider)
+
+        subject.check_ready_pool_vms(pool, provider, pool_check_response, inventory, pool_ttl)
+      end
+    end
+  end
+
+  describe '#check_pending_pool_vms' do
+    let(:provider) { double('provider') }
+    let(:timeout) { 10 }
+    let(:pool_check_response) {
+      {:checked_pending_vms => 0}
+    }
+
+    context 'Pending VM not in the inventory' do
+      let(:inventory) {
+        # mock response from create_inventory
+        {}
+      }
+
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          create_pending_vm(pool,vm,redis,token)
+        end
+      end
+
+      it 'should call fail_pending_vm' do
+        redis_connection_pool.with do |redis|
+          expect(subject).to receive(:fail_pending_vm).with(vm, pool, Integer, redis, exists: false)
+        end
+
+        subject.check_pending_pool_vms(pool, provider, pool_check_response, inventory, timeout)
+      end
+    end
+
+    context 'Pending VM in the inventory' do
+      let(:inventory) {
+        # mock response from create_inventory
+        {vm => 1}
+      }
+
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          create_pending_vm(pool,vm,redis,token)
+        end
+      end
+
+      it 'should return the number of checked pending VMs' do
+        allow(subject).to receive(:check_pending_vm)
+        subject.check_pending_pool_vms(pool, provider, pool_check_response, inventory, timeout)
+
+        expect(pool_check_response[:checked_pending_vms]).to be(1)
+      end
+
+      it 'should log an error if one occurs' do
+        expect(subject).to receive(:check_pending_vm).and_raise(RuntimeError,'MockError')
+        expect(logger).to receive(:log).with('d', "[!] [#{pool}] _check_pool failed with an error while evaluating pending VMs: MockError")
+
+        subject.check_pending_pool_vms(pool, provider, pool_check_response, inventory, timeout)
+      end
+
+      it 'should use the pool timeout if set' do
+        big_lifetime = 2000
+
+        config[:pools][0]['timeout'] = big_lifetime
+        expect(subject).to receive(:check_pending_vm).with(vm,pool,big_lifetime,provider)
+
+        subject.check_pending_pool_vms(pool, provider, pool_check_response, inventory, big_lifetime)
+      end
+
+      it 'should use the configuration setting if the pool timeout is not set' do
+        big_lifetime = 2000
+
+        config[:config]['timeout'] = big_lifetime
+        expect(subject).to receive(:check_pending_vm).with(vm,pool,big_lifetime,provider)
+
+        subject.check_pending_pool_vms(pool, provider, pool_check_response, inventory, big_lifetime)
+      end
+
+      it 'should use a pool timeout of 15 if nothing is set' do
+        expect(subject).to receive(:check_pending_vm).with(vm,pool,timeout,provider)
+
+        subject.check_pending_pool_vms(pool, provider, pool_check_response, inventory, timeout)
+      end
+    end
+  end
+
+  describe '#check_completed_pool_vms' do
+    let(:provider) { double('provider') }
+    let(:pool_check_response) { {
+        :checked_completed_vms => 0,
+        :destroyed_vms => 0
+      }
+    }
+    context 'Completed VM not in the inventory' do
+      let(:inventory) {
+        # mock response from create_inventory
+        {}
+      }
+
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          create_completed_vm(vm,pool,redis,true)
+        end
+      end
+
+      it 'should log a message' do
+        subject.check_completed_pool_vms(pool, provider, pool_check_response, inventory)
+      end
+
+      it 'should not call destroy_vm' do
+        expect(subject).to receive(:destroy_vm).exactly(0).times
+
+        subject.check_completed_pool_vms(pool, provider, pool_check_response, inventory)
+      end
+
+      it 'should remove redis information' do
+        redis_connection_pool.with do |redis|
+          expect(redis.sismember("vmpooler__completed__#{pool}",vm)).to be(true)
+          expect(redis.hget("vmpooler__vm__#{vm}", 'checkout')).to_not be(nil)
+          expect(redis.hget("vmpooler__active__#{pool}",vm)).to_not be(nil)
+
+          subject.check_completed_pool_vms(pool, provider, pool_check_response, inventory)
+
+          expect(redis.sismember("vmpooler__completed__#{pool}",vm)).to be(false)
+          expect(redis.hget("vmpooler__vm__#{vm}", 'checkout')).to be(nil)
+          expect(redis.hget("vmpooler__active__#{pool}",vm)).to be(nil)
+        end
+      end
+    end
+
+    context 'Completed VM in the inventory' do
+      let(:inventory) {
+        # mock response from create_inventory
+        {vm => 1}
+      }
+
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          create_completed_vm(vm,pool,redis,true)
+        end
+      end
+
+      it 'should call destroy_vm' do
+        expect(subject).to receive(:destroy_vm)
+
+        subject.check_completed_pool_vms(pool, provider, pool_check_response, inventory)
+      end
+
+      it 'should return the number of destroyed VMs' do
+        subject.check_completed_pool_vms(pool, provider, pool_check_response, inventory)
+
+        expect(pool_check_response[:destroyed_vms]).to be(1)
+      end
+
+      context 'with an error during destroy_vm' do
+        before(:each) do
+          expect(subject).to receive(:destroy_vm).and_raise(RuntimeError,"MockError")
+          expect(logger).to receive(:log).with('d', "[!] [#{pool}] _check_pool failed with an error while evaluating completed VMs: MockError")
+        end
+
+        it 'should log a message' do
+          subject.check_completed_pool_vms(pool, provider, pool_check_response, inventory)
+        end
+
+        it 'should remove redis information' do
+          redis_connection_pool.with do |redis|
+            expect(redis.sismember("vmpooler__completed__#{pool}",vm)).to be(true)
+            expect(redis.hget("vmpooler__vm__#{vm}", 'checkout')).to_not be(nil)
+            expect(redis.hget("vmpooler__active__#{pool}",vm)).to_not be(nil)
+
+            subject.check_completed_pool_vms(pool, provider, pool_check_response, inventory)
+
+            expect(redis.sismember("vmpooler__completed__#{pool}",vm)).to be(false)
+            expect(redis.hget("vmpooler__vm__#{vm}", 'checkout')).to be(nil)
+            expect(redis.hget("vmpooler__active__#{pool}",vm)).to be(nil)
+          end
+        end
+      end
+    end
+  end
+
+  describe "#check_discovered_pool_vms" do
+    context 'Discovered VM' do
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          create_discovered_vm(vm,pool,redis)
+        end
+      end
+
+      it 'should be moved to the completed queue' do
+        subject.check_discovered_pool_vms(pool)
+
+        redis_connection_pool.with do |redis|
+          expect(redis.sismember("vmpooler__completed__#{pool}", vm)).to be(true)
+        end
+      end
+
+      it 'should log a message if an error occurs' do
+        redis_connection_pool.with do |redis|
+          expect(redis).to receive(:smove).with("vmpooler__discovered__#{pool}", "vmpooler__completed__#{pool}", vm).and_raise(RuntimeError,'MockError')
+        end
+        expect(logger).to receive(:log).with("d", "[!] [#{pool}] _check_pool failed with an error while evaluating discovered VMs: MockError")
+
+        subject.check_discovered_pool_vms(pool)
+      end
+
+      ['pending','ready','running','completed'].each do |queue_name|
+        context "exists in the #{queue_name} queue" do
+          before(:each) do
+            allow(subject).to receive(:migrate_vm)
+            allow(subject).to receive(:check_running_vm)
+            allow(subject).to receive(:check_ready_vm)
+            allow(subject).to receive(:check_pending_vm)
+            allow(subject).to receive(:destroy_vm)
+            allow(subject).to receive(:clone_vm)
+          end
+
+          it "should remain in the #{queue_name} queue" do
+            redis_connection_pool.with do |redis|
+              redis.sadd("vmpooler__#{queue_name}__#{pool}", vm)
+              allow(logger).to receive(:log)
+
+              subject.check_discovered_pool_vms(pool)
+
+              expect(redis.sismember("vmpooler__#{queue_name}__#{pool}", vm)).to be(true)
+            end
+          end
+
+          it "should be removed from the discovered queue" do
+            redis_connection_pool.with do |redis|
+              redis.sadd("vmpooler__#{queue_name}__#{pool}", vm)
+              allow(logger).to receive(:log)
+
+              expect(redis.sismember("vmpooler__discovered__#{pool}", vm)).to be(true)
+              subject.check_discovered_pool_vms(pool)
+              expect(redis.sismember("vmpooler__discovered__#{pool}", vm)).to be(false)
+            end
+          end
+
+          it "should log a message" do
+            redis_connection_pool.with do |redis|
+              redis.sadd("vmpooler__#{queue_name}__#{pool}", vm)
+            end
+            expect(logger).to receive(:log).with('d', "[!] [#{pool}] '#{vm}' found in '#{queue_name}', removed from 'discovered' queue")
+
+            subject.check_discovered_pool_vms(pool)
+          end
+        end
+      end
+    end
+  end
+
+  describe "#check_migrating_pool_vms" do
+    let(:provider) { double('provider') }
+    let(:pool_check_response) { {
+        :migrated_vms => 0
+      }
+    }
+
+    context 'Migrating VM not in the inventory' do
+      let(:inventory) {
+        # mock response from create_inventory
+        {}
+      }
+
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          create_migrating_vm(vm,pool,redis)
+        end
+      end
+
+      it 'should not do anything' do
+        expect(subject).to receive(:migrate_vm).exactly(0).times
+
+        subject.check_migrating_pool_vms(pool, provider, pool_check_response, inventory)
+      end
+    end
+
+    context 'Migrating VM in the inventory' do
+      let(:inventory) {
+        # mock response from create_inventory
+        {vm => 1}
+      }
+
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          create_migrating_vm(vm,pool,redis)
+        end
+      end
+
+      it 'should return the number of migrated VMs' do
+        allow(subject).to receive(:migrate_vm).with(vm,pool,provider)
+        subject.check_migrating_pool_vms(pool, provider, pool_check_response, inventory)
+
+        expect(pool_check_response[:migrated_vms]).to be(1)
+      end
+
+      it 'should log an error if one occurs' do
+        expect(subject).to receive(:migrate_vm).and_raise(RuntimeError,'MockError')
+        expect(logger).to receive(:log).with('s', "[x] [#{pool}] '#{vm}' failed to migrate: MockError")
+
+        subject.check_migrating_pool_vms(pool, provider, pool_check_response, inventory)
+      end
+
+      it 'should call migrate_vm' do
+        expect(subject).to receive(:migrate_vm).with(vm,pool,provider)
+
+        subject.check_migrating_pool_vms(pool, provider, pool_check_response, inventory)
+      end
+    end
+  end
+
+  describe '#repopulate_pool_vms' do
+    let(:pool_size) { 1 }
+    let(:config) {
+      YAML.load(<<-EOT
+---
+:config:
+  task_limit: 10
+EOT
+      )
+    }
+    let(:provider) { double('provider') }
+    let(:pool_check_response) {
+      {
+        :cloned_vms => 0
+      }
+    }
+
+    it 'should not call clone_vm when number of VMs is equal to the pool size' do
+      expect(subject).to receive(:clone_vm).exactly(0).times
+
+      subject.repopulate_pool_vms(pool, provider, pool_check_response, 0)
+    end
+
+    it 'should not call clone_vm when number of VMs is greater than the pool size' do
+      redis_connection_pool.with do |redis|
+        create_ready_vm(pool,vm,redis,token)
+      end
+      expect(subject).to receive(:clone_vm).exactly(0).times
+
+      subject.repopulate_pool_vms(pool, provider, pool_check_response, pool_size)
+    end
+
+    ['ready','pending'].each do |queue_name|
+      it "should use VMs in #{queue_name} queue to calculate pool size" do
+        expect(subject).to receive(:clone_vm).exactly(0).times
+        # Modify the pool size to 1 and add a VM in the queue
+        redis_connection_pool.with do |redis|
+          redis.sadd("vmpooler__#{queue_name}__#{pool}",vm)
+        end
+        pool_size = 1
+
+        subject.repopulate_pool_vms(pool, provider, pool_check_response, pool_size)
+      end
+    end
+
+    ['running','completed','discovered','migrating'].each do |queue_name|
+      it "should not use VMs in #{queue_name} queue to calculate pool size" do
+        expect(subject).to receive(:clone_vm)
+        # Modify the pool size to 1 and add a VM in the queue
+        redis_connection_pool.with do |redis|
+          redis.sadd("vmpooler__#{queue_name}__#{pool}",vm)
+        end
+        pool_size = 1
+
+        subject.repopulate_pool_vms(pool, provider, pool_check_response, pool_size)
+      end
+    end
+
+    it 'should log a message the first time a pool is empty' do
+      expect(logger).to receive(:log).with('s', "[!] [#{pool}] is empty")
+
+      subject.repopulate_pool_vms(pool, provider, pool_check_response, pool_size)
+    end
+
+    it 'should not log a message when the pool size is 0' do
+      expect(logger).to_not receive(:log).with('s', "[!] [#{pool}] is empty")
+
+      subject.repopulate_pool_vms(pool, provider, pool_check_response, 0)
+    end
+
+    context 'when pool is marked as empty' do
+
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          redis.set("vmpooler__empty__#{pool}", 'true')
+        end
+      end
+
+      it 'should not log a message when the pool remains empty' do
+        expect(logger).to receive(:log).with('s', "[!] [#{pool}] is empty").exactly(0).times
+
+        subject.repopulate_pool_vms(pool, provider, pool_check_response, pool_size)
+      end
+
+      it 'should remove the empty pool mark if it is no longer empty' do
+        redis_connection_pool.with do |redis|
+          create_ready_vm(pool,vm,redis,token)
+
+          expect(redis.get("vmpooler__empty__#{pool}")).to be_truthy
+          subject.repopulate_pool_vms(pool, provider, pool_check_response, pool_size)
+          expect(redis.get("vmpooler__empty__#{pool}")).to be_falsey
+        end
+      end
+    end
+
+    context 'when number of VMs is less than the pool size' do
+
+      it 'should return the number of cloned VMs' do
+        pool_size = 5
+
+        subject.repopulate_pool_vms(pool, provider, pool_check_response, pool_size)
+
+        expect(pool_check_response[:cloned_vms]).to be(pool_size)
+      end
+
+      it 'should call clone_vm to populate the pool' do
+        pool_size = 5
+
+        expect(subject).to receive(:clone_vm).exactly(pool_size).times
+
+        subject.repopulate_pool_vms(pool, provider, pool_check_response, pool_size)
+      end
+
+      it 'should call clone_vm until task_limit is hit' do
+        task_limit = 2
+        pool_size = 5
+        config[:config]['task_limit'] = task_limit
+
+        expect(subject).to receive(:clone_vm).exactly(task_limit).times
+
+        subject.repopulate_pool_vms(pool, provider, pool_check_response, pool_size)
+      end
+
+      it 'log a message if a cloning error occurs' do
+        redis_connection_pool.with do |redis|
+          create_ready_vm(pool,'vm',redis)
+        end
+        pool_size = 2
+
+        expect(subject).to receive(:clone_vm).and_raise(RuntimeError,"MockError")
+        expect(logger).to receive(:log).with("s", "[!] [#{pool}] clone failed during check_pool with an error: MockError")
+        expect{ subject.repopulate_pool_vms(pool, provider, pool_check_response, pool_size) }.to raise_error(RuntimeError,'MockError')
+
+      end
+    end
+
+    context 'when a pool template is updating' do
+      let(:poolsize) { 2 }
+      let(:mutex) { Mutex.new }
+      before(:each) do
+        expect(subject).to receive(:pool_mutex).with(pool).and_return(mutex)
+        mutex.lock
+      end
+
+      it 'should not call clone_vm to populate the pool' do
+        expect(subject).to_not receive(:clone_vm)
+
+        subject.repopulate_pool_vms(pool, provider, pool_check_response, poolsize)
+      end
+    end
+
+    context 'export metrics' do
+      it 'increments metrics for ready queue' do
+        redis_connection_pool.with do |redis|
+          create_ready_vm(pool,'vm1',redis)
+          create_ready_vm(pool,'vm2',redis)
+          create_ready_vm(pool,'vm3',redis)
+        end
+
+        expect(metrics).to receive(:gauge).with("ready.#{pool}", 3)
+        allow(metrics).to receive(:gauge)
+
+        subject.repopulate_pool_vms(pool, provider, pool_check_response, pool_size)
+      end
+
+      it 'increments metrics for running queue' do
+        redis_connection_pool.with do |redis|
+          create_running_vm(pool,'vm1',redis,token)
+          create_running_vm(pool,'vm2',redis,token)
+          create_running_vm(pool,'vm3',redis,token)
+        end
+
+        expect(metrics).to receive(:gauge).with("running.#{pool}", 3)
+        allow(metrics).to receive(:gauge)
+
+        subject.repopulate_pool_vms(pool, provider, pool_check_response, pool_size)
+      end
+
+      it 'increments metrics with 0 when pool empty' do
+
+        allow(metrics).to receive(:gauge)
+        expect(metrics).to receive(:gauge).with("ready.#{pool}", 0)
+        expect(metrics).to receive(:gauge).with("running.#{pool}", 0)
+
+        subject.repopulate_pool_vms(pool, provider, pool_check_response, pool_size)
+      end
+    end
+  end
+
+  describe '#_check_pool' do
+    let(:new_vm_response) {
+      # Mock response from Base Provider for vms_in_pool
+      [{ 'name' => new_vm}]
+    }
+    let(:vm_response) {
+      # Mock response from Base Provider for vms_in_pool
+      [{ 'name' => vm}]
+    }
+    let(:multi_vm_response) {
+      # Mock response from Base Provider for vms_in_pool
+      [{ 'name' => 'vm1'},
+       { 'name' => 'vm2'},
+       { 'name' => 'vm3'}]
+    }
+
+    # Default test fixtures will consist of;
+    #   - Empty Redis dataset
+    #   - A single pool with a pool size of zero i.e. no new VMs should be created
+    #   - Task limit of 10
+    let(:config) {
+      YAML.load(<<-EOT
+---
+:config:
+  task_limit: 10
+:pools:
+  - name: #{pool}
+    size: 10
+    ready_ttl: 1234
+    timeout: 5678
+EOT
+      )
+    }
+    let(:pool_object) { config[:pools][0] }
+    let(:new_vm) { 'newvm'}
+    let(:pool_name) { pool_object['name'] }
+    let(:mutex) { Mutex.new }
+
+    before do
+      expect(subject).not_to be_nil
+      allow(logger).to receive(:log)
+    end
+
+    # INVENTORY
+    context 'Conducting inventory' do
+      before(:each) do
+        allow(subject).to receive(:migrate_vm)
+        allow(subject).to receive(:check_running_vm)
+        allow(subject).to receive(:check_ready_vm)
+        allow(subject).to receive(:check_pending_vm)
+        allow(subject).to receive(:destroy_vm)
+        allow(subject).to receive(:clone_vm)
+        allow(provider).to receive(:vms_in_pool).with(pool).and_return(new_vm_response)
+      end
+
+      it 'calls inventory correctly' do
+        expect(subject).to receive(:create_inventory)
+        subject._check_pool(pool_object, provider)
+      end
+
+      it 'captures #create_inventory errors correctly' do
+        allow(subject).to receive(:create_inventory).and_raise(RuntimeError,'Mock Error')
+        subject._check_pool(pool_object, provider)
+      end
+
+      it 'should return early if an error occurs' do
+        allow(subject).to receive(:create_inventory).and_raise(
+          RuntimeError,'Mock Error'
+        )
+
+        expect(subject).to_not receive(:check_running_pool_vms)
+        subject._check_pool(pool_object, provider)
+      end
+
+      it 'should return that no actions were taken' do
+        expect(provider).to receive(:vms_in_pool).and_raise(RuntimeError,'Mock Error')
+
+        result = subject._check_pool(pool_object,provider)
+
+        expect(result[:discovered_vms]).to be(0)
+        expect(result[:checked_running_vms]).to be(0)
+        expect(result[:checked_ready_vms]).to be(0)
+        expect(result[:checked_pending_vms]).to be(0)
+        expect(result[:destroyed_vms]).to be(0)
+        expect(result[:migrated_vms]).to be(0)
+        expect(result[:cloned_vms]).to be(0)
+      end
+
+      it 'should log the discovery of VMs' do
+        expect(logger).to receive(:log).with('s', "[?] [#{pool}] '#{new_vm}' added to 'discovered' queue")
+
+        subject._check_pool(pool_object,provider)
+      end
+
+      it 'should return the number of discovered VMs' do
+        result = subject._check_pool(pool_object,provider)
+
+        expect(result[:discovered_vms]).to be(1)
+      end
+
+      it 'should add undiscovered VMs to the completed queue' do
+        redis_connection_pool.with do |redis|
+          allow(logger).to receive(:log).with('s', "[?] [#{pool}] '#{new_vm}' added to 'discovered' queue")
+
+          expect(redis.sismember("vmpooler__discovered__#{pool}", new_vm)).to be(false)
+          expect(redis.sismember("vmpooler__completed__#{pool}", new_vm)).to be(false)
+
+          subject._check_pool(pool_object,provider)
+
+          expect(redis.sismember("vmpooler__discovered__#{pool}", new_vm)).to be(false)
+          expect(redis.sismember("vmpooler__completed__#{pool}", new_vm)).to be(true)
+        end
+      end
+
+      ['running','ready','pending','completed','discovered','migrating'].each do |queue_name|
+        it "should not discover VMs in the #{queue_name} queue" do
+          redis_connection_pool.with do |redis|
+            expect(logger).to receive(:log).with('s', "[?] [#{pool}] '#{new_vm}' added to 'discovered' queue").exactly(0).times
+            expect(redis.sismember("vmpooler__discovered__#{pool}", new_vm)).to be(false)
+            redis.sadd("vmpooler__#{queue_name}__#{pool}", new_vm)
+
+            subject._check_pool(pool_object,provider)
+
+            if queue_name == 'discovered'
+              # Discovered VMs end up in the completed queue
+              expect(redis.sismember("vmpooler__completed__#{pool}", new_vm)).to be(true)
+            else
+              expect(redis.sismember("vmpooler__#{queue_name}__#{pool}", new_vm)).to be(true)
+            end
+          end
+        end
+      end
+
+      it 'should get the pool mutex' do
+        expect(subject).to receive(:pool_mutex).and_return(mutex).at_least(:once)
+
+        subject._check_pool(pool_object,provider)
+      end
+
+      it 'should run synchronize' do
+        expect(subject).to receive(:pool_mutex).and_return(mutex).at_least(:once)
+        expect(mutex).to receive(:synchronize).at_least(:once)
+
+        subject._check_pool(pool_object,provider)
+      end
+
+      it 'should yield when locked' do
+        expect(subject).to receive(:pool_mutex).and_return(mutex).at_least(:once)
+        mutex.lock
+        expect(mutex).to receive(:synchronize).and_yield
+
+        subject._check_pool(pool_object,provider)
+      end
+    end
+
+    # RUNNING
+    context 'when checking running VMs' do
+      let(:pool_check_response) {
+        {
+          discovered_vms: 0,
+          checked_running_vms: 0,
+          checked_ready_vms: 0,
+          checked_pending_vms: 0,
+          destroyed_vms: 0,
+          migrated_vms: 0,
+          cloned_vms: 0
+        }
+      }
+
+      it 'should call #check_running_pool_vms' do
+        allow(subject).to receive(:create_inventory).and_return({})
+        expect(subject).to receive(:check_running_pool_vms).with(pool, provider, pool_check_response, {})
+
+        subject._check_pool(pool_object,provider)
+      end
+    end
+
+    # READY
+    context 'when checking ready VMs' do
+      let(:pool_check_response) {
+        {
+          discovered_vms: 0,
+          checked_running_vms: 0,
+          checked_ready_vms: 0,
+          checked_pending_vms: 0,
+          destroyed_vms: 0,
+          migrated_vms: 0,
+          cloned_vms: 0
+        }
+      }
+
+      it 'should call #check_ready_pool_vms' do
+        allow(subject).to receive(:create_inventory).and_return({})
+        expect(subject).to receive(:check_ready_pool_vms).with(pool, provider, pool_check_response, {}, pool_object['ready_ttl'])
+
+        subject._check_pool(pool_object,provider)
+      end
+    end
+
+    # PENDING
+    context 'when checking ready VMs' do
+      let(:pool_check_response) {
+        {
+          discovered_vms: 0,
+          checked_running_vms: 0,
+          checked_ready_vms: 0,
+          checked_pending_vms: 0,
+          destroyed_vms: 0,
+          migrated_vms: 0,
+          cloned_vms: 0
+        }
+      }
+
+      it 'should call #check_ready_pool_vms' do
+        allow(subject).to receive(:create_inventory).and_return({})
+        expect(subject).to receive(:check_pending_pool_vms).with(pool, provider, pool_check_response, {}, pool_object['timeout'])
+
+        subject._check_pool(pool_object,provider)
+      end
+    end
+
+
+    # COMPLETED
+    context 'when checking completed VMs' do
+      let(:pool_check_response) {
+        {
+            discovered_vms: 0,
+            checked_running_vms: 0,
+            checked_ready_vms: 0,
+            checked_pending_vms: 0,
+            destroyed_vms: 0,
+            migrated_vms: 0,
+            cloned_vms: 0
+        }
+      }
+
+      it 'should call #check_completed_pool_vms' do
+        allow(subject).to receive(:create_inventory).and_return({})
+        expect(subject).to receive(:check_completed_pool_vms).with(pool, provider, pool_check_response, {})
+
+        subject._check_pool(pool_object,provider)
+      end
+    end
+
+    # DISCOVERED
+    context 'when checking discovered VMs' do
+      let(:pool_check_response) {
+        {
+            discovered_vms: 0,
+            checked_running_vms: 0,
+            checked_ready_vms: 0,
+            checked_pending_vms: 0,
+            destroyed_vms: 0,
+            migrated_vms: 0,
+            cloned_vms: 0
+        }
+      }
+
+      it 'should call #check_discovered_pool_vms' do
+        allow(subject).to receive(:create_inventory).and_return({})
+        expect(subject).to receive(:check_discovered_pool_vms).with(pool)
+
+        subject._check_pool(pool_object,provider)
+      end
+    end
+
+    # MIGRATIONS
+    context 'when checking migrating VMs' do
+      let(:pool_check_response) {
+        {
+          discovered_vms: 0,
+          checked_running_vms: 0,
+          checked_ready_vms: 0,
+          checked_pending_vms: 0,
+          destroyed_vms: 0,
+          migrated_vms: 0,
+          cloned_vms: 0
+        }
+      }
+
+      it 'should call #check_migrating_pool_vms' do
+        allow(subject).to receive(:create_inventory).and_return({})
+        expect(subject).to receive(:check_migrating_pool_vms).with(pool, provider, pool_check_response, {})
+
+        subject._check_pool(pool_object,provider)
+      end
+    end
+
+    # update_pool_size
+    context 'when a pool size configuration change is detected' do
+      let(:poolsize) { 2 }
+      let(:newpoolsize) { 3 }
+      before(:each) do
+        config[:pools][0]['size'] = poolsize
+        redis_connection_pool.with do |redis|
+          redis.hset('vmpooler__config__poolsize', pool, newpoolsize)
+        end
+      end
+
+      it 'should change the pool size configuration' do
+        allow(subject).to receive(:create_inventory).and_return({})
+
+        expect(subject).to receive(:update_pool_size).and_call_original
+
+        subject._check_pool(config[:pools][0],provider)
+
+        expect(config[:pools][0]['size']).to be(newpoolsize)
+      end
+    end
+
+    #REPOPULATE
+    context 'when checking if pools need to be repopulated' do
+      let(:pool_check_response) { {
+        discovered_vms: 0,
+        checked_running_vms: 0,
+        checked_ready_vms: 0,
+        checked_pending_vms: 0,
+        destroyed_vms: 0,
+        migrated_vms: 0,
+        cloned_vms: 0
+      } }
+      it 'should call #repopulate_pool_vms' do
+        allow(subject).to receive(:create_inventory).and_return({})
+        expect(subject).to receive(:repopulate_pool_vms).with(pool, provider, pool_check_response, config[:pools][0]['size'])
+
+        subject._check_pool(pool_object, provider)
+      end
+    end
+
+    #remove_excess_vms
+    context 'when an excess number of ready vms exist' do
+
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          allow(redis).to receive(:scard)
+          expect(redis).to receive(:scard).with("vmpooler__ready__#{pool}").and_return(1)
+          expect(redis).to receive(:scard).with("vmpooler__pending__#{pool}").and_return(1)
+        end
+      end
+
+      it 'should call remove_excess_vms' do
+        allow(subject).to receive(:create_inventory).and_return({})
+        expect(subject).to receive(:remove_excess_vms).with(config[:pools][0])
+
+        subject._check_pool(config[:pools][0],provider)
+      end
+    end
+  end
+
+  describe 'process_ondemand_requests' do
+    context 'with no requests' do
+      it 'returns 0' do
+        result = subject.process_ondemand_requests
+        expect(result).to eq(0)
+      end
+
+      it 'runs process_ondemand_vms' do
+        redis_connection_pool.with do |redis|
+          expect(subject).to receive(:process_ondemand_vms).with(redis).and_return(0)
+          subject.process_ondemand_requests
+        end
+      end
+
+      it 'checks ready requests' do
+        redis_connection_pool.with do |redis|
+          expect(subject).to receive(:check_ondemand_requests_ready).with(redis).and_return(0)
+          subject.process_ondemand_requests
+        end
+      end
+    end
+
+    context 'with provisioning requests' do
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          redis.zadd('vmpooler__provisioning__request', current_time, request_id)
+        end
+      end
+
+      it 'returns the number of requests processed' do
+        result = subject.process_ondemand_requests
+        expect(result).to eq(1)
+      end
+
+      it 'runs create_ondemand_vms for each request' do
+        redis_connection_pool.with do |redis|
+          expect(subject).to receive(:create_ondemand_vms).with(request_id, redis)
+          subject.process_ondemand_requests
+        end
+      end
+    end
+  end
+
+  describe '#create_ondemand_vms' do
+    context 'when requested does not have corresponding data' do
+      it 'logs an error' do
+        redis_connection_pool.with do |redis|
+          expect(logger).to receive(:log).with('s', "Failed to find odrequest for request_id '1111'")
+          subject.create_ondemand_vms('1111', redis)
+        end
+      end
+    end
+
+    context 'with a request that has data' do
+      let(:request_string) { "#{pool}:#{pool}:1" }
+      before(:each) do
+        expect(Time).to receive(:now).and_return(current_time).at_least(:once)
+        redis_connection_pool.with do |redis|
+          create_ondemand_request_for_test(request_id, current_time.to_i, request_string, redis)
+        end
+      end
+
+      it 'creates tasks for instances to be provisioned' do
+        redis_connection_pool.with do |redis|
+          allow(redis).to receive(:zadd)
+          expect(redis).to receive(:zadd).with('vmpooler__odcreate__task', current_time.to_i, "#{request_string}:#{request_id}")
+          subject.create_ondemand_vms(request_id, redis)
+        end
+      end
+
+      it 'adds a member to provisioning__processing' do
+        redis_connection_pool.with do |redis|
+          allow(redis).to receive(:zadd)
+          expect(redis).to receive(:zadd).with('vmpooler__provisioning__processing', current_time.to_i, request_id)
+          subject.create_ondemand_vms(request_id, redis)
+        end
+      end
+    end
+  end
+
+  describe '#process_ondemand_vms' do
+    it 'returns the length of the queue' do
+      redis_connection_pool.with do |redis|
+        result = subject.process_ondemand_vms(redis)
+        expect(result).to eq(0)
+      end
+    end
+
+    context 'with a request to create a single vm' do
+      let(:request_string) { "#{pool}:#{pool}:1" }
+      let(:pool_alias) { pool }
+      before(:each) do
+        config[:config]['ondemand_clone_limit'] = 10
+        expect(subject).to receive(:get_provider_for_pool).and_return(provider)
+        redis_connection_pool.with do |redis|
+          create_ondemand_creationtask("#{request_string}:#{request_id}", current_time.to_i, redis)
+        end
+      end
+
+      it 'creates the vm' do
+        redis_connection_pool.with do |redis|
+          expect(subject).to receive(:clone_vm).with(pool, provider, request_id, pool_alias)
+          subject.process_ondemand_vms(redis)
+        end
+      end
+    end
+
+    context 'with a request to create more instances than the limit' do
+      let(:request_string) { "#{pool}:#{pool}:5" }
+      let(:request_string_remaining) { "#{pool}:#{pool}:2" }
+      let(:pool_alias) { pool }
+      before(:each) do
+        config[:config]['ondemand_clone_limit'] = 3
+        expect(subject).to receive(:get_provider_for_pool).and_return(provider)
+        redis_connection_pool.with do |redis|
+          create_ondemand_creationtask("#{request_string}:#{request_id}", current_time.to_i, redis)
+        end
+      end
+
+      it 'should create the maximum number of vms' do
+        redis_connection_pool.with do |redis|
+          expect(subject).to receive(:clone_vm).with(pool, provider, request_id, pool_alias).exactly(3).times
+          subject.process_ondemand_vms(redis)
+        end
+      end
+
+      it 'should add the remaining number back as a new create task with the same score' do
+        redis_connection_pool.with do |redis|
+          expect(redis).to receive(:zadd).with('vmpooler__odcreate__task', current_time.to_i, "#{request_string_remaining}:#{request_id}")
+          subject.process_ondemand_vms(redis)
+        end
+      end
+
+      it 'should return the number of requests processed' do
+        redis_connection_pool.with do |redis|
+          result = subject.process_ondemand_vms(redis)
+          expect(result).to eq(1)
+        end
+      end
+    end
+
+    context 'when the limit has been reached' do
+      let(:clone_count) { { 'ondemand_clone_count' => 3 } }
+      before(:each) do
+        config[:config]['ondemand_clone_limit'] = 3
+        subject.instance_variable_set(:@tasks, clone_count)
+      end
+
+      it 'does not create any instances' do
+        redis_connection_pool.with do |redis|
+          expect(subject).to_not receive(:clone_vm)
+          subject.process_ondemand_vms(redis)
+        end
+      end
+    end
+  end
+
+  describe '#vms_ready?' do
+    let(:request_string) { "#{pool}:#{pool}:5" }
+    let(:platform_alias) { pool }
+    before(:each) do
+      redis_connection_pool.with do |redis|
+        create_ondemand_request_for_test(request_id, current_time.to_i, request_string, redis)
+      end
+    end
+
+    it 'fails if the request is not valid' do
+      redis_connection_pool.with do |redis|
+        request_id = "#{request_id}-wrong"
+        create_ondemand_request_for_test(request_id, current_time.to_i, "#{pool}:5", redis)
+        expect{subject.vms_ready?(request_id, redis)}.to raise_error(ArgumentError)
+      end
+    end
+
+    it 'returns false when vms for request_id are not ready' do
+      redis_connection_pool.with do |redis|
+        result = subject.vms_ready?(request_id, redis)
+        expect(result).to be false
+      end
+    end
+
+    context 'with a request that has all instances ready' do
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          ['vm1','vm2','vm3','vm4','vm5'].each do |v|
+            redis.sadd("vmpooler__#{request_id}__#{platform_alias}__#{pool}", v)
+          end
+        end
+      end
+
+      it 'returns true' do
+        redis_connection_pool.with do |redis|
+          result = subject.vms_ready?(request_id, redis)
+          expect(result).to be true
+        end
+      end
+    end
+
+    context 'with a request that has some instances ready' do
+      let(:request_string) { "#{pool}:#{pool}:3,#{pool}2:#{pool}2:3" }
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          create_ondemand_request_for_test(request_id, current_time.to_i, request_string, redis)
+          ['vm1','vm2','vm3'].each do |v|
+            redis.sadd("vmpooler__#{request_id}__#{platform_alias}__#{pool}", v)
+          end
+        end
+      end
+
+      it 'returns false' do
+        redis_connection_pool.with do |redis|
+          result = subject.vms_ready?(request_id, redis)
+          expect(result).to be false
+        end
+      end
+    end
+  end
+
+  describe '#check_ondemand_requests_ready' do
+    before(:each) do
+      config[:config]['ondemand_request_ttl'] = 5
+    end
+
+    it 'returns 0 when no provisoning requests are in progress' do
+      redis_connection_pool.with do |redis|
+        result = subject.check_ondemand_requests_ready(redis)
+        expect(result).to eq(0)
+      end
+    end
+
+    context 'with requests in progress' do
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          create_ondemand_processing(request_id, current_time, redis)
+        end
+      end
+
+      it 'returns the number of requests processed' do
+        expect(subject).to receive(:vms_ready?).and_return(false)
+        redis_connection_pool.with do |redis|
+          result = subject.check_ondemand_requests_ready(redis)
+          expect(result).to eq(1)
+        end
+      end
+    end
+  end
+
+  describe '#check_ondemand_request_ready' do
+    let(:score) { current_time.to_f }
+    before(:each) do
+      config[:config]['ondemand_request_ttl'] = 5
+    end
+
+    context 'when the request is ready' do
+      before(:each) do
+        expect(subject).to receive(:vms_ready?).and_return(true)
+        redis_connection_pool.with do |redis|
+          expect(redis).to receive(:zscore).and_return(score)
+        end
+      end
+
+      it 'sets the request as ready' do
+        redis_connection_pool.with do |redis|
+          expect(redis).to receive(:hset).with("vmpooler__odrequest__#{request_id}", 'status', 'ready')
+          subject.check_ondemand_request_ready(request_id, redis)
+        end
+      end
+
+      it 'marks the ondemand request hash key for expiration in one month' do
+        redis_connection_pool.with do |redis|
+          expect(redis).to receive(:expire).with("vmpooler__odrequest__#{request_id}", 2592000)
+          subject.check_ondemand_request_ready(request_id, redis)
+        end
+      end
+
+      it 'removes the request from processing' do
+        redis_connection_pool.with do |redis|
+          expect(redis).to receive(:zrem).with('vmpooler__provisioning__processing', request_id)
+          subject.check_ondemand_request_ready(request_id, redis)
+        end
+      end
+    end
+
+    context 'with the score provided' do
+      it 'should not request the score' do
+        redis_connection_pool.with do |redis|
+          expect(redis).to_not receive(:zscore)
+          expect(subject).to receive(:vms_ready?).and_return(true)
+          expect(redis).to receive(:zrem).with('vmpooler__provisioning__processing', request_id)
+          subject.check_ondemand_request_ready(request_id, redis, score)
+        end
+      end
+    end
+
+    context 'when a request has taken too long to be filled' do
+      it 'should return true for request_expired?' do
+        redis_connection_pool.with do |redis|
+          expect(redis).to receive(:zscore).and_return(score)
+          expect(subject).to receive(:request_expired?).with(request_id, Float, redis).and_return(true)
+          subject.check_ondemand_request_ready(request_id, redis)
+        end
+      end
+    end
+  end
+
+  describe '#request_expired?' do
+    let(:ondemand_request_ttl) { 5 }
+    let(:expiration_ttl) { 10 }
+    before(:each) do
+      config[:config]['ondemand_request_ttl'] = ondemand_request_ttl
+      config[:redis]['data_ttl'] = expiration_ttl
+    end
+
+    context 'with a request that has taken too long to be filled' do
+      let(:expired_time) { (Time.now - 960).to_i }
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          expect(subject).to receive(:remove_vms_for_failed_request)
+          create_ondemand_processing(request_id, expired_time, redis)
+        end
+      end
+
+      it 'returns true when the request is expired' do
+        redis_connection_pool.with do |redis|
+          result = subject.request_expired?(request_id, expired_time, redis)
+          expect(result).to be true
+        end
+      end
+
+      it 'logs a message that the request has expired' do
+        redis_connection_pool.with do |redis|
+          expect(logger).to receive(:log).with('s', "Ondemand request for '#{request_id}' failed to provision all instances within the configured ttl '#{ondemand_request_ttl}'")
+          subject.request_expired?(request_id, expired_time, redis)
+        end
+      end
+
+      it 'removes the request from processing requests' do
+        redis_connection_pool.with do |redis|
+          expect(redis).to receive(:zrem).with('vmpooler__provisioning__processing', request_id)
+          subject.request_expired?(request_id, expired_time, redis)
+        end
+      end
+
+      it 'sets the status as failed on the request hash' do
+        redis_connection_pool.with do |redis|
+          expect(redis).to receive(:hset).with("vmpooler__odrequest__#{request_id}", 'status', 'failed')
+          subject.request_expired?(request_id, expired_time, redis)
+        end
+      end
+
+      it 'marks the request hash for expiration' do
+        redis_connection_pool.with do |redis|
+          expect(redis).to receive(:expire).with("vmpooler__odrequest__#{request_id}", expiration_ttl * 60 * 60)
+          subject.request_expired?(request_id, expired_time, redis)
+        end
+      end
+    end
+
+    context 'with a request that has been made within the ttl' do
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          create_ondemand_processing(request_id, current_time, redis)
+        end
+      end
+
+      it 'should return false' do
+        redis_connection_pool.with do |redis|
+          result = subject.request_expired?(request_id, current_time, redis)
+          expect(result).to be false
+        end
+      end
+    end
+  end
+
+  describe '#remove_vms_for_failed_request)' do
+    let(:expiration_ttl) { 100 * 60 * 60 }
+    let(:platform_alias) { pool }
+    let(:platforms_string) { "#{platform_alias}:#{pool}:3" }
+    context 'with two vms marked as ready for the request' do
+      before(:each) do
+        redis_connection_pool.with do |redis|
+          create_ondemand_request_for_test(request_id, current_time, platforms_string, redis)
+          [vm,"#{vm}2"].each do |v|
+            create_running_vm(pool, v, redis)
+            redis.sadd("vmpooler__#{request_id}__#{platform_alias}__#{pool}", v)
+          end
+        end
+      end
+
+      it 'should remove the associated vms' do
+        redis_connection_pool.with do |redis|
+          expect(subject).to receive(:move_vm_queue).with(pool, String, 'running', 'completed', redis, "moved to completed queue. '#{request_id}' could not be filled in time").twice
+          subject.remove_vms_for_failed_request(request_id, expiration_ttl, redis)
+        end
+      end
+
+      it 'should mark the ready set for expiration' do
+        redis_connection_pool.with do |redis|
+          expect(redis).to receive(:expire).with("vmpooler__#{request_id}__#{platform_alias}__#{pool}", expiration_ttl)
+          subject.remove_vms_for_failed_request(request_id, expiration_ttl, redis)
+        end
+      end
+    end
+  end
+
+  describe 'check_ondemand_requests' do
+    let(:threads) {[]}
+    let(:maxloop) { 0 }
+    let(:loop_delay_min) { 5 }
+    let(:loop_delay_max) { 60 }
+    let(:loop_delay_decay) { 2.0 }
+
+    before(:each) do
+      expect(Thread).to receive(:new).and_yield
+    end
+
+    it 'should log the ondemand provisioner is starting' do
+      expect(subject).to receive(:_check_ondemand_requests).with(maxloop, loop_delay_min, loop_delay_max, loop_delay_decay)
+      expect(logger).to receive(:log).with('d', "[*] [ondemand_provisioner] starting worker thread")
+
+      expect($threads.count).to be(0)
+      subject.check_ondemand_requests
+      expect($threads.count).to be(1)
+    end
+
+    context' delays between loops' do
+      let(:maxloop) { 2 }
+      let(:loop_delay) { 1 }
+
+      it 'when a non-default loop delay is specified' do
+        expect(subject).to receive(:sleep_with_wakeup_events).with(loop_delay, Numeric, Hash).exactly(maxloop).times
+
+        subject.check_ondemand_requests(maxloop,loop_delay,loop_delay)
+      end
+    end
+
+    context 'delays between loops with a specified min and max value' do
+      let(:maxloop) { 5 }
+      let(:loop_delay_min) { 1 }
+      let(:loop_delay_max) { 60 }
+      let(:loop_decay) { 3.0 }
+
+      it 'delay values increase with a decay' do
+        expect(subject).to receive(:sleep_with_wakeup_events).with(3, Numeric, Hash).once
+        expect(subject).to receive(:sleep_with_wakeup_events).with(9, Numeric, Hash).once
+        expect(subject).to receive(:sleep_with_wakeup_events).with(27, Numeric, Hash).once
+        expect(subject).to receive(:sleep_with_wakeup_events).with(60, Numeric, Hash).twice
+
+        subject.check_ondemand_requests(maxloop,loop_delay_min,loop_delay_max,loop_decay)
+      end
+    end
+
+    context 'loops specified number of times (5)' do
+      let(:maxloop) { 5 }
+
+      it 'should run startup tasks only once' do
+        expect(logger).to receive(:log).with('d', "[*] [ondemand_provisioner] starting worker thread")
+
+        subject.check_ondemand_requests(maxloop,0)
+      end
+
+      it 'should run per thread tasks 5 times' do
+        expect(subject).to receive(:process_ondemand_requests).and_return(0).exactly(maxloop).times
+
+        subject.check_ondemand_requests(maxloop,0)
+      end
+    end
+  end
+end
diff --git a/spec/unit/providers/vsphere_spec.rb b/spec/unit/providers/vsphere_spec.rb
new file mode 100644
index 0000000..b05457c
--- /dev/null
+++ b/spec/unit/providers/vsphere_spec.rb
@@ -0,0 +1,3599 @@
+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'
+    provider: 'vsphere'
+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}'
+    provider: 'vsphere'
+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}'
+    provider: 'vsphere'
+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}'
+    provider: 'vsphere'
+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}'
+    provider: 'vsphere'
+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}'
+    provider: 'vsphere'
+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}'
+    provider: 'vsphere'
+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}'
+    provider: 'vsphere'
+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}'
+    provider: 'vsphere'
+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}'
+    provider: 'vsphere'
+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/vmpooler-vsphere-provider.gemspec b/vmpooler-vsphere-provider.gemspec
new file mode 100644
index 0000000..dc48dd3
--- /dev/null
+++ b/vmpooler-vsphere-provider.gemspec
@@ -0,0 +1,32 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'vmpooler-vsphere-provider/version'
+
+Gem::Specification.new do |s|
+  s.name          = 'vmpooler-vsphere-provider'
+  s.version       = VmpoolerVsphereProvider::VERSION
+  s.authors       = ['Puppet']
+  s.email         = ['support@puppet.com']
+
+  s.summary       = 'VMware provider for VMPooler'
+  s.homepage      = 'https://github.com/puppetlabs/vmpooler-provider-vsphere'
+  s.license       = 'Apache-2.0'
+  s.required_ruby_version = Gem::Requirement.new('>= 2.3.0')
+
+  s.files         = Dir[ "lib/**/*" ]
+  s.require_paths = ["lib"]
+  s.add_dependency 'rbvmomi', '>= 2.1', '< 4.0'
+  
+  s.add_development_dependency 'vmpooler', '~> 1.3', '>= 1.3.0'
+
+  # Testing dependencies
+  s.add_development_dependency 'climate_control', '>= 0.2.0'
+  s.add_development_dependency 'mock_redis', '>= 0.17.0'
+  s.add_development_dependency 'pry'
+  s.add_development_dependency 'rack-test', '>= 0.6'
+  s.add_development_dependency 'rspec', '>= 3.2'
+  s.add_development_dependency 'rubocop', '~> 1.1.0'
+  s.add_development_dependency 'simplecov', '>= 0.11.2'
+  s.add_development_dependency 'thor', '~> 1.0', '>= 1.0.1'
+  s.add_development_dependency 'yarjuf', '>= 2.0'
+end