greglu-solr-ruby 0.0.7

data/test/unit/hpricot_test_file.xml

@@ -0,0 +1,26 @@
+<!--
+ /**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+ -->
+<root>
+  <parent>
+    <child attribute="attribute1">text1</child>
+    <child attribute="attribute2">text2</child>
+    <child attribute="attribute3">text3<grandchild>grandchild 3 text</grandchild></child>
+  </parent>
+</root>

data/test/unit/indexer_test.rb

@@ -0,0 +1,57 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'test/unit'
+require 'solr'
+
+class Solr::Indexer
+  attr_reader :added
+  def add_docs(doc)
+    @added ||= []
+    @added << doc
+  end
+end
+
+class IndexerTest < Test::Unit::TestCase
+  def test_mapping_or_mapping
+    mapping = {:field => "foo"}
+    indexer = Solr::Indexer.new([1,2,3], mapping, :debug => true)
+    indexer.index
+    assert_equal 3, indexer.added.size
+    
+    indexer = Solr::Indexer.new([1,2,3,4], Solr::Importer::Mapper.new(mapping), :debug => true)
+    indexer.index
+    assert_equal 4, indexer.added.size
+  end
+
+  def test_batch
+    mapping = {:field => "foo"}
+    indexer = Solr::Indexer.new([1,2,3], mapping, :debug => true, :buffer_docs => 2)
+    indexer.index
+    assert_equal 2, indexer.added.size
+  end
+  
+end
+
+
+# source = DataSource.new
+# 
+# mapping = {
+#   :id => :isbn,
+#   :name => :author,
+#   :source => "BOOKS",
+#   :year => Proc.new {|record| record.date[0,4] },
+# }
+# 
+# Solr::Indexer.index(source, mapper) do |orig_data, solr_document|
+#   solr_document[:timestamp] = Time.now
+# end

data/test/unit/modify_document_test.rb

@@ -0,0 +1,24 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'test/unit'
+require 'solr'
+
+class ModifyDocumentTest < Test::Unit::TestCase
+
+  def test_update_formatting
+    request = Solr::Request::ModifyDocument.new(:id => 10, :overwrite => {:name => ['val1', 'val2'], :copyfield => nil})
+    assert_equal :xml, request.response_format
+    assert_match /copyfield\:OVERWRITE/, request.handler
+    assert_match /name\:OVERWRITE/, request.handler
+  end
+end

data/test/unit/ping_test.rb

@@ -0,0 +1,51 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'solr_mock_base'
+
+class PingTest < SolrMockBaseTestCase 
+
+  def test_ping_response
+    xml = 
+<<PING_RESPONSE
+
+<?xml-stylesheet type="text/xsl" href="ping.xsl"?>
+
+<solr>
+  <ping>
+
+  </ping>
+</solr>
+PING_RESPONSE
+    conn = Solr::Connection.new('http://localhost:9999')
+    set_post_return(xml)
+    response = conn.send(Solr::Request::Ping.new)
+    assert_kind_of Solr::Response::Ping, response
+    assert_equal true, response.ok? 
+
+    # test shorthand
+    assert true, conn.ping
+  end
+
+  def test_bad_ping_response
+    xml = "<foo>bar</foo>"
+    conn = Solr::Connection.new('http://localhost:9999')
+    set_post_return(xml)
+    response = conn.send(Solr::Request::Ping.new)
+    assert_kind_of Solr::Response::Ping, response
+    assert_equal false, response.ok?
+
+    # test shorthand
+    assert_equal false, conn.ping
+  end
+
+end

data/test/unit/request_test.rb

@@ -0,0 +1,61 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'test/unit'
+require 'solr'
+
+class BadRequest < Solr::Request::Base
+end
+
+class RequestTest < Test::Unit::TestCase
+
+  def test_commit_request
+    request = Solr::Request::Commit.new
+    assert_equal :xml, request.response_format
+    assert_equal 'update', request.handler
+    assert_match(/<commit waitSearcher=["']true["'] waitFlush=["'']true["'']\/>/, request.to_s)
+  end
+  
+  def test_add_doc_request
+    request = Solr::Request::AddDocument.new(:title => "title")
+    assert_match(/<add>[\s]*<doc>[\s]*<field name=["']title["']>title<\/field>[\s]*<\/doc>[\s]*<\/add>/m, request.to_s)
+    assert_equal :xml, request.response_format
+    assert_equal 'update', request.handler
+    
+    assert_raise(RuntimeError) do
+      Solr::Request::AddDocument.new("invalid")
+    end
+  end
+  
+  def test_add_multidoc_request
+    request = Solr::Request::AddDocument.new([{:title => "title1"}, {:title => "title2"}])
+    assert_match(/<add>[\s]*<doc>[\s]*<field name=["']title["']>title1<\/field>[\s]*<\/doc>[\s]*<doc>[\s]*<field name=["']title["']>title2<\/field>[\s]*<\/doc>[\s]*<\/add>/m, request.to_s)
+    assert_equal :xml, request.response_format
+    assert_equal 'update', request.handler
+  end
+  
+  def test_ping_request
+    request = Solr::Request::Ping.new
+    assert_equal :xml, request.response_format
+  end
+
+  def test_bad_request_class
+    assert_raise(RuntimeError) do
+      BadRequest.new.response_format
+    end
+    
+    assert_raise(RuntimeError) do
+      BadRequest.new.handler
+    end
+  end
+
+end

data/test/unit/response_test.rb

@@ -0,0 +1,43 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'test/unit'
+require 'solr'
+require 'solr_mock_base'
+
+
+class ResponseTest < SolrMockBaseTestCase
+
+  def test_response_xml_error
+    begin
+      Solr::Response::Xml.new("<broken>invalid xml&")
+      flunk("failed to get Solr::Exception as expected") 
+    rescue Exception => exception
+      assert_kind_of Solr::Exception, exception
+      assert_match 'invalid response xml', exception.to_s
+    end
+  end
+  
+  def test_invalid_ruby
+    assert_raise(Solr::Exception) do
+      Solr::Response::Ruby.new(' {...')
+    end
+  end
+
+  # This is now an acceptable use of Select, for the default request handler with no parameters (other than &wt=ruby)  
+  # def test_bogus_request_handling
+  #   assert_raise(Solr::Exception) do
+  #     Solr::Response::Base.make_response(Solr::Request::Select.new, "response data")
+  #   end
+  # end
+
+end

data/test/unit/select_test.rb

@@ -0,0 +1,25 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'test/unit'
+require 'solr'
+
+class SelectTest < Test::Unit::TestCase
+
+  def test_basic_query
+    request = Solr::Request::Select.new('custom', :q => 'query')
+    assert_equal :ruby, request.response_format
+    assert_equal 'select', request.handler
+    assert_equal 'query', request.to_hash[:q]
+  end
+  
+end

data/test/unit/solr_mock_base.rb

@@ -0,0 +1,40 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'test/unit'
+require 'solr'
+
+# TODO: Maybe replace this with flexmock
+class SolrMockBaseTestCase < Test::Unit::TestCase
+  include Solr
+  
+  def setup
+    Connection.send(:alias_method, :orig_post, :post)
+  end
+  
+  def teardown
+    Connection.send(:alias_method, :post, :orig_post)
+  end
+    
+  def set_post_return(value)
+    Connection.class_eval %{
+      def post(request)
+        %q{#{value}}
+      end
+    }
+  end
+  
+  def test_dummy
+    # So Test::Unit is happy running this class
+  end
+    
+end

data/test/unit/spellcheck_response_test.rb

@@ -0,0 +1,26 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'solr_mock_base'
+
+class SpellcheckResponseTest <  SolrMockBaseTestCase
+  def test_basic
+    ruby_code = "{'responseHeader'=>{'status'=>0,'QTime'=>5},'suggestions'=>['whately','whatcha','whatever']}"
+    conn = Solr::Connection.new 'http://localhost:9999'
+    set_post_return(ruby_code)
+    response = conn.send(Solr::Request::Spellcheck.new(:query => 'whateva'))
+    assert_equal true, response.ok?
+    assert_equal 3, response.suggestions.size
+    assert_equal ['whately','whatcha','whatever'], response.suggestions
+  end
+end
+

data/test/unit/spellchecker_request_test.rb

@@ -0,0 +1,27 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'test/unit'
+require 'solr'
+
+class SpellcheckRequestTest < Test::Unit::TestCase
+  def test_spellcheck_request
+    request = Solr::Request::Spellcheck.new(:query => 'whateva', :suggestion_count => 5, :accuracy => 0.7, :only_more_popular => true)
+    assert_equal :ruby, request.response_format
+    assert_equal 'select', request.handler
+    hash = request.to_hash
+    assert_equal 'whateva', hash[:q]
+    assert_equal 5, hash[:suggestionCount]
+    assert_equal 0.7, hash[:accuracy]
+    assert_equal true, hash[:onlyMorePopular]
+  end
+end

data/test/unit/standard_request_test.rb

@@ -0,0 +1,324 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'test/unit'
+require 'solr'
+
+class StandardRequestTest < Test::Unit::TestCase
+
+  def test_basic_query
+    request = Solr::Request::Standard.new(:query => 'query')
+    assert_equal :ruby, request.response_format
+    assert_equal 'select', request.handler
+    assert_equal 'query', request.to_hash[:q]
+    assert_match /q=query/, request.to_s
+  end
+  
+  def test_bad_params
+    assert_raise(RuntimeError) do
+      Solr::Request::Standard.new(:foo => "invalid")
+    end
+    
+    assert_raise(RuntimeError) do
+      Solr::Request::Standard.new(:query => "valid", :foo => "invalid")
+    end
+    
+    assert_raise(RuntimeError) do
+      Solr::Request::Standard.new(:query => "valid", :operator => :bogus)
+    end
+  end
+  
+  def test_common_params
+    request = Solr::Request::Standard.new(:query => 'query', :start => 10, :rows => 50,
+           :filter_queries => ['fq1', 'fq2'], :field_list => ['id','title','score'], :operator => :and)
+    assert_equal 10, request.to_hash[:start]
+    assert_equal 50, request.to_hash[:rows]
+    assert_equal ['fq1','fq2'], request.to_hash[:fq]
+    assert_equal "id,title,score", request.to_hash[:fl]
+    assert_equal "AND", request.to_hash["q.op"]
+  end
+    
+  def test_missing_params
+    request = Solr::Request::Standard.new(:query => 'query', :debug_query => false, :facets => {:fields =>[:category_facet]})
+    assert_nil request.to_hash[:rows]
+    assert_no_match /rows/, request.to_s
+    assert_no_match /facet\.sort/, request.to_s
+    assert_match /debugQuery/, request.to_s
+  end
+  
+  def test_only_facet_query
+    request = Solr::Request::Standard.new(:query => 'query',
+       :facets => {
+         :queries => ["q1", "q2"],
+        }
+    )
+    
+    hash = request.to_hash
+    assert_equal ["q1", "q2"], hash["facet.query"]
+  end
+  
+  def test_facet_params_all
+    request = Solr::Request::Standard.new(:query => 'query',
+       :facets => {
+         :fields => [:genre,           
+                     # field that overrides the global facet parameters
+                     {:year => {:limit => 50, :mincount => 0, :missing => false, :sort => :term, :prefix=>"199", :offset => 7}}], 
+         :queries => ["q1", "q2"],
+         :prefix => "cat",
+         :offset => 3, :limit => 5, :zeros => true, :mincount => 20, :sort => :count  # global facet parameters
+        }
+    )
+    
+    hash = request.to_hash
+    assert_equal true, hash[:facet]
+    assert_equal [:genre, :year], hash["facet.field"]
+    assert_equal ["q1", "q2"], hash["facet.query"]
+    assert_equal 5, hash["facet.limit"]
+    assert_equal 20, hash["facet.mincount"]
+    assert_equal true, hash["facet.sort"]
+    assert_equal "cat", hash["facet.prefix"]
+    assert_equal 50, hash["f.year.facet.limit"]
+    assert_equal 0, hash["f.year.facet.mincount"]
+    assert_equal false, hash["f.year.facet.sort"]
+    assert_equal "199", hash["f.year.facet.prefix"]
+    assert_equal 3, hash["facet.offset"]
+    assert_equal 7, hash["f.year.facet.offset"]
+  end
+
+  def test_basic_sort
+    request = Solr::Request::Standard.new(:query => 'query', :sort => [{:title => :descending}, {:date => :ascending}])
+    assert_equal 'query', request.to_hash[:q]
+    assert_equal 'title desc,date asc', request.to_hash[:sort]
+  end
+  
+  def test_highlighting
+    request = Solr::Request::Standard.new(:query => 'query',
+      :highlighting => {
+        :field_list => ['title', 'author'],
+        :merge_contiguous => true,
+        :increment => 100,
+        :max_snippets => 3,
+        :require_field_match => true,
+        :prefix => "<blink>",
+        :suffix => "</blink>",
+        :fragment_size => 300,
+        :max_analyzed_chars => 102400,
+        :formatter => 'myFormatter',
+        :fragmenter => 'myFragmenter',
+        :use_phrase_highlighter => true
+      }
+    )
+    
+    hash = request.to_hash
+    assert_equal true, hash[:hl]
+    assert_equal "title,author", hash["hl.fl"]
+    assert_equal true, hash["hl.mergeContiguous"]
+    assert_equal 100, hash["hl.increment"]
+    assert_equal 3, hash["hl.snippets"]
+    assert_equal true, hash["hl.requireFieldMatch"]
+    assert_equal "<blink>", hash["hl.simple.pre"]
+    assert_equal "</blink>", hash["hl.simple.post"]
+    assert_equal 300, hash["hl.fragsize"]
+    assert_equal 102400, hash["hl.maxAnalyzedChars"]
+    assert_equal "myFormatter", hash["hl.formatter"]
+    assert_equal "myFragmenter", hash["hl.fragmenter"]
+    assert_equal true, hash["hl.usePhraseHighlighter"]
+  end
+  
+  def test_highlighting2
+    request = Solr::Request::Standard.new(:query => 'query',
+      :highlighting => {
+        :field_list => ['title', 'author'],
+        :merge_contiguous => {
+          :default=>false, :fields=>{'author'=>true}
+        },
+        :increment => {
+          :default=>100, :fields=>{'author'=>200}
+        },
+        :max_snippets => {
+          :default=>2,:fields=>{'author'=>3}
+        },
+        :prefix => {
+          :default=>"<em>", :fields=>{'author'=>"<blink>"},
+        },
+        :suffix => {
+          :default=>"</em>", :fields=>{'author'=>"</blink>"},
+        },
+        :fragment_size => {
+          :default=>300,:fields=>{'author'=>200}
+        },
+        :max_analyzed_chars => {
+          :default=>102400,:fields=>{'author'=>51200}
+        },
+        :require_field_match => {
+          :default=>false, :fields=>{'author'=>true}
+        },
+        :formatter => {
+          :default=>'defaultFormatter', :fields=>{'title'=>'titleFormatter'}
+        },
+        :fragmenter => {
+          :default=>'defaultFragmenter',:fields=>{'title'=>'titleFragmenter'}
+        },
+      }
+    )
+    
+    hash = request.to_hash
+    assert_equal true, hash[:hl]
+    assert_equal "title,author", hash["hl.fl"]
+    assert_equal false, hash["hl.mergeContiguous"]
+    assert_equal true, hash["f.author.hl.mergeContiguous"]
+    assert_equal 100, hash["hl.increment"]
+    assert_equal 200, hash["f.author.hl.increment"]
+    assert_equal 2, hash["hl.snippets"]
+    assert_equal 3, hash["f.author.hl.snippets"]
+    assert_equal "<em>", hash["hl.simple.pre"]
+    assert_equal "<blink>", hash["f.author.hl.simple.pre"]
+    assert_equal "</em>", hash["hl.simple.post"]
+    assert_equal "</blink>", hash["f.author.hl.simple.post"]
+    assert_equal 300, hash["hl.fragsize"]
+    assert_equal 200, hash["f.author.hl.fragsize"]
+    assert_equal 102400, hash["hl.maxAnalyzedChars"]
+    assert_equal 51200, hash["f.author.hl.maxAnalyzedChars"]
+    assert_equal false, hash["hl.requireFieldMatch"]
+    assert_equal true, hash["f.author.hl.requireFieldMatch"]
+    assert_equal 'defaultFormatter', hash["hl.formatter"]
+    assert_equal 'titleFormatter', hash["f.title.hl.formatter"]
+    assert_equal 'defaultFragmenter', hash["hl.fragmenter"]
+    assert_equal 'titleFragmenter', hash["f.title.hl.fragmenter"]
+  end
+  
+  def test_highlighting_regex
+    request = Solr::Request::Standard.new(:query => 'query',
+      :highlighting => {
+        :field_list => ['title', 'author'],
+        :regex => {
+          :slop => 0.8,
+          :pattern => '\w',
+          :max_analyzed_chars => 10000
+        }
+      }
+    )
+    
+    hash = request.to_hash
+    assert_equal true, hash[:hl]
+    assert_equal "title,author", hash["hl.fl"]
+    assert_equal 0.8, hash["hl.regex.slop"]
+    assert_equal '\w', hash["hl.regex.pattern"]
+    assert_equal 10000, hash["hl.regex.maxAnalyzedChars"]
+  end
+  
+  def test_highlighting_regex2
+    request = Solr::Request::Standard.new(:query => 'query',
+      :highlighting => {
+        :field_list => ['title', 'author'],
+        :regex => {
+          :slop => { :default=>0.5, :fields=>{'author'=>0.8} },
+          :pattern => { :default=>'\w', :fields=>{'author'=>'\n'} },
+          :max_analyzed_chars => { :default=>10000, :fields=>{'author'=>20000} }
+        }
+      }
+    )
+    
+    hash = request.to_hash
+    assert_equal true, hash[:hl]
+    assert_equal "title,author", hash["hl.fl"]
+    assert_equal 0.5, hash["hl.regex.slop"]
+    assert_equal 0.8, hash["f.author.hl.regex.slop"]
+    assert_equal '\w', hash["hl.regex.pattern"]
+    assert_equal '\n', hash["f.author.hl.regex.pattern"]
+    assert_equal 10000, hash["hl.regex.maxAnalyzedChars"]
+    assert_equal 20000, hash["f.author.hl.regex.maxAnalyzedChars"]
+  end
+  
+  def test_highlighting_alternate_field
+    request = Solr::Request::Standard.new(:query => 'query',
+      :highlighting => {
+        :field_list => ['title', 'author'],
+        :alternate_field => 'title',
+        :max_alternate_field_length => 30
+      }
+    )
+    
+    hash = request.to_hash
+    assert_equal true, hash[:hl]
+    assert_equal "title,author", hash["hl.fl"]
+    assert_equal "title", hash["hl.alternateField"]
+    assert_equal 30, hash["hl.maxAlternateFieldLength"]
+  end
+  
+  def test_highlighting_alternate_field2
+    request = Solr::Request::Standard.new(:query => 'query',
+      :highlighting => {
+        :field_list => ['title', 'author'],
+        :alternate_field => {
+          :default=>'default', :fields=>{'title'=>'title', 'author'=>'author'}
+        },
+        :max_alternate_field_length => {
+          :default=>10, :fields=>{'title'=>30, 'author'=>20}
+        }
+      }
+    )
+    
+    hash = request.to_hash
+    assert_equal true, hash[:hl]
+    assert_equal "title,author", hash["hl.fl"]
+    assert_equal "default", hash["hl.alternateField"]
+    assert_equal "title", hash["f.title.hl.alternateField"]
+    assert_equal "author", hash["f.author.hl.alternateField"]
+    assert_equal 10, hash["hl.maxAlternateFieldLength"]
+    assert_equal 30, hash["f.title.hl.maxAlternateFieldLength"]
+    assert_equal 20, hash["f.author.hl.maxAlternateFieldLength"]
+  end
+  
+  def test_highlighting_alternate_field_old_style
+    request = Solr::Request::Standard.new(:query => 'query',
+      :highlighting => {
+        :field_list => ['title', 'author'],
+        :alternate_fields => {'title'=>'title', 'author'=>'author'},
+        :max_alternate_field_length => {'title'=>30, 'author'=>20}
+      }
+    )
+    
+    hash = request.to_hash
+    assert_equal true, hash[:hl]
+    assert_equal "title,author", hash["hl.fl"]
+    assert_equal "title", hash["f.title.hl.alternateField"]
+    assert_equal "author", hash["f.author.hl.alternateField"]
+    assert_equal 30, hash["f.title.hl.maxAlternateFieldLength"]
+    assert_equal 20, hash["f.author.hl.maxAlternateFieldLength"]
+  end
+  
+  def test_mlt
+    request = Solr::Request::Standard.new(:query => 'query',
+      :mlt => {
+        :count => 5, :field_list => ['field1', 'field2'],
+        :min_term_freq => 3, :min_doc_freq => 10,
+        :min_word_length => 4, :max_word_length => 17,
+        :max_query_terms => 20, :max_tokens_parsed => 100,
+        :boost => true
+      }
+    )
+    
+    hash = request.to_hash
+    assert_equal true, hash[:mlt]
+    assert_equal 5, hash["mlt.count"]
+    assert_equal 'field1,field2', hash["mlt.fl"]
+    assert_equal 3, hash["mlt.mintf"]
+    assert_equal 10, hash["mlt.mindf"]
+    assert_equal 4, hash["mlt.minwl"]
+    assert_equal 17, hash["mlt.maxwl"]
+    assert_equal 20, hash["mlt.maxqt"]
+    assert_equal 100, hash["mlt.maxntp"]
+    assert_equal true, hash["mlt.boost"]
+  end
+
+end