blacklight 4.9.0 → 5.0.0.pre1

data/spec/lib/blacklight_spec.rb

@@ -2,43 +2,35 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe Blacklight do
-
-  around :each do |example|
-    Deprecation.silence(Blacklight) do
-      example.run
-    end
-  end
   
   context "locate_path" do
     
     it "should find app/controllers/application_controller.rb" do
       result = Blacklight.locate_path 'app', 'controllers', 'application_controller.rb'
-      expect(result).not_to eq(nil)
+      result.should_not == nil
     end
     
     it "should not find blah.rb" do
       result = Blacklight.locate_path 'blah.rb'
-      expect(result).to eq(nil)
+      result.should == nil
     end
     
   end
   
   context 'root' do
 
-    before(:all) do
-      @blroot = File.expand_path(File.join(__FILE__, '..', '..', '..' ))
-    end
+    let(:blroot) { File.expand_path(File.join(__FILE__, '..', '..', '..' )) }
 
     it 'should return the full path to the BL plugin' do
-      expect(Blacklight.root).to eq(@blroot)
+      Blacklight.root.should == blroot
     end
     
     it 'should return the full path to the model directory' do
-      expect(Blacklight.models_dir).to eq(@blroot + "/app/models")
+      Blacklight.models_dir.should == blroot + "/app/models"
     end
 
     it 'should return the full path to the controllers directory' do
-      expect(Blacklight.controllers_dir).to eq(@blroot + "/app/controllers")
+      Blacklight.controllers_dir.should == blroot + "/app/controllers"
     end
 
   end

data/spec/lib/blacklight_user_spec.rb

@@ -4,10 +4,6 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 describe "Blacklight::User" do
 
   subject { User.create! :email => 'xyz@example.com', :password => 'xyz12345' }
-  
-  around(:each) do |example|
-    Deprecation.silence(Blacklight::User) { example.run }
-  end
 
   def mock_bookmark document_id
     Bookmark.new :document_id => document_id
@@ -26,7 +22,7 @@ describe "Blacklight::User" do
 
   it "should know if it has a bookmarked document" do
     subject.bookmarks << mock_bookmark(1)
-    expect(subject.document_is_bookmarked?(1)).to eq true
+    expect(subject.document_is_bookmarked?(1)).to be_true
   end
 
   it "should be able to create bookmarks in batches" do
@@ -35,7 +31,7 @@ describe "Blacklight::User" do
     @md3 = { :document_id => 3 }
 
     subject.documents_to_bookmark= [@md1,@md2,@md3]
-    expect(subject.bookmarks.size).to eq(3)
+    expect(subject.bookmarks).to have(3).bookmarks
     expect(subject.bookmarked_document_ids).to include("1","2","3")
 
   end
@@ -44,19 +40,19 @@ describe "Blacklight::User" do
     subject.bookmarks << mock_bookmark(1)
 
     @md1 = { :document_id => 1 }
-    expect(subject.bookmarks).not_to receive(:create).with(@md1)
+    subject.bookmarks.should_not_receive(:create).with(@md1)
 
     subject.bookmarks.push(mock_bookmark(1))
     subject.documents_to_bookmark=[@md1]
   end
 
   it "should know if it doesn't have a search" do
-    expect(subject.has_searches?).to eq(false)
+    subject.has_searches?.should == false
   end
 
   it "should know if it has a search" do
     subject.searches << Search.new
-    expect(subject.has_searches?).to eq(true)
+    subject.has_searches?.should == true
   end
 
 end    

data/spec/lib/facet_paginator_spec.rb

@@ -4,68 +4,76 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe 'Blacklight::Solr::FacetPaginator' do
+  before(:all) do
+    require 'yaml'
+    @seven_facet_values = YAML::load("--- \n- !ruby/object:Blacklight::SolrResponse::Facets::FacetItem \n  hits: 792\n  value: Book\n- !ruby/object:Blacklight::SolrResponse::Facets::FacetItem \n  hits: 65\n  value: Musical Score\n- !ruby/object:Blacklight::SolrResponse::Facets::FacetItem \n  hits: 58\n  value: Serial\n- !ruby/object:Blacklight::SolrResponse::Facets::FacetItem \n  hits: 48\n  value: Musical Recording\n- !ruby/object:Blacklight::SolrResponse::Facets::FacetItem \n  hits: 37\n  value: Microform\n- !ruby/object:Blacklight::SolrResponse::Facets::FacetItem \n  hits: 27\n  value: Thesis\n- !ruby/object:Blacklight::SolrResponse::Facets::FacetItem \n  hits: 0\n  value: \n")
+    @six_facet_values = @seven_facet_values.slice(1,6)
+    @limit = 6
 
-  let(:f1) { Blacklight::SolrResponse::Facets::FacetItem.new(hits: '792', value: 'Book') }
-  let(:f2) { Blacklight::SolrResponse::Facets::FacetItem.new(hits: '65', value: 'Musical Score') }
-  let(:f3) { Blacklight::SolrResponse::Facets::FacetItem.new(hits: '58', value: 'Serial') }
-  let(:f4) { Blacklight::SolrResponse::Facets::FacetItem.new(hits: '48', value: 'Musical Recording') }
-  let(:f5) { Blacklight::SolrResponse::Facets::FacetItem.new(hits: '37', value: 'Microform') }
-  let(:f6) { Blacklight::SolrResponse::Facets::FacetItem.new(hits: '27', value: 'Thesis') }
-  let(:f7) { Blacklight::SolrResponse::Facets::FacetItem.new(hits: '0') }
-  let(:seven_facet_values) { [f1, f2, f3, f4, f5, f6, f7] }
-  let(:six_facet_values) { [f1, f2, f3, f4, f5, f6] }
-  let(:limit) { 6 }
-
-  context 'on the first page of two pages' do
-    subject { Blacklight::Solr::FacetPaginator.new(seven_facet_values, limit: limit) }
-    it { should be_first_page }
-    it { should_not be_last_page }
-    its(:current_page) { should eq 1 }
-    its(:prev_page) { should be_nil }
-    its(:next_page) { should eq 2 }
-    it 'should limit items to limit, if limit is smaller than items.length' do
-      expect(subject.items.size).to eq 6
-    end
+    @sort_key = Blacklight::Solr::FacetPaginator.request_keys[:sort]
+    @page_key = Blacklight::Solr::FacetPaginator.request_keys[:page]
   end
-
-  context 'on the last page of two pages' do
-    subject { Blacklight::Solr::FacetPaginator.new(seven_facet_values, offset: 6, limit: limit) }
-    it { should_not be_first_page }
-    it { should be_last_page }
-    its(:current_page) { should eq 2 }
-    its(:prev_page) { should eq 1 }
-    its(:next_page) { should be_nil }
-    it 'should return all items when limit is greater than items.length' do
-      expect(subject.items.size).to eq 1
+  context 'when there are limit+1 results' do
+    before(:each) do
+      @paginator = Blacklight::Solr::FacetPaginator.new(@seven_facet_values, :limit => 6)
     end
+    it 'should have next' do
+      @paginator.should be_has_next
+    end
+
   end
+  it 'should not have next when there are fewer results' do
+    paginator = Blacklight::Solr::FacetPaginator.new(@six_facet_values, :offset => 0, :limit => @limit)
 
-  context 'on the first page of one page' do
-    subject { Blacklight::Solr::FacetPaginator.new(six_facet_values, offset: 0, limit: limit) }
-    it { should be_first_page }
-    it { should be_last_page }
+    paginator.should_not be_has_next
   end
+  context 'when offset is greater than 0' do
+    before(:each) do
+      @offset = 100
+      @paginator = Blacklight::Solr::FacetPaginator.new(@seven_facet_values, :offset => @offset, :limit => @limit)
+    end
+  
+    it 'should have previous' do    
+      @paginator.should be_has_previous
+    end
 
