blacklight 6.14.0 → 7.0.0

data/spec/models/blacklight/document/active_model_shim_spec.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-describe 'Blacklight::Document::ActiveModelShim' do
-
+RSpec.describe 'Blacklight::Document::ActiveModelShim', api: true do
   class MockDocument
     include Blacklight::Document
     include Blacklight::Document::ActiveModelShim
@@ -16,18 +15,28 @@ describe 'Blacklight::Document::ActiveModelShim' do
     end
 
     def documents
-      response.collect {|doc| MockDocument.new(doc, self)}
+      response.collect { |doc| MockDocument.new(doc, self) }
     end
   end
 
   before do
-    allow(MockDocument).to receive(:repository).and_return(double(find: MockResponse.new([{id: 1}], {})))
+    allow(MockDocument).to receive(:repository).and_return(double(find: MockResponse.new([{ id: 1 }], {})))
   end
- 
+
   describe "#find" do
-   it "should return a document from the repository" do
+    it "returns a document from the repository" do
       expect(MockDocument.find(1)).to be_a MockDocument
       expect(MockDocument.find(1).id).to be 1
     end
   end
+
+  describe "#==" do
+    it 'is equal for the same id' do
+      expect(MockDocument.new(id: 1) == MockDocument.new(id: 1)).to eq true
+    end
+
+    it 'is not equal if the ids differ' do
+      expect(MockDocument.new(id: 1) == MockDocument.new(id: 2)).to eq false
+    end
+  end
 end

data/spec/models/blacklight/document/cache_key_spec.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
-describe Blacklight::Document::CacheKey do
+RSpec.describe Blacklight::Document::CacheKey, api: true do
   let(:attributes) { {} }
   let(:subject) { SolrDocument.new(attributes) }
+
   it 'SolrDocument includes the module' do
     expect(subject.class).to include(Blacklight::Document::CacheKey)
   end
@@ -11,6 +12,7 @@ describe Blacklight::Document::CacheKey do
     before do
       allow(subject).to receive_messages(new_record?: true)
     end
+
     it 'provides an acceptable cache key' do
       expect(subject.cache_key).to eq 'solr_documents/new'
     end
@@ -18,11 +20,13 @@ describe Blacklight::Document::CacheKey do
 
   describe 'with version' do
     let(:attributes) { { id: '12345', _version_: '1497353774427013120' } }
+
     it 'provides a cache key with the id and version' do
       expect(subject.cache_key).to eq 'solr_documents/12345-1497353774427013120'
     end
     describe 'as array' do
-      let(:attributes) { { id: '12345', _version_: ['1234', '4321'] } }
+      let(:attributes) { { id: '12345', _version_: %w[1234 4321] } }
+
       it 'provides a cache key with the id and joined version array' do
         expect(subject.cache_key).to eq 'solr_documents/12345-12344321'
       end
@@ -31,6 +35,7 @@ describe Blacklight::Document::CacheKey do
 
   describe 'without version' do
     let(:attributes) { { id: '12345' } }
+
     it 'provides a cache key with just the id' do
       expect(subject.cache_key).to eq 'solr_documents/12345'
     end
@@ -38,9 +43,11 @@ describe Blacklight::Document::CacheKey do
 
   describe '#cache_version_key' do
     let(:attributes) { { id: '12345', another_version_field: '1497353774427013120' } }
+
     before do
       allow(subject).to receive_messages(cache_version_key: :another_version_field)
     end
+
     it 'provides a cache key with the defined field' do
       expect(subject.cache_key).to eq 'solr_documents/12345-1497353774427013120'
     end

data/spec/models/blacklight/document/dublin_core_spec.rb

@@ -1,41 +1,38 @@
 # frozen_string_literal: true
 
-describe "Blacklight::Document::DublinCore" do
+RSpec.describe "Blacklight::Document::DublinCore" do
   before(:all) do
     @mock_class = Class.new do
       include Blacklight::Document
     end
