jbasdf-muck-solr 0.4.0

data/test/functional/acts_as_solr_test.rb

@@ -0,0 +1,413 @@
+# encoding: utf-8
+require "#{File.dirname(File.expand_path(__FILE__))}/../test_helper"
+
+class ActsAsSolrTest < Test::Unit::TestCase
+  
+  fixtures :books, :movies, :electronics, :postings, :authors
+
+  # Inserting new data into Solr and making sure it's getting indexed
+  def test_insert_new_data
+    assert_equal 2, Book.count_by_solr('ruby OR splinter OR bob')
+    b = Book.create(:name => "Fuze in action", :author => "Bob Bobber", :category_id => 1)
+    assert b.valid?
+    assert_equal 3, Book.count_by_solr('ruby OR splinter OR bob')
+  end
+  
+  # Check the type column stored in the index isn't stemmed by SOLR.  If it is stemmed,
+  # then both Post and Posting will be stored as type:Post, so a query for Posts will
+  # return Postings and vice versa
+  
+  def test_insert_new_data_doesnt_stem_type
+    assert_equal 0, Post.count_by_solr('aardvark')
+    p = Posting.new :name => 'aardvark', :description => "An interesting animal"
+    p.guid = '12AB'
+    p.save!
+    assert_equal 0, Post.count_by_solr('aardvark')
+  end
+
+  def test_type_determined_from_database_if_not_explicitly_set
+    assert Post.configuration[:solr_fields][:posted_at][:type] == :date
+  end
+  
+  def test_search_includes_subclasses
+    Novel.create! :name => 'Wuthering Heights', :author => 'Emily Bronte'
+    Book.create! :name => 'Jane Eyre', :author => 'Charlotte Bronte'
+    assert_equal 1, Novel.find_by_solr('Bronte').total_hits
+    assert_equal 2, Book.find_by_solr('Bronte').total_hits
+  end
+
+  # Testing basic solr search:
+  #  Model.find_by_solr 'term'
+  # Note that you're able to mix free-search with fields and boolean operators
+  def test_find_by_solr_ruby
+    ['ruby', 'dummy', 'name:ruby', 'name:dummy', 'name:ruby AND author:peter', 
+      'author:peter AND ruby', 'peter dummy'].each do |term|
+      records = Book.find_by_solr term
+      assert_equal 1, records.total
+      assert_equal "Peter McPeterson", records.docs.first.author
+      assert_equal "Ruby for Dummies", records.docs.first.name
+      assert_equal ({"id" => 2, 
+                      "category_id" => 2, 
+                      "name" => "Ruby for Dummies", 
+                      "author" => "Peter McPeterson", "published_on" => (Date.today - 2.years), "type" => nil}), records.docs.first.attributes
+    end
+  end
+  
+  # Testing basic solr search:
+  #   Model.find_by_solr 'term'
+  # Note that you're able to mix free-search with fields and boolean operators
+  def test_find_by_solr_splinter
+    ['splinter', 'name:splinter', 'name:splinter AND author:clancy', 
+      'author:clancy AND splinter', 'cell tom'].each do |term|
+      records = Book.find_by_solr term
+      assert_equal 1, records.total
+      assert_equal "Splinter Cell", records.docs.first.name
+      assert_equal "Tom Clancy", records.docs.first.author
+      assert_equal ({"id" => 1, "category_id" => 1, "name" => "Splinter Cell", 
+                     "author" => "Tom Clancy", "published_on" => (Date.today - 1.year), "type" => nil}), records.docs.first.attributes
+    end
+  end
+  
+  # Testing basic solr search:
+  #   Model.find_by_solr 'term'
+  # Note that you're able to mix free-search with fields and boolean operators
+  def test_find_by_solr_ruby_or_splinter
+    ['ruby OR splinter', 'ruby OR author:tom', 'name:cell OR author:peter', 'dummy OR cell'].each do |term|
+      records = Book.find_by_solr term
+      assert_equal 2, records.total
+    end
+  end
+  
+  # Testing search in indexed field methods:
+  # 
+  # class Movie < ActiveRecord::Base
+  #   acts_as_solr :fields => [:name, :description, :current_time]
+  # 
+  #   def current_time
+  #     Time.now.to_s
+  #   end
+  # 
+  # end
+  # 
+  # The method current_time above gets indexed as being part of the
+  # Movie model and it's available for search as well
+  def test_find_with_dynamic_fields
+    date = Time.now.strftime('%b %d %Y')
+    ["dynamite AND #{date}", "description:goofy AND #{date}", "goofy napoleon #{date}", 
+      "goofiness #{date}"].each do |term|
+      records = Movie.find_by_solr term 
+      assert_equal 1, records.total
+      assert_equal ({"id" => 1, "name" => "Napoleon Dynamite", 
+                     "description" => "Cool movie about a goofy guy"}), records.docs.first.attributes
+    end
+  end
+  
+  # Testing basic solr search that returns just the ids instead of the objects:
+  #   Model.find_id_by_solr 'term'
+  # Note that you're able to mix free-search with fields and boolean operators
+  def test_find_id_by_solr_ruby
+    ['ruby', 'dummy', 'name:ruby', 'name:dummy', 'name:ruby AND author:peter', 
+      'author:peter AND ruby'].each do |term|
+      records = Book.find_id_by_solr term
+      assert_equal 1, records.docs.size
+      assert_equal [2], records.docs
+    end
+  end
+  
+  # Testing basic solr search that returns just the ids instead of the objects:
+  #   Model.find_id_by_solr 'term'
+  # Note that you're able to mix free-search with fields and boolean operators
+  def test_find_id_by_solr_splinter
+    ['splinter', 'name:splinter', 'name:splinter AND author:clancy', 
+      'author:clancy AND splinter'].each do |term|
+      records = Book.find_id_by_solr term
+      assert_equal 1, records.docs.size
+      assert_equal [1], records.docs
+    end
+  end
+  
+  # Testing basic solr search that returns just the ids instead of the objects:
+  #   Model.find_id_by_solr 'term'
+  # Note that you're able to mix free-search with fields and boolean operators
+  def test_find_id_by_solr_ruby_or_splinter
+    ['ruby OR splinter', 'ruby OR author:tom', 'name:cell OR author:peter', 
+      'dummy OR cell'].each do |term|
+      records = Book.find_id_by_solr term
+      assert_equal 2, records.docs.size
+      assert_equal [1,2], records.docs
+    end
+  end
+  
+  # Testing basic solr search that returns the total number of records found:
+  #   Model.find_count_by_solr 'term'
+  # Note that you're able to mix free-search with fields and boolean operators
+  def test_count_by_solr
+    ['ruby', 'dummy', 'name:ruby', 'name:dummy', 'name:ruby AND author:peter', 
+      'author:peter AND ruby'].each do |term|
+      assert_equal 1, Book.count_by_solr(term), "there should only be 1 result for search: #{term}"
+    end
+  end
+  
+  # Testing basic solr search that returns the total number of records found:
+  #   Model.find_count_by_solr 'term'
+  # Note that you're able to mix free-search with fields and boolean operators
+  def test_count_by_solr_splinter
+    ['splinter', 'name:splinter', 'name:splinter AND author:clancy', 
+      'author:clancy AND splinter', 'author:clancy cell'].each do |term|
+      assert_equal 1, Book.count_by_solr(term)
+    end
+  end
+  
+  # Testing basic solr search that returns the total number of records found:
+  #   Model.find_count_by_solr 'term'
+  # Note that you're able to mix free-search with fields and boolean operators
+  def test_count_by_solr_ruby_or_splinter
+    ['ruby OR splinter', 'ruby OR author:tom', 'name:cell OR author:peter', 'dummy OR cell'].each do |term|
+      assert_equal 2, Book.count_by_solr(term)
+    end
+  end
+    
+  # Testing basic solr search with additional options:
+  # Model.find_count_by_solr 'term', :limit => 10, :offset => 0
+  def test_find_with_options
+    [1,2].each do |count|
+      records = Book.find_by_solr 'ruby OR splinter', :limit => count
+      assert_equal count, records.docs.size
+    end
+  end
+  
+  # Testing self.rebuild_solr_index
+  # - It makes sure the index is rebuilt after a data has been lost
+  def test_rebuild_solr_index
+    assert_equal 1, Book.count_by_solr('splinter')
+    
+    Book.find(:first).solr_destroy
+    assert_equal 0, Book.count_by_solr('splinter')
+    
+    Book.rebuild_solr_index
+    assert_equal 1, Book.count_by_solr('splinter')
+  end
+  
+  # Testing instance methods:
+  # - solr_save
+  # - solr_destroy
+  def test_solr_save_and_solr_destroy
+    assert_equal 1, Book.count_by_solr('splinter')
+  
+    Book.find(:first).solr_destroy
+    assert_equal 0, Book.count_by_solr('splinter')
+    
+    Book.find(:first).solr_save
+    assert_equal 1, Book.count_by_solr('splinter')
+  end
+  
+  # Testing the order of results
+  def test_find_returns_records_in_order
+    records = Book.find_by_solr 'ruby^5 OR splinter'
+    # we boosted ruby so ruby should come first
+  
+    assert_equal 2, records.total
+    assert_equal 'Ruby for Dummies', records.docs.first.name
+    assert_equal 'Splinter Cell', records.docs.last.name    
+  end
+  
+  # Testing solr search with optional :order argument
+  def _test_with_order_option
+    records = Movie.find_by_solr 'office^5 OR goofiness'
+    assert_equal 'Hypnotized dude loves fishing but not working', records.docs.first.description
+    assert_equal 'Cool movie about a goofy guy', records.docs.last.description
+    
+    records = Movie.find_by_solr 'office^5 OR goofiness', :order => 'description asc'
+    assert_equal 'Cool movie about a goofy guy', records.docs.first.description
+    assert_equal 'Hypnotized dude loves fishing but not working', records.docs.last.description
+  end
+  
+  # Testing search with omitted :field_types should 
+  # return the same result set as if when we use it
+  def test_omit_field_types_in_search
+    records  = Electronic.find_by_solr "price:[200 TO 599.99]"
+    assert_match(/599/, records.docs.first.price)
+    assert_match(/319/, records.docs.last.price)
+    
+    records  = Electronic.find_by_solr "price:[200 TO 599.99]", :order => 'price asc'
+    assert_match(/319/, records.docs.first.price)
+    assert_match(/599/, records.docs.last.price)
+    
+  end
+  
+  # Test to make sure the result returned when no matches
+  # are found has the same structure when there are results
+  def test_returns_no_matches
+    records = Book.find_by_solr 'rubyist'
+    assert_equal [], records.docs
+    assert_equal 0, records.total
+    
+    records = Book.find_id_by_solr 'rubyist'
+    assert_equal [], records.docs
+    assert_equal 0, records.total
+    
+    records = Book.find_by_solr 'rubyist', :facets => {}
+    assert_equal [], records.docs
+    assert_equal 0, records.total
+    assert_equal({"facet_fields"=>[]}, records.facets)
+  end
+  
+  
+  # Testing the :exclude_fields option when set in the
+  # model to make sure it doesn't get indexed
+  def test_exclude_fields_option
+    records = Electronic.find_by_solr 'audiobooks OR latency'
+    assert records.docs.empty?
+    assert_equal 0, records.total
+  
+    assert_nothing_raised{
+      records = Electronic.find_by_solr 'features:audiobooks'
+      assert records.docs.empty?
+      assert_equal 0, records.total
+    }
+  end
+  
+  # Testing the :auto_commit option set to false in the model
+  # should not send the commit command to Solr
+  def test_auto_commit_turned_off
+    assert_equal 0, Author.count_by_solr('raymond chandler')
+    
+    original_count = Author.count
+    Author.create(:name => 'Raymond Chandler', :biography => 'Writes noirish detective stories')
+    
+    assert_equal original_count + 1, Author.count
+    assert_equal 0, Author.count_by_solr('raymond chandler')
+  end
+  
+  # Testing models that use a different key as the primary key
+  def test_search_on_model_with_string_id_field
+    records = Posting.find_by_solr 'first^5 OR second'
+    assert_equal 2, records.total
+    assert_equal 'ABC-123', records.docs.first.guid
+    assert_equal 'DEF-456', records.docs.last.guid
+  end
+  
+  # Making sure the result set is ordered correctly even on
+  # models that use a different key as the primary key
+  def test_records_in_order_on_model_with_string_id_field
+    records = Posting.find_by_solr 'first OR second^5'
+    assert_equal 2, records.total
+    assert_equal 'DEF-456', records.docs.first.guid
+    assert_equal 'ABC-123', records.docs.last.guid
+  end
+  
+  # Making sure the records are added when passing a batch size
+  # to rebuild_solr_index
+  def test_using_rebuild_solr_index_with_batch
+    assert_equal 2, Movie.count_by_solr('office OR napoleon')
+    Movie.find(:all).each(&:solr_destroy)
+    assert_equal 0, Movie.count_by_solr('office OR napoleon')
+    
+    Movie.rebuild_solr_index 100
+    assert_equal 2, Movie.count_by_solr('office OR napoleon')
+  end
+  
+  # Making sure find_by_solr with scores actually return the scores
+  # for each individual record
+  def test_find_by_solr_with_score
+    books = Book.find_by_solr 'ruby^10 OR splinter', :scores => true
+    assert_equal 2, books.total
+    assert (books.max_score >= 0.3 && books.max_score <= 0.6)
+
+    books.records.each { |book| assert_not_nil book.solr_score }
+    assert (books.docs.first.solr_score >= 0.3 && books.docs.first.solr_score <= 0.6)
+    assert (books.docs.last.solr_score >= 0.1 && books.docs.last.solr_score <= 0.2)
+  end
+  
+  # Making sure nothing breaks when html entities are inside
+  # the content to be indexed; and on the search as well.
+  def test_index_and_search_with_html_entities
+    description = "
+    inverted exclamation mark  	&iexcl;  	&#161;
+    ¤ 	currency 	&curren; 	&#164;
+    ¢ 	cent 	&cent; 	&#162;
+    £ 	pound 	&pound; 	&#163;
+    ¥ 	yen 	&yen; 	&#165;
+    ¦ 	broken vertical bar 	&brvbar; 	&#166;
+    § 	section 	&sect; 	&#167;
+    ¨ 	spacing diaeresis 	&uml; 	&#168;
+    © 	copyright 	&copy; 	&#169;
+    ª 	feminine ordinal indicator 	&ordf; 	&#170;
+    « 	angle quotation mark (left) 	&laquo; 	&#171;
+    ¬ 	negation 	&not; 	&#172;
+    ­ 	soft hyphen 	&shy; 	&#173;
+    ® 	registered trademark 	&reg; 	&#174;
+    ™ 	trademark 	&trade; 	&#8482;
+    ¯ 	spacing macron 	&macr; 	&#175;
+    ° 	degree 	&deg; 	&#176;
+    ± 	plus-or-minus  	&plusmn; 	&#177;
+    ² 	superscript 2 	&sup2; 	&#178;
+    ³ 	superscript 3 	&sup3; 	&#179;
+    ´ 	spacing acute 	&acute; 	&#180;
+    µ 	micro 	&micro; 	&#181;
+    ¶ 	paragraph 	&para; 	&#182;
+    · 	middle dot 	&middot; 	&#183;
+    ¸ 	spacing cedilla 	&cedil; 	&#184;
+    ¹ 	superscript 1 	&sup1; 	&#185;
+    º 	masculine ordinal indicator 	&ordm; 	&#186;
+    » 	angle quotation mark (right) 	&raquo; 	&#187;
+    ¼ 	fraction 1/4 	&frac14; 	&#188;
+    ½ 	fraction 1/2 	&frac12; 	&#189;
+    ¾ 	fraction 3/4 	&frac34; 	&#190;
+    ¿ 	inverted question mark 	&iquest; 	&#191;
+    × 	multiplication 	&times; 	&#215;
+    ÷ 	division 	&divide; 	&#247
+        &hearts; &diams; &clubs; &spades;"
+    
+    author = Author.create(:name => "Test in Action&trade; - Copyright &copy; Bob", :biography => description)
+    assert author.valid?
+    author.solr_commit
+
+    author = Author.find_by_solr 'trademark &copy &#190 &iexcl &#163'
+    assert_equal 1, author.total
+  end
+  
+  def test_operator_search_option
+    assert_nothing_raised {
+      books = Movie.find_by_solr "office napoleon", :operator => :or
+      assert_equal 2, books.total
+      
+      books = Movie.find_by_solr "office napoleon", :operator => :and
+      assert_equal 0, books.total
+    }
+    
+    assert_raise RuntimeError do
+      Movie.find_by_solr "office napoleon", :operator => :bad
+    end
+  end  
+  
+  # Making sure find_by_solr with scores actually return the scores
+  # for each individual record and orders them accordingly
+  def test_find_by_solr_order_by_score
+    books = Book.find_by_solr 'ruby^10 OR splinter', {:scores => true, :order => 'score asc' }
+    assert (books.docs.collect(&:solr_score).compact.size == books.docs.size), "Each book should have a score"
+    assert (books.docs.last.solr_score >= 0.3 && books.docs.last.solr_score <= 0.6)
+
+    books = Book.find_by_solr 'ruby^10 OR splinter', {:scores => true, :order => 'score desc' }
+    assert (books.docs.first.solr_score >= 0.3 && books.docs.first.solr_score <= 0.6)
+    assert (books.docs.last.solr_score >= 0.1 && books.docs.last.solr_score <= 0.2)
+  end
+  
+  # Search based on fields with the :date format
+  def test_indexed_date_field_format
+    movies = Movie.find_by_solr 'time_on_xml:[NOW-1DAY TO NOW]'
+    assert_equal 2, movies.total
+  end
+  
+  def test_query_time_is_returned
+    results = Book.find_by_solr('ruby')
+    assert_not_nil(results.query_time)
+    assert_equal(results.query_time.class,Fixnum)
+  end
+  
+  def test_should_not_index_the_record_when_offline_proc_returns_true
+    Gadget.search_disabled = true
+    gadget = Gadget.create(:name => "flipvideo mino")
+    assert_equal 0, Gadget.find_id_by_solr('flipvideo').total
+  end
+end