-  describe "params_for_resort_url" do
-    let(:sort_key) { Blacklight::Solr::FacetPaginator.request_keys[:sort] }
-    let(:page_key) { Blacklight::Solr::FacetPaginator.request_keys[:page] }
-    let(:paginator) { Blacklight::Solr::FacetPaginator.new(seven_facet_values, offset: 100, limit: limit, sort: 'index') }
+  end
+  it 'should not have previous when offset is 0' do
+    paginator = Blacklight::Solr::FacetPaginator.new(@seven_facet_values, :offset => 0, :limit => @limit)
 
-    it 'should know a manually set sort, and produce proper sort url' do
-        expect(paginator.sort).to eq 'index'
+    paginator.should_not be_has_previous
+  end
+  it 'should know a manually set sort, and produce proper sort url' do
+      paginator = Blacklight::Solr::FacetPaginator.new(@seven_facet_values, :offset => 100, :limit => @limit, :sort => 'index')
 
-        click_params = paginator.params_for_resort_url('count', {})
+      paginator.sort.should == 'index'
+      
+      click_params = paginator.params_for_resort_url('count', {})
 
-        expect(click_params[ sort_key ]).to eq 'count'
-        expect(click_params[ page_key ]).to be_nil
-    end
+      click_params[ @sort_key ].should == 'count'
+      click_params[ @page_key ].should be_nil
   end
-
-  context "for a nil :limit" do
-    subject { Blacklight::Solr::FacetPaginator.new(seven_facet_values, offset: 0, limit: nil) }
-    it "should return all the items" do
-      expect(subject.items).to eq seven_facet_values
+  it 'should limit items to limit, if limit is smaller than items.length' do
+    paginator = Blacklight::Solr::FacetPaginator.new(@seven_facet_values, :offset => 100, :limit => 6, :sort => 'index')
+    paginator.items.length.should == 6
+  end
+  it 'should return all items when limit is greater than items.length' do
+    paginator = Blacklight::Solr::FacetPaginator.new(@six_facet_values, :offset => 100, :limit => 6, :sort => 'index')
+    paginator.items.length.should == 6
+  end
+  describe "for a nil :limit" do
+    before(:all) do
+      @paginator = Blacklight::Solr::FacetPaginator.new(@seven_facet_values, :offset => 100, :limit => nil, :sort => 'index')
+    end
+    it 'should return all items' do
+      @paginator.items.should == @seven_facet_values      
+    end
+    it 'should not has_next?' do
+      @paginator.should_not be_has_next
+    end
+    it 'should not has_previous?' do
+      @paginator.should_not be_has_previous
     end
   end
-
+  
 end

data/spec/lib/search_fields_spec.rb

@@ -21,12 +21,12 @@ describe Blacklight::SearchFields do
 
   before(:each) do  
     @search_field_obj = MockConfig.new
-    allow(@search_field_obj).to receive(:blacklight_config).and_return(@config)
+    @search_field_obj.stub(:blacklight_config).and_return(@config)
   end
 
   it "should return search field list with calculated :label when needed" do
      @search_field_obj.search_field_list.each do |hash|        
-        expect(hash.label).not_to be_blank
+        hash.label.should_not be_blank
      end
   end
 
@@ -42,30 +42,30 @@ describe Blacklight::SearchFields do
        argument = select_arguments[index]
        config_hash = @search_field_obj.search_field_list[index]
 
-       expect(argument.length).to eq(2)
-       expect(argument[0]).to eq(config_hash.label)
-       expect(argument[1]).to eq(config_hash.key)
+       argument.length.should == 2
+       argument[0].should == config_hash.label
+       argument[1].should == config_hash.key
     end    
   end
 
   it "should not include fields in select if :display_in_simple_search=>false" do
     select_arguments = @search_field_obj.search_field_options_for_select
 
-    expect(select_arguments).not_to include(["No Display", "no_display"])
+    select_arguments.should_not include(["No Display", "no_display"])
   end
 
   
 
   it "should lookup field definitions by key" do
-    expect(@search_field_obj.search_field_def_for_key("title").key).to eq("title")
+    @search_field_obj.search_field_def_for_key("title").key.should == "title"
   end
 
   it "should find label by key" do
-    expect(@search_field_obj.label_for_search_field("title")).to eq("Title")
+    @search_field_obj.label_for_search_field("title").should == "Title"
   end
 
   it "should supply default label for key not found" do
-    expect(@search_field_obj.label_for_search_field("non_existent_key")).to eq("Keyword")
+    @search_field_obj.label_for_search_field("non_existent_key").should == "Keyword"
   end
 
   describe "for unspecified :key" do
@@ -73,10 +73,10 @@ describe Blacklight::SearchFields do
       @bad_config = MockConfig.new
     end
     it "should raise exception on #search_field_list" do
-      expect { allow(@bad_config).to receive(:blacklight_config).and_return(Blacklight::Configuration.new { |config|
+      lambda { @bad_config.stub(:blacklight_config).and_return(Blacklight::Configuration.new { |config|
            config.add_search_field :label => 'All Fields', :qt => 'all_fields'
            config.add_search_field 'title', :qt => 'title_search'
-      })   }.to raise_error
+      })   }.should raise_error
     end
   end
 
@@ -85,11 +85,11 @@ describe Blacklight::SearchFields do
       @bad_config = MockConfig.new
     end
     it "should raise on #search_field_list" do
-      expect { allow(@bad_config).to receive(:blacklight_config).and_return(Blacklight::Configuration.new { |config|
+      lambda { @bad_config.stub(:blacklight_config).and_return(Blacklight::Configuration.new { |config|
         config.add_search_field 'my_key', :label => 'All Fields'
         config.add_search_field 'my_key', :label => 'title'
 
-      }) }.to raise_error
+      }) }.should raise_error
     end
   end
   

data/spec/lib/solr_helper_spec.rb

@@ -1,11 +1,6 @@
 # -*- encoding : utf-8 -*-
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-require 'marc'
 
-
-
-
-=begin
 # 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
@@ -13,7 +8,7 @@ require 'marc'
 #  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?)
-=end
+#
 describe 'Blacklight::SolrHelper' do
 
   # SolrHelper is a controller layer mixin, which depends
@@ -26,15 +21,13 @@ describe 'Blacklight::SolrHelper' do
   def blacklight_config
     @config ||= CatalogController.blacklight_config
   end
-
+  
   def blacklight_config=(config)
     @config = config
   end
 
   def blacklight_solr
-    Deprecation.silence(Blacklight) {
-      Blacklight.solr
-    }
+    Blacklight.solr
   end
 
   include Blacklight::SolrHelper
@@ -51,25 +44,25 @@ describe 'Blacklight::SolrHelper' do
     @subject_search_params = {:commit=>"search", :search_field=>"subject", :action=>"index", :"controller"=>"catalog", :"rows"=>"10", :"q"=>"wome"}
   end
 
-
+  
 
   # SPECS for actual search parameter generation
   describe "solr_search_params" do
     it "allows customization of solr_search_params_logic" do
         # Normally you'd include a new module into (eg) your CatalogController
-        # but a sub-class defininig it directly is simpler for test.
+        # but a sub-class defininig it directly is simpler for test.             
         def add_foo_to_solr_params(solr_params, user_params)
-          solr_params[:foo] = "TESTING"
+          solr_params[:wt] = "TESTING"
         end
-
-
+ 
+                         
         self.solr_search_params_logic += [:add_foo_to_solr_params]
-
-
-        expect(self.solr_search_params[:foo]).to eq("TESTING")
+        
+        
+        self.solr_search_params[:wt].should == "TESTING"                
     end
-
-
+    
+    
     describe 'for an entirely empty search' do
        def params
           {}
@@ -78,40 +71,40 @@ describe 'Blacklight::SolrHelper' do
         @produced_params = self.solr_search_params
       end
       it 'should not have a q param' do
-        expect(@produced_params[:q]).to be_nil
-        expect(@produced_params["spellcheck.q"]).to be_nil
+        @produced_params[:q].should be_nil
+        @produced_params["spellcheck.q"].should be_nil
       end
       it 'should have default rows' do
