diff --git a/bin/vmpooler b/bin/vmpooler
index f053651..69565aa 100755
--- a/bin/vmpooler
+++ b/bin/vmpooler
@@ -38,7 +38,7 @@ if torun.include? 'manager'
     Vmpooler::PoolManager.new(
       config,
       Vmpooler.new_logger(logger_file),
-      Vmpooler.redis_connection_pool(redis_host, redis_port, redis_password, redis_connection_pool_size, redis_connection_pool_timeout),
+      Vmpooler.redis_connection_pool(redis_host, redis_port, redis_password, redis_connection_pool_size, redis_connection_pool_timeout, metrics),
       metrics
     ).execute!
   end
diff --git a/lib/vmpooler.rb b/lib/vmpooler.rb
index ca87d4a..ffcfcd8 100644
--- a/lib/vmpooler.rb
+++ b/lib/vmpooler.rb
@@ -160,9 +160,16 @@ module Vmpooler
     pools
   end
 
-  def self.redis_connection_pool(host, port, password, size, timeout)
-    ConnectionPool.new(size: size, timeout: timeout) {
-      redis_connection(host, port, password)
+  def self.redis_connection_pool(host, port, password, size, timeout, metrics)
+    Vmpooler::PoolManager::GenericConnectionPool.new(
+      metrics: metrics,
+      metric_prefix: 'redis_connection_pool',
+      size: size,
+      timeout: timeout
+    ) {
+      connection = Concurrent::Hash.new
+      redis = redis_connection(host, port, password)
+      connection['connection'] = redis
     }
   end
 
diff --git a/lib/vmpooler/generic_connection_pool.rb b/lib/vmpooler/generic_connection_pool.rb
index 6ae916b..9e9fc0c 100644
--- a/lib/vmpooler/generic_connection_pool.rb
+++ b/lib/vmpooler/generic_connection_pool.rb
@@ -15,35 +15,17 @@ module Vmpooler
         @metric_prefix = 'connectionpool' if @metric_prefix.nil? || @metric_prefix == ''
       end
 
-      if Thread.respond_to?(:handle_interrupt)
-        # MRI
-        def with_metrics(options = {})
-          Thread.handle_interrupt(Exception => :never) do
-            start = Time.now
-            conn = checkout(options)
-            timespan_ms = ((Time.now - start) * 1000).to_i
-            @metrics&.gauge(@metric_prefix + '.available', @available.length)
-            @metrics&.timing(@metric_prefix + '.waited', timespan_ms)
-            begin
-              Thread.handle_interrupt(Exception => :immediate) do
-                yield conn
-              end
-            ensure
-              checkin
-              @metrics&.gauge(@metric_prefix + '.available', @available.length)
-            end
-          end
-        end
-      else
-        # jruby 1.7.x
-        def with_metrics(options = {})
+      def with_metrics(options = {})
+        Thread.handle_interrupt(Exception => :never) do
           start = Time.now
           conn = checkout(options)
           timespan_ms = ((Time.now - start) * 1000).to_i
           @metrics&.gauge(@metric_prefix + '.available', @available.length)
           @metrics&.timing(@metric_prefix + '.waited', timespan_ms)
           begin
-            yield conn
+            Thread.handle_interrupt(Exception => :immediate) do
+              yield conn
+            end
           ensure
             checkin
             @metrics&.gauge(@metric_prefix + '.available', @available.length)
diff --git a/lib/vmpooler/pool_manager.rb b/lib/vmpooler/pool_manager.rb
index 5bb72f8..7ea69c8 100644
--- a/lib/vmpooler/pool_manager.rb
+++ b/lib/vmpooler/pool_manager.rb
@@ -48,7 +48,7 @@ module Vmpooler
 
     # Place pool configuration in redis so an API instance can discover running pool configuration
     def load_pools_to_redis
-      @redis.with do |redis|
+      @redis.with_metrics do |redis|
         previously_configured_pools = redis.smembers('vmpooler__pools')
         currently_configured_pools = []
         config[:pools].each do |pool|
@@ -80,7 +80,7 @@ module Vmpooler
           _check_pending_vm(vm, pool, timeout, provider)
         rescue StandardError => e
           $logger.log('s', "[!] [#{pool}] '#{vm}' #{timeout} #{provider} errored while checking a pending vm : #{e}")
-          @redis.with do |redis|
+          @redis.with_metrics do |redis|
             request_id = redis.hget("vmpooler__vm__#{vm}", 'request_id')
             fail_pending_vm(vm, pool, timeout, redis, request_id=request_id)
           end
@@ -94,10 +94,10 @@ module Vmpooler
       return if mutex.locked?
 
       mutex.synchronize do
-        @redis.with do |redis|
+        @redis.with_metrics do |redis|
           request_id = redis.hget("vmpooler__vm__#{vm}", 'request_id')
           if provider.vm_ready?(pool, vm)
-            move_pending_vm_to_ready(vm, pool, request_id, redis)
+            move_pending_vm_to_ready(vm, pool, redis, request_id)
           else
             fail_pending_vm(vm, pool, timeout, redis, request_id = request_id)
           end
@@ -138,13 +138,8 @@ module Vmpooler
       false
     end
 
-    def move_pending_vm_to_ready(vm, pool, request_id, redis)
+    def move_pending_vm_to_ready(vm, pool, redis, request_id = nil)
       clone_time = redis.hget('vmpooler__vm__' + vm, 'clone')
-    # return false unless clone_time
-    # if clone_time == 'QUEUED'
-    #   $logger.log('s', "Waiting for clone_time. Got 'QUEUED'.")
-    #   return false
-    # end
       finish = format('%<time>.2f', time: Time.now - Time.parse(clone_time))
 
       if request_id
@@ -198,7 +193,7 @@ module Vmpooler
       return if mutex.locked?
 
       mutex.synchronize do
-        @redis.with do |redis|
+        @redis.with_metrics do |redis|
           check_stamp = redis.hget('vmpooler__vm__' + vm, 'check')
           return if check_stamp && (((Time.now - Time.parse(check_stamp)) / 60) <= $config[:config]['vm_checktime'])
 
@@ -220,7 +215,7 @@ module Vmpooler
             end
           end
 
-          return if mismatched_hostname?(vm, pool_name, provider)
+          return if mismatched_hostname?(vm, pool_name, provider, redis)
 
           vm_still_ready?(pool_name, vm, provider, redis)
         end
@@ -274,7 +269,7 @@ module Vmpooler
       return if mutex.locked?
 
       mutex.synchronize do
-        @redis.with do |redis|
+        @redis.with_metrics do |redis|
           # Check that VM is within defined lifetime
           checkouttime = redis.hget('vmpooler__active__' + pool, vm)
       #   return if checkouttime == 'QUEUED'
@@ -320,7 +315,7 @@ module Vmpooler
         rescue StandardError => e
           if request_id
             $logger.log('s', "[!] [#{pool_name}] failed while cloning VM for request #{request_id} with an error: #{e}")
-            @redis.with do |redis|
+            @redis.with_metrics do |redis|
               redis.zadd('vmpooler__odcreate__task', 1, "#{pool_alias}:#{pool_name}:1:#{request_id}")
             end
           else
@@ -367,7 +362,7 @@ module Vmpooler
     end
 
     def _clone_vm(pool_name, provider, request_id = nil, pool_alias = nil)
-      @redis.with do |redis|
+      @redis.with_metrics do |redis|
         new_vmname = find_unique_hostname(pool_name, redis)
         mutex = vm_mutex(new_vmname)
         mutex.synchronize do
@@ -430,7 +425,7 @@ module Vmpooler
       return if mutex.locked?
 
       mutex.synchronize do
-        @redis.with do |redis|
+        @redis.with_metrics do |redis|
           redis.hdel('vmpooler__active__' + pool, vm)
           redis.hset('vmpooler__vm__' + vm, 'destroy', Time.now)
 
@@ -581,7 +576,7 @@ module Vmpooler
       finish = format('%<time>.2f', time: Time.now - start)
 
       if result
-        @redis.with do |redis|
+        @redis.with_metrics do |redis|
           rdisks = redis.hget('vmpooler__vm__' + vm_name, 'disk')
           disks = rdisks ? rdisks.split(':') : []
           disks.push("+#{disk_size}gb")
@@ -616,7 +611,7 @@ module Vmpooler
       finish = format('%<time>.2f', time: Time.now - start)
 
       if result
-        @redis.with do |redis|
+        @redis.with_metrics do |redis|
           redis.hset('vmpooler__vm__' + vm_name, 'snapshot:' + snapshot_name, Time.now.to_s)
         end
         $logger.log('s', "[+] [snapshot_manager] '#{vm_name}' snapshot created in #{finish} seconds")
@@ -708,7 +703,7 @@ module Vmpooler
     end
 
     def _check_disk_queue
-      @redis.with do |redis|
+      @redis.with_metrics do |redis|
         task_detail = redis.spop('vmpooler__tasks__disk')
         unless task_detail.nil?
           begin
@@ -746,7 +741,7 @@ module Vmpooler
     end
 
     def _check_snapshot_queue
-      @redis.with do |redis|
+      @redis.with_metrics do |redis|
         task_detail = redis.spop('vmpooler__tasks__snapshot')
 
         unless task_detail.nil?
@@ -788,7 +783,7 @@ module Vmpooler
         begin
           mutex = vm_mutex(vm_name)
           mutex.synchronize do
-            @redis.with do |redis|
+            @redis.with_metrics do |redis|
               redis.srem("vmpooler__migrating__#{pool_name}", vm_name)
             end
             provider.migrate_vm(pool_name, vm_name)
@@ -823,7 +818,7 @@ module Vmpooler
       wakeup_by = Time.now + wakeup_period
       return if time_passed?(:exit_by, exit_by)
 
-      @redis.with do |redis|
+      @redis.with_metrics do |redis|
         initial_ready_size = redis.scard("vmpooler__ready__#{options[:poolname]}") if options[:pool_size_change]
 
         initial_clone_target = redis.hget("vmpooler__pool__#{options[:poolname]}", options[:clone_target]) if options[:clone_target_change]
@@ -942,7 +937,7 @@ module Vmpooler
     end
 
     def sync_pool_template(pool)
-      @redis.with do |redis|
+      @redis.with_metrics do |redis|
         pool_template = redis.hget('vmpooler__config__template', pool['name'])
         if pool_template
           pool['template'] = pool_template unless pool['template'] == pool_template
@@ -966,7 +961,7 @@ module Vmpooler
 
     def evaluate_template(pool, provider)
       mutex = pool_mutex(pool['name'])
-      @redis.with do |redis|
+      @redis.with_metrics do |redis|
         prepared_template = redis.hget('vmpooler__template__prepared', pool['name'])
         configured_template = redis.hget('vmpooler__config__template', pool['name'])
         return if mutex.locked?
@@ -1013,10 +1008,10 @@ module Vmpooler
       pool['template'] = configured_template
       $logger.log('s', "[*] [#{pool['name']}] template updated from #{prepared_template} to #{configured_template}")
       # Remove all ready and pending VMs so new instances are created from the new template
-      drain_pool(pool['name'])
+      drain_pool(pool['name'], redis)
       # Prepare template for deployment
       $logger.log('s', "[*] [#{pool['name']}] preparing pool template for deployment")
-      prepare_template(pool, provider)
+      prepare_template(pool, provider, redis)
       $logger.log('s', "[*] [#{pool['name']}] is ready for use")
     end
 
@@ -1024,7 +1019,7 @@ module Vmpooler
       mutex = pool_mutex(pool['name'])
       return if mutex.locked?
 
-      @redis.with do |redis|
+      @redis.with_metrics do |redis|
         clone_target = redis.hget('vmpooler__config__clone_target', pool['name'])
         return if clone_target.nil?
         return if clone_target == pool['clone_target']
@@ -1040,7 +1035,7 @@ module Vmpooler
     end
 
     def remove_excess_vms(pool)
-      @redis.with do |redis|
+      @redis.with_metrics do |redis|
         redis.multi
         redis.scard("vmpooler__ready__#{pool['name']}")
         redis.scard("vmpooler__pending__#{pool['name']}")
@@ -1072,7 +1067,7 @@ module Vmpooler
       mutex = pool_mutex(pool['name'])
       return if mutex.locked?
 
-      @redis.with do |redis|
+      @redis.with_metrics do |redis|
         poolsize = redis.hget('vmpooler__config__poolsize', pool['name'])
         return if poolsize.nil?
 
@@ -1087,7 +1082,7 @@ module Vmpooler
 
     def reset_pool(pool)
       poolname = pool['name']
-      @redis.with do |redis|
+      @redis.with_metrics do |redis|
         return unless redis.sismember('vmpooler__poolreset', poolname)
 
         redis.srem('vmpooler__poolreset', poolname)
@@ -1104,7 +1099,7 @@ module Vmpooler
       begin
         mutex = pool_mutex(pool['name'])
         mutex.synchronize do
-          @redis.with do |redis|
+          @redis.with_metrics do |redis|
             provider.vms_in_pool(pool['name']).each do |vm|
               if !redis.sismember('vmpooler__running__' + pool['name'], vm['name']) &&
                  !redis.sismember('vmpooler__ready__' + pool['name'], vm['name']) &&
@@ -1131,7 +1126,7 @@ module Vmpooler
     end
 
     def check_running_pool_vms(pool_name, provider, pool_check_response, inventory)
-      @redis.with do |redis|
+      @redis.with_metrics do |redis|
         redis.smembers("vmpooler__running__#{pool_name}").each do |vm|
           if inventory[vm]
             begin
@@ -1149,12 +1144,12 @@ module Vmpooler
     end
 
     def check_ready_pool_vms(pool_name, provider, pool_check_response, inventory, pool_ttl = 0)
-      @redis.with do |redis|
+      @redis.with_metrics do |redis|
         redis.smembers("vmpooler__ready__#{pool_name}").each do |vm|
           if inventory[vm]
             begin
               pool_check_response[:checked_ready_vms] += 1
-              check_ready_vm(vm, pool_name, pool_ttl || 0, provider, redis)
+              check_ready_vm(vm, pool_name, pool_ttl || 0, provider)
             rescue StandardError => e
               $logger.log('d', "[!] [#{pool_name}] _check_pool failed with an error while evaluating ready VMs: #{e}")
             end
@@ -1167,7 +1162,7 @@ module Vmpooler
 
     def check_pending_pool_vms(pool_name, provider, pool_check_response, inventory, pool_timeout = nil)
       pool_timeout ||= $config[:config]['timeout'] || 15
-      @redis.with do |redis|
+      @redis.with_metrics do |redis|
         redis.smembers("vmpooler__pending__#{pool_name}").reverse.each do |vm|
           if inventory[vm]
             begin
@@ -1184,7 +1179,7 @@ module Vmpooler
     end
 
     def check_completed_pool_vms(pool_name, provider, pool_check_response, inventory)
-      @redis.with do |redis|
+      @redis.with_metrics do |redis|
         redis.smembers("vmpooler__completed__#{pool_name}").each do |vm|
           if inventory[vm]
             begin
@@ -1211,7 +1206,7 @@ module Vmpooler
     end
 
     def check_discovered_pool_vms(pool_name)
-      @redis.with do |redis|
+      @redis.with_metrics do |redis|
         redis.smembers("vmpooler__discovered__#{pool_name}").reverse.each do |vm|
           %w[pending ready running completed].each do |queue|
             if redis.sismember("vmpooler__#{queue}__#{pool_name}", vm)
@@ -1228,7 +1223,7 @@ module Vmpooler
     end
 
     def check_migrating_pool_vms(pool_name, provider, pool_check_response, inventory)
-      @redis.with do |redis|
+      @redis.with_metrics do |redis|
         redis.smembers("vmpooler__migrating__#{pool_name}").reverse.each do |vm|
           if inventory[vm]
             begin
@@ -1245,7 +1240,7 @@ module Vmpooler
     def repopulate_pool_vms(pool_name, provider, pool_check_response, pool_size)
       return if pool_mutex(pool_name).locked?
 
-      @redis.with do |redis|
+      @redis.with_metrics do |redis|
         redis.multi
         redis.scard("vmpooler__ready__#{pool_name}")
         redis.scard("vmpooler__pending__#{pool_name}")
@@ -1384,7 +1379,7 @@ module Vmpooler
     end
 
     def process_ondemand_requests
-      @redis.with do |redis|
+      @redis.with_metrics do |redis|
         requests = redis.zrange('vmpooler__provisioning__request', 0, -1)
         requests&.map { |request_id| create_ondemand_vms(request_id, redis) }
         provisioning_tasks = process_ondemand_vms(redis)
@@ -1479,7 +1474,7 @@ module Vmpooler
     def execute!(maxloop = 0, loop_delay = 1)
       $logger.log('d', 'starting vmpooler')
 
-      @redis.with do |redis|
+      @redis.with_metrics do |redis|
         # Clear out the tasks manager, as we don't know about any tasks at this point
         redis.set('vmpooler__tasks__clone', 0)
         # Clear out vmpooler__migrations since stale entries may be left after a restart
diff --git a/lib/vmpooler/providers/dummy.rb b/lib/vmpooler/providers/dummy.rb
index 47eaf58..100bcb6 100644
--- a/lib/vmpooler/providers/dummy.rb
+++ b/lib/vmpooler/providers/dummy.rb
@@ -9,8 +9,8 @@ module Vmpooler
       class Dummy < Vmpooler::PoolManager::Provider::Base
         # Fake VM Provider for testing
 
-        def initialize(config, logger, metrics, name, options)
-          super(config, logger, metrics, name, options)
+        def initialize(config, logger, metrics, redis_connection_pool, name, options)
+          super(config, logger, metrics, redis_connection_pool, name, options)
           dummyfilename = provider_config['filename']
 
           # This initial_state option is only intended to be used by spec tests
diff --git a/lib/vmpooler/providers/vsphere.rb b/lib/vmpooler/providers/vsphere.rb
index 6f27306..27ca3ac 100644
--- a/lib/vmpooler/providers/vsphere.rb
+++ b/lib/vmpooler/providers/vsphere.rb
@@ -60,7 +60,7 @@ module Vmpooler
         def destroy_vm_and_log(vm_name, vm_object, pool, data_ttl)
           try = 0 if try.nil?
           max_tries = 3
-          @redis.with do |redis|
+          @redis.with_metrics do |redis|
             redis.multi
             redis.srem("vmpooler__completed__#{pool}", vm_name)
             redis.hdel("vmpooler__active__#{pool}", vm_name)
@@ -973,26 +973,24 @@ module Vmpooler
             begin
               connection = ensured_vsphere_connection(pool_object)
               vm_hash = get_vm_details(pool_name, vm_name, connection)
-              @redis.with do |redis|
-                redis.multi
+              @redis.with_metrics do |redis|
                 redis.hset("vmpooler__vm__#{vm_name}", 'host', vm_hash['host_name'])
                 migration_count = redis.scard('vmpooler__migration')
-                redis.exec
-              end
-              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']}")
+                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
-                  migrate_vm_to_new_host(pool_name, vm_name, vm_hash, connection)
+                  logger.log('s', "[ ] [#{pool_name}] '#{vm_name}' is running on #{vm_hash['host_name']}")
                 end
-              else
-                logger.log('s', "[ ] [#{pool_name}] '#{vm_name}' is running on #{vm_hash['host_name']}")
               end
             rescue StandardError
               logger.log('s', "[!] [#{pool_name}] '#{vm_name}' is running on #{vm_hash['host_name']}")
@@ -1002,13 +1000,13 @@ module Vmpooler
         end
 
         def migrate_vm_to_new_host(pool_name, vm_name, vm_hash, connection)
-          @redis.with do |redis|
+          @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 do |redis|
+          @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)
@@ -1016,7 +1014,7 @@ module Vmpooler
           end
           logger.log('s', "[>] [#{pool_name}] '#{vm_name}' migrated from #{vm_hash['host_name']} to #{target_host_name} in #{finish} seconds")
         ensure
