blacklight 6.20.0 → 7.3.0

data/solr/conf/solrconfig.xml

@@ -1,411 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" ?>
-<!--
- Licensed to the Apache Software Foundation (ASF) under one or more
- contributor license agreements.  See the NOTICE file distributed with
- this work for additional information regarding copyright ownership.
- The ASF licenses this file to You under the Apache License, Version 2.0
- (the "License"); you may not use this file except in compliance with
- the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
--->
-
-<!--
- This is a stripped down config file used for a simple example...  
- It is *not* a good example to work from. 
--->
-<config>
-  
-  <!-- Controls what version of Lucene various components of Solr
-       adhere to.  Generally, you want to use the latest version to
-       get all bug fixes and improvements. It is highly recommended
-       that you fully re-index after changing this setting as it can
-       affect both how text is indexed and queried.
-  -->
-  <luceneMatchVersion>5.0.0</luceneMatchVersion>
-  
-  <lib dir="${solr.install.dir:../../../..}/contrib/analysis-extras/lib" />
-  <lib dir="${solr.install.dir:../../../..}/contrib/analysis-extras/lucene-libs" />
-
-  <directoryFactory name="DirectoryFactory" 
-                    class="${solr.directoryFactory:solr.NRTCachingDirectoryFactory}">
-  </directoryFactory> 
-
-  <codecFactory class="solr.SchemaCodecFactory"/>
-
-  <schemaFactory class="ClassicIndexSchemaFactory"/>
-
-
-  <dataDir>${solr.blacklight-core.data.dir:}</dataDir>
-  
-  <requestDispatcher handleSelect="true" >
-    <requestParsers enableRemoteStreaming="false" multipartUploadLimitInKB="2048" />
-  </requestDispatcher>
-  
-  <requestHandler name="/analysis/field" startup="lazy" class="solr.FieldAnalysisRequestHandler" />
-
-  <!-- config for the admin interface --> 
-  <admin>
-    <defaultQuery>*:*</defaultQuery>
-  </admin>
-
-  <!-- SearchHandler
-
-       http://wiki.apache.org/solr/SearchHandler
-
-       For processing Search Queries, the primary Request Handler
-       provided with Solr is "SearchHandler" It delegates to a sequent
-       of SearchComponents (see below) and supports distributed
-       queries across multiple shards
-    -->
-  <requestHandler name="search" class="solr.SearchHandler" default="true">
-    <!-- default values for query parameters can be specified, these
-         will be overridden by parameters in the request
-      -->
-     <lst name="defaults">
-       <str name="defType">dismax</str>
-       <str name="echoParams">explicit</str>
-       <int name="rows">10</int>
-
-       <str name="q.alt">*:*</str>
-       <str name="mm">2&lt;-1 5&lt;-2 6&lt;90%</str>
-
-       <!-- this qf and pf are used by default, if not otherwise specified by
-            client. The default blacklight_config will use these for the
-            "keywords" search. See the author_qf/author_pf, title_qf, etc 
-            below, which the default blacklight_config will specify for
-            those searches. You may also be interested in:
-            http://wiki.apache.org/solr/LocalParams
-       -->
-
-       <str name="qf">
-         title_unstem_search^100000
-         subtitle_unstem_search^50000
-         title_t^25000
-         subtitle_t^10000
-         title_addl_unstem_search^5000
-         title_addl_t^2500
-         title_added_entry_unstem_search^1500
-         title_added_entry_t^1250
-         subject_topic_unstem_search^1000
-         subject_unstem_search^750
-         subject_topic_facet^625
-         subject_t^500
-         author_unstem_search^250
-         author_addl_unstem_search^250
-         author_t^100
-         author_addl_t^50
-         subject_addl_unstem_search^250
-         subject_addl_t^50
-         title_series_unstem_search^25
-         title_series_t^10
-         isbn_t
-         text
-       </str>
-       <str name="pf">
-         title_unstem_search^1000000
-         subtitle_unstem_search^500000
-         title_t^250000
-         subtitle_t^100000
-         title_addl_unstem_search^50000
-         title_addl_t^25000
-         title_added_entry_unstem_search^15000
-         title_added_entry_t^12500
-         subject_topic_unstem_search^10000
-         subject_unstem_search^7500
-         subject_topic_facet^6250
-         subject_t^5000
-         author_unstem_search^2500
-         author_addl_unstem_search^2500
-         author_t^1000
-         author_addl_t^500
-         subject_addl_unstem_search^2500
-         subject_addl_t^500
-         title_series_unstem_search^250
-         title_series_t^100
-         text^10
-       </str>
-       <str name="author_qf">
-         author_unstem_search^200
-         author_addl_unstem_search^50
-         author_t^20
-         author_addl_t
-       </str>
-       <str name="author_pf">
-         author_unstem_search^2000
-         author_addl_unstem_search^500
-         author_t^200
-         author_addl_t^10
-       </str>
-       <str name="title_qf">
-         title_unstem_search^50000
-         subtitle_unstem_search^25000
-         title_addl_unstem_search^10000
-         title_t^5000
-         subtitle_t^2500
-         title_addl_t^100
-         title_added_entry_unstem_search^50
-         title_added_entry_t^10
-         title_series_unstem_search^5
-         title_series_t
-       </str>
-       <str name="title_pf">
-         title_unstem_search^500000
-         subtitle_unstem_search^250000
-         title_addl_unstem_search^100000
-         title_t^50000
-         subtitle_t^25000
-         title_addl_t^1000
-         title_added_entry_unstem_search^500
-         title_added_entry_t^100
-         title_series_t^50
-         title_series_unstem_search^10
-       </str>
-       <str name="subject_qf">
-         subject_topic_unstem_search^200
-         subject_unstem_search^125
-         subject_topic_facet^100
-         subject_t^50
-         subject_addl_unstem_search^10
-         subject_addl_t
-       </str>
-       <str name="subject_pf">
-         subject_topic_unstem_search^2000
-         subject_unstem_search^1250
-         subject_t^1000
-         subject_topic_facet^500
-         subject_addl_unstem_search^100
-         subject_addl_t^10
-       </str>
-       
-       <int name="ps">3</int>
-       <float name="tie">0.01</float>
-
-       <!-- NOT using marc_display because it is large and will slow things down for search results -->
-       <str name="fl">
-         id, 
-         score,
-         author_display,
-         author_vern_display, 
-         format, 
-         isbn_t, 
-         language_facet, 
-         lc_callnum_display,
-         material_type_display, 
-         published_display,
-         published_vern_display,
-         pub_date,
-         title_display,
-         title_vern_display,
-         subject_topic_facet,
-         subject_geo_facet,
-         subject_era_facet,
-         subtitle_display,
-         subtitle_vern_display,
-         url_fulltext_display,
-         url_suppl_display,
-       </str>
-
-       <str name="facet">true</str>
-       <str name="facet.mincount">1</str>
-       <str name="facet.field">format</str>
-       <str name="facet.field">lc_1letter_facet</str>
-       <str name="facet.field">lc_alpha_facet</str>
-       <str name="facet.field">lc_b4cutter_facet</str>
-       <str name="facet.field">language_facet</str>
-       <str name="facet.field">pub_date</str>
-       <str name="facet.field">subject_era_facet</str>
-       <str name="facet.field">subject_geo_facet</str>
-       <str name="facet.field">subject_topic_facet</str>
-       
-       <str name="spellcheck">true</str>
-       <str name="spellcheck.dictionary">default</str>
-       <str name="spellcheck.onlyMorePopular">true</str>
-       <str name="spellcheck.extendedResults">true</str>
-       <str name="spellcheck.collate">false</str>
-       <str name="spellcheck.count">5</str>
-
-     </lst>
-    <!-- In addition to defaults, "appends" params can be specified
-         to identify values which should be appended to the list of
-         multi-val params from the query (or the existing "defaults").
-      -->
-    <!-- In this example, the param "fq=instock:true" would be appended to
-         any query time fq params the user may specify, as a mechanism for
-         partitioning the index, independent of any user selected filtering
-         that may also be desired (perhaps as a result of faceted searching).
-
-         NOTE: there is *absolutely* nothing a client can do to prevent these
-         "appends" values from being used, so don't use this mechanism
-         unless you are sure you always want it.
-      -->
-    <!--
-       <lst name="appends">
-         <str name="fq">inStock:true</str>
-       </lst>
-      -->
-    <!-- "invariants" are a way of letting the Solr maintainer lock down
-         the options available to Solr clients.  Any params values
-         specified here are used regardless of what values may be specified
-         in either the query, the "defaults", or the "appends" params.
-
-         In this example, the facet.field and facet.query params would
-         be fixed, limiting the facets clients can use.  Faceting is
-         not turned on by default - but if the client does specify
-         facet=true in the request, these are the only facets they
-         will be able to see counts for; regardless of what other
-         facet.field or facet.query params they may specify.
-
-         NOTE: there is *absolutely* nothing a client can do to prevent these
-         "invariants" values from being used, so don't use this mechanism
-         unless you are sure you always want it.
-      -->
-    <!--
-       <lst name="invariants">
-         <str name="facet.field">cat</str>
-         <str name="facet.field">manu_exact</str>
-         <str name="facet.query">price:[* TO 500]</str>
-         <str name="facet.query">price:[500 TO *]</str>
-       </lst>
-      -->
-    <!-- If the default list of SearchComponents is not desired, that
-         list can either be overridden completely, or components can be
-         prepended or appended to the default list.  (see below)
-      -->
-    <!--
-       <arr name="components">
-         <str>nameOfCustomComponent1</str>
-         <str>nameOfCustomComponent2</str>
-       </arr>
-      -->
-    <arr name="last-components">
-      <str>spellcheck</str>
-    </arr>
-      
-  </requestHandler>
-
-  <!-- for requests to get a single document; use id=666 instead of q=id:666 -->
-  <requestHandler name="document" class="solr.SearchHandler" >
-    <lst name="defaults">
-      <str name="echoParams">all</str>
-      <str name="fl">*</str>
-      <str name="rows">1</str>
-      <str name="q">{!term f=id v=$id}</str> <!-- use id=666 instead of q=id:666 -->
-    </lst>
-  </requestHandler>
-
-<!-- Spell Check
-
-        The spell check component can return a list of alternative spelling
-        suggestions.  
-
-        http://wiki.apache.org/solr/SpellCheckComponent
-     -->
-  <searchComponent name="spellcheck" class="solr.SpellCheckComponent">
-
-    <str name="queryAnalyzerFieldType">textSpell</str>
-
-    <!-- Multiple "Spell Checkers" can be declared and used by this
-         component
-      -->
-
-    <!-- a spellchecker built from a field of the main index, and
-         written to disk
-      -->
-    <lst name="spellchecker">
-      <str name="name">default</str>
-      <str name="field">spell</str>
-      <str name="spellcheckIndexDir">./spell</str>
-      <str name="buildOnOptimize">true</str>
-    </lst>
-    <lst name="spellchecker">
-      <str name="name">author</str>
-      <str name="field">author_spell</str>
-      <str name="spellcheckIndexDir">./spell_author</str>
-      <str name="accuracy">0.7</str>
-      <str name="buildOnOptimize">true</str>
-    </lst>
-    <lst name="spellchecker">
-      <str name="name">subject</str>
-      <str name="field">subject_spell</str>
-      <str name="spellcheckIndexDir">./spell_subject</str>
-      <str name="accuracy">0.7</str>
-      <str name="buildOnOptimize">true</str>
-    </lst>
-    <lst name="spellchecker">
-      <str name="name">title</str>
-      <str name="field">title_spell</str>
-      <str name="spellcheckIndexDir">./spell_title</str>
-      <str name="accuracy">0.7</str>
-      <str name="buildOnOptimize">true</str>
-    </lst>
-
-    <!-- a spellchecker that uses a different distance measure -->
-    <!--
-       <lst name="spellchecker">
-         <str name="name">jarowinkler</str>
-         <str name="field">spell</str>
-         <str name="distanceMeasure">
-           org.apache.lucene.search.spell.JaroWinklerDistance
-         </str>
-         <str name="spellcheckIndexDir">spellcheckerJaro</str>
-       </lst>
-     -->
-
-    <!-- a spellchecker that use an alternate comparator 
-
-         comparatorClass be one of:
-          1. score (default)
-          2. freq (Frequency first, then score)
-          3. A fully qualified class name
-      -->
-    <!--
-       <lst name="spellchecker">
-         <str name="name">freq</str>
-         <str name="field">lowerfilt</str>
-         <str name="spellcheckIndexDir">spellcheckerFreq</str>
-         <str name="comparatorClass">freq</str>
-         <str name="buildOnCommit">true</str>
-      -->
-
-    <!-- A spellchecker that reads the list of words from a file -->
-    <!--
-       <lst name="spellchecker">
-         <str name="classname">solr.FileBasedSpellChecker</str>
-         <str name="name">file</str>
-         <str name="sourceLocation">spellings.txt</str>
-         <str name="characterEncoding">UTF-8</str>
-         <str name="spellcheckIndexDir">spellcheckerFile</str>
-       </lst>
-      -->
-  </searchComponent>
-
-  <searchComponent name="suggest" class="solr.SuggestComponent">
-    <lst name="suggester">
-      <str name="name">mySuggester</str>
-      <str name="lookupImpl">FuzzyLookupFactory</str>
-      <str name="suggestAnalyzerFieldType">textSuggest</str>
-      <str name="buildOnCommit">true</str>
-      <str name="field">suggest</str>
-    </lst>
-  </searchComponent>
-
-  <requestHandler name="/suggest" class="solr.SearchHandler" startup="lazy">
-    <lst name="defaults">
-      <str name="suggest">true</str>
-      <str name="suggest.count">5</str>
-      <str name="suggest.dictionary">mySuggester</str>
-    </lst>
-    <arr name="components">
-      <str>suggest</str>
-    </arr>
-  </requestHandler>
-
-</config>
-

data/spec/controllers/blacklight/search_helper_spec.rb

@@ -1,489 +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, :repository, :search_state
-
-    def initialize blacklight_config, conn, state
-      self.blacklight_config = blacklight_config
-      self.repository = Blacklight::Solr::Repository.new(blacklight_config)
-      self.repository.connection = conn
-      self.search_state = search_state
-    end
-
-    def params
-      {}
-    end
-  end
-
-  subject { SearchHelperTestClass.new blacklight_config, blacklight_solr, state }
-
-  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)) }
-  let(:state) { {} }
-
-  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
-
-  describe 'Get multiple documents By Id', integration: true do
-    let(:doc_id) { '2007020969' }
-    let(:bad_id) { 'redrum' }
-    let(:response) { subject.fetch([doc_id]).first }
-
-    before do
-      blacklight_config.fetch_many_document_params = { fl: 'id,format' }
-    end
-
-    it 'has the expected value in the id field' do
-      expect(response.documents.first.id).to eq doc_id
-    end
-
-    it 'returns all the requested fields' do
-      expect(response.documents.first['format']).to eq 'Book'
-    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, state }
-    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