blacklight 5.7.2 → 5.8.0

data/spec/helpers/catalog_helper_spec.rb

@@ -11,7 +11,7 @@ describe CatalogHelper do
     start = (current_page - 1) * per_page
 
     mock_docs = (1..total).to_a.map { {}.with_indifferent_access }
-    
+
     mock_response = Kaminari.paginate_array(mock_docs).page(current_page).per(per_page)
 
     allow(mock_response).to receive(:docs).and_return(mock_docs.slice(start, per_page))
@@ -21,8 +21,8 @@ describe CatalogHelper do
   def render_grouped_response?
     false
   end
-  
-  
+
+
   describe "page_entries_info" do
     before(:all) do
     end
@@ -43,6 +43,13 @@ describe CatalogHelper do
       expect(html).to be_html_safe
     end
 
+    it "with an empty page of results" do
+      @response = double(limit_value: -1)
+
+      html = page_entries_info(@response)
+      expect(html).to be_blank
+    end
+
     describe "with a single result" do
       it "should use the provided entry name" do
         response = mock_response :total => 1
@@ -177,17 +184,17 @@ describe CatalogHelper do
       allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_method => :xyz) ))
       allow(helper).to receive_messages(:xyz => "some-thumbnail")
 
-      allow(helper).to receive(:link_to_document).with(document, :label => "some-thumbnail")
+      allow(helper).to receive(:link_to_document).with(document, "some-thumbnail", {})
       helper.render_thumbnail_tag document
     end
 
     it "should create an image tag from the given field" do
       allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_field => :xyz) ))
-      
+
       allow(document).to receive(:has?).with(:xyz).and_return(true)
       allow(document).to receive(:first).with(:xyz).and_return("http://example.com/some.jpg")
 
-      allow(helper).to receive(:link_to_document).with(document, :label => image_tag("http://example.com/some.jpg"))
+      allow(helper).to receive(:link_to_document).with(document, image_tag("http://example.com/some.jpg"), {})
       helper.render_thumbnail_tag document
     end
 
@@ -206,7 +213,7 @@ describe CatalogHelper do
       result = helper.render_thumbnail_tag document, {}, suppress_link: true
       expect(result).to eq "some-thumbnail"
     end
-    
+
 
     it "should return nil if no thumbnail is available" do
       allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new() ))
@@ -216,7 +223,7 @@ describe CatalogHelper do
     it "should return nil if no thumbnail is returned from the thumbnail method" do
       allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_method => :xyz) ))
       allow(helper).to receive_messages(:xyz => nil)
-      
+
       expect(helper.render_thumbnail_tag document).to be_nil
     end
   end
@@ -257,4 +264,45 @@ describe CatalogHelper do
     end
   end
 
+  describe "render_document_class" do
+    before do
+      allow(helper).to receive(:blacklight_config).and_return(blacklight_config)
+    end
+
+    let :blacklight_config do
+      Blacklight::Configuration.new
+    end
+
+    it "should pull data out of a document's field" do
+      blacklight_config.index.display_type_field = :type
+      doc = { :type => 'book' }
+      expect(helper.render_document_class(doc)).to eq "blacklight-book"
+    end
+
+    it "should support multivalued fields" do
+      blacklight_config.index.display_type_field = :type
+      doc = { :type => ['book', 'mss'] }
+      expect(helper.render_document_class(doc)).to eq "blacklight-book blacklight-mss"
+    end
+
+    it "should support empty fields" do
+      blacklight_config.index.display_type_field = :type
+      doc = { :type => [] }
+      expect(helper.render_document_class(doc)).to be_blank
+    end
+
+    it "should support missing fields" do
+      blacklight_config.index.display_type_field = :type
+      doc = { }
+      expect(helper.render_document_class(doc)).to be_blank
+    end
+
+    it "should support view-specific field configuration" do
+      allow(helper).to receive(:document_index_view_type).and_return(:some_view_type)
+      blacklight_config.view.some_view_type.display_type_field = :other_type
+      doc = { other_type: "document"}
+      expect(helper.render_document_class(doc)).to eq "blacklight-document"
+    end
+  end
+
 end

data/spec/helpers/configuration_helper_spec.rb

@@ -92,7 +92,7 @@ describe BlacklightConfigurationHelper do
     let(:document) { double }
     it "should look up the label to display for the given document and field" do
       allow(helper).to receive(:index_fields).and_return({ "my_field" => double(label: "some label") })
-      allow(helper).to receive(:solr_field_label).with("some label", :"blacklight.search.fields.index.my_field", :"blacklight.search.fields.my_field")
+      allow(helper).to receive(:solr_field_label).with(:"blacklight.search.fields.index.my_field", :"blacklight.search.fields.my_field", "some label", "My field")
       helper.index_field_label document, "my_field"
     end
   end
