blacklight 4.9.0 → 5.0.0.pre1

data/spec/helpers/hash_as_hidden_fields_spec.rb

@@ -6,25 +6,19 @@ describe HashAsHiddenFieldsHelper do
   before(:each) do
     @hash = {:q => "query", :search_field => "search_field", :per_page=>10, :page=>5, :extra_arbitrary_key=>"arbitrary_value", :f=> {:field1 => ["a", "b"], :field2=> ["z"]}}
   end
-  around(:each) do |example|
-    tmp_value = Capybara.ignore_hidden_elements
-    Capybara.ignore_hidden_elements = false
-    example.run
-    Capybara.ignore_hidden_elements = tmp_value
-  end
 
   it "should convert a hash with nested complex data to Rails-style hidden form fields" do
 
-    generated = render_hash_as_hidden_fields(@hash)
-
-    expect(generated).to have_selector("input[type='hidden'][name='q'][value='query']")
-    expect(generated).to have_selector("input[type='hidden'][name='per_page'][value='10']")
-    expect(generated).to have_selector("input[type='hidden'][name='page'][value='5']")
-    expect(generated).to have_selector("input[type='hidden'][name='extra_arbitrary_key'][value='arbitrary_value']")
-    expect(generated).to have_selector("input[type='hidden'][name='f[field2][]'][value='z']")
-    expect(generated).to have_selector("input[type='hidden'][name='f[field1][]'][value='a']")
-    expect(generated).to have_selector("input[type='hidden'][name='f[field1][]'][value='b']")
+    generated = hash_as_hidden_fields(@hash)
 
+    generated.should have_selector("input[type='hidden'][name='q'][value='query']")
+    generated.should have_selector("input[type='hidden'][name='per_page'][value='10']")
+    generated.should have_selector("input[type='hidden'][name='page'][value='5']")
+    generated.should have_selector("input[type='hidden'][name='extra_arbitrary_key'][value='arbitrary_value']")
+    generated.should have_selector("input[type='hidden'][name='f[field2][]'][value='z']")
+    generated.should have_selector("input[type='hidden'][name='f[field1][]'][value='a']")
+    generated.should have_selector("input[type='hidden'][name='f[field1][]'][value='b']")
+    
   end
 
 end

data/spec/helpers/render_constraints_helper_spec.rb

@@ -4,12 +4,12 @@ describe RenderConstraintsHelper do
 
   before do
     # the helper methods below infer paths from the current route
-    controller.request.path_parameters[:controller] = 'catalog'
+    controller.request.path_parameters["controller"] = 'catalog'
   end
 
   describe '#render_constraints_query' do
     it "should have a link relative to the current url" do
-      expect(helper.render_constraints_query(:q=>'foobar', :f=>{:type=>'journal'})).to have_selector "a[href='/?f%5Btype%5D=journal']"
+      helper.render_constraints_query(:q=>'foobar', :f=>{:type=>'journal'}).should have_selector "a[href='/?f%5Btype%5D=journal']"
     end
   end
 
@@ -18,12 +18,12 @@ describe RenderConstraintsHelper do
       @config = Blacklight::Configuration.new do |config|
         config.add_facet_field 'type'
       end
-      allow(helper).to receive_messages(:blacklight_config => @config)
+      helper.stub(:blacklight_config => @config)
     end
     it "should have a link relative to the current url" do
       result = helper.render_filter_element('type', ['journal'], {:q=>'biz'})
-      expect(result.size).to eq(1)
-      expect(result.first).to have_link "Remove constraint Type: journal", href: "/?q=biz"
+      # I'm not certain how the ampersand gets in there. It's not important.
+      result.should have_selector "a[href='/?&q=biz']"
     end
   end
 

data/spec/helpers/search_history_constraints_helper_spec.rb

@@ -13,41 +13,41 @@ describe SearchHistoryConstraintsHelper do
   end
 
   before(:each) do
-    allow(helper).to receive(:blacklight_config).and_return(@config)
+    helper.stub(:blacklight_config).and_return(@config)
   end
 
   describe "render_search_to_s_*" do
     describe "render_search_to_s_element" do
       it "should render basic element" do
         response = helper.render_search_to_s_element("key", "value")
-        expect(response).to have_selector("span.constraint")  do |span|
-          expect(span).to have_selector("span.filterName", :content => "key:")
-          expect(span).to have_selector("span.filterValue", :content => "value")
+        response.should have_selector("span.constraint")  do |span|
+          span.should have_selector("span.filterName", :content => "key:")
+          span.should have_selector("span.filterValue", :content => "value")
         end