data/test/functional/association_indexing_test.rb

@@ -0,0 +1,37 @@
+require File.join(File.dirname(__FILE__), '../test_helper')
+
+class AssociationIndexingTest < Test::Unit::TestCase
+  
+  fixtures :categories, :books 
+  
+  # Testing the association indexing with has_many:
+  # 
+  # class Category < ActiveRecord::Base
+  #   has_many :books
+  #   acts_as_solr :include => [:books]
+  # end
+  # 
+  # Note that some of the search terms below are from the 'books'
+  # table, but get indexed as being a part of Category
+  def test_search_on_fields_in_has_many_association
+    ['thriller', 'novel', 'splinter', 'clancy', 'tom clancy thriller'].each do |term|
+      assert_equal 1, Category.count_by_solr(term), "expected one result: #{term}"
+    end
+  end
+  
+  # Testing the association indexing with belongs_to:
+  # 
+  # class Book < ActiveRecord::Base
+  #   belongs_to :category
+  #   acts_as_solr :include => [:category]
+  # end
+  # 
+  # Note that some of the search terms below are from the 'categories'
+  # table, but get indexed as being a part of Book
+  def test_search_on_fields_in_belongs_to_association
+    ['splinter', 'clancy', 'tom clancy thriller', 'splinter novel'].each do |term|
+      assert_equal 1, Book.count_by_solr(term), "expected one result: #{term}"
+    end
+  end
+
+end

