qa_server 0.1.99 → 1.0.0

data/app/models/qa_server/scenario_run_history.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+# Provide access to the scenario_results_history database table which tracks specific scenario runs over time.
+module QaServer
+  class ScenarioRunHistory < ActiveRecord::Base
+    self.table_name = 'scenario_run_history'
+    belongs_to :scenario_run_registry
+    enum scenario_type: [:connection, :accuracy, :performance], _suffix: :type
+    enum status: [:good, :bad, :unknown], _suffix: true
+
+    GOOD_MARKER = '√'
+    BAD_MARKER = 'X'
+    UNKNOWN_MARKER = '?'
+
+    class_attribute :summary_class
+
+    self.summary_class = QaServer::ScenarioRunSummary
+
+    # Save a scenario result
+    # @param run_id [Integer] the run on which to gather statistics
+    # @param result [Hash] the scenario result to be saved
+    def self.save_result(run_id:, scenario_result:)
+      QaServer::ScenarioRunHistory.create(scenario_run_registry_id: run_id,
+                                          status: scenario_result[:status],
+                                          authority_name: scenario_result[:authority_name],
+                                          subauthority_name: scenario_result[:subauthority_name],
+                                          service: scenario_result[:service],
+                                          action: scenario_result[:action],
+                                          url: scenario_result[:url],
+                                          err_message: scenario_result[:err_message],
+                                          run_time: scenario_result[:run_time])
+    end
+
+    # Get a summary of passing/failing tests for a run.
+    # @param scenario_run [ScenarioRunRegistry] the run on which to gather statistics
+    # @returns [Hash] statistics on the requested run
+    # @example
+    #   { run_id: 14,
+    #     failing_count: 3,
+    #     passing_count: 156,
+    #     total_count: 159,
+    #     authority_count: 22,
+    #     failing_authority_count: 1 }
+    def self.run_summary(scenario_run:)
+      return nil unless scenario_run&.id
+      status = status_counts_in_run(run_id: scenario_run.id)
+      summary_class.new(run_id: scenario_run.id,
+                        run_dt_stamp: scenario_run.dt_stamp,
+                        authority_count: authorities_in_run(run_id: scenario_run.id).count,
+                        failing_authority_count: authorities_with_failures_in_run(run_id: scenario_run.id).count,
+                        passing_scenario_count: status['good'],
+                        failing_scenario_count: status['bad'] + status['unknown'])
+    end
+
+    # Get set of all scenario results for a run.
+    # @param run_id [Integer] the run on which to gather statistics
+    # @param authority_name [String] limit results to those for the authority with this name
+    # @param status [Array<Symbol> | Symbol] :good, :bad, :unknown, or any of these in an array to select multiple status
+    # @param url [String] limit results to a specific scenario URL
+    # @returns [Array<ScenarioRunHistory>] scenario details for all scenarios in the run
+    # @example
+    #   [ { status: :bad,
+    #       authority_name: "geonames_ld4l_cache",
+    #       subauthority_name: "area",
+    #       service: "ld4l_cache",
+    #       action: "search",
+    #       url: "/qa/search/linked_data/geonames_ld4l_cache/area?q=France&maxRecords=4",
+    #       err_message: "Unable to connect to authority",
+    #       scenario_type: :connection
+    #       run_time: 11.2 },
+    #     { status: :good,
+    #       authority_name: "oclcfast_ld4l_cache",
+    #       subauthority_name: "Organization",
+    #       service: "ld4l_cache",
+    #       action: "search",
+    #       url: "/qa/search/linked_data/oclcfast_ld4l_cache/organization?q=mark twain&maxRecords=4",
+    #       err_message: "",
+    #       scenario_type: :connection
+    #       run_time: 0.131 },
+    #     { status: :unknown,
+    #       authority_name: "oclcfast_ld4l_cache",
+    #       subauthority_name: "Person",
+    #       service: "ld4l_cache",
+    #       action: "search",
+    #       url: "/qa/search/linked_data/oclcfast_ld4l_cache/person?q=mark twain&maxRecords=4",
+    #       err_message: "Not enough search results returned",
+    #       scenario_type: :connection
+    #       run_time: 0.123 } ]
+    def self.run_results(run_id:, authority_name: nil, status: nil, url: nil)
+      return [] unless run_id
+      where = {}
+      where[:scenario_run_registry_id] = run_id
+      where[:authority_name] = authority_name if authority_name.present?
+      where[:status] = status if status.present?
+      where[:url] = url if url.present?
+      QaServer::ScenarioRunHistory.where(where).to_a
+    end
+
+    # Get set of failures for a run, if any.
+    # @param run_id [Integer] the run on which to gather statistics
+    # @returns [Array<Hash>] scenario details for any failing scenarios in the run
+    # @example
+    #   [ { status: :bad,
+    #       authority_name: "geonames_ld4l_cache",
+    #       subauthority_name: "area",
+    #       service: "ld4l_cache",
+    #       action: "search",
+    #       url: "/qa/search/linked_data/geonames_ld4l_cache/area?q=France&maxRecords=4",
+    #       err_message: "Unable to connect to authority",
+    #       scenario_type: :connection
+    #       run_time: 11.2 },
+    #     { status: :unknown,
+    #       authority_name: "oclcfast_ld4l_cache",
+    #       subauthority_name: "Person",
+    #       service: "ld4l_cache",
+    #       action: "search",
+    #       url: "/qa/search/linked_data/oclcfast_ld4l_cache/person?q=mark twain&maxRecords=4",
+    #       err_message: "Not enough search results returned",
+    #       scenario_type: :connection
+    #       run_time: 0.123 } ]
+    def self.run_failures(run_id:)
+      return [] unless run_id
+      QaServer::ScenarioRunHistory.where(scenario_run_registry_id: run_id).where.not(status: :good).to_a
+    end
+
+    # Get a summary level of historical data
+    # @returns [Array<Hash>] scenario details for any failing scenarios in the run (auth_name, failing, passing)
+    # @example
+    #   [ [ 'agrovoc', 0, 24 ],
+    #     [ 'geonames_ld4l_cache', 2, 22 ] ... ]
+    def self.historical_summary
+      runs = all_runs_per_authority
+      failures = failing_runs_per_authority
+      return [] unless runs.present?
+      data = []
+      runs.each do |auth_name, run_count|
+        auth_data = []
+        auth_data[0] = auth_name
+        failure_count = (failures.key? auth_name) ? failures[auth_name] : 0 # rubocop:disable Style/TernaryParentheses
+        auth_data[1] = failure_count
+        auth_data[2] = run_count - failure_count # passing
+        data << auth_data
+      end
+      data
+    end
+
+    def self.authorities_in_run(run_id:)
+      QaServer::ScenarioRunHistory.where(scenario_run_registry_id: run_id).pluck(:authority_name).uniq
+    end
+    private_class_method :authorities_in_run
+
+    def self.authorities_with_failures_in_run(run_id:)
+      QaServer::ScenarioRunHistory.where(scenario_run_registry_id: run_id).where.not(status: 'good').pluck('authority_name').uniq
+    end
+    private_class_method :authorities_with_failures_in_run
+
+    def self.status_counts_in_run(run_id:)
+      status = QaServer::ScenarioRunHistory.group('status').where(scenario_run_registry_id: run_id).count
+      status["good"] = 0 unless status.key? "good"
+      status["bad"] = 0 unless status.key? "bad"
+      status["unknown"] = 0 unless status.key? "unknown"
+      status
+    end
+    private_class_method :status_counts_in_run
+
+    def self.all_runs_per_authority
+      # TODO: Really want to only get one run per day.  Preferably the first run of the day.
+      authority_runs = QaServer::ScenarioRunHistory.pluck(:authority_name, :scenario_run_registry_id).uniq # rubocop:disable Rails/UniqBeforePluck
+      runs_per_authority(authority_runs)
+    end
+    private_class_method :all_runs_per_authority
+
+    def self.failing_runs_per_authority
+      failing_authority_runs = QaServer::ScenarioRunHistory.where.not(status: 'good').pluck(:authority_name, :scenario_run_registry_id).uniq
+      runs_per_authority(failing_authority_runs)
+    end
+    private_class_method :failing_runs_per_authority
+
+    def self.runs_per_authority(authority_runs)
+      runs_per_authority = {}
+      authority_runs.each do |auth_run|
+        auth_name = auth_run[0]
+        runs_per_authority[auth_name] = 0 unless runs_per_authority.key? auth_name
+        runs_per_authority[auth_name] += 1
+      end
+      runs_per_authority
+    end
+    private_class_method :runs_per_authority
+  end
+end