-          @redis.with do |redis|
+          @redis.with_metrics do |redis|
             redis.srem('vmpooler__migration', vm_name)
           end
         end
@@ -1028,7 +1026,7 @@ module Vmpooler
           metrics.timing("migrate.#{pool_name}", finish)
           metrics.increment("migrate_from.#{vm_hash['host_name']}")
           metrics.increment("migrate_to.#{dest_host_name}")
-          @redis.with do |redis|
+          @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)
diff --git a/spec/fixtures/vmpooler.yaml b/spec/fixtures/vmpooler.yaml
index 1e3e78f..c5c0522 100644
--- a/spec/fixtures/vmpooler.yaml
+++ b/spec/fixtures/vmpooler.yaml
@@ -36,6 +36,8 @@
   - 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
index 39a617a..a016d30 100644
--- a/spec/fixtures/vmpooler2.yaml
+++ b/spec/fixtures/vmpooler2.yaml
@@ -36,6 +36,8 @@
   - 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
index 589e00f..19bec9e 100644
--- a/spec/helpers.rb
+++ b/spec/helpers.rb
@@ -1,12 +1,5 @@
 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
@@ -40,59 +33,54 @@ def token_exists?(token)
   result && !result.empty?
 end
 
-def create_ready_vm(template, name, token = nil)
-  create_vm(name, token)
+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, token = nil, user = nil)
-  create_vm(name, token, nil, user)
+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, token = nil)
-  create_vm(name, token)
+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, token = nil, redis_handle = nil, user = nil)
-  redis_db = redis_handle ? redis_handle : redis
-  redis_db.hset("vmpooler__vm__#{name}", 'checkout', Time.now)
-  redis_db.hset("vmpooler__vm__#{name}", 'token:token', token) if token
-  redis_db.hset("vmpooler__vm__#{name}", 'token:user', user) if user
+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, active = false, redis_handle = nil)
-  redis_db = redis_handle ? redis_handle : redis
-  redis_db.sadd("vmpooler__completed__#{pool}", name)
-  redis_db.hset("vmpooler__vm__#{name}", 'checkout', Time.now)
-  redis_db.hset("vmpooler__active__#{pool}", name, Time.now) if active
+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_handle = nil)
-  redis_db = redis_handle ? redis_handle : redis
-  redis_db.sadd("vmpooler__discovered__#{pool}", name)
+def create_discovered_vm(name, pool, redis)
+  redis.sadd("vmpooler__discovered__#{pool}", name)
 end
 
