qa_server 7.2.1 → 7.6.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/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

data/app/services/qa_server/performance_datatable_service.rb

@@ -32,48 +32,48 @@ module QaServer
         end
       end
 
-      private
+    private
 
-        def datatable_data_for_authority(authority_name: nil)
-          [:search, :fetch, :all_actions].each_with_object({}) do |action, hash|
-            hash[action] = data_table_stats(authority_name, action)
-          end
+      def datatable_data_for_authority(authority_name: nil)
+        [:search, :fetch, :all_actions].each_with_object({}) do |action, hash|
+          hash[action] = data_table_stats(authority_name, action)
         end
+      end
 
-        # Get statistics for data table.
-        # @param auth_name [String] limit statistics to records for the given authority (default: all authorities)
-        # @param action [Symbol] one of :search, :fetch, :all_actions
-        # @returns [Hash] performance statistics for the datatable during the expected time period
-        # @example
-        #   { retrieve_avg_ms: 12.3, graph_load_avg_ms: 2.1, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5,
-        #     retrieve_10th_ms: 12.3, graph_load_10th_ms: 12.3, normalization_10th_ms: 4.2, full_request_10th_ms: 16.5,
-        #     retrieve_90th_ms: 12.3, graph_load_90th_ms: 12.3, normalization_90th_ms: 4.2, full_request_90th_ms: 16.5 }
-        def data_table_stats(auth_name, action)
-          records = records_for_authority(auth_name)
-          stats_calculator_class.new(records, action: action).calculate_stats_with_percentiles
-        end
+      # Get statistics for data table.
+      # @param auth_name [String] limit statistics to records for the given authority (default: all authorities)
+      # @param action [Symbol] one of :search, :fetch, :all_actions
+      # @returns [Hash] performance statistics for the datatable during the expected time period
+      # @example
+      #   { retrieve_avg_ms: 12.3, graph_load_avg_ms: 2.1, normalization_avg_ms: 4.2, full_request_avg_ms: 16.5,
+      #     retrieve_10th_ms: 12.3, graph_load_10th_ms: 12.3, normalization_10th_ms: 4.2, full_request_10th_ms: 16.5,
+      #     retrieve_90th_ms: 12.3, graph_load_90th_ms: 12.3, normalization_90th_ms: 4.2, full_request_90th_ms: 16.5 }
+      def data_table_stats(auth_name, action)
+        records = records_for_authority(auth_name)
+        stats_calculator_class.new(records, action: action).calculate_stats_with_percentiles
+      end
 
-        def expected_time_period
-          QaServer.config.performance_datatable_default_time_period
-        end
+      def expected_time_period
+        QaServer.config.performance_datatable_default_time_period
+      end
 
-        def records_for_authority(auth_name)
-          case expected_time_period
-          when :day
-            QaServer.config.performance_cache.write_all # only need to write if just using today's data
-            performance_data_class.where(QaServer::TimePeriodService.where_clause_for_last_24_hours(auth_name: auth_name))
-          when :month
-            performance_data_class.where(QaServer::TimePeriodService.where_clause_for_last_30_days(auth_name: auth_name))
-          when :year
-            performance_data_class.where(QaServer::TimePeriodService.where_clause_for_last_12_months(auth_name: auth_name))
-          else
-            all_records(auth_name)
-          end
+      def records_for_authority(auth_name)
+        case expected_time_period
+        when :day
+          QaServer.config.performance_cache.write_all # only need to write if just using today's data
+          performance_data_class.where(QaServer::TimePeriodService.where_clause_for_last_24_hours(auth_name: auth_name))
+        when :month
+          performance_data_class.where(QaServer::TimePeriodService.where_clause_for_last_30_days(auth_name: auth_name))
+        when :year
+          performance_data_class.where(QaServer::TimePeriodService.where_clause_for_last_12_months(auth_name: auth_name))
+        else
+          all_records(auth_name)
         end
+      end
 
-        def all_records(auth_name)
-          auth_name.nil? ? performance_data_class.all : performance_data_class.where(authority: auth_name)
-        end
+      def all_records(auth_name)
+        auth_name.nil? ? performance_data_class.all : performance_data_class.where(authority: auth_name)
+      end
     end
   end
 end