qa_server 0.1.99

data/app/models/qa_server/scenarios.rb

@@ -0,0 +1,71 @@
+# Holds all scenarios for an authority.
+module QaServer
+  class Scenarios
+
+    AUTHORITY_SCENARIO = 'authority'.freeze
+    TERM_SCENARIOS = 'term'.freeze
+    SEARCH_SCENARIOS = 'search'.freeze
+
+    # @return [Qa::Authorities::LinkedData::GenericAuthority] authority instance the scenarios run against
+    attr_reader :authority
+
+    # @return [String] name of the authority the scenarios run against (e.g. 'agrovoc_direct')
+    attr_reader :authority_name
+
+    # @return [Array<TermScenario>] the term scenarios to run against the authority
+    attr_reader :term_scenarios
+
+    # @return [Array<SearchScenario>] the search scenarios to run against the authority
+    attr_reader :search_scenarios
+
+    # @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
+    def initialize(authority:, authority_name:, scenarios_config:)
+      @authority = authority
+      @authority_name = authority_name
+      @scenarios_config = scenarios_config
+      parse_term_scenarios
+      parse_search_scenarios
+    end
+
+    private
+
+      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)
+        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)
+        end
+      end
+
+      def scenarios_config
+        @scenarios_config
+      end
+
+      def authority_scenario_config
+        scenarios_config[AUTHORITY_SCENARIO]
+      end
+
+      def term_scenarios_config
+        scenarios_config[TERM_SCENARIOS] || []
+      end
+
+      def search_scenarios_config
+        scenarios_config[SEARCH_SCENARIOS] || []
+      end
+  end
+end
+

data/app/models/qa_server/search_scenario.rb

@@ -0,0 +1,58 @@
+# 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
+
+    # @return [Hash] replacements parameters used to construct the URL executed by this scenario
+    attr_reader :replacements
+
+    # @return [Integer] expected_by_position designates the maximum position in search results of subject_uri, if specified, for this scenario to be considered passing
+    attr_reader :expected_by_position
+
+    # @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 }
+    DEFAULT_POSITION = nil
+    DEFAULT_SUBJECT_URI = nil
+
+    # @param authority [Qa::Authorities::LinkedData::GenericAuthority] the instance of the QA authority
+    # @param authoity_name [Symbol] the name of the authority the scenario tests (e.g. :AGROVOC_DIRECT)
+    # @param authority_scenario_config [Hash] configurations from the yml file that pertain to all scenarios regardless of type
+    # @param scenario_config [Hash] configuration from the yml file that are specific to a search scenario
+    def initialize(authority:, authority_name:, authority_scenario_config:, scenario_config:)
+      super
+      @query = scenario_config['query']
+      @subauthority_name = scenario_config['subauth'] || DEFAULT_SUBAUTH
+      @min_result_size = scenario_config['result_size'] || MIN_EXPECTED_SIZE
+      @replacements = scenario_config['replacements'] || DEFAULT_REPLACEMENTS
+      @expected_by_position = scenario_config['position'] || DEFAULT_POSITION
+      @subject_uri = scenario_config['subject_uri'] || DEFAULT_SUBJECT_URI
+    end
+
+    # Generate an example URL that can be called in a browser or through curl
+    # @return [String] the example URL
+    def url
+      subauth = "/#{subauthority_name}" if subauthority?
+      prefix = "/#{QA_ENGINE_MOUNT}/search/linked_data/#{authority_name.downcase}#{subauth}"
+      "#{prefix}?q=#{query}#{url_replacements}"
+    end
+
+    private
+
+      # Convert replacements hash into URL parameters
+      def url_replacements
+        return "&maxRecords=#{MAX_RECORDS}" unless replacements
+        param_replacements = ""
+        replacements.each { |k, v| param_replacements += "&#{k}=#{v}" }
+        param_replacements
+      end
+
+      def subauthority?
+        subauthority_name.present?
+      end
+  end
+end

data/app/models/qa_server/term_scenario.rb