-        expect(response.html_safe?).to eq(true)
+        response.html_safe?.should == true
       end
       it "should escape them that need escaping" do
         response = helper.render_search_to_s_element("key>", "value>")
-        expect(response).to have_selector("span.constraint") do |span|          
-          expect(span).to have_selector("span.filterName") do |s2|
+        response.should have_selector("span.constraint") do |span|          
+          span.should have_selector("span.filterName") do |s2|
             # Note: nokogiri's gettext will unescape the inner html
             # which seems to be what rspecs "contains" method calls on 
             # text nodes - thus the to_s inserted below.
-            expect(s2.to_s).to match(/key>:/)
+            s2.to_s.should match(/key>:/)
           end
-          expect(span).to have_selector("span.filterValue") do |s3|            
-            expect(s3.to_s).to match(/value>/)
+          span.should have_selector("span.filterValue") do |s3|            
+            s3.to_s.should match(/value>/)
           end
         end
-        expect(response.html_safe?).to eq(true)
+        response.html_safe?.should == true
       end
       it "should not escape with options set thus" do
         response = helper.render_search_to_s_element("key>", "value>", :escape_key => false, :escape_value => false)
-        expect(response).to have_selector("span.constraint") do |span|
-          expect(span).to have_selector("span.filterName", :content => "key>:")
-          expect(span).to have_selector("span.filterValue", :content => "value>")
+        response.should have_selector("span.constraint") do |span|
+          span.should have_selector("span.filterName", :content => "key>:")
+          span.should have_selector("span.filterValue", :content => "value>")
         end
-        expect(response.html_safe?).to eq(true)
+        response.html_safe?.should == true
       end
     end
 
@@ -56,15 +56,15 @@ describe SearchHistoryConstraintsHelper do
         @params = {:q => "history", :f => {"some_facet" => ["value1", "value1"],  "other_facet" => ["other1"]}}        
       end
       it "should call lesser methods" do
-        allow(helper).to receive(:blacklight_config).and_return(@config)
-        allow(helper).to receive(:default_search_field).and_return(Blacklight::Configuration::SearchField.new(:key => 'default_search_field', :display_label => 'Default'))
-        allow(helper).to receive(:label_for_search_field).with(nil).and_return('')
+        helper.stub(:blacklight_config).and_return(@config)
+        helper.stub(:default_search_field).and_return(Blacklight::Configuration::SearchField.new(:key => 'default_search_field', :display_label => 'Default'))
+        helper.stub(:label_for_search_field).with(nil).and_return('')
         # API hooks expect this to be so
         response = helper.render_search_to_s(@params)
 
-        expect(response).to include( helper.render_search_to_s_q(@params))
-        expect(response).to include( helper.render_search_to_s_filters(@params))
-        expect(response.html_safe?).to eq(true)
+        response.should include( helper.render_search_to_s_q(@params))
+        response.should include( helper.render_search_to_s_filters(@params))
+        response.html_safe?.should == true
       end
     end
     

data/spec/lib/blacklight/routes_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper' 
+describe Blacklight::Routes do
+  subject { Blacklight::Routes.new(router, options) }
+  let(:router) { double }
+
+  describe "solr_document" do
+    describe "without constraints" do
+      let(:options) { Hash.new }
+      it "should define the resources" do
+        router.should_receive(:resources).with(:solr_document, {:path=>:records, :controller=>:records, :only=>[:show, :update]})
+        router.should_receive(:resources).with(:records, :only=>[:show, :update])
+        subject.solr_document(:records)
+      end
+    end
+
+    describe "with constraints" do
+      let(:options) { { :constraints => {id: /[a-z]+/, format: false } } }
+      it "should define the resources" do
+        router.should_receive(:resources).with(:solr_document, {:path=>:records, :controller=>:records, :only=>[:show, :update], :constraints=>{:id=>/[a-z]+/, :format=>false} })
+        router.should_receive(:resources).with(:records, :only=>[:show, :update], :constraints=>{:id=>/[a-z]+/, :format=>false})
+        subject.solr_document(:records)
+      end
+    end
+  end
+end

