qa 4.0.0 → 4.1.0

data/lib/qa/authorities/linked_data/find_term.rb

@@ -3,24 +3,29 @@
 module Qa::Authorities
   module LinkedData
     class FindTerm
-      include Qa::Authorities::LinkedData::RdfHelper
+      class_attribute :authority_service, :graph_service, :language_service, :language_sort_service, :results_mapper_service
+      self.authority_service = Qa::LinkedData::AuthorityUrlService
+      self.graph_service = Qa::LinkedData::GraphService
+      self.language_service = Qa::LinkedData::LanguageService
+      self.language_sort_service = Qa::LinkedData::LanguageSortService
+      self.results_mapper_service = Qa::LinkedData::Mapper::TermResultsMapperService
 
       # @param [TermConfig] term_config The term portion of the config
       def initialize(term_config)
         @term_config = term_config
       end
 
-      attr_reader :term_config, :full_graph, :filtered_graph, :language
-      private :full_graph, :filtered_graph, :language
+      attr_reader :term_config, :full_graph, :filtered_graph, :language, :id, :access_time_s, :normalize_time_s
+      private :full_graph, :filtered_graph, :language, :id, :access_time_s, :normalize_time_s
 
-      delegate :term_subauthority?, to: :term_config
+      delegate :term_subauthority?, :prefixes, :authority_name, to: :term_config
 
       # Find a single term in a linked data authority
       # @param [String] the id of the term to fetch
       # @param [Symbol] (optional) language: language used to select literals when multi-language is supported (e.g. :en, :fr, etc.)
       # @param [Hash] (optional) replacements: replacement values with { pattern_name (defined in YAML config) => value }
       # @param [String] subauth: the subauthority from which to fetch the term
-      # @return [String] json results
+      # @return [Hash] json results
       # @example Json Results for Linked Data Term
       #   { "uri":"http://id.worldcat.org/fast/530369",
       #     "id":"530369","label":"Cornell University",
@@ -34,102 +39,159 @@ module Qa::Authorities
       #     "http://schema.org/name":["Cornell University","Ithaca (N.Y.). Cornell University"],
       #     "http://www.w3.org/2004/02/skos/core#altLabel":["Ithaca (N.Y.). Cornell University"],
       #     "http://schema.org/sameAs":["http://id.loc.gov/authorities/names/n79021621","https://viaf.org/viaf/126293486"] } }
-      def find(id, language: nil, replacements: {}, subauth: nil, jsonld: false)
+      def find(id, language: nil, replacements: {}, subauth: nil, jsonld: false, performance_data: false) # rubocop:disable Metrics/ParameterLists
         raise Qa::InvalidLinkedDataAuthority, "Unable to initialize linked data term sub-authority #{subauth}" unless subauth.nil? || term_subauthority?(subauth)
-        @language = Qa::LinkedData::LanguageService.preferred_language(user_language: language, authority_language: term_config.term_language)
-        url = Qa::LinkedData::AuthorityUrlService.build_url(action_config: term_config, action: :term, action_request: id, substitutions: replacements, subauthority: subauth)
+        @language = language_service.preferred_language(user_language: language, authority_language: term_config.term_language)
+        @id = id
+        @performance_data = performance_data
+        @jsonld = jsonld
+        url = authority_service.build_url(action_config: term_config, action: :term, action_request: normalize_id, substitutions: replacements, subauthority: subauth, language: @language)
         Rails.logger.info "QA Linked Data term url: #{url}"
         load_graph(url: url)
-        return "{}" unless full_graph.size.positive?
-        return full_graph.dump(:jsonld, standard_prefixes: true) if jsonld
-        parse_term_authority_response(id)
+        normalize_results
       end
 
       private
 
         def load_graph(url:)
-          # @graph = Qa::LinkedData::GraphService.load_graph(url: url)
-          @full_graph = Qa::LinkedData::GraphService.load_graph(url: url)
-          return unless @full_graph.size.positive?
-          @filtered_graph = Qa::LinkedData::GraphService.deep_copy(graph: @full_graph)
-          @filtered_graph = Qa::LinkedData::GraphService.filter(graph: @filtered_graph, language: language) unless language.blank?
+          access_start_dt = Time.now.utc
+
+          @full_graph = graph_service.load_graph(url: url)
+
+          access_end_dt = Time.now.utc
+          @access_time_s = access_end_dt - access_start_dt
+          Rails.logger.info("Time to receive data from authority: #{access_time_s}s")
         end
 
-        def parse_term_authority_response(id)
-          results = extract_preds(filtered_graph, preds_for_term)
-          consolidated_results = consolidate_term_results(results)
-          json_results = convert_term_to_json(consolidated_results)
-          termhash = select_json_result_for_id(json_results, id)
-          predicates_hash = predicates_with_subject_uri(termhash[:uri])
-          termhash['predicates'] = predicates_hash unless predicates_hash.length <= 0
-          termhash
+        def normalize_results
+          normalize_start_dt = Time.now.utc
+          normalize_end_dt = Time.now.utc
+
+          json = perform_normalization
+
+          @normalize_time_s = normalize_end_dt - normalize_start_dt
+          Rails.logger.info("Time to convert data to json: #{normalize_time_s}s")
+          json = append_performance_data(json) if performance_data? && !jsonld?
+          json
         end
 
