watson-acts_as_ferret 0.4.8.2

data/doc/demo/test/unit/ferret_result_test.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'pp'
+require 'fileutils'
+
+class FerretResultTest < Test::Unit::TestCase
+  fixtures :contents
+
+  def teardown
+  end
+  
+  def test_get_prefetched_fields_from_hash
+    fr = ActsAsFerret::FerretResult.new 'Content', '1', 0.5, 1, :description => 'description from ferret index'
+    assert_equal 'description from ferret index', fr.description
+    assert_equal 0.5, fr.ferret_score
+    assert_equal 1, fr.ferret_rank
+    assert_equal 'My Title', fr.title # triggers auto-load of the record
+    assert_equal 'A useless description', fr.description # description now comes from DB
+  end
+
+  def test_to_param
+    fr = ActsAsFerret::FerretResult.new 'Content', '1', 0.5, 1, :description => 'description from ferret index'
+    assert_equal '1', fr.to_param
+  end
+end

data/doc/demo/test/unit/multi_index_test.rb

@@ -0,0 +1,329 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'pp'
+require 'fileutils'
+
+class MultiIndexTest < Test::Unit::TestCase
+  include Ferret::Index
+  include Ferret::Search
+  fixtures :contents, :comments
+
+  def setup
+    #make sure the fixtures are in the index
+    FileUtils.rm_f 'index/test/'
+    Comment.rebuild_index
+    ContentBase.rebuild_index 
+    raise "missing fixtures" unless ContentBase.count > 2
+    
+    @another_content = Content.new( :title => 'Another Content item', 
+                                    :description => 'this is not the title' )
+    @another_content.save
+    @comment = @another_content.comments.create(:author => 'john doe', :content => 'This is a useless comment')
+    @comment2 = @another_content.comments.create(:author => 'another', :content => 'content')
+    @another_content.save # to update comment_count in ferret-index
+  end
+  
+  def teardown
+    ContentBase.find(:all).each { |c| c.destroy }
+    Comment.find(:all).each { |c| c.destroy }
+  end
+
+
+  # weiter: single index / multisearch lazy loading
+#  def test_lazy_loading
+#    results = Content.find_with_ferret 'description', :lazy => true
+#    assert_equal 1, results.size
+#    result = results.first
+#    class << result
+#      attr_accessor :ar_record # so we have a chance to check if it's been loaded...
+#    end
+#    assert ActsAsFerret::FerretResult === result
+#    assert_equal 'A useless description', result.description
+#    assert_nil result.instance_variable_get(:@ar_record)
+#    assert_equal 'My Title', result.title
+#    assert_not_nil result.ar_record
+#  end
+
+  
+  def test_total_hits
+    q = '*:title OR *:comment'
+    assert_equal 3, Comment.total_hits(q)
+    assert_equal 2, Content.total_hits(q)
+    assert_equal 5, ActsAsFerret::total_hits(q, [ Comment, Content ])
+  end
+
+  def test_sorting
+    sorting = [ Ferret::Search::SortField.new(:id) ]
+    result = ActsAsFerret::find('*:title OR *:comment', [Content, Comment], :sort => sorting)
+    assert_equal result.map(&:id).sort, result.map(&:id)
+
+    sorting = [ Ferret::Search::SortField.new(:title) ]
+    result = ActsAsFerret::find('*:title OR *:comment', [Content, Comment], :sort => sorting)
+    sorting = [ Ferret::Search::SortField.new(:title, :reverse => true) ]
+    result2 = ActsAsFerret::find('*:title OR *:comment', [Content, Comment], :sort => sorting)
+    assert result.any?
+    assert result.map(&:id) != result2.map(&:id)
+
+    result = ActsAsFerret::find('*:title OR *:comment', [Content, Comment ])
+    assert result.any?
+    assert_equal result.map(&:ferret_score).sort.reverse, result.map(&:ferret_score)
+
+    sorting = [ Ferret::Search::SortField::SCORE ]
+    result = ActsAsFerret::find('*:title OR *:comment', [Content, Comment ], :sort => sorting)
+    assert result.any?
+    assert_equal result.map(&:ferret_score).sort.reverse, result.map(&:ferret_score)
+
+    sorting = [ Ferret::Search::SortField::SCORE_REV ]
+    result2 = ActsAsFerret::find('*:title OR *:comment', [Content, Comment], :sort => sorting)
+    assert_equal result2.map(&:ferret_score).sort, result2.map(&:ferret_score)
+    assert_equal result.map(&:ferret_score), result2.map(&:ferret_score).reverse
+  end
+
+  
+  # remote index rebuilds will create an index in a directory with a timestamped name.
+  # the local MultiIndex instance doesn't know about this (because it's running in 
+  # another interpreter instance than the server) and therefore fails to use the 
+  # correct index directories.
+  # TODO strange, still doesn't work but it should now...
+  unless Content.aaf_configuration[:remote]
+    def test_multi_index
+      i =  ActsAsFerret::get_index_for Content, Comment
+      assert ActsAsFerret::MultiIndex === i
+      hits = i.search(TermQuery.new(:title,"title"))
+      assert_equal 1, hits.total_hits
+
+      qp = Ferret::QueryParser.new(:default_field => "title", 
+                                  :analyzer => Ferret::Analysis::WhiteSpaceAnalyzer.new)
+      hits = i.search(qp.parse("title"))
+      assert_equal 1, hits.total_hits
+      
+      qp = Ferret::QueryParser.new(:fields => ['title', 'content', 'description'],
+                        :analyzer => Ferret::Analysis::WhiteSpaceAnalyzer.new)
+      hits = i.search(qp.parse("title"))
+      assert_equal 2, hits.total_hits
+      hits = i.search(qp.parse("title:title OR description:title"))
+      assert_equal 2, hits.total_hits
+
+      hits = i.search("title:title OR description:title OR title:comment OR description:comment OR content:comment")
+      assert_equal 5, hits.total_hits
+
+      hits = i.search("title OR comment")
+      assert_equal 5, hits.total_hits
+
+      hits = i.search("title OR comment", :limit => 2)
+      count = 0
+      hits.hits.each { |hit, score| count += 1 }
+      assert_equal 2, count
+
+      hits = i.search("title OR comment", :offset => 2)
+      count = 0
+      hits.hits.each { |hit, score| count += 1 }
+      assert_equal 3, count
+    end
+  end
+
+  def test_search_rebuilds_index
+    remove_index Content
+    contents_from_ferret = ActsAsFerret::find('description:title', [Content, Comment])
+    assert_equal 1, contents_from_ferret.size
+  end
+
+  # remote index rebuilds will create an index in a directory with a timestamped name...
+  unless Content.aaf_configuration[:remote]
+    def test_rebuilds_index
+      remove_index Content
+      idx = ActsAsFerret.get_index_for( Content )
+      i =  ActsAsFerret::MultiIndex.new([idx])
+      assert File.exists?("#{idx.index_definition[:index_dir]}/segments")
+      hits = i.search("description:title")
+      assert_equal 1, hits.total_hits, hits.inspect
+    end
+  end
+
+  def test_find_options
+    contents_from_ferret = ActsAsFerret::find('title', [Content, Comment ], { }, :order => 'id desc')
+    assert_equal 2, contents_from_ferret.size
+    assert contents_from_ferret.first.id > contents_from_ferret.last.id
+    contents_from_ferret = ActsAsFerret::find('title', [Content, Comment ], { }, :order => 'id asc')
+    assert contents_from_ferret.first.id < contents_from_ferret.last.id
+
+    contents_from_ferret = ActsAsFerret::find('title', [Content, Comment], :limit => 1)
+    assert_equal 1, contents_from_ferret.size
+    contents_from_ferret = ActsAsFerret::find('title', [Content, Comment ], { }, :limit => 1)
+    assert_equal 1, contents_from_ferret.size
+
+
+    more_contents(true)
+    r = ActsAsFerret::find('title OR comment', [Content, Comment], { :limit => :all } )
+    assert_equal 60, r.size
+    assert_equal 60, r.total_hits
+
+    id = Content.find_with_ferret('title').first.id
+    r = ActsAsFerret::find('title OR comment', [Content, Comment], { :limit => :all },
+                                                     { :conditions => { :content => ["id != ?", id] }})
+    assert_equal 59, r.size
+    assert_equal 59, r.total_hits
+
+    r = ActsAsFerret::find('title OR comment', [Content, Comment], { :limit => 20 },
+                                                     { :conditions => { :content => ["id != ?", id] }})
+    assert_equal 20, r.size
+    assert_equal 59, r.total_hits
+
+    r = ActsAsFerret::find('title OR comment', [Content, Comment], { :limit => 20 },
+                                                     { :conditions => { :comment => 'content is null',
+                                                                        :content => ["id != ?", id] }})
+    assert_equal 20, r.size
+    assert_equal 29, r.total_hits
+
+    r = ActsAsFerret::find('title OR comment', [Content, Comment ], { },
+                                                     { :conditions => { :content => ["id != ?", id] }, :limit => 20 })
+    assert_equal 20, r.size
+    assert_equal 59, r.total_hits
+  end
+
+  def test_multi_search
+    assert_equal 4, ContentBase.find(:all).size
+    
+    Content.aaf_index.ferret_index.flush
+    contents_from_ferret = ActsAsFerret::find('description:title', [Content])
+    assert_equal 1, contents_from_ferret.size
+    contents_from_ferret = ActsAsFerret::find('title:title OR description:title', [Content])
+    assert_equal 2, contents_from_ferret.size
+    contents_from_ferret = ActsAsFerret::find('title:title', [Content])
+    assert_equal 1, contents_from_ferret.size
+    contents_from_ferret = ActsAsFerret::find('*:title', [Content])
+    assert_equal 2, contents_from_ferret.size
+    contents_from_ferret = ActsAsFerret::find('title', [Content])
+    assert_equal 2, contents_from_ferret.size
+    
+    assert_equal contents(:first).id, contents_from_ferret.first.id
+    assert_equal @another_content.id, contents_from_ferret.last.id
+    
+    contents_from_ferret = ActsAsFerret::find('title', [Content])
+    assert_equal 2, contents_from_ferret.size
+    contents_from_ferret = ActsAsFerret::find('title', [Content], :limit => 1)
+    assert_equal 1, contents_from_ferret.size
+    contents_from_ferret = ActsAsFerret::find('title', [Content], :offset => 1)
+    assert_equal 1, contents_from_ferret.size
+
+    contents_from_ferret = ActsAsFerret::find('title:title OR content:comment OR description:title', [Content, Comment])
+    assert_equal 5, contents_from_ferret.size
+    contents_from_ferret = ActsAsFerret::find('title:title OR content:comment OR description:title', [Content, Comment], :limit => 2)
+    assert_equal 2, contents_from_ferret.size
+
+    contents_from_ferret = ActsAsFerret::find('*:title OR *:comment', [Content, Comment])
+    assert_equal 5, contents_from_ferret.size
+    contents_from_ferret = ActsAsFerret::find('*:title OR *:comment', [Content, Comment])
+    assert_equal 5, contents_from_ferret.size
+    contents_from_ferret = ActsAsFerret::find('title:(title OR comment) OR description:(title OR comment) OR content:(title OR comment)', [Content, Comment])
+    assert_equal 5, contents_from_ferret.size
+  end
+
+  def test_lazy_search
+    contents_from_ferret = ActsAsFerret.find('title', [Content, Comment], :lazy => true)
+    assert_equal 2, contents_from_ferret.size
+    contents_from_ferret.each do |record|
+      assert ActsAsFerret::FerretResult === record, record.inspect
+      assert !record.description.blank?
+      assert_nil record.instance_variable_get(:"@ar_record")
+    end
+  end
+
+  def test_find_ids
+    assert_equal 4, ContentBase.find(:all).size
+    
+    [ 'title:title OR description:title OR content:title', 'title', '*:title'].each do |query|
+      total_hits, contents_from_ferret = ActsAsFerret.find_ids(query, Content)
+      assert_equal 2, contents_from_ferret.size, query
+      assert_equal 2, total_hits, query
+      assert_equal contents(:first).id, contents_from_ferret.first[:id].to_i
+      assert_equal @another_content.id, contents_from_ferret.last[:id].to_i
+    end
+
+    ContentBase.rebuild_index
+    Comment.rebuild_index
+    ['title OR comment', 'title:(title OR comment) OR description:(title OR comment) OR content:(title OR comment)'].each do |query|
+      total_hits, contents_from_ferret = ActsAsFerret.find_ids(query, [Comment, Content])
+      assert_equal 5, contents_from_ferret.size, query
+      assert_equal 5, total_hits
+    end
+  end
+
+  def test_find_ids_lazy
+    total_hits, contents_from_ferret = ActsAsFerret.find_ids('title', [Comment, Content], :lazy => true)
+    assert_equal 2, contents_from_ferret.size
+    assert_equal 2, total_hits
+    found = 0
+    contents_from_ferret.each do |data|
+      next if data[:model] != 'Content'
+      found += 1
+      assert !data[:data][:description].blank?
+    end
+    assert_equal 2, found
+  end
+
+  def test_pagination
+    more_contents(true)
+
+    r = ActsAsFerret.find 'title OR comment', [ Content, Comment ], :per_page => 10, :sort => 'title'
+    assert_equal 60, r.total_hits
+    assert_equal 10, r.size
+    assert_equal "0", r.first.description
+    assert_equal "9", r.last.description
+    assert_equal 1, r.current_page
+    assert_equal 6, r.page_count
+
+    r = ActsAsFerret.find 'title OR comment', [ Content, Comment ], :page => '2', :per_page => 10, :sort => 'title'
+    assert_equal 60, r.total_hits
+    assert_equal 10, r.size
+    assert_equal "10", r.first.description
+    assert_equal "19", r.last.description
+    assert_equal 2, r.current_page
+    assert_equal 6, r.page_count
+
+    r = ActsAsFerret.find 'title OR comment', [ Content, Comment ], :page => 7, :per_page => 10, :sort => 'title'
+    assert_equal 60, r.total_hits
+    assert_equal 0, r.size
+  end
+
+  def test_pagination_with_ar_conditions
+    more_contents(true)
+    id = Content.find_with_ferret('title').first.id
+    r = ActsAsFerret.find 'title OR comment', [Content, Comment], { :page => 1, :per_page => 10 }, 
+                                          { :conditions => { :content => ["id != ?", id] }, :order => 'id ASC' }
+    assert_equal 59, r.total_hits
+    assert_equal 10, r.size
+    assert_equal "Comment for content 00", r.first.content
+    assert_equal "Comment for content 09", r.last.content
+    assert_equal 1, r.current_page
+    assert_equal 6, r.page_count
+
+    r = ActsAsFerret.find 'title OR comment', [Content, Comment], { :page => 6, :per_page => 10 },
+                                          { :conditions => { :content => [ "id != ?", id ] }, :order => 'id ASC' }
+    assert_equal 59, r.total_hits
+    assert_equal 9, r.size
+    assert_equal "21", r.first.description
+    assert_equal "29", r.last.description
+    assert_equal 6, r.current_page
+    assert_equal 6, r.page_count
+  end
+
+  protected
+
+  def more_contents(with_comments = false)
+    Comment.destroy_all if with_comments
+    Content.destroy_all
+    SpecialContent.destroy_all
+    30.times do |i|
+      c = Content.create! :title => sprintf("title of Content %02d", i), :description => "#{i}"
+      c.comments.create! :content => sprintf("Comment for content %02d", i) if with_comments
+    end
+  end
+
+  def remove_index(clazz)
+    clazz.aaf_index.close # avoid io error when deleting the open index
+    FileUtils.rm_rf clazz.aaf_configuration[:index_dir]
+    assert !File.exists?("#{clazz.aaf_configuration[:index_dir]}/segments")
+  end
+
+end
+

