Adding specs to test fetching availabilities from event catcher

Components being tested are:
* Persister and parser of targeted refresh. Collector is implicitly
  tested with parser.
* New fuctions of event catcher's stream. Some existing test are
  slightly complemented.

Some existing tests were adjusted due to small refactors for code
reusability and avoid repeating stuff.

app/models/manageiq/providers/hawkular/inventory/availability_updates.rb

@@ -1,6 +1,9 @@
 module ManageIQ::Providers
   class Hawkular::Inventory::AvailabilityUpdates
-    delegate :select, :to => :@targets
+    attr_reader :targets
+
+    delegate :select, :to => :targets
+    delegate :<<, :to => :targets
 
     def initialize(targets)
       @targets = targets

app/models/manageiq/providers/hawkular/inventory/parser/availability_updates.rb

@@ -5,6 +5,8 @@ def parse
       fetch_deployment_availabilities
     end
 
+    private
+
     def fetch_server_availabilities
       collector.server_updates.each do |item|
         server = persister.middleware_servers.find_or_build(item.manager_ref[:ems_ref])

app/models/manageiq/providers/hawkular/inventory/persister/availability_updates.rb

@@ -18,20 +18,22 @@ def self.save_deployments(ems, collection)
     def self.save_servers(ems, collection)
       ::ActiveRecord::Base.transaction do
         collection.to_a.each do |item|
+          data_to_update = item.properties.try(:slice, 'Server State', 'Availability', 'Calculated Server State')
+          next if data_to_update.blank?
+
           server = ems.middleware_servers.find_by(:ems_ref => item.manager_uuid)
           next unless server # if no matching server is in the database, there is nothing to update
 
           $mw_log.debug("EMS_#{ems.id}(Persister::AvailabilityUpdates): " \
                         "Updating status to #{item.properties} for server #{server.ems_ref}")
 
-          server.properties = {} unless server.properties
-          server.properties.merge!(item.properties)
+          server.properties = {} if server.properties.blank?
+          server.properties.merge!(data_to_update)
           server.save!
         end
       end
     end
 
-    # has_middleware_manager_servers
     has_middleware_manager_deployments(:custom_save_block => method(:save_deployments))
     has_middleware_manager_servers(:custom_save_block => method(:save_servers))
   end

app/models/manageiq/providers/hawkular/middleware_manager/event_catcher/stream.rb

@@ -57,8 +57,8 @@ def fetch_availabilities
   end
 
   def fetch_server_availabilities(parser)
-    # For servers, it's also needed to refresh server state from inventory.
-    $mw_log.debug("#{log_prefix} Retrieving server state from Hawkular inventory")
+    # For servers, it's also needed to refresh server states from inventory.
+    $mw_log.debug("#{log_prefix} Retrieving server states from Hawkular inventory")
 
     server_states = {}
     @ems.middleware_servers.reload.each do |server|
@@ -106,7 +106,7 @@ def fetch_deployment_availabilities(parser)
   end
 
   def fetch_entities_availabilities(parser, entities)
-    return {} if entities.blank?
+    return [] if entities.blank?
     log_name = entities.first.class.name.demodulize
 
     # Get feeds where availabilities should be looked in.

spec/contexts/targeted_avail_updates.rb

@@ -0,0 +1,12 @@
+RSpec.shared_context 'targeted_avail_updates' do
+  let(:ems_hawkular) { FactoryGirl.create(:ems_hawkular) }
+  let(:target) { ::ManageIQ::Providers::Hawkular::Inventory::AvailabilityUpdates.new([]) }
+  let(:persister) { ::ManageIQ::Providers::Hawkular::Inventory::Persister::AvailabilityUpdates.new(ems_hawkular, target) }
+  let(:collector) { ::ManageIQ::Providers::Hawkular::Inventory::Collector::AvailabilityUpdates.new(ems_hawkular, target) }
+  let(:parser) do
+    parser = described_class.new
+    parser.collector = collector
+    parser.persister = persister
+    parser
+  end
+end

spec/models/manageiq/providers/hawkular/inventory/parser/availability_updates_spec.rb

