multi-solr 01.01.06 → 01.02.00

data/lib/multi_solr.rb

@@ -11,7 +11,6 @@ require 'multi_solr/solr_filter_free_query'
 require 'multi_solr/filter_value_composite'
 require 'multi_solr/search_request'
 require 'multi_solr/search_result'
-require 'multi_solr/base_searcher'
 require 'multi_solr/single_core_handler'
 require 'multi_solr/timeline_core_handler'
 

data/lib/multi_solr/search_request.rb

@@ -12,6 +12,7 @@ class MultiSolr::SearchRequest
   #       :mdate => {:range => true, :start => 'NOW/DAY-5Day', :end => 'NOW/DAY', :gap => '+1DAY'},
   #       :saison => {:stats_field => 'volumen'}}
   attr_accessor :facet_params
+  attr_accessor :facet_prefix     # optinaler Facet-Prefix bei Facetsuche. Wird als facet.prefix an Solr weitergegeben
 
   attr_accessor :sorts            # Array(String) mit den Feldnamen für die Sortierung (optional mit Sortierrichtung)
   attr_accessor :stats_fields     # Array(String) mit den Feldnamen für die Gesamt-Statistiken berechnet werden sollen (Summe, min, max,...)

data/lib/multi_solr/single_core_handler.rb

@@ -344,6 +344,9 @@ class MultiSolr::SingleCoreHandler
       # Umschalten der Facet-Ergebnisse in Array-Darstellung
       # (der json.nl-Schalter wirkt auch bei Ruby siehe http://wiki.apache.org/solr/SolJSON)
       solr_params['json.nl'] = 'arrarr'
+      if solr_search_request.facet_prefix
+        solr_params['facet.prefix'] = solr_search_request.facet_prefix
+      end
     end
 
   end

data/lib/multi_solr/version.rb

@@ -1,3 +1,3 @@
 module MultiSolr
-  VERSION = "01.01.06"
+  VERSION = "01.02.00"
 end

data/spec/multi_solr/single_core_handler_spec.rb

@@ -86,11 +86,16 @@ describe MultiSolr::SingleCoreHandler do
       @request = MultiSolr::SearchRequest.new
     end
 
-    it "should add force-query if context given" do
+    it "should add force-query if context as hash given" do
       solr_params = subject.build_solr_params @request, :context => {:whs_id => 8}
       solr_params[:fq].should == "whs_id:8"
     end
 
+    it "should add force-query if context as string given" do
+      solr_params = subject.build_solr_params @request, :context => "(whs_id:8 OR whs_id:9)"
+      solr_params[:fq].should == "(whs_id:8 OR whs_id:9)"
+    end
+
     it "should have query for all if no query specified" do
       solr_params = subject.build_solr_params @request, {}
       solr_params[:q].should == "*:*"
@@ -159,6 +164,16 @@ describe MultiSolr::SingleCoreHandler do
       it{ @solr_params['f.gewicht.stats.facet'].should == [:sf2] }
     end
 
+    context "should generate facet-params with facet.prefix if facet prefix is specified" do
+      before do
+        @request.facets = ['f1']
+        @request.facet_prefix = 'pre'
+        @solr_params = subject.build_solr_params @request, {}
+      end
+      it{ @solr_params[:facet].should be_true }
+      it{ @solr_params['facet.field'].should == [:f1] }
+      it{ @solr_params['facet.prefix'].should == 'pre' }
+    end
 
     it "should set result-format if specified" do
       solr_params = subject.build_solr_params @request, :result_format => 'json'

metadata

@@ -5,9 +5,9 @@ version: !ruby/object:Gem::Version
   prerelease: 
   segments: 
   - 1
-  - 1
-  - 6
-  version: 01.01.06
+  - 2
+  - 0
+  version: 01.02.00
 platform: ruby
 authors: 
 - Bernd Ledig
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-06-04 00:00:00 +02:00
+date: 2012-06-12 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -127,7 +127,6 @@ files:
 - Gemfile
 - Rakefile
 - lib/multi_solr.rb
-- lib/multi_solr/base_searcher.rb
 - lib/multi_solr/filter_value_composite.rb
 - lib/multi_solr/rails_form_render_helper.rb
 - lib/multi_solr/search_request.rb
