blacklight 5.19.2 → 6.0.0.pre1

data/spec/helpers/catalog_helper_spec.rb

@@ -226,14 +226,6 @@ describe CatalogHelper do
 
       expect(helper.render_thumbnail_tag document).to be_nil
     end
-
-    it "should return nil if no thumbnail is in the document" 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(false)
-
-      expect(helper.render_thumbnail_tag document).to be_nil
-    end
   end
 
   describe "thumbnail_url" do

data/spec/helpers/configuration_helper_spec.rb

@@ -222,32 +222,7 @@ describe BlacklightConfigurationHelper do
       expect(helper.should_render_field?(field_config)).to be false
     end
   end
-  
-  describe "#evaluate_configuration_conditional" do
-    it "should pass through regular values" do
-      val = double
-      expect(helper.evaluate_configuration_conditional(val)).to eq val
-    end
 
-    it "should execute a helper method" do
-      allow(helper).to receive_messages(:my_helper => true)
-      expect(helper.evaluate_configuration_conditional(:my_helper)).to be true
-    end
-
-    it "should call a helper to determine if it should render a field" do
-      a = double
-      allow(helper).to receive(:my_helper_with_an_arg).with(a).and_return(true)
-      expect(helper.evaluate_configuration_conditional(:my_helper_with_an_arg, a)).to be true
-    end
-
-    it "should evaluate a Proc to determine if it should render a field" do
-      one_arg_lambda = lambda { |context, a| true }
-      two_arg_lambda = lambda { |context, a, b| true }
-      expect(helper.evaluate_configuration_conditional(one_arg_lambda, 1)).to be true
-      expect(helper.evaluate_configuration_conditional(two_arg_lambda, 1, 2)).to be true
-    end
-  end
-  
   describe "#search_field_options_for_select" do
     
     before do

data/spec/helpers/facets_helper_spec.rb

@@ -8,7 +8,7 @@ describe FacetsHelper do
   before(:each) do
     allow(helper).to receive(:blacklight_config).and_return blacklight_config
   end
-  
+
   describe "has_facet_values?" do
     it "should be true if there are any facets to display" do
 
@@ -47,8 +47,8 @@ describe FacetsHelper do
       @config = Blacklight::Configuration.new do |config|
         config.add_facet_field 'basic_field'
         config.add_facet_field 'no_show', :show => false
-        config.add_facet_field 'helper_show', :show => :my_helper
-        config.add_facet_field 'helper_with_an_arg_show', :show => :my_helper_with_an_arg
+        config.add_facet_field 'helper_show', :show => :my_custom_check
+        config.add_facet_field 'helper_with_an_arg_show', :show => :my_custom_check_with_an_arg
         config.add_facet_field 'lambda_show', :show => lambda { |context, config, field| true }
         config.add_facet_field 'lambda_no_show', :show => lambda { |context, config, field| false }
       end
@@ -71,14 +71,14 @@ describe FacetsHelper do
     end
 
     it "should call a helper to determine if it should render a field" do
-      allow(helper).to receive_messages(:my_helper => true)
+      allow(controller).to receive_messages(:my_custom_check => true)
       a = double(:items => [1,2], :name=>'helper_show')
       expect(helper.should_render_facet?(a)).to be true
     end
 
     it "should call a helper to determine if it should render a field" do
       a = double(:items => [1,2], :name=>'helper_with_an_arg_show')
-      allow(helper).to receive(:my_helper_with_an_arg).with(@config.facet_fields['helper_with_an_arg_show'], a).and_return(true)
+      allow(controller).to receive(:my_custom_check_with_an_arg).with(@config.facet_fields['helper_with_an_arg_show'], a).and_return(true)
       expect(helper.should_render_facet?(a)).to be true
     end
 
@@ -230,7 +230,7 @@ describe FacetsHelper do
     subject { helper.render_facet_limit_list(paginator, 'type_solr_field') }
     before do
       allow(helper).to receive(:search_action_path) do |*args|
-        catalog_index_path *args
+        search_catalog_path *args
       end
     end
     it "should draw a list of elements" do
@@ -300,19 +300,20 @@ describe FacetsHelper do
   end
 
   describe "render_facet_value" do
-    let (:item) { double(:value => 'A', :hits => 10) }
+    let(:item) { double(:value => 'A', :hits => 10) }
+    let(:blacklight_path) { double(add_facet_params_and_redirect: { controller: 'catalog' }) }
     before do
       allow(helper).to receive(:facet_configuration_for_field).with('simple_field').and_return(double(:query => nil, :date => nil, :helper_method => nil, :single => false, :url_method => nil))
       allow(helper).to receive(:facet_display_value).and_return('Z')
