muck-solr 0.4.0

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

data/test/models/book.rb

@@ -0,0 +1,10 @@
+# Table fields for 'books'
+# - id
+# - category_id
+# - name
+# - author
+
+class Book < ActiveRecord::Base
+  belongs_to :category
+  acts_as_solr :include => [:category]
+end

data/test/models/category.rb

@@ -0,0 +1,8 @@
+# Table fields for 'categories'
+# - id
+# - name
+
+class Category < ActiveRecord::Base
+  has_many :books
+  acts_as_solr :include => [:books]
+end

data/test/models/electronic.rb

@@ -0,0 +1,25 @@
+# Table fields for 'electronics'
+# - id
+# - name
+# - manufacturer
+# - features
+# - category
+# - price
+# - created_on
+
+class Electronic < ActiveRecord::Base
+  acts_as_solr do
+    {
+      :facets => [:category, :manufacturer],
+      :fields => [:name, :manufacturer, :features, :category, {:created_at => :date}, {:updated_at => :date}, {:price => {:type => :range_float, :boost => 10.0}}],
+      :boost  => 5.0,
+      :exclude_fields => [:features]
+    }
+  end
+
+  # The following example would also convert the :price field type to :range_float
+  # 
+  # acts_as_solr :facets => [:category, :manufacturer],
+  #              :fields => [:name, :manufacturer, :features, :category, {:price => :range_float}],
+  #              :boost  => 5.0
+end

data/test/models/gadget.rb

@@ -0,0 +1,9 @@
+class Gadget < ActiveRecord::Base
+  cattr_accessor :search_disabled
+  
+  acts_as_solr :offline => proc {|record| Gadget.search_disabled?}, :format => :ids
+  
+  def self.search_disabled?
+    search_disabled
+  end
+end

data/test/models/movie.rb

@@ -0,0 +1,17 @@
+# Table fields for 'movies'
+# - id
+# - name
+# - description
+
+class Movie < ActiveRecord::Base
+  acts_as_solr :additional_fields => [:current_time, {:time_on_xml => :date}]
+  
+  def current_time
+    Time.now.to_s
+  end
+  
+  def time_on_xml
+    Time.now
+  end
+  
+end

data/test/models/novel.rb

@@ -0,0 +1,2 @@
+class Novel < Book
+end

data/test/models/post.rb

@@ -0,0 +1,3 @@
+class Post < ActiveRecord::Base
+  acts_as_solr
+end

data/test/models/posting.rb

@@ -0,0 +1,11 @@
+# Table fields for 'movies'
+# - guid
+# - name
+# - description
+
+class Posting < ActiveRecord::Base
+
+  set_primary_key 'guid'
+  acts_as_solr({},{:primary_key_field => 'pk_s'})
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'test/unit'
+require 'active_record'
+require 'active_record/fixtures'
+
+begin
+  require 'active_support/test_case'
+rescue
+end
+
+RAILS_ROOT = File.dirname(__FILE__) unless defined? RAILS_ROOT
+RAILS_ENV  = 'test' unless defined? RAILS_ENV
+ENV["RAILS_ENV"] = "test"
+ENV["ACTS_AS_SOLR_TEST"] = "true"
+
+require File.expand_path(File.dirname(__FILE__) + '/../lib/acts_as_solr')
+require File.expand_path(File.dirname(__FILE__) + '/../config/solr_environment.rb')
+
+# Load Models
+models_dir = File.join(File.dirname( __FILE__ ), 'models')
+require "#{models_dir}/book.rb"
+Dir[ models_dir + '/*.rb'].each { |m| require m }
+
+if defined?(ActiveSupport::TestCase)
+  class ActiveSupport::TestCase
+    include ActiveRecord::TestFixtures
+    self.fixture_path = File.dirname(__FILE__) + "/fixtures/"
+  end unless ActiveSupport::TestCase.respond_to?(:fixture_path=)
+else
+  Test::Unit::TestCase.fixture_path = File.dirname(__FILE__) + "/fixtures/"
+end
+
+class Test::Unit::TestCase
+  def self.fixtures(*table_names)
+    fixture_path = defined?(ActiveSupport::TestCase) ? ActiveSupport::TestCase.fixture_path : Test::Unit::TestCase.fixture_path
+    if block_given?
+      Fixtures.create_fixtures(fixture_path, table_names) { yield }
+    else
+      Fixtures.create_fixtures(fixture_path, table_names)
+    end
+    table_names.each do |table_name|
+      clear_from_solr(table_name)
+      klass = instance_eval table_name.to_s.capitalize.singularize
+      klass.find(:all).each{|content| content.solr_save}
+    end
+    
+    clear_from_solr(:novels)
+  end
+  
+  private
+  def self.clear_from_solr(table_name)
+    ActsAsSolr::Post.execute(Solr::Request::Delete.new(:query => "type_s:#{table_name.to_s.capitalize.singularize}"))
+  end
+end

data/test/unit/acts_methods_shoulda.rb

@@ -0,0 +1,68 @@
+require File.expand_path("#{File.dirname(__FILE__)}/test_helper")
+
+class ActsMethodsTest < Test::Unit::TestCase
+  class Model
+    attr_accessor :birthdate
+    
+    def initialize(birthdate)
+      @birthdate = birthdate
+    end
+    
+    def self.configuration
+      @configuration ||= {:solr_fields => {}}
+    end
+
+    def self.columns_hash=(columns_hash)
+      @columns_hash = columns_hash
+    end
+    
+    def self.columns_hash
+      @columns_hash
+    end
+    
+    def [](key)
+      @birthday
+    end
+    
+    self.extend ActsAsSolr::ActsMethods
+  end
+  
+  
+  context "when getting field values" do
+    setup do
+      Model.columns_hash = {"birthdate" => stub("column", :type => :date)}
+      Model.send(:get_field_value, :birthdate)
+    end
+    
+    should "define an accessor methods for a solr converted value" do
+      assert Model.instance_methods.include?("birthdate_for_solr")
+    end
+    
+    context "for date types" do
+      setup do
+        @model = Model.new(Date.today)
+      end
+      
+      should "return nil when field is nil" do
+        @model.birthdate = nil
+        assert_nil @model.birthdate_for_solr
+      end
+      
+      should "return the formatted date" do
+        assert_equal Date.today.strftime("%Y-%m-%dT%H:%M:%SZ"), @model.birthdate_for_solr
+      end
+    end
+    
+    context "for timestamp types" do
+      setup do
+        @now = Time.now
+        @model = Model.new(@now)
+      end
+      
+      should "return a formatted timestamp string for timestamps" do
+        assert_equal @now.utc.strftime("%Y-%m-%dT%H:%M:%SZ"), @model.birthdate_for_solr
+      end
+    end
+  end
+  
+end