qa 4.0.0 → 4.1.0

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

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'qa/authorities/linked_data/config/term_config'
 
 describe Qa::Authorities::LinkedData::TermConfig do
   let(:full_config) { Qa::Authorities::LinkedData::Config.new(:LOD_FULL_CONFIG).term }
@@ -6,13 +7,24 @@ describe Qa::Authorities::LinkedData::TermConfig do
   let(:search_only_config) { Qa::Authorities::LinkedData::Config.new(:LOD_SEARCH_ONLY_CONFIG).term }
   let(:encoding_config) { Qa::Authorities::LinkedData::Config.new(:LOD_ENCODING_CONFIG).term }
 
+  let(:ldpath_results_config) do
+    {
+      id_ldpath:       'schema:identifier ::xsd:string',
+      label_ldpath:    'skos:prefLabel ::xsd:string',
+      altlabel_ldpath: 'skos:altLabel ::xsd:string',
+      broader_ldpath:  'skos:broader ::xsd:string',
+      narrower_ldpath: 'skos:narrower ::xsd:string',
+      sameas_ldpath:   'skos:exactMatch ::xsd:string'
+    }
+  end
+
   describe '#term_config' do
     let(:full_term_config) do
       {
         url: {
           :@context => 'http://www.w3.org/ns/hydra/context.jsonld',
           :@type => 'IriTemplate',
-          template: 'http://localhost/test_default/term/{subauth}/{term_id}?{?param1}&{?param2}',
+          template: 'http://localhost/test_default/term/{subauth}/{term_id}?{?param1}&{?param2}&{?lang}',
           variableRepresentation: 'BasicRepresentation',
           mapping: [
             {
@@ -41,15 +53,23 @@ describe Qa::Authorities::LinkedData::TermConfig do
               property: 'hydra:freetextQuery',
               required: false,
               default: 'beta'
+            },
+            {
+              :@type => 'IriTemplateMapping',
+              variable: 'lang',
+              property: 'hydra:freetextQuery',
+              required: false,
+              default: 'de'
             }
           ]
         },
         qa_replacement_patterns: {
           term_id: 'term_id',
-          subauth: 'subauth'
+          subauth: 'subauth',
+          lang: 'lang'
         },
         term_id: 'ID',
-        language: ['en'],
+        language: ['es'],
         results: {
           id_predicate: 'http://purl.org/dc/terms/identifier',
           label_predicate: 'http://www.w3.org/2004/02/skos/core#prefLabel',
@@ -88,7 +108,7 @@ describe Qa::Authorities::LinkedData::TermConfig do
       {
         :@context => 'http://www.w3.org/ns/hydra/context.jsonld',
         :@type => 'IriTemplate',
-        template: 'http://localhost/test_default/term/{subauth}/{term_id}?{?param1}&{?param2}',
+        template: 'http://localhost/test_default/term/{subauth}/{term_id}?{?param1}&{?param2}&{?lang}',
         variableRepresentation: 'BasicRepresentation',
         mapping: [
           {
@@ -117,6 +137,13 @@ describe Qa::Authorities::LinkedData::TermConfig do
             property: 'hydra:freetextQuery',
             required: false,
             default: 'beta'
+          },
+          {
+            :@type => 'IriTemplateMapping',
+            variable: 'lang',
+            property: 'hydra:freetextQuery',
+            required: false,
+            default: 'de'
           }
         ]
       }
@@ -156,7 +183,7 @@ describe Qa::Authorities::LinkedData::TermConfig do
       expect(min_config.term_language).to eq nil
     end
     it 'returns the preferred language for selecting literal values if configured for term' do
-      expect(full_config.term_language).to eq [:en]
+      expect(full_config.term_language).to eq [:es]
     end
   end
 
@@ -188,6 +215,19 @@ describe Qa::Authorities::LinkedData::TermConfig do
     end
   end
 
+  describe '#term_results_id_ldpath' do
+    it 'returns nil if only search configuration is defined' do
+      expect(search_only_config.term_results_id_ldpath).to eq nil
+    end
+
+    context 'when id specified as ldpath' do
+      before { allow(full_config).to receive(:term_results).and_return(ldpath_results_config) }
+      it 'returns the ldpath' do
+        expect(full_config.term_results_id_ldpath).to eq 'schema:identifier ::xsd:string'
+      end
+    end
+  end
+
   describe '#term_results_label_predicate' do
     it 'returns nil if only search configuration is defined' do
       expect(search_only_config.term_results_label_predicate).to eq nil
@@ -197,6 +237,19 @@ describe Qa::Authorities::LinkedData::TermConfig do
     end
   end
 
+  describe '#term_results_label_ldpath' do
+    it 'returns nil if only search configuration is defined' do
+      expect(search_only_config.term_results_label_ldpath).to eq nil
+    end
+
+    context 'when label specified as ldpath' do
+      before { allow(full_config).to receive(:term_results).and_return(ldpath_results_config) }
+      it 'returns the ldpath' do
+        expect(full_config.term_results_label_ldpath).to eq 'skos:prefLabel ::xsd:string'
+      end
+    end
+  end
+
   describe '#term_results_altlabel_predicate' do
     it 'returns nil if only search configuration is defined' do
       expect(search_only_config.term_results_altlabel_predicate).to eq nil
@@ -209,6 +262,22 @@ describe Qa::Authorities::LinkedData::TermConfig do
     end
   end
 
+  describe '#term_results_altlabel_ldpath' do
+    it 'returns nil if only search configuration is defined' do
+      expect(search_only_config.term_results_altlabel_ldpath).to eq nil
+    end
+    it 'return nil if altlabel predicate is not defined' do
+      expect(min_config.term_results_altlabel_ldpath).to eq nil
+    end
+
+    context 'when altlabel specified as ldpath' do
+      before { allow(full_config).to receive(:term_results).and_return(ldpath_results_config) }
+      it 'returns the ldpath' do
+        expect(full_config.term_results_altlabel_ldpath).to eq 'skos:altLabel ::xsd:string'
+      end
+    end
+  end
+
   describe '#term_results_broader_predicate' do
     it 'returns nil if only search configuration is defined' do
       expect(search_only_config.term_results_broader_predicate).to eq nil
@@ -221,6 +290,22 @@ describe Qa::Authorities::LinkedData::TermConfig do
     end
   end
 
+  describe '#term_results_broader_ldpath' do
+    it 'returns nil if only search configuration is defined' do
+      expect(search_only_config.term_results_broader_ldpath).to eq nil
+    end
+    it 'return nil if broader predicate is not defined' do
+      expect(min_config.term_results_broader_ldpath).to eq nil
+    end
+
+    context 'when broader specified as ldpath' do
+      before { allow(full_config).to receive(:term_results).and_return(ldpath_results_config) }
+      it 'returns the ldpath' do
+        expect(full_config.term_results_broader_ldpath).to eq 'skos:broader ::xsd:string'
+      end
+    end
+  end
+
   describe '#term_results_narrower_predicate' do
     it 'returns nil if only search configuration is defined' do
       expect(search_only_config.term_results_narrower_predicate).to eq nil
@@ -233,6 +318,22 @@ describe Qa::Authorities::LinkedData::TermConfig do
     end
   end
 
+  describe '#term_results_narrower_ldpath' do
+    it 'returns nil if only search configuration is defined' do
+      expect(search_only_config.term_results_narrower_ldpath).to eq nil
+    end
+    it 'return nil if narrower predicate is not defined' do
+      expect(min_config.term_results_narrower_ldpath).to eq nil
+    end
+
+    context 'when narrower specified as ldpath' do
+      before { allow(full_config).to receive(:term_results).and_return(ldpath_results_config) }
+      it 'returns the ldpath' do
+        expect(full_config.term_results_narrower_ldpath).to eq 'skos:narrower ::xsd:string'
+      end
+    end
+  end
+
   describe '#term_results_sameas_predicate' do
     it 'returns nil if only search configuration is defined' do
       expect(search_only_config.term_results_sameas_predicate).to eq nil
@@ -245,6 +346,46 @@ describe Qa::Authorities::LinkedData::TermConfig do
     end
   end
 
+  describe '#term_results_sameas_ldpath' do
+    it 'returns nil if only search configuration is defined' do
+      expect(search_only_config.term_results_sameas_ldpath).to eq nil
+    end
+    it 'return nil if sameas predicate is not defined' do
+      expect(min_config.term_results_sameas_ldpath).to eq nil
+    end
+
+    context 'when sameas specified as ldpath' do
+      before { allow(full_config).to receive(:term_results).and_return(ldpath_results_config) }
+      it 'returns the ldpath' do
+        expect(full_config.term_results_sameas_ldpath).to eq 'skos:exactMatch ::xsd:string'
+      end
+    end
+  end
+
+  describe '#supports_language_parameter?' do
+    it 'returns false if only search configuration is defined' do
+      expect(search_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 search configuration is defined' do
+      expect(search_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 '#term_subauthorities?' do
     it 'returns false if only search configuration is defined' do
       expect(search_only_config.term_subauthorities?).to eq false
@@ -302,4 +443,51 @@ describe Qa::Authorities::LinkedData::TermConfig do
       expect(full_config.term_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).term.info }
+
+    it "returns a list with details for term without subauthorities" do
+      expect(details).to include_hash(term_details)
+    end
+
+    it "does not return a list with details for search without subauthorities" do
+      expect(details).not_to include_hash(search_details)
+    end
+
+    it "does not return a list with details for search with a subauthority" do
+      expect(details).not_to include_hash(search_details_with_subauth)
+    end
+  end
 end

data/spec/lib/configuration_spec.rb

@@ -68,4 +68,22 @@ RSpec.describe Qa::Configuration do
       end
     end
   end
+
+  describe '#limit_ldpath_to_context' do
+    context 'when NOT configured' do
+      it 'returns true' do
+        expect(subject.limit_ldpath_to_context?).to be true
+      end
+    end
+
+    context 'when configured' do
+      before do
+        subject.limit_ldpath_to_context = false
+      end
+
+      it 'returns the configured value' do
+        expect(subject.limit_ldpath_to_context?).to be false
+      end
+    end
+  end
 end

data/spec/models/linked_data/config/context_property_map_spec.rb

@@ -209,34 +209,6 @@ RSpec.describe Qa::LinkedData::Config::ContextPropertyMap do
     it 'returns the values selected from the graph' do
       expect(subject.values(graph, subject_uri)).to match_array coordinates
     end
-
-    context 'when ldpath_program gets parse error' do
-      let(:ldpath) { property_map[:ldpath] }
-      let(:cause) { "undefined method `ascii_tree' for nil:NilClass" }
-      let(:warning) { I18n.t('qa.linked_data.ldpath.parse_logger_error') }
-      let(:log_message) { "WARNING: #{warning} (ldpath='#{ldpath}')\n    cause: #{cause}" }
-
-      before { allow(Ldpath::Program).to receive(:parse).with(anything).and_raise(cause) }
-
-      it 'logs error and returns PARSE ERROR as the value' do
-        expect(Rails.logger).to receive(:warn).with(log_message)
-        expect { subject.values(graph, subject_uri) }.to raise_error StandardError, I18n.t('qa.linked_data.ldpath.parse_error')
-      end
-    end
-
-    context 'when ldpath_evaluate gets parse error' do
-      let(:ldpath) { property_map[:ldpath] }
-      let(:cause) { "unknown cause" }
-      let(:warning) { I18n.t('qa.linked_data.ldpath.evaluate_logger_error') }
-      let(:log_message) { "WARNING: #{warning} (ldpath='#{ldpath}')\n    cause: #{cause}" }
-
-      before { allow(program).to receive(:evaluate).with(subject_uri, graph).and_raise(cause) }
-
-      it 'logs error and returns PARSE ERROR as the value' do
-        expect(Rails.logger).to receive(:warn).with(log_message)
-        expect { subject.values(graph, subject_uri) }.to raise_error StandardError, I18n.t('qa.linked_data.ldpath.evaluate_error')
-      end
-    end
   end
 
   describe '#expand_uri?' do
@@ -271,9 +243,9 @@ RSpec.describe Qa::LinkedData::Config::ContextPropertyMap do
       allow(Ldpath::Program).to receive(:parse).with('property = madsrdf:identifiesRWO/madsrdf:birthDate/schema:label ;').and_return(basic_program)
       allow(Ldpath::Program).to receive(:parse).with('property = skos:prefLabel ::xsd:string ;').and_return(expanded_label_program)
       allow(Ldpath::Program).to receive(:parse).with('property = loc:lccn ::xsd:string ;').and_return(expanded_id_program)
-      allow(basic_program).to receive(:evaluate).with(subject_uri, graph).and_return('property' => [expanded_uri])
-      allow(expanded_label_program).to receive(:evaluate).with(RDF::URI.new(subject_uri), graph).and_return('property' => [expanded_label])
-      allow(expanded_id_program).to receive(:evaluate).with(RDF::URI.new(subject_uri), graph).and_return('property' => [expanded_id])
+      allow(basic_program).to receive(:evaluate).with(subject_uri, context: graph, limit_to_context: true).and_return('property' => [expanded_uri])
+      allow(expanded_label_program).to receive(:evaluate).with(RDF::URI.new(subject_uri), context: graph, limit_to_context: true).and_return('property' => [expanded_label])
+      allow(expanded_id_program).to receive(:evaluate).with(RDF::URI.new(subject_uri), context: graph, limit_to_context: true).and_return('property' => [expanded_id])
     end
     it 'returns the uri, id, label for the expanded uri value' do
       expanded_values = subject.expanded_values(graph, subject_uri).first

data/spec/services/iri_template_service_spec.rb

@@ -5,7 +5,7 @@ RSpec.describe Qa::IriTemplateService do
     {
       :'@context' => 'http://www.w3.org/ns/hydra/context.jsonld',
       :'@type' => 'IriTemplate',
-      template: 'http://localhost/test_default/search?{?subauth}&{?query}&{?max_records}&{?language}',
+      template: 'http://localhost/test_default/search?{?subauth}&{?query}&{?max_records}&{?lang}',
       variableRepresentation: 'BasicRepresentation',
       mapping: [
         {
@@ -18,8 +18,7 @@ RSpec.describe Qa::IriTemplateService do
           :'@type' => 'IriTemplateMapping',
           variable: 'subauth',
           property: 'hydra:freetextQuery',
-          required: false,
-          default: 'personal_names'
+          required: false
         },
         {
           :'@type' => 'IriTemplateMapping',
@@ -30,10 +29,9 @@ RSpec.describe Qa::IriTemplateService do
         },
         {
           :'@type' => 'IriTemplateMapping',
-          variable: 'language',
+          variable: 'lang',
           property: 'hydra:freetextQuery',
-          required: false,
-          default: 'en'
+          required: false
         }
       ]
     }
@@ -47,22 +45,66 @@ RSpec.describe Qa::IriTemplateService do
           query: 'mark twain',
           subauth: 'corporate_names',
           max_records: 10,
-          language: 'fr'
+          lang: 'fr'
         )
       end
 
       it 'returns template with substitutions' do
-        expected_url = 'http://localhost/test_default/search?subauth=corporate_names&query=mark twain&max_records=10&language=fr'
+        expected_url = 'http://localhost/test_default/search?subauth=corporate_names&query=mark twain&max_records=10&lang=fr'
         expect(described_class.build_url(url_config: url_config, substitutions: substitutions)).to eq expected_url
       end
     end
 
     context 'when minimal substitutions specified' do
-      let(:substitutions) { HashWithIndifferentAccess.new(query: 'mark twain') }
+      context 'and default specified for maxRecords only' do
+        let(:substitutions) { HashWithIndifferentAccess.new(query: 'mark twain') }
 
-      it 'returns template with substitutions' do
-        expected_url = 'http://localhost/test_default/search?subauth=personal_names&query=mark twain&max_records=20&language=en'
-        expect(described_class.build_url(url_config: url_config, substitutions: substitutions)).to eq expected_url
+        it 'returns template with substitutions' do
+          expected_url = 'http://localhost/test_default/search?query=mark twain&max_records=20'
+          expect(described_class.build_url(url_config: url_config, substitutions: substitutions)).to eq expected_url
+        end
+      end
+
+      context 'and defaults specified for all' do
+        let(:substitutions) { HashWithIndifferentAccess.new(query: 'mark twain') }
+        let(:mapping) do
+          [
+            {
+              :'@type' => 'IriTemplateMapping',
+              variable: 'query',
+              property: 'hydra:freetextQuery',
+              required: true
+            },
+            {
+              :'@type' => 'IriTemplateMapping',
+              variable: 'subauth',
+              property: 'hydra:freetextQuery',
+              required: false,
+              default: 'personal_names'
+            },
+            {
+              :'@type' => 'IriTemplateMapping',
+              variable: 'max_records',
+              property: 'hydra:freetextQuery',
+              required: false,
+              default: 20
+            },
+            {
+              :'@type' => 'IriTemplateMapping',
+              variable: 'lang',
+              property: 'hydra:freetextQuery',
+              required: false,
+              default: 'en'
+            }
+          ]
+        end
+
+        before { url_template[:mapping] = mapping }
+
+        it 'returns template with substitutions' do
+          expected_url = 'http://localhost/test_default/search?subauth=personal_names&query=mark twain&max_records=20&lang=en'
+          expect(described_class.build_url(url_config: url_config, substitutions: substitutions)).to eq expected_url
+        end
       end
     end
   end