blacklight 4.7.0 → 4.8.0

data/spec/helpers/hash_as_hidden_fields_spec.rb

@@ -6,19 +6,25 @@ 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)
 
-    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']")
-    
+    expect(generated).to have_selector("input[type='hidden'][name='q'][value='query']")
+    expect(generated).to have_selector("input[type='hidden'][name='per_page'][value='10']")
+    expect(generated).to have_selector("input[type='hidden'][name='page'][value='5']")
+    expect(generated).to have_selector("input[type='hidden'][name='extra_arbitrary_key'][value='arbitrary_value']")
+    expect(generated).to have_selector("input[type='hidden'][name='f[field2][]'][value='z']")
+    expect(generated).to have_selector("input[type='hidden'][name='f[field1][]'][value='a']")
+    expect(generated).to have_selector("input[type='hidden'][name='f[field1][]'][value='b']")
+
   end
 
 end

data/spec/helpers/html_head_helper_spec.rb

@@ -1,10 +1,16 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 describe HtmlHeadHelper do
+  around(:each) do |example|
+    tmp_value = Capybara.ignore_hidden_elements
+    Capybara.ignore_hidden_elements = false
+    example.run
+    Capybara.ignore_hidden_elements = tmp_value
+  end
 
   describe "render_js_includes" do
-    helper do 
+    helper do
       def javascript_includes