@@ -142,7 +141,6 @@ files:
 - lib/multi_solr/version.rb
 - multi-solr.gemspec
 - spec/fixtures/solr-testdata.yml
-- spec/multi_solr/base_searcher_spec.rb
 - spec/multi_solr/search_request_spec.rb
 - spec/multi_solr/search_result_spec.rb
 - spec/multi_solr/single_core_handler_spec.rb

data/lib/multi_solr/base_searcher.rb

@@ -1,393 +0,0 @@
-# Basis-Suchmodule für SOLR-Indizies
-
-require 'rsolr'
-require "active_support/core_ext/class/attribute_accessors"
-
-module MultiSolr::BaseSearcher
-
-
-  # Erweitern einer Searcher-Class um Basis-Solr-Funktionen
-  #
-  def self.included(base)
-    base.class_eval do
-
-      cattr_accessor :solr_url                   # String mit der Base-Solr-Url (ohne Core-Anteil!)
-
-      cattr_accessor :result_class do            # die zu nutzende Klasse für das Suchergebnis
-        MultiSolr::SearchResult
-      end
-
-      cattr_accessor :facet_enum_fields do       # Array mit den Namen der Felder, die die Facet-Enum-Methode für Facets nutzen (Felder mit kleinen Wertebereichen)
-        []
-      end
-
-      # der zu verwendende SOLR-Core, wird per default aus dem Klassennamen gebildet
-      # Beispiel:  ContainerSearcher => 'core-container'
-      cattr_accessor(:core_name, :instance_reader => false, :instance_writer => false) do
-        m = self.name.match(/(\w+::)*(\w+)Searcher/)
-        if m
-          c = m[2].downcase
-          name = "core-#{c}"
-        else
-          name = 'core-default'
-        end
-        name
-      end
-
-      attr_accessor :fieldlist                # Field-List (siehe Solr-Doku fl-Parameter), default ist *
-      attr_accessor :facets_only              # wenn true, dann nur Facets ermittlen
-      attr_accessor :without_facets           # wenn true, dann auf Facets verzichten
-      attr_accessor :result_format            # Rückgabe-Format (json, xml), wenn nicht gesetzt wird "ruby" geliefert; Ist es gesetzt wird das Ergebnis nicht geparst (also raw als String zurückgegeben)
-
-
-    end
-    base.extend ClassMethods
-  end
-
-
-  module ClassMethods
-
-    def set_solr_url url
-      self.solr_url = url
-    end
-
-    # Setzen des CORE-Namens
-    def set_core_name name
-      self.core_name = name
-    end
-
-    def set_result_class clasz
-      self.result_class = clasz
-    end
-
-
-    # Setzen der Feldnamen, die bei Facetierung die Facet-Enum-Methode des SOLR nutzen sollen
-    def set_facet_enum_fields *field_names
-      self.facet_enum_fields += field_names
-    end
-
-
-    # Ermittelt und cached die möglichen Werte der als pre_cache_value_fields definierten Felder
-    # Diese werden im Rails-Cache zwischengespeichert
-    # Ansonsten see BaseSearcher.list_possible_values
-    # zusätzlicher Parameter:
-    #   expires_in:  optional, Gültigkeit des Cache-Wertes in Sekunden, default ist 1 Stunde
-    #
-    def cached_list_possible_values fieldname, context=nil, searcher_options=nil, expires_in=1.hours
-      cache_key = "solr-#{self.core_name}-#{context}-#{fieldname}-values"
-      values = MultiSolr.cache.read(cache_key)
-      if values.nil?
-        # dann sind noch gar keine Werte gecached => diese holen
-        values = list_possible_values fieldname, context, searcher_options
-        # und nun im Cache ablegen
-        MultiSolr.logger.debug "#{name}.cached_list_possible_values: write in cache '#{cache_key}' => #{values.inspect}" if MultiSolr.logger.debug?
-        MultiSolr.cache.write(cache_key, values, :expires_in => expires_in)
-      end
-      values
-    end
-
-
-    # Liefert zu dem spezifizierten Kontext und Feld die möglichen Werte
-    # Parameter:
-    #  fieldname: Name des Feldes (als Symbol)
-    #  context:   optionales Object mit weiteren Context-Informationen, dieser wird an den Force-Query-Builder übergeben
-    #  searcher_options: optinale Hash mit Optionen für den hier intern erzeugten Searcher (see self.initialize)
-    # Beispiel:
-    #   searcher.list_possible_values :lkz, :whs_id => 5
-    #
-    def list_possible_values fieldname, context=nil, searcher_options=nil
-      s_request = MultiSolr::SearchRequest.new :facets => [fieldname]
-      searcher_options ||= {}
-      searcher = self.new(searcher_options.merge(:facets_only => true))
-      result = searcher.execute(s_request, context)
-      facet_counts = result.facet_counts
-      values = []
-      if MultiSolr.logger.debug?
-        MultiSolr.logger.debug "#{name}.list_possible_values(#{fieldname}, #{context.inspect}): facet_counts=#{facet_counts.inspect}"
-      end
-      if facet_counts
-        value_pairs = facet_counts[fieldname.to_s]
-        if value_pairs && !value_pairs.empty?
-          # das value_pairs besteht Paar-weise aus Value und Anzahl
-          # Es werden hier nur die Values gebraucht, wo die Anzahl >0 ist
-          value_pairs.each do |value_count_pair|
-            val, count = value_count_pair
-            if val && count > 0
-              # wenn val nur aus Zahlen besteht, dann nach Integer konvertieren (wegen der Sortierung)
-              val = val.to_i if val =~ /\d+/
-              values << val
-            end
-          end
-          values.sort!
-        end
-      end
-      if MultiSolr.logger.debug?
-        MultiSolr.logger.debug "#{name}.list_possible_values(#{fieldname}, #{context.inspect}) => #{values.inspect}"
-      end
-      values
-    end
-
-
-    # Liefert RSolr-Connection (RSolr.connect) zum konfigurierten SOLR-Server(see solr_url)
-    # und konfiguriertem Core (see core_name)
-    def solr_connection
-      url = self.solr_url || raise("no solr-url configured!")
-      url = "#{url}/#{self.core_name}" if self.core_name
-      MultiSolr.logger.debug("solr_connection: url==#{url}")
-      RSolr.connect :url => url
-    end
-
-
-    # sendet Ping an SOLR-Instance
-    # returns true if ok
-    def ping
-      self.solr_connection.head("admin/ping").response[:status] == 200
-    end
-
-
-    # ermitteln Zeitstempel des letzten Datenimports 
-    def import_status solr_core_import_handler_propfile_path
-      MultiSolr.cache.fetch("Solr.import_status.#{self.core_name}.#{solr_core_import_handler_propfile_path}", :expires_in => 900) do
-        result = 'unbekannt'
-        begin
-          raise("Solr-Import-Status-Propertiesfile not exist") unless File.exist?(solr_core_import_handler_propfile_path)
-          matcher = /^last_index_time=(.*)$/
-          data = File.read(solr_core_import_handler_propfile_path)
-          match = matcher.match(data)
-          if match
-            result = match[1]
-            result.gsub!('\\', '') # Zeit enthält \ vor :
-            result = result[0...-3] # Sekunden entfernen
-          end
-        rescue => ex
-          MultiSolr.logger.warn "SolrSearch.import_status: source=#{solr_core_import_handler_propfile_path}, error=#{ex.message}\n\t"+ex.backtrace.join("\n\t")
-        end
-        MultiSolr.logger.info "SolrSearch.import_status: #{solr_core_import_handler_propfile_path}, result=#{result}"
-        result
-      end
-    end
-
-
-    # liefert einzelnes Solr-Dokument an Hand der Id
-    # Parameter:
-    #   id:             die gewünschte Id (Integer oder String)
-    #   id_field_name : optional, der Name des ID-Fields, default ist 'id'
-    def get_doc_by_id(id, id_field_name=:id)
-      solr_result = solr_connection.get 'select', :params => {:q => "#{id_field_name}:#{id}", :rows => 1}
-      docs = solr_result['response']['docs']
-      return nil if docs.nil? || docs.empty?
-      docs.first
-    end
-
-  end
-  # ===== ENDE der Class-Methods =====
-
-
-
-  # ===== START Instance-Methods =====
-
-
-  # Constructor
-  # params:
-  #  options: optionaler Hash mit Options (als Option sind aller hier definierten Attribute erlaubt)
-  def initialize options=nil
-    if options
-      options.each do |k,v|
-        self.send("#{k}=", v)
-      end
-    end
-  end
-
-  # liefert lokalen Core-Namen und wenn nicht gesetzt den globalen Core-Namen (in der Klasse definierten)
-  def core_name
-    @core_name || self.class.core_name
-  end
-
-
-  # setzt lokalen Core-Namen ohne den globalen Core-Namen (in der Klasse definiert) zu ändern
-  def core_name=(name)
-    @core_name = name
-  end
-
-
-  # liefert SOLR-Connection
-  def solr_connection
-    return @solr_connection if @solr_connection
-    url = self.class.solr_url || raise("no solr-url configured!")
-    url = "#{url}/#{self.core_name}" if self.core_name
-    MultiSolr.logger.debug("solr_connection: url==#{url}")
-    @solr_connection = RSolr.connect :url => url
-  end
-
-
-
-  # Ausführen der Suche / Recherche
-  # params:
-  #   solr_search_request: die Suchanfrage als SolrSearchRequest-Instance
-  #   context: Hash mit weiteren Context-Informationen, dieser wird u.a. an den Force-Query-Builder übergeben
-  def execute solr_search_request, context=nil
-    solr_params = build_solr_params solr_search_request, context
-    solr_result = solr_connection.get 'select', :params => solr_params
-
-    # RAW-Result liefern wenn Result-Format gesetzt ist
-    return solr_result if self.result_format
-
-    # Parsen des Ergebnisses
-    result = self.result_class.new solr_result, solr_search_request, context
-    result
-  end
-
-
-  # Bilden der SOLR-Parameter für eine SOLR-Anfrage
-  # params:
-  #   solr_search_request: die Suchanfrage als SolrSearchRequest-Instance
-  #   context: Hash mit weiteren Context-Informationen, dieser wird an den Force-Query-Builder übergeben
-  # returns: Hash mit den SOLR-Parametern
-  def build_solr_params solr_search_request, context=nil
-    solr_params = {}
-    solr_params['stats.field'] = []
-
-    fq_params = self.force_query_params context
-    if fq_params && fq_params.is_a?(Hash)
-      fq = []
-      fq_params.each{|k, v| fq << "#{k}:#{v}"}
-      solr_params[:fq] = fq.join(' ')
-    end
-
-    q = solr_search_request.build_query
-    q = "*:*" if q.blank? # wenn keine Query angegeben ist, dann nach allem Suchen
-    solr_params[:q] = q
-
-    # Fieldlist
-    if q['_val_:']
-      # dann enthält die Query eine query-function
-      # Der Wert dieser wird immer im field "score" abgelegt
-      # daher dieses Feld zur Feldliste hinzufügen
-      if self.fieldlist
-        self.fieldlist << ',score' unless self.fieldlist[',score']
-      else
-        self.fieldlist = '*,score'
-      end
-    end
-    solr_params[:fl] = self.fieldlist if self.fieldlist
-
-    # Sortierung
-    if solr_search_request.sorts && !solr_search_request.sorts.empty?
-      solr_search_request.sorts.delete_if{|s| s.blank?}
-      solr_params[:sort] = solr_search_request.sorts.map{|s| s =~ /\s(asc|desc)$/ ? s : "#{s} asc"}.join(',')
-    end
-
-    # Facets
-    if !self.without_facets && solr_search_request.facets
-      parse_facets solr_search_request, solr_params
-    end
-
-    # Stats
-    if solr_search_request.stats_fields && !solr_search_request.stats_fields.empty?
-      s_fields = solr_search_request.stats_fields.select{|f| !f.blank?}
-      unless s_fields.empty?
-        solr_params[:stats] = true
-        solr_params['stats.field'] += s_fields
-      end
-    end
-    solr_params['stats.field'].map!{|f| f.to_s}.uniq!
-
-    # Gruppierung
-    if !solr_search_request.group_field.blank? && !self.facets_only
-      solr_params[:group] = true
-      solr_params['group.field'] = solr_search_request.group_field
-      solr_params['group.ngroups'] = true
-      solr_params['group.limit'] = solr_search_request.group_size || 1
-      solr_params['group.truncate'] = true if solr_params[:facet] && solr_search_request.group_truncate
-    end
-
-
-    # Paginierung
-    if self.facets_only
-      solr_params[:rows] = 0
-    else
-      solr_params[:rows] = solr_search_request.page_size
-      solr_params[:start] = (solr_search_request.page-1) * solr_search_request.page_size
-    end
-
-    # Ausgabe-Format
-    solr_params[:wt] = self.result_format if self.result_format
-
-    if MultiSolr.logger.debug?
-      MultiSolr.logger.debug "SolrSearch#build_solr_params: #{self.inspect}\n\tSEARCH-REQUEST=#{solr_search_request.inspect}\n\t=> SOLR_PARAMS=#{solr_params.inspect}\n"
-    end
-    solr_params
-  end
-
-
-  protected
-
-  # liefert wenn notwendig die Parameter als Hash für eine SOLR-Force-Query
-  # sollte bei Bedarf von der nutzenden Klasse überschrieben werden.
-  # params:
-  #   context: Hash mit weiteren Context-Informationen
-  def force_query_params context
-    context
-  end
-
-
-  private
-
-
-  # Bilden der Facet-Solr-Params aus den Facet-Definitionen des Requests
-  def parse_facets solr_search_request, solr_params
-    solr_search_request.facets.delete_if(&:blank?) # leer Elemente entfernen
-    return if solr_search_request.facets.empty?
-
-    solr_params['facet.field'] = []
-    solr_params['facet.range'] = []
-    facet_params = solr_search_request.facet_params || {}
-    solr_search_request.facets.map(&:to_sym).each do |facet_field|
-      field_facet_params = facet_params[facet_field] || {}
-      stats_facet_field = field_facet_params[:stats_field]
-      if stats_facet_field
-        # dann Facet per Stats-Componente
-        solr_params[:stats] = true
-        if stats_facet_field.is_a?(Array)
-          solr_params['stats.field'] += stats_facet_field
-        else
-          solr_params['stats.field'] << stats_facet_field
-          stats_facet_field = [stats_facet_field]
-        end
-        stats_facet_field.each do |sfield_name|
-          solr_params["f.#{sfield_name}.stats.facet"] ||= []
-          solr_params["f.#{sfield_name}.stats.facet"] << facet_field
-        end
-      else
-        solr_params[:facet] = true
-        if field_facet_params[:range]
-          # Range-Facet
-          solr_params[:facet] = true
-          solr_params['facet.range'] << facet_field
-          field_facet_params[:end] ||= 'NOW/DAY'
-          field_facet_params[:gap] ||= '+1DAY'
-          field_facet_params.each do |option_name, value|
-            solr_params["f.#{facet_field}.facet.range.#{option_name}"] = value
-          end
-        else
-          # normale Facet-Field
-          solr_params['facet.field'] << facet_field
-          field_facet_params[:mincount] ||= 1 # Facets ohne Treffer ignorieren
-                                        # Nutzen der Facet-Enum-Methode fuer spezielle Felder (Felder mit kleinen Wertebereichen)
-          field_facet_params['method'] = 'enum' if self.facet_enum_fields.include?(facet_field)
-
-          field_facet_params.each do |option_name, value|
-            solr_params["f.#{facet_field}.facet.#{option_name}"] = value
-          end
-        end
-      end
-    end
-    if solr_params[:facet]
-      # Umschalten der Facet-Ergebnisse in Array-Darstellung
-      # (der json.nl-Schalter wirkt auch bei Ruby siehe http://wiki.apache.org/solr/SolJSON)
-      solr_params['json.nl'] = 'arrarr'
-    end
-
-  end
-
-end

