blacklight 6.14.0 → 7.0.0

data/spec/controllers/blacklight/search_helper_spec.rb

@@ -1,470 +0,0 @@
-# frozen_string_literal: true
-
-# check the methods that do solr requests. Note that we are not testing if
-#  solr gives "correct" responses, as that's out of scope (it's a part of
-#  testing the solr code itself).  We *are* testing if blacklight code sends
-#  queries to solr such that it gets appropriate results. When a user does a search,
-#  do we get data back from solr (i.e. did we properly configure blacklight code
-#  to talk with solr and get results)? when we do a document request, does
-#  blacklight code get a single document returned?)
-#
-describe Blacklight::SearchHelper do
-
-  # SearchHelper is a controller layer mixin, which depends
-  # on being mixed into a class which has #params (from Rails)
-  # and #blacklight_config
-  class SearchHelperTestClass
-    include Blacklight::SearchHelper
-
-    attr_accessor :blacklight_config
-    attr_accessor :repository
-
-    def initialize blacklight_config, conn
-      self.blacklight_config = blacklight_config
-      self.repository = Blacklight::Solr::Repository.new(blacklight_config)
-      self.repository.connection = conn
-    end
-
-    def params
-      {}
-    end
-  end
-
-  subject { SearchHelperTestClass.new blacklight_config, blacklight_solr }
-
-  let(:blacklight_config) { Blacklight::Configuration.new }
-  let(:copy_of_catalog_config) { ::CatalogController.blacklight_config.deep_copy }
-  let(:blacklight_solr) { RSolr.connect(Blacklight.connection_config.except(:adapter)) }
-
-  before(:each) do
-    @all_docs_query = ''
-    @no_docs_query = 'zzzzzzzzzzzz'
-    @single_word_query = 'include'
-    @mult_word_query = 'tibetan history'
-  #  f[format][]=Book&f[language_facet][]=English
-    @single_facet = {:format=>'Book'}
-    @multi_facets = {:format=>'Book', :language_facet=>'Tibetan'}
-    @bad_facet = {:format=>'666'}
-    @subject_search_params = {:commit=>"search", :search_field=>"subject", :action=>"index", :"controller"=>"catalog", :"rows"=>"10", :"q"=>"wome"}
-  end
-
-  # SPECS FOR SEARCH RESULTS FOR QUERY
-  describe 'Search Results', :integration => true do
-
-    let(:blacklight_config) { copy_of_catalog_config }
-    describe 'for a sample query returning results' do
-
-      before do
-        (@solr_response, @document_list) = subject.search_results(q: @all_docs_query)
-      end
-
-      it "uses the configured request handler" do
-        allow(blacklight_config).to receive(:default_solr_params).and_return({:qt => 'custom_request_handler'})
-        allow(blacklight_solr).to receive(:send_and_receive) do |path, params|
-          expect(path).to eq 'select'
-          expect(params[:params]['facet.field']).to eq ["format", "{!ex=pub_date_single}pub_date", "subject_topic_facet", "language_facet", "lc_1letter_facet", "subject_geo_facet", "subject_era_facet"]
-          expect(params[:params]["facet.query"]).to eq ["pub_date:[#{5.years.ago.year} TO *]", "pub_date:[#{10.years.ago.year} TO *]", "pub_date:[#{25.years.ago.year} TO *]"]
-          expect(params[:params]).to include('rows' => 10, 'qt'=>"custom_request_handler", 'q'=>"", "f.subject_topic_facet.facet.limit"=>21, 'sort'=>"score desc, pub_date_sort desc, title_sort asc")
-        end.and_return({'response'=>{'docs'=>[]}})
-        subject.search_results(q: @all_docs_query)
-      end
-
-      it 'has a @response.docs list of the same size as @document_list' do
-        expect(@solr_response.docs).to have(@document_list.length).docs
-      end
-
-      it 'has @response.docs list representing same documents as SolrDocuments in @document_list' do
-        @solr_response.docs.each_index do |index|
-          mash = @solr_response.docs[index]
-          solr_document = @document_list[index]
-
-          expect(Set.new(mash.keys)).to eq Set.new(solr_document.keys)
-
-          mash.keys.each do |key|
-            expect(mash[key]).to eq solr_document[key]
-          end
-        end
-      end
-    end
-
-    describe "for a query returning a grouped response" do
-      let(:blacklight_config) { copy_of_catalog_config }
-      before do
-        blacklight_config.default_solr_params[:group] = true
-        blacklight_config.default_solr_params[:'group.field'] = 'pub_date_sort'
-        (@solr_response, @document_list) = subject.search_results(q: @all_docs_query)
-      end
-
-      it "has an empty document list" do
-        expect(@document_list).to be_empty
-      end
-
-      it "returns a grouped response" do
-        expect(@solr_response).to be_a_kind_of Blacklight::Solr::Response::GroupResponse
-
-      end
-    end
-
-    describe "for a query returning multiple groups", integration: true do
-      let(:blacklight_config) { copy_of_catalog_config }
-
-      before do
-        allow(subject).to receive_messages grouped_key_for_results: 'title_sort'
-        blacklight_config.default_solr_params[:group] = true
-        blacklight_config.default_solr_params[:'group.field'] = ['pub_date_sort', 'title_sort']
-        (@solr_response, @document_list) = subject.search_results(q: @all_docs_query)
-      end
-
-      it "has an empty document list" do
-        expect(@document_list).to be_empty
-      end
-
-      it "returns a grouped response" do
-        expect(@solr_response).to be_a_kind_of Blacklight::Solr::Response::GroupResponse
-        expect(@solr_response.group_field).to eq "title_sort"
-      end
-    end
-
-
-    describe "for All Docs Query and One Facet" do
-      it 'has results' do
-        (solr_response, document_list) = subject.search_results(q: @all_docs_query, f: @single_facet)
-        expect(solr_response.docs).to have(document_list.size).results
-        expect(solr_response.docs).to have_at_least(1).result
-      end
-      # TODO: check that number of these results < number of results for all docs query
-      #   BUT can't: num docs isn't total, it's the num docs in the single SOLR response (e.g. 10)
-    end
-
-    describe "for Query Without Results and No Facet" do
-      it 'has no results and not raise error' do
-        (solr_response, document_list) = subject.search_results(q: @no_docs_query)
-        expect(document_list).to have(0).results
-        expect(solr_response.docs).to have(0).results
-      end
-    end
-
-    describe "for Query Without Results and One Facet" do
-      it 'has no results and not raise error' do
-        (solr_response, document_list) = subject.search_results(q: @no_docs_query, f: @single_facet)
-        expect(document_list).to have(0).results
-        expect(solr_response.docs).to have(0).results
-      end
-    end
-
-    describe "for All Docs Query and Bad Facet" do
-      it 'has no results and not raise error' do
-        (solr_response, document_list) = subject.search_results(q: @all_docs_query, f: @bad_facet)
-        expect(document_list).to have(0).results
-        expect(solr_response.docs).to have(0).results
-      end
-    end
-  end  # Search Results
-
-
-  # SPECS FOR SEARCH RESULTS FOR FACETS
-  describe 'Facets in Search Results for All Docs Query', :integration => true do
-
-    let(:blacklight_config) { copy_of_catalog_config }
-
-    before do
-      (solr_response, document_list) = subject.search_results(q: @all_docs_query)
-      @facets = solr_response.aggregations
-    end
-
-    it 'has more than one facet' do
-      expect(@facets).to have_at_least(1).facet
-    end
-    it 'has all facets specified in initializer' do
-      expect(@facets.keys).to include *blacklight_config.facet_fields.keys
-      expect(@facets.none? { |k, v| v.nil? }).to eq true
-    end
-
-    it 'has at least one value for each facet' do
-      @facets.each do |key, facet|
-        expect(facet.items).to have_at_least(1).hit
-      end
-    end
-    it 'has multiple values for at least one facet' do
-      has_mult_values = false
-      @facets.each do |key, facet|
-        if facet.items.size > 1
-          has_mult_values = true
-          break
-        end
-      end
-      expect(has_mult_values).to eq true
-    end
-    it 'has all value counts > 0' do
-      @facets.each do |key, facet|
-        facet.items.each do |facet_vals|
-          expect(facet_vals.hits).to be > 0
-        end
-      end
-    end
-  end # facet specs
-
-
-  # SPECS FOR SEARCH RESULTS FOR PAGING
-  describe 'Paging', :integration => true do
-    let(:blacklight_config) { copy_of_catalog_config }
-
-    it 'starts with first results by default' do
-      (solr_response, document_list) = subject.search_results(q: @all_docs_query)
-      expect(solr_response.params[:start].to_i).to eq 0
-    end
-    it 'has number of results (per page) set in initializer, by default' do
-      (solr_response, document_list) = subject.search_results(q: @all_docs_query)
-      expect(solr_response.docs).to have(blacklight_config[:default_solr_params][:rows]).items
-      expect(document_list).to have(blacklight_config[:default_solr_params][:rows]).items
-    end
-
-    it 'gets number of results per page requested' do
-      num_results = 3  # non-default value
-      (solr_response1, document_list1) = subject.search_results(q: @all_docs_query, per_page: num_results)
-      expect(document_list1).to have(num_results).docs
-      expect(solr_response1.docs).to have(num_results).docs
-    end
-
-    it 'gets number of rows requested' do
-      num_results = 4  # non-default value
-      (solr_response1, document_list1) = subject.search_results(q: @all_docs_query, rows: num_results)
-      expect(document_list1).to have(num_results).docs
-      expect(solr_response1.docs).to have(num_results).docs
-    end
-
-    it 'skips appropriate number of results when requested - default per page' do
-      page = 3
-      (solr_response2, document_list2) = subject.search_results(q: @all_docs_query, page: page)
-      expect(solr_response2.params[:start].to_i).to eq  blacklight_config[:default_solr_params][:rows] * (page-1)
-    end
-    it 'skips appropriate number of results when requested - non-default per page' do
-      page = 3
-      num_results = 3
-      (solr_response2a, document_list2a) = subject.search_results(q: @all_docs_query, per_page: num_results, page: page)
-      expect(solr_response2a.params[:start].to_i).to eq num_results * (page-1)
-    end
-
-    it 'has no results when prompted for page after last result' do
-      big = 5000
-      (solr_response3, document_list3) = subject.search_results(q: @all_docs_query, rows: big, page: big)
-      expect(document_list3).to have(0).docs
-      expect(solr_response3.docs).to have(0).docs
-    end
-
-    it 'shows first results when prompted for page before first result' do
-      # FIXME: should it show first results, or should it throw an error for view to deal w?
-      #   Solr throws an error for a negative start value
-      (solr_response4, document_list4) = subject.search_results(q: @all_docs_query, page: '-1')
-      expect(solr_response4.params[:start].to_i).to eq 0
-    end
-    it 'has results available when asked for more than are in response' do
-      big = 5000
-      (solr_response5, document_list5) = subject.search_results(q: @all_docs_query, rows: big, page: 1)
-      expect(solr_response5.docs).to have(document_list5.length).docs
-      expect(solr_response5.docs).to have_at_least(1).doc
-    end
-
-  end # page specs
-
-  # SPECS FOR SINGLE DOCUMENT REQUESTS
-  describe 'Get Document By Id', :integration => true do
-    before do
-      @doc_id = '2007020969'
-      @bad_id = "redrum"
-      @response2, @document = subject.fetch(@doc_id)
-    end
-
-    it "raises Blacklight::RecordNotFound for an unknown id" do
-      expect {
-        subject.fetch(@bad_id)
-      }.to raise_error(Blacklight::Exceptions::RecordNotFound)
-    end
-
-    it "uses a provided document request handler" do
-      allow(blacklight_config).to receive_messages(:document_solr_request_handler => 'document')
-      allow(blacklight_solr).to receive(:send_and_receive).with('select', kind_of(Hash)).and_return({'response'=>{'docs'=>[]}})
-      expect { subject.fetch(@doc_id)}.to raise_error Blacklight::Exceptions::RecordNotFound
-    end
-
-    it "uses a provided document solr path" do
-      allow(blacklight_config).to receive_messages(:document_solr_path => 'get')
-      allow(blacklight_solr).to receive(:send_and_receive).with('get', kind_of(Hash)).and_return({'response'=>{'docs'=>[]}})
-      expect { subject.fetch(@doc_id)}.to raise_error Blacklight::Exceptions::RecordNotFound
-    end
-
-    it "has a non-nil result for a known id" do
-      expect(@document).not_to be_nil
-    end
-    it "has a single document in the response for a known id" do
-      expect(@response2.docs.size).to eq 1
-    end
-    it 'has the expected value in the id field' do
-      expect(@document.id).to eq @doc_id
-    end
-    it 'has non-nil values for required fields set in initializer' do
-      expect(@document.fetch(blacklight_config.view_config(:show).display_type_field)).not_to be_nil
-    end
-  end
-
-# SPECS FOR SPELLING SUGGESTIONS VIA SEARCH
-  describe "Searches should return spelling suggestions", :integration => true do
-    it 'search results for just-poor-enough-query term should have (multiple) spelling suggestions' do
-      (solr_response, document_list) = subject.search_results(q: 'boo')
-      expect(solr_response.spelling.words).to include('bon')
-      expect(solr_response.spelling.words).to include('bod')  #for multiple suggestions
-    end
-
-    it 'search results for just-poor-enough-query term should have multiple spelling suggestions' do
-      (solr_response, document_list) = subject.search_results(q: 'politica')
-      expect(solr_response.spelling.words).to include('policy') # less freq
-      expect(solr_response.spelling.words).to include('politics') # more freq
-      expect(solr_response.spelling.words).to include('political') # more freq
-=begin
-      #  when we can have multiple suggestions
-      expect(solr_response.spelling.words).to_not include('policy') # less freq
-      solr_response.spelling.words).to include('politics') # more freq
-      solr_response.spelling.words).to include('political') # more freq
-=end
-    end
-
-    it "title search results for just-poor-enough query term should have spelling suggestions" do
-      (solr_response, document_list) = subject.search_results(q: 'yehudiyam', qt: 'search', :"spellcheck.dictionary" => "title")
-      expect(solr_response.spelling.words).to include('yehudiyim')
-    end
-
-    it "author search results for just-poor-enough-query term should have spelling suggestions" do
-      (solr_response, document_list) = subject.search_results(q: 'shirma', qt: 'search', :"spellcheck.dictionary" => "author")
-      expect(solr_response.spelling.words).to include('sharma')
-    end
-
-    it "subject search results for just-poor-enough-query term should have spelling suggestions" do
-      (solr_response, document_list) = subject.search_results(q: 'wome', qt: 'search', :"spellcheck.dictionary" => "subject")
-      expect(solr_response.spelling.words).to include('women')
-    end
-
-    it 'search results for multiple terms query with just-poor-enough-terms should have spelling suggestions for each term' do
-     skip
-#     get_spelling_suggestion("histo politica").should_not be_nil
-    end
-
-  end
-
-  describe "facet_limit_for" do
-    let(:blacklight_config) { copy_of_catalog_config }
-
-    it "returns specified value for facet_field specified" do
-      expect(subject.facet_limit_for("subject_topic_facet")).to eq blacklight_config.facet_fields["subject_topic_facet"].limit
-    end
-
-    it "facet_limit_hash should return hash with key being facet_field and value being configured limit" do
-      # facet_limit_hash has been removed from solrhelper in refactor. should it go back?
-      skip "facet_limit_hash has been removed from solrhelper in refactor. should it go back?"
-      expect(subject.facet_limit_hash).to eq blacklight_config[:facet][:limits]
-    end
-
-    it "handles no facet_limits in config" do
-      blacklight_config.facet_fields = {}
-      expect(subject.facet_limit_for("subject_topic_facet")).to be_nil
-    end
-
-    describe "for 'true' configured values" do
-      let(:blacklight_config) do
-        Blacklight::Configuration.new do |config|
-          config.add_facet_field "language_facet", limit: true
-        end
-      end
-      it "returns nil if no @response available" do
-        expect(subject.facet_limit_for("some_unknown_field")).to be_nil
-      end
-      it "gets from @response facet.limit if available" do        
-        @response = instance_double(Blacklight::Solr::Response, aggregations: { "language_facet" => double(limit: nil) })
-        subject.instance_variable_set(:@response, @response)
-        blacklight_config.facet_fields['language_facet'].limit = 10
-        expect(subject.facet_limit_for("language_facet")).to eq 10
-      end
-      it "gets the limit from the facet field in @response" do
-        @response = instance_double(Blacklight::Solr::Response, aggregations: { "language_facet" => double(limit: 16) })
-        subject.instance_variable_set(:@response, @response)
-        expect(subject.facet_limit_for("language_facet")).to eq 15
-      end
-      it "defaults to 10" do
-        expect(subject.facet_limit_for("language_facet")).to eq 10
-      end
-    end
-    
-    context 'for facet fields with a key that is different from the field name' do
-      let(:blacklight_config) do
-        Blacklight::Configuration.new do |config|
-          config.add_facet_field 'some_key', field: 'x', limit: true
-        end
-      end
-
-      it 'gets the limit from the facet field in the @response' do
-        response = instance_double(Blacklight::Solr::Response, aggregations: { 'x' => double(limit: 16) })
-        subject.instance_variable_set(:@response, response)
-        expect(subject.facet_limit_for('some_key')).to eq 15
-      end
-    end
-  end
-
-# TODO:  more complex queries!  phrases, offset into search results, non-latin, boosting(?)
-#  search within query building (?)
-#  search + facets (search done first; facet selected first, both selected)
-
-# TODO: maybe eventually check other types of solr requests
-#  more like this
-#  nearby on shelf
-  it "raises 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.repository.search }.to raise_exception(/Unable to connect to Solr instance/)
-  end
-
-  describe "grouped_key_for_results" do
-    it "pulls the grouped key out of the config" do
-      blacklight_config.index.group = 'xyz'
-      expect(subject.grouped_key_for_results).to eq('xyz')
-    end 
-  end
-
-  describe "#get_previous_and_next_documents_for_search" do
-    let(:pre_query) { SearchHelperTestClass.new blacklight_config, blacklight_solr }
-    before do
-      @full_response, @all_docs = pre_query.search_results(q: '', per_page: '100')
-    end
-
-    it "returns the previous and next documents for a search" do
-      response, docs = subject.get_previous_and_next_documents_for_search(4, :q => '')
-
-      expect(docs.first.id).to eq @all_docs[3].id
-      expect(docs.last.id).to eq @all_docs[5].id
-    end
-
-    it "returns only the next document if the counter is 0" do
-      response, docs = subject.get_previous_and_next_documents_for_search(0, :q => '')
-
-      expect(docs.first).to be_nil
-      expect(docs.last.id).to eq @all_docs[1].id
-    end
-
-    it "returns only the previous document if the counter is the total number of documents" do
-      response, docs = subject.get_previous_and_next_documents_for_search(@full_response.total - 1, :q => '')
-      expect(docs.first.id).to eq @all_docs.slice(-2).id
-      expect(docs.last).to be_nil
-    end
-
-    it "returns an array of nil values if there is only one result" do
-      response, docs = subject.get_previous_and_next_documents_for_search(0, :q => 'id:2007020969')
-      expect(docs.last).to be_nil
-      expect(docs.first).to be_nil
-    end
-
-    it 'allows the query parameters to be customized using configuration' do
-      blacklight_config.document_pagination_params[:fl] = 'id,format'
-
-      response, docs = subject.get_previous_and_next_documents_for_search(0, :q => '')
-
-      expect(docs.last.to_h).to eq @all_docs[1].to_h.slice('id', 'format')
-    end
-  end
-end

