Add discovered and partly migrating VM definitions. Spec tests

still failing.

lib/vmpooler/pool_manager.rb

@@ -789,6 +789,38 @@ module Vmpooler
       end
     end
 
+    def check_discovered_pool_vms(pool_name)
+      begin
+        $redis.smembers("vmpooler__discovered__#{pool_name}").each do |vm|
+          %w[pending ready running completed].each do |queue|
+            if $redis.sismember("vmpooler__#{queue}__#{pool_name}", vm)
+              $logger.log('d', "[!] [#{pool_name}] '#{vm}' found in '#{queue}', removed from 'discovered' queue")
+              $redis.srem("vmpooler__discovered__#{pool_name}", vm)
+            end
+          end
+
+          if $redis.sismember("vmpooler__discovered__#{pool_name}", vm)
+            $redis.smove("vmpooler__discovered__#{pool_name}", "vmpooler__completed__#{pool_name}", vm)
+          end
+        end
+      rescue => err
+        $logger.log('d', "[!] [#{pool_name}] _check_pool failed with an error while evaluating discovered VMs: #{err}")
+      end
+    end
+
+    def check_migrating_pool_vms(pool_name, provider, pool_check_response, inventory)
+      $redis.smembers("vmpooler__migrating__#{pool_name}").each do |vm|
+        if inventory[vm]
+          begin
+            pool_check_response[:migrated_vms] += 1
+            migrate_vm(vm, pool_name, provider)
+          rescue => err
+            $logger.log('s', "[x] [#{pool_name}] '#{vm}' failed to migrate: #{err}")
+          end
+        end
+      end
+    end
+
     def _check_pool(pool, provider)
       pool_check_response = {
         discovered_vms: 0,
@@ -814,35 +846,10 @@ module Vmpooler
 
       check_completed_pool_vms(pool['name'], provider, pool_check_response, inventory)
 
-      # DISCOVERED
+      check_discovered_pool_vms(pool['name'])
-      begin
-        $redis.smembers("vmpooler__discovered__#{pool['name']}").each do |vm|
-          %w[pending ready running completed].each do |queue|
-            if $redis.sismember("vmpooler__#{queue}__#{pool['name']}", vm)
-              $logger.log('d', "[!] [#{pool['name']}] '#{vm}' found in '#{queue}', removed from 'discovered' queue")
-              $redis.srem("vmpooler__discovered__#{pool['name']}", vm)
-            end
-          end
 
-          if $redis.sismember("vmpooler__discovered__#{pool['name']}", vm)
+      check_migrating_pool_vms(pool['name'], provider, pool_check_response, inventory)
-            $redis.smove("vmpooler__discovered__#{pool['name']}", "vmpooler__completed__#{pool['name']}", vm)
-          end
-        end
-      rescue => err
-        $logger.log('d', "[!] [#{pool['name']}] _check_pool failed with an error while evaluating discovered VMs: #{err}")
-      end
 
-      # MIGRATIONS
-      $redis.smembers("vmpooler__migrating__#{pool['name']}").each do |vm|
-        if inventory[vm]
-          begin
-            pool_check_response[:migrated_vms] += 1
-            migrate_vm(vm, pool['name'], provider)
-          rescue => err
-            $logger.log('s', "[x] [#{pool['name']}] '#{vm}' failed to migrate: #{err}")
-          end
-        end
-      end
 
       # UPDATE TEMPLATE
       # Evaluates a pool template to ensure templates are prepared adequately for the configured provider

spec/unit/pool_manager_spec.rb

@@ -2819,18 +2819,12 @@ EOT
         # mock response from create_inventory
         {}
       }
-      let(:new_vm) { 'newvm'}
-      let(:new_vm_response) {
-        # Mock response from Base Provider for vms_in_pool
-        [{ 'name' => new_vm}]
-      }
 
       before(:each) do
         create_pending_vm(pool,vm,token)
       end
 
       it 'should call fail_pending_vm' do
-        expect(subject).to receive(:check_ready_vm).exactly(0).times
         expect(subject).to receive(:fail_pending_vm).with(vm,pool,Integer,false)
 
         subject.check_pending_pool_vms(pool, provider, pool_check_response, inventory)