-def create_migrating_vm(name, pool, redis_handle = nil)
-  redis_db = redis_handle ? redis_handle : redis
-  redis_db.hset("vmpooler__vm__#{name}", 'checkout', Time.now)
-  redis_db.sadd("vmpooler__migrating__#{pool}", name)
+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_handle = nil)
-  redis_db = redis_handle ? redis-handle : redis
-  redis_db.hset("vmpooler__vm__#{vm}", "tag:#{tag_name}", tag_value)
+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_handle = nil)
-  redis_db = redis_handle ? redis_handle : redis
-  redis_db.sadd('vmpooler__migration', name)
+def add_vm_to_migration_set(name, redis)
+  redis.sadd('vmpooler__migration', name)
 end
 
 def fetch_vm(vm)
diff --git a/spec/unit/pool_manager_spec.rb b/spec/unit/pool_manager_spec.rb
index e3218f6..1a1b324 100644
--- a/spec/unit/pool_manager_spec.rb
+++ b/spec/unit/pool_manager_spec.rb
@@ -11,7 +11,6 @@ end
 
 describe 'Pool Manager' do
   let(:logger) { MockLogger.new }
-  let(:redis) { MockRedis.new }
   let(:metrics) { Vmpooler::DummyStatsd.new }
   let(:pool) { 'pool1' }
   let(:vm) { 'vm1' }
@@ -20,7 +19,15 @@ describe 'Pool Manager' do
   let(:token) { 'token1234'}
 
   let(:provider_options) { {} }
-  let(:provider) { Vmpooler::PoolManager::Provider::Base.new(config, logger, metrics, 'mock_provider', provider_options) }
+  let(:redis_connection_pool) { Vmpooler::PoolManager::GenericConnectionPool.new(
+    metrics: metrics,
+    metric_prefix: 'redis_connection_pool',
+    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
 ---
@@ -34,7 +41,7 @@ EOT
     )
   }
 
-  subject { Vmpooler::PoolManager.new(config, logger, redis, metrics) }
+  subject { Vmpooler::PoolManager.new(config, logger, redis_connection_pool, metrics) }
 
   describe '#config' do
     before do
@@ -92,14 +99,18 @@ EOT
 
       it 'calls move_pending_vm_to_ready if host is ready' do
         expect(provider).to receive(:vm_ready?).with(pool,vm).and_return(true)
-        expect(subject).to receive(:move_pending_vm_to_ready).with(vm, pool)
+        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)
-        expect(subject).to receive(:fail_pending_vm).with(vm, pool, timeout)
+        redis_connection_pool.with do |redis|
+          expect(subject).to receive(:fail_pending_vm).with(vm, pool, timeout, redis, nil)
+        end
 
         subject._check_pending_vm(vm, pool, timeout, provider)
       end
@@ -125,17 +136,20 @@ EOT
     end
 
     it 'removes VM from pending in redis' do
-      create_pending_vm(pool,vm)
+      redis_connection_pool.with do |redis|
+        create_pending_vm(pool,vm,redis)
 
-      expect(redis.sismember("vmpooler__pending__#{pool}", vm)).to be(true)
-      subject.remove_nonexistent_vm(vm, pool)
-      expect(redis.sismember("vmpooler__pending__#{pool}", vm)).to be(false)
+        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.")
 
-      subject.remove_nonexistent_vm(vm, pool)
+      redis_connection_pool.with do |redis|
+        subject.remove_nonexistent_vm(vm, pool, redis)
+      end
     end
   end
 
@@ -145,49 +159,64 @@ EOT
     end
 
     before(:each) do
-      create_pending_vm(pool,vm)
+      redis_connection_pool.with do |redis|
+        create_pending_vm(pool,vm,redis)
+      end
     end
 
     it 'takes no action if VM is not cloning' do