-        expect(@produced_params[:rows]).to eq(10)
+        @produced_params[:rows].should == 10
       end
       it 'should have default facet fields' do
         # remove local params from the facet.field
-        expect(@produced_params[:"facet.field"].map { |x| x.gsub(/\{![^}]+\}/, '') }).to eq(blacklight_config.facet_fields_to_add_to_solr)
+        @produced_params[:"facet.field"].map { |x| x.gsub(/\{![^}]+\}/, '') }.should == blacklight_config.facet_fields_to_add_to_solr
       end
-
+      
       it "should have default qt"  do
-        expect(@produced_params[:qt]).to eq("search")
+        @produced_params[:qt].should == "search"
       end
       it "should have no fq" do
-        expect(@produced_params[:phrase_filters]).to be_blank
-        expect(@produced_params[:fq]).to be_blank
+        @produced_params[:phrase_filters].should be_blank
+        @produced_params[:fq].should be_blank
       end
     end
 
 
-    describe "for an empty string search" do
-      it "should return empty string q in solr parameters" do
+    describe "for an empty string search" do      
+      it "should return empty string q in solr parameters" do        
         solr_params = solr_search_params(:q => "")
-        expect(solr_params[:q]).to eq("")
-        expect(solr_params["spellcheck.q"]).to eq("")
+        solr_params[:q].should == ""
+        solr_params["spellcheck.q"].should == ""
       end
     end
 
-    describe "for request params also passed in as argument" do
-      it "should only have one 'q' key, as symbol" do
-        solr_params = solr_search_params( :q => "some query" )
-        expect(solr_params.keys).to include(:q)
-        expect(solr_params.keys).not_to include("q")
+    describe "for request params also passed in as argument" do      
+      it "should only have one value for the key 'q' regardless if a symbol or string" do        
+        solr_params = solr_search_params( :q => "some query", 'q' => 'another value' )
+        solr_params[:q].should == 'some query'
+        solr_params['q'].should == 'some query'
       end
     end
 
@@ -121,11 +114,11 @@ describe 'Blacklight::SolrHelper' do
 
         solr_params = solr_search_params(:f => @single_facet)
 
-        expect(solr_params[:q]).to be_blank
-        expect(solr_params["spellcheck.q"]).to be_blank
+        solr_params[:q].should be_blank
+        solr_params["spellcheck.q"].should be_blank
 
         @single_facet.each_value do |value|
-          expect(solr_params[:fq]).to include("{!raw f=#{@single_facet.keys[0]}}#{value}")
+          solr_params[:fq].should include("{!raw f=#{@single_facet.keys[0]}}#{value}")
         end
       end
     end
@@ -138,7 +131,7 @@ describe 'Blacklight::SolrHelper' do
           value_list ||= []
           value_list = [value_list] unless value_list.respond_to? :each
           value_list.each do |value|
-            expect(solr_params[:fq]).to include("{!raw f=#{facet_field}}#{value}"  )
+            solr_params[:fq].should include("{!raw f=#{facet_field}}#{value}"  )
           end
         end
 
@@ -153,10 +146,10 @@ describe 'Blacklight::SolrHelper' do
           value_list ||= []
           value_list = [value_list] unless value_list.respond_to? :each
           value_list.each do |value|
-            expect(solr_params[:fq]).to include("{!raw f=#{facet_field}}#{value}"  )
+            solr_params[:fq].should include("{!raw f=#{facet_field}}#{value}"  )
           end
         end
-        expect(solr_params[:q]).to eq(@mult_word_query)
+        solr_params[:q].should == @mult_word_query
       end
     end
 
@@ -167,91 +160,80 @@ describe 'Blacklight::SolrHelper' do
       end
 
       it "should use the raw handler for strings" do
-        expect(facet_value_to_fq_string("facet_name", "my value")).to  eq("{!raw f=facet_name}my value")
+        facet_value_to_fq_string("facet_name", "my value").should  == "{!raw f=facet_name}my value" 
       end
 
       it "should pass booleans through" do
-        expect(facet_value_to_fq_string("facet_name", true)).to  eq("facet_name:true")
+        facet_value_to_fq_string("facet_name", true).should  == "facet_name:true"
       end
 
       it "should pass boolean-like strings through" do
-        expect(facet_value_to_fq_string("facet_name", "true")).to  eq("facet_name:true")
+        facet_value_to_fq_string("facet_name", "true").should  == "facet_name:true"
       end
 
       it "should pass integers through" do
-        expect(facet_value_to_fq_string("facet_name", 1)).to  eq("facet_name:1")
+        facet_value_to_fq_string("facet_name", 1).should  == "facet_name:1"
       end
 
       it "should pass integer-like strings through" do
-        expect(facet_value_to_fq_string("facet_name", "1")).to  eq("facet_name:1")
+        facet_value_to_fq_string("facet_name", "1").should  == "facet_name:1"
       end
 
       it "should pass floats through" do
-        expect(facet_value_to_fq_string("facet_name", 1.11)).to  eq("facet_name:1.11")
+        facet_value_to_fq_string("facet_name", 1.11).should  == "facet_name:1.11"
       end
 
       it "should pass floats through" do
-        expect(facet_value_to_fq_string("facet_name", "1.11")).to  eq("facet_name:1.11")
+        facet_value_to_fq_string("facet_name", "1.11").should  == "facet_name:1.11"
       end
 
       it "should pass date-type fields through" do
-        allow(blacklight_config.facet_fields).to receive(:[]).with('facet_name').and_return(double(:date => true, :query => nil, :tag => nil))
-
-        expect(facet_value_to_fq_string("facet_name", "2012-01-01")).to eq "facet_name:2012\\-01\\-01"
-      end
-
-      it "should escape datetime-type fields" do
-        allow(blacklight_config.facet_fields).to receive(:[]).with('facet_name').and_return(double(:date => true, :query => nil, :tag => nil))
+        blacklight_config.facet_fields.stub(:[]).with('facet_name').and_return(double(:date => true, :query => nil, :tag => nil))
 
-        expect(facet_value_to_fq_string("facet_name", "2003-04-09T00:00:00Z")).to eq "facet_name:2003\\-04\\-09T00\\:00\\:00Z"
-      end
-
-      it "should format Date objects correctly" do
-        allow(blacklight_config.facet_fields).to receive(:[]).with('facet_name').and_return(double(:date => nil, :query => nil, :tag => nil))
-        d = DateTime.parse("2003-04-09T00:00:00")
-        expect(facet_value_to_fq_string("facet_name", d)).to eq "facet_name:2003\\-04\\-09T00\\:00\\:00Z"
+        facet_value_to_fq_string("facet_name", "2012-01-01").should  == "facet_name:2012-01-01"
       end
 
       it "should handle range requests" do
-        expect(facet_value_to_fq_string("facet_name", 1..5)).to  eq("facet_name:[1 TO 5]")
+        facet_value_to_fq_string("facet_name", 1..5).should  == "facet_name:[1 TO 5]"
       end
 
       it "should add tag local parameters" do
-        allow(blacklight_config.facet_fields).to receive(:[]).with('facet_name').and_return(double(:query => nil, :tag => 'asdf', :date => nil))
+        blacklight_config.facet_fields.stub(:[]).with('facet_name').and_return(double(:query => nil, :tag => 'asdf', :date => nil))
 
-        expect(facet_value_to_fq_string("facet_name", true)).to  eq("{!tag=asdf}facet_name:true")
-        expect(facet_value_to_fq_string("facet_name", "my value")).to  eq("{!raw f=facet_name tag=asdf}my value")
+        facet_value_to_fq_string("facet_name", true).should  == "{!tag=asdf}facet_name:true"
+        facet_value_to_fq_string("facet_name", "my value").should  == "{!raw f=facet_name tag=asdf}my value"
       end
     end
 
     describe "solr parameters for a field search from config (subject)" do
-      before do
-        @solr_params = solr_search_params( @subject_search_params )
-      end
+      let(:solr_params) { solr_search_params @subject_search_params }
+
       it "should look up qt from field definition" do