@@ -0,0 +1,50 @@
+require 'erb'
+
+# This class parses the term configuration from the yml file into the parts needed by the term scenario validator.
+module QaServer
+  class TermScenario < AuthorityScenario
+    include ERB::Util
+
+    # @return [String] id or uri of the term being fetched by this scenario
+    attr_reader :identifier
+
+    # @param authority [Qa::Authorities::LinkedData::GenericAuthority] the instance of the QA authority
+    # @param authoity_name [Symbol] the name of the authority the scenario tests (e.g. :AGROVOC_DIRECT)
+    # @param authority_scenario_config [Hash] configurations from the yml file that pertain to all scenarios regardless of type
+    # @param scenario_config [Hash] configuration from the yml file that are specific to a term scenario
+    def initialize(authority:, authority_name:, authority_scenario_config:, scenario_config:)
+      super
+      @identifier = scenario_config['identifier']
+      @subauthority_name = scenario_config['subauth'] || DEFAULT_SUBAUTH
+      @min_result_size = scenario_config['min_result_size'] || MIN_EXPECTED_SIZE
+    end
+
+    # Generate an example URL that can be called in a browser or through curl
+    # @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}/#{url_identifier}"
+    end
+
+    private
+
+      # Convert identifier into URL safe version with encoding if needed.
+      def url_identifier
+        return uri_encode(identifier) if encode?
+        identifier
+      end
+
+      def subauthority?
+        subauthority_name.present?
+      end
+
+      def encode?
+        authority.auth_config.term.term_id_expects_uri?
+      end
+
+      def uri_encode(uri)
+        url_encode(uri).gsub(".", "%2E")
+      end
+  end
+end

data/app/presenters/qa_server/authority_list_presenter.rb

@@ -0,0 +1,22 @@
+# 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
+
+    # @return [Array<Hash>] A list of status data for each scenario tested.
+    # @example
+    #   { status: :PASS,
+    #     status_label: '√',
+    #     authority_name: 'LOCNAMES_LD4L_CACHE',
+    #     subauthority_name: 'person',
+    #     service: 'ld4l_cache',
+    #     action: 'search',
+    #     url: '/qa/search/linked_data/locnames_ld4l_cache/person?q=mark twain&maxRecords=4',
+    #     err_message: '' }
+    def urls_data
+      @urls_data
+    end
+  end
+end

data/app/presenters/qa_server/check_status_presenter.rb

@@ -0,0 +1,96 @@
+# 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:)
+      @authorities_list = authorities_list
+      @connection_status_data = connection_status_data
+      @accuracy_status_data = accuracy_status_data
+    end
+
+    # @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
+
+    # @return [Array<Hash>] A list of status data for each connection scenario tested.
+    # @example
+    #   [ { status: :PASS,
+    #       status_label: '√',
+    #       authority_name: 'LOCNAMES_LD4L_CACHE',
+    #       subauthority_name: 'person',
+    #       service: 'ld4l_cache',
+    #       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
+
+    # @return [Array<Hash>] A list of status data for each accuracy scenario tested.
+    # @example
+    #   [ { status: :PASS,
+    #       status_label: '√',
+    #       authority_name: 'LOCNAMES_LD4L_CACHE',
+    #       subauthority_name: 'person',
+    #       service: 'ld4l_cache',
+    #       action: 'search',
+    #       expected: 10,
+    #       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
+
+    # @return [Boolean] true if status data exists; otherwise false
+    def connection_status_data?
+      @connection_status_data.present?
+    end
+
+    # @return [Boolean] true if status data exists; otherwise false
+    def accuracy_status_data?
+      @accuracy_status_data.present?
+    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_style_class(status)
+      "status-#{status[:status].to_s}"
+    end
+
+    def value_all_collections
+      CheckStatusController::ALL_AUTHORITIES
+    end
+
+    def value_check_param
+      AuthorityValidationController::VALIDATION_TYPE_PARAM
+    end
+
+    def value_check_connections
+      AuthorityValidationController::VALIDATE_CONNECTIONS
+    end
+
+    def label_check_connections
+      "#{value_check_param}_#{value_check_connections}".downcase.to_sym
+    end
+
+    def value_check_accuracy
+      AuthorityValidationController::VALIDATE_ACCURACY
+    end
+
+    def label_check_accuracy
+      "#{value_check_param}_#{value_check_accuracy}".downcase.to_sym
+    end
+
+    def value_all_checks
+      AuthorityValidationController::ALL_VALIDATIONS
+    end
+
+    def label_all_checks
+      "#{value_check_param}_#{value_all_checks}".downcase.to_sym
+    end
+  end
+end

data/app/presenters/qa_server/monitor_status_presenter.rb

