qa_server 7.3.0 → 7.7.0

data/app/presenters/qa_server/monitor_status/current_status_presenter.rb

@@ -13,12 +13,13 @@ module QaServer::MonitorStatus
 
     # @return [ActiveSupport::TimeWithZone] date time stamp of last test run
     def last_updated_dt
-      @current_summary.run_dt_stamp
+      @current_summary ? @current_summary.run_dt_stamp : QaServer::TimeService.current_time
     end
 
     # @return [String] date with time of last test run
     def last_updated
-      QaServer::TimeService.pretty_time(last_updated_dt)
+      return I18n.t('qa_server.monitor_status.summary.no_data') if @current_summary.blank?
+      I18n.t('qa_server.monitor_status.summary.last_updated', date: QaServer::TimeService.pretty_time(last_updated_dt))
     end
 
     # @return [ActiveSupport::TimeWithZone] date time stamp of first recorded test run
@@ -33,12 +34,12 @@ module QaServer::MonitorStatus
 
     # @return [Integer] number of loaded authorities
     def authorities_count
-      @current_summary.authority_count
+      @current_summary ? @current_summary.authority_count : "N/A"
     end
 
     # @return [Integer] number of authorities with failing tests in the latest test run
     def failing_authorities_count
-      @current_failure_data.map { |f| f[:authority_name] }.uniq.count
+      @current_failure_data ? @current_failure_data.map { |f| f[:authority_name] }.uniq.count : "N/A"
     end
 
     # @return [String] css style class representing whether all tests passed or any failed
@@ -48,17 +49,17 @@ module QaServer::MonitorStatus
 
     # @return [Integer] number of tests in the latest test run
     def tests_count
-      @current_summary.total_scenario_count
+      @current_summary ? @current_summary.total_scenario_count : 0
     end
 
     # @return [Integer] number of passing tests in the latest test run
     def passing_tests_count
-      @current_summary.passing_scenario_count
+      @current_summary ? @current_summary.passing_scenario_count : 0
     end
 
     # @return [Integer] number of failing tests in the latest test run
     def failing_tests_count
-      @current_summary.failing_scenario_count
+      @current_summary ? @current_summary.failing_scenario_count : 0
     end
 
     # @return [String] css style class representing whether all tests passed or any failed
@@ -77,7 +78,7 @@ module QaServer::MonitorStatus
     #       url: '/qa/search/linked_data/locnames_ld4l_cache/person?q=mark twain&maxRecords=4',
     #       err_message: 'Exception: Something went wrong.' }, ... ]
     def failures
-      @current_failure_data
+      @current_failure_data ? @current_failure_data : []
     end
 
     # @return [Boolean] true if failure data exists for the latest test run; otherwise false

data/app/presenters/qa_server/monitor_status/history_presenter.rb

@@ -2,6 +2,9 @@
 # This presenter class provides historical testing data needed by the view that monitors status of authorities.
 module QaServer::MonitorStatus
   class HistoryPresenter
+    CAUTION_THRESHOLD = 0.05
+    WARNING_THRESHOLD = 0.1
+
     # @param parent [QaServer::MonitorStatusPresenter] parent presenter
     # @param historical_summary_data [Array<Hash>] summary of past failuring runs per authority to drive chart
     def initialize(parent:, historical_summary_data:)
@@ -94,8 +97,8 @@ module QaServer::MonitorStatus
     end
 
     def failure_style_class(historical_entry)
-      return "status-neutral" if days_authority_failing(historical_entry) <= 0
-      percent_authority_failing(historical_entry) < 0.10 ? "status-unknown" : "status-bad"
+      return "status-neutral" if days_authority_failing(historical_entry) <= CAUTION_THRESHOLD
+      percent_authority_failing(historical_entry) < WARNING_THRESHOLD ? "status-unknown" : "status-bad"
     end
 
     def passing_style_class(historical_entry)

data/app/services/concerns/qa_server/gruff_graph.rb

@@ -5,24 +5,24 @@ require 'gruff'
 # This module include provides graph methods for generating graphs with Gruff
 module QaServer
   module GruffGraph
-    private
+  private
 
-      # common path for displaying and writing
-      def graph_relative_path
-        File.join('qa_server', 'charts')
-      end
+    # common path for displaying and writing
+    def graph_relative_path
+      File.join('qa_server', 'charts')
+    end
 
