blacklight 3.1.2 → 3.2.0pre1

data/test_support/spec/lib/{configurable_spec.rb → global_configurable_spec.rb}

@@ -1,10 +1,10 @@
 # -*- encoding : utf-8 -*-
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
-describe Blacklight::Configurable do
+describe Blacklight::GlobalConfigurable do
   
   class TestConfig
-    extend Blacklight::Configurable
+    extend Blacklight::GlobalConfigurable
   end
   
   before(:each) do

data/test_support/spec/lib/search_fields_spec.rb

@@ -5,46 +5,45 @@ describe Blacklight::SearchFields do
 
   class MockConfig
     include Blacklight::SearchFields
+  end
 
-    # add in a #config method that includes search field config
-    # that will be used by SearchFields
-    def config
-      @config ||= {:search_fields => [ {:display_label => 'All Fields', :key => "all_fields"},
+  before(:all) do
+    @config = Blacklight::Configuration.from_legacy_configuration({:search_fields => [ {:label => 'All Fields', :key => "all_fields"},
                            {:key => 'title', :qt => 'title_search'},
                            {:key => 'author', :qt => 'author_search'},
                            {:key => 'subject', :qt=> 'subject_search'},
                            ['Legacy Config', 'legacy_qt'],
                            {:key => "no_display", :qt=>"something", :include_in_simple_select => false}
                           ],
-        :default_qt => "search"
-      }
-    end
-    
+                           :default_solr_params => { :qt => "search" }
+    })
   end
 
-  before(:all) do
+  before(:each) do  
     @search_field_obj = MockConfig.new
+    @search_field_obj.stub!(:blacklight_config).and_return(@config)
   end
 
   it 'should convert legacy Array config to Hash properly' do
     hash = @search_field_obj.search_field_def_for_key('legacy_qt')
 
-    hash.should be_kind_of(Hash)
-    hash[:key].should == hash[:qt]
-    hash[:display_label].should == 'Legacy Config'
+    hash.should be_kind_of(Blacklight::Configuration::SearchField)
+    hash.key.should == hash.qt
+    hash.label.should == 'Legacy Config'
   end
   
-  it "should return search field list with calculated :display_label when needed" do
+  it "should return search field list with calculated :label when needed" do
      @search_field_obj.search_field_list.each do |hash|        
-        hash[:display_label].should_not be_blank
+        hash.label.should_not be_blank
      end
   end
 
   it "should fill in default qt where needed" do
-    @search_field_obj.search_field_def_for_key("all_fields")[:qt].should == Blacklight.config[:default_qt]
+    @search_field_obj.search_field_def_for_key("all_fields").qt == @config.default_solr_params[:qt]
   end
   
   it "should return proper options_for_select arguments" do
+
     select_arguments = @search_field_obj.search_field_options_for_select
 
     select_arguments.each_index do |index|
@@ -52,8 +51,8 @@ describe Blacklight::SearchFields do
        config_hash = @search_field_obj.search_field_list[index]
 
        argument.length.should == 2
-       argument[0].should == config_hash[:display_label]
-       argument[1].should == config_hash[:key]
+       argument[0].should == config_hash.label
+       argument[1].should == config_hash.key
     end    
   end
 
@@ -66,10 +65,10 @@ describe Blacklight::SearchFields do
   
 
   it "should lookup field definitions by key" do
-    @search_field_obj.search_field_def_for_key("title")[:key].should == "title"
+    @search_field_obj.search_field_def_for_key("title").key.should == "title"
   end
 
-  it "should find display_label by key" do
+  it "should find label by key" do
     @search_field_obj.label_for_search_field("title").should == "Title"
   end
 
@@ -80,26 +79,24 @@ describe Blacklight::SearchFields do
   describe "for unspecified :key" do
     before do
       @bad_config = MockConfig.new
-      @bad_config.config[:search_fields] = [ 
-        {:display_label => 'All Fields', :qt => "all_fields"},
-        {:key => 'title', :qt => 'title_search'}
-      ]
     end
     it "should raise exception on #search_field_list" do
-      lambda {@bad_config.search_field_list}.should raise_error
+      lambda { @bad_config.stub(:blacklight_config).and_return(Blacklight::Configuration.from_legacy_configuration({:search_fields => [ 
+        {:label => 'All Fields', :qt => "all_fields"},
+        {:key => 'title', :qt => 'title_search'}
+      ]}))   }.should raise_error
     end
   end
 
   describe "for duplicate keys" do
     before do
       @bad_config = MockConfig.new
-      @bad_config.config[:search_fields] = [ 
-        {:display_label => 'All Fields', :key => "my_key"},
-        {:key => 'title', :key => 'my_key'}
-      ]
     end
     it "should raise on #search_field_list" do
-      lambda {@bad_config.search_field_list}.should raise_error
+      lambda { @bad_config.stub(:blacklight_config).and_return(Blacklight::Configuration.from_legacy_configuration({:search_fields => [ 
+        {:label => 'All Fields', :qt => "my_key"},
+        {:key => 'title', :qt => 'my_key'}
+      ]})) }.should raise_error
     end
   end
   

data/test_support/spec/{helpers → lib}/solr_helper_spec.rb

@@ -2,22 +2,7 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 require 'marc'
 
-# Because SolrHelper is a controller layer mixin,
-# it depends on the methods provided by AtionController::Base
-# currently, the only method that is used is #params
-class MockSolrHelperContainer
 
-  include Blacklight::SolrHelper
-  attr_accessor :params
-  attr_accessor :response
-
-  # SolrHelper expects a method called #params,
-  # within the class that's mixing it in
-  def params
-    @params ||= {}
-  end
-
-end
 
 
 =begin
@@ -31,11 +16,23 @@ end
 =end
 describe 'Blacklight::SolrHelper' do
 
-  before(:all) do
-    @solr_helper = MockSolrHelperContainer.new
-    @solr_url = Blacklight.solr_config[:url]
+  # SolrHelper is a controller layer mixin, which depends
+  # on being mixed into a class which has #params (from Rails)
+  # and #blacklight_config
+  def params
+    {}
   end
 
+  def blacklight_config
+    @config ||= CatalogController.blacklight_config
+  end
+  
+  def blacklight_config=(config)
+    @config = config
+  end
+
+  include Blacklight::SolrHelper
+
   before(:each) do
     @all_docs_query = ''
     @no_docs_query = 'zzzzzzzzzzzz'
@@ -45,62 +42,46 @@ describe 'Blacklight::SolrHelper' do
     @single_facet = {:format=>'Book'}
     @multi_facets = {:format=>'Book', :language_facet=>'Tibetan'}
     @bad_facet = {:format=>'666'}
-    @subject_search_params = {:commit=>"search", :search_field=>"subject", :action=>"index", :"controller"=>"catalog", :"per_page"=>"10", :"q"=>"wome"}
+    @subject_search_params = {:commit=>"search", :search_field=>"subject", :action=>"index", :"controller"=>"catalog", :"rows"=>"10", :"q"=>"wome"}
   end
 
-  # SPECS FOR blacklight.rb contents
-  describe "blacklight.rb" do
-    describe "solr.yml and/or initializers" do
-
-      it "should contain a solr_url" do
-        Blacklight.solr_config[:url].should_not == nil
-      end
-
-      it "should contain some display fields" do
-        Blacklight.config[:show].should_not == nil
-      end
-
-    end
-  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. 
-        class CustomizableHelper < MockSolrHelperContainer          
-            def add_foo_to_solr_params(solr_params, user_params)
-              solr_params[:foo] = "TESTING"
-            end
-        end 
+        # 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"
+        end
+ 
                          
-        CustomizableHelper.solr_search_params_logic += [:add_foo_to_solr_params]
-        
+        self.solr_search_params_logic += [:add_foo_to_solr_params]
         
-        obj = CustomizableHelper.new
-        params = obj.solr_search_params
         
-        params[:foo].should == "TESTING"
+        self.solr_search_params[:foo].should == "TESTING"                
     end
     
     
     describe 'for an entirely empty search' do
+       def params
+          {}
+        end
       before do
-        @produced_params = @solr_helper.solr_search_params
+        @produced_params = self.solr_search_params
       end
       it 'should not have a q param' do
         @produced_params[:q].should be_nil
         @produced_params["spellcheck.q"].should be_nil
       end
-      it 'should have default per_page' do
-        @produced_params[:per_page].should == 10
+      it 'should have default rows' do
+        @produced_params[:rows].should == 10
       end
       it 'should have default facet fields' do
-        @produced_params[:"facet.field"].should == Blacklight.config[:default_solr_params][:"facet.field"]
-      end
-      it 'should not use the exact facet array from config defaults' do
-        @produced_params[:"facet.field"].should_not be_equal(Blacklight.config[:facet][:field_names])
+        @produced_params[:"facet.field"].should == blacklight_config[:default_solr_params][:"facet.field"]
       end
+      
       it "should have default qt"  do
         @produced_params[:qt].should == "search"
       end
@@ -111,21 +92,17 @@ describe 'Blacklight::SolrHelper' do
     end
 
 
-    describe "for an empty string search" do
-      it "should return empty string q in solr parameters" do
-        params = @solr_helper.solr_search_params(:q => "")
-        params[:q].should == ""
-        params["spellcheck.q"].should == ""
+    describe "for an empty string search" do      
+      it "should return empty string q in solr parameters" do        
+        solr_params = solr_search_params(:q => "")
+        solr_params[:q].should == ""
+        solr_params["spellcheck.q"].should == ""
       end
     end
 
-    describe "for request params also passed in as argument" do
-      before do
-        @req_params = HashWithIndifferentAccess.new({:q => "some query"})
-        params = @req_params
-      end
-      it "should only have one 'q' key, as symbol" do
-        solr_params = @solr_helper.solr_search_params( @req_params )
+    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" )
         solr_params.keys.should include(:q)
         solr_params.keys.should_not include("q")
       end
@@ -135,27 +112,27 @@ describe 'Blacklight::SolrHelper' do
     describe "for one facet, no query" do
       it "should have proper solr parameters" do
 
-        params = @solr_helper.solr_search_params(:f => @single_facet)
+        solr_params = solr_search_params(:f => @single_facet)
 
-        params[:q].should be_blank
-        params["spellcheck.q"].should be_blank
-        params[:"facet.field"].should == Blacklight.config[:default_solr_params][:"facet.field"]
+        solr_params[:q].should be_blank
+        solr_params["spellcheck.q"].should be_blank
+        solr_params[:"facet.field"].should == blacklight_config[:default_solr_params][:"facet.field"]
 
         @single_facet.each_value do |value|
-          params[:fq].should include("{!raw f=#{@single_facet.keys[0]}}#{value}")
+          solr_params[:fq].should include("{!raw f=#{@single_facet.keys[0]}}#{value}")
         end
       end
     end
 
     describe "with Multi Facets, No Query" do
       it 'should have fq set properly' do
-        params = @solr_helper.solr_search_params(:f => @multi_facets)
+        solr_params = solr_search_params(:f => @multi_facets)
 
         @multi_facets.each_pair do |facet_field, value_list|
           value_list ||= []
           value_list = [value_list] unless value_list.respond_to? :each
           value_list.each do |value|
-            params[:fq].should include("{!raw f=#{facet_field}}#{value}"  )
+            solr_params[:fq].should include("{!raw f=#{facet_field}}#{value}"  )
           end
         end
 
@@ -164,22 +141,48 @@ describe 'Blacklight::SolrHelper' do
 
     describe "with Multi Facets, Multi Word Query" do
       it 'should have fq and q set properly' do
-        params = @solr_helper.solr_search_params(:q => @mult_word_query, :f => @multi_facets)
+        solr_params = solr_search_params(:q => @mult_word_query, :f => @multi_facets)
 
         @multi_facets.each_pair do |facet_field, value_list|
           value_list ||= []
           value_list = [value_list] unless value_list.respond_to? :each
           value_list.each do |value|
-            params[:fq].should include("{!raw f=#{facet_field}}#{value}"  )
+            solr_params[:fq].should include("{!raw f=#{facet_field}}#{value}"  )
           end
         end
-        params[:q].should == @mult_word_query
+        solr_params[:q].should == @mult_word_query
+      end
+    end
+
+    describe "facet_value_to_fq_string", :focus => true do
+      it "should use the raw handler for strings" do
+        facet_value_to_fq_string("facet_name", "my value").should  == "{!raw f=facet_name}my value" 
+      end
+
+      it "should pass integers through" do
+        facet_value_to_fq_string("facet_name", 1).should  == "facet_name:1"
+      end
+
+      it "should pass integer-like strings through" do
+        facet_value_to_fq_string("facet_name", "1").should  == "facet_name:1"
+      end
+
+      it "should pass floats through" do
+        facet_value_to_fq_string("facet_name", 1.11).should  == "facet_name:1.11"
+      end
+
+      it "should pass floats through" do
+        facet_value_to_fq_string("facet_name", "1.11").should  == "facet_name:1.11"
+      end
+
+      it "should handle range requests" do
+        facet_value_to_fq_string("facet_name", 1..5).should  == "facet_name:[1 TO 5]"
       end
     end
 
     describe "solr parameters for a field search from config (subject)" do
       before do
-        @solr_params = @solr_helper.solr_search_params( @subject_search_params )
+        @solr_params = solr_search_params( @subject_search_params )
       end
       it "should look up qt from field definition" do
         @solr_params[:qt].should == "search"
@@ -203,13 +206,13 @@ describe 'Blacklight::SolrHelper' do
         @solr_params["spellcheck.q"].should == "wome"
       end
       it "should include facet.field from default_solr_params" do
-        @solr_params[:"facet.field"].should == Blacklight.config[:default_solr_params][:"facet.field"]
+        @solr_params[:"facet.field"].should == blacklight_config[:default_solr_params][:"facet.field"]
       end
       it "should include spellcheck.dictionary from field def solr_parameters" do
         @solr_params[:"spellcheck.dictionary"].should == "subject"
       end
       it "should add on :solr_local_parameters using Solr LocalParams style" do
-        params = @solr_helper.solr_search_params( @subject_search_params )
+        params = solr_search_params( @subject_search_params )
 
         #q == "{!pf=$subject_pf $qf=subject_qf} wome", make sure
         #the LocalParams are really there
@@ -222,45 +225,41 @@ describe 'Blacklight::SolrHelper' do
 
     describe "overriding of qt parameter" do
       it "should return the correct overriden parameter" do
-        @solr_helper.params[:qt] = "overriden"
-        @solr_helper.solr_search_params[:qt].should == "overriden"
-        @solr_helper.params[:qt] = nil
+        def params
+          super.merge(:qt => "overridden")
+        end
+        
+        solr_search_params[:qt].should == "overridden"        
       end
     end
 
     describe "with a complex parameter environment" do
-      before do
-        # Add a custom search field def in so we can test it
-        Blacklight.config[:search_fields] << {:display_label => "Test", :key=>"test_field", :solr_parameters => {:qf => "fieldOne^2.3 fieldTwo fieldThree^0.4", :pf => "", :spellcheck => 'false', :per_page => "55", :sort => "request_params_sort"}}
-        #re-memoize
-        Blacklight.search_field_list(:reload)
-
-        # Add some params
-        @solr_helper_with_params = MockSolrHelperContainer.new
-        @solr_helper_with_params.params = {:search_field => "test_field", :q => "test query", "facet.field" => "extra_facet"}
-      end
-      after do
-        # restore search field list to how it was.
-        Blacklight.config[:search_fields].delete_if {|hash| hash[:key] == "test_field"}
-        #re-memoize
-        Blacklight.search_field_list(:reload)
-      end
-
+      def blacklight_config          
+        config = Blacklight::Configuration.new
+        config.add_search_field("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          
+        {:search_field => "test_field", :q => "test query", "facet.field" => "extra_facet"}
+      end
+      
       it "should merge parameters from search_field definition" do
-        params = @solr_helper_with_params.solr_search_params
-
-        params[:qf].should == "fieldOne^2.3 fieldTwo fieldThree^0.4"
-        params[:spellcheck].should == 'false'
+        solr_params = solr_search_params
+        
+        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
-        params = @solr_helper_with_params.solr_search_params
-        params[:pf].should == ""
+        solr_search_params[:pf].should == ""        
       end
 
       describe "should respect proper precedence of settings, " do
         before do
-          @produced_params = @solr_helper_with_params.solr_search_params().merge(:sort => "extra_params_sort")
-          1+1
+          @produced_params = solr_search_params
         end
 
 
@@ -269,11 +268,11 @@ describe 'Blacklight::SolrHelper' do
         end
 
         it "should fall through to BL general defaults for qt not otherwise specified " do
-          @produced_params[:qt].should == Blacklight.config[:default_solr_params][:qt]
+          @produced_params[:qt].should == blacklight_config[:default_solr_params][:qt]
         end
 
-        it "should take per_page from search field definition where specified" do
-          @produced_params[:per_page].should == "55"
+        it "should take rows from search field definition where specified" do
+          @produced_params[:rows].should == "55"
         end
 
         it "should take q from request params" do
@@ -284,67 +283,58 @@ describe 'Blacklight::SolrHelper' do
           @produced_params[:"facet.field"].should include("extra_facet")
         end
 
-        it "should Overwrite request params sort with extra_params sort" do
-          @produced_params[:sort].should == "extra_params_sort"
-        end
-
       end
     end
 
     describe "sorting" do
-      it "should send the default sort parameter to solr" do
-        test_sort_field = ['test', 'solr_test_field asc'] 
-        Blacklight.config[:sort_fields].unshift(test_sort_field)
-
-        produced_params = @solr_helper.solr_search_params
-        produced_params[:sort].should == 'solr_test_field asc'
-
-        Blacklight.config[:sort_fields].delete(test_sort_field)
+      
+      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
-        test_sort_field = ['test', nil] 
-        Blacklight.config[:sort_fields].unshift(test_sort_field)
+        def blacklight_config          
+          config = Blacklight::Configuration.new
+          config.add_sort_field('', :label => 'test')
+          return config
+        end
 
-        produced_params = @solr_helper.solr_search_params
+        produced_params = solr_search_params
         produced_params.should_not have_key(:sort)
-
-        Blacklight.config[:sort_fields].delete(test_sort_field)
       end
 
       it "should pass through user sort parameters" do
-        produced_params = @solr_helper.solr_search_params :sort => 'solr_test_field desc'
+        produced_params = solr_search_params( :sort => 'solr_test_field desc' )
         produced_params[:sort].should == 'solr_test_field desc'
       end
     end
 
     describe "for :solr_local_parameters config" do
-      before do
-        # Hack to test with our own custom config specified here
-        @orig_blacklight = Blacklight
-        Object.instance_eval{ remove_const :Blacklight }
-        Blacklight = @orig_blacklight.clone
-        Blacklight.unmemoize_all
-        Blacklight.instance_variable_set("@config", {}.deep_merge(@orig_blacklight.config))
-
-        Blacklight.config[:search_fields] = [
-          { :display_label => "Author",
-            :qt => "author_qt",
-            :key => "author_key",
-            :solr_local_parameters => {
-              :qf => "$author_qf",
-              :pf => "you'll have \" to escape this"
-            },
-            :solr_parameters => {
-              :qf => "someField^1000",
-              :ps => "2"
-            }
+      def blacklight_config          
+        config = Blacklight::Configuration.new
+        config.add_search_field(
+          "custom_author_key",
+          :display_label => "Author",
+          :qt => "author_qt",
+          :key => "custom_author_key",
+          :solr_local_parameters => {
+            :qf => "$author_qf",
+            :pf => "you'll have \" to escape this"
+          },
+          :solr_parameters => {
+            :qf => "someField^1000",
+            :ps => "2"
           }
-        ]
-
-        @solr_helper = MockSolrHelperContainer.new
-        @solr_helper.params = {:search_field => "author_key", :q => "query"}
-        @result = @solr_helper.solr_search_params
+        )
+        return config
+      end
+      
+      def params        
+        {:search_field => "custom_author_key", :q => "query"}
+      end
+      
+      before do
+        @result = solr_search_params
       end
 
       it "should pass through ordinary params" do
@@ -357,27 +347,22 @@ describe 'Blacklight::SolrHelper' do
         @result[:q].should include('qf=$author_qf')
         @result[:q].should include('pf=\'you\\\'ll have \\" to escape this\'')
       end
-
-      after do
-        Object.instance_eval{ remove_const :Blacklight }
-        Blacklight = @orig_blacklight
-      end
     end
     
     describe "mapping facet.field" do
       it "should add single additional facet.field from app" do
-        solr_params = @solr_helper.solr_search_params( "facet.field" => "additional_facet" )
+        solr_params = solr_search_params( "facet.field" => "additional_facet" )
         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_helper.solr_search_params( "facet.field" => ["add_facet1", "add_facet2"] )
+        solr_params = solr_search_params( "facet.field" => ["add_facet1", "add_facet2"] )
         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_helper.solr_search_params( "facets" => ["add_facet1", "add_facet2"] )
+        solr_params = solr_search_params( "facets" => ["add_facet1", "add_facet2"] )
         solr_params[:"facet.field"].should include("add_facet1")
         solr_params[:"facet.field"].should include("add_facet2")
         solr_params[:"facet.field"].length.should > 2
@@ -389,7 +374,7 @@ describe 'Blacklight::SolrHelper' do
   describe "solr_facet_params" do
     before do
       @facet_field = 'format'
-      @generated_solr_facet_params = @solr_helper.solr_facet_params(@facet_field)
+      @generated_solr_facet_params = solr_facet_params(@facet_field)
 
       @sort_key = Blacklight::Solr::FacetPaginator.request_keys[:sort]
       @offset_key = Blacklight::Solr::FacetPaginator.request_keys[:offset]
@@ -404,30 +389,30 @@ describe 'Blacklight::SolrHelper' do
       @generated_solr_facet_params['facet.offset'].should == 0
     end
     it 'uses offset manually set, and converts it to an integer' do
-      solr_params = @solr_helper.solr_facet_params(@facet_field, @offset_key => "100")
+      solr_params = solr_facet_params(@facet_field, @offset_key => "100")
       solr_params['facet.offset'].should == 100
     end
     it 'defaults limit to 20' do
-      solr_params = @solr_helper.solr_facet_params(@facet_field)
+      solr_params = solr_facet_params(@facet_field)
       solr_params[:"f.#{@facet_field}.facet.limit"].should == 21
     end
     describe 'if facet_list_limit is defined in controller' do
-      before(:each) do
-        @solr_helper.stub!("facet_list_limit").and_return("1000")
+      def facet_list_limit
+        1000
       end
       it 'uses controller method for limit' do
-        solr_params = @solr_helper.solr_facet_params(@facet_field)
+        solr_params = solr_facet_params(@facet_field)
         solr_params[:"f.#{@facet_field}.facet.limit"].should == 1001
       end
     end
     it 'uses sort set manually' do
-      solr_params = @solr_helper.solr_facet_params(@facet_field, @sort_key => "index")
+      solr_params = solr_facet_params(@facet_field, @sort_key => "index")
       solr_params['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'}}
-      solr_search_params = @solr_helper.solr_search_params( search_params )
-      solr_facet_params = @solr_helper.solr_facet_params('format', search_params)
+      solr_search_params = solr_search_params( search_params )
+      solr_facet_params = solr_facet_params('format', search_params)
 
       solr_search_params.each_pair do |key, value|
         # The specific params used for fetching the facet list we
@@ -439,25 +424,28 @@ describe 'Blacklight::SolrHelper' do
 
     end
   end
-  describe "for facet limit parameters config ed" do
-    before(:each) do
-      @solr_helper_facet = MockSolrHelperContainer.new
-      @solr_helper_facet.params = {:search_field => "test_field", :q => "test query"}
-      @solr_helper_facet.stub!("facet_limit_hash").and_return({:some_facet => nil, :subject_facet => 10})
-      @generated_params = @solr_helper_facet.solr_search_params
+  describe "for facet limit parameters config ed" do              
+    def params
+      {:search_field => "test_field", :q => "test query"}
+    end
+    
+    
+    before do            
+      @generated_params = solr_search_params
     end
     
     it "should include specifically configged facet limits +1" do
-      @generated_params[:"f.subject_facet.facet.limit"].should == 11      
+      @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
-      @generated_params.should_not have_key(:"f.some_facet.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" do
+  
+   describe "get_facet_pagination", :integration => true do
     before(:each) do
-      @facet_paginator = @solr_helper.get_facet_pagination(@facet_field)
+      @facet_paginator = get_facet_pagination(@facet_field)
     end
     it 'should return a facet paginator' do
       @facet_paginator.should be_a_kind_of(Blacklight::Solr::FacetPaginator)
@@ -468,12 +456,12 @@ describe 'Blacklight::SolrHelper' do
    end
 
 # SPECS FOR SEARCH RESULTS FOR QUERY
-  describe 'Search Results' do
+  describe 'Search Results', :integration => true do
 
     describe 'for a sample query returning results' do
 
       before(:all) do        
-        (@solr_response, @document_list) = @solr_helper.get_search_results(:q => @all_docs_query)
+        (@solr_response, @document_list) = get_search_results(:q => @all_docs_query)
       end
 
       it 'should have a @response.docs list of the same size as @document_list' do
@@ -496,11 +484,11 @@ describe 'Blacklight::SolrHelper' do
 
     describe 'for All Docs Query, No Facets' do
       it 'should have non-nil values for required doc fields set in initializer' do
-        (solr_response, document_list) = @solr_helper.get_search_results(:q => @all_docs_query)
+        (solr_response, document_list) = get_search_results(:q => @all_docs_query)
         result_docs = document_list
         document = result_docs.first
-        document.get(Blacklight.config[:index][:show_link]).should_not == nil
-        document.get(Blacklight.config[:index][:record_display_type]).should_not == nil
+        document.get(blacklight_config.index.show_link).should_not == nil
+        document.get(blacklight_config.index.record_display_type).should_not == nil
       end
     end
 
@@ -508,7 +496,7 @@ describe 'Blacklight::SolrHelper' do
 
     describe "Single Word Query with no Facets" do
       it 'should have results' do
-        (solr_response, document_list) = @solr_helper.get_search_results(:q => @single_word_query)
+        (solr_response, document_list) = get_search_results(:q => @single_word_query)
         solr_response.docs.size.should == document_list.size
         solr_response.docs.size.should > 0
       end
@@ -517,7 +505,7 @@ describe 'Blacklight::SolrHelper' do
     describe "Multiple Words Query with No Facets" do
       it 'should have results' do
 
-        (solr_response, document_list) = @solr_helper.get_search_results(:q => @mult_word_query)
+        (solr_response, document_list) = get_search_results(:q => @mult_word_query)
         solr_response.docs.size.should == document_list.size
         solr_response.docs.size.should > 0
       end
@@ -525,7 +513,7 @@ describe 'Blacklight::SolrHelper' do
 
     describe "One Facet, No Query" do
       it 'should have results' do
-        (solr_response, document_list) = @solr_helper.get_search_results(:f => @single_facet)
+        (solr_response, document_list) = get_search_results(:f => @single_facet)
         solr_response.docs.size.should == document_list.size
         solr_response.docs.size.should > 0
       end
@@ -533,7 +521,7 @@ describe 'Blacklight::SolrHelper' do
 
     describe "Mult Facets, No Query" do
       it 'should have results' do
-        (solr_response, document_list) = @solr_helper.get_search_results(:f => @multi_facets)
+        (solr_response, document_list) = get_search_results(:f => @multi_facets)
         solr_response.docs.size.should == document_list.size
         solr_response.docs.size.should > 0
       end
@@ -541,7 +529,7 @@ describe 'Blacklight::SolrHelper' do
 
     describe "Single Word Query with One Facet" do
       it 'should have results' do
-        (solr_response, document_list) = @solr_helper.get_search_results(:q => @single_word_query, :f => @single_facet)
+        (solr_response, document_list) = get_search_results(:q => @single_word_query, :f => @single_facet)
         solr_response.docs.size.should == document_list.size
         solr_response.docs.size.should > 0
       end
@@ -549,7 +537,7 @@ describe 'Blacklight::SolrHelper' do
 
     describe "Multiple Words Query with Multiple Facets" do
       it 'should have results' do
-        (solr_response, document_list) = @solr_helper.get_search_results(:q => @mult_word_query, :f => @multi_facets)
+        (solr_response, document_list) = get_search_results(:q => @mult_word_query, :f => @multi_facets)
         solr_response.docs.size.should == document_list.size
         solr_response.docs.size.should > 0
       end
@@ -557,7 +545,7 @@ describe 'Blacklight::SolrHelper' do
 
     describe "for All Docs Query and One Facet" do
       it 'should have results' do
-        (solr_response, document_list) = @solr_helper.get_search_results(:q => @all_docs_query, :f => @single_facet)
+        (solr_response, document_list) = get_search_results(:q => @all_docs_query, :f => @single_facet)
         solr_response.docs.size.should == document_list.size
         solr_response.docs.size.should > 0
       end
@@ -567,7 +555,7 @@ 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) = @solr_helper.get_search_results(:q => @no_docs_query)
+        (solr_response, document_list) = get_search_results(:q => @no_docs_query)
         solr_response.docs.size.should == document_list.size
         solr_response.docs.size.should == 0
       end
@@ -575,7 +563,7 @@ describe 'Blacklight::SolrHelper' do
 
     describe "for Query Without Results and One Facet" do
       it 'should have no results and not raise error' do
-        (solr_response, document_list) = @solr_helper.get_search_results(:q => @no_docs_query, :f => @single_facet)
+        (solr_response, document_list) = get_search_results(:q => @no_docs_query, :f => @single_facet)
         solr_response.docs.size.should == document_list.size
         solr_response.docs.size.should == 0
       end
@@ -583,30 +571,23 @@ describe 'Blacklight::SolrHelper' do
 
     describe "for All Docs Query and Bad Facet" do
       it 'should have no results and not raise error' do
-        (solr_response, document_list) = @solr_helper.get_search_results(:q => @all_docs_query, :f => @bad_facet)
+        (solr_response, document_list) = get_search_results(:q => @all_docs_query, :f => @bad_facet)
         solr_response.docs.size.should == document_list.size
         solr_response.docs.size.should == 0
       end
     end
 
-    describe "for default display fields" do
-      it "should have a list of field names for index_view_fields" do
-        Blacklight.config[:index_fields].should_not be_nil
-        Blacklight.config[:index_fields][:field_names].should be_instance_of(Array)
-        Blacklight.config[:index_fields][:field_names].length.should > 0
-        Blacklight.config[:index_fields][:field_names][0].should_not == nil
-      end
-    end
+
 
 
   end  # Search Results
 
 
 # SPECS FOR SEARCH RESULTS FOR FACETS
-  describe 'Facets in Search Results for All Docs Query' do
+  describe 'Facets in Search Results for All Docs Query', :integration => true do
 
     before(:all) do
-      (solr_response, document_list) = @solr_helper.get_search_results(:q => @all_docs_query)
+      (solr_response, document_list) = get_search_results(:q => @all_docs_query)
       @facets = solr_response.facets
     end
 
@@ -614,7 +595,7 @@ describe 'Blacklight::SolrHelper' do
       @facets.size.should > 1
     end
     it 'should have all facets specified in initializer' do      
-      Blacklight.config[:default_solr_params][:"facet.field"].each do |field|
+      blacklight_config[:default_solr_params][:"facet.field"].each do |field|
         @facets.find {|f| f.name == field}.should_not be_nil        
       end
     end
@@ -644,40 +625,40 @@ describe 'Blacklight::SolrHelper' do
 
 
 # SPECS FOR SEARCH RESULTS FOR PAGING
-  describe 'Paging' do
+  describe 'Paging', :integration => true do
 
     it 'should start with first results by default' do
-      (solr_response, document_list) = @solr_helper.get_search_results(:q => @all_docs_query)
+      (solr_response, document_list) = get_search_results(:q => @all_docs_query)
       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) = @solr_helper.get_search_results(:q => @all_docs_query)
+      (solr_response, document_list) = get_search_results(:q => @all_docs_query)
       solr_response.docs.size.should == document_list.size
-      solr_response.docs.size.should == Blacklight.config[:default_solr_params][:per_page]
+      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) = @solr_helper.get_search_results(:q => @all_docs_query, :per_page => num_results)
+      (solr_response1, document_list1) = get_search_results(:q => @all_docs_query, :per_page => 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) = @solr_helper.get_search_results(:q => @all_docs_query, :page => page)
-      solr_response2.params[:start].to_i.should ==  Blacklight.config[:default_solr_params][:per_page] * (page-1)
+      (solr_response2, document_list2) = get_search_results(:q => @all_docs_query, :page => page)
+      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) = @solr_helper.get_search_results(:q => @all_docs_query, :per_page => num_results, :page => page)
+      (solr_response2a, document_list2a) = get_search_results(:q => @all_docs_query, :per_page => num_results, :page => page)
       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) = @solr_helper.get_search_results(:q => @all_docs_query, :per_page => big, :page => big)
