tire 0.5.4 → 0.5.5

data/test/integration/active_record_searchable_test.rb

@@ -32,6 +32,10 @@ module Tire
         create_table :active_record_class_with_dynamic_index_names do |t|
           t.string     :title
         end
+        create_table :active_record_model_with_percolations do |t|
+          t.string   :title
+          t.datetime :created_at, :default => 'NOW()'
+        end
       end
     end
 
@@ -158,6 +162,16 @@ module Tire
             assert hit['_score'] > 0
           end
         end
+
+        should "provide access to highlighted fields in hit" do
+          results = ActiveRecordArticle.search :load => true do
+            query { string '"Test 1" OR "Test 2"' }
+            highlight :title
+          end
+          results.each_with_hit do |result, hit|
+            assert_equal 1, hit['highlight']['title'].size
+          end
+        end
       end
 
       context "with pagination" do
@@ -295,6 +309,16 @@ module Tire
               assert_nil results.first
             end
 
+            should "find second page with four loaded models" do
+              results = ActiveRecordArticle.search :load => true, :page => 2, :per_page => 5 do |search|
+                search.query { |query| query.string @q }
+                search.sort  { by :title }
+              end
+              assert_equal 4, results.size
+              assert results.all? { |r| assert_instance_of ActiveRecordArticle, r }
+              assert_equal 'Test6', results.first.title
+            end
+
           end
 
           context "with from/size" do
@@ -571,6 +595,24 @@ module Tire
         end
 
       end
+
+      context "percolated search" do
+        setup do
+          ActiveRecordModelWithPercolation.index.register_percolator_query('alert') { string 'warning' }
+          Tire.index('_percolator').refresh
+        end
+
+        should "return matching queries when percolating" do
+          a = ActiveRecordModelWithPercolation.new :title => 'Warning!'
+          assert_contains a.percolate, 'alert'
+        end
+
+        should "return matching queries when saving" do
+          a = ActiveRecordModelWithPercolation.create! :title => 'Warning!'
+          assert_contains a.matches, 'alert'
+        end
+      end
+
     end
 
   end

data/test/integration/dis_max_queries_test.rb

@@ -22,7 +22,7 @@ module Tire
         Tire.index('dis_max_test').delete
       end
 
-      should "boost matches in both fields" do
+      should_eventually "boost matches in both fields" do
         dis_max = Tire.search 'dis_max_test' do
           query do
             dis_max do

data/test/integration/dsl_search_test.rb

@@ -13,6 +13,15 @@ module Tire
 
         assert_equal 2, s.results.count
         assert_equal 2, s.results.facets['tags']['count']