data/spec/multi_solr/base_searcher_spec.rb

@@ -1,212 +0,0 @@
-require 'spec_helper'
-
-describe "Base-Searcher-Modul" do
-
-
-  subject { Class.new { include MultiSolr::BaseSearcher } }
-
-
-  context "core_name" do
-    it "should the defined core-name if set" do
-      subject.set_core_name 'core-set'
-      subject.core_name.should == 'core-set'
-    end
-
-    it "should use class-name if ends with Searcher" do
-      sample_searcher = Class.new
-      Object.const_set 'SampleSearcher', sample_searcher
-      sample_searcher.send :include, MultiSolr::BaseSearcher
-      sample_searcher.core_name.should == 'core-sample'
-    end
-
-    it "should use local (instance) core-name if set" do
-      searcher = subject.new
-      searcher.core_name = 'test-core'
-      searcher.core_name.should == 'test-core'
-      searcher.class.core_name == 'core-default'
-    end
-  end
-
-
-  context "cached_list_possible_values" do
-    it "should get cached value if exist" do
-      fieldname = :test; context = :test_context1
-      value = "test-value"
-      MultiSolr.cache.write("solr-#{subject.core_name}-#{context}-#{fieldname}-values", value)
-      subject.cached_list_possible_values(fieldname, context).should == value
-    end
-
-    it "should call 'list_possible_values' if no cached value exist" do
-      fieldname = :test; context = :test_context2
-      value = "test-value"
-      subject.should_receive(:list_possible_values).with(fieldname, context, nil) do
-        value
-      end
-      subject.cached_list_possible_values(fieldname, context).should == value
-    end
-  end
-
-
-  context "list_possible_values" do
-
-    it "should for field p1 an Array with right sortert Strings" do
-      facet_searcher_mock = double :searcher
-      result = double :solr_result
-      result.stub(:facet_counts).and_return('p1' => [['schuhe', 11], ['hosen', 2]])
-      facet_searcher_mock.stub(:execute).and_return(result)
-      subject.should_receive(:new).and_return(facet_searcher_mock)
-      subject.list_possible_values(:p1).should == ['hosen', 'schuhe']
-    end
-
-    it "should for field p2 an Array with sortet Integers" do
-      facet_searcher_mock = double :searcher
-      result = double :solr_result
-      result.stub(:facet_counts).and_return('p2' => [['2233', 2], ['11', 3]])
-      facet_searcher_mock.stub(:execute).and_return(result)
-      subject.should_receive(:new).and_return(facet_searcher_mock)
-      subject.list_possible_values(:p2).should == [11, 2233] # Int-Strings sollten nach int konvertiert sein
-    end
-  end
-
-  context "solr_connection" do
-    it "should raise exception if no solr_url set" do
-      expect{ subject.solr_connection }.to raise_error
-    end
-
-    it "should connect with solr-url + core-name" do
-      subject.set_solr_url 'http://localhost/solr'
-      RSolr.should_receive(:connect) do |options|
-        options # zum Test die options selbst wieder zurück liefern
-      end
-      subject.solr_connection[:url].should == 'http://localhost/solr/core-default'
-    end
-
-    it "should use local (instance) core-name if set" do
-      subject.set_solr_url 'http://localhost/solr'
-      RSolr.should_receive(:connect) do |options|
-        options # zum Test die options selbst wieder zurück liefern
-      end
-      searcher = subject.new
-      searcher.core_name = 'test_11'
-      searcher.solr_connection[:url].should == 'http://localhost/solr/test_11'
-    end
-  end
-
-
-
-  context "execute" do
-    before do
-      @request = MultiSolr::SearchRequest.new
-      @searcher = subject.new
-    end
-
-    it "should parse result if result-format is 'ruby'" do
-      rsolr_mock = double('rsolr')
-      rsolr_mock.should_receive(:get).and_return({})
-      @searcher.should_receive(:solr_connection).and_return(rsolr_mock)
-      result = @searcher.execute @request
-      result.should be_a(MultiSolr::SearchResult)
-    end
-
-    it "should not parse result if result-format is not 'ruby'" do
-      @searcher.result_format = 'json'
-      result_mock = "RAW"
-      rsolr_mock = double('rsolr')
-      rsolr_mock.should_receive(:get).and_return(result_mock)
-      @searcher.should_receive(:solr_connection).and_return(rsolr_mock)
-      result = @searcher.execute @request
-      result.should == result_mock
-    end
-  end
-
-
-
-  context "build_solr_params" do
-    before do
-      @request = MultiSolr::SearchRequest.new
-      @searcher = subject.new
-    end
-
-    it "should add score force-query if context given" do
-      solr_params = @searcher.build_solr_params @request, :whs_id => 8
-      solr_params[:fq].should == "whs_id:8"
-    end
-
-    it "should have query for all if no query specified" do
-      solr_params = @searcher.build_solr_params @request
-      solr_params[:q].should == "*:*"
-    end
-
-
-    it "should use query-params builded by search request" do
-      @request.should_receive(:build_query).and_return('lkz:1234')
-      solr_params = @searcher.build_solr_params @request
-      solr_params[:q].should == "lkz:1234"
-    end
-
-    it "should add score field to fieldlist if '_val_' in query (function query)" do
-      @request.should_receive(:build_query).and_return('lkz:1234 _val_:"product(menge,volumen)')
-      solr_params = @searcher.build_solr_params @request
-      @searcher.fieldlist.should == "*,score"
-      solr_params[:fl].should == "*,score"
-    end
-
-    it "should use sort if specified" do
-      @request.sorts = ['s1', 's2 desc']
-      solr_params = @searcher.build_solr_params @request
-      solr_params[:sort].should == 's1 asc,s2 desc'
-    end
-
-    context "should generate facet-params if simple facet fields specified" do
-      before do
-        @request.facets = ['f1', 'f2']
-        @solr_params = @searcher.build_solr_params @request
-      end
-      it{ @solr_params[:facet].should be_true }
-      it{ @solr_params['facet.field'].should == [:f1, :f2] }
-    end
-
-    context "should generate facet-params if facet fields specified" do
-      before do
-        @request.facets = ['f1', 'f2', 'f3']
-        @request.facet_params = {:f2 => {:limit => 1000, :sort => :index},
-                                 :f3 => {:range => true, :start => 'NOW/DAY-2DAY'}}
-        @solr_params = @searcher.build_solr_params @request
-      end
-      it{ @solr_params[:facet].should be_true }
-      it{ @solr_params['facet.field'].should == [:f1, :f2] }
-      it{ @solr_params['f.f2.facet.limit'].should == 1000 }
-      it{ @solr_params['f.f2.facet.sort'].to_s.should == 'index' }
-      it{ @solr_params['facet.range'].should == [:f3] }
-      it{ @solr_params['f.f3.facet.range.start'].should == 'NOW/DAY-2DAY' }
-      it{ @solr_params['f.f3.facet.range.end'].should == 'NOW/DAY' }
-      it{ @solr_params['f.f3.facet.range.gap'].should == '+1DAY' }
-      it{ @solr_params['json.nl'].should == 'arrarr' }
-    end
-
-    context "should generate stats-facets if facet-params have stats-field specified" do
-      before do
-        @request.facets = ['sf1', 'sf2']
-        @request.stats_fields = [:menge]
-        @request.facet_params = {:sf1 => {:stats_field => 'menge'},
-                                 :sf2 => {:stats_field => ['volumen', 'gewicht', 'menge']}}
-        @solr_params = @searcher.build_solr_params @request
-#        puts @solr_params.inspect
-      end
-      it{ @solr_params[:facet].should be_nil }
-      it{ @solr_params[:stats].should be_true }
-      it{ @solr_params['stats.field'].should == ['menge', 'volumen', 'gewicht'] }
-      it{ @solr_params['f.menge.stats.facet'].should == [:sf1, :sf2] }
-      it{ @solr_params['f.volumen.stats.facet'].should == [:sf2] }
-      it{ @solr_params['f.gewicht.stats.facet'].should == [:sf2] }
-    end
-
-
-    it "should set result-format to in searcher specified format" do
-      @searcher.result_format = 'json'
-      solr_params = @searcher.build_solr_params @request
-      solr_params[:wt].should == 'json'
-    end
-  end
-
-end