tire-erez 0.5.4

data/test/integration/boolean_queries_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+module Tire
+
+  class BooleanQueriesIntegrationTest < Test::Unit::TestCase
+    include Test::Integration
+
+    context "Boolean queries" do
+
+      should "allow to set multiple queries per condition" do
+        s = Tire.search('articles-test') do
+          query do
+            boolean do
+              must { term :tags, 'ruby' }
+              must { term :tags, 'python' }
+            end
+          end
+        end
+
+        assert_equal 1, s.results.size
+        assert_equal 'Two', s.results.first.title
+      end
+
+      should "allow to set multiple queries for multiple conditions" do
+        s = Tire.search('articles-test') do
+          query do
+            boolean do
+              must   { term :tags, 'ruby' }
+              should { term :tags, 'python' }
+            end
+          end
+        end
+
+        assert_equal 2, s.results.size
+        assert_equal 'Two', s.results[0].title
+        assert_equal 'One', s.results[1].title
+      end
+
+    end
+
+  end
+
+end

data/test/integration/boosting_queries_test.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+module Tire
+
+  class BoostingQueriesIntegrationTest < Test::Unit::TestCase
+    include Test::Integration
+
+    context "Boosting queries" do
+
+      should "allow to set multiple queries per condition" do
+        s = Tire.search('articles-test') do
+          query do
+            boosting(:negative_boost => 0.2) do
+              positive do
+                string "Two One"
+              end
+              negative do
+                term :tags, 'python'
+              end
+            end
+          end
+        end
+
+        assert_equal 'One', s.results[0].title
+        assert_equal 'Two', s.results[1].title
+      end
+
+    end
+
+  end
+
+end

data/test/integration/bulk_test.rb

@@ -0,0 +1,86 @@
+require 'test_helper'
+
+module Tire
+
+  class BulkIntegrationTest < Test::Unit::TestCase
+    include Test::Integration
+
+    context "Bulk" do
+      setup do
+        @index    = Tire.index('bulk-test') { delete; create }
+        @articles = [
+          { id: '1', type: 'article', title: 'one',   tags: ['ruby']           },
+          { id: '2', type: 'article', title: 'two',   tags: ['ruby', 'python'] },
+          { id: '3', type: 'article', title: 'three', tags: ['java']           }
+        ]
+      end
+
+      teardown do
+        @index.delete
+        Tire.index('bulk-test-fresh').delete
+        Tire.index('bulk-test-consistency').delete
+        Tire.index('bulk-test-routing').delete
+      end
+
+      should "store a collection of documents and refresh the index" do
+        @index.bulk_store @articles, refresh: true
+        assert_equal 3, Tire.search('bulk-test/article').query { all }.results.size
+      end
+
+      should "extract the routing value from documents" do
+        index = Tire.index('bulk-test-routing')
+        index.delete
+        index.create index: { number_of_shards: 2, number_of_replicas: 0 }
+        index.bulk_store [ { id: '1', title: 'A', _routing: 'a'}, { id: '2', title: 'B', _routing: 'b'} ]
+        index.refresh
+
+        assert_equal 2, Tire.search('bulk-test-routing') { query {all} }.results.size
+        assert_equal 1, Tire.search('bulk-test-routing', routing: 'a') { query {all} }.results.size
+        assert_equal 1, Tire.search('bulk-test-routing', routing: 'b') { query {all} }.results.size
+      end
+
+      should "delete documents in bulk" do
+        (1..10).to_a.each { |i| @index.store id: i }
+        @index.refresh
+        assert_equal 10, Tire.search('bulk-test') { query {all} }.results.size
+
+        documents = (1..10).to_a.map { |i| { id: i } }
+        @index.bulk_delete documents, refresh: true
+        assert_equal 0, Tire.search('bulk-test') { query {all} }.results.size
+      end
+
+      should "allow to feed search results to bulk API" do
+        (1..10).to_a.each { |i| @index.store id: i }
+        @index.refresh
+        assert_equal 10, Tire.search('bulk-test') { query {all} }.results.size
+
+        documents = Tire.search('bulk-test') { query {all} }.results.to_a
+
+        @index.bulk_delete documents, refresh: true
+        assert_equal 0, Tire.search('bulk-test') { query {all} }.results.size
+
+        Tire.index('bulk-test-fresh').bulk_create documents, refresh: true
+        assert_equal 10, Tire.search('bulk-test-fresh') { query {all} }.results.size
+      end
+
+      should "timeout when consistency factor is not met" do
+        # Tire.configure { logger STDERR, level: 'debug' }
+
+        Tire.index 'bulk-test-consistency' do
+          delete
+          create index: { number_of_shards: 1, number_of_replicas: 15 }
+        end
+
+        assert_raise Timeout::Error do
+          Timeout::timeout(3) do
+            Tire.index('bulk-test-consistency').bulk_store [ {id: '1', title: 'One' } ],
+                                               consistency: 'all',
+                                               raise: true
+          end
+        end
+      end
+    end
+
+  end
+
+end

