websolr-rails 1.4.4 → 2.0.0

data/test/functional/association_indexing_test.rb

@@ -1,37 +0,0 @@
-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

@@ -1,163 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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
-    assert_equal Movie, records.docs.first.class
-    assert_equal Book,  records.docs.last.class
-  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
-    records = Book.multi_solr_search "Napoleon OR Tom OR Thriller", :models => [Movie, Category], :results_format => :ids
-    assert_equal 4, records.total
-    [{"id" => "Category:1"}, {"id" =>"Book:1"}, {"id" => "Movie:1"}, {"id" =>"Book:3"}].each do |result|
-      assert records.docs.include?(result)
-    end
-  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_equal 1.0112731, records.docs.first.solr_score
-    assert_equal 0.6723396, records.docs.last.solr_score
-  end
-end

data/test/models/author.rb

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

data/test/models/book.rb

@@ -1,10 +0,0 @@
-# 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

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

data/test/models/electronic.rb

@@ -1,21 +0,0 @@
-# Table fields for 'electronics'
-# - id
-# - name
-# - manufacturer
-# - features
-# - category
-# - price
-# - created_on
-
-class Electronic < ActiveRecord::Base
-  acts_as_solr :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]
-
-  # 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

@@ -1,9 +0,0 @@
-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

@@ -1,17 +0,0 @@
-# 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

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

data/test/models/post.rb

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

data/test/models/posting.rb

@@ -1,11 +0,0 @@
-# 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

@@ -1,51 +0,0 @@
-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
-
-require File.dirname(__FILE__) + '/../lib/acts_as_solr'
-require File.dirname(__FILE__) + '/../config/solr_environment.rb'
-
-# Load Models
-models_dir = File.join(File.dirname( __FILE__ ), 'models')
-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

@@ -1,70 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-require 'acts_methods'
-require 'mocha'
-
-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