qa 3.1.0 → 4.0.0.rc1

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

@@ -1,131 +1,7 @@
 require 'spec_helper'
 
 RSpec.describe Qa::Authorities::LinkedData::SearchQuery do
-  describe "#sort_search_results" do
-    let(:config) { Qa::Authorities::LinkedData::Config.new(auth_name).search }
-    let(:instance) { described_class.new(config) }
-
-    let(:term_a) { "alpha" }
-    let(:term_b) { "bravo" }
-    let(:term_c) { "charlie" }
-    let(:term_d) { "delta" }
-
-    context 'when sort predicate is NOT specified in configuration' do
-      let(:auth_name) { :LOD_MIN_CONFIG }
-
-      it "does not change order" do
-        json_results = [{ label: "[#{term_b}, #{term_c}]", sort: [term_b, term_c] },
-                        { label: "[#{term_b}, #{term_d}]", sort: [term_b, term_d] },
-                        { label: "[#{term_b}, #{term_a}]", sort: [term_b, term_a] }]
-        expect(instance.send(:sort_search_results, json_results)).to eq json_results
-      end
-    end
-
-    context 'when sort predicate is specified in configuration' do
-      let(:auth_name) { :LOD_SORT }
-
-      context "and sort term is empty" do
-        context "for all" do
-          it "does not change order" do
-            json_results = [{ label: "[#{term_b}]", sort: [""] },
-                            { label: "[#{term_a}]", sort: [""] },
-                            { label: "[#{term_c}]", sort: [""] }]
-            expect(instance.send(:sort_search_results, json_results)).to eq json_results
-          end
-        end
-
-        context "for one" do
-          it "puts empty first when empty is in 1st position" do
-            json_results = [{ label: "['_empty_1_']", sort: [""] },
-                            { label: "[#{term_c}]", sort: [term_c] },
-                            { label: "[#{term_a}]", sort: [term_a] }]
-            expected_results = [{ label: "['_empty_1_']" },
-                                { label: "[#{term_a}]" },
-                                { label: "[#{term_c}]" }]
-            expect(instance.send(:sort_search_results, json_results)).to eq expected_results
-          end
-
-          it "puts empty first when empty is in 2nd position" do
-            json_results = [{ label: "[#{term_b}]", sort: [term_b] },
-                            { label: "['_empty_2_']", sort: [""] },
-                            { label: "[#{term_a}]", sort: [term_a] }]
-            expected_results = [{ label: "['_empty_2_']" },
-                                { label: "[#{term_a}]" },
-                                { label: "[#{term_b}]" }]
-            expect(instance.send(:sort_search_results, json_results)).to eq expected_results
-          end
-
-          it "puts empty first when empty is in last position" do
-            json_results = [{ label: "[#{term_b}]", sort: [term_b] },
-                            { label: "[#{term_c}]", sort: [term_c] },
-                            { label: "['_empty_last_']", sort: [""] }]
-            expected_results = [{ label: "['_empty_last_']" },
-                                { label: "[#{term_b}]" },
-                                { label: "[#{term_c}]" }]
-            expect(instance.send(:sort_search_results, json_results)).to eq expected_results
-          end
-        end
-      end
-
-      context "and sort term is single value" do
-        context "for all" do
-          it "sorts on the single value" do
-            json_results = [{ label: "[#{term_b}]", sort: [term_b] },
-                            { label: "[#{term_c}]", sort: [term_c] },
-                            { label: "[#{term_a}]", sort: [term_a] }]
-            expected_results = [{ label: "[#{term_a}]" },
-                                { label: "[#{term_b}]" },
-                                { label: "[#{term_c}]" }]
-            expect(instance.send(:sort_search_results, json_results)).to eq expected_results
-          end
-        end
-      end
-
-      context "when first sort term is same" do
-        it "sorts on second sort term" do
-          json_results = [{ label: "[#{term_b}, #{term_c}]", sort: [term_b, term_c] },
-                          { label: "[#{term_b}, #{term_d}]", sort: [term_b, term_d] },
-                          { label: "[#{term_b}, #{term_a}]", sort: [term_b, term_a] }]
-          expected_results = [{ label: "[#{term_b}, #{term_a}]" },
-                              { label: "[#{term_b}, #{term_c}]" },
-                              { label: "[#{term_b}, #{term_d}]" }]
-          expect(instance.send(:sort_search_results, json_results)).to eq expected_results
-        end
-      end
-
-      context "when different number of sort terms" do
-        context "and initial terms match" do
-          it "puts shorter set of terms before longer set" do
-            json_results = [{ label: "[#{term_b}, #{term_c}]", sort: [term_b, term_c] },
-                            { label: "[#{term_b}]", sort: [term_b] },
-                            { label: "[#{term_b}, #{term_a}]", sort: [term_b, term_a] }]
-            expected_results = [{ label: "[#{term_b}]" },
-                                { label: "[#{term_b}, #{term_a}]" },
-                                { label: "[#{term_b}, #{term_c}]" }]
-            expect(instance.send(:sort_search_results, json_results)).to eq expected_results
-          end
-        end
-
-        context "and a difference happens before end of term sets" do
-          it "stops ordering as soon as a difference is found" do
-            json_results = [{ label: "[#{term_b}, #{term_d}, #{term_c}]", sort: [term_b, term_d, term_c] },
-                            { label: "[#{term_a}, #{term_c}]", sort: [term_a, term_c] },
-                            { label: "[#{term_b}, #{term_d}, #{term_a}]", sort: [term_b, term_d, term_a] }]
-            expected_results = [{ label: "[#{term_a}, #{term_c}]" },
-                                { label: "[#{term_b}, #{term_d}, #{term_a}]" },
-                                { label: "[#{term_b}, #{term_d}, #{term_c}]" }]
-            expect(instance.send(:sort_search_results, json_results)).to eq expected_results
-          end
-        end
-      end
-
-      context "and sort values are numeric" do
-        it "does numeric compare" do
-          json_results = [{ label: "['22']", sort: ["22"] }, { label: "['1']", sort: ["1"] }, { label: "['215']", sort: ["215"] }]
-          expected_results = [{ label: "['1']" }, { label: "['22']" }, { label: "['215']" }]
-          expect(instance.send(:sort_search_results, json_results)).to eq expected_results
-        end
-      end
-    end
-  end
+  # 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"
 end

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