-    @mock_class.use_extension( Blacklight::Document::DublinCore )
+    @mock_class.use_extension(Blacklight::Document::DublinCore)
     @mock_class.field_semantics.merge!(
-      :title => :title_display,
-      :non_dc_title => :title_display
+      title: :title_tsim,
+      non_dc_title: :title_tsim
     )
   end
 
-
-  it "should register all its export formats" do
+  it "registers all its export formats" do
     document = @mock_class.new
-    expect(document.export_formats.keys).to include :oai_dc_xml, :dc_xml, :xml   
+    expect(document.export_formats.keys).to include :oai_dc_xml, :dc_xml, :xml
   end
 
-  it "should export oai_dc with the proper namespaces" do
+  it "exports oai_dc with the proper namespaces" do
     document = @mock_class.new
     expect(document.export_as_oai_dc_xml).to match 'xmlns:oai_dc="http://www.openarchives.org/OAI/2.0/oai_dc/"'
-
   end
 
-  it "should include 'dc:'-prefixed semantic fields" do
-      data = {'id'=>'123456','title_display'=>['654321'] }
-      document = @mock_class.new(data)
-      expect(document.export_as_oai_dc_xml).to match  'xmlns:dc="http://purl.org/dc/elements/1.1/"'
-      expect(document.export_as_oai_dc_xml).to match  '<dc:title>654321</dc:title>'
+  it "includes 'dc:'-prefixed semantic fields" do
+    data = { 'id' => '123456', 'title_tsim' => ['654321'] }
+    document = @mock_class.new(data)
+    expect(document.export_as_oai_dc_xml).to match  'xmlns:dc="http://purl.org/dc/elements/1.1/"'
+    expect(document.export_as_oai_dc_xml).to match  '<dc:title>654321</dc:title>'
   end
 
-  it "should work with multi-value fields" do
-      data = {'id'=>'123456','title_display'=>['654321', '987'] }
-      document = @mock_class.new(data)
-      expect(document.export_as_oai_dc_xml).to match '<dc:title>654321</dc:title>'
-      expect(document.export_as_oai_dc_xml).to match '<dc:title>987</dc:title></oai_dc:dc>'
+  it "works with multi-value fields" do
+    data = { 'id' => '123456', 'title_tsim' => %w[654321 987] }
+    document = @mock_class.new(data)
+    expect(document.export_as_oai_dc_xml).to match '<dc:title>654321</dc:title>'
+    expect(document.export_as_oai_dc_xml).to match '<dc:title>987</dc:title></oai_dc:dc>'
   end
 end
-

data/spec/models/blacklight/document/email_spec.rb

@@ -1,23 +1,23 @@
 # frozen_string_literal: true
 
-describe "Blacklight::Document::Email" do
+RSpec.describe "Blacklight::Document::Email" do
   before(:all) do
-    SolrDocument.use_extension( Blacklight::Document::Email )
+    SolrDocument.use_extension(Blacklight::Document::Email)
   end
-  it "should only return values that are available in the field semantics" do
-    doc = SolrDocument.new({:id=>"1234", :title_display=>"My Title"})
+
+  it "onlies return values that are available in the field semantics" do
+    doc = SolrDocument.new(id: "1234", title_tsim: "My Title")
     email_body = doc.to_email_text
     expect(email_body).to match(/Title: My Title/)
-    expect(email_body).to_not match(/Author/)
+    expect(email_body).not_to match(/Author/)
   end
-  it "should handle multi-values fields correctly" do
-    doc = SolrDocument.new({:id=>"1234", :title_display=>["My Title", "My Alt. Title"]})
+  it "handles multi-values fields correctly" do
+    doc = SolrDocument.new(id: "1234", title_tsim: ["My Title", "My Alt. Title"])
     email_body = doc.to_email_text
     expect(email_body).to match(/Title: My Title My Alt. Title/)
   end
-  it "should return nil if there are no valid field semantics to build the email body from" do
-    doc = SolrDocument.new({:id=>"1234"})
+  it "returns nil if there are no valid field semantics to build the email body from" do
+    doc = SolrDocument.new(id: "1234")
     expect(doc.to_email_text).to be_nil
   end
 end
