load_balanced_tire 0.1

data/test/integration/index_update_document_test.rb

@@ -0,0 +1,111 @@
+require 'test_helper'
+
+module Tire
+
+  class IndexUpdateDocumentIntegrationTest < Test::Unit::TestCase
+    include Test::Integration
+
+    context "Updating a document" do
+
+      setup do
+        Tire.index 'articles-with-tags' do
+          delete
+          create
+
+          store :type => 'article', :id => 1, :title => 'One',   :tags => ['foo'],        :views => 0
+          store :type => 'article', :id => 2, :title => 'Two',   :tags => ['foo', 'bar'], :views => 10
+          store :type => 'article', :id => 3, :title => 'Three', :tags => ['foobar']
+
+          refresh
+        end
+      end
+
+      teardown { Tire.index('articles-with-tags').delete }
+
+      should "increment a counter" do
+        Tire.index('articles-with-tags') { update( 'article', '1', :script => "ctx._source.views += 1" ) and refresh }
+
+        document = Tire.search('articles-with-tags') { query { string 'title:one' } }.results.first
+        assert_equal 1, document.views, document.inspect
+
+        Tire.index('articles-with-tags') { update( 'article', '2', :script => "ctx._source.views += 1" ) and refresh }
+
+        document = Tire.search('articles-with-tags') { query { string 'title:two' } }.results.first
+        assert_equal 11, document.views, document.inspect
+      end
+
+      should "add a tag to document" do
+        Tire.index('articles-with-tags') do
+          update 'article', '1', :script => "ctx._source.tags += tag",
+                                 :params => { :tag => 'new' }
+          refresh
+        end
+
+        document = Tire.search('articles-with-tags') { query { string 'title:one' } }.results.first
+        assert_equal ['foo', 'new'], document.tags, document.inspect
+      end
+
+      should "remove a tag from document" do
+        Tire.index('articles-with-tags') do
+          update 'article', '1', :script => "ctx._source.tags = tags",
+                                 :params => { :tags => [] }
+          refresh
+        end
+
+        document = Tire.index('articles-with-tags').retrieve 'article', '1'
+        assert_equal [], document.tags, document.inspect
+      end
+
+      should "remove the entire document if specific condition is met" do
+        Tire.index('articles-with-tags') do
+          # Remove document when it contains tag 'foobar'
+          update 'article', '3', :script => "ctx._source.tags.contains(tag) ? ctx.op = 'delete' : 'none'",
+                                 :params => { :tag => 'foobar' }
+          refresh
+        end
+
+        assert_nil Tire.index('articles-with-tags').retrieve 'article', '3'
+      end
+
+      should "pass the operation parameters to the API" do
+        Tire.index('articles-with-tags').update 'article', '2', { :script => "ctx._source.tags += tag",
+                                                                  :params => { :tag => 'new' }
+                                                                },
+                                                                {
+                                                                  :refresh => true
+                                                                }
+
+        document = Tire.search('articles-with-tags') { query { string 'title:two' } }.results.first
+        assert_equal 3, document.tags.size, document.inspect
+      end
+
+      should "access variables from the outer scope" do
+        $t = self
+
+        class Updater
+          @tags = ['foo', 'bar', 'baz']
+
+          def self.perform_update!
+            $t.assert_not_nil @tags
+
+            Tire.index('articles-with-tags') do |index|
+              $t.assert_not_nil @tags
+
+              index.update 'article', '3', :script => "ctx._source.tags = tags",
+                                     :params => { :tags => @tags }
+              index.refresh
+            end
+          end
+        end
+
+        Updater.perform_update!
+
+        document = Tire.search('articles-with-tags') { query { string 'title:three' } }.results.first
+        assert_equal 3, document.tags.size, document.inspect
+      end
+
+    end
+
+  end
+
+end

data/test/integration/mongoid_searchable_test.rb