@@ -0,0 +1,108 @@
+# This presenter class provides all data needed by the view that monitors status of authorities.
+module QaServer
+  class MonitorStatusPresenter
+
+    # @param authority_count [Integer] number of loaded authorities
+    # @param authority_status [AuthorityStatus] summary status of the latest run of test scenarios
+    # @param current_data [Array<Hash>] current set of failures for the latest test run, if any
+    # @param historical_data [Array<Hash>] data for past failures
+    def initialize(authority_count:, authority_status:, current_data:, historical_data:)
+      @authority_count = authority_count
+      @authority_status = authority_status
+      @current_failures = current_data
+      @history = historical_data
+    end
+
+    # @return [String] date of last test run
+    def last_updated
+      @authority_status.dt_stamp.in_time_zone("Eastern Time (US & Canada)").strftime("%m/%d/%y - %I:%M %p")
+    end
+
+    # @return [String] date of first recorded test run
+    def first_updated
+      AuthorityStatus.first.dt_stamp.in_time_zone("Eastern Time (US & Canada)").strftime("%m/%d/%y - %I:%M %p")
+    end
+
+    # @return [Integer] number of loaded authorities
+    def authorities_count
+      @authority_count
+    end
+
+    # @return [Integer] number of authorities with failing tests in the latest test run
+    def failing_authorities_count
+      @current_failures.map { |f| f[:authority_name] }.uniq.count
+    end
+
+    # @return [String] css style class representing whether all tests passed or any failed
+    def authorities_count_style
+      failures? ? 'status-bad' : 'status-good'
+    end
+
+    # @return [Integer] number of tests in the latest test run
+    def tests_count
+      @authority_status.test_count
+    end
+
+    # @return [Integer] number of passing tests in the latest test run
+    def passing_tests_count
+      tests_count - failing_tests_count
+    end
+
+    # @return [Integer] number of failing tests in the latest test run
+    def failing_tests_count
+      @current_failures.count
+    end
+
+    # @return [String] css style class representing whether all tests passed or any failed
+    def failing_tests_style
+      failures? ? 'status-bad' : 'status-good'
+    end
+
+    # @return [Array<Hash>] A list of failures data in the latest test run, if any
+    # @example
+    #   [ { status: :FAIL,
+    #       status_label: 'X',
+    #       authority_name: 'LOCNAMES_LD4L_CACHE',
+    #       subauthority_name: 'person',
+    #       service: 'ld4l_cache',
+    #       action: 'search',
+    #       url: '/qa/search/linked_data/locnames_ld4l_cache/person?q=mark twain&maxRecords=4',
+    #       err_message: 'Exception: Something went wrong.' }, ... ]
+    def failures
+      @current_failures
+    end
+
+    # @return [Boolean] true if failure data exists for the latest test run; otherwise false
+    def failures?
+      failing_tests_count.positive?
+    end
+
+    # @return [Array<Hash>] historical test data to be displayed
+    # @example
+    #   [ { days_failing: 1, authority_name: 'AGROVOC_DIRECT' },
+    #     { days_failing: 3, authority_name: 'AGROVOC_LD4L_CACHE' },
+    #     { days_failing: 0, authority_name: 'LOCNAMES_LD4L_CACHE' } ]
+    def history
+      # TODO: STUBED -- need to include history of past failures -- Question: How much data to save?
+      # Want to answer questions like...
+      #   * # of failing days out of # of days run
+      #   * # type of failures... can't load authority vs. exception vs. no data returned
+      #   * for a given authority, did all tests fail or just a few?
+      #   * are tests failing for a particular subauthority?
+      #   * are tests failing for a particular type (search vs. term)
+      history = []
+      entry = { days_failing: 3,
+                authority_name: "FOO",
+                subauthority_name: "bar",
+                service: 'test',
+                action: 'search' }
+      history << entry
+    end
+
+    # @return [Boolean] true if historical test data exists; otherwise false
+    def history?
+      # TODO: STUBED -- need check for history data
+      false
+    end
+  end
+end

data/app/services/qa_server/authority_lister_service.rb