+      (solr_response3, document_list3) = get_search_results(:q => @all_docs_query, :rows => big, :page => big)
       solr_response3.docs.size.should == document_list3.size
       solr_response3.docs.size.should == 0
     end
@@ -685,12 +666,12 @@ describe 'Blacklight::SolrHelper' do
     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) = @solr_helper.get_search_results(:q => @all_docs_query, :page => '-1')
+      (solr_response4, document_list4) = get_search_results(:q => @all_docs_query, :page => '-1')
       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) = @solr_helper.get_search_results(:q => @all_docs_query, :per_page => big, :page => 1)
+      (solr_response5, document_list5) = get_search_results(:q => @all_docs_query, :rows => big, :page => 1)
       solr_response5.docs.size.should == document_list5.size
       solr_response5.docs.size.should > 0
     end
@@ -698,16 +679,16 @@ describe 'Blacklight::SolrHelper' do
   end # page specs
 
   # SPECS FOR SINGLE DOCUMENT REQUESTS
-  describe 'Get Document By Id' do
+  describe 'Get Document By Id', :integration => true do
     before(:all) do
       @doc_id = '2007020969'
       @bad_id = "redrum"
-      @response2, @document = @solr_helper.get_solr_response_for_doc_id(@doc_id)
+      @response2, @document = get_solr_response_for_doc_id(@doc_id)
     end
 
     it "should raise Blacklight::InvalidSolrID for an unknown id" do
       lambda {
-        @solr_helper.get_solr_response_for_doc_id(@bad_id)
+        get_solr_response_for_doc_id(@bad_id)
       }.should raise_error(Blacklight::Exceptions::InvalidSolrID)
     end
 