-      # used for displaying in a view with <image> tag
-      def graph_image_path
-        File.join('/', graph_relative_path)
-      end
+    # used for displaying in a view with <image> tag
+    def graph_image_path
+      File.join('/', graph_relative_path)
+    end
 
-      # used for writing out the file
-      def graph_full_path(graph_filename)
-        path = Rails.root.join('public', graph_relative_path)
-        # path = Rails.root.join('app', 'assets', 'images', graph_relative_path)
-        FileUtils.mkdir_p path
-        File.join(path, graph_filename)
-      end
+    # used for writing out the file
+    def graph_full_path(graph_filename)
+      path = Rails.root.join('public', graph_relative_path)
+      # path = Rails.root.join('app', 'assets', 'images', graph_relative_path)
+      FileUtils.mkdir_p path
+      File.join(path, graph_filename)
+    end
   end
 end

data/app/services/qa_server/authority_loader_service.rb

@@ -22,24 +22,24 @@ module QaServer
         authority
       end
 
-      private
+    private
 
-        def authority_key(authority_name)
-          authority_name.upcase.to_sym
-        end
+      def authority_key(authority_name)
+        authority_name.upcase.to_sym
+      end
 
-        def load_authority(authority_name, status_log)
-          authority = Qa::Authorities::LinkedData::GenericAuthority.new(authority_key(authority_name))
-          if authority.blank?
-            if status_log.present?
-              status_log.add(authority_name: authority_name,
-                             status: QaServer::ScenarioValidator::FAIL,
-                             error_message: "Unable to load authority '#{authority_name}'; cause: UNKNOWN")
-            end
-            return nil
+      def load_authority(authority_name, status_log)
+        authority = Qa::Authorities::LinkedData::GenericAuthority.new(authority_key(authority_name))
+        if authority.blank?
+          if status_log.present?
+            status_log.add(authority_name: authority_name,
+                           status: QaServer::ScenarioValidator::FAIL,
+                           error_message: "Unable to load authority '#{authority_name}'; cause: UNKNOWN")
           end
-          authority
+          return nil
         end
+        authority
+      end
     end
   end
 end

data/app/services/qa_server/authority_validator_service.rb

@@ -14,6 +14,7 @@ module QaServer
 
     VALIDATE_CONNECTIONS = validator_class::VALIDATE_CONNECTION
     VALIDATE_ACCURACY = validator_class::VALIDATE_ACCURACY
+    VALIDATE_ACCURACY_COMPARISON = validator_class::VALIDATE_ACCURACY_COMPARISON
     ALL_VALIDATIONS = validator_class::ALL_VALIDATIONS
     DEFAULT_VALIDATION_TYPE = validator_class::DEFAULT_VALIDATION_TYPE
 

data/app/services/qa_server/database_migrator.rb

@@ -50,22 +50,22 @@ module QaServer
       end
     end
 
-    private
+  private
 
-      def migrations
-        Dir.chdir(self.class.migrations_dir) { Dir.glob('db/migrate/[0-9]*_*.rb.erb') }.sort
-      end
+    def migrations
+      Dir.chdir(self.class.migrations_dir) { Dir.glob('db/migrate/[0-9]*_*.rb.erb') }.sort
+    end
 
-      def parse_basename_from(filename)
-        # Add engine name to filename to mimic ``ActiveRecord::Migration.copy` behavior
-        filename.slice(/(?<dateprefix>\d)+_(?<basename>.+)\.erb/, 'basename').sub('.', '.qa_server.')
-      end
+    def parse_basename_from(filename)
+      # Add engine name to filename to mimic ``ActiveRecord::Migration.copy` behavior
+      filename.slice(/(?<dateprefix>\d)+_(?<basename>.+)\.erb/, 'basename').sub('.', '.qa_server.')
+    end
 
-      def migration_version
-        # Don't use AR migration versioning in Rails 4
-        return if Rails.version < '5.0.0'
-        # Specify the current major.minor version of Rails for AR migrations
-        "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
-      end
+    def migration_version
+      # Don't use AR migration versioning in Rails 4
+      return if Rails.version < '5.0.0'
+      # Specify the current major.minor version of Rails for AR migrations
+      "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
+    end
   end
 end