-        expect(@solr_params[:qt]).to eq("search")
+        solr_params[:qt].should == "search"
       end
       it "should not include weird keys not in field definition" do
-        expect(@solr_params[:phrase_filters]).to be_nil
-        expect(@solr_params[:fq]).to be_nil
-        expect(@solr_params[:commit]).to be_nil
-        expect(@solr_params[:action]).to be_nil
-        expect(@solr_params[:controller]).to be_nil
+        solr_params.to_hash.tap do |h|
+          h[:phrase_filters].should be_nil
+          h[:fq].should be_nil
+          h[:commit].should be_nil
+          h[:action].should be_nil
+          h[:controller].should be_nil
+        end
       end
       it "should include proper 'q', possibly with LocalParams" do
-        expect(@solr_params[:q]).to match(/(\{[^}]+\})?wome/)
+        solr_params[:q].should match(/(\{[^}]+\})?wome/)
       end
       it "should include proper 'q' when LocalParams are used" do
-        if @solr_params[:q] =~ /\{[^}]+\}/
-          expect(@solr_params[:q]).to match(/\{[^}]+\}wome/)
+        if solr_params[:q] =~ /\{[^}]+\}/
+          solr_params[:q].should match(/\{[^}]+\}wome/)
         end
       end
       it "should include spellcheck.q, without LocalParams" do
-        expect(@solr_params["spellcheck.q"]).to eq("wome")
+        solr_params["spellcheck.q"].should == "wome"
       end
 
       it "should include spellcheck.dictionary from field def solr_parameters" do
-        expect(@solr_params[:"spellcheck.dictionary"]).to eq("subject")
+        solr_params[:"spellcheck.dictionary"].should == "subject"
       end
       it "should add on :solr_local_parameters using Solr LocalParams style" do
         params = solr_search_params( @subject_search_params )
@@ -260,8 +242,8 @@ describe 'Blacklight::SolrHelper' do
         #the LocalParams are really there
         params[:q] =~ /^\{!([^}]+)\}/
         key_value_pairs = $1.split(" ")
-        expect(key_value_pairs).to include("pf=$subject_pf")
-        expect(key_value_pairs).to include("qf=$subject_qf")
+        key_value_pairs.should include("pf=$subject_pf")
+        key_value_pairs.should include("qf=$subject_qf")
       end
     end
 
@@ -270,18 +252,18 @@ describe 'Blacklight::SolrHelper' do
         def params
           super.merge(:qt => "overridden")
         end
-
-        expect(solr_search_params[:qt]).to eq("overridden")
+        
+        solr_search_params[:qt].should == "overridden"        
       end
     end
 
     describe "converts a String fq into an Array" do
       it "should return the correct overriden parameter" do
         solr_parameters = {:fq => 'a string' }
-
+        
         add_facet_fq_to_solr(solr_parameters, {})
 
-        expect(solr_parameters[:fq]).to be_a_kind_of Array
+        solr_parameters[:fq].should be_a_kind_of Array
       end
     end
 
@@ -300,48 +282,48 @@ describe 'Blacklight::SolrHelper' do
 
       it "should return the correct solr parameters" do
 
-        solr_parameters = { }
-
+        solr_parameters = Blacklight::Solr::Request.new
+        
         add_facetting_to_solr(solr_parameters, {})
 
-        expect(solr_parameters[:facet]).to eq true
+        expect(solr_parameters[:facet]).to be_true
 
-        expect(solr_parameters[:'facet.field']).to include('test_field')
-        expect(solr_parameters[:'f.test_field.facet.sort']).to eq('count')
+        solr_parameters[:'facet.field'].should include('test_field')
+        solr_parameters[:'f.test_field.facet.sort'].should == 'count'
       end
 
       it "should add facet exclusions" do
-        solr_parameters = { }
+        solr_parameters = Blacklight::Solr::Request.new
 
         add_facetting_to_solr(solr_parameters, {})
 
-        expect(solr_parameters[:'facet.query']).to include('{!ex=xyz}some:query')
-        expect(solr_parameters[:'facet.pivot']).to include('{!ex=xyz}a,b')
+        solr_parameters[:'facet.query'].should include('{!ex=xyz}some:query')
+        solr_parameters[:'facet.pivot'].should include('{!ex=xyz}a,b')
       end
     end
 
     describe "with a complex parameter environment" do
-      def blacklight_config
+      def blacklight_config          
         config = Blacklight::Configuration.new
         config.add_search_field("test_field",
-                             :display_label => "Test",
-                             :key=>"test_field",
+                             :display_label => "Test", 
+                             :key=>"test_field", 
                              :solr_parameters => {:qf => "fieldOne^2.3 fieldTwo fieldThree^0.4", :pf => "", :spellcheck => 'false', :rows => "55", :sort => "request_params_sort" }
                             )
         return config
       end
-      def params
+      def params          
         {:search_field => "test_field", :q => "test query", "facet.field" => "extra_facet"}
       end
-
+      
       it "should merge parameters from search_field definition" do
         solr_params = solr_search_params
-
-        expect(solr_params[:qf]).to eq("fieldOne^2.3 fieldTwo fieldThree^0.4")
-        expect(solr_params[:spellcheck]).to eq('false')
+        
+        solr_params[:qf].should == "fieldOne^2.3 fieldTwo fieldThree^0.4"
+        solr_params[:spellcheck].should == 'false'
       end
       it "should merge empty string parameters from search_field definition" do
-        expect(solr_search_params[:pf]).to eq("")
+        solr_search_params[:pf].should == ""        
       end
 
       describe "should respect proper precedence of settings, " do
@@ -351,53 +333,53 @@ describe 'Blacklight::SolrHelper' do
 
 
         it "should not put :search_field in produced params" do
-          expect(@produced_params[:search_field]).to be_nil
+          @produced_params[:search_field].should be_nil
         end
 
         it "should fall through to BL general defaults for qt not otherwise specified " do
-          expect(@produced_params[:qt]).to eq(blacklight_config[:default_solr_params][:qt])
+          @produced_params[:qt].should == blacklight_config[:default_solr_params][:qt]
         end
 
         it "should take rows from search field definition where specified" do
-          expect(@produced_params[:rows]).to eq("55")
+          @produced_params[:rows].should == "55"
         end
 
         it "should take q from request params" do
-          expect(@produced_params[:q]).to eq("test query")
+          @produced_params[:q].should == "test query"
         end
 
         it "should add in extra facet.field from params" do
-          expect(@produced_params[:"facet.field"]).to include("extra_facet")
+          @produced_params[:"facet.field"].should include("extra_facet")
         end
 
       end
     end
 
     describe "sorting" do
-
-      it "should send the default sort parameter to solr" do
-        expect(solr_search_params[:sort]).to eq('score desc, pub_date_sort desc, title_sort asc')
+      
+      it "should send the default sort parameter to solr" do                        
+        solr_search_params[:sort].should == 'score desc, pub_date_sort desc, title_sort asc'        
       end
 
       it "should not send a sort parameter to solr if the sort value is blank" do
-        def blacklight_config
+        def blacklight_config          
           config = Blacklight::Configuration.new
           config.add_sort_field('', :label => 'test')
           return config
         end
 
         produced_params = solr_search_params
-        expect(produced_params).not_to have_key(:sort)
+        produced_params.should_not have_key(:sort)
       end
 
       it "should pass through user sort parameters" do
         produced_params = solr_search_params( :sort => 'solr_test_field desc' )
-        expect(produced_params[:sort]).to eq('solr_test_field desc')
+        produced_params[:sort].should == 'solr_test_field desc'
       end
     end
 
     describe "for :solr_local_parameters config" do
-      def blacklight_config
+      def blacklight_config          
         config = Blacklight::Configuration.new
         config.add_search_field(
           "custom_author_key",
@@ -416,45 +398,45 @@ describe 'Blacklight::SolrHelper' do
         )
         return config
       end
-
-      def params
+      
+      def params        
         {:search_field => "custom_author_key", :q => "query"}
       end
