tire 0.3.3 → 0.3.4

data/test/integration/mongoid_searchable_test.rb

@@ -0,0 +1,308 @@
+require 'test_helper'
+
+begin
+  require "mongo"
+  Mongo::Connection.new("localhost", 27017)
+
+  ENV["MONGODB_IS_AVAILABLE"] = 'true'
+rescue Mongo::ConnectionFailure => e
+  ENV["MONGODB_IS_AVAILABLE"] = nil
+end
+
+if ENV["MONGODB_IS_AVAILABLE"]
+  module Tire
+
+    class MongoidSearchableIntegrationTest < Test::Unit::TestCase
+      include Test::Integration
+
+      def setup
+        super
+        Mongoid.configure do |config|
+          config.master = Mongo::Connection.new.db("tire_mongoid_integration_test")
+        end
+      end
+
+      context "Mongoid integration" do
+
+        setup    do
+          MongoidArticle.destroy_all
+          Tire.index('mongoid_articles').delete
+
+          load File.expand_path('../../models/mongoid_models.rb', __FILE__)
+        end
+        teardown do
+          MongoidArticle.destroy_all
+          Tire.index('mongoid_articles').delete
+        end
+
+        should "configure mapping" do
+          assert_equal 'snowball', MongoidArticle.mapping[:title][:analyzer]
+          assert_equal 10, MongoidArticle.mapping[:title][:boost]
+
+          assert_equal 'snowball', MongoidArticle.tire.index.mapping['mongoid_article']['properties']['title']['analyzer']
+        end
+
+        should "save document into index on save and find it" do
+          a = MongoidArticle.new :title => 'Test'
+          a.save!
+          id = a.id
+
+          a.index.refresh
+
+          results = MongoidArticle.tire.search 'test'
+
+          assert       results.any?
+          assert_equal 1, results.count
+
+          assert_instance_of Results::Item, results.first
+          assert_not_nil results.first.id
+          assert_equal   id.to_s, results.first.id.to_s
+          assert         results.first.persisted?, "Record should be persisted"
+          assert_not_nil results.first._score
+          assert_equal   'Test', results.first.title
+        end
+
+        context "with eager loading" do
+          setup do
+            MongoidArticle.destroy_all
+
+            @first_article  = MongoidArticle.create! :title => "Test 1"
+            @second_article = MongoidArticle.create! :title => "Test 2"
+            @third_article  = MongoidArticle.create! :title => "Test 3"
+            @fourth_article = MongoidArticle.create! :title => "Test 4"
+            @fifth_article  = MongoidArticle.create! :title => "Test 5"
+
+            MongoidArticle.tire.index.refresh
+          end
+
+          should "load records on query search" do
+            results = MongoidArticle.tire.search '"Test 1"', :load => true
+
+            assert       results.any?
+            assert_equal MongoidArticle.all.first, results.first
+          end
+
+          should "load records on block search" do
+            results = MongoidArticle.tire.search :load => true do
+              query { string '"Test 1"' }
+            end
+
+            assert_equal MongoidArticle.all.first, results.first
+          end
+
+          should "load records with options on query search" do
+            assert_equal MongoidArticle.find([@first_article[:_id]], :include => 'comments').first,
+            MongoidArticle.tire.search('"Test 1"',
+                                  :load => { :include => 'comments' }).results.first
+          end
+
+          should "return empty collection for nonmatching query" do
+            assert_nothing_raised do
+              results = MongoidArticle.tire.search :load => true do
+                query { string '"Hic Sunt Leones"' }
+              end
+              assert_equal 0, results.size
+              assert !results.any?
+            end
+          end
+        end
+
+        should "remove document from index on destroy" do
+          a = MongoidArticle.new :title => 'Test remove...'
+          a.save!
+          assert_equal 1, MongoidArticle.count
+
+          a.destroy
+          assert_equal 0, MongoidArticle.all.size
+
+          a.index.refresh
+          results = MongoidArticle.tire.search 'test'
+          assert_equal 0, results.count
+        end
+
+        should "return documents with scores" do
+          MongoidArticle.create! :title => 'foo'
+          MongoidArticle.create! :title => 'bar'
+
+          MongoidArticle.tire.index.refresh
+          results = MongoidArticle.tire.search 'foo OR bar^100'
+          assert_equal 2, results.count
+
+          assert_equal 'bar', results.first.title
+        end
+
+        context "with pagination" do
+          setup do
+            1.upto(9) { |number| MongoidArticle.create :title => "Test#{number}" }
+            MongoidArticle.tire.index.refresh
+          end
+
+          context "and parameter searches" do
+
+            should "find first page with five results" do
+              results = MongoidArticle.tire.search 'test*', :sort => 'title', :per_page => 5, :page => 1
+              assert_equal 5, results.size
+
+              assert_equal 2, results.total_pages
+              assert_equal 1, results.current_page
+              assert_equal nil, results.previous_page
+              assert_equal 2, results.next_page
+
+              assert_equal 'Test1', results.first.title
+            end
+
+            should "find next page with five results" do
+              results = MongoidArticle.tire.search 'test*', :sort => 'title', :per_page => 5, :page => 2
+              assert_equal 4, results.size
+
+              assert_equal 2, results.total_pages
+              assert_equal 2, results.current_page
+              assert_equal 1, results.previous_page
+              assert_equal nil, results.next_page
+
+              assert_equal 'Test6', results.first.title
+            end
+
+            should "find not find missing page" do
+              results = MongoidArticle.tire.search 'test*', :sort => 'title', :per_page => 5, :page => 3
+              assert_equal 0, results.size
+
+              assert_equal 2, results.total_pages
+              assert_equal 3, results.current_page
+              assert_equal 2, results.previous_page
+              assert_equal nil, results.next_page
+
+              assert_nil results.first
+            end
+
+          end
+
+          context "and block searches" do
+            setup { @q = 'test*' }
+
+            should "find first page with five results" do
+              results = MongoidArticle.tire.search do |search|
+                search.query { |query| query.string @q }
+                search.sort  { by :title }
+                search.from 0
+                search.size 5
+              end
+              assert_equal 5, results.size
+
+              assert_equal 2, results.total_pages
+              assert_equal 1, results.current_page
+              assert_equal nil, results.previous_page
+              assert_equal 2, results.next_page
+
+              assert_equal 'Test1', results.first.title
+            end
+
+            should "find next page with five results" do
+              results = MongoidArticle.tire.search do |search|
+                search.query { |query| query.string @q }
+                search.sort  { by :title }
+                search.from 5
+                search.size 5
+              end
+              assert_equal 4, results.size
+
+              assert_equal 2, results.total_pages
+              assert_equal 2, results.current_page
+              assert_equal 1, results.previous_page
+              assert_equal nil, results.next_page
+
+              assert_equal 'Test6', results.first.title
+            end
+
+            should "not find a missing page" do
+              results = MongoidArticle.tire.search do |search|
+                search.query { |query| query.string @q }
+                search.sort  { by :title }
+                search.from 10
+                search.size 5
+              end
+              assert_equal 0, results.size
+
+              assert_equal 2, results.total_pages
+              assert_equal 3, results.current_page
+              assert_equal 2, results.previous_page
+              assert_equal nil, results.next_page
+
+              assert_nil results.first
+            end
+
+          end
+
+        end
+
+        context "with proxy" do
+
+          should "allow access to Tire instance methods" do
+            a = MongoidClassWithTireMethods.create :title => 'One'
+            assert_equal "THIS IS MY INDEX!", a.index
+            assert_instance_of Tire::Index, a.tire.index
+            assert a.tire.index.exists?, "Index should exist"
+          end
+
+          should "allow access to Tire class methods" do
+            class ::MongoidClassWithTireMethods
+              include Mongoid::Document
+              def self.search(*)
+                "THIS IS MY SEARCH!"
+              end
+            end
+
+            MongoidClassWithTireMethods.create :title => 'One'
+            MongoidClassWithTireMethods.tire.index.refresh
+
+            assert_equal "THIS IS MY SEARCH!", MongoidClassWithTireMethods.search
+
+            results = MongoidClassWithTireMethods.tire.search 'one'
+
+            assert_equal 'One', results.first.title
+          end
+
+        end
+
+        context "within Rails" do
+
+          setup do
+            module ::Rails; end
+
+            a = MongoidArticle.new :title => 'Test'
+            c = a.comments.build :author => 'fool', :body => 'Works!'
+            s = a.stats.build    :pageviews  => 12, :period => '2011-08'
+            a.save!
+            c.save!
+            s.save!
+            @id = a.id.to_s
+
+            a.index.refresh
+            @item = MongoidArticle.tire.search('test').first
+          end
+
+          should "have access to indexed properties" do
+            assert_equal 'Test', @item.title
+            assert_equal 'fool', @item.comments.first.author
+            assert_equal 12,     @item.stats.first.pageviews
+          end
+
+          should "load the underlying models" do
+            assert_instance_of Results::Item, @item
+            assert_instance_of MongoidArticle, @item.load
+            assert_equal      'Test', @item.load.title
+
+            assert_instance_of Results::Item, @item.comments.first
+            assert_instance_of MongoidComment, @item.comments.first.load
+            assert_equal      'fool', @item.comments.first.load.author
+          end
+
+          should "load the underlying model with options" do
+            assert_equal MongoidArticle.find(@id), @item.load(:include => 'comments')
+          end
+
+        end
+      end
+    end
+  end
+end