data/app/services/qa_server/history_graphing_service.rb

@@ -29,41 +29,41 @@ module QaServer
         QaServer.config.monitor_logger.warn("FAILED to write historical graph at #{history_graph_image_path}") unless history_graph_image_exists?
       end
 
-      private
+    private
 
-        def create_gruff_graph(reworked_data, full_path)
-          g = Gruff::SideStackedBar.new
-          historical_graph_theme(g)
-          g.labels = reworked_data[0]
-          g.data('Fail', reworked_data[1])
-          g.data('Pass', reworked_data[2])
-          g.write full_path
-        end
+      def create_gruff_graph(reworked_data, full_path)
+        g = Gruff::SideStackedBar.new
+        historical_graph_theme(g)
+        g.labels = reworked_data[0]
+        g.data('Fail', reworked_data[1])
+        g.data('Pass', reworked_data[2])
+        g.write full_path
+      end
 
-        def historical_graph_theme(g)
-          g.theme_pastel
-          g.colors = ['#ffcccc', '#ccffcc']
-          g.marker_font_size = 12
-          g.x_axis_increment = 10
-        end
+      def historical_graph_theme(g)
+        g.theme_pastel
+        g.colors = ['#ffcccc', '#ccffcc']
+        g.marker_font_size = 12
+        g.x_axis_increment = 10
+      end
 
-        def historical_graph_full_path
-          graph_full_path(HISTORICAL_GRAPH_FILENAME)
-        end
+      def historical_graph_full_path
+        graph_full_path(HISTORICAL_GRAPH_FILENAME)
+      end
 
-        def rework_historical_data_for_gruff(data)
-          labels = {}
-          pass_data = []
-          fail_data = []
-          i = 0
-          data.each do |authname, authdata|
-            labels[i] = authname
-            i += 1
-            fail_data << authdata[:bad]
-            pass_data << authdata[:good]
-          end
-          [labels, fail_data, pass_data]
+      def rework_historical_data_for_gruff(data)
+        labels = {}
+        pass_data = []
+        fail_data = []
+        i = 0
+        data.each do |authname, authdata|
+          labels[i] = authname
+          i += 1
+          fail_data << authdata[:bad]
+          pass_data << authdata[:good]
         end
+        [labels, fail_data, pass_data]
+      end
     end
   end
 end

data/app/services/qa_server/performance_calculator_service.rb

@@ -40,85 +40,85 @@ module QaServer
       stats
     end
 