-      expect(subject.fail_pending_vm(vm, pool, timeout)).to eq(true)
-      expect(redis.sismember("vmpooler__pending__#{pool}", vm)).to be(true)
+      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.hset("vmpooler__vm__#{vm}", 'clone',Time.now.to_s)
-      expect(subject.fail_pending_vm(vm, pool, timeout)).to eq(true)
-      expect(redis.sismember("vmpooler__pending__#{pool}", vm)).to be(true)
+      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.hset("vmpooler__vm__#{vm}", 'clone',Date.new(2001,1,1).to_s)
-      expect(subject.fail_pending_vm(vm, pool, timeout,true)).to eq(true)
-      expect(redis.sismember("vmpooler__pending__#{pool}", vm)).to be(false)
-      expect(redis.sismember("vmpooler__completed__#{pool}", vm)).to be(true)
+      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, 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.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,true)).to eq(true)
+      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, true)).to eq(true)
+      end
     end
 
     it 'calls remove_nonexistent_vm if VM has exceeded timeout and does not exist' do
-      redis.hset("vmpooler__vm__#{vm}", 'clone',Date.new(2001,1,1).to_s)
-      expect(subject).to receive(:remove_nonexistent_vm).with(vm, pool)
-      expect(subject.fail_pending_vm(vm, pool, timeout,false)).to eq(true)
+      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, false)).to eq(true)
+      end
     end
 
     it 'swallows error if an error is raised' do
-      redis.hset("vmpooler__vm__#{vm}", 'clone','iamnotparsable_asdate')
-      expect(subject.fail_pending_vm(vm, pool, timeout,true)).to eq(false)
+      redis_connection_pool.with do |redis|
+        redis.hset("vmpooler__vm__#{vm}", 'clone','iamnotparsable_asdate')
+        expect(subject.fail_pending_vm(vm, pool, timeout, redis, true)).to eq(false)
+      end
     end
 
     it 'logs message if an error is raised' do
-      redis.hset("vmpooler__vm__#{vm}", 'clone','iamnotparsable_asdate')
-      expect(logger).to receive(:log).with('d', String)
+      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,true)
+        subject.fail_pending_vm(vm, pool, timeout, redis, true)
+      end
     end
   end
 
@@ -199,55 +228,71 @@ EOT
     end
 
     before(:each) do
-      create_pending_vm(pool,vm)
+      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
-        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)
-        expect(redis.sismember("vmpooler__pending__#{pool}", vm)).to be(false)
-        expect(redis.sismember("vmpooler__ready__#{pool}", vm)).to be(true)
+        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")
 
-        subject.move_pending_vm_to_ready(vm, pool)
+        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.hset("vmpooler__vm__#{vm}", 'clone',Time.now.to_s)
-        expect(metrics).to receive(:timing).with(/time_to_ready_state\./,/0/)
+        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)
+          subject.move_pending_vm_to_ready(vm, pool, redis)
+        end
       end
 
 
       it 'should set the boot time in redis' do
-        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)
-        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?
+        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
-        expect(redis.hget('vmpooler__boot__' + Date.today.to_s, pool + ':' + vm)).to be_nil
-        subject.move_pending_vm_to_ready(vm, pool)
-        expect(redis.hget('vmpooler__boot__' + Date.today.to_s, pool + ':' + vm)).to eq("") # Possible implementation bug here. Should still be nil here
+        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 eq("") # Possible implementation bug here. Should still be nil here
+        end
       end
 
       it 'should raise error if clone start time is not parsable' do
-        redis.hset("vmpooler__vm__#{vm}", 'clone','iamnotparsable_asdate')
-        expect{subject.move_pending_vm_to_ready(vm, pool)}.to raise_error(/iamnotparsable_asdate/)
+        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
-        expect(redis.hget('vmpooler__lastboot', pool)).to be(nil)
-        subject.move_pending_vm_to_ready(vm, pool)
-        expect(redis.hget('vmpooler__lastboot', pool)).to_not be(nil)
+        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
   end
@@ -286,7 +331,9 @@ EOT
     }
 
     before(:each) do
-      create_ready_vm(pool,vm)
+      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
@@ -297,34 +344,42 @@ EOT
 
     context 'a VM that does not need to be checked' do
       it 'should do nothing' do
-        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)
+        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
-      let(:last_check_date) { Date.new(2001,1,1).to_s }
+      let(:last_check_date) { Time.now - 901 }
 
       it 'should set the current check timestamp' do
-        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
+        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) { Date.new(2001,1,1).to_s }
+      let(:last_check_date) { Time.now - 901 }
       before(:each) do
-        redis.hset("vmpooler__vm__#{vm}", 'check',last_check_date)
+        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
-        expect(redis.hget("vmpooler__vm__#{vm}", 'check')).to eq(last_check_date)
-        subject._check_ready_vm(vm, pool, ttl, provider)
-        expect(redis.hget("vmpooler__vm__#{vm}", 'check')).to_not eq(last_check_date)
+        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
@@ -340,20 +395,25 @@ EOT
       context 'has correct name and is not ready' do
         before(:each) do
           expect(provider).to receive(:vm_ready?).with(pool, vm).and_return(false)
+          redis_connection_pool.with do |redis|
+            redis.hset("vmpooler__vm__#{vm}", 'ready', Time.now - 901)
+            redis.sadd("vmpooler__ready__#{pool}", vm)
+          end
         end
 
         it 'should move the VM to the completed queue' do
-          expect(redis).to receive(:smove).with("vmpooler__ready__#{pool}", "vmpooler__completed__#{pool}", vm)
+          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)
+            subject._check_ready_vm(vm, pool, ttl, provider)
+          end
         end
 
         it 'should move the VM to the completed queue in Redis' do
-          expect(redis.sismember("vmpooler__ready__#{pool}", vm)).to be(true)
-          expect(redis.sismember("vmpooler__completed__#{pool}", vm)).to be(false)
-          subject._check_ready_vm(vm, pool, ttl, provider)
-          expect(redis.sismember("vmpooler__ready__#{pool}", vm)).to be(false)
-          expect(redis.sismember("vmpooler__completed__#{pool}", vm)).to be(true)
+          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
@@ -367,7 +427,9 @@ EOT
 
         context 'when less than 60 seconds since a VM moved to ready' do
           before(:each) do
-            redis.hset("vmpooler__vm__#{vm}", 'ready', Time.now)
+            redis_connection_pool.with do |redis|
+              redis.hset("vmpooler__vm__#{vm}", 'ready', Time.now)
+            end
           end
 
           it 'should return nil' do
@@ -380,20 +442,27 @@ EOT
           before(:each) do
             expect(provider).to receive(:get_vm).with(pool,vm).and_return(host)
             host['hostname'] = different_hostname
+            redis_connection_pool.with do |redis|
+              redis.sadd("vmpooler__ready__#{pool}", vm)
+            end
           end
 
           it 'should move the VM to the completed queue' do
-            expect(redis).to receive(:smove).with("vmpooler__ready__#{pool}", "vmpooler__completed__#{pool}", vm)
+            redis_connection_pool.with do |redis|
+              expect(redis).to receive(:smove).with("vmpooler__ready__#{pool}", "vmpooler__completed__#{pool}", vm)
+            end
 
             subject._check_ready_vm(vm, pool, ttl, provider)
           end
 
           it 'should move the VM to the completed queue in Redis' do
-            expect(redis.sismember("vmpooler__ready__#{pool}", vm)).to be(true)
-            expect(redis.sismember("vmpooler__completed__#{pool}", vm)).to be(false)
-            subject._check_ready_vm(vm, pool, ttl, provider)
-            expect(redis.sismember("vmpooler__ready__#{pool}", vm)).to be(false)
-            expect(redis.sismember("vmpooler__completed__#{pool}", vm)).to be(true)
+            redis_connection_pool.with do |redis|
+              expect(redis.sismember("vmpooler__ready__#{pool}", vm)).to be(true)
+              expect(redis.sismember("vmpooler__completed__#{pool}", vm)).to be(false)
+              subject._check_ready_vm(vm, pool, ttl, provider)
+              expect(redis.sismember("vmpooler__ready__#{pool}", vm)).to be(false)
+              expect(redis.sismember("vmpooler__completed__#{pool}", vm)).to be(true)
+            end
           end
 
           it 'should log messages about being misnamed' do
@@ -467,7 +536,9 @@ EOT
     end
 
     before(:each) do
-      create_running_vm(pool,vm)
+      redis_connection_pool.with do |redis|
+        create_running_vm(pool,vm, redis)
+      end
 
       # Create a VM which is powered on
       host['hostname'] = vm
@@ -476,36 +547,44 @@ EOT
     end
 
     it 'moves a missing VM to the completed queue' do
-      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)
+      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 not move VM if it has no checkout time' do
-        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(true)
+        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(true)
+        end
       end
 
       it 'should not move VM if TTL is zero' do
-        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)
+        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.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)
+        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
 
@@ -533,31 +612,43 @@ EOT
     end
 
     before(:each) do