data/app/models/qa_server/scenario_run_registry.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+# Provide access to the scenario_run_registry database table which registers each run of tests made over time.
+module QaServer
+  class ScenarioRunRegistry < ActiveRecord::Base
+    self.table_name = 'scenario_run_registry'
+    has_many :scenario_run_history, foreign_key: :scenario_run_registry_id
+
+    # Get the latest saved run of scenarios.
+    def self.latest_run
+      return nil unless QaServer::ScenarioRunRegistry.last
+      QaServer::ScenarioRunRegistry.last # Can we count on last to always be the one with the latest dt_stamp?
+      # latest_run = ScenarioRunRegistry.all.sort(:dt_stamp).last
+      # return nil if latest_run.blank?
+      # latest_run.id
+    end
+
+    # Get the latest saved status.
+    def self.latest_run_id
+      latest = latest_run
+      return nil unless latest
+      lastest.id
+    end
+
+    def self.save_run(scenarios_results:)
+      run = QaServer::ScenarioRunRegistry.create(dt_stamp: dt_stamp_now_et)
+      scenarios_results.each { |result| QaServer::ScenarioRunHistory.save_result(run_id: run.id, scenario_result: result) }
+    end
+
+    def self.dt_stamp_now_et
+      Time.now.in_time_zone("Eastern Time (US & Canada)")
+    end
+    private_class_method :dt_stamp_now_et
+  end
+end