@@ -0,0 +1,97 @@
+describe ManageIQ::Providers::Hawkular::Inventory::Parser::AvailabilityUpdates do
+  describe "#parse" do
+    include_context 'targeted_avail_updates'
+
+    it "must create an item in persister with new status data for each server reported by collector" do
+      # Setup
+      avail_data = {
+        'Availability'            => 'up',
+        'Server State'            => 'running',
+        'Calculated Server State' => 'running'
+      }
+
+      target << ManagerRefresh::Target.new(
+        :manager     => ems_hawkular,
+        :association => :middleware_servers,
+        :manager_ref => { :ems_ref => 'abc' },
+        :options     => avail_data
+      )
+
+      # Try
+      parser.parse
+
+      # Verify
+      item = persister.middleware_servers.find('abc')
+      expect(item).to be
+      expect(item.manager_uuid).to eq('abc')
+      expect(item.properties).to eq(avail_data)
+
+      expect(persister.middleware_deployments.size).to be_zero
+    end
+
+    it "must create an item in persister with new status data for each deployment reported by collector" do
+      # Setup
+      target << ManagerRefresh::Target.new(
+        :manager     => ems_hawkular,
+        :association => :middleware_deployments,
+        :manager_ref => { :ems_ref => 'def' },
+        :options     => { :status => 'ready' }
+      )
+
+      # Try
+      parser.parse
+
+      # Verify
+      item = persister.middleware_deployments.find('def')
+      expect(item).to be
+      expect(item.manager_uuid).to eq('def')
+      expect(item.status).to eq('ready')
+
+      expect(persister.middleware_servers.size).to be_zero
+    end
+
+    it "must create one persister item if two servers in collector have same ems_ref" do
+      # Setup
+      target << ManagerRefresh::Target.new(
+        :manager     => ems_hawkular,
+        :association => :middleware_servers,
+        :manager_ref => { :ems_ref => 'abc' },
+        :options     => { 'Server State' => 'ok' }
+      )
+      target << ManagerRefresh::Target.new(
+        :manager     => ems_hawkular,
+        :association => :middleware_servers,
+        :manager_ref => { :ems_ref => 'abc' },
+        :options     => { 'Server State' => 'not ok' }
+      )
+
+      # Try
+      parser.parse
+
+      # Verify
+      expect(persister.middleware_servers.size).to eq(1)
+    end
+
+    it "must create one persister item if two deployments in collector have same ems_ref" do
+      # Setup
+      target << ManagerRefresh::Target.new(
+        :manager     => ems_hawkular,
+        :association => :middleware_deployments,
+        :manager_ref => { :ems_ref => 'def' },
+        :options     => { :status => 'ready' }
+      )
+      target << ManagerRefresh::Target.new(
+        :manager     => ems_hawkular,
+        :association => :middleware_deployments,
+        :manager_ref => { :ems_ref => 'def' },
+        :options     => { :status => 'not ready' }
+      )
+
+      # Try
+      parser.parse
+
+      # Verify
+      expect(persister.middleware_deployments.size).to eq(1)
+    end
+  end
+end

spec/models/manageiq/providers/hawkular/inventory/parser/middleware_manager_spec.rb

@@ -180,7 +180,13 @@ def call_subject(feeds = %w(f1), resources = [stubbed_resource])
     let(:stubbed_deployment) { OpenStruct.new(:manager_uuid => '/t;hawkular/f;f1/r;s1/r;d1') }
 
     before do
-      allow(persister_double).to receive(:middleware_deployments).and_return([stubbed_deployment])
+      deployments_collection = [stubbed_deployment]
+      deployments_collection.define_singleton_method(
+        :model_class,
+        -> { ::ManageIQ::Providers::Hawkular::MiddlewareManager::MiddlewareDeployment }
+      )
+
+      allow(persister_double).to receive(:middleware_deployments).and_return(deployments_collection)
       allow(parser).to receive(:fetch_availabilities_for)
         .and_yield(stubbed_deployment, stubbed_metric_data)
     end
@@ -221,7 +227,13 @@ def call_subject(feeds = %w(f1), resources = [stubbed_resource])
 
   describe 'fetch_server_availabilities' do
     before do
-      allow(persister_double).to receive(:middleware_servers).and_return([server])
+      server_collection = [server]
+      server_collection.define_singleton_method(
+        :model_class,
+        -> { ::ManageIQ::Providers::Hawkular::MiddlewareManager::MiddlewareServer }
+      )
+
+      allow(persister_double).to receive(:middleware_servers).and_return(server_collection)
       allow(parser).to receive(:fetch_availabilities_for)
         .and_yield(server, stubbed_metric_data)
     end