-        def preds_for_term
-          { required: required_term_preds, optional: optional_term_preds }
+        def perform_normalization
+          return "{}" unless full_graph.size.positive?
+          return full_graph.dump(:jsonld, standard_prefixes: true) if jsonld?
+
+          filter_graph
+          results = map_results
+          convert_results_to_json(results)
         end
 
-        def required_term_preds
-          label_pred_uri = term_config.term_results_label_predicate
-          raise Qa::InvalidConfiguration, "required label_predicate is missing in configuration for LOD authority #{auth_name}" if label_pred_uri.nil?
-          { label: label_pred_uri }
-        end
-
-        def optional_term_preds
-          preds = {}
-          preds[:altlabel] = term_config.term_results_altlabel_predicate unless term_config.term_results_altlabel_predicate.nil?
-          preds[:id] = term_config.term_results_id_predicate unless term_config.term_results_id_predicate.nil?
-          preds[:narrower] = term_config.term_results_narrower_predicate unless term_config.term_results_narrower_predicate.nil?
-          preds[:broader] = term_config.term_results_broader_predicate unless term_config.term_results_broader_predicate.nil?
-          preds[:sameas] = term_config.term_results_sameas_predicate unless term_config.term_results_sameas_predicate.nil?
-          preds
-        end
-
-        def consolidate_term_results(results) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize # TODO: Explore a way to simplify
-          consolidated_results = {}
-          results.each do |statement|
-            stmt_hash = statement.to_h
-            uri = stmt_hash[:uri].to_s
-            consolidated_hash = init_consolidated_hash(consolidated_results, uri, stmt_hash[:id].to_s)
-
-            consolidated_hash[:label] = object_value(stmt_hash, consolidated_hash, :label, false)
-            altlabel = object_value(stmt_hash, consolidated_hash, :altlabel, false)
-            narrower = object_value(stmt_hash, consolidated_hash, :narrower)
-            broader = object_value(stmt_hash, consolidated_hash, :broader)
-            sameas = object_value(stmt_hash, consolidated_hash, :sameas)
-
-            consolidated_hash[:altlabel] = altlabel unless altlabel.nil?
-            consolidated_hash[:narrower] = narrower unless narrower.nil?
-            consolidated_hash[:broader] = broader unless broader.nil?
-            consolidated_hash[:sameas] = sameas unless sameas.nil?
-            consolidated_results[uri] = consolidated_hash
-          end
-          consolidated_results.each do |res|
-            consolidated_hash = res[1]
-            consolidated_hash[:label] = sort_string_by_language consolidated_hash[:label]
-            consolidated_hash[:altlabel] = sort_string_by_language consolidated_hash[:altlabel]
-            consolidated_hash[:sort] = sort_string_by_language consolidated_hash[:sort]
-          end
-          consolidated_results
-        end
-
-        def convert_term_to_json(consolidated_results)
-          json_results = []
-          consolidated_results.each do |uri, h|
-            json_hash = { uri: uri, id: h[:id], label: h[:label] }
-            json_hash[:altlabel] = h[:altlabel] unless h[:altlabel].nil?
-            json_hash[:narrower] = h[:narrower] unless h[:narrower].nil?
-            json_hash[:broader] = h[:broader] unless h[:broader].nil?
-            json_hash[:sameas] = h[:sameas] unless h[:sameas].nil?
-            json_results << json_hash
+        def filter_graph
+          @filtered_graph = graph_service.deep_copy(graph: @full_graph)
+          @filtered_graph = graph_service.filter(graph: @filtered_graph, language: language) unless language.blank?
+        end
+
+        def map_results
+          predicate_map = preds_for_term
+          ldpath_map = ldpaths_for_term
+
+          raise Qa::InvalidConfiguration, "do not specify results using both predicates and ldpath in term configuration for LOD authority #{authority_name} (ldpath is preferred)" if predicate_map.present? && ldpath_map.present? # rubocop:disable Metrics/LineLength
+          raise Qa::InvalidConfiguration, "must specify label_ldpath or label_predicate in term configuration for LOD authority #{authority_name} (label_ldpath is preferred)" unless ldpath_map.key?(:label) || predicate_map.key?(:label) # rubocop:disable Metrics/LineLength
+
+          if predicate_map.present?
+            Qa.deprecation_warning(
+              in_msg: 'Qa::Authorities::LinkedData::FindTerm',
+              msg: 'defining results using predicates in term config is deprecated; update to define using ldpaths'
+            )
           end