-      allow(helper).to receive(:add_facet_params_and_redirect).and_return({controller:'catalog'})
-      
+      allow(helper).to receive(:blacklight_path).and_return(blacklight_path)
       allow(helper).to receive(:search_action_path) do |*args|
-        catalog_index_path *args
+        search_catalog_path *args
       end
     end
     describe "simple case" do
       let(:expected_html) { "<span class=\"facet-label\"><a class=\"facet_select\" href=\"/catalog\">Z</a></span><span class=\"facet-count\">10</span>" }
-      it "should use facet_display_value" do
+
+      it "uses facet_display_value" do
         result = helper.render_facet_value('simple_field', item)
         expect(result).to be_equivalent_to(expected_html).respecting_element_order
       end

data/spec/helpers/hash_as_hidden_fields_spec.rb

@@ -10,13 +10,13 @@ describe HashAsHiddenFieldsHelper do
 
     generated = render_hash_as_hidden_fields(@hash)
 
-    expect(generated).to have_selector("input[type='hidden'][name='q'][value='query']", visible: false)
-    expect(generated).to have_selector("input[type='hidden'][name='per_page'][value='10']", visible: false)
-    expect(generated).to have_selector("input[type='hidden'][name='page'][value='5']", visible: false)
-    expect(generated).to have_selector("input[type='hidden'][name='extra_arbitrary_key'][value='arbitrary_value']", visible: false)
-    expect(generated).to have_selector("input[type='hidden'][name='f[field2][]'][value='z']", visible: false)
-    expect(generated).to have_selector("input[type='hidden'][name='f[field1][]'][value='a']", visible: false)
-    expect(generated).to have_selector("input[type='hidden'][name='f[field1][]'][value='b']", visible: false)
+    expect(generated).to have_selector("input[type='hidden'][name='q'][value='query']")
+    expect(generated).to have_selector("input[type='hidden'][name='per_page'][value='10']")
+    expect(generated).to have_selector("input[type='hidden'][name='page'][value='5']")
+    expect(generated).to have_selector("input[type='hidden'][name='extra_arbitrary_key'][value='arbitrary_value']")
+    expect(generated).to have_selector("input[type='hidden'][name='f[field2][]'][value='z']")
+    expect(generated).to have_selector("input[type='hidden'][name='f[field1][]'][value='a']")
+    expect(generated).to have_selector("input[type='hidden'][name='f[field1][]'][value='b']")
     
   end
 

data/spec/helpers/layout_helper_spec.rb

@@ -28,11 +28,4 @@ describe LayoutHelper do
       expect(helper.sidebar_classes).to eq 'col-md-3 col-sm-4'
     end
   end
-
-  describe '#container_classes' do
-    it 'returns a string of classe(s)' do
-      expect(helper.container_classes).to be_an String
-      expect(helper.container_classes).to eq 'container'
-    end
-  end
 end

data/spec/helpers/render_constraints_helper_spec.rb

@@ -12,7 +12,7 @@ describe RenderConstraintsHelper do
     # the helper methods below infer paths from the current route
     controller.request.path_parameters[:controller] = 'catalog'
     allow(helper).to receive(:search_action_path) do |*args|
-      catalog_index_path *args
+      search_catalog_path *args
     end
   end
 
@@ -32,7 +32,9 @@ describe RenderConstraintsHelper do
       allow(helper).to receive(:blacklight_config).and_return(config)
       expect(helper).to receive(:facet_field_label).with('type').and_return("Item Type")
     end
-    subject { helper.render_filter_element('type', ['journal'], {:q=>'biz'}) }
+    subject { helper.render_filter_element('type', ['journal'], path) }
+
+    let(:path) { Blacklight::Path.new({:q=>'biz'}, config) }
 
     it "should have a link relative to the current url" do
       expect(subject).to have_link "Remove constraint Item Type: journal", href: "/catalog?q=biz"

data/spec/helpers/url_helper_spec.rb

@@ -11,7 +11,7 @@ describe BlacklightUrlHelper do
 
   before do
     allow(helper).to receive(:search_action_path) do |*args|
-      catalog_index_url *args
+      search_catalog_url *args
     end
 
     allow(helper).to receive_messages(blacklight_config: blacklight_config)
@@ -26,6 +26,7 @@ describe BlacklightUrlHelper do
     before do
       allow(helper).to receive_messages(controller: controller_class)
       allow(helper).to receive_messages(controller_name: controller_class.controller_name)