data/spec/lib/blacklight/solr/request_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Blacklight::Solr::Request do
+  before do
+    subject[:qt] = 'hey'
+    subject[:fq] = ["what's up.", "dood"]
+    subject['q'] = "what's"
+    subject[:wt] = "going"
+    subject[:start] = "on"
+    subject[:rows] = "Man"
+    subject['hl'] = "I"
+    subject['hl.fl'] = "wish"
+    subject['group'] = "I"
+    subject['defType'] = "had"
+    subject['spellcheck'] = "a"
+    subject['spellcheck.q'] = "fleece"
+    subject['f.title_facet.facet.limit'] = "vest"
+    subject['facet.field'] = [] 
+  end
+  it "should accept valid parameters" do
+    expect(subject.to_hash).to eq({"defType" => "had",
+       "f.title_facet.facet.limit" => "vest",
+       "fq" => ["what's up.", "dood"],
+       "group" => "I",
+       "hl" => "I",
+       "hl.fl" => "wish",
+       "q" => "what's",
+       "qt" => "hey",
+       "rows" => "Man",
+       "spellcheck" => "a",
+       "spellcheck.q" => "fleece",
+       "start" => "on",
+       "wt" => "going"
+    })
+  end
+
+end

data/spec/lib/blacklight/solr_response/group_response_spec.rb

@@ -12,9 +12,9 @@ describe Blacklight::SolrResponse::GroupResponse do
 
   describe "groups" do
     it "should return an array of Groups" do
-      expect(response.grouped).to be_a Array
+      response.grouped.should be_a Array
 
-      expect(group.groups.size).to eq(2)
+      expect(group.groups).to have(2).items
       group.groups.each do |group|
         expect(group).to be_a Blacklight::SolrResponse::Group
       end

data/spec/lib/blacklight_configurable_spec.rb

@@ -20,17 +20,17 @@ describe "Blacklight::Configurable" do
       end
     end
     it "should inherit the configuration when subclassed" do            
-      expect(TestCaseInheritence::Child.blacklight_config.list).to include(1,2,3)
+      TestCaseInheritence::Child.blacklight_config.list.should include(1,2,3)
     end
     
     it "inherited version should be a deep copy, not original" do      
-      expect(TestCaseInheritence::Child.blacklight_config).not_to  be(TestCaseInheritence::Parent.blacklight_config)
+      TestCaseInheritence::Child.blacklight_config.should_not  be(TestCaseInheritence::Parent.blacklight_config)
     
       TestCaseInheritence::Child.blacklight_config.list << "child_only"
 
 
-      expect(TestCaseInheritence::Child.blacklight_config.list).to include("child_only")      
-      expect(TestCaseInheritence::Parent.blacklight_config.list).not_to include("child_only")
+      TestCaseInheritence::Child.blacklight_config.list.should include("child_only")      
+      TestCaseInheritence::Parent.blacklight_config.list.should_not include("child_only")
     end    
   end
 
@@ -47,7 +47,7 @@ describe "Blacklight::Configurable" do
       a = Class.new
       a.send(:include, Blacklight::Configurable)
 
-      expect(a.blacklight_config.default_solr_params).to be_empty
+      a.blacklight_config.default_solr_params.should be_empty
     end
 
     it "should allow the user to provide a default configuration" do
@@ -56,7 +56,7 @@ describe "Blacklight::Configurable" do
       Blacklight::Configurable.default_configuration = Blacklight::Configuration.new :a => 1
 
       a.send(:include, Blacklight::Configurable)
-      expect(a.blacklight_config.a).to eq(1)
+      a.blacklight_config.a.should == 1
     end
     
     it "has configure_blacklight convenience method" do
@@ -67,7 +67,7 @@ describe "Blacklight::Configurable" do
         config.my_key = 'value'
       end 
       
-      expect(klass.blacklight_config.my_key).to eq('value')
+      klass.blacklight_config.my_key.should == 'value'
     end
 
     it "allows the instance to set a radically different config from the class" do
@@ -78,8 +78,8 @@ describe "Blacklight::Configurable" do
       instance = klass.new
       instance.blacklight_config = Blacklight::Configuration.new
       
-      expect(instance.blacklight_config).not_to eq(klass.blacklight_config)
-      expect(instance.blacklight_config.foo).to be_nil
+      instance.blacklight_config.should_not == klass.blacklight_config
+      instance.blacklight_config.foo.should be_nil
     end
     
     it "allows instance to set it's own config seperate from class" do
@@ -94,11 +94,11 @@ describe "Blacklight::Configurable" do
       
       instance = klass.new
       instance.blacklight_config.bar << "123"