@@ -721,15 +702,9 @@ describe 'Blacklight::SolrHelper' do
       @document.id.should == @doc_id
     end
     it 'should have non-nil values for required fields set in initializer' do
-      @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
-    it "should have a list of field names for show_view_fields" do
-      Blacklight.config[:show_fields].should_not be_nil
-      Blacklight.config[:show_fields][:field_names].should be_instance_of(Array)
-      Blacklight.config[:show_fields][:field_names].length.should > 0
-      Blacklight.config[:show_fields][:field_names][0].should_not == 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
 
@@ -744,20 +719,18 @@ describe 'Blacklight::SolrHelper' do
     end
 =end
     it "should respect the configuration-supplied unique id" do
-      doc_params = @solr_helper.solr_doc_params('"Strong Medicine speaks"')
+      doc_params = solr_doc_params('"Strong Medicine speaks"')
       doc_params[:id].should == '"Strong Medicine speaks"'
     end
   end
 
-# NOTE: some of these repeated fields could be in a shared behavior, but the
-#  flow of control is such that the variables can't be instance variables
-#  (or at least not for me - Naomi)
+
 
 # SPECS FOR SINGLE DOCUMENT VIA SEARCH
-  describe "Get Document Via Search" do
+  describe "Get Document Via Search", :integration => true do
     before(:all) do
       @doc_row = 3