-

data/spec/models/blacklight/document/sms_spec.rb

@@ -1,23 +1,23 @@
 # frozen_string_literal: true
 
-describe "Blacklight::Document::Email" do
+RSpec.describe "Blacklight::Document::Email" do
   before(:all) do
-    SolrDocument.use_extension( Blacklight::Document::Sms )
+    SolrDocument.use_extension(Blacklight::Document::Sms)
   end
-  it "should only return values that are available in the field semantics" do
-    doc = SolrDocument.new({:id=>"1234", :title_display=>"My Title", :author_display=>"Joe Schmoe"})
+
+  it "onlies return values that are available in the field semantics" do
+    doc = SolrDocument.new(id: "1234", title_tsim: "My Title", author_tsim: "Joe Schmoe")
     sms_text = doc.to_sms_text
     expect(sms_text).to match(/My Title by Joe Schmoe/)
   end
-  it "should handle multi-values fields correctly and only take the first" do
-    doc = SolrDocument.new({:id=>"1234", :title_display=>["My Title", "My Alt. Title"]})
+  it "handles multi-values fields correctly and only take the first" do
+    doc = SolrDocument.new(id: "1234", title_tsim: ["My Title", "My Alt. Title"])
     sms_text = doc.to_sms_text
     expect(sms_text).to match(/My Title/)
-    expect(sms_text).to_not match(/My Alt\. Title/)
+    expect(sms_text).not_to match(/My Alt\. Title/)
   end
-  it "should return nil if there are no valid field semantics to build the email body from" do
-    doc = SolrDocument.new({:id=>"1234"})
+  it "returns nil if there are no valid field semantics to build the email body from" do
+    doc = SolrDocument.new(id: "1234")
     expect(doc.to_sms_text).to be_nil
   end
 end
-

data/spec/models/blacklight/document_spec.rb

@@ -1,25 +1,13 @@
 # frozen_string_literal: true
 
-describe Blacklight::Document do
-  let(:data) { {} }
-  let(:test_class) do
+RSpec.describe Blacklight::Document, api: true do
+  subject do
     Class.new do
       include Blacklight::Document
-    end
+    end.new(data)
   end
 
-  subject { test_class.new(data) }
-
-  describe '.new' do
-    it 'accepts a hash' do
-      expect(test_class.new(id: 1)[:id]).to eq 1
-    end
-
-    it 'accepts a SolrDocument' do
-      expect(Deprecation).to receive(:warn)
-      expect(test_class.new(test_class.new(id: 1))[:id]).to eq 1
-    end
-  end
+  let(:data) { {} }
 
   describe "#has?" do
     context "without value constraints" do
@@ -27,7 +15,7 @@ describe Blacklight::Document do
         data[:x] = true
         expect(subject).to have_field(:x)
       end
-      
+
       it "does not have the field if the field is not in the data" do
         expect(subject).not_to have_field(:x)
       end
@@ -38,7 +26,7 @@ describe Blacklight::Document do
         data[:x] = true
         expect(subject).to have_field(:x, true)
       end
-      
+
       it "does not have the field if the data does not have that value" do
         data[:x] = false
         expect(subject).not_to have_field(:x, true)
@@ -50,12 +38,12 @@ describe Blacklight::Document do
       end
 
       it "supports multivalued fields" do
-        data[:x] = ["a", "b", "c"]
+        data[:x] = %w[a b c]
         expect(subject).to have_field(:x, "a")
       end
 
       it "supports multivalued fields with an array of value constraints" do
-        data[:x] = ["a", "b", "c"]
+        data[:x] = %w[a b c]
         expect(subject).to have_field(:x, "a", "d")
       end
     end
@@ -88,12 +76,12 @@ describe Blacklight::Document do
       end
 
       def documents
-        response.collect {|doc| MockDocument.new(doc, self)}
+        response.collect { |doc| MockDocument.new(doc, self) }
       end
     end
 
     before do