@@ -12,7 +12,7 @@ describe Qa::Authorities::LinkedData::TermConfig do
         url: {
           :@context => 'http://www.w3.org/ns/hydra/context.jsonld',
           :@type => 'IriTemplate',
-          template: 'http://localhost/test_default/term/{?subauth}/{?term_id}?param1={?param1}&param2={?param2}',
+          template: 'http://localhost/test_default/term/{subauth}/{term_id}?{?param1}&{?param2}',
           variableRepresentation: 'BasicRepresentation',
           mapping: [
             {
@@ -83,12 +83,12 @@ describe Qa::Authorities::LinkedData::TermConfig do
     end
   end
 
-  describe '#term_url' do
+  describe '#url_config' do
     let(:url_config) do
       {
         :@context => 'http://www.w3.org/ns/hydra/context.jsonld',
         :@type => 'IriTemplate',
-        template: 'http://localhost/test_default/term/{?subauth}/{?term_id}?param1={?param1}&param2={?param2}',
+        template: 'http://localhost/test_default/term/{subauth}/{term_id}?{?param1}&{?param2}',
         variableRepresentation: 'BasicRepresentation',
         mapping: [
           {
@@ -123,20 +123,10 @@ describe Qa::Authorities::LinkedData::TermConfig do
     end
 
     it 'returns nil if only search configuration is defined' do
-      expect(search_only_config.term_url).to eq nil
+      expect(search_only_config.url_config).to eq nil
     end
-    it 'returns the term url from the configuration' do
-      expect(full_config.term_url).to eq url_config
-    end
-  end
-
-  describe '#term_url' do
-    it 'returns nil if only search configuration is defined' do
-      expect(search_only_config.term_url_template).to eq nil
-    end
-    it 'returns the term url from the configuration' do
-      expected_url = 'http://localhost/test_default/term/{?subauth}/{?term_id}?param1={?param1}&param2={?param2}'
-      expect(full_config.term_url_template).to eq expected_url
+    it 'returns the url config from the configuration' do
+      expect(full_config.url_config).to be_kind_of Qa::IriTemplate::UrlConfig
     end
   end
 
@@ -255,48 +245,6 @@ describe Qa::Authorities::LinkedData::TermConfig do
     end
   end
 
-  describe '#term_replacements?' do
-    it 'returns false if only search configuration is defined' do
-      expect(search_only_config.term_replacements?).to eq false
-    end
-    it 'returns false if the configuration does NOT define replacements' do
-      expect(min_config.term_replacements?).to eq false
-    end
-    it 'returns true if the configuration defines replacements' do
-      expect(full_config.term_replacements?).to eq true
-    end
-  end
-
-  describe '#term_replacement_count' do
-    it 'returns 0 if only search configuration is defined' do
-      expect(search_only_config.term_replacement_count).to eq 0
-    end
-    it 'returns 0 if replacement_count is NOT defined' do
-      expect(min_config.term_replacement_count).to eq 0
-    end
-    it 'returns the number of replacements if defined' do
-      expect(full_config.term_replacement_count).to eq 2
-    end
-  end
-
-  describe '#term_replacements' do
-    it 'returns empty hash if only search configuration is defined' do
-      empty_hash = {}
-      expect(search_only_config.term_replacements).to eq empty_hash
-    end
-    it 'returns empty hash if no replacement patterns are defined' do
-      empty_hash = {}
-      expect(min_config.term_replacements).to eq empty_hash
-    end
-    it 'returns hash of all replacement patterns' do
-      expected_hash = {
-        param1: { :@type => 'IriTemplateMapping', variable: 'param1', property: 'hydra:freetextQuery', required: false, default: 'alpha' },
-        param2: { :@type => 'IriTemplateMapping', variable: 'param2', property: 'hydra:freetextQuery', required: false, default: 'beta' }
-      }
-      expect(full_config.term_replacements).to eq expected_hash
-    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
@@ -354,80 +302,4 @@ describe Qa::Authorities::LinkedData::TermConfig do
       expect(full_config.term_subauthorities).to eq expected_hash
     end
   end
-
-  describe '#term_subauthority_replacement_pattern' do
-    it 'returns empty hash if only search configuration is defined' do
-      empty_hash = {}
-      expect(search_only_config.term_subauthority_replacement_pattern).to eq empty_hash
-    end
-    it 'returns empty hash if no subauthorities are defined' do
-      empty_hash = {}
-      expect(min_config.term_subauthority_replacement_pattern).to eq empty_hash
-    end
-    it 'returns hash replacement pattern for subauthority and the default value' do
-      expected_hash = { pattern: 'subauth', default: 'term_sub2_name' }
-      expect(full_config.term_subauthority_replacement_pattern).to eq expected_hash
-    end
-  end
-
-  # rubocop:disable RSpec/RepeatedExample
-  describe '#term_url_with_replacements' do
-    it 'returns nil if only search configuration is defined' do
-      expect(search_only_config.term_url_with_replacements('C123')).to eq nil
-    end
-    context 'when subauthorities ARE defined' do
-      it 'returns the url with query substitution applied' do
-        expected_url = 'http://localhost/test_default/term/term_sub2_name/C123?param1=alpha&param2=beta'
-        expect(full_config.term_url_with_replacements('C123')).to eq expected_url
-      end
-      it 'returns the url with default subauthority when NOT specified' do
-        expected_url = 'http://localhost/test_default/term/term_sub2_name/C123?param1=alpha&param2=beta'
-        expect(full_config.term_url_with_replacements('C123')).to eq expected_url
-      end
-      it 'returns the url with subauthority substitution when specified' do
-        expected_url = 'http://localhost/test_default/term/term_sub3_name/C123?param1=alpha&param2=beta'
-        expect(full_config.term_url_with_replacements('C123', 'term_sub3_key')).to eq expected_url
-      end
-      it 'returns the url with default values when replacements are NOT specified' do
-        expected_url = 'http://localhost/test_default/term/term_sub2_name/C123?param1=alpha&param2=beta'
-        expect(full_config.term_url_with_replacements('C123')).to eq expected_url
-      end
-      it 'returns the url with replacement substitution values when replacements are specified' do
-        expected_url = 'http://localhost/test_default/term/term_sub2_name/C123?param1=golf&param2=hotel'
-        expect(full_config.term_url_with_replacements('C123', nil, param1: 'golf', param2: 'hotel')).to eq expected_url
-      end
-    end
-
-    context 'when subauthorities are NOT defined' do
-      it 'returns the url with query substitution applied' do
-        expected_url = 'http://localhost/test_default/term/C123'
-        expect(min_config.term_url_with_replacements('C123')).to eq expected_url
-      end
-      it 'and subauth param is included returns the url with query substitution applied ignoring the subauth' do
-        expected_url = 'http://localhost/test_default/term/C123'
-        expect(min_config.term_url_with_replacements('C123', 'fake_subauth_key')).to eq expected_url
-      end
-    end
-
-    context 'when replacements are not defined' do
-      it 'returns the url with query substitution applied' do
-        expected_url = 'http://localhost/test_default/term/C123'
-        expect(min_config.term_url_with_replacements('C123')).to eq expected_url
-      end
-      it 'and replacements param is included returns the url with query substitution applied ignoring the replacements' do
-        expected_url = 'http://localhost/test_default/term/C123'
-        expect(min_config.term_url_with_replacements('C123', nil, fake_replacement_key: 'fake_value')).to eq expected_url
-      end
-    end
-
-    context 'with encoding specified in config' do
-      it 'returns the uri as the url' do
-        expected_url = 'http://localhost/test_default/term?uri=http%3A%2F%2Fencoded%2Ebecause%3Fencode%3Dtrue&yes%3Aencoded%20here&no:encoding here&defaults:to not encoded'
-        term_uri = 'http://encoded.because?encode=true'
-        replacements = { encode_true: 'yes:encoded here', encode_false: 'no:encoding here', encode_not_specified: 'defaults:to not encoded' }
-        expect(encoding_config.term_url_with_replacements(term_uri, nil, replacements)).to eq expected_url
-      end
-    end
-  end
-  # rubocop:enable RSpec/RepeatedExample
 end

data/spec/lib/authorities/loc_spec.rb

@@ -28,14 +28,14 @@ describe Qa::Authorities::Loc do
     end
 
     context "for searching" do
-      let(:url) { 'https://id.loc.gov/search/?q=foo&q=cs%3Ahttp%3A%2F%2Fid.loc.gov%2Fauthorities%2Fsubjects&format=json' }
+      let(:url) { 'http://id.loc.gov/search/?q=foo&q=cs%3Ahttp%3A%2F%2Fid.loc.gov%2Fauthorities%2Fsubjects&format=json' }
       it "returns a url" do
         expect(authority.build_query_url("foo")).to eq(url)
       end
     end
 
     context "for returning single terms" do
-      let(:url) { "https://id.loc.gov/authorities/subjects/sh2002003586.json" }
+      let(:url) { "http://id.loc.gov/authorities/subjects/sh2002003586.json" }
       it "returns a url with an authority and id" do
         expect(authority.find_url("sh2002003586")).to eq(url)
       end
@@ -49,15 +49,15 @@ describe Qa::Authorities::Loc do
     end
 
     before do
-      stub_request(:get, "https://id.loc.gov/search/?format=json&q=cs:http://id.loc.gov/authorities/subjects")
+      stub_request(:get, "http://id.loc.gov/search/?format=json&q=cs:http://id.loc.gov/authorities/subjects")
         .with(headers: { 'Accept' => 'application/json' })
         .to_return(status: 200, body: "")
     end
 
     context "with flat params encoded" do
-      let(:url) { 'https://id.loc.gov/search/?q=foo&q=cs%3Ahttp%3A%2F%2Fid.loc.gov%2Fauthorities%2Fsubjects&format=json' }
+      let(:url) { 'http://id.loc.gov/search/?q=foo&q=cs%3Ahttp%3A%2F%2Fid.loc.gov%2Fauthorities%2Fsubjects&format=json' }
       it "returns a response" do
-        flat_params_url = "https://id.loc.gov/search/?format=json&q=foo&q=cs%3Ahttp%3A%2F%2Fid.loc.gov%2Fauthorities%2Fsubjects"
+        flat_params_url = "http://id.loc.gov/search/?format=json&q=foo&q=cs%3Ahttp%3A%2F%2Fid.loc.gov%2Fauthorities%2Fsubjects"
         expect(subject.env.url.to_s).to eq(flat_params_url)
       end
     end
@@ -66,7 +66,7 @@ describe Qa::Authorities::Loc do
   describe "#search" do
     context "any LOC authorities" do
       let :authority do
-        stub_request(:get, "https://id.loc.gov/search/?format=json&q=s&q=cs:http://id.loc.gov/vocabulary/geographicAreas")
+        stub_request(:get, "http://id.loc.gov/search/?format=json&q=s&q=cs:http://id.loc.gov/vocabulary/geographicAreas")
           .with(headers: { 'Accept' => 'application/json' })
           .to_return(body: webmock_fixture("loc-response.txt"), status: 200)
         described_class.subauthority_for("geographicAreas")
@@ -95,7 +95,7 @@ describe Qa::Authorities::Loc do
 
     context "subject terms" do
       let :results do
-        stub_request(:get, "https://id.loc.gov/search/?format=json&q=History--&q=cs:http://id.loc.gov/authorities/subjects")
+        stub_request(:get, "http://id.loc.gov/search/?format=json&q=History--&q=cs:http://id.loc.gov/authorities/subjects")
           .with(headers: { 'Accept' => 'application/json' })
           .to_return(body: webmock_fixture("loc-subjects-response.txt"), status: 200)
         described_class.subauthority_for("subjects").search("History--")
@@ -111,7 +111,7 @@ describe Qa::Authorities::Loc do
 
     context "name terms" do
       let :results do
-        stub_request(:get, "https://id.loc.gov/search/?format=json&q=Berry&q=cs:http://id.loc.gov/authorities/names")
+        stub_request(:get, "http://id.loc.gov/search/?format=json&q=Berry&q=cs:http://id.loc.gov/authorities/names")
           .with(headers: { 'Accept' => 'application/json' })
           .to_return(body: webmock_fixture("loc-names-response.txt"), status: 200)
         described_class.subauthority_for("names").search("Berry")
@@ -125,7 +125,7 @@ describe Qa::Authorities::Loc do
   describe "#find" do
     context "using a subject id" do
       let :results do
-        stub_request(:get, "https://id.loc.gov/authorities/subjects/sh2002003586.json")
+        stub_request(:get, "http://id.loc.gov/authorities/subjects/sh2002003586.json")
           .with(headers: { 'Accept' => 'application/json' })
           .to_return(status: 200, body: webmock_fixture("loc-subject-find-response.txt"), headers: {})
         described_class.subauthority_for("subjects").find("sh2002003586")

data/spec/lib/configuration_spec.rb

@@ -1,13 +1,8 @@
+require 'spec_helper'
+
 RSpec.describe Qa::Configuration do
   subject { described_class.new }
 
-  it { is_expected.to respond_to(:cors_headers?) }
-  it { is_expected.to respond_to(:enable_cors_headers) }
-  it { is_expected.to respond_to(:disable_cors_headers) }
-  it { is_expected.to respond_to(:authorized_reload_token=) }
-  it { is_expected.to respond_to(:authorized_reload_token) }
-  it { is_expected.to respond_to(:valid_authority_reload_token?) }
-
   describe '#enable_cors_headers' do
     it 'turns on cors headers support' do
       subject.enable_cors_headers
@@ -55,4 +50,22 @@ RSpec.describe Qa::Configuration do
       end
     end
   end
+
+  describe '#default_language' do
+    context 'when NOT configured' do
+      it 'returns :en as the default language' do
+        expect(subject.default_language).to be :en
+      end
+    end
+
+    context 'when configured' do
+      before do
+        subject.default_language = [:fr]
+      end
+
+      it 'returns the configured default language' do
+        expect(subject.default_language).to match_array [:fr]
+      end
+    end
+  end
 end

data/spec/lib/tasks/mesh.rake_spec.rb

@@ -10,8 +10,8 @@ describe "mesh rake tasks" do # rubocop:disable RSpec/DescribeClass
     Rake::Task.define_task(:environment) # rspec has loaded rails
   end
 
-  describe "mesh:import" do
-    let(:task_name) { "mesh:import" }
+  describe "qa:mesh:import" do
+    let(:task_name) { "qa:mesh:import" }
     let(:output) { StringIO.new }
     before do
       $stdout = output # rubocop:disable RSpec/ExpectOutput # TODO: Explore how to remove this disable

data/spec/models/iri_template/url_config_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+RSpec.describe Qa::IriTemplate::UrlConfig do
+  let(:url_template) do
+    {
+      :"@context" => "http://www.w3.org/ns/hydra/context.jsonld",
+      :"@type" => "IriTemplate",
+      template: "http://localhost/test_default/search?{?subauth}&{?query}&{?param1}&{?param2}",
+      variableRepresentation: "BasicRepresentation",
+      mapping: [
+        {
+          :"@type" => "IriTemplateMapping",
+          variable: "query",
+          property: "hydra:freetextQuery",
+          required: true
+        },
+        {
+          :"@type" => "IriTemplateMapping",
+          variable: "subauth",
+          property: "hydra:freetextQuery",
+          required: false,
+          default: "search_sub1_name"
+        },
+        {
+          :"@type" => "IriTemplateMapping",
+          variable: "param1",
+          property: "hydra:freetextQuery",
+          required: false,
+          default: "delta"
+        },
+        {
+          :"@type" => "IriTemplateMapping",
+          variable: "param2",
+          property: "hydra:freetextQuery",
+          required: false,
+          default: "echo"
+        }
+      ]
+    }
+  end
+
+  describe 'model attributes' do
+    subject { described_class.new(url_template) }
+
+    it { is_expected.to respond_to :template }
+    it { is_expected.to respond_to :variable_representation }
+    it { is_expected.to respond_to :mapping }
+  end
+
+  describe '#new' do
+    context 'when missing template' do
+      before do
+        allow(url_template).to receive(:fetch).with(:template, nil).and_return(nil)
+      end
+
+      it 'raises an error' do
+        expect { described_class.new(url_template) }.to raise_error(Qa::InvalidConfiguration, 'template is required')
+      end
+    end
+
+    context 'when missing mapping' do
+      before do
+        allow(url_template).to receive(:fetch).with(:template, nil).and_return("http://localhost/test_default/search?{?subauth}&{?query}&{?param1}&{?param2}")
+        allow(url_template).to receive(:fetch).with(:mapping, nil).and_return(nil)
+      end
+
+      it 'raises an error' do
+        expect { described_class.new(url_template) }.to raise_error(Qa::InvalidConfiguration, 'mapping is required')
+      end
+    end
+
+    context 'when no maps defined' do
+      before do
+        allow(url_template).to receive(:fetch).with(:template, nil).and_return("http://localhost/test_default/search?{?subauth}&{?query}&{?param1}&{?param2}")
+        allow(url_template).to receive(:fetch).with(:mapping, nil).and_return([])
+      end
+
+      it 'raises an error' do
+        expect { described_class.new(url_template) }.to raise_error(Qa::InvalidConfiguration, 'mapping must include at least one map')
+      end
+    end
+  end
+
+  describe '#template' do
+    subject { described_class.new(url_template) }
+
+    it 'returns the configured url template' do
+      expect(subject.template).to eq 'http://localhost/test_default/search?{?subauth}&{?query}&{?param1}&{?param2}'
+    end
+  end
+
+  describe '#mapping' do
+    subject { described_class.new(url_template) }
+
+    it 'returns an array of variable maps' do
+      mapping = subject.mapping
+      expect(mapping).to be_kind_of Array
+      expect(mapping.size).to eq 4
+      expect(mapping.first).to be_kind_of Qa::IriTemplate::VariableMap
+    end
+  end
+end