Merge pull request #182 from glennsarti/ticket/master/POOLER-73-add-unit-tests

(POOLER-73) Update unit tests prior to refactoring

lib/vmpooler/pool_manager.rb

@@ -412,15 +412,20 @@ module Vmpooler
       end
     end
 
-    def check_disk_queue
+    def check_disk_queue(maxloop = 0, loop_delay = 5)
       $logger.log('d', "[*] [disk_manager] starting worker thread")
 
       $vsphere['disk_manager'] ||= Vmpooler::VsphereHelper.new $config, $metrics
-
       $threads['disk_manager'] = Thread.new do
+        loop_count = 1
         loop do
           _check_disk_queue $vsphere['disk_manager']
-          sleep(5)
+          sleep(loop_delay)
+
+          unless maxloop.zero?
+            break if loop_count >= maxloop
+            loop_count = loop_count + 1
+          end
         end
       end
     end
@@ -438,15 +443,21 @@ module Vmpooler
       end
     end
 
-    def check_snapshot_queue
+    def check_snapshot_queue(maxloop = 0, loop_delay = 5)
       $logger.log('d', "[*] [snapshot_manager] starting worker thread")
 
       $vsphere['snapshot_manager'] ||= Vmpooler::VsphereHelper.new $config, $metrics
 
       $threads['snapshot_manager'] = Thread.new do
+        loop_count = 1
         loop do
           _check_snapshot_queue $vsphere['snapshot_manager']
-          sleep(5)
+          sleep(loop_delay)
+
+          unless maxloop.zero?
+            break if loop_count >= maxloop
+            loop_count = loop_count + 1
+          end
         end
       end
     end
@@ -546,15 +557,21 @@ module Vmpooler
       finish
     end
 
-    def check_pool(pool)
+    def check_pool(pool,maxloop = 0, loop_delay = 5)
       $logger.log('d', "[*] [#{pool['name']}] starting worker thread")
 
       $vsphere[pool['name']] ||= Vmpooler::VsphereHelper.new $config, $metrics
 
       $threads[pool['name']] = Thread.new do
+        loop_count = 1
         loop do
           _check_pool(pool, $vsphere[pool['name']])
-          sleep(5)
+          sleep(loop_delay)
+
+          unless maxloop.zero?
+            break if loop_count >= maxloop
+            loop_count = loop_count + 1
+          end
         end
       end
     end
@@ -714,7 +731,7 @@ module Vmpooler
       raise
     end
 
-    def execute!
+   def execute!(maxloop = 0, loop_delay = 1)
       $logger.log('d', 'starting vmpooler')
 
       # Clear out the tasks manager, as we don't know about any tasks at this point
@@ -722,6 +739,7 @@ module Vmpooler
       # Clear out vmpooler__migrations since stale entries may be left after a restart
       $redis.del('vmpooler__migration')
 
+      loop_count = 1
       loop do
         if ! $threads['disk_manager']
           check_disk_queue
@@ -746,7 +764,12 @@ module Vmpooler
           end
         end
 
-        sleep(1)
+        sleep(loop_delay)
+
+        unless maxloop.zero?
+          break if loop_count >= maxloop
+          loop_count = loop_count + 1
+        end
       end
     end
   end

spec/helpers.rb

@@ -6,6 +6,28 @@ def redis
   @redis
 end
 
+# Mock an object which is result from Vmpooler::VsphereHelper.find_folder(foldername)
+class MockFindFolder
+  attr_reader :childEntity
+
+  def initialize(vmlist = [])
+    # Generate an array of hashes
+    @childEntity = vmlist.map do |vm|
+      vm_object = {}
+      vm_object['name'] = vm
+
+      vm_object
+    end
+  end
+end
+
+# Mock an object which represents a Logger.  This stops the proliferation
+# of allow(logger).to .... expectations in tests.
+class MockLogger
+  def log(_level, string)
+  end
+end
+
 def expect_json(ok = true, http = 200)
   expect(last_response.header['Content-Type']).to eq('application/json')
 
