blacklight 6.19.1 → 7.1.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,16 +1,18 @@
 # 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)
+    expect(subject.class).to include(described_class)
   end
 
   describe 'new record' 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