data/doc/demo/test/unit/remote_index_test.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class RemoteIndexTest < Test::Unit::TestCase
+  def setup
+    ActsAsFerret::remote = 'druby://localhost:9999'
+  end
+
+  def test_raises_drb_errors
+    ActsAsFerret::raise_drb_errors = true
+    @srv = ActsAsFerret::RemoteIndex.new :name => 'idx'
+    assert_raise DRb::DRbConnError do
+      @srv.find_ids 'some query'
+    end
+  end
+
+  def test_does_not_raise_drb_errors
+    ActsAsFerret::raise_drb_errors = false
+    @srv = ActsAsFerret::RemoteIndex.new :name => 'idx'
+    total_hits, results = @srv.find_ids( 'some query' )
+    assert_equal 0, total_hits
+    assert results.empty?
+  end
+end

data/doc/demo/test/unit/shared_index1_test.rb

@@ -0,0 +1,108 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class SharedIndex1Test < Test::Unit::TestCase
+  fixtures :shared_index1s, :shared_index2s
+
+  def setup
+    SharedIndex1.rebuild_index
+  end
+
+  def test_lazy_loading
+    results = ActsAsFerret::find 'first', 'shared', :lazy => [ :name ]
+    assert_equal 2, results.size
+    found_lazy_result = false
+    results.each { |r|
+      assert ActsAsFerret::FerretResult === r
+      assert !r.name.blank?
+      assert_nil r.instance_variable_get(:@ar_record) # lazy, AR record has not been fetched
+    }
+  end
+  
+  def test_find
+    assert_equal shared_index1s(:first), SharedIndex1.find(1)
+    assert_equal shared_index2s(:first), SharedIndex2.find(1)
+  end
+
+  def test_find_ids_with_ferret
+    result = SharedIndex1.find_ids_with_ferret("first")
+    assert_equal 2, result.size
+  end
+
+  def test_find_with_ferret_one_class
+    result = SharedIndex1.find_with_ferret("first")
+    assert_equal 1, result.size, result.inspect
+    assert_equal shared_index1s(:first), result.first
+  end
+
+  def test_custom_query
+    result = SharedIndex1.find_with_ferret("name:first class_name:SharedIndex1")
+    assert_equal 1, result.size
+    assert_equal shared_index1s(:first), result.first
+  end
+
+  def test_find_with_index_name
+    result = ActsAsFerret::find("first", 'shared')
+    assert_equal 2, result.size
+    assert result.include?(shared_index1s(:first))
+    assert result.include?(shared_index2s(:first))
+  end
+
+  def test_find_with_class_list
+    result = ActsAsFerret::find("name:first", [SharedIndex1, SharedIndex2])
+    assert_equal 2, result.size
+    assert result.include?(shared_index1s(:first))
+    assert result.include?(shared_index2s(:first))
+  end
+
+  def test_query_for_record
+    assert_match /SharedIndex1/, shared_index1s(:first).query_for_record.to_s
+  end
+
+  def test_destroy
+    result = ActsAsFerret::find("first OR another", 'shared')
+    assert_equal 4, result.size
+    SharedIndex1.destroy(shared_index1s(:first))
+    result = ActsAsFerret::find("first OR another", 'shared')
+    assert_equal 3, result.size
+    shared_index2s(:first).destroy
+    result = ActsAsFerret::find("first OR another", 'shared')
+    assert_equal 2, result.size
+  end
+
+  def test_ferret_destroy
+    SharedIndex1.rebuild_index
+    result = SharedIndex1.find_ids_with_ferret("first OR another", :models => :all)
+    assert_equal 4, result.first
+    shared_index1s(:first).ferret_destroy
+    result = SharedIndex1.find_ids_with_ferret("first OR another", :models => :all)
+    assert_equal 3, result.first
+  end
+
+  def test_ferret_destroy_ticket_88
+    SharedIndex1.rebuild_index
+    result = SharedIndex1.find_ids_with_ferret("first OR another", :models => :all)
+    assert_equal 4, result.first
+    result = SharedIndex2.find_ids_with_ferret("first OR another", :models => :all)
+    assert_equal 4, result.first
+    SharedIndex1.destroy(shared_index1s(:first))
+    result = SharedIndex1.find_ids_with_ferret("first OR another", :models => :all)
+    assert_equal 3, result.first
+    result = SharedIndex2.find_ids_with_ferret("first OR another", :models => :all)
+    assert_equal 3, result.first
+    shared_index2s(:first).destroy
+    result = SharedIndex1.find_ids_with_ferret("first OR another", :models => :all)
+    assert_equal 2, result.first
+    result = SharedIndex2.find_ids_with_ferret("first OR another", :models => :all)
+    assert_equal 2, result.first
+  end
+
+  def test_update
+    assert SharedIndex1.find_with_ferret("new").empty?
+    shared_index1s(:first).name = "new name"
+    shared_index1s(:first).save
+    assert_equal 1, SharedIndex1.find_with_ferret("new").size
+    assert_equal 1, SharedIndex1.find_with_ferret("new").size
+    assert_equal 1, SharedIndex1.find_with_ferret("new", :models => [SharedIndex2]).size
+    assert_equal 0, SharedIndex2.find_with_ferret("new").size
+  end
+end