@@ -101,7 +101,7 @@ describe BlacklightConfigurationHelper do
     let(:document) { double }
     it "should look up the label to display for the given document and field" do
       allow(helper).to receive(:document_show_fields).and_return({ "my_field" => double(label: "some label") })
-      allow(helper).to receive(:solr_field_label).with("some label", :"blacklight.search.fields.show.my_field", :"blacklight.search.fields.my_field")
+      allow(helper).to receive(:solr_field_label).with(:"blacklight.search.fields.show.my_field", :"blacklight.search.fields.my_field", "some label", "My field")
       helper.document_show_field_label document, "my_field"
     end
   end
@@ -110,14 +110,14 @@ describe BlacklightConfigurationHelper do
     let(:document) { double }
     it "should look up the label to display for the given document and field" do
       allow(blacklight_config).to receive(:facet_fields).and_return({ "my_field" => double(label: "some label") })
-      allow(helper).to receive(:solr_field_label).with("some label", :"blacklight.search.fields.facet.my_field", :"blacklight.search.fields.my_field")
+      allow(helper).to receive(:solr_field_label).with(:"blacklight.search.fields.facet.my_field", :"blacklight.search.fields.my_field", "some label", "My field")
       helper.facet_field_label "my_field"
     end
   end
 
   describe "#solr_field_label" do
     it "should look up the label as an i18n string" do
-      allow(helper).to receive(:t).with(:some_key).and_return "my label"
+      allow(helper).to receive(:t).with(:some_key, default: []).and_return "my label"
       label = helper.solr_field_label :some_key
 
       expect(label).to eq "my label"
@@ -126,7 +126,7 @@ describe BlacklightConfigurationHelper do
     it "should pass the provided i18n keys to I18n.t" do
       allow(helper).to receive(:t).with(:key_a, default: [:key_b, "default text"])
 
-      label = helper.solr_field_label "default text", :key_a, :key_b
+      label = helper.solr_field_label :key_a, :key_b, "default text"
     end
   end
   

data/spec/helpers/url_helper_spec.rb

@@ -254,37 +254,44 @@ describe BlacklightUrlHelper do
     it "should consist of the document title wrapped in a <a>" do
       data = {'id'=>'123456','title_display'=>['654321'] }
       @document = SolrDocument.new(data)
-      expect(helper.link_to_document(@document, { :label => :title_display })).to have_selector("a", :text => '654321', :count => 1)
+      expect(helper.link_to_document(@document, :title_display)).to have_selector("a", :text => '654321', :count => 1)
     end
 
-    it "should accept and return a string label" do
+    it "should have the old deprecated behavior (second argument is a hash)" do
       data = {'id'=>'123456','title_display'=>['654321'] }
       @document = SolrDocument.new(data)
+      expect(Deprecation).to receive(:warn)
       expect(helper.link_to_document(@document, { :label => "title_display" })).to have_selector("a", :text => 'title_display', :count => 1)
     end
 
+    it "should accept and return a string label" do
+      data = {'id'=>'123456','title_display'=>['654321'] }
+      @document = SolrDocument.new(data)
+      expect(helper.link_to_document(@document, "title_display")).to have_selector("a", :text => 'title_display', :count => 1)
+    end
+
     it "should accept and return a Proc" do
       data = {'id'=>'123456','title_display'=>['654321'] }
       @document = SolrDocument.new(data)
-      expect(helper.link_to_document(@document, { :label => Proc.new { |doc, opts| doc.get(:id) + ": " + doc.get(:title_display) } })).to have_selector("a", :text => '123456: 654321', :count => 1)
+      expect(helper.link_to_document(@document, Proc.new { |doc, opts| doc.get(:id) + ": " + doc.get(:title_display) })).to have_selector("a", :text => '123456: 654321', :count => 1)
     end
 
     it "should return id when label is missing" do
       data = {'id'=>'123456'}
       @document = SolrDocument.new(data)
-      expect(helper.link_to_document(@document, { :label => :title_display })).to have_selector("a", :text => '123456', :count => 1)
+      expect(helper.link_to_document(@document, :title_display)).to have_selector("a", :text => '123456', :count => 1)
     end
 
     it "should be html safe" do
       data = {'id'=>'123456'}
       @document = SolrDocument.new(data)