data/test/integration/count_test.rb

@@ -0,0 +1,64 @@
+require 'test_helper'
+
+module Tire
+
+  class CountIntegrationTest < Test::Unit::TestCase
+    include Test::Integration
+
+    context "Count with search type" do
+
+      should "return total number of hits for the query, but no hits" do
+        s = Tire.search 'articles-test', :search_type => 'count' do
+          query { term :tags, 'ruby' }
+        end
+
+        assert_equal 2, s.results.total
+        assert_equal 0, s.results.count
+        assert s.results.empty?
+      end
+
+      should "return facets in results" do
+        s = Tire.search 'articles-test', :search_type => 'count' do
+          query { term :tags, 'ruby' }
+          facet('tags') { terms :tags }
+        end
+
+        assert ! s.results.facets['tags'].empty?
+        assert_equal 2, s.results.facets['tags']['terms'].select { |t| t['term'] == 'ruby' }.  first['count']
+        assert_equal 1, s.results.facets['tags']['terms'].select { |t| t['term'] == 'python' }.first['count']
+      end
+
+    end
+
+    context "Count with the count method" do
+      setup    { Tire.index('articles-test-count') { delete; create and store(title: 'Test') and refresh } }
+      teardown { Tire.index('articles-test-count') { delete } }
+
+      should "return number of documents in the index" do
+        assert_equal 5, Tire.count('articles-test')
+      end
+
+      should "return number of documents in the index for specific query" do
+        # Tire.configure { logger STDERR, level: 'debug' }
+        count = Tire.count('articles-test') do
+          term :tags, 'ruby'
+        end
+        assert_equal 2, count
+      end
+
+      should "return number of documents in multiple indices" do
+        assert_equal 6, Tire.count(['articles-test', 'articles-test-count'])
+      end
+
+      should "allow access to the JSON and response" do
+        c = Tire::Search::Count.new('articles-test')
+        c.perform
+        assert_equal 5, c.value
+        assert_equal 0, c.json['_shards']['failed']
+        assert c.response.success?, "Response should be successful: #{c.response.inspect}"
+      end
+
+    end
+
+  end
+end

data/test/integration/custom_score_queries_test.rb

@@ -0,0 +1,89 @@
+require 'test_helper'
+
+module Tire
+
+  class CustomScoreQueriesIntegrationTest < Test::Unit::TestCase
+    include Test::Integration
+
+    context "Custom score queries" do
+
+      should "allow to define custom score queries (base score on field value)" do
+        s = Tire.search('articles-test') do
+          query do
+            # Give longer documents higher score
+            #
+            custom_score :script => "1.0 / doc['words'].value" do
+              string "title:T*"
+            end
+          end
+        end
+
+        assert_equal 2, s.results.size
+        assert_equal ['Two', 'Three'], s.results.map(&:title)
+
+        assert s.results[0]._score > 0
+        assert s.results[1]._score > 0
+        assert s.results[0]._score > s.results[1]._score
+      end
+
+      should "allow to manipulate the default score (boost recent)" do
+        s = Tire.search('articles-test') do
+          query do
+            # Boost recent documents
+            #
+            custom_score :script => "_score + ( doc['published_on'].date.getMillis() / time() )" do
+              string 'title:F*'
+            end
+          end
+        end
+
+        assert_equal 2, s.results.size
+        assert_equal ['Five', 'Four'], s.results.map(&:title)
+
+        assert s.results[0]._score > 1
+        assert s.results[1]._score > 1
+      end
+
+      should "allow to define arbitrary custom scoring" do
+        s = Tire.search('articles-test') do
+          query do
+            # Replace documents score with the count of characters in their title
+            #
+            custom_score :script => "doc['title'].value.length()" do
+              string "title:T*"
+            end
+          end
+        end
+
+        assert_equal 2, s.results.size
+        assert_equal ['Three', 'Two'], s.results.map(&:title)
+
+        assert_equal 5.0, s.results.max_score
+        assert_equal 5.0, s.results[0]._score
+        assert_equal 3.0, s.results[1]._score
+      end
+
+      should "allow to pass parameters to the script" do
+        s = Tire.search('articles-test') do
+          query do
+            # Replace documents score with parameterized computation
+            #
+            custom_score :script => "doc['words'].doubleValue / max(a, b)",
+                         :params => { :a => 1, :b => 2 } do
+              string "title:T*"
+            end
+          end
+        end
+
+        assert_equal 2, s.results.size
+        assert_equal ['Three', 'Two'], s.results.map(&:title)
+
+        assert_equal 187.5, s.results[0]._score
+        assert_equal 125.0, s.results[1]._score
+      end
+
+    end
+
+  end
+
+end