+        assert_match /_search\?pretty' -d '{/, s.to_curl, 'Make sure to ignore payload in URL params'
+      end
+
+      should "allow passing URL parameters" do
+        s = Tire.search 'articles-test', search_type: 'count', query: { match: { tags: 'ruby' } }
+
+        assert_equal 0, s.results.count
+        assert_equal 2, s.results.total
+        assert_match /_search.*search_type=count.*' -d '{/, s.to_curl
       end
 
       should "allow building search query iteratively" do

data/test/integration/index_mapping_test.rb

@@ -8,7 +8,7 @@ module Tire
     context "Default mapping" do
       teardown { Tire.index('mapped-index').delete; sleep 0.1 }
 
-      should "create and return the default mapping" do
+      should "create and return the default mapping as a Hash" do
 
         index = Tire.index 'mapped-index' do
           create
@@ -24,17 +24,92 @@ module Tire
 
     context "Creating index with mapping" do
       teardown { Tire.index('mapped-index').delete; sleep 0.1 }
-    
+
       should "create the specified mapping" do
-    
         index = Tire.index 'mapped-index' do
-          create :mappings => { :article => { :properties => { :title => { :type => 'string', :boost => 2.0, :store => 'yes' } } } }
+          create mappings: {
+            article: {
+              _all: { enabled: false },
+              properties: {
+                title: { type: 'string', boost: 2.0, store: 'yes' }
+              }
+            }
+          }
         end
 
-        # p index.mapping    
+        # p index.mapping
+        assert_equal false, index.mapping['article']['_all']['enabled'],               index.mapping.inspect
         assert_equal 2.0,   index.mapping['article']['properties']['title']['boost'],  index.mapping.inspect
-        assert_equal 'yes', index.mapping['article']['properties']['title']['store'],  index.mapping.inspect
-    
+      end
+    end
+
+    context "Update mapping" do
+      setup    { Tire.index("mapped-index").create; sleep 1   }
+      teardown { Tire.index("mapped-index").delete; sleep 0.1 }
+
+      should "update the mapping for type" do
+        index = Tire.index("mapped-index")
+
+        index.mapping "article", :properties => { :body => { :type => "string" } }
+        assert_equal({ "type" => "string" }, index.mapping["article"]["properties"]["body"])
+
+        assert index.mapping("article", :properties => { :title => { :type => "string" } })
+
+        mapping = index.mapping
+
+        # Verify return value
+        assert mapping, index.response.inspect
+
+        # Verify response
+        assert_equal( { "type" => "string" }, mapping["article"]["properties"]["body"] )
+        assert_equal( { "type" => "string" }, mapping["article"]["properties"]["title"] )
+      end
+
+      should "fail to update the mapping in an incompatible way" do
+        index = Tire.index("mapped-index")
+
+        # 1. Update initial index mapping
+        assert index.mapping "article", properties: { body: { type: "string" } }
+        assert_equal( { "type" => "string" }, index.mapping["article"]["properties"]["body"] )
+
+        # 2. Attempt to update the mapping in incompatible way (change property type)
+        mapping = index.mapping "article", :properties => { :body => { :type => "integer" } }
+
+        # Verify return value
+        assert !mapping, index.response.inspect
+        #
+        # Verify response
+        assert_match /MergeMappingException/, index.response.body
+      end
+
+      should "honor the `ignore_conflicts` option" do
+        index = Tire.index("mapped-index")
+
+        # 1. Update initial index mapping
+        assert index.mapping "article", properties: { body: { type: "string" } }
+        assert_equal( { "type" => "string" }, index.mapping["article"]["properties"]["body"] )
+
+        # 2. Attempt to update the mapping in incompatible way and ignore conflicts
+        mapping = index.mapping "article", ignore_conflicts: true, properties: { body: { type: "integer" } }
+
+        # Verify return value (true since we ignore conflicts)
+        assert mapping, index.response.inspect
+      end
+
+    end
+
+    context "Delete mapping" do
+      setup    { Tire.index("mapped-index").create; sleep 1   }
+      teardown { Tire.index("mapped-index").delete; sleep 0.1 }
+
+      should "delete the mapping for type" do
+        index = Tire.index("mapped-index")
+
+        # 1. Update initial index mapping
+        assert index.mapping 'article', properties: { body: { type: "string" } }
+
+        assert index.delete_mapping 'article'
+        assert index.mapping.empty?, index.response.inspect
       end
     end
 

data/test/integration/persistent_model_test.rb

@@ -182,6 +182,23 @@ module Tire
         end
       end
 
+      context "percolated search" do
+        setup do
+          PersistentArticleWithPercolation.index.register_percolator_query('alert') { string 'warning' }
+          Tire.index('_percolator').refresh
+        end
+
+        should "return matching queries when percolating" do
+          a = PersistentArticleWithPercolation.new :title => 'Warning!'
+          assert_contains a.percolate, 'alert'
+        end
+
+        should "return matching queries when saving" do
+          a = PersistentArticleWithPercolation.create :title => 'Warning!'
+          assert_contains a.matches, 'alert'
+        end
+      end
+
     end
 
   end

data/test/integration/sort_test.rb

@@ -29,6 +29,22 @@ module Tire
         assert_equal 'Two', s.results.first[:title]
       end
 
+      should "sort by multiple fields" do
+        q = '*'
+        s = Tire.search('articles-test') do
+          query { string q }
+          sort  do
+            by :words, :desc
+            by :title, :asc
+          end
+        end
+
+        # p s.results.to_a.map { |i| [i.title, i.sort] }
+        assert_equal 'Three', s.results[0][:title]
+        assert_equal 'Four',  s.results[1][:title]
+        assert_equal 'Two',   s.results[2][:title]
+      end
+
     end
 
   end

data/test/models/active_record_models.rb

@@ -120,3 +120,12 @@ class ActiveRecordNamespace::MyModel < ActiveRecord::Base
   include Tire::Model::Search
   include Tire::Model::Callbacks
 end
+
+# Model with percolation
+
+class ActiveRecordModelWithPercolation < ActiveRecord::Base
+  include Tire::Model::Search
+  include Tire::Model::Callbacks
+
+  percolate!
+end

data/test/models/persistent_article.rb

@@ -1,4 +1,4 @@
-# Example class with ElasticSearch persistence
+# Example class with Elasticsearch persistence
 
 class PersistentArticle
 

data/test/models/persistent_article_in_index.rb

@@ -1,4 +1,4 @@
-# Example class with ElasticSearch persistence in index `persistent_articles`
+# Example class with Elasticsearch persistence in index `persistent_articles`
 #
 # The `index` is `persistent_articles`
 #

data/test/models/persistent_article_in_namespace.rb

@@ -1,4 +1,4 @@
-# Example namespaced class with ElasticSearch persistence
+# Example namespaced class with Elasticsearch persistence
 #
 # The `document_type` is `my_namespace/persistent_article_in_namespace`
 #

data/test/models/persistent_article_with_percolation.rb

@@ -0,0 +1,5 @@
+class PersistentArticleWithPercolation
+  include Tire::Model::Persistence
+  property :title
+  percolate!
+end

data/test/models/persistent_articles_with_custom_index_name.rb

@@ -1,4 +1,4 @@
-# Example class with ElasticSearch persistence and custom index name
+# Example class with Elasticsearch persistence and custom index name
 
 class PersistentArticleWithCustomIndexName
 

data/test/test_helper.rb

@@ -84,7 +84,7 @@ module Test::Integration
     begin
       ::RestClient.get URL
     rescue Errno::ECONNREFUSED
-      abort "\n\n#{'-'*87}\n[ABORTED] You have to run ElasticSearch on #{URL} for integration tests\n#{'-'*87}\n\n"
+      abort "\n\n#{'-'*87}\n[ABORTED] You have to run Elasticsearch on #{URL} for integration tests\n#{'-'*87}\n\n"
     end
 
     ::RestClient.delete "#{URL}/articles-test"     rescue nil

data/test/unit/index_alias_test.rb

@@ -130,7 +130,7 @@ module Tire
 
       context "saving" do
 
-        should "send data to ElasticSearch" do
+        should "send data to Elasticsearch" do
           Configuration.client.expects(:post).with do |url, json|
             url  == "#{Configuration.url}/_aliases" &&
             json =~ /"index":"index_2012_05"/ &&

data/test/unit/index_test.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 require 'test_helper'
 
 module Tire
@@ -170,7 +172,7 @@ module Tire
                                             }
         end
 
-        should "return the mapping" do
+        should "return the mapping as a Hash" do
           json =<<-JSON
           {
             "dummy" : {
@@ -189,6 +191,33 @@ module Tire
           assert_equal 2.0,      @index.mapping['article']['properties']['title']['boost']
         end
 
+        should "update the mapping" do
+          Configuration.client.expects(:put).returns(mock_response('{"ok":true,"acknowledged":true}', 200))
+          assert @index.mapping( 'document', { properties: { body: {type: 'string', analyzer: 'english'} } } )
+        end
+
+        should "fail to update the mapping when conflicts occur" do
+          Configuration.client.expects(:put).returns(mock_response('{"error":"MergeMappingException","status":400}', 400))
+          assert ! @index.mapping( 'document', { properties: { body: {type: 'string', analyzer: 'english'} } } )
+        end
+
+        should "raise an exception for the bang method" do
+          Configuration.client.expects(:put).returns(mock_response('{"error":"MergeMappingException","status":400}', 400))
+          assert_raise(RuntimeError) do
+            @index.mapping!("blah", {})
+          end
+        end
+
+        should "delete the mapping" do
+          Configuration.client.expects(:delete).returns(mock_response('{"ok":true}', 200))
+          assert @index.delete_mapping('document')
+        end
+
+        should "fail when deleting the mapping for non-existing type" do
+          Configuration.client.expects(:delete).returns(mock_response('{"error":"TypeMissingException[[dummy] type[document] missing]","status":404}', 400))
+          assert ! @index.delete_mapping('document')
+        end
+
       end
 
       context "settings" do
@@ -296,6 +325,16 @@ module Tire
           @index.store( {:id => 123, :title => 'Test'}, {:routing => 'abc'} )
         end
 
+        should "extract the replication type from options" do
+          Configuration.client.expects(:post).
+            with do |url, payload|
+              assert_equal "#{Configuration.url}/dummy/document/?replication=async", url
+            end.
+            returns(mock_response('{"ok":true,"_id":"test"}'))
+
+          @index.store({:title => 'Test'}, {:replication => 'async'})
+        end
+
         context "document with ID" do
 
           should "store Hash it under its ID property" do
@@ -331,6 +370,16 @@ module Tire
             assert_equal 'c',   @index.get_id_from_document(document_3)
           end
 
+          should "escape the ID in URL" do
+            Configuration.client.expects(:post).with do |url, payload|
+              assert_equal "#{@index.url}/document/%C3%A4ccent", url
+              assert_equal 'äccent', MultiJson.load(payload)['id']
+            end.
+            returns(mock_response('{"ok":true,"_id":"äccent"}'))
+
+            @index.store :id => 'äccent'
+          end
+
         end
 
       end
@@ -389,6 +438,13 @@ module Tire
           end
         end
 
+        should "escape the ID in URL" do
+          Configuration.client.expects(:get).with("#{@index.url}/document/%C3%A4ccent").
+                                             returns(mock_response('{"_id":"äccent"}'))
+
+          @index.retrieve 'document', 'äccent'
+        end
+
         should "properly encode document type" do
           Configuration.client.expects(:get).with("#{@index.url}/my_namespace%2Fmy_model/id-1").
                                              returns(mock_response('{"_id":"id-1","_version":1, "_source" : {"title":"Test"}}'))
@@ -467,6 +523,13 @@ module Tire
           end
         end
 
+        should "escape the ID in URL" do
+          Configuration.client.expects(:delete).with("#{@index.url}/document/%C3%A4ccent").
+                                                returns(mock_response('{"ok":true,"_id":"äccent"}'))
+
+          @index.remove 'document', 'äccent'
+        end
+
         should "properly encode document type" do
           Configuration.client.expects(:delete).with("#{@index.url}/my_namespace%2Fmy_model/id-1").
                                              returns(mock_response('{"_id":"id-1","_version":1, "_source" : {"title":"Test"}}'))
@@ -523,6 +586,15 @@ module Tire
           assert_raise(ArgumentError) { @index.update(nil, '123', :script => 'foobar') }
         end
 
+        should "escape the ID in URL" do
+          Configuration.client.expects(:post).with do |url,payload|
+                                assert_equal( "#{@index.url}/document/%C3%A4ccent/_update", url )
+                              end.
+                              returns(mock_response('{"ok":"true","_id":"äccent","_version":"2"}'))
+
+          assert @index.update('document', 'äccent', {:doc => {:foo => 'bar'}})
+        end
+
         should "raise an error when no script or partial document is passed" do
            assert_raise ArgumentError do
              @index.update('article', "42", {:foo => 'bar'})
@@ -749,6 +821,12 @@ module Tire
           @index.bulk :index,  [ {:id => '1', :title => 'One'} ]
         end
 
+
+          should "return immediately with empty collection" do
+            Configuration.client.expects(:post).never
+            @index.bulk_store []
+          end
+
       end
 
       context "when importing" do