data/test/integration/persistent_model_test.rb

@@ -26,7 +26,7 @@ module Tire
         results = PersistentArticle.find [1, 2]
 
         assert_equal 2, results.size
-        
+
       end
 
       context "with pagination" do
@@ -40,10 +40,19 @@ module Tire
           results = PersistentArticle.search( :per_page => 5, :page => 1 ) { query { all } }
           assert_equal 5, results.size
 
+          # WillPaginate
+          #
           assert_equal 2, results.total_pages
           assert_equal 1, results.current_page
           assert_equal nil, results.previous_page
           assert_equal 2, results.next_page
+
+          # Kaminari
+          #
+          assert_equal 5, results.limit_value
+          assert_equal 9, results.total_count
+          assert_equal 2, results.num_pages
+          assert_equal 0, results.offset_value
         end
       end
 

data/test/models/active_record_models.rb

@@ -5,14 +5,6 @@ class ActiveRecordArticle < ActiveRecord::Base
   has_many :comments, :class_name => "ActiveRecordComment", :foreign_key => "article_id"
   has_many :stats,    :class_name => "ActiveRecordStat",    :foreign_key => "article_id"
 
-  # def index
-  #   "KEEP OFF MY INDEX!!!"
-  # end
-  #
-  # def self.settings
-  #   "KEEP OFF MY SETTINGS!!!"
-  # end
-
   include Tire::Model::Search
   include Tire::Model::Callbacks
 
