blacklight 4.7.0 → 4.8.0

data/spec/lib/blacklight_email_spec.rb

@@ -8,17 +8,17 @@ describe "Blacklight::Solr::Document::Email" do
   it "should only return values that are available in the field semantics" do
     doc = SolrDocument.new({:id=>"1234", :title_display=>"My Title"})
     email_body = doc.to_email_text
-    email_body.should match(/Title: My Title/)
-    email_body.should_not match(/Author/)
+    expect(email_body).to match(/Title: My Title/)
+    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"]})
     email_body = doc.to_email_text
-    email_body.should match(/Title: My Title My Alt. Title/)
+    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"})
-    doc.to_email_text.should be_nil
+    expect(doc.to_email_text).to be_nil
   end
 end
 

data/spec/lib/blacklight_sms_spec.rb

@@ -8,17 +8,17 @@ describe "Blacklight::Solr::Document::Email" do
   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"})
     sms_text = doc.to_sms_text
-    sms_text.should match(/My Title by Joe Schmoe/)
+    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"]})
     sms_text = doc.to_sms_text
-    sms_text.should match(/My Title/)
-    sms_text.should_not match(/My Alt\. Title/)
+    expect(sms_text).to match(/My 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"})
-    doc.to_sms_text.should be_nil
+    expect(doc.to_sms_text).to be_nil
   end
 end
 

data/spec/lib/blacklight_solr_document_dublin_core_spec.rb

@@ -16,27 +16,27 @@ describe "Blacklight::Solr::Document::DublinCore" do
 
   it "should register all its export formats" do
     document = @mock_class.new
-    Set.new(document.export_formats.keys).should  be_superset(Set.new([:oai_dc_xml,:dc_xml, :xml]))    
+    expect(Set.new(document.export_formats.keys)).to  be_superset(Set.new([:oai_dc_xml,:dc_xml, :xml]))    
   end
 
   it "should export oai_dc with the proper namespaces" do
     document = @mock_class.new
-    document.export_as_oai_dc_xml.should match 'xmlns:oai_dc="http://www.openarchives.org/OAI/2.0/oai_dc/"'
+    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)
-      document.export_as_oai_dc_xml.should match  'xmlns:dc="http://purl.org/dc/elements/1.1/"'
-      document.export_as_oai_dc_xml.should match  '<dc:title>654321</dc:title>'
+      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)
-      document.export_as_oai_dc_xml.should match '<dc:title>654321</dc:title>'
-      document.export_as_oai_dc_xml.should match '<dc:title>987</dc:title></oai_dc:dc>'
+      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/lib/blacklight_solr_document_marc_spec.rb

@@ -17,7 +17,7 @@ describe "Blacklight::Solr::Document::Marc" do
     end
     it "should read and parse a marc binary file" do
       document = @mock_class.new(:marc => sample_marc_binary )
-      document.to_marc.should == marc_from_string(:binary => sample_marc_binary )
+      expect(document.to_marc).to eq(marc_from_string(:binary => sample_marc_binary ))
     end
   end
 
@@ -27,13 +27,13 @@ describe "Blacklight::Solr::Document::Marc" do
     end
     it "should read and parse a marc xml file" do
       document = @mock_class.new(:marc => sample_marc_xml)
-      document.to_marc.should == marc_from_string(:xml => sample_marc_xml)
+      expect(document.to_marc).to eq(marc_from_string(:xml => sample_marc_xml))
     end
   end
 
   it "should register all its export formats" do
     document = @mock_class.new
-    Set.new(document.export_formats.keys).should  be_superset(Set.new([:marc, :marcxml, :openurl_ctx_kev, :refworks_marc_txt, :endnote, :xml]))    
+    expect(Set.new(document.export_formats.keys)).to  be_superset(Set.new([:marc, :marcxml, :openurl_ctx_kev, :refworks_marc_txt, :endnote, :xml]))    
   end
 
 

data/spec/lib/blacklight_solr_document_more_like_this_spec.rb

@@ -10,9 +10,9 @@ describe Blacklight::Solr::Document::MoreLikeThis do
   it "should pluck the MoreLikeThis results from the Solr Response" do
     mock_solr_response = double(:more_like => [{'id' => 'abc'}])
     result = @mock_class.new({:id => '123'}, mock_solr_response).more_like_this
-    result.should have(1).item
-    result.first.should be_a_kind_of(SolrDocument)
-    result.first.id.should == 'abc'
-    result.first.solr_response.should == mock_solr_response
+    expect(result.size).to eq(1)
+    expect(result.first).to be_a_kind_of(SolrDocument)
+    expect(result.first.id).to eq('abc')
+    expect(result.first.solr_response).to eq(mock_solr_response)
   end 
 end