-          json_results
+
+          results_mapper_service.map_values(graph: @filtered_graph, subject_uri: uri, prefixes: prefixes,
+                                            ldpath_map: ldpaths_for_term, predicate_map: preds_for_term)
+        end
+
+        def normalize_id
+          return id if expects_uri?
+          authority_name.to_s.casecmp('loc').zero? ? id.delete(' ') : id
+        end
+
+        def expects_uri?
+          term_config.term_id_expects_uri?
+        end
+
+        def uri
+          return @uri if @uri.present?
+          return @uri = RDF::URI.new(id) if expects_uri?
+          @uri = graph_service.subjects_for_object_value(graph: @filtered_graph, predicate: RDF::URI.new(term_config.term_results_id_predicate), object_value: id.gsub('%20', ' ')).first
+        end
+
+        def ldpaths_for_term
+          label_ldpath = term_config.term_results_label_ldpath
+          return {} if label_ldpath.blank?
+          ldpaths = { label: label_ldpath }
+          ldpaths.merge(optional_ldpaths)
+        end
+
+        def optional_ldpaths
+          opt_ldpaths = {}
+          opt_ldpaths[:altlabel] = term_config.term_results_altlabel_ldpath
+          opt_ldpaths[:id] = term_config.term_results_id_ldpath
+          opt_ldpaths[:narrower] = term_config.term_results_narrower_ldpath
+          opt_ldpaths[:broader] = term_config.term_results_broader_ldpath
+          opt_ldpaths[:sameas] = term_config.term_results_sameas_ldpath
+          opt_ldpaths.delete_if { |_k, v| v.blank? }
+        end
+
+        def jsonld?
+          @jsonld == true
+        end
+
+        def performance_data?
+          @performance_data == true
+        end
+
+        def preds_for_term
+          label_pred_uri = term_config.term_results_label_predicate
+          return {} if label_pred_uri.blank?
+          preds = { label: label_pred_uri }
+          preds.merge(optional_preds)
         end
 
-        def select_json_result_for_id(json_results, id)
-          json_results.select! { |r| r[:uri].include? id } if json_results.size > 1
-          json_results.select! { |r| r[:uri].ends_with? id } if json_results.size > 1
-          json_results.first
+        def optional_preds
+          opt_preds = {}
+          opt_preds[:altlabel] = term_config.term_results_altlabel_predicate
+          opt_preds[:id] = term_config.term_results_id_predicate
+          opt_preds[:narrower] = term_config.term_results_narrower_predicate
+          opt_preds[:broader] = term_config.term_results_broader_predicate
+          opt_preds[:sameas] = term_config.term_results_sameas_predicate
+          opt_preds.delete_if { |_k, v| v.blank? }
+        end
+
+        def convert_results_to_json(results)
+          json_hash = { uri: uri.to_s }
+          json_hash[:id] = results.key?(:id) && results[:id].present? ? results[:id].first.to_s : uri.to_s
+          json_hash[:label] = sort_literals(results, :label)
+          json_hash.merge!(optional_results_to_json(results))
+          predicates_hash = predicates_with_subject_uri(uri)
+          json_hash['predicates'] = predicates_hash if predicates_hash.present?
+          json_hash
+        end
+
+        def optional_results_to_json(results)
+          opt_results_json = {}
+          opt_results_json[:altlabel] = sort_literals(results, :altlabel)
+          opt_results_json[:narrower] = extract_result(results, :narrower)
+          opt_results_json[:broader] = extract_result(results, :broader)
+          opt_results_json[:sameas] = extract_result(results, :sameas)
+          opt_results_json.delete_if { |_k, v| v.blank? }
+        end
+
+        def extract_result(results, key)
+          return nil unless results.key?(key) && results[key].present?
+          results[key].map(&:to_s)
+        end
+
+        def sort_literals(results, key)
+          return nil unless results.key? key
+          return [] if results[key].blank?
+          language_sort_service.new(results[key], language).uniq_sorted_strings
         end
 
         def predicates_with_subject_uri(expected_uri) # rubocop:disable Metrics/MethodLength
@@ -152,6 +214,14 @@ module Qa::Authorities
           end
           predicates_hash
         end
+
+        def append_performance_data(results)
+          performance = { predicate_count: results['predicates'].size,
+                          fetch_time_s: access_time_s,
+                          normalization_time_s: normalize_time_s,
+                          total_time_s: (access_time_s + normalize_time_s) }
+          { performance: performance, results: results }
+        end
     end
   end
 end

data/lib/qa/authorities/linked_data/search_query.rb

@@ -15,10 +15,10 @@ module Qa::Authorities
         @search_config = search_config
       end
 
-      attr_reader :search_config, :graph, :language
-      private :graph, :language
+      attr_reader :search_config, :graph, :language, :access_time_s, :normalize_time_s
+      private :graph, :language, :access_time_s, :normalize_time_s
 
