qa 4.0.0 → 4.1.0

data/spec/lib/authorities/linked_data/search_config_spec.rb

@@ -1,18 +1,32 @@
 require 'spec_helper'
+require 'qa/authorities/linked_data/config/search_config'
 
 RSpec.describe Qa::Authorities::LinkedData::SearchConfig do
+  before do
+    Qa::LinkedData::AuthorityService.load_authorities
+  end
+
   let(:full_config) { Qa::Authorities::LinkedData::Config.new(:LOD_FULL_CONFIG).search }
   let(:min_config) { Qa::Authorities::LinkedData::Config.new(:LOD_MIN_CONFIG).search }
   let(:term_only_config) { Qa::Authorities::LinkedData::Config.new(:LOD_TERM_ONLY_CONFIG).search }
   let(:encoding_config) { Qa::Authorities::LinkedData::Config.new(:LOD_ENCODING_CONFIG).search }
 
+  let(:ldpath_results_config) do
+    {
+      id_ldpath: 'schema:identifier ::xsd:string',
+      label_ldpath: 'skos:prefLabel ::xsd:string',
+      altlabel_ldpath: 'skos:altLabel ::xsd:string',
+      sort_ldpath: 'skos:prefLabel ::xsd:string'
+    }
+  end
+
   describe '#search_config' do
     let(:full_search_config) do
       {
         url: {
           :@context => 'http://www.w3.org/ns/hydra/context.jsonld',
           :@type => 'IriTemplate',
-          template: 'http://localhost/test_default/search?{?subauth}&{?query}&{?param1}&{?param2}',
+          template: 'http://localhost/test_default/search?{?subauth}&{?query}&{?param1}&{?param2}&{?lang}',
           variableRepresentation: 'BasicRepresentation',
           mapping: [
             {
@@ -41,12 +55,20 @@ RSpec.describe Qa::Authorities::LinkedData::SearchConfig do
               property: 'hydra:freetextQuery',
               required: false,
               default: 'echo'
+            },
+            {
+              :@type => 'IriTemplateMapping',
+              variable: 'lang',
+              property: 'hydra:freetextQuery',
+              required: false,
+              default: 'fr'
             }
           ]
         },
         qa_replacement_patterns: {
           query: 'query',
-          subauth: 'subauth'
+          subauth: 'subauth',
+          lang: 'lang'
         },
         language: ['en', 'fr', 'de'],
         results: {
@@ -177,6 +199,19 @@ RSpec.describe Qa::Authorities::LinkedData::SearchConfig do
     end
   end
 
+  describe '#results_id_ldpath' do
+    it 'returns nil if only term configuration is defined' do
+      expect(term_only_config.results_id_ldpath).to eq nil
+    end
+
+    context 'when id specified as ldpath' do
+      before { allow(full_config).to receive(:results).and_return(ldpath_results_config) }
+      it 'returns the ldpath' do
+        expect(full_config.results_id_ldpath).to eq 'schema:identifier ::xsd:string'
+      end
+    end
+  end
+
   describe '#results_label_predicate' do
     it 'returns nil if only term configuration is defined' do
       expect(term_only_config.results_label_predicate).to eq nil
@@ -186,11 +221,24 @@ RSpec.describe Qa::Authorities::LinkedData::SearchConfig do
     end
   end
 
+  describe '#results_label_ldpath' do
+    it 'returns nil if only term configuration is defined' do
+      expect(term_only_config.results_label_ldpath).to eq nil
+    end
+
+    context 'when label specified as ldpath' do
+      before { allow(full_config).to receive(:results).and_return(ldpath_results_config) }
+      it 'returns the ldpath' do
+        expect(full_config.results_label_ldpath).to eq 'skos:prefLabel ::xsd:string'
+      end
+    end
+  end
+
   describe '#results_altlabel_predicate' do
     it 'returns nil if only term configuration is defined' do
       expect(term_only_config.results_altlabel_predicate).to eq nil
     end
-    it 'return nil if altlabel predicate is not defined' do
+    it 'returns nil if altlabel predicate is not defined' do
       expect(min_config.results_altlabel_predicate).to eq nil
     end
     it 'returns the predicate that holds the altlabel in search results' do
@@ -198,6 +246,22 @@ RSpec.describe Qa::Authorities::LinkedData::SearchConfig do
     end
   end
 
+  describe '#results_altlabel_ldpath' do
+    it 'returns nil if only term configuration is defined' do
+      expect(term_only_config.results_altlabel_ldpath).to eq nil
+    end
+    it 'returns nil if altlabel ldpath is not defined' do
+      expect(min_config.results_altlabel_ldpath).to eq nil
+    end
+
+    context 'when altlabel specified as ldpath' do
+      before { allow(full_config).to receive(:results).and_return(ldpath_results_config) }
+      it 'returns the ldpath' do
+        expect(full_config.results_altlabel_ldpath).to eq 'skos:altLabel ::xsd:string'
+      end
+    end
+  end
+
   describe '#supports_sort?' do
     it 'returns false if only term configuration is defined' do
       expect(term_only_config.supports_sort?).to eq false
@@ -222,6 +286,22 @@ RSpec.describe Qa::Authorities::LinkedData::SearchConfig do
     end
   end
 
+  describe '#results_sort_ldpath' do
+    it 'returns nil if only term configuration is defined' do
+      expect(term_only_config.results_sort_ldpath).to eq nil
+    end
+    it 'returns nil if sort ldpath is not defined' do
+      expect(min_config.results_sort_ldpath).to eq nil
+    end
+
+    context 'when sort specified as ldpath' do
+      before { allow(full_config).to receive(:results).and_return(ldpath_results_config) }
+      it 'returns the ldpath' do
+        expect(full_config.results_sort_ldpath).to eq 'skos:prefLabel ::xsd:string'
+      end
+    end
+  end
+
   describe '#supports_context?' do
     it 'returns false if only term configuration is defined' do
       expect(term_only_config.supports_context?).to eq false
@@ -246,6 +326,30 @@ RSpec.describe Qa::Authorities::LinkedData::SearchConfig do
     end
   end
 
+  describe '#supports_language_parameter?' do
+    it 'returns false if only term configuration is defined' do
+      expect(term_only_config.supports_language_parameter?).to eq false
+    end
+    it 'returns false if the configuration does NOT define the lang replacement' do
+      expect(min_config.supports_language_parameter?).to eq false
+    end
+    it 'returns true if the configuration defines the lang replacement' do
+      expect(full_config.supports_language_parameter?).to eq true
+    end
+  end
+
+  describe '#supports_subauthorities?' do
+    it 'returns false if only term configuration is defined' do
+      expect(term_only_config.supports_subauthorities?).to eq false
+    end
+    it 'returns false if the configuration does NOT define the subauth replacement' do
+      expect(min_config.supports_subauthorities?).to eq false
+    end
+    it 'returns true if the configuration defines the subauth replacement' do
+      expect(full_config.supports_subauthorities?).to eq true
+    end
+  end
+
   describe '#subauthorities?' do
     it 'returns false if only term configuration is defined' do
       expect(term_only_config.subauthorities?).to eq false
@@ -303,4 +407,51 @@ RSpec.describe Qa::Authorities::LinkedData::SearchConfig do
       expect(full_config.subauthorities).to eq expected_hash
     end
   end
+
+  describe '#info' do
+    let(:term_details) do
+      {
+        "label" => "oclc_fast term (QA)",
+        "uri" => "urn:qa:term:oclc_fast",
+        "authority" => "oclc_fast",
+        "action" => "term",
+        "language" => ["en"]
+      }
+    end
+
+    let(:search_details) do
+      {
+        "label" => "oclc_fast search (QA)",
+        "uri" => "urn:qa:search:oclc_fast",
+        "authority" => "oclc_fast",
+        "action" => "search",
+        "language" => ["en"]
+      }
+    end
+
+    let(:search_details_with_subauth) do
+      {
+        "label" => "oclc_fast search topic (QA)",
+        "uri" => "urn:qa:search:oclc_fast:topic",
+        "authority" => "oclc_fast",
+        "subauthority" => "topic",
+        "action" => "search",
+        "language" => ["en"]
+      }
+    end
+
+    let(:details) { Qa::Authorities::LinkedData::Config.new(:OCLC_FAST).search.info }
+
+    it "does not return a list with details for term" do
+      expect(details).not_to include_hash(term_details)
+    end
+
+    it "returns a list with details for search without subauthorities" do
+      expect(details).to include_hash(search_details)
+    end
+
+    it "returns a list with details for search with a subauthority" do
+      expect(details).to include_hash(search_details_with_subauth)
+    end
+  end
 end

data/spec/lib/authorities/linked_data/search_query_spec.rb

@@ -1,7 +1,244 @@
 require 'spec_helper'
 
 RSpec.describe Qa::Authorities::LinkedData::SearchQuery do
-  # all search functionality is tested in spec/lib/authorities/linked_data/generic_authority_spec.rb and
-  # spec/controllers/linked_data_term_controller_spec.rb
-  it "is tested elsewhere"
+  describe '#search' do
+    let(:lod_oclc) { described_class.new(search_config(:OCLC_FAST)) }
+
+    context 'performance stats' do
+      before do
+        stub_request(:get, 'http://experimental.worldcat.org/fast/search?maximumRecords=3&query=oclc.personalName%20all%20%22cornell%22&sortKeys=usage')
+          .to_return(status: 200, body: webmock_fixture('lod_oclc_personalName_query_3_results.rdf.xml'), headers: { 'Content-Type' => 'application/rdf+xml' })
+      end
+      context 'when set to true' do
+        let :results do
+          lod_oclc.search('cornell', subauth: 'personal_name', replacements: { 'maximumRecords' => '3' }, performance_data: true)
+        end
+        it 'includes performance in return hash' do
+          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
+      end
+
+      context 'when set to false' do
+        let :results do
+          lod_oclc.search('cornell', subauth: 'personal_name', replacements: { 'maximumRecords' => '3' }, performance_data: false)
+        end
+        it 'does NOT include performance in return hash' do
+          expect(results).to be_kind_of Array
+        end
+      end
+
+      context 'when using default setting' do
+        let :results do
+          lod_oclc.search('cornell', subauth: 'personal_name', replacements: { 'maximumRecords' => '3' })
+        end
+        it 'does NOT include performance in return hash' do
+          expect(results).to be_kind_of Array
+        end
+      end
+    end
+
+    context 'in OCLC_FAST authority' do
+      context '0 search results' do
+        let :results do
+          stub_request(:get, 'http://experimental.worldcat.org/fast/search?maximumRecords=3&query=cql.any%20all%20%22supercalifragilisticexpialidocious%22&sortKeys=usage')
+            .to_return(status: 200, body: webmock_fixture('lod_oclc_query_no_results.rdf.xml'), headers: { 'Content-Type' => 'application/rdf+xml' })
+          lod_oclc.search('supercalifragilisticexpialidocious', replacements: { 'maximumRecords' => '3' })
+        end
+        it 'returns an empty array' do
+          expect(results).to eq([])
+        end
+      end
+
+      context '3 search results' do
+        let :results do
+          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' })
+          lod_oclc.search('cornell', replacements: { 'maximumRecords' => '3' })
+        end
+        it 'is correctly parsed' do
+          expect(results.count).to eq(3)
+          expect(results.first).to eq(uri: 'http://id.worldcat.org/fast/530369', id: '530369', label: 'Cornell University')
+          expect(results.second).to eq(uri: 'http://id.worldcat.org/fast/5140', id: '5140', label: 'Cornell, Joseph')
+          expect(results.third).to eq(uri: 'http://id.worldcat.org/fast/557490', id: '557490', label: 'New York State School of Industrial and Labor Relations')
+        end
+      end
+    end
+
+    context 'in OCLC_FAST authority and personal_name subauthority' do
+      context '0 search results' do
+        let :results do
+          stub_request(:get, 'http://experimental.worldcat.org/fast/search?maximumRecords=3&query=oclc.personalName%20all%20%22supercalifragilisticexpialidocious%22&sortKeys=usage')
+            .to_return(status: 200, body: webmock_fixture('lod_oclc_query_no_results.rdf.xml'), headers: { 'Content-Type' => 'application/rdf+xml' })
+          lod_oclc.search('supercalifragilisticexpialidocious', subauth: 'personal_name', replacements: { 'maximumRecords' => '3' })
+        end
+        it 'returns an empty array' do
+          expect(results).to eq([])
+        end
+      end
+
+      context '3 search results' do
+        let :results do
+          stub_request(:get, 'http://experimental.worldcat.org/fast/search?maximumRecords=3&query=oclc.personalName%20all%20%22cornell%22&sortKeys=usage')
+            .to_return(status: 200, body: webmock_fixture('lod_oclc_personalName_query_3_results.rdf.xml'), headers: { 'Content-Type' => 'application/rdf+xml' })
+          lod_oclc.search('cornell', subauth: 'personal_name', replacements: { 'maximumRecords' => '3' })
+        end
+        it 'is correctly parsed' do
+          expect(results.count).to eq(3)
+          expect(results.first).to eq(uri: 'http://id.worldcat.org/fast/409667', id: '409667', label: 'Cornell, Ezra, 1807-1874')
+          expect(results.second).to eq(uri: 'http://id.worldcat.org/fast/5140', id: '5140', label: 'Cornell, Joseph')
+          expect(results.third).to eq(uri: 'http://id.worldcat.org/fast/72456', id: '72456', label: 'Cornell, Sarah Maria, 1802-1832')
+        end
+      end
+    end
+
+    context 'when id predicate is not specified' do
+      let(:min_authority) { described_class.new(search_config(:LOD_MIN_CONFIG)) }
+      let :results do
+        stub_request(:get, 'http://localhost/test_default/search?query=peanuts')
+          .to_return(status: 200, body: webmock_fixture('lod_oclc_personalName_query_3_results.rdf.xml'), headers: { 'Content-Type' => 'application/rdf+xml' })
+        min_authority.search('peanuts')
+      end
+      it 'uses subject uri for id' do
+        expect(results.count).to eq(3)
+        expect(results.first).to eq(uri: 'http://id.worldcat.org/fast/409667', id: 'http://id.worldcat.org/fast/409667', label: 'Cornell, Ezra, 1807-1874')
+        expect(results.second).to eq(uri: 'http://id.worldcat.org/fast/5140', id: 'http://id.worldcat.org/fast/5140', label: 'Cornell, Joseph')
+        expect(results.third).to eq(uri: 'http://id.worldcat.org/fast/72456', id: 'http://id.worldcat.org/fast/72456', label: 'Cornell, Sarah Maria, 1802-1832')
+      end
+    end
+
+    # context 'in LOC authority' do
+    #   ###################################
+    #   ### SEARCH NOT SUPPORTED BY LOC ###
+    #   ###################################
+    #   # let(:lod_loc) { described_class.new(search_config(:LOC)) }
+    # end
+
+    # rubocop:disable RSpec/NestedGroups
+    describe "language processing" do
+      context "when filtering #search results" do
+        context "and lang NOT passed in" do
+          context "and NO language defined in authority config" do
+            context "and NO language defined in Qa config" do
+              let(:lod_lang_no_defaults) { described_class.new(search_config(:LOD_LANG_NO_DEFAULTS)) }
+              let :results do
+                stub_request(:get, "http://localhost/test_no_default/search?query=milk")
+                  .to_return(status: 200, body: webmock_fixture("lod_lang_search_enfr.rdf.xml"), headers: { 'Content-Type' => 'application/rdf+xml' })
+                lod_lang_no_defaults.search('milk')
+              end
+
+              before do
+                Qa.config.default_language = []
+              end
+
+              after do
+                Qa.config.default_language = :en
+              end
+
+              it "is not filtered" do
+                expect(results.first[:label]).to eq('[buttermilk, Babeurre] (yummy, délicieux)')
+                expect(results.second[:label]).to eq('[condensed milk, lait condensé] (creamy, crémeux)')
+                expect(results.third[:label]).to eq('[dried milk, lait en poudre] (powdery, poudreux)')
+              end
+            end
+
+            context "and default_language is defined in Qa config" do
+              let(:lod_lang_no_defaults) { described_class.new(search_config(:LOD_LANG_NO_DEFAULTS)) }
+              let :results do
+                stub_request(:get, "http://localhost/test_no_default/search?query=milk")
+                  .to_return(status: 200, body: webmock_fixture("lod_lang_search_enfr.rdf.xml"), headers: { 'Content-Type' => 'application/rdf+xml' })
+                lod_lang_no_defaults.search('milk')
+              end
+              it "filters using Qa configured default" do
+                expect(results.first[:label]).to eq('buttermilk (yummy)')
+                expect(results.second[:label]).to eq('condensed milk (creamy)')
+                expect(results.third[:label]).to eq('dried milk (powdery)')
+              end
+            end
+          end
+
+          context "and language IS defined in authority config" do
+            let(:lod_lang_defaults) { described_class.new(search_config(:LOD_LANG_DEFAULTS)) }
+            let :results do
+              stub_request(:get, "http://localhost/test_default/search?query=milk")
+                .to_return(status: 200, body: webmock_fixture("lod_lang_search_enfr.rdf.xml"), headers: { 'Content-Type' => 'application/rdf+xml' })
+              lod_lang_defaults.search('milk')
+            end
+            it "is filtered to authority defined language" do
+              expect(results.first[:label]).to eq('Babeurre (délicieux)')
+              expect(results.second[:label]).to eq('lait condensé (crémeux)')
+              expect(results.third[:label]).to eq('lait en poudre (poudreux)')
+            end
+          end
+        end
+
+        context "and multiple languages ARE defined in authority config" do
+          let(:lod_lang_multi_defaults) { described_class.new(search_config(:LOD_LANG_MULTI_DEFAULTS)) }
+          let :results do
+            stub_request(:get, "http://localhost/test_default/search?query=milk")
+              .to_return(status: 200, body: webmock_fixture("lod_lang_search_enfrde.rdf.xml"), headers: { 'Content-Type' => 'application/rdf+xml' })
+            lod_lang_multi_defaults.search('milk')
+          end
+          it "is filtered to authority defined languages" do
+            expect(results.first[:label]).to eq('[buttermilk, Babeurre] (yummy, délicieux)')
+            expect(results.second[:label]).to eq('[condensed milk, lait condensé] (creamy, crémeux)')
+            expect(results.third[:label]).to eq('[dried milk, lait en poudre] (powdery, poudreux)')
+          end
+        end
+
+        context "and language IS passed in to search" do
+          let(:lod_lang_defaults) { described_class.new(search_config(:LOD_LANG_DEFAULTS)) }
+          let :results do
+            stub_request(:get, "http://localhost/test_default/search?query=milk")
+              .to_return(status: 200, body: webmock_fixture("lod_lang_search_enfr.rdf.xml"), headers: { 'Content-Type' => 'application/rdf+xml' })
+            lod_lang_defaults.search('milk', language: :fr)
+          end
+          it "is filtered to specified language" do
+            expect(results.first[:label]).to eq('Babeurre (délicieux)')
+            expect(results.second[:label]).to eq('lait condensé (crémeux)')
+            expect(results.third[:label]).to eq('lait en poudre (poudreux)')
+          end
+        end
+
+        context "when replacement on authority search URL" do
+          context "and using default" do
+            let(:lod_lang_param) { described_class.new(search_config(:LOD_LANG_PARAM)) }
+            let :results do
+              stub_request(:get, "http://localhost/test_replacement/search?lang=en&query=milk")
+                .to_return(status: 200, body: webmock_fixture("lod_lang_search_en.rdf.xml"), headers: { 'Content-Type' => 'application/rdf+xml' })
+              lod_lang_param.search("milk")
+            end
+            it "is correctly parsed" do
+              expect(results.first[:label]).to eq('buttermilk (yummy)')
+              expect(results.second[:label]).to eq('condensed milk (creamy)')
+              expect(results.third[:label]).to eq('dried milk (powdery)')
+            end
+          end
+
+          context "and lang specified" do
+            let(:lod_lang_param) { described_class.new(search_config(:LOD_LANG_PARAM)) }
+            let :results do
+              stub_request(:get, "http://localhost/test_replacement/search?query=milk&lang=fr")
+                .to_return(status: 200, body: webmock_fixture("lod_lang_search_fr.rdf.xml"), headers: { 'Content-Type' => 'application/rdf+xml' })
+              lod_lang_param.search("milk", replacements: { 'lang' => 'fr' })
+            end
+            it "is correctly parsed" do
+              expect(results.first[:label]).to eq('Babeurre (délicieux)')
+              expect(results.second[:label]).to eq('lait condensé (crémeux)')
+              expect(results.third[:label]).to eq('lait en poudre (poudreux)')
+            end
+          end
+        end
+      end
+    end
+    # rubocop:enable RSpec/NestedGroups
+  end
+
+  def search_config(authority_name)
+    Qa::Authorities::LinkedData::Config.new(authority_name).search
+  end
 end