-        [ 
+        [
           ["some_js.js", {:plugin => :blacklight}],
           ["other_js"]
         ]
@@ -16,27 +22,27 @@ describe HtmlHeadHelper do
         helper.render_js_includes
       end
 
-      if Rails::VERSION::MAJOR == 4 
-        html.should have_selector("script[src='/javascripts/some_js.js']")
-        html.should have_selector("script[src='/javascripts/other_js.js']")      
+      if Rails::VERSION::MAJOR == 4
+        expect(html).to have_selector("script[src='/javascripts/some_js.js']")
+        expect(html).to have_selector("script[src='/javascripts/other_js.js']")
       elsif use_asset_pipeline?
         # only for rails 3 with asset pipeline enabled
-        html.should have_selector("script[src='/assets/some_js.js'][type='text/javascript']")
-        html.should have_selector("script[src='/assets/other_js.js'][type='text/javascript']")
+        expect(html).to have_selector("script[src='/assets/some_js.js'][type='text/javascript']")
+        expect(html).to have_selector("script[src='/assets/other_js.js'][type='text/javascript']")
       else
         # rails 3 with asset pipeline disabled
-        html.should have_selector("script[src='/javascripts/some_js.js'][type='text/javascript']")
-        html.should have_selector("script[src='/javascripts/other_js.js'][type='text/javascript']")      
+        expect(html).to have_selector("script[src='/javascripts/some_js.js'][type='text/javascript']")
+        expect(html).to have_selector("script[src='/javascripts/other_js.js'][type='text/javascript']")
       end
 
-      html.html_safe?.should == true
+      expect(html.html_safe?).to eq(true)
     end
   end
 
   describe "render_stylesheet_links" do
-    helper do 
+    helper do
       def stylesheet_links
-        [ 
+        [
           ["my_stylesheet", {:plugin => :blacklight}],
           ["other_stylesheet"]
         ]
@@ -48,23 +54,23 @@ describe HtmlHeadHelper do
         helper.render_stylesheet_includes
       end
 
-      if Rails::VERSION::MAJOR == 4 
-        html.should have_selector("link[href='/stylesheets/my_stylesheet.css'][rel='stylesheet']")
-        html.should have_selector("link[href='/stylesheets/other_stylesheet.css'][rel='stylesheet']")
+      if Rails::VERSION::MAJOR == 4
+        expect(html).to have_selector("link[href='/stylesheets/my_stylesheet.css'][rel='stylesheet']")
+        expect(html).to have_selector("link[href='/stylesheets/other_stylesheet.css'][rel='stylesheet']")
       elsif use_asset_pipeline?
-        html.should have_selector("link[href='/assets/my_stylesheet.css'][rel='stylesheet'][type='text/css']")
-        html.should have_selector("link[href='/assets/other_stylesheet.css'][rel='stylesheet'][type='text/css']")
+        expect(html).to have_selector("link[href='/assets/my_stylesheet.css'][rel='stylesheet'][type='text/css']")
+        expect(html).to have_selector("link[href='/assets/other_stylesheet.css'][rel='stylesheet'][type='text/css']")
       else
-        html.should have_selector("link[href='/stylesheets/my_stylesheet.css'][rel='stylesheet'][type='text/css']")
-        html.should have_selector("link[href='/stylesheets/other_stylesheet.css'][rel='stylesheet'][type='text/css']")
+        expect(html).to have_selector("link[href='/stylesheets/my_stylesheet.css'][rel='stylesheet'][type='text/css']")
+        expect(html).to have_selector("link[href='/stylesheets/other_stylesheet.css'][rel='stylesheet'][type='text/css']")
       end
 
-      html.html_safe?.should == true
+      expect(html.html_safe?).to eq(true)
     end
   end
-  
+
   describe "render_extra_head_content" do
-    helper do 
+    helper do
       def extra_head_content
         ['<link rel="a">', '<link rel="b">']
       end
@@ -76,10 +82,10 @@ describe HtmlHeadHelper do
         helper.render_extra_head_content
       end
 
-      html.should have_selector("link[rel=a]")
-      html.should have_selector("link[rel=b]")
+      expect(html).to have_selector("link[rel=a]")
+      expect(html).to have_selector("link[rel=b]")
 
-      html.html_safe?.should == true
+      expect(html.html_safe?).to eq(true)
     end
   end
 
@@ -87,14 +93,14 @@ describe HtmlHeadHelper do
     describe "with no methods defined" do
       it "should return empty string without complaint" do
         Deprecation.silence(Blacklight::HtmlHeadHelperBehavior) do
-          lambda {helper.render_head_content}.should_not raise_error
-          helper.render_head_content.should be_blank
-          helper.render_head_content.html_safe?.should == true
+          expect {helper.render_head_content}.not_to raise_error
+          expect(helper.render_head_content).to be_blank
+          expect(helper.render_head_content.html_safe?).to eq(true)
         end
       end
     end
     describe "with methods defined" do
-      helper do 
+      helper do
         def javascript_includes
           [["my_js"]]
         end
@@ -104,47 +110,47 @@ describe HtmlHeadHelper do
         def extra_head_content
           [
             "<madeup_tag></madeup_tag>",
-            '<link rel="rel" type="type" href="href">' 
+            '<link rel="rel" type="type" href="href">'
           ]
         end
       end
       before(:each) do
-        helper.should_receive(:content_for).with(:head).and_return("<meta keywords=\"foo bar\"/>".html_safe)
+        expect(helper).to receive(:content_for).with(:head).and_return("<meta keywords=\"foo bar\"/>".html_safe)
 
         @output = Deprecation.silence(Blacklight::HtmlHeadHelperBehavior) do
           helper.render_head_content
         end
       end
       it "should include extra_head_content" do
-        @output.should have_selector("madeup_tag")
-        @output.should have_selector("link[rel=rel][type=type][href=href]")
+        expect(@output).to have_selector("madeup_tag")
+        expect(@output).to have_selector("link[rel=rel][type=type][href=href]")
       end
       it "should include render_javascript_includes" do
-        if Rails::VERSION::MAJOR == 4 
-          @output.should have_selector("script[src='/javascripts/my_js.js']")
+        if Rails::VERSION::MAJOR == 4
+          expect(@output).to have_selector("script[src='/javascripts/my_js.js']")
         else
-          @output.should have_selector("script[src='/assets/my_js.js'][type='text/javascript']")
+          expect(@output).to have_selector("script[src='/assets/my_js.js'][type='text/javascript']")
         end
       end
       it "should include render_stylesheet_links" do
-        if Rails::VERSION::MAJOR == 4 
-          @output.should have_selector("link[href='/stylesheets/my_css.css']")
+        if Rails::VERSION::MAJOR == 4
+          expect(@output).to have_selector("link[href='/stylesheets/my_css.css']")
         else
-          @output.should have_selector("link[href='/assets/my_css.css'][type='text/css']")
+          expect(@output).to have_selector("link[href='/assets/my_css.css'][type='text/css']")
         end
       end
       it "should include content_for :head" do
-        @output.should have_selector("meta[keywords]")
+        expect(@output).to have_selector("meta[keywords]")
       end
 
       it "should include all head content" do
-        helper.should_receive(:render_extra_head_content).and_return("".html_safe)
-        helper.should_receive(:render_js_includes).and_return("".html_safe)
-        helper.should_receive(:render_stylesheet_includes).and_return("".html_safe)
-        helper.should_receive(:content_for).with(:head).and_return("".html_safe)
+        expect(helper).to receive(:render_extra_head_content).and_return("".html_safe)
+        expect(helper).to receive(:render_js_includes).and_return("".html_safe)
+        expect(helper).to receive(:render_stylesheet_includes).and_return("".html_safe)
+        expect(helper).to receive(:content_for).with(:head).and_return("".html_safe)
 
         Deprecation.silence(Blacklight::HtmlHeadHelperBehavior) do
-          helper.render_head_content.should be_html_safe
+          expect(helper.render_head_content).to be_html_safe
         end
       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
-      helper.render_constraints_query(:q=>'foobar', :f=>{:type=>'journal'}).should have_selector "a[href='/?f%5Btype%5D=journal']"
+      expect(helper.render_constraints_query(:q=>'foobar', :f=>{:type=>'journal'})).to have_selector "a[href='/?f%5Btype%5D=journal']"
     end
   end
 
@@ -18,13 +18,12 @@ describe RenderConstraintsHelper do
       @config = Blacklight::Configuration.new do |config|
         config.add_facet_field 'type'
       end
-      helper.stub(:blacklight_config => @config)
+      allow(helper).to receive_messages(:blacklight_config => @config)
     end
     it "should have a link relative to the current url" do
       result = helper.render_filter_element('type', ['journal'], {:q=>'biz'})
-      result.size.should == 1
-      # I'm not certain how the ampersand gets in there. It's not important.
-      result.first.should have_selector "a[href='/?&q=biz']"
+      expect(result.size).to eq(1)
+      expect(result.first).to have_link "Remove constraint Type: journal", 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
-    helper.stub(:blacklight_config).and_return(@config)
+    allow(helper).to receive(: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")
-        response.should have_selector("span.constraint")  do |span|
-          span.should have_selector("span.filterName", :content => "key:")
-          span.should have_selector("span.filterValue", :content => "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")
         end
-        response.html_safe?.should == true
+        expect(response.html_safe?).to eq(true)
       end
       it "should escape them that need escaping" do
         response = helper.render_search_to_s_element("key>", "value>")
-        response.should have_selector("span.constraint") do |span|          
-          span.should have_selector("span.filterName") do |s2|
+        expect(response).to have_selector("span.constraint") do |span|          
+          expect(span).to 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.
-            s2.to_s.should match(/key>:/)
+            expect(s2.to_s).to match(/key>:/)
           end
-          span.should have_selector("span.filterValue") do |s3|            
-            s3.to_s.should match(/value>/)
+          expect(span).to have_selector("span.filterValue") do |s3|            
+            expect(s3.to_s).to match(/value>/)
           end
         end
-        response.html_safe?.should == true
+        expect(response.html_safe?).to eq(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)
-        response.should have_selector("span.constraint") do |span|
-          span.should have_selector("span.filterName", :content => "key>:")
-          span.should have_selector("span.filterValue", :content => "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>")
         end
-        response.html_safe?.should == true
+        expect(response.html_safe?).to eq(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
-        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('')
+        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('')
         # API hooks expect this to be so
         response = helper.render_search_to_s(@params)
 
-        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
+        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)
       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
-      response.grouped.should be_a Array
+      expect(response.grouped).to be_a Array
 
-      expect(group.groups).to have(2).items
+      expect(group.groups.size).to eq(2)
       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            
-      TestCaseInheritence::Child.blacklight_config.list.should include(1,2,3)
+      expect(TestCaseInheritence::Child.blacklight_config.list).to include(1,2,3)
     end
     
     it "inherited version should be a deep copy, not original" do      
-      TestCaseInheritence::Child.blacklight_config.should_not  be(TestCaseInheritence::Parent.blacklight_config)
+      expect(TestCaseInheritence::Child.blacklight_config).not_to  be(TestCaseInheritence::Parent.blacklight_config)
     
       TestCaseInheritence::Child.blacklight_config.list << "child_only"
 
 
-      TestCaseInheritence::Child.blacklight_config.list.should include("child_only")      
-      TestCaseInheritence::Parent.blacklight_config.list.should_not include("child_only")
+      expect(TestCaseInheritence::Child.blacklight_config.list).to include("child_only")      
+      expect(TestCaseInheritence::Parent.blacklight_config.list).not_to include("child_only")
     end    
   end
 
@@ -47,7 +47,7 @@ describe "Blacklight::Configurable" do
       a = Class.new
       a.send(:include, Blacklight::Configurable)
 
-      a.blacklight_config.default_solr_params.should be_empty
+      expect(a.blacklight_config.default_solr_params).to 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)
-      a.blacklight_config.a.should == 1
+      expect(a.blacklight_config.a).to eq(1)
     end
     
     it "has configure_blacklight convenience method" do
@@ -67,7 +67,7 @@ describe "Blacklight::Configurable" do
         config.my_key = 'value'
       end 
       
-      klass.blacklight_config.my_key.should == 'value'
+      expect(klass.blacklight_config.my_key).to eq('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
       
-      instance.blacklight_config.should_not == klass.blacklight_config
-      instance.blacklight_config.foo.should be_nil
+      expect(instance.blacklight_config).not_to eq(klass.blacklight_config)
+      expect(instance.blacklight_config.foo).to 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"
-      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")
+      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")
     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"
 
-      klass.blacklight_config.foo.should == "bar"
-      klass2.blacklight_config.foo.should == "asdf"
+      expect(klass.blacklight_config.foo).to eq("bar")
+      expect(klass2.blacklight_config.foo).to eq("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
 
-    @config.a.should == 1
-    @config[:a].should == 1
+    expect(@config.a).to eq(1)
+    expect(@config[:a]).to eq(1)
   end
 
   describe "initialization" do
     it "should be an OpenStructWithHashAccess" do
-      @config.should be_a_kind_of Blacklight::OpenStructWithHashAccess
+      expect(@config).to 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 }
 
-      config.a.should == 2
+      expect(config.a).to eq(2)
 
       config.configure { |c| c.a = 3 }
 
-      config.a.should == 3
+      expect(config.a).to eq(3)
     end
   end
 
   describe "defaults" do
     it "should have a hash of default rsolr query parameters" do
-      @config.default_solr_params.should be_a_kind_of Hash
+      expect(@config.default_solr_params).to be_a_kind_of Hash
     end
 
     it "should have openstruct values for show and index parameters" do
-      @config.show.should be_a_kind_of OpenStruct
-      @config.index.should be_a_kind_of OpenStruct
+      expect(@config.show).to be_a_kind_of OpenStruct
+      expect(@config.index).to be_a_kind_of OpenStruct
     end
 
     it "should introspect SolrDocument for sensible defaults  for show + index" do
-      @config.show.html_title.should == 'id'
-      @config.show.heading.should == 'id'
-      @config.index.show_link.should == 'id'
+      expect(@config.show.html_title).to eq('id')
+      expect(@config.show.heading).to eq('id')
+      expect(@config.index.show_link).to eq('id')
     end
 
     it "should have ordered hashes for field configuration" do
-      @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
+      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
     end
   end
 
   describe "spell_max" do
     it "should default to 5" do
-      Blacklight::Configuration.new.spell_max.should == 5
+      expect(Blacklight::Configuration.new.spell_max).to eq(5)
     end
-    
+
     it "should accept config'd value" do
-      Blacklight::Configuration.new(:spell_max => 10).spell_max.should == 10
+      expect(Blacklight::Configuration.new(:spell_max => 10).spell_max).to eq(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
 
-      @config.a.should be_nil
-      @config.facet_fields.should_not include(@mock_facet)
+      expect(@config.a).to be_nil
+      expect(@config.facet_fields).not_to include(@mock_facet)
     end
   end
 
@@ -89,9 +89,9 @@ describe "Blacklight::Configuration" do
         config.add_my_custom_field 'qwerty', :label => "asdf"
       end
 
-      
 
-      config.my_custom_fields.keys.should include('qwerty')
+
+      expect(config.my_custom_fields.keys).to 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
 
-      
 
-      config.my_custom_facet_fields['qwerty'].should be_a_kind_of(Blacklight::Configuration::FacetField)
+
+      expect(config.my_custom_facet_fields['qwerty']).to 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)
-      
-      @config.facet_fields["format"].should_not be_nil
-      @config.facet_fields["format"]["label"].should == "Format"
-      @config.facet_fields["format"]["limit"].should == 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)
     end
 
     it "should accept FacetField obj arg" do
       @config.add_facet_field("format", Blacklight::Configuration::FacetField.new( :label => "Format"))
-      
-      @config.facet_fields["format"].should_not be_nil
-      @config.facet_fields["format"]["label"].should == "Format"
+
+      expect(@config.facet_fields["format"]).not_to be_nil
+      expect(@config.facet_fields["format"]["label"]).to eq("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
-      
-      @config.facet_fields["format"].should_not be_nil
-      @config.facet_fields["format"].limit.should == true
+
+      expect(@config.facet_fields["format"]).not_to be_nil
+      expect(@config.facet_fields["format"].limit).to eq(true)
     end
 
     it "should accept block form" do
@@ -141,208 +141,208 @@ describe "Blacklight::Configuration" do
         facet.label = "Format"
       end
 
-      @config.facet_fields['format'].should_not be_nil
+      expect(@config.facet_fields['format']).not_to be_nil
     end
 
     it "should accept a configuration hash" do
       @config.add_facet_field :field => 'format', :label => 'Format'
-      @config.facet_fields['format'].should_not be_nil
+      expect(@config.facet_fields['format']).not_to be_nil
     end
 
     it "should accept array form" do
       @config.add_facet_field([{ :field => 'format', :label => 'Format'}, { :field => 'publication_date', :label => 'Publication Date' }])
 
-      @config.facet_fields.length.should == 2
+      expect(@config.facet_fields.length).to eq(2)
     end
 
     it "should create default label from titleized solr field" do
       @config.add_facet_field("publication_date")
-        
-      @config.facet_fields["publication_date"].label.should == "Publication Date"
+
+      expect(@config.facet_fields["publication_date"].label).to eq("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)
-        
-      @config.facet_fields["publication_date"]['show'].should be_false
+
+      expect(@config.facet_fields["publication_date"]['show']).to eq false
     end
-    
+
     it "should raise on nil solr field name" do
-      lambda { @config.add_facet_field(nil) }.should raise_error ArgumentError
+      expect { @config.add_facet_field(nil) }.to raise_error ArgumentError
     end
-    
+
   end
-  
+
   describe "add_index_field" do
     it "takes hash form" do
       @config.add_index_field("title_display", :label => "Title")
-      
-      @config.index_fields["title_display"].should_not be_nil
-      @config.index_fields["title_display"].label.should == "Title"
+
+      expect(@config.index_fields["title_display"]).not_to be_nil
+      expect(@config.index_fields["title_display"].label).to eq("Title")
     end
     it "takes IndexField param" do
       @config.add_index_field("title_display", Blacklight::Configuration::IndexField.new(:field => "title_display", :label => "Title"))
-      
-      @config.index_fields["title_display"].should_not be_nil
-      @config.index_fields["title_display"].label.should == "Title"
+
+      expect(@config.index_fields["title_display"]).not_to be_nil
+      expect(@config.index_fields["title_display"].label).to eq("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
-      @config.index_fields["title_display"].should_not be_nil
-      @config.index_fields["title_display"].label.should == "Title"
+      expect(@config.index_fields["title_display"]).not_to be_nil
+      expect(@config.index_fields["title_display"].label).to eq("Title")
     end
-    
+
     it "creates default label from titleized field" do
       @config.add_index_field("title_display")
-      
-      @config.index_fields["title_display"].label.should == "Title Display"
+
+      expect(@config.index_fields["title_display"].label).to eq("Title Display")
     end
-    
+
     it "should raise on nil solr field name" do
-      lambda { @config.add_index_field(nil) }.should raise_error ArgumentError
+      expect { @config.add_index_field(nil) }.to raise_error ArgumentError
     end
 
   end
-  
+
   describe "add_show_field" do
     it "takes hash form" do
       @config.add_show_field("title_display", :label => "Title")
-      
-      @config.show_fields["title_display"].should_not be_nil
-      @config.show_fields["title_display"].label.should == "Title"
+
+      expect(@config.show_fields["title_display"]).not_to be_nil
+      expect(@config.show_fields["title_display"].label).to eq("Title")
     end
     it "takes ShowField argument" do
       @config.add_show_field("title_display", Blacklight::Configuration::ShowField.new(:field => "title_display", :label => "Title"))
-      
-      @config.show_fields["title_display"].should_not be_nil
-      @config.show_fields["title_display"].label.should == "Title"
+
+      expect(@config.show_fields["title_display"]).not_to be_nil
+      expect(@config.show_fields["title_display"].label).to eq("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
-      
-      @config.show_fields["title_display"].should_not be_nil
-      @config.show_fields["title_display"].label.should == "Title"
+
+      expect(@config.show_fields["title_display"]).not_to be_nil
+      expect(@config.show_fields["title_display"].label).to eq("Title")
     end
-    
+
     it "creates default label humanized from field" do
       @config.add_show_field("my_custom_field")
-      
-      @config.show_fields["my_custom_field"].label.should == "My Custom Field"
+
+      expect(@config.show_fields["my_custom_field"].label).to eq("My Custom Field")
     end
-    
+
     it "should raise on nil solr field name" do
-      lambda { @config.add_show_field(nil) }.should raise_error ArgumentError
+      expect { @config.add_show_field(nil) }.to 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")
-      c.search_fields["my_search_key"].should_not be_nil
+      expect(c.search_fields["my_search_key"]).not_to 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"]
-      
-      field.should_not be_nil
-      
-      
-      field.solr_parameters.should_not be_nil
-      field.solr_local_parameters.should_not be_nil  
-      
-      
-    end
-    
+
+      expect(field).not_to be_nil
+
+
+      expect(field.solr_parameters).not_to be_nil
+      expect(field.solr_local_parameters).not_to 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"]
-      
-      f.should_not be_nil
-      f.solr_parameters.should_not be_nil
-      f.solr_local_parameters.should_not be_nil      
+
+      expect(f).not_to be_nil
+      expect(f.solr_parameters).not_to be_nil
+      expect(f.solr_local_parameters).not_to 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)
-      
-      c.search_fields["foo"].should_not be_nil
+
+      expect(c.search_fields["foo"]).not_to be_nil
     end
-    
+
     it "should raise on nil key" do
-      lambda {@config.add_search_field(nil, :foo => "bar")}.should raise_error ArgumentError
+      expect {@config.add_search_field(nil, :foo => "bar")}.to raise_error ArgumentError
     end
-    
+
     it "creates default label from titleized field key" do
       @config.add_search_field("author_name")
-      
-      @config.search_fields["author_name"].label.should == "Author Name"
+
+      expect(@config.search_fields["author_name"].label).to eq("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")
-      c.sort_fields["my_sort_key"].should_not be_nil
+      expect(c.sort_fields["my_sort_key"]).not_to 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")
+
 
-      
-      @config.sort_fields.values.find{|f| f.label == "relevance"}.should_not be_nil
+      expect(@config.sort_fields.values.find{|f| f.label == "relevance"}).not_to 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"
-))     
-      @config.sort_fields.values.find{|f| f.label == "relevance"}.should_not be_nil
+))
+      expect(@config.sort_fields.values.find{|f| f.label == "relevance"}).not_to 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
-      
-      @config.sort_fields.values.find{|f| f.label == "relevance"}.should_not be_nil
+
+      expect(@config.sort_fields.values.find{|f| f.label == "relevance"}).not_to 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)
 
-      @config.default_search_field.key.should == 'search_field_2'
+      expect(@config.default_search_field.key).to eq('search_field_2')
     end
   end
-  
+
 end