-      delegate :subauthority?, :supports_sort?, to: :search_config
+      delegate :subauthority?, :supports_sort?, :prefixes, :authority_name, to: :search_config
 
       # Search a linked data authority
       # @praram [String] the query
@@ -26,32 +26,66 @@ module Qa::Authorities
       # @param replacements [Hash] (optional) replacement values with { pattern_name (defined in YAML config) => value }
       # @param subauth [String] (optional) the subauthority to query
       # @param context [Boolean] (optional) true if context should be returned with the results; otherwise, false (default: false)
+      # @param performance_data [Boolean] (optional) true if include_performance_data should be returned with the results; otherwise, false (default: false)
       # @return [String] json results
       # @example Json Results for Linked Data Search
       #   [ {"uri":"http://id.worldcat.org/fast/5140","id":"5140","label":"Cornell, Joseph"},
       #     {"uri":"http://id.worldcat.org/fast/72456","id":"72456","label":"Cornell, Sarah Maria, 1802-1832"},
       #     {"uri":"http://id.worldcat.org/fast/409667","id":"409667","label":"Cornell, Ezra, 1807-1874"} ]
-      def search(query, language: nil, replacements: {}, subauth: nil, context: false)
+      def search(query, language: nil, replacements: {}, subauth: nil, context: false, performance_data: false) # rubocop:disable Metrics/ParameterLists
         raise Qa::InvalidLinkedDataAuthority, "Unable to initialize linked data search sub-authority #{subauth}" unless subauth.nil? || subauthority?(subauth)
         @context = context
+        @performance_data = performance_data
         @language = language_service.preferred_language(user_language: language, authority_language: search_config.language)
-        url = authority_service.build_url(action_config: search_config, action: :search, action_request: query, substitutions: replacements, subauthority: subauth)
+        url = authority_service.build_url(action_config: search_config, action: :search, action_request: query, substitutions: replacements, subauthority: subauth, language: @language)
         Rails.logger.info "QA Linked Data search url: #{url}"
         load_graph(url: url)
-        parse_search_authority_response
+        normalize_results
       end
 
       private
 
         def load_graph(url:)
+          access_start_dt = Time.now.utc
+
           @graph = graph_service.load_graph(url: url)
+
+          access_end_dt = Time.now.utc
+          @access_time_s = access_end_dt - access_start_dt
+          Rails.logger.info("Time to receive data from authority: #{access_time_s}s")
+        end
+
+        def normalize_results
+          normalize_start_dt = Time.now.utc
+
           @graph = graph_service.filter(graph: @graph, language: language, remove_blanknode_subjects: true)
+          results = map_results
+          json = convert_results_to_json(results)
+
+          normalize_end_dt = Time.now.utc
+          @normalize_time_s = normalize_end_dt - normalize_start_dt
+          Rails.logger.info("Time to convert data to json: #{normalize_time_s}s")
+          json = append_performance_data(json) if performance_data?
+          json
         end
 
-        def parse_search_authority_response
-          results = results_mapper_service.map_values(graph: @graph, predicate_map: preds_for_search, sort_key: :sort,
-                                                      preferred_language: @language, context_map: context_map)
-          convert_results_to_json(results)
+        def map_results
+          predicate_map = preds_for_search
+          ldpath_map = ldpaths_for_search
+
+          raise Qa::InvalidConfiguration, "do not specify results using both predicates and ldpath in search configuration for LOD authority #{authority_name} (ldpath is preferred)" if predicate_map.present? && ldpath_map.present? # rubocop:disable Metrics/LineLength
+          raise Qa::InvalidConfiguration, "must specify label_ldpath or label_predicate in search configuration for LOD authority #{authority_name} (label_ldpath is preferred)" unless ldpath_map.key?(:label) || predicate_map.key?(:label) # rubocop:disable Metrics/LineLength
+
+          if predicate_map.present?
+            Qa.deprecation_warning(
+              in_msg: 'Qa::Authorities::LinkedData::SearchQuery',
+              msg: 'defining results using predicates in search config is deprecated; update to define using ldpaths'
+            )
+          end
+
+          results_mapper_service.map_values(graph: @graph, prefixes: prefixes, ldpath_map: ldpath_map,
+                                            predicate_map: predicate_map, sort_key: :sort,
+                                            preferred_language: @language, context_map: context_map)
         end
 
         def context_map
@@ -62,11 +96,32 @@ module Qa::Authorities
           @context == true
         end
 
+        def performance_data?
+          @performance_data == true
+        end
+
+        def ldpaths_for_search
+          label_ldpath = search_config.results_label_ldpath
+          return {} if label_ldpath.blank?
+          ldpaths = { label: label_ldpath, uri: :subject_uri }
+          ldpaths[:altlabel] = search_config.results_altlabel_ldpath unless search_config.results_altlabel_ldpath.nil?
+          ldpaths[:id] = id_ldpath.present? ? id_ldpath : :subject_uri
+          ldpaths[:sort] = sort_ldpath.present? ? sort_ldpath : ldpaths[:label]
+          ldpaths
+        end
+
+        def id_ldpath
+          @id_ldpath ||= search_config.results_id_ldpath
+        end
+
+        def sort_ldpath
+          @sort_ldpath ||= search_config.results_sort_ldpath
+        end
+
         def preds_for_search
           label_pred_uri = search_config.results_label_predicate