-      expect(instance.blacklight_config).not_to eq(klass.blacklight_config)
-      expect(klass.blacklight_config.foo).to eq("bar")
-      expect(instance.blacklight_config.foo).to eq("bar")
-      expect(klass.blacklight_config.bar).not_to include("123")
-      expect(instance.blacklight_config.bar).to include("asd", "123")
+      instance.blacklight_config.should_not == klass.blacklight_config
+      klass.blacklight_config.foo.should == "bar"
+      instance.blacklight_config.foo.should == "bar"
+      klass.blacklight_config.bar.should_not include("123")
+      instance.blacklight_config.bar.should include("asd", "123")
     end
 
     it "configurable classes should not mutate the default configuration object" do
@@ -110,8 +110,8 @@ describe "Blacklight::Configurable" do
       klass2.send(:include, Blacklight::Configurable)
       klass2.blacklight_config.foo = "asdf"
 
-      expect(klass.blacklight_config.foo).to eq("bar")
-      expect(klass2.blacklight_config.foo).to eq("asdf")
+      klass.blacklight_config.foo.should == "bar"
+      klass2.blacklight_config.foo.should == "asdf"
     end
     
   end

data/spec/lib/blacklight_configuration_spec.rb

@@ -3,7 +3,7 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe "Blacklight::Configuration" do
-
+  
   before(:each) do
     @config = Blacklight::Configuration.new
   end
@@ -11,60 +11,60 @@ describe "Blacklight::Configuration" do
   it "should support arbitrary configuration values" do
     @config.a = 1
 
-    expect(@config.a).to eq(1)
-    expect(@config[:a]).to eq(1)
+    @config.a.should == 1
+    @config[:a].should == 1
   end
 
   describe "initialization" do
     it "should be an OpenStructWithHashAccess" do
-      expect(@config).to be_a_kind_of Blacklight::OpenStructWithHashAccess
+      @config.should be_a_kind_of Blacklight::OpenStructWithHashAccess
     end
 
     it "should accept a block for configuration" do
       config = Blacklight::Configuration.new(:a => 1) { |c| c.a = 2 }
 
-      expect(config.a).to eq(2)
+      config.a.should == 2
 
       config.configure { |c| c.a = 3 }
 
-      expect(config.a).to eq(3)
+      config.a.should == 3
     end
   end
 
   describe "defaults" do
     it "should have a hash of default rsolr query parameters" do
-      expect(@config.default_solr_params).to be_a_kind_of Hash
+      @config.default_solr_params.should be_a_kind_of Hash
     end
 
     it "should have openstruct values for show and index parameters" do
-      expect(@config.show).to be_a_kind_of OpenStruct
-      expect(@config.index).to be_a_kind_of OpenStruct
+      @config.show.should be_a_kind_of OpenStruct
+      @config.index.should be_a_kind_of OpenStruct
     end
 
     it "should introspect SolrDocument for sensible defaults  for show + index" do
-      expect(@config.show.html_title).to eq('id')
-      expect(@config.show.heading).to eq('id')
-      expect(@config.index.show_link).to eq('id')
+      @config.show.html_title.should == 'id'
+      @config.show.heading.should == 'id'
+      @config.index.show_link.should == 'id'
     end
 
     it "should have ordered hashes for field configuration" do
-      expect(@config.facet_fields).to be_a_kind_of ActiveSupport::OrderedHash
-      expect(@config.index_fields).to be_a_kind_of ActiveSupport::OrderedHash
-      expect(@config.show_fields).to be_a_kind_of ActiveSupport::OrderedHash
-      expect(@config.search_fields).to be_a_kind_of ActiveSupport::OrderedHash
-      expect(@config.show_fields).to be_a_kind_of ActiveSupport::OrderedHash
-      expect(@config.search_fields).to be_a_kind_of ActiveSupport::OrderedHash
-      expect(@config.sort_fields).to be_a_kind_of ActiveSupport::OrderedHash
+      @config.facet_fields.should be_a_kind_of ActiveSupport::OrderedHash
+      @config.index_fields.should be_a_kind_of ActiveSupport::OrderedHash
+      @config.show_fields.should be_a_kind_of ActiveSupport::OrderedHash
+      @config.search_fields.should be_a_kind_of ActiveSupport::OrderedHash
+      @config.show_fields.should be_a_kind_of ActiveSupport::OrderedHash
+      @config.search_fields.should be_a_kind_of ActiveSupport::OrderedHash
+      @config.sort_fields.should be_a_kind_of ActiveSupport::OrderedHash
     end
   end
 
   describe "spell_max" do
     it "should default to 5" do