data/test/integration/dis_max_queries_test.rb

@@ -0,0 +1,68 @@
+require 'test_helper'
+
+module Tire
+
+  class DisMaxQueriesIntegrationTest < Test::Unit::TestCase
+    include Test::Integration
+
+    context "Dis Max queries" do
+      setup do
+        Tire.index 'dis_max_test' do
+          delete
+          create
+
+          store title: "It's an Albino, Albino, Albino thing!", text: "Albino, albino, albino! Wanna know about albino? ..."
+          store title: "Albino Vampire Monkey Attacks!",        text: "The night was just setting in when ..."
+          store title: "Pinky Elephant",                        text: "An albino walks into a ZOO and ..."
+          refresh
+        end
+      end
+
+      teardown do
+        Tire.index('dis_max_test').delete
+      end
+
+      should_eventually "boost matches in both fields" do
+        dis_max = Tire.search 'dis_max_test' do
+          query do
+            dis_max do
+              query { string "albino elephant", fields: ['title', 'text'] }
+            end
+          end
+        end
+        # p "DisMax:", dis_max.results.map(&:title)
+
+        assert_equal 'Pinky Elephant', dis_max.results.first.title
+
+        # NOTE: This gives exactly the same result as a boolean query:
+        # boolean = Tire.search 'dis_max_test' do
+        #   query do
+        #     boolean do
+        #       should { string "albino",   fields: ['title', 'text'] }
+        #       should { string "elephant", fields: ['title', 'text'] }
+        #     end
+        #   end
+        # end
+        # p "Boolean:", boolean.results.map(&:title)
+      end
+
+      should "allow to set multiple queries" do
+        s = Tire.search('articles-test') do
+          query do
+            dis_max do
+              query { term :tags, 'ruby' }
+              query { term :tags, 'python' }
+            end
+          end
+        end
+
+        assert_equal 2, s.results.size
+        assert_equal 'Two', s.results[0].title
+        assert_equal 'One', s.results[1].title
+      end
+
+    end
+
+  end
+
+end

data/test/integration/dsl_search_test.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+
+module Tire
+
+  class DSLSearchIntegrationTest < Test::Unit::TestCase
+    include Test::Integration
+
+    context "DSL" do
+
+      should "allow passing search payload as a Hash" do
+        s = Tire.search 'articles-test', :query  => { :query_string => { :query => 'ruby' } },
+                                         :facets => { 'tags' => { :filter => { :term => {:tags => 'ruby' } } } }
+
+        assert_equal 2, s.results.count
+        assert_equal 2, s.results.facets['tags']['count']
+      end
+
+      should "allow building search query iteratively" do
+        s = Tire.search 'articles-test'
+        s.query { string 'T*' }
+        s.filter :terms, :tags => ['java']
+
+        assert_equal 1, s.results.count
+      end
+
+    end
+
+  end
+
+end

data/test/integration/explanation_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+module Tire
+
+  class ExplanationIntegrationTest < Test::Unit::TestCase
+    include Test::Integration
+
+    context "Explanation" do
+      teardown { Tire.index('explanation-test').delete }
+
+      setup do
+        content = "A Fox one day fell into a deep well and could find no means of escape."
+
+        Tire.index 'explanation-test' do
+          delete
+          create
+          store   :id => 1, :content => content
+          refresh
+        end
+      end
+
+      should "add '_explanation' field to the result item" do
+        # Tire::Configuration.logger STDERR, :level => 'debug'
+        s = Tire.search 'explanation-test', :explain => true do
+          query do
+            boolean do
+              should   { string 'content:Fox' }
+            end
+          end
+        end
+
+        doc = s.results.first
+
+        explanation = doc._explanation
+
+        assert explanation.description.include?("product of:")
+        assert explanation.value < 0.6
+        assert_not_nil explanation.details
+        end
+
+      end
+
+    end
+  end