data/app/models/qa_server/scenario_run_summary.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+# Abstract class that parses the authority configuration from the yml file into the parts needed by inheriting scenario types.
+module QaServer
+  class ScenarioRunSummary
+    # @return [Integer] the id of the scenario run being summarized
+    attr_reader :run_id
+
+    # @return [Date] the date time stamp of the scenario run being summarized
+    attr_reader :run_dt_stamp
+
+    # @return [Integer] number of all authorities in the run
+    attr_reader :authority_count
+
+    # @return [Integer] number of authorities in the run that had at least one failing test
+    attr_reader :failing_authority_count
+
+    # @return [Integer] number of scenarios that passed during this run
+    attr_reader :passing_scenario_count
+
+    # @return [Integer] name of the subauthority the scenario runs against
+    attr_reader :failing_scenario_count
+
+    # @return [Integer] total number of scenarios in this run
+    attr_reader :total_scenario_count
+
+    # @param run_id [Integer] the id of the scenario run being summarized
+    # @param run_dt_stamp [Date] the date time stamp of the scenario run being summarized
+    # @param authority_count [Integer] number of all authorities in the run
+    # @param failing_authority_count [Integer] number of authorities in the run that had failing tests
+    # @param passing_scenario_count [Integer] number of scenarios that passed during this run
+    # @param failing_scenario_count [Integer] number of scenarios that failed during this run
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(run_id:, run_dt_stamp:, authority_count:, failing_authority_count:, passing_scenario_count:, failing_scenario_count:)
+      @run_id = run_id
+      @run_dt_stamp = run_dt_stamp
+      @authority_count = authority_count
+      @failing_authority_count = failing_authority_count
+      @passing_scenario_count = passing_scenario_count
+      @failing_scenario_count = failing_scenario_count
+      @total_scenario_count = failing_scenario_count + passing_scenario_count
+    end
+    # rubocop:enable Metrics/ParameterLists
+  end
+end

data/app/models/qa_server/scenarios.rb

@@ -1,10 +1,10 @@
+# frozen_string_literal: true
 # Holds all scenarios for an authority.
 module QaServer
   class Scenarios
-
-    AUTHORITY_SCENARIO = 'authority'.freeze
-    TERM_SCENARIOS = 'term'.freeze
-    SEARCH_SCENARIOS = 'search'.freeze
+    AUTHORITY_SCENARIO = 'authority'
+    TERM_SCENARIOS = 'term'
+    SEARCH_SCENARIOS = 'search'
 
     # @return [Qa::Authorities::LinkedData::GenericAuthority] authority instance the scenarios run against
     attr_reader :authority
@@ -18,6 +18,9 @@ module QaServer
     # @return [Array<SearchScenario>] the search scenarios to run against the authority
     attr_reader :search_scenarios
 