data/spec/lib/blacklight_solr_document_spec.rb

@@ -23,13 +23,13 @@ describe "Blacklight::Solr::Document" do
       it 'should create a doc with hashy methods' do
         doc = SolrDocument.new({'id'=>'SP2514N','inStock'=>true,'manu'=>'Samsung Electronics Co. Ltd.','name'=>'Samsung SpinPoint P120 SP2514N - hard drive - 250 GB - ATA-133','popularity'=>6,'price'=>92.0,'sku'=>'SP2514N','timestamp'=>'2009-03-20T14:42:49.795Z','cat'=>['electronics','hard drive'],'spell'=>['Samsung SpinPoint P120 SP2514N - hard drive - 250 GB - ATA-133'],'features'=>['7200RPM, 8MB cache, IDE Ultra ATA-133','NoiseGuard, SilentSeek technology, Fluid Dynamic Bearing (FDB) motor']})
 
-        doc.has?(:cat, /^elec/).should == true
-        doc.has?(:cat, 'elec').should_not == true
-        doc.has?(:cat, 'electronics').should == true
+        expect(doc.has?(:cat, /^elec/)).to eq(true)
+        expect(doc.has?(:cat, 'elec')).not_to eq(true)
+        expect(doc.has?(:cat, 'electronics')).to eq(true)
 
-        doc.get(:cat).should == 'electronics, hard drive'
-        doc.get(:xyz).should == nil
-        doc.get(:xyz, :default=>'def').should == 'def'
+        expect(doc.get(:cat)).to eq('electronics, hard drive')
+        expect(doc.get(:xyz)).to eq(nil)
+        expect(doc.get(:xyz, :default=>'def')).to eq('def')
       end
     end
 
@@ -44,7 +44,7 @@ describe "Blacklight::Solr::Document" do
       end
       it "should use a configuration-defined document unique key" do
         @document = MockDocument.new :id => 'asdf', :my_unique_key => '1234'
-        @document.id.should == '1234'
+        expect(@document.id).to eq('1234')
       end
     end
 
@@ -57,54 +57,54 @@ describe "Blacklight::Solr::Document" do
       it "should let you register an extension" do
         MockDocument.use_extension(MockExtension) { |doc| true }
 
-        MockDocument.registered_extensions.find {|a| a[:module_obj] == MockExtension}.should_not be_nil
+        expect(MockDocument.registered_extensions.find {|a| a[:module_obj] == MockExtension}).not_to be_nil
       end
       it "should let you register an extension with a nil condition proc" do
         MockDocument.use_extension(MockExtension) { |doc| true }
-        MockDocument.registered_extensions.find {|a| a[:module_obj] == MockExtension}.should_not be_nil
+        expect(MockDocument.registered_extensions.find {|a| a[:module_obj] == MockExtension}).not_to be_nil
       end
       it "should apply an extension whose condition is met" do
         MockDocument.use_extension(MockExtension) {|doc| true}
         doc = MockDocument.new()
 
-        doc.methods.find {|name| name.to_s == "my_extension_method"}.should_not be_nil
-        doc.my_extension_method.to_s.should == "my_extension_results"
+        expect(doc.methods.find {|name| name.to_s == "my_extension_method"}).not_to be_nil
+        expect(doc.my_extension_method.to_s).to eq("my_extension_results")
       end
       it "should apply an extension based on a Solr field" do
         MockDocument.use_extension(MockExtension) {|doc| doc.key?(:required_key)}
 
         with_extension = MockDocument.new(:required_key => "value")
-        with_extension.my_extension_method.to_s.should == "my_extension_results"
+        expect(with_extension.my_extension_method.to_s).to eq("my_extension_results")
 
         without_extension = MockDocument.new(:other_key => "value")
-        without_extension.methods.find {|name| name.to_s == "my_extension_method"}.should be_nil
+        expect(without_extension.methods.find {|name| name.to_s == "my_extension_method"}).to be_nil
         
       end
       it "should not apply an extension whose condition is not met" do
         MockDocument.use_extension(MockExtension) {|doc| false}
         doc = MockDocument.new()
   
-        doc.methods.find {|name| name.to_s == "my_extension_method"}.should be_nil      
+        expect(doc.methods.find {|name| name.to_s == "my_extension_method"}).to be_nil      
       end
       it "should treat a nil condition as always applyable" do
         MockDocument.use_extension(MockExtension)
   
         doc = MockDocument.new()
   