-      allow(MockDocument).to receive(:repository).and_return(instance_double(Blacklight::Solr::Repository, find: MockResponse.new([{id: 1}], {})))
+      allow(MockDocument).to receive(:repository).and_return(instance_double(Blacklight::Solr::Repository, find: MockResponse.new([{ id: 1 }], {})))
     end
 
     it "has a globalid" do

data/spec/models/blacklight/facet_paginator_spec.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-describe Blacklight::FacetPaginator do
-
+RSpec.describe Blacklight::FacetPaginator, api: true do
   let(:f1) { Blacklight::Solr::Response::Facets::FacetItem.new(hits: '792', value: 'Book') }
   let(:f2) { Blacklight::Solr::Response::Facets::FacetItem.new(hits: '65', value: 'Musical Score') }
   let(:f3) { Blacklight::Solr::Response::Facets::FacetItem.new(hits: '58', value: 'Serial') }
@@ -15,11 +14,12 @@ describe Blacklight::FacetPaginator do
 
   context 'on the first page of two pages' do
     subject { described_class.new(seven_facet_values, limit: limit) }
-    it { should be_first_page }
-    it { should_not be_last_page }
-    its(:current_page) { should eq 1 }
-    its(:prev_page) { should be_nil }
-    its(:next_page) { should eq 2 }
+
+    it { is_expected.to be_first_page }
+    it { is_expected.not_to be_last_page }
+    its(:current_page) { is_expected.to eq 1 }
+    its(:prev_page) { is_expected.to be_nil }
+    its(:next_page) { is_expected.to eq 2 }
     it 'limits items to limit, if limit is smaller than items.length' do
       expect(subject.items.size).to eq 6
     end
@@ -27,11 +27,12 @@ describe Blacklight::FacetPaginator do
 
   context 'on the last page of two pages' do
     subject { described_class.new([f7], offset: 6, limit: limit) }
-    it { should_not be_first_page }
-    it { should be_last_page }
-    its(:current_page) { should eq 2 }
-    its(:prev_page) { should eq 1 }
-    its(:next_page) { should be_nil }
+
+    it { is_expected.not_to be_first_page }
+    it { is_expected.to be_last_page }
+    its(:current_page) { is_expected.to eq 2 }
+    its(:prev_page) { is_expected.to eq 1 }
+    its(:next_page) { is_expected.to be_nil }
     it 'returns all items when limit is greater than items.length' do
       expect(subject.items.size).to eq 1
     end
@@ -39,11 +40,12 @@ describe Blacklight::FacetPaginator do
 
   context 'on the second page of three pages' do
     subject { described_class.new(seven_facet_values, offset: 6, limit: limit) }
-    it { should_not be_first_page }
-    it { should_not be_last_page }
-    its(:current_page) { should eq 2 }
-    its(:prev_page) { should eq 1 }
-    its(:next_page) { should eq 3 }
+
+    it { is_expected.not_to be_first_page }
+    it { is_expected.not_to be_last_page }
+    its(:current_page) { is_expected.to eq 2 }
+    its(:prev_page) { is_expected.to eq 1 }
+    its(:next_page) { is_expected.to eq 3 }
     it 'limits items to limit, if limit is smaller than items.length' do
       expect(subject.items.size).to eq 6
     end
@@ -51,34 +53,37 @@ describe Blacklight::FacetPaginator do
 
   context 'on the first page of one page' do
     subject { described_class.new(six_facet_values, offset: 0, limit: limit) }
-    it { should be_first_page }
-    it { should be_last_page }
+
+    it { is_expected.to be_first_page }
+    it { is_expected.to be_last_page }
   end
 
   describe "params_for_resort_url" do
+    subject { described_class.new([], offset: 100, limit: limit, sort: 'index') }
+
     let(:sort_key) { described_class.request_keys[:sort] }
     let(:page_key) { described_class.request_keys[:page] }
-    subject { described_class.new([], offset: 100, limit: limit, sort: 'index') }
 
     it 'knows a manually set sort, and produce proper sort url' do