@@ -2903,27 +2897,18 @@ EOT
         # mock response from create_inventory
         {}
       }
-      # let(:new_vm) { 'newvm'}
+
-      # let(:new_vm_response) {
-      #   # Mock response from Base Provider for vms_in_pool
-      #   [{ 'name' => new_vm}]
-      # }
       before(:each) do
-        # expect(provider).to receive(:vms_in_pool).with(pool).and_return(new_vm_response)
-        # expect(logger).to receive(:log).with('s', "[?] [#{pool}] '#{new_vm}' added to 'discovered' queue")
-        # expect(logger).to receive(:log).with('s', "[!] [#{pool}] '#{vm}' not found in inventory, removed from 'completed' queue")
         create_completed_vm(vm,pool,true)
       end
 
       it 'should log a message' do
-        # subject._check_pool(pool_object,provider)
         subject.check_completed_pool_vms(pool, provider, pool_check_response, inventory)
       end
 
       it 'should not call destroy_vm' do
         expect(subject).to receive(:destroy_vm).exactly(0).times
 
-        # subject._check_pool(pool_object,provider)
         subject.check_completed_pool_vms(pool, provider, pool_check_response, inventory)
       end
 
@@ -2932,7 +2917,6 @@ EOT
         expect(redis.hget("vmpooler__vm__#{vm}", 'checkout')).to_not be(nil)
         expect(redis.hget("vmpooler__active__#{pool}",vm)).to_not be(nil)
 
-        # subject._check_pool(pool_object,provider)
         subject.check_completed_pool_vms(pool, provider, pool_check_response, inventory)
 
         expect(redis.sismember("vmpooler__completed__#{pool}",vm)).to be(false)
@@ -2951,22 +2935,19 @@ EOT
         {vm => 1}
       }
       before(:each) do
-        # expect(provider).to receive(:vms_in_pool).with(pool).and_return(vm_response)
         create_completed_vm(vm,pool,true)
       end
 
       it 'should call destroy_vm' do
         expect(subject).to receive(:destroy_vm)
 
-        # subject._check_pool(pool_object,provider)
         subject.check_completed_pool_vms(pool, provider, pool_check_response, inventory)
       end
 
       it 'should return the number of destroyed VMs' do
-        result = subject._check_pool(pool_object,provider)
         subject.check_completed_pool_vms(pool, provider, pool_check_response, inventory)
 
-        expect(result[:destroyed_vms]).to be(1)
+        expect(pool_check_response[:destroyed_vms]).to be(1)
       end
 
       context 'with an error during destroy_vm' do
@@ -2976,7 +2957,6 @@ EOT
         end
 
         it 'should log a message' do
-          subject._check_pool(pool_object,provider)
           subject.check_completed_pool_vms(pool, provider, pool_check_response, inventory)
         end
 
@@ -2985,7 +2965,6 @@ EOT
           expect(redis.hget("vmpooler__vm__#{vm}", 'checkout')).to_not be(nil)
           expect(redis.hget("vmpooler__active__#{pool}",vm)).to_not be(nil)
 
-          subject._check_pool(pool_object,provider)
           subject.check_completed_pool_vms(pool, provider, pool_check_response, inventory)
 
           expect(redis.sismember("vmpooler__completed__#{pool}",vm)).to be(false)
@@ -2996,6 +2975,110 @@ EOT
     end
   end
 