-        doc.methods.find {|name | name.to_s =="my_extension_method"}.should_not be_nil
-        doc.my_extension_method.should == "my_extension_results"
+        expect(doc.methods.find {|name | name.to_s =="my_extension_method"}).not_to be_nil
+        expect(doc.my_extension_method).to eq("my_extension_results")
       end
       it "should let last extension applied override earlier extensions" do
         MockDocument.use_extension(MockExtension)
         MockDocument.use_extension(MockSecondExtension)
 
-        MockDocument.new().my_extension_method.to_s.should == "override"        
+        expect(MockDocument.new().my_extension_method.to_s).to eq("override")        
       end
 
       describe "extension_parameters class-level hash" do
         it "should provide an extension_parameters hash at the class level" do
           MockDocument.extension_parameters[:key] = "value"
-          MockDocument.extension_parameters[:key].should == "value"
+          expect(MockDocument.extension_parameters[:key]).to eq("value")
         end
     
         it "extension_parameters should not be shared between classes" do
@@ -118,7 +118,7 @@ describe "Blacklight::Solr::Document" do
           class_one.extension_parameters[:key] = "class_one_value"
           class_two.extension_parameters[:key] = "class_two_value"
 
-          class_one.extension_parameters[:key].should == "class_one_value"
+          expect(class_one.extension_parameters[:key]).to eq("class_one_value")
         end
       end
       
@@ -136,14 +136,14 @@ describe "Blacklight::Solr::Document" do
       it "reports it's exportable formats properly" do
         doc = MockDocument.new
         doc.will_export_as(:marc, "application/marc" )
-        doc.export_formats.should have_key(:marc)
-        doc.export_formats[:marc][:content_type].should ==  "application/marc"
+        expect(doc.export_formats).to have_key(:marc)
+        expect(doc.export_formats[:marc][:content_type]).to eq("application/marc")
       end
 
       it "looks up content-type from Mime::Type if not given in arg" do
         doc = MockDocument.new
         doc.will_export_as(:html)
-        doc.export_formats.should have_key(:html)        
+        expect(doc.export_formats).to have_key(:html)        
       end
 
       context "format not registered with Mime::Type" do
@@ -154,17 +154,17 @@ describe "Blacklight::Solr::Document" do
           # registration in an after, sorry. 
         end
         it "registers format" do
-          defined?("Mime::MOCK2").should be_true
+          expect(defined?("Mime::MOCK2")).to be_truthy
         end
         it "registers as alias only" do
-          Mime::Type.lookup("application/mock2").should_not equal(Mime::Type.lookup_by_extension("mock2"))
+          expect(Mime::Type.lookup("application/mock2")).not_to equal(Mime::Type.lookup_by_extension("mock2"))
         end
       end
 
       it "export_as(:format) by calling export_as_format" do
         doc = MockDocument.new
         doc.will_export_as(:marc, "application/marc")
-        doc.export_as(:marc).should == "fake_marc"
+        expect(doc.export_as(:marc)).to eq("fake_marc")
       end
     end
 
@@ -183,17 +183,17 @@ describe "Blacklight::Solr::Document" do
       end
 
       it "should return complete dictionary based on config'd fields" do        
-        @doc1.to_semantic_values.should == {:title => ["doc1 title"], :something => ["val1", "val2"]}
+        expect(@doc1.to_semantic_values).to eq({:title => ["doc1 title"], :something => ["val1", "val2"]})
       end      
       it "should return empty array for a key without a value" do
-        @doc1.to_semantic_values[:author].should == []
-        @doc1.to_semantic_values[:nonexistent_token].should == []
+        expect(@doc1.to_semantic_values[:author]).to eq([])
+        expect(@doc1.to_semantic_values[:nonexistent_token]).to eq([])
       end
       it "should return an array even for a single-value field" do
-        @doc1.to_semantic_values[:title].should be_kind_of(Array)
+        expect(@doc1.to_semantic_values[:title]).to be_kind_of(Array)
       end
       it "should return complete array for a multi-value field" do
-        @doc1.to_semantic_values[:something].should == ["val1", "val2"] 
+        expect(@doc1.to_semantic_values[:something]).to eq(["val1", "val2"]) 
       end
       
     end
@@ -207,27 +207,27 @@ describe "Blacklight::Solr::Document" do
 
       describe "#has_highlight_field?" do
         it "should be true if the highlight field is in the solr response" do
-          @document.should have_highlight_field 'title_text'
-          @document.should have_highlight_field :title_text
+          expect(@document).to have_highlight_field 'title_text'
+          expect(@document).to have_highlight_field :title_text
         end
 
         it "should be false if the highlight field isn't in the solr response" do