-    private
-
-      def calculate_load_stats(avg, low, high)
-        stats[AVG_LOAD] = calculate_average(full_load_times) if avg
-        stats[LOW_LOAD] = calculate_10th_percentile(full_load_times) if low
-        stats[HIGH_LOAD] = calculate_90th_percentile(full_load_times) if high
-      end
-
-      def calculate_retrieve_stats(avg, low, high)
-        stats[AVG_RETR] = calculate_average(retrieve_times) if avg
-        stats[LOW_RETR] = calculate_10th_percentile(retrieve_times) if low
-        stats[HIGH_RETR] = calculate_90th_percentile(retrieve_times) if high
-      end
-
-      def calculate_graph_load_stats(avg, low, high)
-        stats[AVG_GRPH] = calculate_average(graph_load_times) if avg
-        stats[LOW_GRPH] = calculate_10th_percentile(graph_load_times) if low
-        stats[HIGH_GRPH] = calculate_90th_percentile(graph_load_times) if high
-      end
-
-      def calculate_normalization_stats(avg, low, high)
-        stats[AVG_NORM] = calculate_average(norm_times) if avg
-        stats[LOW_NORM] = calculate_10th_percentile(norm_times) if low
-        stats[HIGH_NORM] = calculate_90th_percentile(norm_times) if high
-      end
-
-      def calculate_action_stats(avg, low, high)
-        stats[AVG_ACTN] = calculate_average(action_times) if avg
-        stats[LOW_ACTN] = calculate_10th_percentile(action_times) if low
-        stats[HIGH_ACTN] = calculate_90th_percentile(action_times) if high
-      end
-
-      def tenth_percentile_count(times)
-        percentile_count = (times.count * 0.1).round
-        percentile_count = 1 if percentile_count.zero? && times.count > 1
-        percentile_count
-      end
-
-      def times(column)
-        where_clause = action.nil? ? "" : { "action" => action }
-        records.where(where_clause).where.not(column => nil).order(column).pluck(column)
-      end
-
-      def full_load_times
-        @full_load_times ||= times(:retrieve_plus_graph_load_time_ms)
-      end
-
-      def retrieve_times
-        @retrieve_times ||= times(:retrieve_time_ms)
-      end
-
-      def graph_load_times
-        @graph_load_times ||= times(:graph_load_time_ms)
-      end
-
-      def norm_times
-        @norm_times ||= times(:normalization_time_ms)
-      end
-
-      def action_times
-        @action_times ||= times(:action_time_ms)
-      end
-
-      def calculate_average(times)
-        return 0 if times.count.zero?
-        return times[0] if times.count == 1
-        times.inject(0.0) { |sum, el| sum + el } / times.count
-      end
-
-      def calculate_10th_percentile(times)
-        return 0 if times.count.zero?
-        return times[0] if times.count == 1
-        times[tenth_percentile_count(times) - 1]
-      end
-
-      def calculate_90th_percentile(times)
-        return 0 if times.count.zero?
-        return times[0] if times.count == 1
-        times[times.count - tenth_percentile_count(times)]
-      end
+  private
+
+    def calculate_load_stats(avg, low, high)
+      stats[AVG_LOAD] = calculate_average(full_load_times) if avg
+      stats[LOW_LOAD] = calculate_10th_percentile(full_load_times) if low
+      stats[HIGH_LOAD] = calculate_90th_percentile(full_load_times) if high
+    end
+
+    def calculate_retrieve_stats(avg, low, high)
+      stats[AVG_RETR] = calculate_average(retrieve_times) if avg
+      stats[LOW_RETR] = calculate_10th_percentile(retrieve_times) if low
+      stats[HIGH_RETR] = calculate_90th_percentile(retrieve_times) if high
+    end
+
+    def calculate_graph_load_stats(avg, low, high)
+      stats[AVG_GRPH] = calculate_average(graph_load_times) if avg
+      stats[LOW_GRPH] = calculate_10th_percentile(graph_load_times) if low
+      stats[HIGH_GRPH] = calculate_90th_percentile(graph_load_times) if high
+    end
+
+    def calculate_normalization_stats(avg, low, high)
+      stats[AVG_NORM] = calculate_average(norm_times) if avg
+      stats[LOW_NORM] = calculate_10th_percentile(norm_times) if low
+      stats[HIGH_NORM] = calculate_90th_percentile(norm_times) if high
+    end
+
+    def calculate_action_stats(avg, low, high)
+      stats[AVG_ACTN] = calculate_average(action_times) if avg
+      stats[LOW_ACTN] = calculate_10th_percentile(action_times) if low
+      stats[HIGH_ACTN] = calculate_90th_percentile(action_times) if high
+    end
+
+    def tenth_percentile_count(times)
+      percentile_count = (times.count * 0.1).round
+      percentile_count = 1 if percentile_count.zero? && times.count > 1
+      percentile_count
+    end
+
+    def times(column)
+      where_clause = action.nil? ? "" : { "action" => action }
+      records.where(where_clause).where.not(column => nil).order(column).pluck(column)
+    end
+
+    def full_load_times
+      @full_load_times ||= times(:retrieve_plus_graph_load_time_ms)
+    end
+
+    def retrieve_times
+      @retrieve_times ||= times(:retrieve_time_ms)
+    end
+
+    def graph_load_times
+      @graph_load_times ||= times(:graph_load_time_ms)
+    end
+
+    def norm_times
+      @norm_times ||= times(:normalization_time_ms)
+    end
+
+    def action_times
+      @action_times ||= times(:action_time_ms)
+    end
+
+    def calculate_average(times)
+      return 0 if times.count.zero?
+      return times[0] if times.count == 1
+      times.inject(0.0) { |sum, el| sum + el } / times.count
+    end
+
+    def calculate_10th_percentile(times)
+      return 0 if times.count.zero?
+      return times[0] if times.count == 1
+      times[tenth_percentile_count(times) - 1]
+    end
+
+    def calculate_90th_percentile(times)
+      return 0 if times.count.zero?
+      return times[0] if times.count == 1
+      times[times.count - tenth_percentile_count(times)]
+    end
   end
 end