-
+      
       before do
         @result = solr_search_params
       end
 
       it "should pass through ordinary params" do
-        expect(@result[:qt]).to eq("author_qt")
-        expect(@result[:ps]).to eq("2")
-        expect(@result[:qf]).to eq("someField^1000")
+        @result[:qt].should == "author_qt"
+        @result[:ps].should == "2"
+        @result[:qf].should == "someField^1000"
       end
 
       it "should include include local params with escaping" do
-        expect(@result[:q]).to include('qf=$author_qf')
-        expect(@result[:q]).to include('pf=\'you\\\'ll have \\" to escape this\'')
-        expect(@result[:q]).to include('pf2=$pf2_do_not_escape_or_quote')
+        @result[:q].should include('qf=$author_qf')
+        @result[:q].should include('pf=\'you\\\'ll have \\" to escape this\'')
+        @result[:q].should include('pf2=$pf2_do_not_escape_or_quote')
       end
     end
-
+    
     describe "mapping facet.field" do
       it "should add single additional facet.field from app" do
         solr_params = solr_search_params( "facet.field" => "additional_facet" )
-        expect(solr_params[:"facet.field"]).to include("additional_facet")
-        expect(solr_params[:"facet.field"].length).to be > 1
+        solr_params[:"facet.field"].should include("additional_facet")
+        solr_params[:"facet.field"].length.should > 1
       end
       it "should map multiple facet.field to additional facet.field" do
         solr_params = solr_search_params( "facet.field" => ["add_facet1", "add_facet2"] )
-        expect(solr_params[:"facet.field"]).to include("add_facet1")
-        expect(solr_params[:"facet.field"]).to include("add_facet2")
-        expect(solr_params[:"facet.field"].length).to be > 2
+        solr_params[:"facet.field"].should include("add_facet1")
+        solr_params[:"facet.field"].should include("add_facet2")
+        solr_params[:"facet.field"].length.should > 2
       end
       it "should map facets[fields][] to additional facet.field" do
         solr_params = solr_search_params( "facets" => ["add_facet1", "add_facet2"] )
-        expect(solr_params[:"facet.field"]).to include("add_facet1")
-        expect(solr_params[:"facet.field"]).to include("add_facet2")
-        expect(solr_params[:"facet.field"].length).to be > 2
+        solr_params[:"facet.field"].should include("add_facet1")
+        solr_params[:"facet.field"].should include("add_facet2")
+        solr_params[:"facet.field"].length.should > 2
       end
     end
 
@@ -476,21 +458,21 @@ describe 'Blacklight::SolrHelper' do
       end
     end
     it 'sets rows to 0' do
-      expect(@generated_solr_facet_params[:rows]).to eq(0)
+      @generated_solr_facet_params[:rows].should == 0
     end
     it 'sets facets requested to facet_field argument' do
-      expect(@generated_solr_facet_params["facet.field".to_sym]).to eq(@facet_field)
+      @generated_solr_facet_params["facet.field".to_sym].should == @facet_field
     end
     it 'defaults offset to 0' do
-      expect(@generated_solr_facet_params[:"f.#{@facet_field}.facet.offset"]).to eq(0)
+      @generated_solr_facet_params[:"f.#{@facet_field}.facet.offset"].should == 0
     end
     it 'uses offset manually set, and converts it to an integer' do
       solr_params = solr_facet_params(@facet_field, @page_key => 2)
-      expect(solr_params[:"f.#{@facet_field}.facet.offset"]).to eq(20)
+      solr_params[:"f.#{@facet_field}.facet.offset"].should == 20
     end
     it 'defaults limit to 20' do
       solr_params = solr_facet_params(@facet_field)
-      expect(solr_params[:"f.#{@facet_field}.facet.limit"]).to eq(21)
+      solr_params[:"f.#{@facet_field}.facet.limit"].should == 21
     end
 
     describe 'if facet_list_limit is defined in controller' do
@@ -499,29 +481,29 @@ describe 'Blacklight::SolrHelper' do
       end
       it 'uses controller method for limit' do
         solr_params = solr_facet_params(@facet_field)
-        expect(solr_params[:"f.#{@facet_field}.facet.limit"]).to eq(1001)
+        solr_params[:"f.#{@facet_field}.facet.limit"].should == 1001
       end
 
       it 'uses controller method for limit when a ordinary limit is set' do
         solr_params = solr_facet_params(@facet_field)
-        expect(solr_params[:"f.#{@facet_field}.facet.limit"]).to eq(1001)
+        solr_params[:"f.#{@facet_field}.facet.limit"].should == 1001
       end
     end
 
     it 'uses the default sort' do
       solr_params = solr_facet_params(@facet_field)
-      expect(solr_params[:"f.#{@facet_field}.facet.sort"]).to be_blank
+      solr_params[:"f.#{@facet_field}.facet.sort"].should be_blank
     end
 
     it "uses the field-specific sort" do
       @facet_field = 'format_ordered'
       solr_params = solr_facet_params(@facet_field)
-      expect(solr_params[:"f.#{@facet_field}.facet.sort"]).to eq(:count)
+      solr_params[:"f.#{@facet_field}.facet.sort"].should == :count
     end
 
     it 'uses sort provided in the parameters' do
       solr_params = solr_facet_params(@facet_field, @sort_key => "index")
-      expect(solr_params[:"f.#{@facet_field}.facet.sort"]).to eq('index')
+      solr_params[:"f.#{@facet_field}.facet.sort"].should == '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'}}
@@ -531,41 +513,41 @@ describe 'Blacklight::SolrHelper' do
       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".to_sym, :rows, 'facet.limit', 'facet.offset', 'facet.sort'].include?(key)
+        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)
+        solr_facet_params[key].should == value
       end
 
     end
   end
-  describe "for facet limit parameters config ed" do
+  describe "for facet limit parameters config ed" do              
     def params
       {:search_field => "test_field", :q => "test query"}
     end
-
-
-    before do
+    
+    
+    before do            
       @generated_params = solr_search_params
     end
-
+    
     it "should include specifically configged facet limits +1" do
-      expect(@generated_params[:"f.subject_topic_facet.facet.limit"]).to eq(21)
+      @generated_params[:"f.subject_topic_facet.facet.limit"].should == 21      
     end
     it "should not include a facet limit for a nil key in hash" do
-      expect(@generated_params).not_to have_key(:"f.format.facet.limit")
-      expect(@generated_params).not_to have_key(:"facet.limit")
+      @generated_params.should_not have_key(:"f.format.facet.limit")
+      @generated_params.should_not have_key(:"facet.limit")
     end
   end
-
+  
    describe "get_facet_pagination", :integration => true do
     before(:each) do
       @facet_paginator = get_facet_pagination(@facet_field)
     end
     it 'should return a facet paginator' do
-      expect(@facet_paginator).to be_a_kind_of(Blacklight::Solr::FacetPaginator)
+      @facet_paginator.should be_a_kind_of(Blacklight::Solr::FacetPaginator)
     end
     it 'with a limit set' do
-      expect(@facet_paginator.limit).not_to be_nil
+      @facet_paginator.limit.should_not be_nil
     end
    end
 
@@ -574,23 +556,23 @@ describe 'Blacklight::SolrHelper' do
 
     describe 'for a sample query returning results' do
 
-      before(:all) do
+      before(:all) do        
         (@solr_response, @document_list) = get_search_results(:q => @all_docs_query)
       end
 
       it "should use the configured request handler " do