-           @document.should_not have_highlight_field 'nonexisting_field'
+           expect(@document).not_to have_highlight_field 'nonexisting_field'
         end
       end
 
       describe "#highlight_field" do
         it "should return a value" do
-          @document.highlight_field('title_text').should include('doc <em>1</em>')
+          expect(@document.highlight_field('title_text')).to include('doc <em>1</em>')
         end
 
 
         it "should return a value that is html safe" do
-          @document.highlight_field('title_text').first.should be_html_safe
+          expect(@document.highlight_field('title_text').first).to be_html_safe
         end
 
         it "should return nil when the field doesn't exist" do
-          @document.highlight_field('nonexisting_field').should be_nil
+          expect(@document.highlight_field('nonexisting_field')).to be_nil
         end
       end
     end

data/spec/lib/blacklight_solr_response_spec.rb

@@ -11,47 +11,47 @@ describe Blacklight::SolrResponse do
   let(:r) { create_response }
 
   it 'should create a valid response' do
-    r.should respond_to(:header)
+    expect(r).to respond_to(:header)
   end
 
   it 'should have accurate pagination numbers' do
-    r.rows.should == 11
-    r.total.should == 26
-    r.start.should == 0
+    expect(r.rows).to eq(11)
+    expect(r.total).to eq(26)
+    expect(r.start).to eq(0)
   end
 
   it 'should create a valid response class' do
-    r.should respond_to(:response)
-    r.docs.size.should == 11
-    r.params[:echoParams].should == 'EXPLICIT'
+    expect(r).to respond_to(:response)
+    expect(r.docs.size).to eq(11)
+    expect(r.params[:echoParams]).to eq('EXPLICIT')
     
-    r.should be_a(Blacklight::SolrResponse::Facets)
+    expect(r).to be_a(Blacklight::SolrResponse::Facets)
   end
 
   it 'should provide facet helpers' do
-    r.facets.size.should == 2
+    expect(r.facets.size).to eq(2)
 
     field_names = r.facets.collect{|facet|facet.name}
-    field_names.include?('cat').should == true
-    field_names.include?('manu').should == true
+    expect(field_names.include?('cat')).to eq(true)
+    expect(field_names.include?('manu')).to eq(true)
 
     first_facet = r.facets.select { |x| x.name == 'cat'}.first
-    first_facet.name.should == 'cat'
+    expect(first_facet.name).to eq('cat')
 
-    first_facet.items.size.should == 10
+    expect(first_facet.items.size).to eq(10)
 
     expected = "electronics - 14, memory - 3, card - 2, connector - 2, drive - 2, graphics - 2, hard - 2, monitor - 2, search - 2, software - 2"
     received = first_facet.items.collect do |item|
       item.value + ' - ' + item.hits.to_s
     end.join(', ')
 
-    received.should == expected
+    expect(received).to eq(expected)
 
     r.facets.each do |facet|
-      facet.respond_to?(:name).should == true
+      expect(facet.respond_to?(:name)).to eq(true)
       facet.items.each do |item|
-        item.respond_to?(:value).should == true
-        item.respond_to?(:hits).should == true
+        expect(item.respond_to?(:value)).to eq(true)
+        expect(item.respond_to?(:hits)).to eq(true)
       end
     end
 
@@ -72,7 +72,7 @@ describe Blacklight::SolrResponse do
   it "should provide a model name helper" do
     first_doc_model_name = double(:human => 'xyz')
 
-    r.docs.first.stub(:model_name).and_return first_doc_model_name
+    allow(r.docs.first).to receive(:model_name).and_return first_doc_model_name
 
     expect(r.model_name).to eq first_doc_model_name
   end
@@ -80,33 +80,33 @@ describe Blacklight::SolrResponse do
   describe "FacetItem" do
     it "should work with a field,value tuple" do
       item = Blacklight::SolrResponse::Facets::FacetItem.new('value', 15)
-      item.value.should == 'value'
-      item.hits.should == 15
+      expect(item.value).to eq('value')
+      expect(item.hits).to eq(15)
     end
 
     it "should work with a field,value + hash triple" do
       item = Blacklight::SolrResponse::Facets::FacetItem.new('value', 15, :a => 1, :value => 'ignored')
-      item.value.should == 'value'
-      item.hits.should == 15
-      item.a.should == 1
+      expect(item.value).to eq('value')
+      expect(item.hits).to eq(15)
+      expect(item.a).to eq(1)
     end
 
     it "should work like an openstruct" do
       item = Blacklight::SolrResponse::Facets::FacetItem.new(:value => 'value', :hits => 15)
       
