From a08cba099f867b1db01a50940ec3ae9239245db5 Mon Sep 17 00:00:00 2001
From: Gene Liverman <gene.liverman+06301990@puppet.com>
Date: Mon, 29 Nov 2021 15:14:42 -0500
Subject: [PATCH] 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.
---
 .github/dependabot.yml                   |    8 +
 .github/workflows/testing.yml            |   47 +
 .gitignore                               |   10 +
 CODEOWNERS                               |   10 +
 Gemfile                                  |   13 +
 Gemfile.lock                             |  191 +
 README.md                                |    3 +
 Rakefile                                 |   25 +
 lib/vmpooler-vsphere-provider/version.rb |    5 +
 lib/vmpooler/providers/vsphere.rb        | 1173 +++++
 scripts/create_template_deltas.rb        |   98 +
 spec/fixtures/vmpooler.yaml              |   43 +
 spec/fixtures/vmpooler2.yaml             |   43 +
 spec/helpers.rb                          |  154 +
 spec/rbvmomi_helper.rb                   |  922 ++++
 spec/spec_helper.rb                      |   19 +
 spec/unit/pool_manager_spec.rb           | 5027 ++++++++++++++++++++++
 spec/unit/providers/vsphere_spec.rb      | 3599 ++++++++++++++++
 vmpooler-vsphere-provider.gemspec        |   32 +
 19 files changed, 11422 insertions(+)
 create mode 100644 .github/dependabot.yml
 create mode 100644 .github/workflows/testing.yml
 create mode 100644 .gitignore
 create mode 100644 CODEOWNERS
 create mode 100644 Gemfile
 create mode 100644 Gemfile.lock
 create mode 100644 README.md
 create mode 100644 Rakefile
 create mode 100644 lib/vmpooler-vsphere-provider/version.rb
 create mode 100644 lib/vmpooler/providers/vsphere.rb
 create mode 100755 scripts/create_template_deltas.rb
 create mode 100644 spec/fixtures/vmpooler.yaml
 create mode 100644 spec/fixtures/vmpooler2.yaml
 create mode 100644 spec/helpers.rb
 create mode 100644 spec/rbvmomi_helper.rb
 create mode 100644 spec/spec_helper.rb
 create mode 100644 spec/unit/pool_manager_spec.rb
 create mode 100644 spec/unit/providers/vsphere_spec.rb
 create mode 100644 vmpooler-vsphere-provider.gemspec

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