-      @doc = @solr_helper.get_single_doc_via_search(@doc_row, :q => @all_docs_query)
+      @doc = get_single_doc_via_search(@doc_row, :q => @all_docs_query)
     end
 =begin
 # can't test these here, because the method only returns the document
@@ -780,28 +753,28 @@ describe 'Blacklight::SolrHelper' do
     end
 
     it 'should have non-nil values for required fields set in initializer' do
-      @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
+      @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 = @solr_helper.get_single_doc_via_search(@doc_row , :q => @all_docs_query, :f => @multi_facets)
+      doc2 = get_single_doc_via_search(@doc_row , :q => @all_docs_query, :f => @multi_facets)
       doc2[:id].should_not == nil
     end
 
   end
 
 # SPECS FOR SPELLING SUGGESTIONS VIA SEARCH
-  describe "Searches should return spelling suggestions" 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) = @solr_helper.get_search_results({:q => 'boo'})
+      (solr_response, document_list) = get_search_results({:q => 'boo'})
       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) = @solr_helper.get_search_results({:q => 'politica'})
+      (solr_response, document_list) = get_search_results({:q => 'politica'})
       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
@@ -814,17 +787,17 @@ describe 'Blacklight::SolrHelper' do
     end
 
     it "title search results for just-poor-enough query term should have spelling suggestions" do