-        expect(subject.sort).to eq 'index'
+      expect(subject.sort).to eq 'index'
 
-        click_params = subject.params_for_resort_url('count', {}.with_indifferent_access)
+      click_params = subject.params_for_resort_url('count', {}.with_indifferent_access)
 
-        expect(click_params[ sort_key ]).to eq 'count'
-        expect(click_params[ page_key ]).to be_nil
+      expect(click_params[sort_key]).to eq 'count'
+      expect(click_params[page_key]).to be_nil
     end
 
     context 'when sorting by "count"' do
       subject { described_class.new([]) }
-      let(:params) { HashWithIndifferentAccess.new :'facet.prefix' => 'A' }
+
+      let(:params) { HashWithIndifferentAccess.new 'facet.prefix': 'A' }
 
       it 'includes the prefix filter for "index" sorting' do
-        expect(subject.params_for_resort_url('index', params)).to include :'facet.prefix' => 'A'
+        expect(subject.params_for_resort_url('index', params)).to include 'facet.prefix': 'A'
       end
 
       it 'removes the prefix filter' do
-        expect(subject.params_for_resort_url('count', params)).not_to include :'facet.prefix' => 'A'
+        expect(subject.params_for_resort_url('count', params)).not_to include 'facet.prefix': 'A'
       end
     end
   end
@@ -88,31 +93,36 @@ describe Blacklight::FacetPaginator do
 
     describe "#items" do
       subject { paginator.items }
+
       it { is_expected.to eq seven_facet_values }
     end
 
     describe "#last_page?" do
       subject { paginator.last_page? }
+
       it { is_expected.to be true }
     end
 
     describe "#current_page" do
       subject { paginator.current_page }
+
       it { is_expected.to eq 1 }
     end
   end
 
   describe "#as_json" do
     subject { described_class.new([f1], offset: 0, limit: nil).as_json }
+
     it "is well structured" do
-      expect(subject).to eq("items" => [{"hits"=>"792", "value"=>"Book"}], "limit" => nil,
-       "offset" => 0, "sort" => nil)
+      expect(subject).to eq("items" => [{ "hits" => "792", "value" => "Book" }], "limit" => nil,
+                            "offset" => 0, "sort" => nil)
     end
   end
 
   describe "#total_pages" do
     # this method is just for API compatability with kaminari 0.16.1
     subject { described_class.new([f1], offset: 0, limit: nil).total_pages }
-    it { should eq -1 }
+
+    it { is_expected.to eq -1 }
   end
 end

data/spec/models/blacklight/icon_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+RSpec.describe Blacklight::Icon do
+  subject { described_class.new(:search, classes: 'awesome') }
+
+  describe '#svg' do
+    it 'returns a string' do
+      expect(subject.svg).to be_an String
+    end
+    it 'returns raw svg' do
+      expect(Capybara.string(subject.svg))
+        .to have_css 'svg title', text: 'Search'
+    end
+  end
+
+  describe '#options' do
+    it 'applies options classes and default class' do
+      expect(subject.options[:class]).to eq 'blacklight-icons awesome'
+    end
+  end
+
+  describe '#path' do
+    it 'prepends blacklight and sufixes .svg' do
+      expect(subject.path).to eq 'blacklight/search.svg'
+    end
+  end
+
+  describe 'file_source' do
+    context 'file is not available' do
+      subject { described_class.new(:yolo) }
+
+      it {
+        expect { subject.file_source }
+          .to raise_error(Blacklight::Exceptions::IconNotFound)
+      }
+    end
+
+    context 'file is available' do
+      it 'returns the filesource' do
+        expect(subject.file_source).to include '<svg'
+      end
+    end
+  end
+end

data/spec/models/blacklight/search_builder_spec.rb

@@ -1,28 +1,17 @@
 # frozen_string_literal: true
 
-describe Blacklight::SearchBuilder do
+RSpec.describe Blacklight::SearchBuilder, api: true do
+  subject(:builder) { described_class.new processor_chain, scope }
+
   let(:processor_chain) { [] }
   let(:blacklight_config) { Blacklight::Configuration.new }
   let(:scope) { double blacklight_config: blacklight_config }