@@ -0,0 +1,31 @@
+# Provide service methods for getting a list of all authorities and scenarios for an authority.
+module QaServer
+  class AuthorityListerService
+
+    # Return a list of supported authorities
+    # @return [Array<String>] list of authorities
+    def self.authorities_list
+      LINKED_DATA_AUTHORITIES_CONFIG.keys.sort
+    end
+
+    # Fill in status_log with data about each scenario for an authority
+    # @param authority_name [String] the name of the authority
+    # @param status_log [ScenarioLogger] the log that will hold the data about the scenarios
+    def self.scenarios_list(authority_name:, status_log:)
+      scenarios = QaServer::ScenariosLoaderService.load(authority_name: authority_name, status_log: status_log)
+      return if scenarios.blank?
+      list_terms(scenarios, status_log)
+      list_searches(scenarios, status_log)
+    end
+
+    private
+
+      def self.list_terms(scenarios, status_log)
+        scenarios.term_scenarios.each { |scenario| QaServer::TermScenarioValidator.new(scenario: scenario, status_log: status_log).log_without_running }
+      end
+
+      def self.list_searches(scenarios, status_log)
+        scenarios.search_scenarios.each { |scenario| QaServer::SearchScenarioValidator.new(scenario: scenario, status_log: status_log).log_without_running }
+      end
+  end
+end

data/app/services/qa_server/authority_loader_service.rb

@@ -0,0 +1,38 @@
+# This class loads an authority.
+module QaServer
+  class AuthorityLoaderService
+
+    # Load a QA authority
+    # @param authority_name [String] name of the authority to load (e.g. "agrovoc_direct")
+    # @param status_log [ScenarioLogger] logger to hold failure information if the authority cannot be loaded
+    # @return [Qa::Authorities::LinkedData::GenericAuthority] the instance of the authority that can receive QA requests OR nil if fails to load
+    def self.load(authority_name:, status_log:)
+      begin
+        authority = load_authority(authority_name, status_log)
+        return nil if authority.blank?
+      rescue Exception => e
+        status_log.add(authority_name: authority_name,
+                       status: ScenarioValidator::FAIL,
+                       error_message: "Unable to load authority '#{authority_name}'; cause: #{e.message}")
+        return nil
+      end
+      authority
+    end
+
+    private
+      def self.authority_key(authority_name)
+        authority_name.upcase.to_sym
+      end
+
+      def self.load_authority(authority_name, status_log)
+        authority = Qa::Authorities::LinkedData::GenericAuthority.new(authority_key(authority_name))
+        if authority.blank?
+          status_log.add(authority_name: authority_name,
+                         status: ScenarioValidator::FAIL,
+                         error_message: "Unable to load authority '#{authority_name}'; cause: UNKNOWN") unless authority.present?
+          return nil
+        end
+        authority
+    end
+  end
+end

data/app/services/qa_server/authority_validator_service.rb

@@ -0,0 +1,41 @@
+# Provide service methods for running a a set of validation scenarios for an authority.
+module QaServer
+  class AuthorityValidatorService
+    class_attribute :validator_class,
+                    :term_validator_class,
+                    :search_validator_class,
+                    :scenarios_loader_class
+
+    self.validator_class = ScenarioValidator
+    self.term_validator_class = TermScenarioValidator
+    self.search_validator_class = SearchScenarioValidator
+    self.scenarios_loader_class = ScenariosLoaderService
+
+    VALIDATE_CONNECTIONS = validator_class::VALIDATE_CONNECTION
+    VALIDATE_ACCURACY = validator_class::VALIDATE_ACCURACY
+    ALL_VALIDATIONS = validator_class::ALL_VALIDATIONS
+    DEFAULT_VALIDATION_TYPE = validator_class::DEFAULT_VALIDATION_TYPE
+
+    # Run the set of validation scenarios for an authority logging the results
+    # @param authority_name [String] the name of the authority
+    # @param status_log [ScenarioLogger] the log that will hold the data about the scenarios and test results
+    # @param validation_type [Symbol] the type of scenarios to run (e.g. VALIDATE_CONNECTIONS, VALIDATE_ACCURACY, ALL_VALIDATIONS)
+    def self.run(authority_name:, status_log:, validation_type: DEFAULT_VALIDATION_TYPE)
+      scenarios = scenarios_loader_class.load(authority_name: authority_name, status_log: status_log)
+      return if scenarios.blank?
+      run_terms(scenarios, status_log, validation_type)
+      run_searches(scenarios, status_log, validation_type)
+    end
+
+
+    private
+
+      def self.run_terms(scenarios, status_log, validation_type)
+        scenarios.term_scenarios.each { |scenario| term_validator_class.new(scenario: scenario, status_log: status_log, validation_type: validation_type).run }
+      end
+
+      def self.run_searches(scenarios, status_log, validation_type)
+        scenarios.search_scenarios.each { |scenario| search_validator_class.new(scenario: scenario, status_log: status_log, validation_type: validation_type).run }
+      end
+  end
+end