-      (solr_response, document_list) = @solr_helper.get_search_results({:q => 'yehudiyam', :qt => 'search', :"spellcheck.dictionary" => "title"})
+      (solr_response, document_list) = get_search_results({:q => 'yehudiyam', :qt => 'search', :"spellcheck.dictionary" => "title"})
       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) = @solr_helper.get_search_results({:q => 'shirma', :qt => 'search', :"spellcheck.dictionary" => "author"})
+      (solr_response, document_list) = get_search_results({:q => 'shirma', :qt => 'search', :"spellcheck.dictionary" => "author"})
       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) = @solr_helper.get_search_results({:q => 'wome', :qt => 'search', :"spellcheck.dictionary" => "subject"})
+      (solr_response, document_list) = get_search_results({:q => 'wome', :qt => 'search', :"spellcheck.dictionary" => "subject"})
       solr_response.spelling.words.should include('women')
     end
 
@@ -838,71 +811,79 @@ describe 'Blacklight::SolrHelper' do
   describe "facet_limit_for" do
 
     it "should return specified value for facet_field specified" do
-      @solr_helper.facet_limit_for("subject_topic_facet").should == Blacklight.config[:facet][:limits]["subject_topic_facet"]
+      facet_limit_for("subject_topic_facet").should == blacklight_config.facet_fields["subject_topic_facet"].limit
+    end
+    it "should generate proper solr param" do
+      solr_search_params[:"f.subject_topic_facet.facet.limit"].should == 21
     end