+      allow(helper).to receive_messages(params: {})
     end
 
     it "should be a polymorphic routing-ready object" do
@@ -49,6 +50,7 @@ describe BlacklightUrlHelper do
       let(:controller_class) { ::AlternateController.new }
       before do
         helper.blacklight_config.show.route = { controller: :current }
+        allow(helper).to receive(:params).and_return(controller: 'alternate')
       end
       it "should support the :current controller configuration" do
         expect(helper.url_for_document(doc)).to eq({controller: 'alternate', action: :show, id: doc})
@@ -129,13 +131,6 @@ describe BlacklightUrlHelper do
     end
   end
 
-  describe "link_to_previous_document" do
-    context "when the argument is nil" do
-      subject { helper.link_to_previous_document(nil) }
-      it { is_expected.to eq '<span class="previous">&laquo; Previous</span>' }
-    end
-  end
-
   describe "link_to_query" do
     it "should build a link tag to catalog using query string (no other params)" do
       query = "brilliant"
@@ -166,94 +161,17 @@ describe BlacklightUrlHelper do
     end
   end
 
-  describe "sanitize_search_params" do
-    it "should strip nil values" do
-      result = helper.sanitize_search_params(:a => nil, :b => 1)
-      expect(result).to_not have_key(:a)
-      expect(result[:b]).to eq 1
-    end
-
-    it "should remove blacklisted keys" do
-      result = helper.sanitize_search_params(:action => true, :controller => true, :id => true, :commit => true, :utf8 => true)
-      expect(result).to be_empty
-    end
-  end
-
-  describe "params_for_search" do
-    before do
-      allow(helper).to receive_messages(params: { 'default' => 'params'})
-    end
-
-    it "should default to using the controller's params" do
-      result = helper.params_for_search
-      expect(result).to eq({ 'default' => 'params' })
-      expect(params.object_id).to_not eq result.object_id
-    end
-
-    it "should let you pass in params to merge into the controller's params" do
-      source_params = { :q => 'query'}
-      result = helper.params_for_search( source_params )
-      expect(result).to include(:q => 'query', 'default' => 'params')
-    end
-
-    it "should not return blacklisted elements" do
-      source_params = { :action => 'action', :controller => 'controller', :id => "id", :commit => 'commit'}
-      result = helper.params_for_search(source_params)
-      expect(result.keys).to_not include(:action, :controller, :commit, :id)
-    end
-
-    it "should adjust the current page if the per_page changes" do
-      source_params = { :per_page => 20, :page => 5}
-      result = helper.params_for_search(source_params, :per_page => 100)
-      expect(result[:page]).to eq 1
-    end
-
-    it "should not adjust the current page if the per_page is the same as it always was" do
-      source_params = { :per_page => 20, :page => 5}
-      result = helper.params_for_search(source_params, :per_page => 20)
-      expect(result[:page]).to eq 5
-    end
-
-    it "should adjust the current page if the sort changes" do
-      source_params = { :sort => 'field_a', :page => 5}
-      result = helper.params_for_search(source_params, :sort => 'field_b')
-      expect(result[:page]).to eq 1
-    end
-
-    it "should not adjust the current page if the sort is the same as it always was" do
-      source_params = { :sort => 'field_a', :page => 5}
-      result = helper.params_for_search(source_params, :sort => 'field_a')
-      expect(result[:page]).to eq 5
-    end
-
-    describe "params_for_search with a block" do
-      it "should evalute the block and allow it to add or remove keys" do
-        result = helper.params_for_search({:a => 1, :b => 2}, :c => 3) do |params|
-          params.except! :a, :b 
-          params[:d] = 'd'
-        end
-
-        expect(result.keys).to_not include(:a, :b)
-        expect(result[:c]).to eq 3
-        expect(result[:d]).to eq 'd'
-      end
-
-    end
-
-  end
-
-
   describe "start_over_path" do
     it 'should be the catalog path with the current view type' do
       allow(blacklight_config).to receive(:view) { { list: nil, abc: nil} }
       allow(helper).to receive_messages(:blacklight_config => blacklight_config)
-      expect(helper.start_over_path(:view => 'abc')).to eq catalog_index_url(:view => 'abc')
+      expect(helper.start_over_path(:view => 'abc')).to eq search_catalog_url(:view => 'abc')
     end
 
     it 'should not include the current view type if it is the default' do
       allow(blacklight_config).to receive(:view) { { list: nil, asdf: nil} }
       allow(helper).to receive_messages(:blacklight_config => blacklight_config)