-      expect(helper.link_to_document(@document, { :label => :title_display })).to be_html_safe
+      expect(helper.link_to_document(@document, :title_display)).to be_html_safe
     end
 
     it "should convert the counter parameter into a data- attribute" do
       data = {'id'=>'123456','title_display'=>['654321']}
       @document = SolrDocument.new(data)
-      expect(helper.link_to_document(@document, { :label => :title_display, :counter => 5  })).to match /\/catalog\/123456\/track\?counter=5/
+      expect(helper.link_to_document(@document, :title_display, counter: 5)).to match /\/catalog\/123456\/track\?counter=5/
     end
 
     it "should merge the data- attributes from the options with the counter params" do
@@ -297,12 +304,12 @@ describe BlacklightUrlHelper do
 
     it "passes on the title attribute to the link_to_with_data method" do
       @document = SolrDocument.new('id'=>'123456')
-      expect(helper.link_to_document(@document,:label=>"Some crazy long label...",:title=>"Some crazy longer label")).to match(/title=\"Some crazy longer label\"/)
+      expect(helper.link_to_document(@document, "Some crazy long label...", title: "Some crazy longer label")).to match(/title=\"Some crazy longer label\"/)
     end
 
     it "doesn't add an erroneous title attribute if one isn't provided" do
       @document = SolrDocument.new('id'=>'123456')
-      expect(helper.link_to_document(@document,:label=>"Some crazy long label...")).to_not match(/title=/)
+      expect(helper.link_to_document(@document, "Some crazy long label...")).to_not match(/title=/)
     end
 
     it "should  work with integer ids" do

data/spec/lib/blacklight/catalog/component_configuration_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Blacklight::Catalog::ComponentConfiguration do
+  subject do
+    Class.new do
+      include Blacklight::Configurable
+      include Blacklight::Catalog::ComponentConfiguration
+
+      def some_existing_action
+        1
+      end
+    end
+  end
+
+  describe ".add_show_tools_partial" do
+    it "should define an action method" do
+      subject.add_show_tools_partial :xyz
+      expect(subject.new).to respond_to :xyz
+    end
+
+    it "should not replace an existing method" do
+      subject.add_show_tools_partial :some_existing_action
+      expect(subject.new.some_existing_action).to eq 1
+    end
+  end
+
+  
+
+end

data/spec/lib/blacklight/configuration_spec.rb

@@ -83,6 +83,21 @@ describe "Blacklight::Configuration" do
       expect(@config.a).to be_nil
       expect(@config.facet_fields).to_not include(@mock_facet)
     end
+
+    it "should provide cloned copies of mutable data structures" do
+      @config.a = { value: 1 }
+      @config.b = [1,2,3]
+
+      config_copy = @config.inheritable_copy
+
+      config_copy.a[:value] = 2
+      config_copy.b << 5
+
+      expect(@config.a[:value]).to eq 1
+      expect(config_copy.a[:value]).to eq 2
+      expect(@config.b).to match_array [1,2,3]
+      expect(config_copy.b).to match_array [1,2,3,5]
+    end
   end
 
   describe "add alternative solr fields" do

data/spec/lib/blacklight/solr_helper_spec.rb

@@ -18,20 +18,17 @@ describe Blacklight::SolrHelper do
     include Blacklight::SolrHelper
 
     attr_accessor :blacklight_config
-    attr_accessor :blacklight_solr
+    attr_accessor :solr_repository
 
     def initialize blacklight_config, blacklight_solr
       self.blacklight_config = blacklight_config
-      self.blacklight_solr = blacklight_solr
+      self.solr_repository = Blacklight::SolrRepository.new(blacklight_config)
+      self.solr_repository.blacklight_solr = blacklight_solr
     end
 
     def params
       {}
     end
-
-    def logger
-      Rails.logger
-    end
   end
 
   subject { SolrHelperTestClass.new blacklight_config, blacklight_solr }
@@ -52,70 +49,6 @@ describe Blacklight::SolrHelper do
     @subject_search_params = {:commit=>"search", :search_field=>"subject", :action=>"index", :"controller"=>"catalog", :"rows"=>"10", :"q"=>"wome"}
   end
 
-  describe "#find" do  
-    it "should use the configured solr path" do
-      blacklight_config.solr_path = 'xyz'
-      allow(blacklight_solr).to receive(:send_and_receive).with('xyz', anything).and_return("{}".to_json)
-      expect(subject.find({})).to be_a_kind_of Blacklight::SolrResponse
-    end
-
-    it "should override the configured solr path" do
-      blacklight_config.solr_path = 'xyz'
-      allow(blacklight_solr).to receive(:send_and_receive).with('abc', anything).and_return("{}".to_json)
-      expect(subject.find('abc', {})).to be_a_kind_of Blacklight::SolrResponse
-    end
-
-    it "should use a default :qt param" do
-      blacklight_config.qt = 'xyz'
-      allow(blacklight_solr).to receive(:send_and_receive).with('select', hash_including(params: { qt: 'xyz'})).and_return("{}".to_json)
-      expect(subject.find({})).to be_a_kind_of Blacklight::SolrResponse
-    end
-
-    it "should use the provided :qt param" do
-      blacklight_config.qt = 'xyz'
-      allow(blacklight_solr).to receive(:send_and_receive).with('select', hash_including(params: { qt: 'abc'})).and_return("{}".to_json)
-      expect(subject.find({qt: 'abc'})).to be_a_kind_of Blacklight::SolrResponse
-    end
-
-    describe "http_method configuration" do
-      describe "using default" do
-
-        it "defaults to get" do
-          expect(blacklight_config.http_method).to eq :get
-          allow(blacklight_solr).to receive(:send_and_receive) do |path, params|
-            expect(path).to eq 'select'
-            expect(params[:method]).to eq :get
-            expect(params[:params]).to include(:q)
-          end.and_return({'response'=>{'docs'=>[]}})
-          subject.find(:q => @all_docs_query)
-        end
-      end
-
-      describe "setting to post" do
-        let (:blacklight_config) {config = Blacklight::Configuration.new; config.http_method=:post; config}
-
-        it "keep value set to post" do
-          expect(blacklight_config.http_method).to eq :post
-          allow(blacklight_solr).to receive(:send_and_receive) do |path, params|
-            expect(path).to eq 'select'
-            expect(params[:method]).to eq :post
-            expect(params[:data]).to include(:q)
-          end.and_return({'response'=>{'docs'=>[]}})
-          subject.find(:q => @all_docs_query)
-        end
-      end
-    end
-  end
-  
-  describe "http_method configuration", :integration => true do
-    let (:blacklight_config) {config = Blacklight::Configuration.new; config.http_method=:post; config}
-
-    it "should send a post request to solr and get a response back" do
-      response = subject.find(:q => @all_docs_query)
-      expect(response.docs.length).to be >= 1
-    end
-  end
-
   # SPECS for actual search parameter generation
   describe "solr_search_params" do
     it "allows customization of solr_search_params_logic" do
@@ -688,28 +621,19 @@ describe Blacklight::SolrHelper do
       expect(solr_params[:"f.#{@facet_field}.facet.sort"]).to be_blank
     end
 
-    it "uses the field-specific sort" do
-      solr_params = subject.solr_facet_params('format_ordered')
-      expect(solr_params[:"f.format_ordered.facet.sort"]).to eq :count
-    end
-
     it 'uses sort provided in the parameters' do
       solr_params = subject.solr_facet_params(@facet_field, @sort_key => "index")
       expect(solr_params[:"f.#{@facet_field}.facet.sort"]).to eq 'index'
     end
+
     it "comes up with the same params as #solr_search_params to constrain context for facet list" do
       search_params = {:q => 'tibetan history', :f=> {:format=>'Book', :language_facet=>'Tibetan'}}
-      solr_search_params = subject.solr_search_params( search_params )
       solr_facet_params = subject.solr_facet_params('format', search_params)
 
-      solr_search_params.each_pair do |key, value|
-        # The specific params used for fetching the facet list we
-        # don't care about.
-        next if ['facets', "facet.field", 'rows', 'facet.limit', 'facet.offset', 'facet.sort'].include?(key)
-        # Everything else should match
-        expect(solr_facet_params[key]).to eq value
-      end
-
+      expect(solr_facet_params).to include :"facet.field" => "format"
+      expect(solr_facet_params).to include :"f.format.facet.limit" => 21
+      expect(solr_facet_params).to include :"f.format.facet.offset" => 0
+      expect(solr_facet_params).to include :"rows" => 0
     end
   end
   describe "for facet limit parameters config ed" do                
@@ -1079,27 +1003,35 @@ describe Blacklight::SolrHelper do
 
   describe "solr_doc_params" do
     it "should default to using the 'document' requestHandler" do
-      doc_params = subject.solr_doc_params('asdfg')
-      expect(doc_params[:qt]).to eq 'document'
+      Deprecation.silence(Blacklight::SolrHelper) do
+        doc_params = subject.solr_doc_params('asdfg')
+        expect(doc_params[:qt]).to eq 'document'
+      end
     end
 
     it "should default to using the id parameter when sending solr queries" do
-      doc_params = subject.solr_doc_params('asdfg')
-      expect(doc_params[:id]).to eq 'asdfg'
+      Deprecation.silence(Blacklight::SolrHelper) do
+        doc_params = subject.solr_doc_params('asdfg')
+        expect(doc_params[:id]).to eq 'asdfg'
+      end
     end
 
     it "should use the document_unique_id_param configuration" do
-      allow(blacklight_config).to receive_messages(document_unique_id_param: :ids)
-      doc_params = subject.solr_doc_params('asdfg')
-      expect(doc_params[:ids]).to eq 'asdfg'
+      Deprecation.silence(Blacklight::SolrHelper) do
+        allow(blacklight_config).to receive_messages(document_unique_id_param: :ids)
+        doc_params = subject.solr_doc_params('asdfg')
+        expect(doc_params[:ids]).to eq 'asdfg'
+      end
     end
 
     describe "blacklight config's default_document_solr_parameters" do
       it "should use parameters from the controller's default_document_solr_parameters" do
-        blacklight_config.default_document_solr_params = { :qt => 'my_custom_handler', :asdf => '1234' }
-        doc_params = subject.solr_doc_params('asdfg')
-        expect(doc_params[:qt]).to eq 'my_custom_handler'
-        expect(doc_params[:asdf]).to eq '1234'
+        Deprecation.silence(Blacklight::SolrHelper) do
+          blacklight_config.default_document_solr_params = { :qt => 'my_custom_handler', :asdf => '1234' }
+          doc_params = subject.solr_doc_params('asdfg')
+          expect(doc_params[:qt]).to eq 'my_custom_handler'
+          expect(doc_params[:asdf]).to eq '1234'
+        end
       end
     end
 
@@ -1116,8 +1048,10 @@ describe Blacklight::SolrHelper do
     end
 =end
     it "should respect the configuration-supplied unique id" do
-      doc_params = subject.solr_doc_params('"Strong Medicine speaks"')
-      expect(doc_params[:id]).to eq '"Strong Medicine speaks"'
+      Deprecation.silence(Blacklight::SolrHelper) do
+        doc_params = subject.solr_doc_params('"Strong Medicine speaks"')
+        expect(doc_params[:id]).to eq '"Strong Medicine speaks"'
+      end
     end
   end
 
@@ -1277,18 +1211,24 @@ describe Blacklight::SolrHelper do
         allow(@mock_response).to receive_messages(documents: [])
       end
       it "should contruct a solr query based on the field and value pair" do
-        allow(subject).to receive(:find).with(hash_including(:q => "field_name:(value)")).and_return(@mock_response)
-        subject.get_solr_response_for_field_values('field_name', 'value')
+        Deprecation.silence(Blacklight::SolrHelper) do
+          allow(subject.solr_repository).to receive(:send_and_receive).with('select', hash_including("q" => "{!lucene}field_name:(value)")).and_return(@mock_response)
+          subject.get_solr_response_for_field_values('field_name', 'value')
+        end
       end
 
       it "should OR multiple values together" do
-        allow(subject).to receive(:find).with(hash_including(:q => "field_name:(a OR b)")).and_return(@mock_response)
-        subject.get_solr_response_for_field_values('field_name', ['a', 'b'])
+        Deprecation.silence(Blacklight::SolrHelper) do
+          allow(subject.solr_repository).to receive(:send_and_receive).with('select', hash_including("q" => "{!lucene}field_name:(a OR b)")).and_return(@mock_response)
+          subject.get_solr_response_for_field_values('field_name', ['a', 'b'])
+        end
       end
 
       it "should escape crazy identifiers" do
-        allow(subject).to receive(:find).with(hash_including(:q => "field_name:(\"h://\\\"\\\'\")")).and_return(@mock_response)
-        subject.get_solr_response_for_field_values('field_name', 'h://"\'')
+        Deprecation.silence(Blacklight::SolrHelper) do
+          allow(subject.solr_repository).to receive(:send_and_receive).with('select', hash_including("q" => "{!lucene}field_name:(\"h://\\\"\\\'\")")).and_return(@mock_response)
+          subject.get_solr_response_for_field_values('field_name', 'h://"\'')
+        end
       end
     end
 
@@ -1301,7 +1241,7 @@ describe Blacklight::SolrHelper do
 #  nearby on shelf
   it "should raise a Blacklight exception if RSolr can't connect to the Solr instance" do
     allow(blacklight_solr).to receive(:send_and_receive).and_raise(Errno::ECONNREFUSED)
-    expect { subject.find(:a => 123) }.to raise_exception(/Unable to connect to Solr instance/)
+    expect { subject.query_solr }.to raise_exception(/Unable to connect to Solr instance/)
   end
 
   describe "grouped_key_for_results" do