@@ -56,6 +78,18 @@ def create_vm(name, token = nil, redis_handle = nil)
   redis_db.hset("vmpooler__vm__#{name}", 'token:token', token) if token
 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
+end
+
+def create_discovered_vm(name, pool, redis_handle = nil)
+  redis_db = redis_handle ? redis_handle : redis
+  redis_db.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)
@@ -71,11 +105,20 @@ def fetch_vm(vm)
   redis.hgetall("vmpooler__vm__#{vm}")
 end
 
+def snapshot_revert_vm(vm, snapshot = '12345678901234567890123456789012')
+  redis.sadd('vmpooler__tasks__snapshot-revert', "#{vm}:#{snapshot}")
+  redis.hset("vmpooler__vm__#{vm}", "snapshot:#{snapshot}", "1")
+end
+
 def snapshot_vm(vm, snapshot = '12345678901234567890123456789012')
   redis.sadd('vmpooler__tasks__snapshot', "#{vm}:#{snapshot}")
   redis.hset("vmpooler__vm__#{vm}", "snapshot:#{snapshot}", "1")
 end
 
+def disk_task_vm(vm, disk_size = '10')
+  redis.sadd('vmpooler__tasks__disk', "#{vm}:#{disk_size}")
+end
+
 def has_vm_snapshot?(vm)
   redis.smembers('vmpooler__tasks__snapshot').any? do |snapshot|
     instance, sha = snapshot.split(':')

spec/vmpooler/pool_manager_migration_spec.rb

@@ -1,87 +0,0 @@
-require 'spec_helper'
-require 'mock_redis'
-require 'time'
-
-describe 'Pool Manager' do
-  let(:logger) { double('logger') }
-  let(:redis) { MockRedis.new }
-  let(:metrics) { Vmpooler::DummyStatsd.new }
-  let(:config) {
-    {
-      config: {
-        'site_name' => 'test pooler',
-        'migration_limit' => 2,
-        vsphere: {
-          'server' => 'vsphere.puppet.com',
-          'username' => 'vmpooler@vsphere.local',
-          'password' => '',
-          'insecure' => true
-        },
-        pools: [ {'name' => 'pool1', 'size' => 5, 'folder' => 'pool1_folder'} ],
-        statsd: { 'prefix' => 'stats_prefix'},
-        pool_names: [ 'pool1' ]
-      }
-    }
-  }
-  let(:pool) { config[:config][:pools][0]['name'] }
-  let(:vm) {
-    {
-      'name' => 'vm1',
-      'host' => 'host1',
-      'template' => pool,
-    }
-  }
-
-  describe '#_migrate_vm' do
-    let(:vsphere) { double(pool) }
-    let(:pooler) { Vmpooler::PoolManager.new(config, logger, redis, metrics) }
-    context 'evaluates VM for migration and logs host' do
-      before do
-        create_migrating_vm vm['name'], pool, redis
-        allow(vsphere).to receive(:find_vm).and_return(vm)
-        allow(pooler).to receive(:get_vm_host_info).and_return([{'name' => 'host1'}, 'host1'])
-      end
-
-      it 'logs VM host when migration is disabled' do
-        config[:config]['migration_limit'] = nil
-
-        expect(redis.sismember("vmpooler__migrating__#{pool}", vm['name'])).to be true
-        expect(logger).to receive(:log).with('s', "[ ] [#{pool}] '#{vm['name']}' is running on #{vm['host']}")
-
-        pooler._migrate_vm(vm['name'], pool, vsphere)
-
-        expect(redis.sismember("vmpooler__migrating__#{pool}", vm['name'])).to be false
-      end
-
-      it 'verifies that migration_limit greater than or equal to migrations in progress and logs host' do
-        add_vm_to_migration_set vm['name'], redis
-        add_vm_to_migration_set 'vm2', redis
-
-        expect(logger).to receive(:log).with('s', "[ ] [#{pool}] '#{vm['name']}' is running on #{vm['host']}. No migration will be evaluated since the migration_limit has been reached")
-
-        pooler._migrate_vm(vm['name'], pool, vsphere)
-      end
-
-      it 'verifies that migration_limit is less than migrations in progress and logs old host, new host and migration time' do
-        allow(vsphere).to receive(:find_least_used_compatible_host).and_return([{'name' => 'host2'}, 'host2'])
-        allow(vsphere).to receive(:migrate_vm_host)
-
-        expect(redis.hget("vmpooler__vm__#{vm['name']}", 'migration_time'))
-        expect(redis.hget("vmpooler__vm__#{vm['name']}", 'checkout_to_migration'))
-        expect(logger).to receive(:log).with('s', "[>] [#{pool}] '#{vm['name']}' migrated from #{vm['host']} to host2 in 0.00 seconds")
-
-        pooler._migrate_vm(vm['name'], pool, vsphere)
-      end
-
-      it 'fails when no suitable host can be found' do
-        error = 'ArgumentError: No target host found'
-        allow(vsphere).to receive(:find_least_used_compatible_host)
-        allow(vsphere).to receive(:migrate_vm_host).and_raise(error)
-
-        expect(logger).to receive(:log).with('s', "[x] [#{pool}] '#{vm['name']}' migration failed with an error: #{error}")
-
-        pooler._migrate_vm(vm['name'], pool, vsphere)
-      end
-    end
-  end
-end