spec/models/manageiq/providers/hawkular/inventory/persister/availability_updates_spec.rb

@@ -0,0 +1,108 @@
+describe ::ManageIQ::Providers::Hawkular::Inventory::Persister::AvailabilityUpdates do
+  include_context 'targeted_avail_updates'
+
+  describe '#save_servers' do
+    let!(:db_server1) { ems_hawkular.middleware_servers.create(:ems_ref => 'server1', :feed => 'f1') }
+    let!(:db_server2) { ems_hawkular.middleware_servers.create(:ems_ref => 'server2', :feed => 'f1', :properties => { 'Server State' => 'unknown' }) }
+
+    it 'must update status of servers with no properties in database' do
+      # Set-up
+      updated_server = persister.middleware_servers.build(:ems_ref => 'server1', :properties => { 'Availability' => 'up' })
+      persister.middleware_servers << updated_server
+
+      # Try
+      described_class.save_servers(ems_hawkular, persister.middleware_servers)
+
+      # Verify
+      db_server1.reload
+      db_server2.reload
+      expect(db_server1.properties).to eq('Availability' => 'up')
+      expect(db_server2.properties).to eq('Server State' => 'unknown') # Check the other one wasn't updated
+    end
+
+    it 'must update only status related fields' do
+      # Set-up
+      db_server1.properties = { 'Some other data' => 'value' }
+      db_server1.save!
+
+      updated_server = persister.middleware_servers.build(
+        :ems_ref    => 'server1',
+        :properties => {
+          'Availability'            => 'up',
+          'spurious field'          => 'ok',
+          'Server State'            => 'running',
+          'Calculated Server State' => 'down'
+        }
+      )
+      persister.middleware_servers << updated_server
+
+      # Try
+      described_class.save_servers(ems_hawkular, persister.middleware_servers)
+
+      # Verify
+      db_server1.reload
+      expect(db_server1.properties).to eq(
+        'Availability'            => 'up',
+        'Server State'            => 'running',
+        'Calculated Server State' => 'down',
+        'Some other data'         => 'value'
+      )
+    end
+
+    it 'must ignore servers not found in database' do
+      # Set-up
+      updated_server = persister.middleware_servers.build(:ems_ref => 'server7', :properties => { 'Server State' => 'new status' })
+      persister.middleware_servers << updated_server
+
+      # Try
+      described_class.save_servers(ems_hawkular, persister.middleware_servers)
+
+      # Verify
+      db_server1.reload
+      db_server2.reload
+      expect(db_server1.properties).to be_blank
+      expect(db_server2.properties).to eq('Server State' => 'unknown')
+
+      ems_hawkular.middleware_servers.reload
+      expect(ems_hawkular.middleware_servers.count).to eq(2)
+    end
+  end
+
+  describe '#save_deployments' do
+    let!(:db_deployment1) { ems_hawkular.middleware_deployments.create(:ems_ref => 'deployment1', :status => 'old status') }
+    let!(:db_deployment2) { ems_hawkular.middleware_deployments.create(:ems_ref => 'deployment2', :status => 'old status') }
+
+    it 'must update status of specified deployments' do
+      # Set-up
+      updated_deployment = persister.middleware_deployments.build(:ems_ref => 'deployment1', :status => 'new status')
+      persister.middleware_deployments << updated_deployment
+
+      # Try
+      described_class.save_deployments(ems_hawkular, persister.middleware_deployments)
+
+      # Verify
+      db_deployment1.reload
+      db_deployment2.reload
+      expect(db_deployment1.status).to eq('new status')
+      expect(db_deployment2.status).to eq('old status')
+    end
+
+    it 'must ignore deployments not found in database' do
+      # Set-up
+      updated_deployment = persister.middleware_deployments.build(:ems_ref => 'deployment7', :status => 'new status')
+      persister.middleware_deployments << updated_deployment
+
+      # Try
+      described_class.save_deployments(ems_hawkular, persister.middleware_deployments)
+
+      # Verify
+      db_deployment1.reload
+      db_deployment2.reload
+      expect(db_deployment1.status).to eq('old status')
+      expect(db_deployment2.status).to eq('old status')
+
+      ems_hawkular.middleware_deployments.reload
+      expect(ems_hawkular.middleware_deployments.count).to eq(2)
+    end
+  end
+end