+  describe "#check_discovered_pool_vms" do
+    context 'Discovered VM' do
+      before(:each) do
+        create_discovered_vm(vm,pool)
+      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)
+      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')
+        expect(logger).to receive(:log).with("d", "[!] [#{pool}] _check_pool failed with an error while evaluating discovered VMs: MockError")
+
+        subject.check_discovered_pool_vms(pool)
+      end
+
+      ['pending','ready','running','completed'].each do |queue_name|
+        context "exists in the #{queue_name} queue" do
+          before(:each) do
+            allow(subject).to receive(:migrate_vm)
+            allow(subject).to receive(:check_running_vm)
+            allow(subject).to receive(:check_ready_vm)
+            allow(subject).to receive(:check_pending_vm)
+            allow(subject).to receive(:destroy_vm)
+            allow(subject).to receive(:clone_vm)
+          end
+
+          it "should remain in the #{queue_name} queue" do
+            redis.sadd("vmpooler__#{queue_name}__#{pool}", vm)
+            allow(logger).to receive(:log)
+
+            subject.check_discovered_pool_vms(pool)
+
+            expect(redis.sismember("vmpooler__#{queue_name}__#{pool}", vm)).to be(true)
+          end
+
+          it "should be removed from the discovered queue" do
+            redis.sadd("vmpooler__#{queue_name}__#{pool}", vm)
+            allow(logger).to receive(:log)
+
+            expect(redis.sismember("vmpooler__discovered__#{pool}", vm)).to be(true)
+            subject.check_discovered_pool_vms(pool)
+            expect(redis.sismember("vmpooler__discovered__#{pool}", vm)).to be(false)
+          end
+
+          it "should log a message" do
+            redis.sadd("vmpooler__#{queue_name}__#{pool}", vm)
+            expect(logger).to receive(:log).with('d', "[!] [#{pool}] '#{vm}' found in '#{queue_name}', removed from 'discovered' queue")
+
+            subject.check_discovered_pool_vms(pool)
+          end
+        end
+      end
+    end
+  end
+
+  describe "#check_migrating_pool_vms" do
+    context 'Migrating VM not in the inventory' do
+      before(:each) do
+        expect(provider).to receive(:vms_in_pool).with(pool).and_return(new_vm_response)
+        expect(logger).to receive(:log).with('s', "[?] [#{pool}] '#{new_vm}' added to 'discovered' queue")
+        create_migrating_vm(vm,pool)
+      end
+
+      it 'should not do anything' do
+        expect(subject).to receive(:migrate_vm).exactly(0).times
+
+        subject._check_pool(pool_object,provider)
+      end
+    end
+
+    context 'Migrating VM in the inventory' do
+      before(:each) do
+        expect(provider).to receive(:vms_in_pool).with(pool).and_return(vm_response)
+        allow(subject).to receive(:check_ready_vm)
+        allow(logger).to receive(:log).with("s", "[!] [#{pool}] is empty")
+        create_migrating_vm(vm,pool)
+      end
+
+      it 'should return the number of migrated VMs' do
+        allow(subject).to receive(:migrate_vm).with(vm,pool,provider)
+        result = subject._check_pool(pool_object,provider)
+
+        expect(result[:migrated_vms]).to be(1)
+      end
+
+      it 'should log an error if one occurs' do
+        expect(subject).to receive(:migrate_vm).and_raise(RuntimeError,'MockError')
+        expect(logger).to receive(:log).with('s', "[x] [#{pool}] '#{vm}' failed to migrate: MockError")
+
+        subject._check_pool(pool_object,provider)
+      end
+
+      it 'should call migrate_vm' do
+        expect(subject).to receive(:migrate_vm).with(vm,pool,provider)
+
+        subject._check_pool(pool_object,provider)
+      end
+    end
+  end
+
   describe '#_check_pool' do
     let(:new_vm_response) {
       # Mock response from Base Provider for vms_in_pool
@@ -3195,109 +3278,51 @@ EOT
 
 
     # COMPLETED
+    context 'when checking completed VMs' do
+      let(:pool_check_response) {
+        {
+            discovered_vms: 0,
+            checked_running_vms: 0,
+            checked_ready_vms: 0,
+            checked_pending_vms: 0,
+            destroyed_vms: 0,
+            migrated_vms: 0,
+            cloned_vms: 0
+        }
+      }
+
+      it 'should call #check_completed_pool_vms' do
+        allow(subject).to receive(:create_inventory).and_return({})
+        expect(subject).to receive(:check_completed_pool_vms).with(pool, provider, pool_check_response, {})
+
+        subject._check_pool(pool_object,provider)
+      end
+    end
 
     # DISCOVERED
-    context 'Discovered VM' do
+    context 'when checking discovered VMs' do
-      before(:each) do
+      let(:pool_check_response) {
-        expect(provider).to receive(:vms_in_pool).with(pool).and_return(vm_response)
+        {
-        create_discovered_vm(vm,pool)
+            discovered_vms: 0,
-      end
+            checked_running_vms: 0,
+            checked_ready_vms: 0,
+            checked_pending_vms: 0,
+            destroyed_vms: 0,
+            migrated_vms: 0,
+            cloned_vms: 0
+        }
+      }
 
-      it 'should be moved to the completed queue' do
+      it 'should call #check_discovered_pool_vms' do
-        subject._check_pool(pool_object,provider)
+        allow(subject).to receive(:create_inventory).and_return({})
-
+        expect(subject).to receive(:check_discovered_pool_vms).with(pool)
-        expect(redis.sismember("vmpooler__completed__#{pool}", vm)).to be(true)
-      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')
-        expect(logger).to receive(:log).with("d", "[!] [#{pool}] _check_pool failed with an error while evaluating discovered VMs: MockError")
 
         subject._check_pool(pool_object,provider)
       end
-
-      ['pending','ready','running','completed'].each do |queue_name|
-        context "exists in the #{queue_name} queue" do
-          before(:each) do
-            allow(subject).to receive(:migrate_vm)
-            allow(subject).to receive(:check_running_vm)
-            allow(subject).to receive(:check_ready_vm)
-            allow(subject).to receive(:check_pending_vm)
-            allow(subject).to receive(:destroy_vm)
-            allow(subject).to receive(:clone_vm)
-          end
-
-          it "should remain in the #{queue_name} queue" do
-            redis.sadd("vmpooler__#{queue_name}__#{pool}", vm)
-            allow(logger).to receive(:log)
-
-            subject._check_pool(pool_object,provider)
-
-            expect(redis.sismember("vmpooler__#{queue_name}__#{pool}", vm)).to be(true)
-          end
-
-          it "should be removed from the discovered queue" do
-            redis.sadd("vmpooler__#{queue_name}__#{pool}", vm)
-            allow(logger).to receive(:log)
-
-            expect(redis.sismember("vmpooler__discovered__#{pool}", vm)).to be(true)
-            subject._check_pool(pool_object,provider)
-            expect(redis.sismember("vmpooler__discovered__#{pool}", vm)).to be(false)
-          end
-
-          it "should log a message" do
-            redis.sadd("vmpooler__#{queue_name}__#{pool}", vm)
-            expect(logger).to receive(:log).with('d', "[!] [#{pool}] '#{vm}' found in '#{queue_name}', removed from 'discovered' queue")
-
-            subject._check_pool(pool_object,provider)
-          end
-        end
-      end
     end
 
     # MIGRATIONS
-    context 'Migrating VM not in the inventory' do
-      before(:each) do
-        expect(provider).to receive(:vms_in_pool).with(pool).and_return(new_vm_response)
-        expect(logger).to receive(:log).with('s', "[?] [#{pool}] '#{new_vm}' added to 'discovered' queue")
-        create_migrating_vm(vm,pool)
-      end
 
-      it 'should not do anything' do
-        expect(subject).to receive(:migrate_vm).exactly(0).times
-
-        subject._check_pool(pool_object,provider)
-      end
-    end
-
-    context 'Migrating VM in the inventory' do
-      before(:each) do
-        expect(provider).to receive(:vms_in_pool).with(pool).and_return(vm_response)
-        allow(subject).to receive(:check_ready_vm)
-        allow(logger).to receive(:log).with("s", "[!] [#{pool}] is empty")
-        create_migrating_vm(vm,pool)
-      end
-
-      it 'should return the number of migrated VMs' do
-        allow(subject).to receive(:migrate_vm).with(vm,pool,provider)
-        result = subject._check_pool(pool_object,provider)
-
-        expect(result[:migrated_vms]).to be(1)
-      end
-
-      it 'should log an error if one occurs' do
-        expect(subject).to receive(:migrate_vm).and_raise(RuntimeError,'MockError')
-        expect(logger).to receive(:log).with('s', "[x] [#{pool}] '#{vm}' failed to migrate: MockError")
-
-        subject._check_pool(pool_object,provider)
-      end
-
-      it 'should call migrate_vm' do
-        expect(subject).to receive(:migrate_vm).with(vm,pool,provider)
-
-        subject._check_pool(pool_object,provider)
-      end
-    end
 
     # REPOPULATE
     context 'Repopulate a pool' do