-        allow(blacklight_config).to receive(:default_solr_params).and_return({:qt => 'custom_request_handler'})
-        expect(blacklight_solr).to receive(:send_and_receive) { |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=>"", "spellcheck.q"=>"", :"f.subject_topic_facet.facet.limit"=>21, :sort=>"score desc, pub_date_sort desc, title_sort asc")
-        }.and_return({'response'=>{'docs'=>[]}})
+        blacklight_config.stub(:default_solr_params).and_return({:qt => 'custom_request_handler'})
+        Blacklight.solr.should_receive(:send_and_receive) do |path, params|
+          path.should == 'select'
+          params[:params][:'facet.field'].should == ["format", "{!ex=pub_date_single}pub_date", "subject_topic_facet", "language_facet", "lc_1letter_facet", "subject_geo_facet", "subject_era_facet"]
+          params[:params][:"facet.query"].should == ["pub_date:[#{5.years.ago.year} TO *]", "pub_date:[#{10.years.ago.year} TO *]", "pub_date:[#{25.years.ago.year} TO *]"]
+          params[:params].should include(:rows => 10, :qt=>"custom_request_handler", :q=>"", "spellcheck.q"=>"", :"f.subject_topic_facet.facet.limit"=>21, :sort=>"score desc, pub_date_sort desc, title_sort asc")
+        end.and_return({'response'=>{'docs'=>[]}})
         get_search_results(:q => @all_docs_query)
       end
 
       it 'should have a @response.docs list of the same size as @document_list' do
-        expect(@solr_response.docs.length).to eq(@document_list.length)
+        @solr_response.docs.length.should == @document_list.length
       end
 
       it 'should have @response.docs list representing same documents as SolrDocuments in @document_list' do
@@ -598,10 +580,10 @@ describe 'Blacklight::SolrHelper' do
           mash = @solr_response.docs[index]
           solr_document = @document_list[index]
 
-          expect(Set.new(mash.keys)).to eq(Set.new(solr_document.keys))
+          Set.new(mash.keys).should == Set.new(solr_document.keys)
 
           mash.each_key do |key|
-            expect(mash[key]).to eq(solr_document[key])
+            mash[key].should == solr_document[key]
           end
         end
       end
@@ -644,7 +626,7 @@ describe 'Blacklight::SolrHelper' do
     describe '#query_solr' do
       it 'should have results' do
         solr_response = query_solr(:q => @single_word_query)
-        expect(solr_response.docs.size).to be > 0
+        solr_response.docs.size.should > 0
       end
 
     end
@@ -654,24 +636,24 @@ describe 'Blacklight::SolrHelper' do
         (solr_response, document_list) = get_search_results(:q => @all_docs_query)
         result_docs = document_list
         document = result_docs.first
-        expect(document.get(blacklight_config.index.show_link)).not_to eq(nil)
-        expect(document.get(blacklight_config.index.record_display_type)).not_to eq(nil)
+        document.get(blacklight_config.index.show_link).should_not == nil
+        document.get(blacklight_config.index.record_display_type).should_not == nil
       end
     end
 
 
 
     describe "Single Word Query with no Facets" do
-
+    	
       it 'should have results' do
         solr_response = query_solr(:q => @single_word_query)
-        expect(solr_response.docs.size).to be > 0
+        solr_response.docs.size.should > 0
       end
 
       it 'should have results' do
         (solr_response, document_list) = get_search_results(:q => @single_word_query)
-        expect(solr_response.docs.size).to eq(document_list.size)
-        expect(solr_response.docs.size).to be > 0
+        solr_response.docs.size.should == document_list.size
+        solr_response.docs.size.should > 0
       end
     end
 
@@ -679,48 +661,48 @@ describe 'Blacklight::SolrHelper' do
       it 'should have results' do
 
         (solr_response, document_list) = get_search_results(:q => @mult_word_query)
-        expect(solr_response.docs.size).to eq(document_list.size)
-        expect(solr_response.docs.size).to be > 0
+        solr_response.docs.size.should == document_list.size
+        solr_response.docs.size.should > 0
       end
     end
 
     describe "One Facet, No Query" do
       it 'should have results' do
         (solr_response, document_list) = get_search_results(:f => @single_facet)
-        expect(solr_response.docs.size).to eq(document_list.size)
-        expect(solr_response.docs.size).to be > 0
+        solr_response.docs.size.should == document_list.size
+        solr_response.docs.size.should > 0
       end
     end
 
     describe "Mult Facets, No Query" do
       it 'should have results' do
         (solr_response, document_list) = get_search_results(:f => @multi_facets)
-        expect(solr_response.docs.size).to eq(document_list.size)
-        expect(solr_response.docs.size).to be > 0
+        solr_response.docs.size.should == document_list.size
+        solr_response.docs.size.should > 0
       end
     end
 
     describe "Single Word Query with One Facet" do
       it 'should have results' do
         (solr_response, document_list) = get_search_results(:q => @single_word_query, :f => @single_facet)
-        expect(solr_response.docs.size).to eq(document_list.size)
-        expect(solr_response.docs.size).to be > 0
+        solr_response.docs.size.should == document_list.size
+        solr_response.docs.size.should > 0
       end
     end
 
     describe "Multiple Words Query with Multiple Facets" do
       it 'should have results' do
         (solr_response, document_list) = get_search_results(:q => @mult_word_query, :f => @multi_facets)
-        expect(solr_response.docs.size).to eq(document_list.size)
-        expect(solr_response.docs.size).to be > 0
+        solr_response.docs.size.should == document_list.size
+        solr_response.docs.size.should > 0
       end
     end
 
     describe "for All Docs Query and One Facet" do
       it 'should have results' do
         (solr_response, document_list) = get_search_results(:q => @all_docs_query, :f => @single_facet)
-        expect(solr_response.docs.size).to eq(document_list.size)
-        expect(solr_response.docs.size).to be > 0
+        solr_response.docs.size.should == document_list.size
+        solr_response.docs.size.should > 0
       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)
@@ -729,24 +711,24 @@ describe 'Blacklight::SolrHelper' do
     describe "for Query Without Results and No Facet" do
       it 'should have no results and not raise error' do
         (solr_response, document_list) = get_search_results(:q => @no_docs_query)
-        expect(solr_response.docs.size).to eq(document_list.size)
-        expect(solr_response.docs.size).to eq(0)
+        solr_response.docs.size.should == document_list.size
+        solr_response.docs.size.should == 0
       end
     end
 
     describe "for Query Without Results and One Facet" do
       it 'should have no results and not raise error' do
         (solr_response, document_list) = get_search_results(:q => @no_docs_query, :f => @single_facet)
-        expect(solr_response.docs.size).to eq(document_list.size)
-        expect(solr_response.docs.size).to eq(0)
+        solr_response.docs.size.should == document_list.size
+        solr_response.docs.size.should == 0
       end
     end
 
     describe "for All Docs Query and Bad Facet" do
       it 'should have no results and not raise error' do
         (solr_response, document_list) = get_search_results(:q => @all_docs_query, :f => @bad_facet)
-        expect(solr_response.docs.size).to eq(document_list.size)
-        expect(solr_response.docs.size).to eq(0)
+        solr_response.docs.size.should == document_list.size
+        solr_response.docs.size.should == 0
       end
     end
 
@@ -765,16 +747,16 @@ describe 'Blacklight::SolrHelper' do
     end
 
     it 'should have more than one facet' do
-      expect(@facets.size).to be > 1
+      @facets.size.should > 1
     end
-    it 'should have all facets specified in initializer' do
+    it 'should have all facets specified in initializer' do      
       blacklight_config.facet_fields_to_add_to_solr.each do |field|
-        expect(@facets.find {|f| f.name == field}).not_to be_nil
+        @facets.find {|f| f.name == field}.should_not be_nil        
       end
     end
     it 'should have at least one value for each facet' do
       @facets.each do |facet|
-        expect(facet.items.size).to be > 0
+        facet.items.size.should > 0
       end
     end
     it 'should have multiple values for at least one facet' do
@@ -785,7 +767,7 @@ describe 'Blacklight::SolrHelper' do
           break
         end
       end
-      expect(has_mult_values).to eq(true)
+      has_mult_values.should == true
     end
     it 'should have all value counts > 0' do
       @facets.each do |facet|
@@ -802,58 +784,58 @@ describe 'Blacklight::SolrHelper' do
 
     it 'should start with first results by default' do
       (solr_response, document_list) = get_search_results(:q => @all_docs_query)