-    it "@solr_helper.facet_limit_hash should return hash with key being facet_field and value being configured limit" do
-      @solr_helper.facet_limit_hash.should == Blacklight.config[:facet][:limits]
+    
+    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?"
+      facet_limit_hash.should == blacklight_config[:facet][:limits]
     end
     it "should handle no facet_limits in config" do
-      Blacklight.config[:facet][:field_names].include?("subject_topic_facet").should be_true
-      Blacklight.config[:facet][:limits].has_key?("subject_topic_facet").should be_true
-      @solr_helper.facet_limit_for("subject_topic_facet").should == 20
-      fl = Blacklight.config[:facet][:limits]
-      Blacklight.config[:facet][:limits] = nil
-      @solr_helper.facet_limit_for("subject_topic_facet").should be_nil
-      Blacklight.config[:facet][:limits] = fl
-    end
-    it "solr_search_params should handle no facet_limits in config" do
-      Blacklight.config[:facet][:field_names].include?("subject_topic_facet").should be_true
-      Blacklight.config[:facet][:limits].has_key?("subject_topic_facet").should be_true
-      @solr_helper.solr_search_params[:"f.subject_topic_facet.facet.limit"].should == 21
-      fl = Blacklight.config[:facet][:limits]
-      Blacklight.config[:facet][:limits] = nil
-      @solr_helper.solr_search_params.has_key?(:"f.subject_topic_facet.facet.limit").should be_false
-      Blacklight.config[:facet][:limits] = fl
+      def blacklight_config
+        config = super.inheritable_copy
+        config.facet_fields = {}
+        return config
+      end
+            
+      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
-        @solr_helper.facet_limit_for("some_field").should be_nil
+        facet_limit_for("some_unknown_field").should be_nil
       end