-          raise Qa::InvalidConfiguration, "required label_predicate is missing in search configuration for LOD authority #{auth_name}" if label_pred_uri.nil?
-          preds = { label: label_pred_uri }
-          preds[:uri] = :subject_uri
+          return {} if label_pred_uri.blank?
+          preds = { label: label_pred_uri, uri: :subject_uri }
           preds[:altlabel] = search_config.results_altlabel_predicate unless search_config.results_altlabel_predicate.nil?
           preds[:id] = id_predicate.present? ? id_predicate : :subject_uri
           preds[:sort] = sort_predicate.present? ? sort_predicate : preds[:label]
@@ -111,6 +166,14 @@ module Qa::Authorities
           lbl = '[' + lbl + ']' if labels.size > 1
           lbl
         end
+
+        def append_performance_data(results)
+          performance = { result_count: results.size,
+                          fetch_time_s: access_time_s,
+                          normalization_time_s: normalize_time_s,
+                          total_time_s: (access_time_s + normalize_time_s) }
+          { performance: performance, results: results }
+        end
     end
   end
 end

data/lib/qa/configuration.rb

@@ -37,5 +37,13 @@ module Qa
     def default_language
       @default_language ||= :en
     end
+
+    # When true, prevents ldpath requests from making additional network calls.  All values will come from the context graph
+    # passed to the ldpath request.
+    attr_writer :limit_ldpath_to_context
+    def limit_ldpath_to_context?
+      return true if @limit_ldpath_to_context.nil?
+      @limit_ldpath_to_context
+    end
   end
 end

data/lib/qa/version.rb

@@ -1,3 +1,3 @@
 module Qa
-  VERSION = "4.0.0".freeze
+  VERSION = "4.1.0".freeze
 end

data/spec/controllers/linked_data_terms_controller_spec.rb

@@ -81,14 +81,54 @@ describe Qa::LinkedDataTermsController, type: :controller do
   end
 
   describe '#list' do
-    let(:expected_results) { ['Auth1', 'Auth2', 'Auth3'] }
-    before do
-      allow(Qa::LinkedData::AuthorityService).to receive(:authority_names).and_return(expected_results)
+    context 'when details=false' do
+      let(:expected_results) { ['Auth1', 'Auth2', 'Auth3'] }
+      before do
+        allow(Qa::LinkedData::AuthorityService).to receive(:authority_names).and_return(expected_results)
+      end
+      it 'returns list of authorities' do
+        get :list
+        expect(response).to be_successful
+        expect(response.body).to eq expected_results.to_json
+      end
     end
-    it 'returns list of authorities' do
-      get :list
-      expect(response).to be_successful
-      expect(response.body).to eq expected_results.to_json
+
+    context 'when details=true' do
+      let(:expected_results) do
+        [
+          {
+            "label" => "oclc_fast term (QA)",
+            "uri" => "urn:qa:term:oclc_fast",
+            "authority" => "oclc_fast",
+            "action" => "term",
+            "language" => ["en"]
+          },
+          {
+            "label" => "oclc_fast search (QA)",
+            "uri" => "urn:qa:search:oclc_fast",
+            "authority" => "oclc_fast",
+            "action" => "search",
+            "language" => ["en"]
+          },
+          {
+            "label" => "oclc_fast search topic (QA)",
+            "uri" => "urn:qa:search:oclc_fast:topic",
+            "authority" => "oclc_fast",
+            "subauthority" => "topic",
+            "action" => "search",
+            "language" => ["en"]
+          }
+        ]
+      end
+
+      before do
+        allow(Qa::LinkedData::AuthorityService).to receive(:authority_details).and_return(expected_results)
+      end
+      it 'returns list of authorities' do
+        get :list, params: { details: 'true' }
+        expect(response).to be_successful
+        expect(response.body).to eq expected_results.to_json
+      end
     end
   end
 
@@ -254,6 +294,33 @@ describe Qa::LinkedDataTermsController, type: :controller do
         expect(results.first.key?('context')).to be false
       end
     end