-      create_pending_vm(pool, vm, token)
+      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
-      expect(redis.sismember("vmpooler__#{queue_from}__#{pool}",vm))
+      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
-      subject.move_vm_queue(pool, vm, queue_from, queue_to, message)
-      expect(!redis.sismember("vmpooler__#{queue_from}__#{pool}",vm))
+      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
-      expect(!redis.sismember("vmpooler__#{queue_to}__#{pool}",vm))
+      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
-      subject.move_vm_queue(pool, vm, queue_from, queue_to, message)
-      expect(redis.sismember("vmpooler__#{queue_to}__#{pool}",vm))
+      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}")
 
-      subject.move_vm_queue(pool, vm, queue_from, queue_to, message)
+      redis_connection_pool.with do |redis|
+        subject.move_vm_queue(pool, vm, queue_from, queue_to, redis, message)
+      end
     end
   end
 
@@ -612,25 +703,29 @@ EOT
       end
 
       it 'should create a cloning VM' do
-        expect(redis.scard("vmpooler__pending__#{pool}")).to eq(0)
+        redis_connection_pool.with do |redis|
+          expect(redis.scard("vmpooler__pending__#{pool}")).to eq(0)
 
-        subject._clone_vm(pool,provider)
+          subject._clone_vm(pool,provider)
 
-        expect(redis.scard("vmpooler__pending__#{pool}")).to eq(1)
-        # 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(redis.hget("vmpooler__vm__#{vm_name}", 'clone')).to_not be_nil
-        expect(redis.hget("vmpooler__vm__#{vm_name}", 'template')).to eq(pool)
-        expect(redis.hget("vmpooler__clone__#{Date.today.to_s}", "#{pool}:#{vm_name}")).to_not be_nil
-        expect(redis.hget("vmpooler__vm__#{vm_name}", 'clone_time')).to_not be_nil
+          expect(redis.scard("vmpooler__pending__#{pool}")).to eq(1)
+          # 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(redis.hget("vmpooler__vm__#{vm_name}", 'clone')).to_not be_nil
+          expect(redis.hget("vmpooler__vm__#{vm_name}", 'template')).to eq(pool)
+          expect(redis.hget("vmpooler__clone__#{Date.today.to_s}", "#{pool}:#{vm_name}")).to_not be_nil
+          expect(redis.hget("vmpooler__vm__#{vm_name}", 'clone_time')).to_not be_nil
+        end
       end
 
       it 'should decrement the clone tasks counter' do
-        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')
+        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
@@ -654,27 +749,33 @@ EOT
       end
 
       it 'should not create a cloning VM' do
-        expect(redis.scard("vmpooler__pending__#{pool}")).to eq(0)
+        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{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
+          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.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')
+        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
-        expect(redis).to receive(:expire)
-        expect{subject._clone_vm(pool,provider)}.to raise_error(/MockError/)
+        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
@@ -708,7 +809,9 @@ EOT
     before(:each) do
       expect(subject).not_to be_nil
 
-      create_completed_vm(vm,pool,true)
+      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)
 
@@ -723,9 +826,11 @@ EOT
       end
 
       it 'should call redis expire with 0' do
-        expect(redis.hget("vmpooler__vm__#{vm}", 'checkout')).to_not be_nil
-        subject._destroy_vm(vm,pool,provider)
-        expect(redis.hget("vmpooler__vm__#{vm}", 'checkout')).to be_nil
+        redis_connection_pool.with do |redis|
+          expect(redis.hget("vmpooler__vm__#{vm}", 'checkout')).to_not be_nil
+          subject._destroy_vm(vm,pool,provider)
+          expect(redis.hget("vmpooler__vm__#{vm}", 'checkout')).to be_nil
+        end
       end
     end
 
@@ -832,7 +937,9 @@ EOT
 
       context 'when a VM has not been checked out' do
         before(:each) do
-          create_ready_vm(template, vm)
+          redis_connection_pool.with do |redis|
+            create_ready_vm(template, vm, redis)
+          end
         end
 
         it 'should return' do
@@ -847,7 +954,9 @@ EOT
         context 'without auth' do
 
           before(:each) do
-            create_running_vm(template, vm)
+            redis_connection_pool.with do |redis|
+              create_running_vm(template, vm, redis)
+            end
           end
 
           it 'should emit a metric' do
@@ -860,7 +969,9 @@ EOT
         context 'with auth' do
 
           before(:each) do
-            create_running_vm(template, vm, token, user)
+            redis_connection_pool.with do |redis|
+              create_running_vm(template, vm, redis, token, user)
+            end
           end
 
           it 'should emit a metric' do
@@ -875,7 +986,9 @@ EOT
             let(:metric_nodes) { metric_string.split('.') }
 
             before(:each) do
-              create_running_vm(template, vm)
+              redis_connection_pool.with do |redis|
+                create_running_vm(template, vm, redis)
+              end
             end
 
             it 'should emit a metric with the character replaced' do
@@ -1173,7 +1286,9 @@ EOT
       expect(subject).not_to be_nil
       allow(logger).to receive(:log)
 
-      create_running_vm(pool,vm,token)
+      redis_connection_pool.with do |redis|
+        create_running_vm(pool,vm,token)
+      end
     end
 
     context 'Given a VM that does not exist' do
@@ -1183,8 +1298,10 @@ EOT
       end
 
       it 'should not update redis if the VM does not exist' do
-        expect(redis).to receive(:hset).exactly(0).times
-        expect{ subject._create_vm_disk(pool, vm, disk_size, provider) }.to raise_error(RuntimeError)
+        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
 
@@ -1201,8 +1318,10 @@ EOT
       end
 
       it 'should raise an error if the disk size is a Fixnum' do
-        expect(redis).to receive(:hset).exactly(0).times
-        expect{ subject._create_vm_disk(pool, vm, 10, provider) }.to raise_error(NoMethodError,/empty?/)
+        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
 
@@ -1219,16 +1338,20 @@ EOT
       end
 
       it 'should update redis information when attaching the first disk' do
-        subject._create_vm_disk(pool, vm, disk_size, provider)
-        expect(redis.hget("vmpooler__vm__#{vm}", 'disk')).to eq("+#{disk_size}gb")
+        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
-        initial_disks = '+10gb:+20gb'
-        redis.hset("vmpooler__vm__#{vm}", 'disk', initial_disks)
+        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")
+          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
 
@@ -1238,10 +1361,12 @@ EOT
       end
 
       it 'should not update redis information' do
-        expect(redis).to receive(:hset).exactly(0).times
+        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
+          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
@@ -1275,7 +1400,9 @@ EOT
     end
 
     before(:each) do
-      create_running_vm(pool,vm,token)
+      redis_connection_pool.with do |redis|
+        create_running_vm(pool,vm,redis,token)
+      end
     end
 
     context 'Given a Pool that does not exist' do
@@ -1286,9 +1413,11 @@ EOT
       end
 
       it 'should not update redis' do
-        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
+        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
 
@@ -1299,9 +1428,11 @@ EOT
       end
 
       it 'should not update redis' do
-        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
+        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
 
@@ -1318,9 +1449,11 @@ EOT
       end
 
       it 'should add snapshot redis information' do
-        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
+        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
 
@@ -1337,9 +1470,11 @@ EOT
       end
 
       it 'should not update redis' do
-        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
+        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
@@ -1433,7 +1568,9 @@ EOT
   describe '#get_pool_name_for_vm' do
     context 'Given a valid VM' do
       before(:each) do
-        create_running_vm(pool, vm, token)
+        redis_connection_pool.with do |redis|
+          create_running_vm(pool, vm, redis, token)
+        end
       end
 
       it 'should return the pool name' do
@@ -1630,9 +1767,11 @@ EOT
 
     context 'when specified provider does not exist' do
       before(:each) do
-        disk_task_vm(vm,"snapshot_#{vm}")
-        create_running_vm(pool, vm, token)
-        expect(subject).to receive(:get_provider_for_pool).and_return(nil)
+        redis_connection_pool.with do |redis|
+          disk_task_vm(vm,"snapshot_#{vm}")
+          create_running_vm(pool, vm, token)
+          expect(subject).to receive(:get_provider_for_pool).and_return(nil)
+        end
       end
 
       it 'should log an error' do
@@ -1651,8 +1790,10 @@ EOT
     context 'when multiple VMs in the queue' do
       before(:each) do
         ['vm1', 'vm2', 'vm3'].each do |vm_name|
-          disk_task_vm(vm_name,"snapshot_#{vm_name}")
-          create_running_vm(pool, vm_name, token)
+          redis_connection_pool.with do |redis|
+            disk_task_vm(vm_name,"snapshot_#{vm_name}")
+            create_running_vm(pool, vm_name, redis, token)
+          end
         end
 
         allow(subject).to receive(:get_provider_for_pool).with(pool).and_return(provider)
@@ -1772,9 +1913,11 @@ EOT
 
       context 'when specified provider does not exist' do
         before(:each) do