+    # @return [Hash] configurations from the yml file for all scenarios for an authority
+    attr_reader :scenarios_config; private :scenarios_config # rubocop:disable Style/Semicolon
+
     # @param authority [Qa::Authorities::LinkedData::GenericAuthority] the instance of the QA authority
     # @param authoity_name [String] the name of the authority the scenario tests (e.g. "agrovoc_direct")
     # @param scenarios_config [Hash] configurations from the yml file for all scenarios for an authority
@@ -34,27 +37,23 @@ module QaServer
       def parse_term_scenarios
         @term_scenarios = []
         term_scenarios_config.each do |term_scenario_config|
-          @term_scenarios << TermScenario.new(authority: authority,
-                                             authority_name: authority_name,
-                                             authority_scenario_config: authority_scenario_config,
-                                             scenario_config: term_scenario_config)
+          @term_scenarios << QaServer::TermScenario.new(authority: authority,
+                                                        authority_name: authority_name,
+                                                        authority_scenario_config: authority_scenario_config,
+                                                        scenario_config: term_scenario_config)
         end
       end
 
       def parse_search_scenarios
         @search_scenarios = []
         search_scenarios_config.each do |search_scenario_config|
-          @search_scenarios << SearchScenario.new(authority: authority,
-                                                  authority_name: authority_name,
-                                                  authority_scenario_config: authority_scenario_config,
-                                                  scenario_config: search_scenario_config)
+          @search_scenarios << QaServer::SearchScenario.new(authority: authority,
+                                                            authority_name: authority_name,
+                                                            authority_scenario_config: authority_scenario_config,
+                                                            scenario_config: search_scenario_config)
         end
       end
 
-      def scenarios_config
-        @scenarios_config
-      end
-
       def authority_scenario_config
         scenarios_config[AUTHORITY_SCENARIO]
       end
@@ -68,4 +67,3 @@ module QaServer
       end
   end
 end
-

data/app/models/qa_server/search_scenario.rb

@@ -1,7 +1,7 @@
+# frozen_string_literal: true
 # This class parses the search configuration from the yml file into the parts needed by the search scenario validator.
 module QaServer
   class SearchScenario < AuthorityScenario
-
     # @return [String] query being executed by this scenario
     attr_reader :query
 
@@ -14,8 +14,8 @@ module QaServer
     # @return [String] subject_uri, if specified, should be in the search results between position 1 and expected_by_position
     attr_reader :subject_uri
 
-    MAX_RECORDS = '4'.freeze
-    DEFAULT_REPLACEMENTS = { maxRecords: MAX_RECORDS }
+    MAX_RECORDS = '4'
+    DEFAULT_REPLACEMENTS = { maxRecords: MAX_RECORDS }.freeze
     DEFAULT_POSITION = nil
     DEFAULT_SUBJECT_URI = nil
 
@@ -37,7 +37,7 @@ module QaServer
     # @return [String] the example URL
     def url
       subauth = "/#{subauthority_name}" if subauthority?
-      prefix = "/#{QA_ENGINE_MOUNT}/search/linked_data/#{authority_name.downcase}#{subauth}"
+      prefix = "#{QaServer::Engine.qa_engine_mount}/search/linked_data/#{authority_name.downcase}#{subauth}"
       "#{prefix}?q=#{query}#{url_replacements}"
     end
 

data/app/models/qa_server/term_scenario.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'erb'
 
 # This class parses the term configuration from the yml file into the parts needed by the term scenario validator.
@@ -23,7 +24,7 @@ module QaServer
     # @return [String] the example URL
     def url
       subauth = "/#{subauthority_name}" if subauthority_name.present?
-      prefix = "/#{QA_ENGINE_MOUNT}/show/linked_data/#{authority_name.downcase}#{subauth}"
+      prefix = "#{QaServer::Engine.qa_engine_mount}/show/linked_data/#{authority_name.downcase}#{subauth}"
       "#{prefix}/#{url_identifier}"
     end
 

data/app/presenters/qa_server/authority_list_presenter.rb

@@ -1,10 +1,8 @@
+# frozen_string_literal: true
 # This presenter class provides all data needed by the view that show the list of authorities.
 module QaServer
   class AuthorityListPresenter
-    def initialize(urls_data:)
-      @urls_data = urls_data
-    end
-
+    # rubocop:disable Style/AsciiComments
     # @return [Array<Hash>] A list of status data for each scenario tested.
     # @example
     #   { status: :PASS,