+
+    context 'when requesting performance data' do
+      before do
+        Qa.config.disable_cors_headers
+        stub_request(:get, 'http://experimental.worldcat.org/fast/search?maximumRecords=3&query=cql.any%20all%20%22cornell%22&sortKeys=usage')
+          .to_return(status: 200, body: webmock_fixture('lod_oclc_all_query_3_results.rdf.xml'), headers: { 'Content-Type' => 'application/rdf+xml' })
+      end
+      it "returns basic data + performance data when performance_data='true'" do
+        get :search, params: { q: 'cornell', vocab: 'OCLC_FAST', maximumRecords: '3', performance_data: 'true' }
+        expect(response).to be_successful
+        results = JSON.parse(response.body)
+        expect(results).to be_kind_of Hash
+        expect(results.keys).to match_array ['performance', 'results']
+        expect(results['performance'].keys).to match_array ['result_count', 'fetch_time_s', 'normalization_time_s', 'total_time_s']
+        expect(results['performance']['total_time_s']).to eq results['performance']['fetch_time_s'] + results['performance']['normalization_time_s']
+        expect(results['performance']['result_count']).to eq 3
+        expect(results['results'].count).to eq 3
+      end
+
+      it "returns basic data only when performance_data='false'" do
+        get :search, params: { q: 'cornell', vocab: 'OCLC_FAST', maximumRecords: '3', performance_data: 'false' }
+        expect(response).to be_successful
+        results = JSON.parse(response.body)
+        expect(results).to be_kind_of Array
+        expect(results.size).to eq 3
+      end
+    end
   end
 
   describe '#show' do
@@ -378,48 +445,75 @@ describe Qa::LinkedDataTermsController, type: :controller do
             .to_return(status: 200, body: webmock_fixture('lod_loc_term_found.rdf.xml'), headers: { 'Content-Type' => 'application/rdf+xml' })
         end
         it 'succeeds and defaults to json content type' do
-          get :show, params: { id: 'sh85118553', vocab: 'LOC', subauthority: 'subjects' }
+          get :show, params: { id: 'sh 85118553', vocab: 'LOC', subauthority: 'subjects' }
           expect(response).to be_successful
           expect(response.content_type).to eq 'application/json'
         end
       end
     end
+
+    context 'when requesting performance data' do
+      before do
+        stub_request(:get, 'http://id.loc.gov/authorities/subjects/sh85118553')
+          .to_return(status: 200, body: webmock_fixture('lod_loc_term_found.rdf.xml'), headers: { 'Content-Type' => 'application/rdf+xml' })
+      end
+      it "returns basic data + performance data when performance_data='true'" do
+        get :show, params: { id: 'sh 85118553', vocab: 'LOC', subauthority: 'subjects', performance_data: 'true' }
+        expect(response).to be_successful
+        results = JSON.parse(response.body)
+        expect(results).to be_kind_of Hash
+        expect(results.keys).to match_array ['performance', 'results']
+        expect(results['performance'].keys).to match_array ['predicate_count', 'fetch_time_s', 'normalization_time_s', 'total_time_s']
+        expect(results['performance']['total_time_s']).to eq results['performance']['fetch_time_s'] + results['performance']['normalization_time_s']
+        expect(results['performance']['predicate_count']).to eq 15
+        expect(results['results']['predicates'].count).to eq 15
+      end
+
+      it "returns basic data only when performance_data='false'" do
+        get :show, params: { id: 'sh 85118553', vocab: 'LOC', subauthority: 'subjects', performance_data: 'false' }
+        expect(response).to be_successful
+        results = JSON.parse(response.body)
+        expect(results).to be_kind_of Hash
+        expect(results.keys).not_to include('performance')
+        expect(results['predicates'].size).to eq 15
+      end
+    end
   end
 
   describe '#fetch' do
     context 'producing internal server error' do
       context 'when server returns 500' do
         before do
-          stub_request(:get, 'http://localhost/test_default/term?uri=http://test.org/530369').to_return(status: 500)
+          stub_request(:get, 'http://localhost/test_default/term?uri=http://id.worldcat.org/fast/530369').to_return(status: 500)
         end
         it 'returns 500' do
-          expect(Rails.logger).to receive(:warn).with("Internal Server Error - Fetch term http://test.org/530369 unsuccessful for authority LOD_TERM_URI_PARAM_CONFIG")
-          get :fetch, params: { vocab: 'LOD_TERM_URI_PARAM_CONFIG', uri: 'http://test.org/530369' }
+          expect(Rails.logger).to receive(:warn).with("Internal Server Error - Fetch term http://id.worldcat.org/fast/530369 unsuccessful for authority LOD_TERM_URI_PARAM_CONFIG")
+          get :fetch, params: { vocab: 'LOD_TERM_URI_PARAM_CONFIG', uri: 'http://id.worldcat.org/fast/530369' }
           expect(response.code).to eq('500')
         end
       end
 
       context 'when rdf format error' do
         before do
-          stub_request(:get, 'http://localhost/test_default/term?uri=http://test.org/530369').to_return(status: 200)
+          stub_request(:get, 'http://localhost/test_default/term?uri=http://id.worldcat.org/fast/530369').to_return(status: 200)
           allow(RDF::Graph).to receive(:load).and_raise(RDF::FormatError)
         end
         it 'returns 500' do