-          snapshot_vm(vm,"snapshot_#{vm}")
-          create_running_vm(pool, vm, token)
-          expect(subject).to receive(:get_provider_for_pool).and_return(nil)
+          redis_connection_pool.with do |redis|
+            snapshot_vm(vm,"snapshot_#{vm}")
+            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
@@ -1793,8 +1936,10 @@ EOT
       context 'when multiple VMs in the queue' do
         before(:each) do
           ['vm1', 'vm2', 'vm3'].each do |vm_name|
-            snapshot_vm(vm_name,"snapshot_#{vm_name}")
-            create_running_vm(pool, vm_name, token)
+            redis_connection_pool.with do |redis|
+              snapshot_vm(vm_name,"snapshot_#{vm_name}")
+              create_running_vm(pool, vm_name, redis, token)
+            end
           end
 
           allow(subject).to receive(:get_provider_for_pool).with(pool).and_return(provider)
@@ -1846,9 +1991,11 @@ EOT
 
       context 'when specified provider does not exist' do
         before(:each) do
-          snapshot_revert_vm(vm,"snapshot_#{vm}")
-          create_running_vm(pool, vm, token)
-          expect(subject).to receive(:get_provider_for_pool).and_return(nil)
+          redis_connection_pool.with do |redis|
+            snapshot_revert_vm(vm,"snapshot_#{vm}")
+            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
@@ -1867,8 +2014,10 @@ EOT
       context 'when multiple VMs in the queue' do
         before(:each) do
           ['vm1', 'vm2', 'vm3'].each do |vm_name|
-            snapshot_revert_vm(vm_name,"snapshot_#{vm_name}")
-            create_running_vm(pool, vm_name, token)
+            redis_connection_pool.with do |redis|
+              snapshot_revert_vm(vm_name,"snapshot_#{vm_name}")
+              create_running_vm(pool, vm_name, redis, token)
+            end
           end
 
           allow(subject).to receive(:get_provider_for_pool).with(pool).and_return(provider)
@@ -1982,15 +2131,18 @@ EOT
     end
 
     it 'returns when a template is set and matches the configured template' do
-      redis.hset('vmpooler__config__template', pool, old_template)
-
+      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.hset('vmpooler__config__template', pool, new_template)
+      redis_connection_pool.with do |redis|
+        redis.hset('vmpooler__config__template', pool, new_template)
+      end
 
       subject.sync_pool_template(config[:pools][0])
 
@@ -2030,7 +2182,9 @@ EOT
     end
 
     it 'should set the pool template to match the configured template' do
-      subject.update_pool_template(poolconfig, provider, new_template, current_template)
+      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
@@ -2038,31 +2192,41 @@ EOT
     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}")
 
-      subject.update_pool_template(poolconfig, provider, new_template, current_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
-      expect(subject).to receive(:drain_pool).with(pool)
+      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)
+        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")
 
-      subject.update_pool_template(poolconfig, provider, new_template, current_template)
+      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
       expect(subject).to receive(:prepare_template).with(poolconfig, provider)
 
-      subject.update_pool_template(poolconfig, provider, new_template, current_template)
+      redis_connection_pool.with do |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")
 
-      subject.update_pool_template(poolconfig, provider, new_template, current_template)
+      redis_connection_pool.with do |redis|
+        subject.update_pool_template(poolconfig, provider, new_template, current_template, redis)
+      end
     end
   end
 
@@ -2092,8 +2256,10 @@ EOT
     context 'when the mutex is locked' do
       let(:mutex) { Mutex.new }
       before(:each) do
-        expect(redis).to receive(:scard).with("vmpooler__pending__#{pool}").and_return(1)
-        expect(redis).to receive(:scard).with("vmpooler__ready__#{pool}").and_return(2)
+        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(2)
+        end
         mutex.lock
         expect(subject).to receive(:pool_mutex).with(pool).and_return(mutex)
       end
@@ -2105,27 +2271,33 @@ EOT
 
     context 'with a total size less than the pool size' do
       it 'should return nil' do
-        expect(redis).to receive(:scard).with("vmpooler__pending__#{pool}").and_return(1)
-        expect(redis).to receive(:scard).with("vmpooler__ready__#{pool}").and_return(1)
+        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
-        expect(redis).to receive(:scard).with("vmpooler__ready__#{pool}").and_return(4)
-        expect(redis).to receive(:scard).with("vmpooler__pending__#{pool}").and_return(0)
+        redis_connection_pool.with do |redis|
+          expect(redis).to receive(:scard).with("vmpooler__ready__#{pool}").and_return(4)
+          expect(redis).to receive(:scard).with("vmpooler__pending__#{pool}").and_return(0)
+        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
-        create_pending_vm(pool,'vm1')
-        create_pending_vm(pool,'vm2')
-        create_ready_vm(pool, 'vm3')
-        create_ready_vm(pool, 'vm4')
-        create_ready_vm(pool, 'vm5')
+        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)
+        end
         expect(subject).to receive(:move_vm_queue).exactly(3).times
 
         subject.remove_excess_vms(config[:pools][0])
@@ -2150,20 +2322,26 @@ EOT
 
     context 'when creating the template delta disks' do
       before(:each) do
-        allow(redis).to receive(:hset)
+        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
-        expect(provider).to receive(:create_template_delta_disks).with(config[:pools][0])
+        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)
+          subject.prepare_template(config[:pools][0], provider, redis)
+        end
       end
 
       it 'should mark the template as prepared' do
-        expect(redis).to receive(:hset).with('vmpooler__template__prepared', pool, config[:pools][0]['template'])
+        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)
+          subject.prepare_template(config[:pools][0], provider, redis)
+        end
       end
     end
 
@@ -2174,9 +2352,11 @@ EOT
       end
 
       it 'should log a message when delta disk creation returns an error' do
-        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")
+        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)
+          subject.prepare_template(config[:pools][0], provider, redis)
+        end
       end
     end
   end
@@ -2200,18 +2380,24 @@ EOT
     }
 
     before(:each) do
-      allow(redis).to receive(:hget)
+      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
-      expect(redis).to receive(:hget).with('vmpooler__template__prepared', pool).and_return(current_template)
+      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
-      expect(redis).to receive(:hget).with('vmpooler__config__template', pool).and_return(new_template)
+      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
@@ -2229,14 +2415,18 @@ EOT
     context 'when prepared template is nil' do
 
       it 'should prepare the template' do
-        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_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
-        expect(redis).to receive(:hget).with('vmpooler__template__prepared', pool).and_return(current_template)
+        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)
@@ -2245,19 +2435,25 @@ EOT
 
     context 'when the configured pool template does not match the prepared template' do
       before(:each) do
-        config[:pools][0]['template'] = new_template
-        expect(redis).to receive(:hget).with('vmpooler__template__prepared', pool).and_return(current_template)
+        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
-        expect(subject).to receive(:prepare_template).with(config[:pools][0], provider)
+        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
-          expect(redis).to receive(:hget).with('vmpooler__config__template', pool).and_return(current_template)
+          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)
@@ -2267,12 +2463,16 @@ EOT
 
     context 'when a new template is requested' do
       before(:each) do
-        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)
+        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
-        expect(subject).to receive(:update_pool_template).with(config[:pools][0], provider, new_template, current_template)
+        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
@@ -2286,57 +2486,75 @@ EOT
 
     context 'with no vms' do
       it 'should return nil' do
-        expect(subject.drain_pool(pool)).to be_nil
+        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)
 
-        subject.drain_pool(pool)
+        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)
 
-        subject.drain_pool(pool)
+        redis_connection_pool.with do |redis|
+          subject.drain_pool(pool, redis)
+        end
       end
     end
 
     context 'with ready vms' do
       before(:each) do
-        create_ready_vm(pool, 'vm1')
-        create_ready_vm(pool, 'vm2')
+        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
 
-        subject.drain_pool(pool)
+        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")
 
-        subject.drain_pool(pool)
+        redis_connection_pool.with do |redis|
+          subject.drain_pool(pool, redis)
+        end
       end
     end
 
     context 'with pending instances' do
       before(:each) do
-        create_pending_vm(pool, 'vm1')
-        create_pending_vm(pool, 'vm2')
+        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
 
-        subject.drain_pool(pool)
+        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")
 
-        subject.drain_pool(pool)
+        redis_connection_pool.with do |redis|
+          subject.drain_pool(pool, redis)
+        end
       end
     end
   end
@@ -2368,25 +2586,33 @@ EOT
     end
 
     it 'should get the pool size configuration from redis' do
-      expect(redis).to receive(:hget).with('vmpooler__config__poolsize', pool)
+      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
-      expect(redis).to receive(:hget).with('vmpooler__config__poolsize', pool).and_return(nil)
+      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
-      expect(redis).to receive(:hget).with('vmpooler__config__poolsize', pool).and_return('2')
+      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
-      expect(redis).to receive(:hget).with('vmpooler__config__poolsize', pool).and_return(newsize)
+      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)
 