-      expect(solr_response.params[:start].to_i).to eq(0)
+      solr_response.params[:start].to_i.should == 0
     end
     it 'should have number of results (per page) set in initializer, by default' do
       (solr_response, document_list) = get_search_results(:q => @all_docs_query)
-      expect(solr_response.docs.size).to eq(document_list.size)
-      expect(solr_response.docs.size).to eq(blacklight_config[:default_solr_params][:rows])
+      solr_response.docs.size.should == document_list.size
+      solr_response.docs.size.should == blacklight_config[:default_solr_params][:rows]
     end
 
     it 'should get number of results per page requested' do
       num_results = 3  # non-default value
       (solr_response1, document_list1) = get_search_results(:q => @all_docs_query, :per_page => num_results)
-      expect(solr_response1.docs.size).to eq(document_list1.size)
-      expect(solr_response1.docs.size).to eq(num_results)
+      solr_response1.docs.size.should == document_list1.size
+      solr_response1.docs.size.should == num_results
     end
 
     it 'should get number of rows requested' do
       num_results = 4  # non-default value
       (solr_response1, document_list1) = get_search_results(:q => @all_docs_query, :rows => num_results)
-      expect(solr_response1.docs.size).to eq(document_list1.size)
-      expect(solr_response1.docs.size).to eq(num_results)
+      solr_response1.docs.size.should == document_list1.size
+      solr_response1.docs.size.should == num_results
     end
 
     it 'should skip appropriate number of results when requested - default per page' do
       page = 3
       (solr_response2, document_list2) = get_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))
+      solr_response2.params[:start].to_i.should ==  blacklight_config[:default_solr_params][:rows] * (page-1)
     end
     it 'should skip appropriate number of results when requested - non-default per page' do
       page = 3
       num_results = 3
       (solr_response2a, document_list2a) = get_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))
+      solr_response2a.params[:start].to_i.should == num_results * (page-1)
     end
 
     it 'should have no results when prompted for page after last result' do
       big = 5000
       (solr_response3, document_list3) = get_search_results(:q => @all_docs_query, :rows => big, :page => big)
-      expect(solr_response3.docs.size).to eq(document_list3.size)
-      expect(solr_response3.docs.size).to eq(0)
+      solr_response3.docs.size.should == document_list3.size
+      solr_response3.docs.size.should == 0
     end
 
     it 'should show 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) = get_search_results(:q => @all_docs_query, :page => '-1')
-      expect(solr_response4.params[:start].to_i).to eq(0)
+      solr_response4.params[:start].to_i.should == 0
     end
     it 'should have results available when asked for more than are in response' do
       big = 5000
       (solr_response5, document_list5) = get_search_results(:q => @all_docs_query, :rows => big, :page => 1)
-      expect(solr_response5.docs.size).to eq(document_list5.size)
-      expect(solr_response5.docs.size).to be > 0
+      solr_response5.docs.size.should == document_list5.size
+      solr_response5.docs.size.should > 0
     end
 
   end # page specs
@@ -867,42 +849,42 @@ describe 'Blacklight::SolrHelper' do
     end
 
     it "should raise Blacklight::InvalidSolrID for an unknown id" do
-      expect {
+      lambda {
         get_solr_response_for_doc_id(@bad_id)
-      }.to raise_error(Blacklight::Exceptions::InvalidSolrID)
+      }.should raise_error(Blacklight::Exceptions::InvalidSolrID)
     end
 
     it "should use a provided document request handler " do
-      allow(blacklight_config).to receive_messages(:document_solr_request_handler => 'document')
-      expect(blacklight_solr).to receive(:get).with('select', kind_of(Hash)).and_return({'response'=>{'docs'=>[]}})
-      expect { get_solr_response_for_doc_id(@doc_id)}.to raise_error Blacklight::Exceptions::InvalidSolrID
+      blacklight_config.stub(:document_solr_request_handler => 'document')
+      Blacklight.solr.should_receive(:get).with('select', kind_of(Hash)).and_return({'response'=>{'docs'=>[]}})
+      lambda { get_solr_response_for_doc_id(@doc_id)}.should raise_error Blacklight::Exceptions::InvalidSolrID
     end
 
     it "should have a non-nil result for a known id" do
-      expect(@document).not_to eq(nil)
+      @document.should_not == nil
     end
     it "should have a single document in the response for a known id" do
-      expect(@response2.docs.size).to eq(1)
+      @response2.docs.size.should == 1
     end
     it 'should have the expected value in the id field' do
-      expect(@document.id).to eq(@doc_id)
+      @document.id.should == @doc_id
     end
     it 'should have non-nil values for required fields set in initializer' do
-      expect(@document.get(blacklight_config[:show][:html_title])).not_to eq(nil)
-      expect(@document.get(blacklight_config[:show][:heading])).not_to eq(nil)
-      expect(@document.get(blacklight_config[:show][:display_type])).not_to eq(nil)
+      @document.get(blacklight_config[:show][:html_title]).should_not == nil
+      @document.get(blacklight_config[:show][:heading]).should_not == nil
+      @document.get(blacklight_config[:show][:display_type]).should_not == nil
     end
   end
 
   describe "solr_doc_params" do
     it "should default to using the 'document' requestHandler" do
       doc_params = solr_doc_params('asdfg')
-      expect(doc_params[:qt]).to eq('document')
+      doc_params[:qt].should == 'document'
     end
 
 
     describe "blacklight config's default_document_solr_parameters" do
-      def blacklight_config
+      def blacklight_config          
         config = Blacklight::Configuration.new
         config.default_document_solr_params = { :qt => 'my_custom_handler', :asdf => '1234' }
         config
@@ -910,15 +892,15 @@ describe 'Blacklight::SolrHelper' do
 
       it "should use parameters from the controller's default_document_solr_parameters" do
         doc_params = solr_doc_params('asdfg')
-        expect(doc_params[:qt]).to eq('my_custom_handler')
-        expect(doc_params[:asdf]).to eq('1234')
+        doc_params[:qt].should == 'my_custom_handler'
+        doc_params[:asdf].should == '1234'
       end
     end
 
   end
 
   describe "Get Document by custom unique id" do
-=begin
+=begin    
     # Can't test this properly without updating the "document" request handler in solr
     it "should respect the configuration-supplied unique id" do
       SolrDocument.should_receive(:unique_key).and_return("title_display")
@@ -929,7 +911,7 @@ describe 'Blacklight::SolrHelper' do
 =end
     it "should respect the configuration-supplied unique id" do
       doc_params = solr_doc_params('"Strong Medicine speaks"')
-      expect(doc_params[:id]).to eq('"Strong Medicine speaks"')
+      doc_params[:id].should == '"Strong Medicine speaks"'
     end
   end
 
@@ -958,18 +940,18 @@ describe 'Blacklight::SolrHelper' do
 =end
 
     it 'should have a doc id field' do
-      expect(@doc[:id]).not_to eq(nil)
+      @doc[:id].should_not == nil
     end
 
     it 'should have non-nil values for required fields set in initializer' do
-      expect(@doc[blacklight_config.show.html_title]).not_to eq(nil)
-      expect(@doc[blacklight_config.show.heading]).not_to eq(nil)
-      expect(@doc[blacklight_config.show.display_type]).not_to eq(nil)
+      @doc[blacklight_config.show.html_title].should_not == nil
+      @doc[blacklight_config.show.heading].should_not == nil
+      @doc[blacklight_config.show.display_type].should_not == nil
     end
 
     it "should limit search result by facets when supplied" do
       doc2 = get_single_doc_via_search(@doc_row , :q => @all_docs_query, :f => @multi_facets)
-      expect(doc2[:id]).not_to eq(nil)
+      doc2[:id].should_not == nil
     end
 
   end
@@ -978,15 +960,15 @@ describe 'Blacklight::SolrHelper' do
   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) = get_search_results({:q => 'boo'})