-      item.hits.should == 15
-      item.value.should == 'value'
-      item.should be_a_kind_of(OpenStruct)
+      expect(item.hits).to eq(15)
+      expect(item.value).to eq('value')
+      expect(item).to be_a_kind_of(OpenStruct)
     end
 
     it "should provide a label accessor" do
       item = Blacklight::SolrResponse::Facets::FacetItem.new('value', :hits => 15)
-      item.label.should == 'value'
+      expect(item.label).to eq('value')
     end
 
     it "should use a provided label" do
       item = Blacklight::SolrResponse::Facets::FacetItem.new('value', 15, :label => 'custom label')
-      item.label.should == 'custom label'
+      expect(item.label).to eq('custom label')
 
     end
 
@@ -115,71 +115,71 @@ describe Blacklight::SolrResponse do
   it 'should return the correct value when calling facet_by_field_name' do
     r = create_response
     facet = r.facet_by_field_name('cat')
-    facet.name.should == 'cat'
+    expect(facet.name).to eq('cat')
   end
 
   it 'should provide the responseHeader params' do
     raw_response = eval(mock_query_response)
     raw_response['responseHeader']['params']['test'] = :test
     r = Blacklight::SolrResponse.new(raw_response, raw_response['params'])
-    r.params['test'].should == :test
+    expect(r.params['test']).to eq(:test)
   end
 
   it 'should provide the solr-returned params and "rows" should be 11' do
     raw_response = eval(mock_query_response)
     r = Blacklight::SolrResponse.new(raw_response, {})
-    r.params[:rows].to_s.should == '11'
+    expect(r.params[:rows].to_s).to eq('11')
   end
 
   it 'should provide the ruby request params if responseHeader["params"] does not exist' do
     raw_response = eval(mock_query_response)
     raw_response.delete 'responseHeader'
     r = Blacklight::SolrResponse.new(raw_response, :rows => 999)
-    r.params[:rows].to_s.should == '999'
+    expect(r.params[:rows].to_s).to eq('999')
   end
 
   it 'should provide spelling suggestions for regular spellcheck results' do
     raw_response = eval(mock_response_with_spellcheck)
     r = Blacklight::SolrResponse.new(raw_response,  {})
-    r.spelling.words.should include("dell")
-    r.spelling.words.should include("ultrasharp")
+    expect(r.spelling.words).to include("dell")
+    expect(r.spelling.words).to include("ultrasharp")
   end
 
   it 'should provide spelling suggestions for extended spellcheck results' do
     raw_response = eval(mock_response_with_spellcheck_extended)
     r = Blacklight::SolrResponse.new(raw_response, {})
-    r.spelling.words.should include("dell")
-    r.spelling.words.should include("ultrasharp")
+    expect(r.spelling.words).to include("dell")
+    expect(r.spelling.words).to include("ultrasharp")
   end
 
   it 'should provide no spelling suggestions when extended results and suggestion frequency is the same as original query frequency' do
     raw_response = eval(mock_response_with_spellcheck_same_frequency)
     r = Blacklight::SolrResponse.new(raw_response, {})
-    r.spelling.words.should == []
+    expect(r.spelling.words).to eq([])
   end
 
   it 'should provide spelling suggestions for a regular spellcheck results with a collation' do
     raw_response = eval(mock_response_with_spellcheck_collation)
     r = Blacklight::SolrResponse.new(raw_response, {})
-    r.spelling.words.should include("dell")
-    r.spelling.words.should include("ultrasharp")
+    expect(r.spelling.words).to include("dell")
+    expect(r.spelling.words).to include("ultrasharp")
   end
 
   it 'should provide spelling suggestion collation' do
     raw_response = eval(mock_response_with_spellcheck_collation)
     r = Blacklight::SolrResponse.new(raw_response, {})
-    r.spelling.collation.should == 'dell ultrasharp'
+    expect(r.spelling.collation).to eq('dell ultrasharp')
   end
 
   it "should provide MoreLikeThis suggestions" do
     raw_response = eval(mock_response_with_more_like_this)
     r = Blacklight::SolrResponse.new(raw_response, {})
-    r.more_like(double(:id => '79930185')).should have(2).items
+    expect(r.more_like(double(:id => '79930185')).size).to eq(2)
   end
 
   it "should be empty when the response has no results" do
     r = Blacklight::SolrResponse.new({}, {})
-    r.stub(:total => 0)
+    allow(r).to receive_messages(:total => 0)
     expect(r).to be_empty
   end