-          msg = "RDF Format Error - Results from fetch term http://test.org/530369 for authority LOD_TERM_URI_PARAM_CONFIG was not identified as a valid RDF format.  " \
+          msg = "RDF Format Error - Results from fetch term http://id.worldcat.org/fast/530369 for authority LOD_TERM_URI_PARAM_CONFIG was not identified as a valid RDF format.  " \
                 "You may need to include the linkeddata gem."
           expect(Rails.logger).to receive(:warn).with(msg)
-          get :fetch, params: { uri: 'http://test.org/530369', vocab: 'LOD_TERM_URI_PARAM_CONFIG' }
+          get :fetch, params: { uri: 'http://id.worldcat.org/fast/530369', vocab: 'LOD_TERM_URI_PARAM_CONFIG' }
           expect(response.code).to eq('500')
         end
       end
 
       context "when error isn't specifically handled" do
         before do
-          stub_request(:get, 'http://localhost/test_default/term?uri=http://test.org/530369').to_return(status: 501)
+          stub_request(:get, 'http://localhost/test_default/term?uri=http://id.worldcat.org/fast/530369').to_return(status: 501)
         end
         it 'returns 500' do
-          expect(Rails.logger).to receive(:warn).with("Internal Server Error - Fetch term http://test.org/530369 unsuccessful for authority LOD_TERM_URI_PARAM_CONFIG")
-          get :fetch, params: { uri: 'http://test.org/530369', vocab: 'LOD_TERM_URI_PARAM_CONFIG' }
+          expect(Rails.logger).to receive(:warn).with("Internal Server Error - Fetch term http://id.worldcat.org/fast/530369 unsuccessful for authority LOD_TERM_URI_PARAM_CONFIG")
+          get :fetch, params: { uri: 'http://id.worldcat.org/fast/530369', vocab: 'LOD_TERM_URI_PARAM_CONFIG' }
           expect(response.code).to eq('500')
         end
       end
@@ -427,11 +521,11 @@ describe Qa::LinkedDataTermsController, type: :controller do
 
     context 'when service unavailable' do
       before do
-        stub_request(:get, 'http://localhost/test_default/term?uri=http://test.org/530369').to_return(status: 503)
+        stub_request(:get, 'http://localhost/test_default/term?uri=http://id.worldcat.org/fast/530369').to_return(status: 503)
       end
       it 'returns 503' do
-        expect(Rails.logger).to receive(:warn).with("Service Unavailable - Fetch term http://test.org/530369 unsuccessful for authority LOD_TERM_URI_PARAM_CONFIG")
-        get :fetch, params: { uri: 'http://test.org/530369', vocab: 'LOD_TERM_URI_PARAM_CONFIG' }
+        expect(Rails.logger).to receive(:warn).with("Service Unavailable - Fetch term http://id.worldcat.org/fast/530369 unsuccessful for authority LOD_TERM_URI_PARAM_CONFIG")
+        get :fetch, params: { uri: 'http://id.worldcat.org/fast/530369', vocab: 'LOD_TERM_URI_PARAM_CONFIG' }
         expect(response.code).to eq('503')
       end
     end
@@ -450,19 +544,19 @@ describe Qa::LinkedDataTermsController, type: :controller do
     context 'in LOD_TERM_URI_PARAM_CONFIG authority' do
       context 'term found' do
         before do
-          stub_request(:get, 'http://localhost/test_default/term?uri=http://test.org/530369')
+          stub_request(:get, 'http://localhost/test_default/term?uri=http://id.worldcat.org/fast/530369')
             .to_return(status: 200, body: webmock_fixture('lod_oclc_term_found.rdf.xml'), headers: { 'Content-Type' => 'application/rdf+xml' })
         end
 
         it 'succeeds and defaults to json content type' do
-          get :fetch, params: { uri: 'http://test.org/530369', vocab: 'LOD_TERM_URI_PARAM_CONFIG' }
+          get :fetch, params: { uri: 'http://id.worldcat.org/fast/530369', vocab: 'LOD_TERM_URI_PARAM_CONFIG' }
           expect(response).to be_successful
           expect(response.content_type).to eq 'application/json'
         end
 
         context 'and it was requested as json' do
           it 'succeeds and returns term data as json content type' do
-            get :fetch, params: { uri: 'http://test.org/530369', vocab: 'LOD_TERM_URI_PARAM_CONFIG', format: 'json' }
+            get :fetch, params: { uri: 'http://id.worldcat.org/fast/530369', vocab: 'LOD_TERM_URI_PARAM_CONFIG', format: 'json' }
             expect(response).to be_successful
             expect(response.content_type).to eq 'application/json'
           end
@@ -470,7 +564,7 @@ describe Qa::LinkedDataTermsController, type: :controller do
 
         context 'and it was requested as jsonld' do
           it 'succeeds and returns term data as jsonld content type' do