-      expect(solr_response.spelling.words).to include('bon')
-      expect(solr_response.spelling.words).to include('bod')  #for multiple suggestions
+      solr_response.spelling.words.should include('bon')
+      solr_response.spelling.words.should 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) = get_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
+      solr_response.spelling.words.should include('policy') # less freq
+      solr_response.spelling.words.should include('politics') # more freq
+      solr_response.spelling.words.should include('political') # more freq
 =begin
       #  when we can have multiple suggestions
       solr_response.spelling.words.should_not include('policy') # less freq
@@ -997,33 +979,39 @@ describe 'Blacklight::SolrHelper' do
 
     it "title search results for just-poor-enough query term should have spelling suggestions" do
       (solr_response, document_list) = get_search_results({:q => 'yehudiyam', :qt => 'search', :"spellcheck.dictionary" => "title"})
-      expect(solr_response.spelling.words).to include('yehudiyim')
+      solr_response.spelling.words.should include('yehudiyim')
     end
 
     it "author search results for just-poor-enough-query term should have spelling suggestions" do
       (solr_response, document_list) = get_search_results({:q => 'shirma', :qt => 'search', :"spellcheck.dictionary" => "author"})
-      expect(solr_response.spelling.words).to include('sharma')
+      solr_response.spelling.words.should include('sharma')
     end
 
     it "subject search results for just-poor-enough-query term should have spelling suggestions" do
       (solr_response, document_list) = get_search_results({:q => 'wome', :qt => 'search', :"spellcheck.dictionary" => "subject"})
-      expect(solr_response.spelling.words).to include('women')
+      solr_response.spelling.words.should include('women')
+    end
+
+    it 'search results for multiple terms query with just-poor-enough-terms should have spelling suggestions for each term' do
+     pending
+#     get_spelling_suggestion("histo politica").should_not be_nil
     end
+
   end
 
   describe "facet_limit_for" do
 
     it "should return specified value for facet_field specified" do
-      expect(facet_limit_for("subject_topic_facet")).to eq(blacklight_config.facet_fields["subject_topic_facet"].limit)
+      facet_limit_for("subject_topic_facet").should == blacklight_config.facet_fields["subject_topic_facet"].limit
     end
     it "should generate proper solr param" do
-      expect(solr_search_params[:"f.subject_topic_facet.facet.limit"]).to eq(21)
+      solr_search_params[:"f.subject_topic_facet.facet.limit"].should == 21
     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?
       pending "facet_limit_hash has been removed from solrhelper in refactor. should it go back?"
-      expect(facet_limit_hash).to eq(blacklight_config[:facet][:limits])
+      facet_limit_hash.should == blacklight_config[:facet][:limits]
     end
     it "should handle no facet_limits in config" do
       def blacklight_config
@@ -1031,61 +1019,61 @@ describe 'Blacklight::SolrHelper' do
         config.facet_fields = {}
         return config
       end
-
-      expect(facet_limit_for("subject_topic_facet")).to be_nil
-
-      expect(solr_search_params).not_to have_key(:"f.subject_topic_facet.facet.limit")
-
+            
+      facet_limit_for("subject_topic_facet").should be_nil
+      
+      solr_search_params.should_not have_key(:"f.subject_topic_facet.facet.limit")
+      
     end
-
+    
     describe "for 'true' configured values" do
       it "should return nil if no @response available" do
-        expect(facet_limit_for("some_unknown_field")).to be_nil
+        facet_limit_for("some_unknown_field").should be_nil
       end
-      it "should get from @response facet.limit if available" do
+      it "should get from @response facet.limit if available" do        
         # Okay, this is cheesy, since we included SolrHelper directly
         # into our example groups, we need to set an iVar here, so it will
-        # use it.
-        @response = {"responseHeader" => {"params" => {"facet.limit" => 11}}}
-        expect(facet_limit_for("language_facet")).to eq(10)
+        # use it. 
+        @response = {"responseHeader" => {"params" => {"facet.limit" => 11}}}        
+        facet_limit_for("language_facet").should == 10
       end
       it "should get from specific field in @response if available" do
         @response = {"responseHeader" => {"params" => {"facet.limit" => 11,"f.language_facet.facet.limit" => 16}}}
-        expect(facet_limit_for("language_facet")).to eq(15)
+        facet_limit_for("language_facet").should == 15
       end
     end
   end
 
     describe "with max per page enforced" do
-      def blacklight_config
+      def blacklight_config          
         config = Blacklight::Configuration.new
         config.max_per_page = 123
         return config
       end
 
       it "should enforce max_per_page against all parameters" do
-        expect(blacklight_config.max_per_page).to eq(123)
-        expect(solr_search_params(:per_page => 98765)[:rows]).to eq(123)
-      end
+        blacklight_config.max_per_page.should == 123
+        solr_search_params(:per_page => 98765)[:rows].should == 123
+      end              
     end
 
     describe "#get_solr_response_for_field_values" do
       before do
         @mock_response = double()
-        allow(@mock_response).to receive_messages(:docs => [])
+        @mock_response.stub(:docs => [])
       end
       it "should contruct a solr query based on the field and value pair" do
-        expect(self).to receive(:find).with(an_instance_of(String), hash_including(:q => "field_name:(value)")).and_return(@mock_response)
+        self.should_receive(:find).with(an_instance_of(String), hash_including(:q => "field_name:(value)")).and_return(@mock_response)
         get_solr_response_for_field_values('field_name', 'value')
       end
 
       it "should OR multiple values together" do
-        expect(self).to receive(:find).with(an_instance_of(String), hash_including(:q => "field_name:(a OR b)")).and_return(@mock_response)
+        self.should_receive(:find).with(an_instance_of(String), hash_including(:q => "field_name:(a OR b)")).and_return(@mock_response)
         get_solr_response_for_field_values('field_name', ['a', 'b'])
       end
 
       it "should escape crazy identifiers" do
-        expect(self).to receive(:find).with(an_instance_of(String), hash_including(:q => "field_name:(\"h://\\\"\\\'\")")).and_return(@mock_response)
+        self.should_receive(:find).with(an_instance_of(String), hash_including(:q => "field_name:(\"h://\\\"\\\'\")")).and_return(@mock_response)
         get_solr_response_for_field_values('field_name', 'h://"\'')
       end
     end
@@ -1098,7 +1086,7 @@ describe 'Blacklight::SolrHelper' do
 #  more like this
 #  nearby on shelf
   it "should raise a Blacklight exception if RSolr can't connect to the Solr instance" do
-    allow(blacklight_solr).to receive(:get).and_raise(Errno::ECONNREFUSED)
+    Blacklight.solr.stub(:get).and_raise(Errno::ECONNREFUSED)
     expect { find(:a => 123) }.to raise_exception(/Unable to connect to Solr instance/)
   end
 
@@ -1110,7 +1098,7 @@ describe 'Blacklight::SolrHelper' do
     it "should pull the grouped key out of the config" do
       blacklight_config.index.group = 'xyz'
       expect(self.grouped_key_for_results).to eq('xyz')
-    end
+    end 
   end
 
   describe "#with_tag_ex" do
@@ -1158,39 +1146,5 @@ describe 'Blacklight::SolrHelper' do
     end
   end
 
-  describe "http_method configuration" do
-    describe "using default" do
-      let (:blacklight_config) {Blacklight::Configuration.new}
-
-      it "defaults to get" do
-        expect(blacklight_config.http_method).to eq :get
-        expect(blacklight_solr).to receive(:send_and_receive) { |path, params|
-          expect(path).to eq 'select'
-          expect(params[:method]).to eq :get
-          expect(params[:params]).to include(:q)
-        }.and_return({'response'=>{'docs'=>[]}})
-        get_search_results(: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
-        expect(blacklight_solr).to receive(:send_and_receive) { |path, params|
-          expect(path).to eq 'select'
-          expect(params[:method]).to eq :post
-          expect(params[:data]).to include(:q)
-        }.and_return({'response'=>{'docs'=>[]}})
-        get_search_results(:q => @all_docs_query)
-      end
-
-      it "should send a post request to solr", :integration => true do
-        response, docs = get_search_results(:q => @all_docs_query)
-        expect(docs.length).to be >= 1
-     end
-    end
-  end
-
 end
+