@@ -0,0 +1,309 @@
+require 'test_helper'
+require File.expand_path('../../models/mongoid_models', __FILE__)
+
+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/percolator_test.rb

@@ -0,0 +1,111 @@
+require 'test_helper'
+
+module Tire
+
+  class PercolatorIntegrationTest < Test::Unit::TestCase
+    include Test::Integration
+
+    context "Percolator" do
+      setup do
+        delete_registered_queries
+        @index = Tire.index('percolator-test')
+        @index.create
+      end
+      teardown do
+        delete_registered_queries
+        @index.delete
+      end
+
+      context "when registering a query" do
+        should "register query as a Hash" do
+          query = { :query => { :query_string => { :query => 'warning' } } }
+          assert @index.register_percolator_query('alert', query)
+          Tire.index('_percolator').refresh
+
+          percolator = Configuration.client.get("#{Configuration.url}/_percolator/percolator-test/alert")
+          assert percolator
+        end
+
+        should "register query as block" do
+          assert @index.register_percolator_query('alert') { string 'warning' }
+          Tire.index('_percolator').refresh
+
+          percolator = Configuration.client.get("#{Configuration.url}/_percolator/percolator-test/alert")
+          assert percolator
+        end
+
+        should "unregister a query" do
+          query = { :query => { :query_string => { :query => 'warning' } } }
+          assert @index.register_percolator_query('alert', query)
+          Tire.index('_percolator').refresh
+          assert Configuration.client.get("#{Configuration.url}/_percolator/percolator-test/alert")
+
+          assert @index.unregister_percolator_query('alert')
+          Tire.index('_percolator').refresh
+
+          assert Configuration.client.get("#{Configuration.url}/_percolator/percolator-test/alert").failure?
+        end
+
+      end
+
+      context "when percolating a document" do
+        setup do
+          @index.register_percolator_query('alert') { string 'warning' }
+          @index.register_percolator_query('gantz') { string '"y u no match"' }
+          @index.register_percolator_query('weather', :tags => ['weather']) { string 'severe' }
+          Tire.index('_percolator').refresh
+        end
+
+        should "return an empty array when no query matches" do
+          matches = @index.percolate :message => 'Situation normal'
+          assert_equal [], matches
+        end
+
+        should "return an array of matching query names" do
+          matches = @index.percolate :message => 'Severe weather warning'
+          assert_equal ['alert','weather'], matches.sort
+        end
+
+        should "return an array of matching query names for specific percolated queries" do
+          matches = @index.percolate(:message => 'Severe weather warning') { term :tags, 'weather' }
+          assert_equal ['weather'], matches
+        end
+      end
+
+      context "when storing document and percolating it" do
+        setup do
+          @index.register_percolator_query('alert') { string 'warning' }
+          @index.register_percolator_query('gantz') { string '"y u no match"' }
+          @index.register_percolator_query('weather', :tags => ['weather']) { string 'severe' }
+          Tire.index('_percolator').refresh
+        end
+
+        should "return an empty array when no query matches" do
+          response = @index.store( {:message => 'Situation normal'}, {:percolate => true} )
+          assert_equal [], response['matches']
+        end
+
+        should "return an array of matching query names" do
+          response = @index.store( {:message => 'Severe weather warning'}, {:percolate => true} )
+          assert_equal ['alert','weather'], response['matches'].sort
+        end
+
+        should "return an array of matching query names for specific percolated queries" do
+          response = @index.store( {:message => 'Severe weather warning'}, {:percolate => 'tags:weather'} )
+          assert_equal ['weather'], response['matches']
+        end
+      end
+
+    end
+
+    private
+
+    def delete_registered_queries
+      Configuration.client.get("#{Configuration.url}/_percolator/percolator-test/alert") rescue nil
+      Configuration.client.get("#{Configuration.url}/_percolator/percolator-test/gantz") rescue nil
+      Configuration.client.get("#{Configuration.url}/_percolator/percolator-test/weather") rescue nil
+    end
+
+  end
+
+end