-            get :fetch, params: { uri: 'http://test.org/530369', vocab: 'LOD_TERM_URI_PARAM_CONFIG', format: 'jsonld' }
+            get :fetch, params: { uri: 'http://id.worldcat.org/fast/530369', vocab: 'LOD_TERM_URI_PARAM_CONFIG', format: 'jsonld' }
             expect(response).to be_successful
             expect(response.content_type).to eq 'application/ld+json'
             expect(JSON.parse(response.body).keys).to match_array ["@context", "@graph"]
@@ -479,11 +573,11 @@ describe Qa::LinkedDataTermsController, type: :controller do
 
         context 'blank nodes not included in predicates list' do
           before do
-            stub_request(:get, 'http://localhost/test_default/term?uri=http://test.org/530369wbn')
+            stub_request(:get, 'http://localhost/test_default/term?uri=http://id.worldcat.org/fast/530369wbn')
               .to_return(status: 200, body: webmock_fixture('lod_term_with_blanknode_objects.nt'), headers: { 'Content-Type' => 'application/n-triples' })
           end
           it 'succeeds' do
-            get :fetch, params: { uri: 'http://test.org/530369wbn', vocab: 'LOD_TERM_URI_PARAM_CONFIG' }
+            get :fetch, params: { uri: 'http://id.worldcat.org/fast/530369wbn', vocab: 'LOD_TERM_URI_PARAM_CONFIG' }
             expect(response).to be_successful
           end
         end
@@ -492,11 +586,11 @@ describe Qa::LinkedDataTermsController, type: :controller do
       context 'when cors headers are enabled' do
         before do
           Qa.config.enable_cors_headers
-          stub_request(:get, 'http://localhost/test_default/term?uri=http://test.org/530369')
+          stub_request(:get, 'http://localhost/test_default/term?uri=http://id.worldcat.org/fast/530369')
             .to_return(status: 200, body: webmock_fixture('lod_oclc_term_found.rdf.xml'), headers: { 'Content-Type' => 'application/rdf+xml' })
         end
         it 'Access-Control-Allow-Origin is *' do
-          get :fetch, params: { uri: 'http://test.org/530369', vocab: 'LOD_TERM_URI_PARAM_CONFIG' }
+          get :fetch, params: { uri: 'http://id.worldcat.org/fast/530369', vocab: 'LOD_TERM_URI_PARAM_CONFIG' }
           expect(response.headers['Access-Control-Allow-Origin']).to eq '*'
         end
       end
@@ -504,15 +598,42 @@ describe Qa::LinkedDataTermsController, type: :controller do
       context 'when cors headers are disabled' do
         before do
           Qa.config.disable_cors_headers
-          stub_request(:get, 'http://localhost/test_default/term?uri=http://test.org/530369')
+          stub_request(:get, 'http://localhost/test_default/term?uri=http://id.worldcat.org/fast/530369')
             .to_return(status: 200, body: webmock_fixture('lod_oclc_term_found.rdf.xml'), headers: { 'Content-Type' => 'application/rdf+xml' })
         end
         it 'Access-Control-Allow-Origin is not present' do
-          get :fetch, params: { uri: 'http://test.org/530369', vocab: 'LOD_TERM_URI_PARAM_CONFIG' }
+          get :fetch, params: { uri: 'http://id.worldcat.org/fast/530369', vocab: 'LOD_TERM_URI_PARAM_CONFIG' }
           expect(response.headers.key?('Access-Control-Allow-Origin')).to be false
         end
       end
     end
+
+    context 'when requesting performance data' do
+      before do
+        stub_request(:get, 'http://localhost/test_default/term?uri=http://id.worldcat.org/fast/530369')
+          .to_return(status: 200, body: webmock_fixture('lod_oclc_term_found.rdf.xml'), headers: { 'Content-Type' => 'application/rdf+xml' })
+      end
+      it "returns basic data + performance data when performance_data='true'" do
+        get :fetch, params: { uri: 'http://id.worldcat.org/fast/530369', vocab: 'LOD_TERM_URI_PARAM_CONFIG', performance_data: 'true' }
+        expect(response).to be_successful
+        results = JSON.parse(response.body)
+        expect(results).to be_kind_of Hash
+        expect(results.keys).to match_array ['performance', 'results']
+        expect(results['performance'].keys).to match_array ['predicate_count', 'fetch_time_s', 'normalization_time_s', 'total_time_s']
+        expect(results['performance']['total_time_s']).to eq results['performance']['fetch_time_s'] + results['performance']['normalization_time_s']
+        expect(results['performance']['predicate_count']).to eq 7
+        expect(results['results']['predicates'].count).to eq 7
+      end
+
+      it "returns basic data only when performance_data='false'" do
+        get :fetch, params: { uri: 'http://id.worldcat.org/fast/530369', vocab: 'LOD_TERM_URI_PARAM_CONFIG', performance_data: 'false' }
+        expect(response).to be_successful
+        results = JSON.parse(response.body)
+        expect(results).to be_kind_of Hash
+        expect(results.keys).not_to include('performance')
+        expect(results['predicates'].size).to eq 7
+      end
+    end
   end
 
   describe '#reload' do