data/spec/controllers/saved_searches_controller_spec.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-describe SavedSearchesController do
-  routes { Blacklight::Engine.routes }
-
-  before(:all) do
-    @one = Search.create
-    @two = Search.create
-    @three = Search.create
-  end
-
-  before(:each) do
-    @user = User.create! :email => 'test@example.com', :password => 'abcd12345', :password_confirmation => 'abcd12345'
-    sign_in @user  
-  end
-
-  describe "save" do
-    it "lets you save a search" do
-      request.env["HTTP_REFERER"] = "where_i_came_from"
-      session[:history] = [@one.id]
-      post :save, params: { id: @one.id }
-      expect(response).to redirect_to "where_i_came_from"
-    end
-
-    it "does not let you save a search that isn't in your search history" do
-      session[:history] = [@one.id]
-      expect {
-        post :save, params: { id: @two.id }
-      }.to raise_error ActiveRecord::RecordNotFound
-    end
-  end
-end

data/spec/controllers/suggest_controller_spec.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-describe SuggestController do
-  routes { Blacklight::Engine.routes }
-  describe 'GET index' do
-    it 'returns JSON' do
-      get :index, params: { format: 'json' }
-      expect(response.body).to eq [].to_json
-    end
-    it 'returns suggestions' do
-      get :index, params: { format: 'json', q: 'new' }
-      json = JSON.parse(response.body)
-      expect(json.count).to eq 3
-      expect(json.first['term']).to eq 'new jersey'
-    end
-  end
-end