spec/vmpooler/pool_manager_spec.rb

@@ -1,361 +0,0 @@
-require 'spec_helper'
-require 'time'
-
-describe 'Pool Manager' do
-  let(:logger) { double('logger') }
-  let(:redis) { double('redis') }
-  let(:metrics) { Vmpooler::DummyStatsd.new }
-  let(:config) { {} }
-  let(:pool) { 'pool1' }
-  let(:vm) { 'vm1' }
-  let(:timeout) { 5 }
-  let(:host) { double('host') }
-
-  subject { Vmpooler::PoolManager.new(config, logger, redis, metrics) }
-
-  describe '#_check_pending_vm' do
-    let(:pool_helper) { double('pool') }
-    let(:vsphere) { {pool => pool_helper} }
-
-    before do
-      expect(subject).not_to be_nil
-      $vsphere = vsphere
-    end
-
-    context 'host not in pool' do
-      it 'calls fail_pending_vm' do
-        allow(vsphere).to receive(:find_vm).and_return(nil)
-        allow(redis).to receive(:hget)
-        subject._check_pending_vm(vm, pool, timeout, vsphere)
-      end
-    end
-
-    context 'host is in pool' do
-      let(:vm_finder) { double('vm_finder') }
-      let(:tcpsocket) { double('TCPSocket') }
-
-      it 'calls move_pending_vm_to_ready' do
-        allow(subject).to receive(:open_socket).and_return(true)
-        allow(vsphere).to receive(:find_vm).and_return(vm_finder)
-        allow(vm_finder).to receive(:summary).and_return(nil)
-
-        expect(vm_finder).to receive(:summary).once
-        expect(redis).not_to receive(:hget).with(String, 'clone')
-
-        subject._check_pending_vm(vm, pool, timeout, vsphere)
-      end
-    end
-  end
-
-  describe '#move_vm_to_ready' do
-    before do
-      expect(subject).not_to be_nil
-    end
-
-    context 'a host without correct summary' do
-      it 'does nothing when summary is nil' do
-        allow(host).to receive(:summary).and_return nil
-        subject.move_pending_vm_to_ready(vm, pool, host)
-      end
-
-      it 'does nothing when guest is nil' do
-        allow(host).to receive(:summary).and_return true
-        allow(host).to receive_message_chain(:summary, :guest).and_return nil
-        subject.move_pending_vm_to_ready(vm, pool, host)
-      end
-
-      it 'does nothing when hostName is nil' do
-        allow(host).to receive(:summary).and_return true
-        allow(host).to receive_message_chain(:summary, :guest).and_return true
-        allow(host).to receive_message_chain(:summary, :guest, :hostName).and_return nil
-        subject.move_pending_vm_to_ready(vm, pool, host)
-      end
-
-      it 'does nothing when hostName does not match vm' do
-        allow(host).to receive(:summary).and_return true
-        allow(host).to receive_message_chain(:summary, :guest).and_return true
-        allow(host).to receive_message_chain(:summary, :guest, :hostName).and_return 'adifferentvm'
-        subject.move_pending_vm_to_ready(vm, pool, host)
-      end
-    end
-
-    context 'a host with proper summary' do
-      before do
-        allow(host).to receive(:summary).and_return true
-        allow(host).to receive_message_chain(:summary, :guest).and_return true
-        allow(host).to receive_message_chain(:summary, :guest, :hostName).and_return vm
-
-        allow(redis).to receive(:hget)
-        allow(redis).to receive(:smove)
-        allow(redis).to receive(:hset)
-        allow(logger).to receive(:log)
-      end
-
-      it 'moves vm to ready' do
-        allow(redis).to receive(:hget).with(String, 'clone').and_return Time.now.to_s
-
-        expect(redis).to receive(:smove).with(String, String, vm)
-        expect(redis).to receive(:hset).with(String, String, String)
-        expect(logger).to receive(:log).with('s', String)
-
-        subject.move_pending_vm_to_ready(vm, pool, host)
-      end
-
-      it 'sets finish to nil when clone_time is nil' do
-        expect(redis).to receive(:smove).with(String, String, vm)
-        expect(redis).to receive(:hset).with(String, String, nil)
-        expect(logger).to receive(:log).with('s', String)
-
-        subject.move_pending_vm_to_ready(vm, pool, host)
-      end
-    end
-  end
-
-  describe '#fail_pending_vm' do
-    before do
-      expect(subject).not_to be_nil
-    end
-
-    context 'does not have a clone stamp' do
-      it 'has no side effects' do
-        allow(redis).to receive(:hget)
-        subject.fail_pending_vm(vm, pool, timeout)
-      end
-    end
-
-    context 'has valid clone stamp' do
-      it 'does nothing when less than timeout' do
-        allow(redis).to receive(:hget).with(String, 'clone').and_return Time.now.to_s
-        subject.fail_pending_vm(vm, pool, timeout)
-      end
-
-      it 'moves vm to completed when over timeout' do
-        allow(redis).to receive(:hget).with(String, 'clone').and_return '2005-01-1'
-        allow(redis).to receive(:smove).with(String, String, String)
-        allow(logger).to receive(:log).with(String, String)
-
-        expect(redis).to receive(:smove).with(String, String, vm)
-        expect(logger).to receive(:log).with('d', String)
-
-        subject.fail_pending_vm(vm, pool, timeout)
-      end
-
-    end
-  end
-
-  describe '#_check_running_vm' do
-    let(:pool_helper) { double('pool') }
-    let(:vsphere) { {pool => pool_helper} }
-
-    before do
-      expect(subject).not_to be_nil
-      $vsphere = vsphere
-    end
-
-    it 'does nothing with nil host' do
-      allow(vsphere).to receive(:find_vm).and_return(nil)
-      expect(redis).not_to receive(:smove)
-      subject._check_running_vm(vm, pool, timeout, vsphere)
-    end
-
-    context 'valid host' do
-      let(:vm_host) { double('vmhost') }
-
-      it 'does not move vm when not poweredOn' do
-        allow(vsphere).to receive(:find_vm).and_return vm_host
-        allow(vm_host).to receive(:runtime).and_return true
-        allow(vm_host).to receive_message_chain(:runtime, :powerState).and_return 'poweredOff'
-
-        expect(redis).to receive(:hget)
-        expect(redis).not_to receive(:smove)
-        expect(logger).not_to receive(:log).with('d', "[!] [#{pool}] '#{vm}' appears to be powered off or dead")
-
-        subject._check_running_vm(vm, pool, timeout, vsphere)
-      end
-
-      it 'moves vm when poweredOn, but past TTL' do
-        allow(vsphere).to receive(:find_vm).and_return vm_host
-        allow(vm_host).to receive(:runtime).and_return true
-        allow(vm_host).to receive_message_chain(:runtime, :powerState).and_return 'poweredOn'
-
-        expect(redis).to receive(:hget).with('vmpooler__active__pool1', 'vm1').and_return((Time.now - timeout*60*60).to_s)
-        expect(redis).to receive(:smove)
-        expect(logger).to receive(:log).with('d', "[!] [#{pool}] '#{vm}' reached end of TTL after #{timeout} hours")
-
-        subject._check_running_vm(vm, pool, timeout, vsphere)
-      end
-    end
-  end
-
-  describe '#move_running_to_completed' do
-    before do
-      expect(subject).not_to be_nil
-    end
-
-    it 'uses the pool in smove' do
-      allow(redis).to receive(:smove).with(String, String, String)
-      allow(logger).to receive(:log)
-      expect(redis).to receive(:smove).with('vmpooler__running__p1', 'vmpooler__completed__p1', 'vm1')
-      subject.move_vm_queue('p1', 'vm1', 'running', 'completed', 'msg')
-    end
-
-    it 'logs msg' do
-      allow(redis).to receive(:smove)
-      allow(logger).to receive(:log)
-      expect(logger).to receive(:log).with('d', "[!] [p1] 'vm1' a msg here")
-      subject.move_vm_queue('p1', 'vm1', 'running', 'completed', 'a msg here')
-    end
-  end
-
-  describe '#_check_pool' do
-    let(:pool_helper) { double('pool') }
-    let(:vsphere) { {pool => pool_helper} }
-    let(:config) { {
-      config: { task_limit: 10 },
-      pools: [ {'name' => 'pool1', 'size' => 5} ]
-    } }
-
-    before do
-      expect(subject).not_to be_nil
-      $vsphere = vsphere
-      allow(logger).to receive(:log)
-      allow(pool_helper).to receive(:find_folder)
-      allow(redis).to receive(:smembers).with('vmpooler__pending__pool1').and_return([])
-      allow(redis).to receive(:smembers).with('vmpooler__ready__pool1').and_return([])
-      allow(redis).to receive(:smembers).with('vmpooler__running__pool1').and_return([])
-      allow(redis).to receive(:smembers).with('vmpooler__completed__pool1').and_return([])
-      allow(redis).to receive(:smembers).with('vmpooler__discovered__pool1').and_return([])
-      allow(redis).to receive(:smembers).with('vmpooler__migrating__pool1').and_return([])
-      allow(redis).to receive(:set)
-      allow(redis).to receive(:get).with('vmpooler__tasks__clone').and_return(0)
-      allow(redis).to receive(:get).with('vmpooler__empty__pool1').and_return(nil)
-    end
-
-    context 'logging' do
-      it 'logs empty pool' do
-        allow(redis).to receive(:scard).with('vmpooler__pending__pool1').and_return(0)
-        allow(redis).to receive(:scard).with('vmpooler__ready__pool1').and_return(0)
-        allow(redis).to receive(:scard).with('vmpooler__running__pool1').and_return(0)
-
-        expect(logger).to receive(:log).with('s', "[!] [pool1] is empty")
-        subject._check_pool(config[:pools][0], vsphere)
-      end
-    end
-  end
-
-  describe '#_stats_running_ready' do
-    let(:pool_helper) { double('pool') }
-    let(:vsphere) { {pool => pool_helper} }
-    let(:metrics) { Vmpooler::DummyStatsd.new }
-    let(:config) { {
-      config: { task_limit: 10 },
-      pools: [ {'name' => 'pool1', 'size' => 5} ],
-      graphite: { 'prefix' => 'vmpooler' }
-    } }
-
-    before do
-      expect(subject).not_to be_nil
-      $vsphere = vsphere
-      allow(logger).to receive(:log)
-      allow(pool_helper).to receive(:find_folder)
-      allow(redis).to receive(:smembers).and_return([])
-      allow(redis).to receive(:set)
-      allow(redis).to receive(:get).with('vmpooler__tasks__clone').and_return(0)
-      allow(redis).to receive(:get).with('vmpooler__empty__pool1').and_return(nil)
-    end
-
-    context 'metrics' do
-      subject { Vmpooler::PoolManager.new(config, logger, redis, metrics) }
-
-      it 'increments metrics' do
-        allow(redis).to receive(:scard).with('vmpooler__ready__pool1').and_return(1)
-        allow(redis).to receive(:scard).with('vmpooler__cloning__pool1').and_return(0)
-        allow(redis).to receive(:scard).with('vmpooler__pending__pool1').and_return(0)
-        allow(redis).to receive(:scard).with('vmpooler__running__pool1').and_return(5)
-
-        expect(metrics).to receive(:gauge).with('ready.pool1', 1)
-        expect(metrics).to receive(:gauge).with('running.pool1', 5)
-        subject._check_pool(config[:pools][0], vsphere)
-      end
-
-      it 'increments metrics when ready with 0 when pool empty' do
-        allow(redis).to receive(:scard).with('vmpooler__ready__pool1').and_return(0)
-        allow(redis).to receive(:scard).with('vmpooler__cloning__pool1').and_return(0)
-        allow(redis).to receive(:scard).with('vmpooler__pending__pool1').and_return(0)
-        allow(redis).to receive(:scard).with('vmpooler__running__pool1').and_return(5)
-
-        expect(metrics).to receive(:gauge).with('ready.pool1', 0)
-        expect(metrics).to receive(:gauge).with('running.pool1', 5)
-        subject._check_pool(config[:pools][0], vsphere)
-      end
-    end
-  end
-
-  describe '#_create_vm_snapshot' do
-    let(:snapshot_manager) { 'snapshot_manager' }
-    let(:pool_helper) { double('snapshot_manager') }
-    let(:vsphere) { {snapshot_manager => pool_helper} }
-
-    before do
-      expect(subject).not_to be_nil
-      $vsphere = vsphere
-    end
-
-    context '(valid host)' do
-      let(:vm_host) { double('vmhost') }
-
-      it 'creates a snapshot' do
-        expect(vsphere).to receive(:find_vm).and_return vm_host
-        expect(logger).to receive(:log)
-        expect(vm_host).to receive_message_chain(:CreateSnapshot_Task, :wait_for_completion)
-        expect(redis).to receive(:hset).with('vmpooler__vm__testvm', 'snapshot:testsnapshot', Time.now.to_s)
-        expect(logger).to receive(:log)
-
-        subject._create_vm_snapshot('testvm', 'testsnapshot', vsphere)
-      end
-    end
-  end
-
-  describe '#_revert_vm_snapshot' do
-    let(:snapshot_manager) { 'snapshot_manager' }
-    let(:pool_helper) { double('snapshot_manager') }
-    let(:vsphere) { {snapshot_manager => pool_helper} }
-
-    before do
-      expect(subject).not_to be_nil
-      $vsphere = vsphere
-    end
-
-    context '(valid host)' do
-      let(:vm_host) { double('vmhost') }
-      let(:vm_snapshot) { double('vmsnapshot') }
-
-      it 'reverts a snapshot' do
-        expect(vsphere).to receive(:find_vm).and_return vm_host
-        expect(vsphere).to receive(:find_snapshot).and_return vm_snapshot
-        expect(logger).to receive(:log)
-        expect(vm_snapshot).to receive_message_chain(:RevertToSnapshot_Task, :wait_for_completion)
-        expect(logger).to receive(:log)
-
-        subject._revert_vm_snapshot('testvm', 'testsnapshot', vsphere)
-      end
-    end
-  end
-
-  describe '#_check_snapshot_queue' do
-    let(:pool_helper) { double('pool') }
-    let(:vsphere) { {pool => pool_helper} }
-
-    before do
-      expect(subject).not_to be_nil
-      $vsphere = vsphere
-    end
-
-    it 'checks appropriate redis queues' do
-      expect(redis).to receive(:spop).with('vmpooler__tasks__snapshot')
-      expect(redis).to receive(:spop).with('vmpooler__tasks__snapshot-revert')
-
-      subject._check_snapshot_queue(vsphere)
-    end
-  end
-end