@@ -2421,25 +2647,33 @@ EOT
     end
 
     it 'should get the pool clone target configuration from redis' do
-      expect(redis).to receive(:hget).with('vmpooler__config__clone_target', pool)
+      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
-      expect(redis).to receive(:hget).with('vmpooler__config__clone_target', pool).and_return(nil)
+      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
-      expect(redis).to receive(:hget).with('vmpooler__config__clone_target', pool).and_return('cluster1')
+      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
-      expect(redis).to receive(:hget).with('vmpooler__config__clone_target', pool).and_return(newtarget)
+      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)
 
@@ -2463,6 +2697,7 @@ EOT
       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
@@ -2480,15 +2715,19 @@ EOT
       end
 
       it 'should set clone tasks to zero' do
-        redis.set('vmpooler__tasks__clone', 1)
-        subject.execute!(1,0)
-        expect(redis.get('vmpooler__tasks__clone')).to eq('0')
+        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.set('vmpooler__migration', 1)
-        subject.execute!(1,0)
-        expect(redis.get('vmpooler__migration')).to be_nil
+        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
@@ -2526,7 +2765,7 @@ EOT
         it 'should call create_provider_object idempotently' do
           # Even though there are two pools using the vsphere provider (the default), it should only
           # create the provider object once.
-          expect(subject).to receive(:create_provider_object).with(Object, Object, Object, 'vsphere', 'vsphere', Object).and_return(vsphere_provider)
+          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
@@ -2549,8 +2788,8 @@ EOT
     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, 'vsphere', provider_options) }
-      let(:provider2) { Vmpooler::PoolManager::Provider::Base.new(config, logger, metrics, 'secondvsphere', provider_options) }
+      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
 ---
@@ -2571,8 +2810,8 @@ 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, "vsphere", "vsphere", Object).and_return(vsphere_provider)
-        expect(subject).to receive(:create_provider_object).with(Object, Object, Object, "vsphere", "secondvsphere", Object).and_return(vsphere_provider2)
+        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
 
@@ -2747,7 +2986,7 @@ EOT
       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)
@@ -2768,8 +3007,10 @@ EOT
         end
 
       it 'should run startup tasks only once' do
-        expect(redis).to receive(:set).with('vmpooler__tasks__clone', 0).once
-        expect(redis).to receive(:del).with('vmpooler__migration').once
+        redis_connection_pool.with do |redis|
+          expect(redis).to receive(:set).with('vmpooler__tasks__clone', 0).once
+          expect(redis).to receive(:del).with('vmpooler__migration').once
+        end
 
         subject.execute!(maxloop,0)
       end
@@ -2798,7 +3039,9 @@ EOT
     context 'when redis server connection is not available' do
       let(:maxloop) { 2 }
       it 'should log a failure and raise the error' do
-        expect(redis).to receive(:set).with('vmpooler__tasks__clone', 0).and_raise(Redis::CannotConnectError)
+        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
@@ -2838,22 +3081,28 @@ EOT
       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
-        expect(subject).to receive(:time_passed?).with(:exit_by, Time).and_return(false, true)
-        expect(redis).to receive(:scard).with("vmpooler__ready__#{pool}").once
+        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
-        expect(subject).to receive(:sleep).exactly(3).times
-        expect(redis).to receive(:scard).with("vmpooler__ready__#{pool}").and_return(1,1,1,2)
+        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
-        expect(subject).to receive(:sleep).exactly(3).times
-        expect(redis).to receive(:scard).with("vmpooler__ready__#{pool}").and_return(2,2,2,1)
+        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
@@ -2869,20 +3118,26 @@ EOT
 
       context 'with a template configured' do
         before(:each) do
-          redis.hset('vmpooler__config__template', pool, new_template)
-          allow(redis).to receive(:hget)
+          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
-          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
+          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
-          expect(subject).to receive(:sleep).exactly(3).times
-          expect(redis).to receive(:hget).with('vmpooler__config__template', pool).and_return(nil,nil,new_template)
+          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
@@ -2899,12 +3154,16 @@ EOT
 
       context 'when a pool reset is requested' do
         before(:each) do
-          redis.sadd('vmpooler__poolreset', pool)
+          redis_connection_pool.with do |redis|
+            redis.sadd('vmpooler__poolreset', pool)
+          end
         end
 
         it 'should sleep until the reset request is detected' do
-          expect(subject).to receive(:sleep).exactly(3).times
-          expect(redis).to receive(:sismember).with('vmpooler__poolreset', pool).and_return(false,false,true)
+          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
@@ -3197,7 +3456,9 @@ EOT
         {}
       }
       before(:each) do
-        create_running_vm(pool,vm,token)
+        redis_connection_pool.with do |redis|
+          create_running_vm(pool,vm,redis,token)
+        end
       end
 
       it 'should not call check_running_vm' do
@@ -3207,7 +3468,9 @@ EOT
       end
 
       it 'should move the VM to completed queue' do
-        expect(subject).to receive(:move_vm_queue).with(pool,vm,'running','completed',String).and_call_original
+        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
@@ -3220,8 +3483,10 @@ EOT
         { vm => 1 }
       }
       before(:each) do
-        allow(subject).to receive(:check_running_vm)
-        create_running_vm(pool,vm,token)
+        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
@@ -3239,8 +3504,9 @@ EOT
 
       it 'should use the VM lifetime in preference to defaults' do
         big_lifetime = 2000
-
-        redis.hset("vmpooler__vm__#{vm}", 'lifetime',big_lifetime)
+        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)
 
@@ -3274,7 +3540,9 @@ EOT
         {}
       }
       before(:each) do
-        create_ready_vm(pool,vm,token)
+        redis_connection_pool.with do |redis|
+          create_ready_vm(pool,vm,redis,token)
+        end
       end
 
       it 'should not call check_ready_vm' do
@@ -3284,7 +3552,9 @@ EOT
       end
 
       it 'should move the VM to completed queue' do
-        expect(subject).to receive(:move_vm_queue).with(pool,vm,'ready','completed',String).and_call_original
+        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)
       end
@@ -3297,8 +3567,10 @@ EOT
       }
       let(:big_lifetime) { 2000 }
       before(:each) do
-        allow(subject).to receive(:check_ready_vm)
-        create_ready_vm(pool,vm,token)
+        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
@@ -3341,11 +3613,15 @@ EOT
       }
 
       before(:each) do
-        create_pending_vm(pool,vm,token)
+        redis_connection_pool.with do |redis|
+          create_pending_vm(pool,vm,redis,token)
+        end
       end
 
       it 'should call fail_pending_vm' do
-        expect(subject).to receive(:fail_pending_vm).with(vm,pool,Integer,false)
+        redis_connection_pool.with do |redis|
+          expect(subject).to receive(:fail_pending_vm).with(vm,pool,Integer,redis,false)
+        end
 
         subject.check_pending_pool_vms(pool, provider, pool_check_response, inventory)
       end
@@ -3358,7 +3634,9 @@ EOT
       }
 
       before(:each) do
-        create_pending_vm(pool,vm,token)
+        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
@@ -3415,7 +3693,9 @@ EOT
       }
 
       before(:each) do
-        create_completed_vm(vm,pool,true)
+        redis_connection_pool.with do |redis|
+          create_completed_vm(vm,pool,redis,true)
+        end
       end
 
       it 'should log a message' do
@@ -3429,15 +3709,17 @@ EOT
       end
 
       it 'should remove redis information' do
-        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)
+        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)
+          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)
+          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
 
@@ -3448,7 +3730,9 @@ EOT
       }
 
       before(:each) do
-        create_completed_vm(vm,pool,true)
+        redis_connection_pool.with do |redis|
+          create_completed_vm(vm,pool,redis,true)
+        end
       end
 
       it 'should call destroy_vm' do
@@ -3474,15 +3758,17 @@ EOT
         end
 
         it 'should remove redis information' do
-          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)
+          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)
+            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)
+            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
@@ -3491,17 +3777,23 @@ EOT
   describe "#check_discovered_pool_vms" do
     context 'Discovered VM' do
       before(:each) do
-        create_discovered_vm(vm,pool)
+        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)
 
-        expect(redis.sismember("vmpooler__completed__#{pool}", vm)).to be(true)
+        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
-        expect(redis).to receive(:smove).with("vmpooler__discovered__#{pool}", "vmpooler__completed__#{pool}", vm).and_raise(RuntimeError,'MockError')
+        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)
@@ -3519,25 +3811,31 @@ EOT
           end
 
           it "should remain in the #{queue_name} queue" do
-            redis.sadd("vmpooler__#{queue_name}__#{pool}", vm)
-            allow(logger).to receive(:log)
+            redis_connection_pool.with do |redis|
+              redis.sadd("vmpooler__#{queue_name}__#{pool}", vm)
+              allow(logger).to receive(:log)
 