data/test/functional/faceted_search_test.rb

@@ -0,0 +1,163 @@
+require File.join(File.dirname(__FILE__), '../test_helper')
+
+class FacetedSearchTest < Test::Unit::TestCase
+  
+  fixtures :electronics
+  
+  # The tests below are for faceted search, but make sure you setup
+  # the fields on your model you'd like to index as a facet field:
+  # 
+  # class Electronic < ActiveRecord::Base
+  #   acts_as_solr :facets => [:category, :manufacturer]  
+  # end
+  # 
+  # A basic faceted search using just one facet field
+  def test_faceted_search_basic
+    records = Electronic.find_by_solr "memory", :facets => {:fields =>[:category]}
+    assert_equal 4, records.docs.size
+    assert_match /Apple 60 GB Memory iPod/, records.docs.first.name
+    assert_equal({"category_facet" => {"Electronics" => 1, 
+                                       "Memory" => 2, 
+                                       "Hard Drive" => 1}}, 
+                 records.facets['facet_fields'])
+  end
+  
+  # Making sure the empty result returned what we expected
+  def test_faceted_search_no_matches
+    records = Electronic.find_by_solr "not found", :facets => { :fields => [:category]}
+    assert_equal [], records.docs
+    assert_equal [], records.facets['facet_fields']
+  end
+  
+  # A basic faceted search using multiple facet fields
+  def test_faceted_search_multiple_fields
+    records = Electronic.find_by_solr "memory", :facets => {:fields =>[:category, :manufacturer]}
+    assert_equal 4, records.docs.size
+    assert_equal({"category_facet" => {"Electronics" => 1, 
+                                       "Memory" => 2, 
+                                       "Hard Drive" => 1},
+                  "manufacturer_facet" => {"Dell, Inc" => 0,
+                                           "Samsung Electronics Co. Ltd." => 1, 
+                                           "Corsair Microsystems Inc." => 1, 
+                                           "A-DATA Technology Inc." => 1,
+                                           "Apple Computer Inc." => 1}}, records.facets['facet_fields'])
+  end
+  
+  # A basic faceted search using facet queries to get counts. 
+  # Here are the facets search query meaning:
+  # "price:[* TO 200]" - Price up to 200
+  # "price:[200 TO 500]" - Price from 200 to 500
+  # "price:[500 TO *]" - Price higher than 500
+  def test_facet_search_with_query
+    records = Electronic.find_by_solr "memory", :facets => {:query => ["price:[* TO 200.00]",
+                                                                          "price:[200.00 TO 500.00]",
+                                                                          "price:[500.00 TO *]"]}
+    assert_equal 4, records.docs.size
+    assert_equal({"facet_queries" => {"price_rf:[* TO 200.00]"=>2,
+                                      "price_rf:[200.00 TO 500.00]"=>1,
+                                      "price_rf:[500.00 TO *]"=>1}, 
+                  "facet_fields" => {}, "facet_dates" => {}}, records.facets)
+  end
+  
+  # Faceted search specifying the query and fields
+  def test_facet_search_with_query_and_field
+    records = Electronic.find_by_solr "memory", :facets => {:query => ["price:[* TO 200.00]",
+                                                                          "price:[200.00 TO 500.00]",
+                                                                          "price:[500.00 TO *]"],
+                                                               :fields => [:category, :manufacturer]}
+    
+    q = records.facets["facet_queries"]
+    assert_equal 2, q["price_rf:[* TO 200.00]"]
+    assert_equal 1, q["price_rf:[500.00 TO *]"]
+    assert_equal 1, q["price_rf:[200.00 TO 500.00]"]
+  
+    f = records.facets["facet_fields"]
+    assert_equal 1, f["category_facet"]["Electronics"]
+    assert_equal 2, f["category_facet"]["Memory"]
+    assert_equal 1, f["category_facet"]["Hard Drive"]
+    assert_equal 1, f["manufacturer_facet"]["Samsung Electronics Co. Ltd."]
+    assert_equal 1, f["manufacturer_facet"]["Corsair Microsystems Inc."]
+    assert_equal 1, f["manufacturer_facet"]["A-DATA Technology Inc."]
+    assert_equal 1, f["manufacturer_facet"]["Apple Computer Inc."]
+  end
+  
+  # Faceted searches with :sort and :zeros options turned on/off
+  def test_faceted_search_using_zero_and_sort
+    records = Electronic.find_by_solr "memory", :facets => {:fields =>[:category]}
+    assert_equal({"category_facet"=>{"Electronics"=>1, "Memory"=>2, "Hard Drive"=>1}}, records.facets['facet_fields'])
+    
+    records = Electronic.find_by_solr "memory", :facets => {:sort => true, :fields =>[:category]}
+    assert_equal({"category_facet"=>{"Memory"=>2, "Electronics"=>1, "Hard Drive"=>1}}, records.facets['facet_fields'])
+    
+    records = Electronic.find_by_solr "memory", :facets => {:fields =>[:manufacturer]}
+    assert_equal({"manufacturer_facet" => {"Dell, Inc" => 0,
+                                          "Samsung Electronics Co. Ltd." => 1, 
+                                          "Corsair Microsystems Inc." => 1, 
+                                          "A-DATA Technology Inc." => 1,
+                                          "Apple Computer Inc." => 1}}, records.facets['facet_fields'])
+  
+    records = Electronic.find_by_solr "memory", :facets => {:zeros => false, :fields =>[:manufacturer]}
+    assert_equal({"manufacturer_facet" => {"Samsung Electronics Co. Ltd." => 1, 
+                                          "Corsair Microsystems Inc." => 1, 
+                                          "A-DATA Technology Inc." => 1,
+                                          "Apple Computer Inc." => 1}}, records.facets['facet_fields'])
+  end
+  
+  # Faceted search with 'drill-down' option being passed.
+  # The :browse option receives the argument in the format:
+  # "facet_field:term". You can drill-down to as many
+  # facet fields as you like
+  def test_faceted_search_with_drill_down
+    records = Electronic.find_by_solr "memory", :facets => {:fields =>[:category]}
+    assert_equal 4, records.docs.size
+    assert_equal({"category_facet"=>{"Electronics"=>1, "Memory"=>2, "Hard Drive"=>1}}, records.facets['facet_fields'])
+    
+    records = Electronic.find_by_solr "memory", :facets => {:fields =>[:category],
+                                                               :browse => "category:Memory",
+                                                               :zeros => false}
+    assert_equal 2, records.docs.size
+    assert_equal({"category_facet"=>{"Memory"=>2}}, records.facets['facet_fields'])
+  end
+  
+  def test_faceted_search_with_dates
+    records = Electronic.find_by_solr "memory", :facets => {:dates => {:fields => [:created_at, :updated_at],
+      :start => (Date.today - 7.years).strftime("%Y-%m-%dT%H:%M:%SZ"), :end => Date.today.strftime("%Y-%m-%dT%H:%M:%SZ"), :gap => '+1YEAR', :other => :all}}
+
+    assert_equal 4, records.docs.size
+    
+    assert_equal 0, records.facets["facet_dates"]["created_at_d"]["after"]
+    assert_equal 1, records.facets["facet_dates"]["created_at_d"]["before"]
+    assert_equal 3, records.facets["facet_dates"]["created_at_d"]["between"]
+    
+    assert_equal 0, records.facets["facet_dates"]["updated_at_d"]["after"]
+    assert_equal 0, records.facets["facet_dates"]["updated_at_d"]["before"]
+    assert_equal 4, records.facets["facet_dates"]["updated_at_d"]["between"]
+  end
+  
+  def test_faceted_search_with_dates_filter
+    records = Electronic.find_by_solr "memory", :facets => {:dates => {:filter => ["updated_at:[#{(Date.today - 3.months).strftime("%Y-%m-%dT%H:%M:%SZ")} TO NOW-1MONTH/DAY]"]}}
+    
+    assert_equal 2, records.docs.size
+    
+    records.docs.each { |r|
+      assert r.updated_at >= (Date.today - 3.month)
+      assert r.updated_at <= (Date.today - 1.month)
+    }
+  end
+  
+  def test_faceted_search_with_dates_filter_and_facets
+    # this is a very contrived example but gives us data to validate
+    records = Electronic.find_by_solr "memory", :facets => {:dates => {:filter => ["updated_at:[#{(Date.today - 3.months).strftime("%Y-%m-%dT%H:%M:%SZ")} TO NOW-1MONTH/DAY]"],
+      :fields => [:created_at, :updated_at], :start => 'NOW-2MONTHS/DAY', :end => 'NOW-1MONTH/DAY', :gap => '+1MONTH', :other => :all}}
+    
+    assert_equal 2, records.docs.size
+    
+    assert_equal 0, records.facets["facet_dates"]["created_at_d"]["after"]
+    assert_equal 2, records.facets["facet_dates"]["created_at_d"]["before"]
+    assert_equal 0, records.facets["facet_dates"]["created_at_d"]["between"]
+    
+    assert_equal 0, records.facets["facet_dates"]["updated_at_d"]["after"]
+    assert_equal 1, records.facets["facet_dates"]["updated_at_d"]["before"]
+    assert_equal 1, records.facets["facet_dates"]["updated_at_d"]["between"]
+  end
+end