-      expect(Blacklight::Configuration.new.spell_max).to eq(5)
+      Blacklight::Configuration.new.spell_max.should == 5
     end
-
+    
     it "should accept config'd value" do
-      expect(Blacklight::Configuration.new(:spell_max => 10).spell_max).to eq(10)
+      Blacklight::Configuration.new(:spell_max => 10).spell_max.should == 10
     end
   end
 
@@ -76,8 +76,8 @@ describe "Blacklight::Configuration" do
       @mock_facet = Blacklight::Configuration::FacetField.new
       config_copy.add_facet_field "dummy_field", @mock_facet
 
-      expect(@config.a).to be_nil
-      expect(@config.facet_fields).not_to include(@mock_facet)
+      @config.a.should be_nil
+      @config.facet_fields.should_not include(@mock_facet)
     end
   end
 
@@ -89,9 +89,9 @@ describe "Blacklight::Configuration" do
         config.add_my_custom_field 'qwerty', :label => "asdf"
       end
 
+      
 
-
-      expect(config.my_custom_fields.keys).to include('qwerty')
+      config.my_custom_fields.keys.should include('qwerty')
     end
 
     it "should let you define a field accessor that uses an existing field-type" do
@@ -102,37 +102,37 @@ describe "Blacklight::Configuration" do
         config.add_my_custom_facet_field 'qwerty', :label => "asdf"
       end
 
+      
 
-
-      expect(config.my_custom_facet_fields['qwerty']).to be_a_kind_of(Blacklight::Configuration::FacetField)
+      config.my_custom_facet_fields['qwerty'].should be_a_kind_of(Blacklight::Configuration::FacetField)
     end
 
   end
-
+  
   describe "add_facet_field" do
     it "should accept field name and hash form arg" do
       @config.add_facet_field('format',  :label => "Format", :limit => true)
-
-      expect(@config.facet_fields["format"]).not_to be_nil
-      expect(@config.facet_fields["format"]["label"]).to eq("Format")
-      expect(@config.facet_fields["format"]["limit"]).to eq(true)
+      
+      @config.facet_fields["format"].should_not be_nil
+      @config.facet_fields["format"]["label"].should == "Format"
+      @config.facet_fields["format"]["limit"].should == true
     end
 
     it "should accept FacetField obj arg" do
       @config.add_facet_field("format", Blacklight::Configuration::FacetField.new( :label => "Format"))
-
-      expect(@config.facet_fields["format"]).not_to be_nil
-      expect(@config.facet_fields["format"]["label"]).to eq("Format")
+      
+      @config.facet_fields["format"].should_not be_nil
+      @config.facet_fields["format"]["label"].should == "Format"
     end
-
+    
     it "should accept field name and block form" do
-      @config.add_facet_field("format") do |facet|
+      @config.add_facet_field("format") do |facet|        
         facet.label = "Format"
         facet.limit = true
       end
-
-      expect(@config.facet_fields["format"]).not_to be_nil
-      expect(@config.facet_fields["format"].limit).to eq(true)
+      
+      @config.facet_fields["format"].should_not be_nil
+      @config.facet_fields["format"].limit.should == true
     end
 
     it "should accept block form" do
@@ -141,208 +141,208 @@ describe "Blacklight::Configuration" do
         facet.label = "Format"
       end
 
-      expect(@config.facet_fields['format']).not_to be_nil
+      @config.facet_fields['format'].should_not be_nil
     end
 
     it "should accept a configuration hash" do
       @config.add_facet_field :field => 'format', :label => 'Format'
-      expect(@config.facet_fields['format']).not_to be_nil
+      @config.facet_fields['format'].should_not be_nil
     end
 
     it "should accept array form" do
       @config.add_facet_field([{ :field => 'format', :label => 'Format'}, { :field => 'publication_date', :label => 'Publication Date' }])
 
-      expect(@config.facet_fields.length).to eq(2)
+      @config.facet_fields.length.should == 2
     end
 
     it "should create default label from titleized solr field" do
       @config.add_facet_field("publication_date")