-      it "should get from @response facet.limit if available" do
-        @solr_helper.response = {"responseHeader" => {"params" => {"facet.limit" => 11}}}
-        @solr_helper.facet_limit_for("language_facet").should == 10
+      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}}}        
+        facet_limit_for("language_facet").should == 10
       end
       it "should get from specific field in @response if available" do
-        @solr_helper.response = {"responseHeader" => {"params" => {"facet.limit" => 11,"f.language_facet.facet.limit" => 16}}}
-        @solr_helper.facet_limit_for("language_facet").should == 15
+        @response = {"responseHeader" => {"params" => {"facet.limit" => 11,"f.language_facet.facet.limit" => 16}}}
+        facet_limit_for("language_facet").should == 15
       end
     end
   end
 
     describe "with max per page enforced" do
+      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
+        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
-        # Add some params
-        @solr_helper_with_params = MockSolrHelperContainer.new
-        @solr_helper_with_params.params = {:search_field => "test_field", :per_page => 12345, :q => "test query", "facet.field" => "extra_facet"}
+        @mock_response = mock()
+        @mock_response.stub(:docs => [])
       end
-      after do
+      it "should contruct a solr query based on the field and value pair" do
+        self.should_receive(:find).with(hash_including(:q => "field_name:(value)")).and_return(@mock_response)
+        get_solr_response_for_field_values('field_name', 'value')
       end
 
-      describe "should enforce MaxPerPage against user supplied parameters" do
-        before do
-          @produced_params = @solr_helper_with_params.solr_search_params
-          1+1
-        end
-        it "should take per_page from search field definition where specified" do
-          @produced_params[:per_page].should == "100"
-        end
+      it "should OR multiple values together" do
+        self.should_receive(:find).with(hash_including(:q => "field_name:(a OR b)")).and_return(@mock_response)
+        get_solr_response_for_field_values('field_name', ['a', 'b'])
       end
 
-      describe "should enforce MaxPerPage against extra controller parameters" do
-        before do
-          @produced_params = @solr_helper_with_params.solr_search_params(:per_page => 98765)
-          1+1
-        end
-        it "should take per_page from search field definition where specified" do
-          @produced_params[:per_page].should == "100"
-        end
+      it "should escape crazy identifiers" do
+        self.should_receive(:find).with(hash_including(:q => "field_name:(\"h://\\\"\\\'\")")).and_return(@mock_response)
+        get_solr_response_for_field_values('field_name', 'h://"\'')
       end
     end