@@ -28,10 +20,6 @@ class ActiveRecordArticle < ActiveRecord::Base
     end
   end
 
-  # tire.mapping do
-  #   indexes :title,      :type => 'string', :boost => 10, :analyzer => 'snowball'
-  # end
-
   def to_indexed_json
     {
       :title        => title,
@@ -81,3 +69,12 @@ class ActiveRecordClassWithTireMethods < ActiveRecord::Base
     end
   end
 end
+
+class ActiveRecordClassWithDynamicIndexName < ActiveRecord::Base
+  include Tire::Model::Search
+  include Tire::Model::Callbacks
+
+  index_name do
+    "dynamic" + '_' + "index"
+  end
+end

data/test/models/mongoid_models.rb

@@ -0,0 +1,98 @@
+require 'rubygems'
+require 'mongoid'
+
+class MongoidArticle
+
+  include Mongoid::Document
+
+
+  has_many :comments, :class_name => "MongoidComment", :foreign_key => "article_id"
+  has_many :stats,    :class_name => "MongoidStat",    :foreign_key => "article_id"
+
+  # def index
+  #   "KEEP OFF MY INDEX!!!"
+  # end
+  #
+  # def self.settings
+  #   "KEEP OFF MY SETTINGS!!!"
+  # end
+
+  include Tire::Model::Search
+  include Tire::Model::Callbacks
+
+  tire do
+    mapping do
+      indexes :title,      :type => 'string', :boost => 10, :analyzer => 'snowball'
+      indexes :created_at, :type => 'date'
+
+      indexes :comments do
+        indexes :author
+        indexes :body
+      end
+    end
+  end
+
+  # tire.mapping do
+  #   indexes :title,      :type => 'string', :boost => 10, :analyzer => 'snowball'
+  # end
+
+  def to_indexed_json
+    {
+      :title        => title,
+      :length       => length,
+
+      :comments     => comments.map { |c| { :_type  => 'mongoid_comment',
+                                            :_id    => c.id,
+                                            :author => c.author,
+                                            :body   => c.body  } },
+      :stats        => stats.map    { |s| { :pageviews  => s.pageviews } }
+    }.to_json
+  end
+
+  def length
+    title.length
+  end
+
+  def comment_authors
+    comments.map(&:author).to_sentence
+  end
+end
+
+class MongoidComment
+
+  include Mongoid::Document
+
+
+  belongs_to :article, :class_name => "MongoidArticle", :foreign_key => "article_id"
+end
+
+class MongoidStat
+
+  include Mongoid::Document
+
+
+  belongs_to :article, :class_name => "MongoidArticle", :foreign_key => "article_id"
+end
+
+class MongoidClassWithTireMethods
+
+  include Mongoid::Document
+
+
+  def self.mapping
+    "THIS IS MY MAPPING!"
+  end
+
+  def index
+    "THIS IS MY INDEX!"
+  end
+
+  include Tire::Model::Search
+  include Tire::Model::Callbacks
+
+  tire do
+    mapping do
+      indexes :title, :type => 'string', :analyzer => 'snowball'
+    end
+  end
+end

data/test/unit/http_client_test.rb

@@ -19,6 +19,13 @@ module Tire
           assert_respond_to Client::RestClient, :head
         end
 
+        should "not rescue generic exceptions" do
+          Client::RestClient.expects(:get).raises(RuntimeError, "Something bad happened in YOUR code")
+          assert_raise(RuntimeError) do
+            Client::RestClient.get 'http://example.com'
+          end
+        end
+
       end
 
     end

data/test/unit/model_callbacks_test.rb

@@ -1,7 +1,7 @@
 require 'test_helper'
 
 class ModelOne
-  extend ActiveModel::Naming
+  extend  ActiveModel::Naming
   include Tire::Model::Search
   include Tire::Model::Callbacks
 
@@ -11,38 +11,40 @@ end
 
 class ModelTwo
   extend ActiveModel::Naming
-  extend  ActiveModel::Callbacks
+  extend ActiveModel::Callbacks
   define_model_callbacks :save, :destroy
 
   include Tire::Model::Search
   include Tire::Model::Callbacks
 
-  def save
-    _run_save_callbacks {}
-  end
-
-  def destroy
-    _run_destroy_callbacks { @destroyed = true }
-  end
+  def save;    _run_save_callbacks {};                       end
+  def destroy; _run_destroy_callbacks { @destroyed = true }; end
 
   def destroyed?; !!@destroyed; end
 end
 
 class ModelThree
   extend ActiveModel::Naming
-  extend  ActiveModel::Callbacks
+  extend ActiveModel::Callbacks
   define_model_callbacks :save, :destroy
 
   include Tire::Model::Search
   include Tire::Model::Callbacks
 
-  def save
-    _run_save_callbacks {}
-  end
+  def save;    _run_save_callbacks {};    end
+  def destroy; _run_destroy_callbacks {}; end
+end
 
-  def destroy
-    _run_destroy_callbacks {}
-  end
+class ModelWithoutTireAutoCallbacks
+  extend ActiveModel::Naming
+  extend ActiveModel::Callbacks
+  define_model_callbacks :save, :destroy
+
+  include Tire::Model::Search
+  # DO NOT include Callbacks
+
+  def save;    _run_save_callbacks {};    end
+  def destroy; _run_destroy_callbacks {}; end
 end
 
 module Tire
@@ -90,6 +92,24 @@ module Tire
 
       end
 
+      context "Model without Tire::Callbacks included" do
+
+        should "respond to Tire update_index callbacks" do
+          assert_respond_to ModelWithoutTireAutoCallbacks, :after_update_elasticsearch_index
+          assert_respond_to ModelWithoutTireAutoCallbacks, :before_update_elasticsearch_index
+        end
+
+        should "not execute the update_index hooks" do
+          m = ModelWithoutTireAutoCallbacks.new
+          m.tire.expects(:update_index).never
+
+          m.save
+          m.destroy
+        end
+      end
+
+      # ---------------------------------------------------------------------------
+
     end
 
   end

data/test/unit/model_search_test.rb

@@ -287,6 +287,26 @@ module Tire
             assert_equal 'snowball', ModelWithCustomMapping.mapping[:title][:analyzer]
           end
 
+          should "not raise an error when defining mapping" do
+            Tire::Index.any_instance.unstub(:exists?)
+            Configuration.client.expects(:head).raises(Errno::ECONNREFUSED)
+
+            assert_nothing_raised do
+              class ::ModelWithCustomMapping
+                extend ActiveModel::Naming
+                extend ActiveModel::Callbacks
+
+                include Tire::Model::Search
+                include Tire::Model::Callbacks
+
+                mapping do
+                  indexes :title, :type => 'string', :analyzer => 'snowball', :boost => 10
+                end
+
+              end
+            end
+          end
+
           should "define mapping for nested properties with a block" do
             expected = {
               :settings => {},
@@ -695,6 +715,29 @@ module Tire
 
         end
 
+        context "with dynamic index name" do
+          class ::ModelWithDynamicIndexName
+            extend ActiveModel::Naming
+            extend ActiveModel::Callbacks
+
+            include Tire::Model::Search
+            include Tire::Model::Callbacks
+
+            index_name do
+              "dynamic" + '_' + "index"
+            end
+          end
+
+          should "have index name as a proc" do
+            assert_kind_of Proc, ::ModelWithDynamicIndexName.index_name
+          end
+
+          should "evaluate the proc in Model.index" do
+            assert_equal 'dynamic_index', ::ModelWithDynamicIndexName.index.name
+          end
+
+        end
+
       end
 
       context "Results::Item" do

data/test/unit/results_collection_test.rb

@@ -57,6 +57,13 @@ module Tire
         end
       end
 
+      should "be kaminari compatible" do
+        collection = Results::Collection.new(@default_response)
+        %w(limit_value total_count num_pages offset_value).each do |method|
+          assert_respond_to collection, method
+        end
+      end
+
       context "wrapping results" do
 
         setup do

data/test/unit/search_test.rb

@@ -117,7 +117,9 @@ module Tire
         STDERR.expects(:puts)
 
         s = Search::Search.new('index')
-        assert ! s.perform
+        assert_raise Search::SearchRequestFailed do
+          s.perform
+        end
       end
 
       should "log request, but not response, when logger is set" do

data/tire.gemspec

@@ -38,6 +38,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency "shoulda"
   s.add_development_dependency "mocha"
   s.add_development_dependency "activerecord", "~> 3.0.7"
+  s.add_development_dependency "mongoid",      "~> 2.2.1"
   s.add_development_dependency "sqlite3"
   s.add_development_dependency "supermodel"