-
-      expect(@config.facet_fields["publication_date"].label).to eq("Publication Date")
+        
+      @config.facet_fields["publication_date"].label.should == "Publication Date"
     end
 
     it "should allow you to not show the facet in the facet bar" do
       @config.add_facet_field("publication_date", :show=>false)
-
-      expect(@config.facet_fields["publication_date"]['show']).to eq false
+        
+      @config.facet_fields["publication_date"]['show'].should be_false
     end
-
+    
     it "should raise on nil solr field name" do
-      expect { @config.add_facet_field(nil) }.to raise_error ArgumentError
+      lambda { @config.add_facet_field(nil) }.should raise_error ArgumentError
     end
-
+    
   end
-
+  
   describe "add_index_field" do
     it "takes hash form" do
       @config.add_index_field("title_display", :label => "Title")
-
-      expect(@config.index_fields["title_display"]).not_to be_nil
-      expect(@config.index_fields["title_display"].label).to eq("Title")
+      
+      @config.index_fields["title_display"].should_not be_nil
+      @config.index_fields["title_display"].label.should == "Title"
     end
     it "takes IndexField param" do
       @config.add_index_field("title_display", Blacklight::Configuration::IndexField.new(:field => "title_display", :label => "Title"))
-
-      expect(@config.index_fields["title_display"]).not_to be_nil
-      expect(@config.index_fields["title_display"].label).to eq("Title")
+      
+      @config.index_fields["title_display"].should_not be_nil
+      @config.index_fields["title_display"].label.should == "Title"
     end
     it "takes block form" do
-      @config.add_index_field("title_display") do |field|
+      @config.add_index_field("title_display") do |field|        
         field.label = "Title"
       end
-      expect(@config.index_fields["title_display"]).not_to be_nil
-      expect(@config.index_fields["title_display"].label).to eq("Title")
+      @config.index_fields["title_display"].should_not be_nil
+      @config.index_fields["title_display"].label.should == "Title"
     end
-
+    
     it "creates default label from titleized field" do
       @config.add_index_field("title_display")
-
-      expect(@config.index_fields["title_display"].label).to eq("Title Display")
+      
+      @config.index_fields["title_display"].label.should == "Title Display"
     end
-
+    
     it "should raise on nil solr field name" do
-      expect { @config.add_index_field(nil) }.to raise_error ArgumentError
+      lambda { @config.add_index_field(nil) }.should raise_error ArgumentError
     end
 
   end
-
+  
   describe "add_show_field" do
     it "takes hash form" do
       @config.add_show_field("title_display", :label => "Title")
-
-      expect(@config.show_fields["title_display"]).not_to be_nil
-      expect(@config.show_fields["title_display"].label).to eq("Title")
+      
+      @config.show_fields["title_display"].should_not be_nil
+      @config.show_fields["title_display"].label.should == "Title"
     end
     it "takes ShowField argument" do
       @config.add_show_field("title_display", Blacklight::Configuration::ShowField.new(:field => "title_display", :label => "Title"))
-
-      expect(@config.show_fields["title_display"]).not_to be_nil
-      expect(@config.show_fields["title_display"].label).to eq("Title")
+      
+      @config.show_fields["title_display"].should_not be_nil
+      @config.show_fields["title_display"].label.should == "Title"
     end
     it "takes block form" do
-      @config.add_show_field("title_display") do |f|
+      @config.add_show_field("title_display") do |f|        
         f.label = "Title"
       end
-
-      expect(@config.show_fields["title_display"]).not_to be_nil
-      expect(@config.show_fields["title_display"].label).to eq("Title")
+      
+      @config.show_fields["title_display"].should_not be_nil
+      @config.show_fields["title_display"].label.should == "Title"
     end
-
+    
     it "creates default label humanized from field" do
       @config.add_show_field("my_custom_field")
-
-      expect(@config.show_fields["my_custom_field"].label).to eq("My Custom Field")
+      
+      @config.show_fields["my_custom_field"].label.should == "My Custom Field"
     end
-
+    
     it "should raise on nil solr field name" do
-      expect { @config.add_show_field(nil) }.to raise_error ArgumentError
+      lambda { @config.add_show_field(nil) }.should raise_error ArgumentError
     end
-
+       
   end
-
-
+    
+  
   describe "add_search_field" do
     it "should accept hash form" do
       c = Blacklight::Configuration.new
       c.add_search_field(:key => "my_search_key")
-      expect(c.search_fields["my_search_key"]).not_to be_nil
+      c.search_fields["my_search_key"].should_not be_nil
     end
 
     it "should accept two-arg hash form" do
       c = Blacklight::Configuration.new