-      expect(helper.start_over_path(:view => 'list')).to eq catalog_index_url
+      expect(helper.start_over_path(:view => 'list')).to eq search_catalog_url
     end
   end
 
@@ -298,7 +216,10 @@ describe BlacklightUrlHelper do
     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, :title_display, counter: 5)).to match /\/catalog\/123456\/track\?counter=5/
+
+      allow(helper).to receive(:track_test_path).with(hash_including(id: '123456', counter: 5)).and_return('tracking url')
+
+      expect(helper.link_to_document(@document, :title_display, counter: 5)).to include 'data-context-href="tracking url"'
     end
 
     it "should merge the data- attributes from the options with the counter params" do
@@ -335,170 +256,6 @@ describe BlacklightUrlHelper do
     end
   end
 
-  describe "add_facet_params" do
-    before do
-      @params_no_existing_facet = {:q => "query", :search_field => "search_field", :per_page => "50"}
-      @params_existing_facets = {:q => "query", :search_field => "search_field", :per_page => "50", :f => {"facet_field_1" => ["value1"], "facet_field_2" => ["value2", "value2a"]}}
-    end
-
-    it "should add facet value for no pre-existing facets" do
-      allow(helper).to receive(:params).and_return(@params_no_existing_facet)
-
-      result_params = helper.add_facet_params("facet_field", "facet_value")
-      expect(result_params[:f]).to be_a_kind_of(Hash)
-      expect(result_params[:f]["facet_field"]).to be_a_kind_of(Array)
-      expect(result_params[:f]["facet_field"]).to eq ["facet_value"]
-    end
-
-    it "should use the facet's key in the url" do
-      allow(helper).to receive(:facet_configuration_for_field).with('some_field').and_return(double(single: true, field: "a_solr_field", key: "some_key"))
-
-      result_params = helper.add_facet_params('some_field', 'my_value', {})
-
-      expect(result_params[:f]['some_key']).to have(1).item
-      expect(result_params[:f]['some_key'].first).to eq 'my_value'
-    end
-
-
-    it "should add a facet param to existing facet constraints" do
-      allow(helper).to receive(:params).and_return(@params_existing_facets)
-      
-      result_params = helper.add_facet_params("facet_field_2", "new_facet_value")
-
-      expect(result_params[:f]).to be_a_kind_of(Hash)
-
-      @params_existing_facets[:f].each_pair do |facet_field, value_list|
-        expect(result_params[:f][facet_field]).to be_a_kind_of(Array)
-        
-        if facet_field == 'facet_field_2'
-          expect(result_params[:f][facet_field]).to eq (@params_existing_facets[:f][facet_field] | ["new_facet_value"])
-        else
-          expect(result_params[:f][facet_field]).to eq @params_existing_facets[:f][facet_field]
-        end        
-      end
-    end
-    it "should leave non-facet params alone" do
-      [@params_existing_facets, @params_no_existing_facet].each do |params|
-        allow(helper).to receive(:params).and_return(params)
-
-        result_params = helper.add_facet_params("facet_field_2", "new_facet_value")
-
-        params.each_pair do |key, value|
-          next if key == :f
-          expect(result_params[key]).to eq params[key]
-        end        
-      end
-    end    
-
-    it "should replace facets for facets configured as single" do
-      allow(helper).to receive(:facet_configuration_for_field).with('single_value_facet_field').and_return(double(single: true, key: "single_value_facet_field"))
-      params = { :f => { 'single_value_facet_field' => 'other_value'}}
-      allow(helper).to receive(:params).and_return params
-
-      result_params = helper.add_facet_params('single_value_facet_field', 'my_value')
-
-
-      expect(result_params[:f]['single_value_facet_field']).to have(1).item
-      expect(result_params[:f]['single_value_facet_field'].first).to eq 'my_value'
-    end
-
-    it "should accept a FacetItem instead of a plain facet value" do
-          
-      result_params = helper.add_facet_params('facet_field_1', double(:value => 123))
-
-      expect(result_params[:f]['facet_field_1']).to include(123)
-    end
-
-    it "should defer to the field set on a FacetItem" do
-          
-      result_params = helper.add_facet_params('facet_field_1', double(:field => 'facet_field_2', :value => 123))
-
-      expect(result_params[:f]['facet_field_1']).to be_blank
-      expect(result_params[:f]['facet_field_2']).to include(123)
-    end
-
-    it "should add any extra fq parameters from the FacetItem" do
-          
-      result_params = helper.add_facet_params('facet_field_1', double(:value => 123, :fq => {'facet_field_2' => 'abc'}))
-
-      expect(result_params[:f]['facet_field_1']).to include(123)
-      expect(result_params[:f]['facet_field_2']).to include('abc')
-    end
-  end
-
-  describe "add_facet_params_and_redirect" do
-    before do
-      catalog_facet_params = {:q => "query", 
-                :search_field => "search_field", 
-                :per_page => "50",
-                :page => "5",
-                :f => {"facet_field_1" => ["value1"], "facet_field_2" => ["value2", "value2a"]},
-                Blacklight::Solr::FacetPaginator.request_keys[:page] => "100",
-                Blacklight::Solr::FacetPaginator.request_keys[:sort] => "index",
-                :id => 'facet_field_name'
-      }
-      allow(helper).to receive(:params).and_return(catalog_facet_params)
-    end
-    it "should not include request parameters used by the facet paginator" do
-      params = helper.add_facet_params_and_redirect("facet_field_2", "facet_value")
-
-      bad_keys = Blacklight::Solr::FacetPaginator.request_keys.values + [:id]
-      bad_keys.each do |paginator_key|
-        expect(params.keys).to_not include(paginator_key)        
-      end
-    end
-    it 'should remove :page request key' do
-      params = helper.add_facet_params_and_redirect("facet_field_2", "facet_value")
-      expect(params.keys).to_not include(:page)
-    end
-    it "should otherwise do the same thing as add_facet_params" do
-      added_facet_params = helper.add_facet_params("facet_field_2", "facet_value")
-      added_facet_params_from_facet_action = helper.add_facet_params_and_redirect("facet_field_2", "facet_value")
-
-      expect(added_facet_params_from_facet_action).to eq added_facet_params.except(Blacklight::Solr::FacetPaginator.request_keys[:page], Blacklight::Solr::FacetPaginator.request_keys[:sort])     
-    end
-  end
-
-  describe "#remove_facet_params" do
-    let(:query_params) { { f: facet_params }}
-    let(:facet_params) { { } }
-    it "should remove the facet / value tuple from the query parameters" do
-      facet_params['some_field'] = ['some_value', 'another_value']
-
-      params = helper.remove_facet_params('some_field', 'some_value', query_params)
-
-      expect(params[:f]['some_field']).not_to include 'some_value'
-      expect(params[:f]['some_field']).to include 'another_value'
-    end
-
-    it "should use the facet's key configuration" do
-      allow(helper).to receive(:facet_configuration_for_field).with('some_field').and_return(double(single: true, field: "a_solr_field", key: "some_key"))
-      facet_params['some_key'] = ['some_value', 'another_value']
-
-      params = helper.remove_facet_params('some_field', 'some_value', query_params)
-
-      expect(params[:f]['some_key']).not_to eq 'some_value'
-      expect(params[:f]['some_key']).to include 'another_value'
-    end
-
-    it "should remove the facet entirely when the last facet value is removed" do
-      facet_params['another_field'] = ['some_value']
-      facet_params['some_field'] = ['some_value']
-
-      params = helper.remove_facet_params('some_field', 'some_value', query_params)
-
-      expect(params[:f]).not_to include 'some_field'
-    end
-
-    it "should remove the 'f' parameter entirely when no facets remain" do
-      facet_params['some_field'] = ['some_value']
-
-      params = helper.remove_facet_params('some_field', 'some_value', query_params)
-
-      expect(params).not_to include :f
-    end
-  end
-  
   describe "#bookmarks_export_url" do
     it "should be the bookmark url with an encrypted user token" do
       allow(helper).to receive_messages(encrypt_user_id: 'xyz', current_or_guest_user: double(id: 123))
@@ -510,11 +267,13 @@ describe BlacklightUrlHelper do
   describe "#session_tracking_path" do
     let(:document) { SolrDocument.new(id: 1) }
     it "should determine the correct route for the document class" do
-      expect(helper.session_tracking_path(document)).to eq helper.track_solr_document_path(document)
+      allow(helper).to receive(:track_test_path).with(id: 1).and_return('x')
+      expect(helper.session_tracking_path(document)).to eq 'x'
     end
 
     it "should pass through tracking parameters" do
-      expect(helper.session_tracking_path(document, x: 1)).to eq helper.track_solr_document_path(document, x: 1)
+      allow(helper).to receive(:track_test_path).with(id: 1, x: 1).and_return('x')
+      expect(helper.session_tracking_path(document, x: 1)).to eq 'x'
     end
   end
 end