load_balanced_tire 0.1

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/count_test.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+
+module Tire
+
+  class CountIntegrationTest < Test::Unit::TestCase
+    include Test::Integration
+
+    context "Count" 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
+
+  end
+end

data/test/integration/custom_score_queries_test.rb

@@ -0,0 +1,88 @@
+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[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 "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,22 @@
+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' } } } }
+        # p s.results
+        assert_equal 2, s.results.count
+        assert_equal 2, s.results.facets['tags']['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

data/test/integration/facets_test.rb

@@ -0,0 +1,259 @@
+require 'test_helper'
+require 'date'
+
+module Tire
+
+  class FacetsIntegrationTest < Test::Unit::TestCase
+    include Test::Integration
+
+    context "Facets" do
+
+      should "return results scoped to current query" do
+        q = 'tags:ruby'
+        s = Tire.search('articles-test') do
+          query { string q }
+          facet 'tags' do
+            terms :tags
+          end
+        end
+        facets = s.results.facets['tags']['terms']
+        assert_equal 2, facets.count
+        assert_equal 'ruby', facets.first['term']
+        assert_equal 2,      facets.first['count']
+      end
+
+      should "allow to specify global facets and query-scoped facets" do
+        q = 'tags:ruby'
+        s = Tire.search('articles-test') do
+          query { string q }
+          facet('scoped-tags')                  { terms :tags }
+          facet('global-tags', :global => true) { terms :tags }
+        end
+
+        scoped_facets = s.results.facets['scoped-tags']['terms']
+        global_facets = s.results.facets['global-tags']['terms']
+
+        assert_equal 2, scoped_facets.count
+        assert_equal 5, global_facets.count
+      end
+
+      should "allow to define multiple facets" do
+        s = Tire.search('articles-test') do
+          facet('tags') { terms :tags }
+          facet('date') { date :published_on }
+        end
+
+        assert_equal 2, s.results.facets.size
+      end
+
+      should "allow to restrict facets with filters" do
+        s = Tire.search('articles-test') do
+          query { string 'tags:ruby' }
+          facet('tags', :facet_filter => { :range => { :published_on => { :from => '2011-01-01', :to => '2011-01-01' } }  }) do
+            terms :tags
+          end
+        end
+
+        assert_equal 1,      s.results.facets.size
+        assert_equal 'ruby', s.results.facets['tags']['terms'].first['term']
+        assert_equal 1,      s.results.facets['tags']['terms'].first['count'].to_i
+      end
+
+      context "terms" do
+        setup do
+          @s = Tire.search('articles-test') do
+            query { string 'tags:ruby' }
+          end
+        end
+
+        should "return results ordered by term" do
+          @s.facet('tags')              { terms :tags                }
+          @s.facet('term-ordered-tags') { terms :tags, order: 'term' }
+
+          facets = @s.results.facets
+          # p facets
+          assert_equal 'ruby',   facets['tags']['terms']             .first['term']
+          assert_equal 'python', facets['term-ordered-tags']['terms'].first['term']
+        end
+
+        should "return results aggregated over multiple fields" do
+          @s.facet('multiple-fields') { terms ['tags', 'words'] }
+
+          facets = @s.results.facets
+          # p facets
+          assert_equal 4, facets['multiple-fields']['terms'].size
+        end
+
+      end
+
+      context "date histogram" do
+
+        should "return aggregated values for all results" do
+          s = Tire.search('articles-test') do
+            query { all }
+            facet 'published_on' do
+              date :published_on
+            end
+          end
+
+          facets = s.results.facets['published_on']['entries']
+          assert_equal 4, facets.size, facets.inspect
+          assert_equal 2, facets.entries[1]["count"], facets.inspect
+        end
+
+      end
+
+      context "date ranges" do
+
+        should "return aggregated values for all results" do
+          s = Tire.search('articles-test') do
+            query { all }
+            facet 'published_on' do
+              range :published_on, [{:to => '2010-12-31'}, {:from => '2011-01-01', :to => '2011-01-05'}]
+            end
+          end
+
+          facets = s.results.facets['published_on']['ranges']
+          assert_equal 2, facets.size, facets.inspect
+          assert_equal 0, facets.entries[0]["count"], facets.inspect
+          assert_equal 5, facets.entries[1]["count"], facets.inspect
+        end
+
+      end
+
+      context "histogram" do
+
+        should "return aggregated values for all results" do
+          s = Tire.search('articles-test') do
+            query { all }
+            facet 'words_histogram' do
+              histogram :words, :interval => 100
+            end
+          end
+
+          facets = s.results.facets['words_histogram']['entries']
+          assert_equal 3, facets.size, facets.inspect
+          assert_equal({"key" => 100, "count" => 2}, facets.entries[0], facets.inspect)
+          assert_equal({"key" => 200, "count" => 2}, facets.entries[1], facets.inspect)
+          assert_equal({"key" => 300, "count" => 1}, facets.entries[2], facets.inspect)
+        end
+
+      end
+
+      context "statistical" do
+
+        should "return computed statistical data on a numeric field" do
+          s = Tire.search('articles-test') do
+            query { all }
+            facet 'word_stats' do
+              statistical :words
+            end
+          end
+
+          facets = s.results.facets["word_stats"]
+          assert_equal 5,      facets["count"], facets.inspect
+          assert_equal 1125.0, facets["total"], facets.inspect
+          assert_equal 125.0,  facets["min"], facets.inspect
+          assert_equal 375.0,  facets["max"], facets.inspect
+          assert_equal 225.0,  facets["mean"], facets.inspect
+        end
+
+        should "return computed statistical data by given script" do
+          s = Tire.search('articles-test') do
+            query { all }
+            facet 'word_stats' do
+              statistical :statistical => { :script => "doc['words'].value * factor",
+                                            :params => { :factor => 2 } }
+            end
+          end
+
+          facets = s.results.facets["word_stats"]
+          assert_equal 2250.0, facets["total"], facets.inspect
+        end
+
+      end
+
+      context "terms_stats" do
+
+        should "return computed stats computed on a field, per term value driven by another field" do
+          s = Tire.search('articles-test') do
+            query { all }
+            facet 'words_per_tag_stats' do
+              terms_stats :tags, :words
+            end
+          end
+          facets = s.results.facets['words_per_tag_stats']['terms']
+
+          assert_equal({"term" => "ruby", "count" => 2, "total_count"=> 2, "min"=> 125.0, "max"=> 250.0, "total"=> 375.0, "mean"=> 187.5}, facets[0], facets.inspect)
+          assert_equal({"term" => "java", "count" => 2, "total_count"=> 2, "min"=> 125.0, "max"=> 375.0, "total"=> 500.0, "mean"=> 250.0}, facets[1], facets.inspect)
+          assert_equal({"term" => "python", "count" => 1, "total_count"=> 1, "min"=> 250.0, "max"=> 250.0, "total"=> 250.0, "mean"=> 250.0}, facets[2], facets.inspect)
+        end
+
+      end
+
+      context "query facets" do
+
+        should "return aggregated values for a string query" do
+          s = Tire.search('articles-test') do
+            facet 'tees' do
+              query { string 'T*' }
+            end
+          end
+
+          count = s.results.facets['tees']['count']
+          assert_equal 2, count, s.results.facets['tees'].inspect
+        end
+
+        should "return aggregated values for _exists_ string query" do
+          s = Tire.search('articles-test') do
+            facet 'drafts' do
+              query { string '_exists_:draft' }
+            end
+          end
+
+          count = s.results.facets['drafts']['count']
+          assert_equal 1, count, s.results.facets['drafts'].inspect
+        end
+
+        should "return aggregated values for a terms query" do
+          s = Tire.search('articles-test') do
+            facet 'friends' do
+              query { terms :tags, ['ruby', 'python'] }
+            end
+          end
+
+          count = s.results.facets['friends']['count']
+          assert_equal 2, count, s.results.facets['friends'].inspect
+
+          s = Tire.search('articles-test') do
+            facet 'friends' do
+              query { terms :tags, ['ruby', 'python'], :minimum_match => 2 }
+            end
+          end
+
+          count = s.results.facets['friends']['count']
+          assert_equal 1, count, s.results.facets['friends'].inspect
+        end
+
+      end
+
+      context "filter" do
+        should "return a filtered facet" do
+          s = Tire.search('articles-test') do
+            query { all }
+            facet 'filtered' do
+              filter :tags, 'ruby'
+            end
+          end
+
+          assert_equal 5, s.results.size, s.results.inspect
+          facets = s.results.facets["filtered"]
+          assert_equal 2, facets["count"], facets.inspect
+        end
+      end
+
+    end
+
+  end
+
+end