-
+      
       c.add_search_field("my_search_type",
           :key => "my_search_type",
-          :solr_parameters => { :qf => "my_field_qf^10" },
+          :solr_parameters => { :qf => "my_field_qf^10" }, 
           :solr_local_parameters => { :pf=>"$my_field_pf"})
-
+      
       field = c.search_fields["my_search_type"]
-
-      expect(field).not_to be_nil
-
-
-      expect(field.solr_parameters).not_to be_nil
-      expect(field.solr_local_parameters).not_to be_nil
-
-
-    end
-
+      
+      field.should_not be_nil
+      
+      
+      field.solr_parameters.should_not be_nil
+      field.solr_local_parameters.should_not be_nil  
+      
+      
+    end
+    
     it "should accept block form" do
       c = Blacklight::Configuration.new
-
-      c.add_search_field("some_field") do |field|
+      
+      c.add_search_field("some_field") do |field|        
         field.solr_parameters = {:qf => "solr_field^10"}
         field.solr_local_parameters = {:pf => "$some_field_pf"}
       end
-
+      
       f = c.search_fields["some_field"]
-
-      expect(f).not_to be_nil
-      expect(f.solr_parameters).not_to be_nil
-      expect(f.solr_local_parameters).not_to be_nil
+      
+      f.should_not be_nil
+      f.solr_parameters.should_not be_nil
+      f.solr_local_parameters.should_not be_nil      
     end
-
+    
     it "should accept SearchField object" do
       c = Blacklight::Configuration.new
-
+      
       f = Blacklight::Configuration::SearchField.new( :foo => "bar")
-
+      
       c.add_search_field("foo", f)
-
-      expect(c.search_fields["foo"]).not_to be_nil
+      
+      c.search_fields["foo"].should_not be_nil
     end
-
+    
     it "should raise on nil key" do
-      expect {@config.add_search_field(nil, :foo => "bar")}.to raise_error ArgumentError
+      lambda {@config.add_search_field(nil, :foo => "bar")}.should raise_error ArgumentError
     end
-
+    
     it "creates default label from titleized field key" do
       @config.add_search_field("author_name")
-
-      expect(@config.search_fields["author_name"].label).to eq("Author Name")
+      
+      @config.search_fields["author_name"].label.should == "Author Name"
     end
-
-
+                
+        
   end
-
+  
   describe "add_sort_field" do
     it "should take a hash" do
       c = Blacklight::Configuration.new
       c.add_sort_field(:key => "my_sort_key", :sort => "score desc")
-      expect(c.sort_fields["my_sort_key"]).not_to be_nil
+      c.sort_fields["my_sort_key"].should_not be_nil
     end
 
     it "should take a two-arg form with a hash" do
-      @config.add_sort_field("score desc, pub_date_sort desc, title_sort asc", :label => "relevance")
-
+      @config.add_sort_field("score desc, pub_date_sort desc, title_sort asc", :label => "relevance") 
 
-      expect(@config.sort_fields.values.find{|f| f.label == "relevance"}).not_to be_nil
+      
+      @config.sort_fields.values.find{|f| f.label == "relevance"}.should_not be_nil
     end
-
+    
     it "should take a SortField object" do
       @config.add_sort_field(Blacklight::Configuration::SortField.new(:label => "relevance", :sort => "score desc, pub_date_sort desc, title_sort asc"
-))
-      expect(@config.sort_fields.values.find{|f| f.label == "relevance"}).not_to be_nil
+))     
+      @config.sort_fields.values.find{|f| f.label == "relevance"}.should_not be_nil
     end
-
+    
     it "should take block form" do
       @config.add_sort_field do |field|
         field.label = "relevance"
         field.sort = "score desc, pub_date_sort desc, title_sort asc"
       end
-
-      expect(@config.sort_fields.values.find{|f| f.label == "relevance"}).not_to be_nil
+      
+      @config.sort_fields.values.find{|f| f.label == "relevance"}.should_not be_nil
 
     end
   end
-
+  
   describe "#default_search_field" do
     it "should use the field with a :default key" do
       @config.add_search_field('search_field_1')
       @config.add_search_field('search_field_2', :default => true)
 
-      expect(@config.default_search_field.key).to eq('search_field_2')
+      @config.default_search_field.key.should == 'search_field_2'
     end
   end
-
+  
 end