-            subject.check_discovered_pool_vms(pool)
+              subject.check_discovered_pool_vms(pool)
 
-            expect(redis.sismember("vmpooler__#{queue_name}__#{pool}", vm)).to be(true)
+              expect(redis.sismember("vmpooler__#{queue_name}__#{pool}", vm)).to be(true)
+            end
           end
 
           it "should be removed from the discovered queue" do
-            redis.sadd("vmpooler__#{queue_name}__#{pool}", vm)
-            allow(logger).to receive(:log)
+            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)
+              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.sadd("vmpooler__#{queue_name}__#{pool}", vm)
+            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)
@@ -3561,7 +3859,9 @@ EOT
       }
 
       before(:each) do
-        create_migrating_vm(vm,pool)
+        redis_connection_pool.with do |redis|
+          create_migrating_vm(vm,pool,redis)
+        end
       end
 
       it 'should not do anything' do
@@ -3578,7 +3878,9 @@ EOT
       }
 
       before(:each) do
-        create_migrating_vm(vm,pool)
+        redis_connection_pool.with do |redis|
+          create_migrating_vm(vm,pool,redis)
+        end
       end
 
       it 'should return the number of migrated VMs' do
@@ -3627,7 +3929,9 @@ EOT
     end
 
     it 'should not call clone_vm when number of VMs is greater than the pool size' do
-      create_ready_vm(pool,vm,token)
+      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)
@@ -3637,9 +3941,11 @@ EOT
       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.sadd("vmpooler__#{queue_name}__#{pool}",vm)
+        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
@@ -3648,7 +3954,9 @@ EOT
       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.sadd("vmpooler__#{queue_name}__#{pool}",vm)
+        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)
@@ -3664,7 +3972,9 @@ EOT
     context 'when pool is marked as empty' do
 
       before(:each) do
-        redis.set("vmpooler__empty__#{pool}", 'true')
+        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
@@ -3674,11 +3984,13 @@ EOT
       end
 
       it 'should remove the empty pool mark if it is no longer empty' do
-        create_ready_vm(pool,vm,token)
+        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
+          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
 
@@ -3711,11 +4023,13 @@ EOT
       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")
-        create_ready_vm(pool,'vm')
         expect{ subject.repopulate_pool_vms(pool, provider, pool_check_response, pool_size) }.to raise_error(RuntimeError,'MockError')
 
       end
@@ -3738,9 +4052,11 @@ EOT
 
     context 'export metrics' do
       it 'increments metrics for ready queue' do
-        create_ready_vm(pool,'vm1')
-        create_ready_vm(pool,'vm2')
-        create_ready_vm(pool,'vm3')
+        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)
@@ -3749,9 +4065,11 @@ EOT
       end
 
       it 'increments metrics for running queue' do
-        create_running_vm(pool,'vm1',token)
-        create_running_vm(pool,'vm2',token)
-        create_running_vm(pool,'vm3',token)
+        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)
@@ -3761,6 +4079,7 @@ EOT
 
       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)
 
@@ -3870,30 +4189,34 @@ EOT
       end
 
       it 'should add undiscovered VMs to the completed queue' do
-        allow(logger).to receive(:log).with('s', "[?] [#{pool}] '#{new_vm}' added to 'discovered' queue")
+        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)
+          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)
+          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)
+          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
-          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)
+          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)
+            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)
+            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
@@ -4059,7 +4382,9 @@ EOT
       let(:newpoolsize) { 3 }
       before(:each) do
         config[:pools][0]['size'] = poolsize
-        redis.hset('vmpooler__config__poolsize', pool, newpoolsize)
+        redis_connection_pool.with do |redis|
+          redis.hset('vmpooler__config__poolsize', pool, newpoolsize)
+        end
       end
 
       it 'should change the pool size configuration' do
@@ -4096,9 +4421,11 @@ EOT
     context 'when an excess number of ready vms exist' do
 
       before(:each) do
-        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)
+        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
diff --git a/spec/unit/providers/base_spec.rb b/spec/unit/providers/base_spec.rb
index 5dc71c5..27b3d94 100644
--- a/spec/unit/providers/base_spec.rb
+++ b/spec/unit/providers/base_spec.rb
@@ -22,7 +22,9 @@ describe 'Vmpooler::PoolManager::Provider::Base' do
     fake_vm
   }
 
-  subject { Vmpooler::PoolManager::Provider::Base.new(config, logger, metrics, provider_name, provider_options) }
+  let(:redis_connection_pool) { ConnectionPool.new(size: 1) { MockRedis.new } }
+
+  subject { Vmpooler::PoolManager::Provider::Base.new(config, logger, metrics, redis_connection_pool, provider_name, provider_options) }
 
   # Helper attr_reader methods
   describe '#logger' do
diff --git a/spec/unit/providers/dummy_spec.rb b/spec/unit/providers/dummy_spec.rb
index 13006ce..a22d2e6 100644
--- a/spec/unit/providers/dummy_spec.rb
+++ b/spec/unit/providers/dummy_spec.rb
@@ -91,7 +91,9 @@ EOT
     )
   }
 
-  subject { Vmpooler::PoolManager::Provider::Dummy.new(config, logger, metrics, 'dummy', provider_options) }
+  let(:redis_connection_pool) { ConnectionPool.new(size: 1) { MockRedis.new } }
+
+  subject { Vmpooler::PoolManager::Provider::Dummy.new(config, logger, metrics, redis_connection_pool, 'dummy', provider_options) }
 
   describe '#name' do
     it 'should be dummy' do
diff --git a/spec/unit/providers/vsphere_spec.rb b/spec/unit/providers/vsphere_spec.rb
index a4ce37a..2f14a8f 100644
--- a/spec/unit/providers/vsphere_spec.rb
+++ b/spec/unit/providers/vsphere_spec.rb
@@ -77,9 +77,15 @@ EOT
   let(:connection_options) {{}}
   let(:connection) { mock_RbVmomi_VIM_Connection(connection_options) }
   let(:vmname) { 'vm1' }
-  let(:redis) { MockRedis.new }
+  let(:redis_connection_pool) { Vmpooler::PoolManager::GenericConnectionPool.new(
+    metrics: metrics,
+    metric_prefix: 'redis_connection_pool',
+    size: 1,
+    timeout: 5
+  ) { MockRedis.new }
+  }
 
-  subject { Vmpooler::PoolManager::Provider::VSphere.new(config, logger, metrics, 'vsphere', provider_options) }
+  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)
@@ -149,17 +155,6 @@ EOT
         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)
-        $redis = redis
-      end
-
-      it 'should remove redis data and expire the vm key' do
-        allow(Time).to receive(:now).and_return(now)
-        expect(redis).to receive(:srem).with("vmpooler__completed__#{pool}", vmname)
-        expect(redis).to receive(:hdel).with("vmpooler__active__#{pool}", vmname)
-        expect(redis).to receive(:hset).with("vmpooler__vm__#{vmname}", 'destroy', now)
-        expect(redis).to receive(:expire).with("vmpooler__vm__#{vmname}", data_ttl * 60 * 60)
-
-        subject.destroy_vm_and_log(vmname, vm_object, pool, data_ttl)
       end
 
       it 'should log a message that the vm is destroyed' do
@@ -169,6 +164,7 @@ EOT
       end
 
       it 'should record metrics' do
+        expect(metrics).to receive(:timing).with('redis_connection_pool.waited', 0)
         expect(metrics).to receive(:timing).with("destroy.#{pool}", finish)
 
         subject.destroy_vm_and_log(vmname, vm_object, pool, data_ttl)
@@ -2573,10 +2569,12 @@ EOT
         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)
-          allow($redis).to receive(:hset)
           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
@@ -2585,7 +2583,6 @@ EOT
         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($redis).to receive(:hget).with("vmpooler__vm__#{vmname}", 'checkout').and_return((Time.now - 1).to_s)
         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)
@@ -2603,7 +2600,6 @@ EOT
         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($redis).to receive(:hset).with("vmpooler__vm__#{vmname}", 'host', parent_host)
           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
@@ -2622,11 +2618,13 @@ EOT
       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($redis).to receive(:scard).with('vmpooler__migration').and_return(5)
           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
@@ -2691,14 +2689,10 @@ EOT
     end
 
     it' migrates a vm' do
-      expect($redis).to receive(:sadd).with('vmpooler__migration', vmname)
       expect(subject).to receive(:select_next_host).and_return(new_host)
-      expect($redis).to receive(:hset).with("vmpooler__vm__#{vmname}", 'host', new_host)
-      expect($redis).to receive(:hset).with("vmpooler__vm__#{vmname}", 'migrated', true)
       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")
-      expect($redis).to receive(:srem).with('vmpooler__migration', vmname)
       subject.migrate_vm_to_new_host(poolname, vmname, vm_details, connection)
     end
   end