-  subject { described_class.new processor_chain, scope }
 
   context "with default processor chain" do
-    context "with two arguments" do
-      subject do
-        Deprecation.silence Blacklight::SearchBuilder do
-          described_class.new true, scope
-        end
-      end
-      it "uses the class-level default_processor_chain" do
-        expect(subject.processor_chain).to eq []
-      end
-    end
+    subject { described_class.new scope }
 
-    context "with one arguments" do
-      subject { described_class.new scope }
-      it "uses the class-level default_processor_chain" do
-        expect(subject.processor_chain).to eq []
-      end
+    it "uses the class-level default_processor_chain" do
+      expect(subject.processor_chain).to eq []
     end
   end
 
@@ -44,6 +33,7 @@ describe Blacklight::SearchBuilder do
 
   describe "#processor_chain" do
     let(:processor_chain) { [:a, :b, :c] }
+
     it "is mutable" do
       subject.processor_chain.insert(-1, :d)
       expect(subject.processor_chain).to match_array [:a, :b, :c, :d]
@@ -52,6 +42,7 @@ describe Blacklight::SearchBuilder do
 
   describe "#append" do
     let(:processor_chain) { [:a, :b, :c] }
+
     it "provides a new search builder with the processor chain" do
       builder = subject.append(:d, :e)
       expect(subject.processor_chain).to eq processor_chain
@@ -62,6 +53,7 @@ describe Blacklight::SearchBuilder do
 
   describe "#except" do
     let(:processor_chain) { [:a, :b, :c, :d, :e] }
+
     it "provide a new search builder excepting arguments" do
       builder = subject.except(:b, :d, :does_not_exist)
       expect(builder).not_to equal(subject)
@@ -82,11 +74,13 @@ describe Blacklight::SearchBuilder do
 
   describe "#merge" do
     let(:processor_chain) { [:pass_through] }
+
     before do
       allow(subject).to receive(:pass_through) do |req_params|
         req_params.replace subject.blacklight_params
       end
     end
+
     it "overwrites the processed parameters" do
       actual = subject.with(q: 'abc').merge(q: 'xyz')
       expect(actual[:q]).to eq 'xyz'
@@ -95,6 +89,7 @@ describe Blacklight::SearchBuilder do
 
   describe "#reverse_merge" do
     let(:processor_chain) { [:pass_through] }
+
     before do
       allow(subject).to receive(:pass_through) do |req_params|
         req_params.replace subject.blacklight_params
@@ -176,18 +171,38 @@ describe Blacklight::SearchBuilder do
   end
 
   describe "#sort" do
-    it "passes through the sort parameter" do
-      expect(subject.with(sort: 'x').send(:sort)).to eq 'x'
-    end
+    context "when no sort parameter is given" do
+      subject(:sort) { builder.send(:sort) }
 
-    it "uses the default if no sort parameter is given" do
-      blacklight_config.default_sort_field = double(sort: 'x desc')
-      expect(subject.send(:sort)).to eq 'x desc'
+      before do
+        blacklight_config.default_sort_field = double(sort: 'x desc')
+      end
+
+      it "uses the default" do
+        expect(sort).to eq 'x desc'
+      end
     end
 
-    it "uses the requested sort field" do
-      blacklight_config.add_sort_field 'x', sort: 'x asc'
-      expect(subject.with(sort: 'x').send(:sort)).to eq 'x asc'
+    context "when the user provides an sort parameter" do
+      subject(:sort) { builder_with_param.send(:sort) }
+
+      let(:builder_with_param) { builder.with(sort: 'x') }
+
+      context "that is invalid" do
+        it "removes them" do
+          expect(sort).to be_nil
+        end
+      end
+
+      context "that is valid" do
+        before do
+          blacklight_config.add_sort_field 'x', sort: 'x asc'
+        end
+
+        it "uses the requested sort field" do
+          expect(sort).to eq 'x asc'
+        end
+      end
     end
   end