data/test/functional/multi_solr_search_test.rb

@@ -0,0 +1,57 @@
+require File.join(File.dirname(__FILE__), '../test_helper')
+
+class ActsAsSolrTest < Test::Unit::TestCase
+  
+  fixtures :books, :movies
+
+  # Testing the multi_solr_search with the returning results being objects
+  def test_multi_solr_search_return_objects
+    records = Book.multi_solr_search "Napoleon OR Tom", :models => [Movie], :results_format => :objects
+    assert_equal 2, records.total
+    classes = records.docs.map {|d| d.class}
+    assert classes.include?(Book)
+    assert classes.include?(Movie)
+  end
+  
+  # Testing the multi_solr_search with the returning results being ids
+  def test_multi_solr_search_return_ids
+    records = Book.multi_solr_search "Napoleon OR Tom", :models => [Movie], :results_format => :ids
+    assert_equal 2, records.total
+    assert records.docs.include?({"id" => "Movie:1"})
+    assert records.docs.include?({"id" => "Book:1"})
+  end
+  
+  # Testing the multi_solr_search with multiple models
+  def test_multi_solr_search_multiple_models
+    # TODO: Generalize me
+    ActsAsSolr::Post.execute(Solr::Request::Delete.new(:query => 'type_s:Author AND NOT id:"Author:1" AND NOT id:"Author:2"'))
+    ActsAsSolr::Post.execute(Solr::Request::Delete.new(:query => 'type_s:Book AND NOT id:"Book:1" AND NOT id:"Book:2"'))
+    ActsAsSolr::Post.execute(Solr::Request::Commit.new)
+
+    records = Book.multi_solr_search "Napoleon OR Tom OR Thriller", :models => [Movie, Category], :results_format => :ids
+    assert_equal 3, records.total
+    assert records.docs.include?({"id" => "Category:1"})
+    assert records.docs.include?({"id" =>"Book:1"})
+    assert records.docs.include?({"id" => "Movie:1"})
+  end
+  
+  # Testing empty result set format
+  def test_returns_no_matches
+    records = Book.multi_solr_search "not found", :models => [Movie, Category]
+    assert_equal [], records.docs
+    assert_equal 0, records.total
+  end
+  
+  def test_search_on_empty_string_does_not_return_nil
+    records = Book.multi_solr_search('', :models => [Movie, Category])
+    assert_not_nil records
+    assert_equal [], records.docs
+    assert_equal 0, records.total
+  end
+  
+  def test_search_with_score_should_set_score
+    records = Book.multi_solr_search "Napoleon OR Tom", :models => [Movie], :results_format => :objects, :scores => true
+    assert records.docs.first.solr_score.is_a?(Float)
+    assert records.docs.last.solr_score.is_a?(Float)
+  end
+end

data/test/models/author.rb

@@ -0,0 +1,10 @@
+# Table fields for 'movies'
+# - id
+# - name
+# - biography
+
+class Author < ActiveRecord::Base
+
+  acts_as_solr :auto_commit => false
+  
+end