data/spec/features/saved_searches_spec.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-describe "Saved Searches" do
-  before do
-    sign_in 'user1'
-    visit root_path
-  end
-
-  it "is empty" do
-    click_link 'Saved Searches'
-    expect(page).to have_content 'You have no saved searches'
-  end
-
-  describe "with a saved search 'book'" do
-    before do
-      fill_in "q", with: 'book'
-      click_button 'search'
-      click_link "History"
-      click_button "save"
-      click_link 'Saved Searches'
-    end
-    it "shows saved searches" do
-      expect(page).to have_content 'Your saved searches'
-      expect(page).to have_content 'book'
-    end
-    it "deletes saved searches" do
-      click_button 'delete'
-      expect(page).to have_content 'Successfully removed that saved search.'
-    end
-
-    describe "and a saved search 'dang'" do
-      before do
-        visit root_path
-        fill_in "q", with: 'dang'
-        click_button 'search'
-        click_link "History"
-        click_button "save"
-        click_link 'Saved Searches'
-      end
-      it "clears the searhes" do
-        click_link "Clear Saved Searches"
-        expect(page).to have_content 'Cleared your saved searches.'
-        expect(page).to have_content 'You have no saved searches'
-      end
-    end
-  end
-end

data/spec/helpers/deprecated_url_helper_behavior_spec.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-describe Blacklight::DeprecatedUrlHelperBehavior do
-  around do |test|
-    Deprecation.silence(described_class) do
-      test.call
-    end
-  end
-
-  let(:parameter_class) { ActionController::Parameters }
-  let(:search_state) { Blacklight::SearchState.new(params, blacklight_config) }
-  let(:params) { parameter_class.new }
-  let(:blacklight_config) { Blacklight::Configuration.new }
-
-  before do
-    allow(helper).to receive(:search_state).and_return(search_state)
-    allow(helper).to receive(:params).and_return(params)
-    allow(helper).to receive(:blacklight_config).and_return(blacklight_config)
-    allow(controller).to receive(:search_state_class).and_return(Blacklight::SearchState)
-  end
-
-  describe '#params_for_search' do
-    it 'passes through to the search state' do
-      expect(helper.params_for_search).to eq search_state.params_for_search
-    end
-
-    it 'passes arguments through to the search state' do
-      expect(helper.params_for_search(merge: 1)).to eq search_state.params_for_search(merge: 1)
-    end
-
-    it 'generates a search state for the source parameters' do
-      expect(helper.params_for_search(parameter_class.new(source: 1), { merge: 1 })).to include merge: 1, source: 1
-    end
-  end
-
-  describe '#sanitize_search_params' do
-    it 'passes through to the parameter sanitizer' do
-      expect(helper.sanitize_search_params(a: 1)).to eq Blacklight::Parameters.sanitize(a: 1)
-    end
-  end
-
-  describe '#reset_search_params' do
-    let(:source_parameters) { parameter_class.new page: 1, counter: 10 }
-    it 'resets the current page and counter' do
-      expect(helper.reset_search_params(source_parameters)).to be_blank
-    end
-  end
-
-  describe '#add_facet_params' do
-    before do
-      blacklight_config.add_facet_field 'x'
-    end
-
-    let(:field) { blacklight_config.facet_fields['x'] }
-    let(:item) { true }
-
-    it 'passes through to the search state' do
-      expect(helper.add_facet_params(field, item)).to eq search_state.add_facet_params(field, item)
-    end
-
-    context "with source_parameters" do
-      let(:source_parameters) { parameter_class.new source: 1 }
-      it 'generates a search state for the source parameters' do
-        expect(helper.add_facet_params(field, item, source_parameters)).to include source: 1
-      end
-    end
-  end
-
-  describe '#add_facet_params_and_redirect' do
-    before do
-      blacklight_config.add_facet_field 'x'
-    end
-
-    let(:field) { blacklight_config.facet_fields['x'] }
-    let(:item) { true }
-
-    it 'passes through to the search state' do
-      expect(helper.add_facet_params_and_redirect(field, item)).to eq search_state.add_facet_params_and_redirect(field, item)
-    end
-  end
-
-  describe '#remove_facet_params' do
-    before do
-      blacklight_config.add_facet_field 'x'
-    end
-
-    let(:field) { blacklight_config.facet_fields['x'] }
-    let(:item) { true }
-
-    it 'passes through to the search state' do
-      expect(helper.remove_facet_params(field, item)).to eq search_state.remove_facet_params(field, item)
-    end
-
-    context "with source_parameters" do
-      let(:source_parameters) { parameter_class.new source: 1 }
-      it 'generates a search state for the source parameters' do
-        expect(helper.remove_facet_params(field, item, source_parameters)).to include source: 1
-      end
-    end
-  end
-end