@@ -15,8 +13,11 @@ module QaServer
     #     action: 'search',
     #     url: '/qa/search/linked_data/locnames_ld4l_cache/person?q=mark twain&maxRecords=4',
     #     err_message: '' }
-    def urls_data
-      @urls_data
+    attr_reader :urls_data
+    # rubocop:enable Style/AsciiComments
+
+    def initialize(urls_data:)
+      @urls_data = urls_data
     end
   end
 end

data/app/presenters/qa_server/check_status_presenter.rb

@@ -1,7 +1,7 @@
+# frozen_string_literal: true
 # This presenter class provides all data needed by the view that checks the status of authorities.
 module QaServer
   class CheckStatusPresenter
-
     # @param authorities_list [Array<String>] a list of all loaded authorities' names
     # @param status_data [Array<Hash>] a list of status data for each scenario tested
     def initialize(authorities_list:, connection_status_data:, accuracy_status_data:)
@@ -12,10 +12,9 @@ module QaServer
 
     # @return [Array<String>] A list of all loaded authorities' names
     # @example ['AGROVOC_DIRECT', 'AGROVOC_LD4L_CACHE', 'LOCNAMES_LD4L_CACHE']
-    def authorities_list
-      @authorities_list
-    end
+    attr_reader :authorities_list
 
+    # rubocop:disable Style/AsciiComments
     # @return [Array<Hash>] A list of status data for each connection scenario tested.
     # @example
     #   [ { status: :PASS,
@@ -26,10 +25,10 @@ module QaServer
     #       action: 'search',
     #       url: '/qa/search/linked_data/locnames_ld4l_cache/person?q=mark twain&maxRecords=4',
     #       err_message: '' }, ... ]
-    def connection_status_data
-      @connection_status_data
-    end
+    attr_reader :connection_status_data
+    # rubocop:enable Style/AsciiComments
 
+    # rubocop:disable Style/AsciiComments
     # @return [Array<Hash>] A list of status data for each accuracy scenario tested.
     # @example
     #   [ { status: :PASS,
@@ -42,9 +41,8 @@ module QaServer
     #       actual: 8,
     #       url: '/qa/search/linked_data/locnames_ld4l_cache/person?q=mark twain&maxRecords=20',
     #       err_message: '' }, ... ]
-    def accuracy_status_data
-      @accuracy_status_data
-    end
+    attr_reader :accuracy_status_data
+    # rubocop:enable Style/AsciiComments
 
     # @return [Boolean] true if status data exists; otherwise false
     def connection_status_data?
@@ -58,19 +56,31 @@ module QaServer
 
     # @return [String] the name of the css style class to use for the status cell based on the status of the scenario test.
     def status_style_class(status)
-      "status-#{status[:status].to_s}"
+      "status-#{status[:status]}"
+    end
+
+    # @return [String] the name of the css style class to use for the status cell based on the status of the scenario test.
+    def status_label(status)
+      case status[:status]
+      when :good
+        QaServer::ScenarioRunHistory::GOOD_MARKER
+      when :bad
+        QaServer::ScenarioRunHistory::BAD_MARKER
+      when :unknown
+        QaServer::ScenarioRunHistory::UNKNOWN_MARKER
+      end
     end
 
     def value_all_collections
-      CheckStatusController::ALL_AUTHORITIES
+      QaServer::CheckStatusController::ALL_AUTHORITIES
     end
 
     def value_check_param
-      AuthorityValidationController::VALIDATION_TYPE_PARAM
+      QaServer::AuthorityValidationController::VALIDATION_TYPE_PARAM
     end
 
     def value_check_connections
-      AuthorityValidationController::VALIDATE_CONNECTIONS
+      QaServer::AuthorityValidationController::VALIDATE_CONNECTIONS
     end
 
     def label_check_connections
@@ -78,7 +88,7 @@ module QaServer
     end
 
     def value_check_accuracy
-      AuthorityValidationController::VALIDATE_ACCURACY
+      QaServer::AuthorityValidationController::VALIDATE_ACCURACY
     end
 
     def label_check_accuracy
@@ -86,7 +96,7 @@ module QaServer
     end
 
     def value_all_checks
-      AuthorityValidationController::ALL_VALIDATIONS
+      QaServer::AuthorityValidationController::ALL_VALIDATIONS
     end
 
     def label_all_checks