data/app/services/qa_server/database_migrator.rb

@@ -0,0 +1,70 @@
+require 'rails/generators/active_record'
+
+module QaServer
+  # QaServer::DatabaseMigrator is responsible for copying QaServer's required database
+  # migrations into applications. Rails engines typically use the built-in
+  # `{ENGINE_NAME}:install:migrations` task to handle this; instead QaServer
+  # follows the practice used by Devise to dynamically subclass migrations with
+  # the version of `ActiveRecord::Migration` corresponding to the version of
+  # Rails used by the application.
+  #
+  # @note QaServer::DatabaseMigrator uses Rails' generator internals to avoid
+  #       having to re-implement code that knows how to copy migrations only if
+  #       needed
+  class DatabaseMigrator < Rails::Generators::Base
+    # @note included to pick up AR's migration numbering algorithm
+    include ActiveRecord::Generators::Migration
+
+    # @note This method is required by Rails::Generators::Base
+    def self.source_root
+      migrations_dir
+    end
+
+    def self.migrations_dir
+      QaServer::Engine.root.join('lib', 'generators', 'qa_server', 'templates')
+    end
+
+    def self.copy
+      new.copy
+    end
+
+    # def copy
+    #   # QA Server's migrations changed between 2.0.0 and subsequent versions, so the
+    #   # migration comparison algorithm decides that those older migrations are a
+    #   # source of conflict. Default Rails behavior here is to abort and
+    #   # explicitly instruct the user to try again with either the `--skip` or
+    #   # `--force` option. QA Server skips these conflicts.
+    #   migrations.each do |filename|
+    #     migration_template filename,
+    #                        "db/migrate/#{parse_basename_from(filename)}",
+    #                        migration_version: migration_version,
+    #                        skip: true
+    #   end
+    # end
+    def copy
+      migrations.each do |filename|
+        migration_template filename,
+                           "db/migrate/#{parse_basename_from(filename)}",
+                           migration_version: migration_version
+      end
+    end
+
+    private
+
+      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 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/scenarios_loader_service.rb

@@ -0,0 +1,57 @@
+# This class loads scenario configuration file for an authority.
+module QaServer
+  class ScenariosLoaderService
+
+    # Load scenarios for testing an authority
+    # @param authority_name [String] name of the authority to load (e.g. "agrovoc_direct")
+    # @param status_log [ScenarioLogger] logger to hold failure information if the scenarios cannot be loaded
+    # @return [Scenarios] the instance of the set of scenarios to test for the authority OR nil if fails to load
+    def self.load(authority_name:, status_log:)
+      begin
+        authority = load_authority(authority_name, status_log)
+        return nil if authority.blank?
+        return nil unless scenarios_exist?(authority_name, status_log)
+
+        scenarios_config = load_config(authority_name, status_log)
+        return nil if scenarios_config.blank?
+
+        scenarios = Scenarios.new(authority: authority, authority_name: authority_name, scenarios_config: scenarios_config)
+      rescue Exception => e
+        status_log.add(authority_name: authority_name,
+                       status: ScenarioValidator::FAIL,
+                       error_message: "Unable to load scenarios for authority '#{authority_name}'; cause: #{e.message}")
+        return nil
+      end
+      scenarios
+    end
+
+    private
+
+      def self.load_authority(authority_name, status_log)
+        AuthorityLoaderService.load(authority_name: authority_name, status_log: status_log)
+      end
+
+      def self.load_config(authority_name, status_log)
+        scenarios_config = YAML.load_file(scenario_path(authority_name))
+        unless scenarios_config.present?
+          status_log.add(authority_name: authority_name,
+                         status: ScenarioValidator::FAIL,
+                         error_message: "Unable to load scenarios for authority '#{authority_name}'; cause: UNKNOWN")
+          return nil
+        end
+        scenarios_config
+      end
+
+      def self.scenarios_exist?(authority_name, status_log)
+        return true if File.exists?(scenario_path(authority_name))
+        status_log.add(authority_name: authority_name,
+                       status: ScenarioValidator::FAIL,
+                       error_message: "Unable to load scenarios for authority '#{authority_name}'; cause: #{scenario_path} does not exist.")
+        false
+      end
+
+      def self.scenario_path(authority_name)
+        File.join(::Rails.root, 'config', 'authorities', 'linked_data', 'scenarios', "#{authority_name.downcase}_validation.yml")
+      end
+  end
+end