load_balanced_tire 0.1

data/test/unit/search_facet_test.rb

@@ -0,0 +1,153 @@
+require 'test_helper'
+
+module Tire::Search
+
+  class FacetTest < Test::Unit::TestCase
+
+    context "Facet" do
+
+      should "be serialized to JSON" do
+        assert_respond_to Facet.new('foo'), :to_json
+      end
+
+      context "generally" do
+
+        should "encode facets with defaults for current query" do
+          assert_equal( { :foo => { :terms => {:field=>'bar',:size=>10,:all_terms=>false} } }.to_json,
+                        Facet.new('foo').terms(:bar).to_json )
+        end
+
+        should "encode facets as global" do
+          assert_equal( { :foo => { :terms => {:field=>'bar',:size=>10,:all_terms=>false}, :global => true } }.to_json,
+                        Facet.new('foo', :global => true).terms(:bar).to_json )
+        end
+
+        should "pass options to facets" do
+          payload = Facet.new('foo', :facet_filter => { :term => { :account_id => 'foo' } }).terms(:bar).to_hash
+
+          assert_not_nil payload['foo'][:facet_filter]
+          assert_equal( { :term => { :account_id => 'foo' } },
+                        payload['foo'][:facet_filter] )
+        end
+
+        should "encode facet options" do
+          assert_equal( { :foo => { :terms => {:field=>'bar',:size=>5,:all_terms=>false} } }.to_json,
+                        Facet.new('foo').terms(:bar, :size => 5).to_json )
+        end
+
+        should "encode facets when passed as a block" do
+          f = Facet.new('foo') do
+            terms :bar
+          end
+          assert_equal( { :foo => { :terms => {:field=>'bar',:size=>10,:all_terms=>false} } }.to_json, f.to_json )
+        end
+
+        should "encode facets when passed as a block, using variables from outer scope" do
+          def foo; 'bar'; end
+
+          f = Facet.new('foo') do |facet|
+            facet.terms foo, :size => 20
+          end
+          assert_equal( { :foo => { :terms => {:field=>'bar',:size=>20,:all_terms=>false} } }.to_json, f.to_json )
+        end
+
+      end
+
+      context "terms facet" do
+
+        should "encode the default all_terms option" do
+          assert_equal false, Facet.new('foo') { terms :foo }.to_hash['foo'][:terms][:all_terms]
+        end
+
+        should "encode the all_terms option" do
+          assert_equal true, Facet.new('foo') { terms :foo, :all_terms => true }.to_hash['foo'][:terms][:all_terms]
+        end
+
+        should "encode custom options" do
+          assert_equal( { :foo => { :terms => {:field=>'bar',:size=>5,:all_terms=>false,:exclude=>['moo']} } }.to_json,
+                        Facet.new('foo').terms(:bar, :size => 5, :exclude => ['moo']).to_json )
+        end
+
+      end
+
+      context "date histogram" do
+
+        should "encode the JSON with default values" do
+          f = Facet.new('date') { date :published_on }
+          assert_equal({ :date => { :date_histogram => { :field => 'published_on', :interval => 'day' } } }.to_json, f.to_json)
+        end
+
+        should "encode the JSON with custom interval" do
+          f = Facet.new('date') { date :published_on, :interval => 'month' }
+          assert_equal({ :date => { :date_histogram => { :field => 'published_on', :interval => 'month' } } }.to_json, f.to_json)
+        end
+
+        should "encode custom options" do
+          f = Facet.new('date') { date :published_on, :value_field => 'price'  }
+          assert_equal( {:date=>{:date_histogram=>{:field=>'published_on',:interval=>'day',:value_field=>'price' } } }.to_json,
+                        f.to_json )
+        end
+
+      end
+
+      context "range facet" do
+        should "encode facet options" do
+          f = Facet.new('range') { range :published_on, [{:to => '2010-12-31'}, {:from => '2011-01-01', :to => '2011-05-27'}, {:from => '2011-05-28'}]}
+          assert_equal({ :range => { :range => { :field => 'published_on', :ranges => [{:to => '2010-12-31'}, {:from => '2011-01-01', :to => '2011-05-27'}, {:from => '2011-05-28'}] } } }.to_json, f.to_json)
+        end
+      end
+
+      context "histogram facet" do
+        should "encode facet options with default key" do
+          f = Facet.new('histogram') { histogram :age, {:interval => 5} }
+          assert_equal({ :histogram => { :histogram => { :field => 'age', :interval => 5 } } }.to_json, f.to_json)
+        end
+
+        should "encode the JSON if define an histogram" do
+          f = Facet.new('histogram') { histogram :age, {:histogram => {:key_field => "age", :value_field => "age", :interval => 100}} }
+          assert_equal({ :histogram => { :histogram => {:key_field => "age", :value_field => "age", :interval => 100} } }.to_json, f.to_json)
+        end
+      end
+
+      context "statistical facet" do
+        should "encode facet options" do
+          f = Facet.new('statistical') { statistical :words }
+          assert_equal({:statistical => {:statistical => {:field => 'words'}}}.to_json, f.to_json)
+        end
+
+        should "encode the JSON if a 'statistical' custom option is defined" do
+          f = Facet.new('statistical') { statistical :words, :statistical => {:params => {:factor => 5}} }
+          assert_equal({:statistical => {:statistical => {:params => {:factor => 5 }}}}.to_json, f.to_json)
+        end
+      end
+
+      context "terms_stats facet" do
+        should "should encode facet options" do
+          f = Facet.new('terms_stats') { terms_stats :tags, :words }
+          assert_equal({:terms_stats => {:terms_stats => {:key_field => 'tags', :value_field => 'words'}}}.to_json, f.to_json)
+        end
+      end
+
+      context "query facet" do
+        should "encode facet options" do
+          f = Facet.new('q_facet') do
+            query { string '_exists_:foo' }
+          end
+          assert_equal({ :q_facet => { :query => { :query_string => { :query => '_exists_:foo' } } } }.to_json, f.to_json)
+        end
+      end
+
+      context "filter facet" do
+        should "encode facet options" do
+          f = Facet.new('filter_facet') do
+            filter :tags, 'ruby'
+          end
+          assert_equal({ :filter_facet => { :filter => { :term => { :tags => 'ruby' } } } }.to_json, f.to_json)
+        end
+      end
+
+    end
+
+  end
+
+end

data/test/unit/search_filter_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+module Tire::Search
+
+  class FilterTest < Test::Unit::TestCase
+
+    context "Filter" do
+
+      should "be serialized to JSON" do
+        assert_respond_to Filter.new(:terms, {}), :to_json
+      end
+
+      should "encode simple filter declarations as JSON" do
+        assert_equal( { :terms => {} }.to_json,
+                      Filter.new('terms').to_json )
+
+        assert_equal( { :terms => { :tags => ['foo'] } }.to_json,
+                      Filter.new('terms', :tags => ['foo']).to_json )
+
+        assert_equal( { :range => { :age => { :from => 10, :to => 20 } } }.to_json,
+                      Filter.new('range', { :age => { :from => 10, :to => 20 } }).to_json )
+
+        assert_equal( { :geo_distance => { :distance => '12km', :location => [40, -70] } }.to_json,
+                      Filter.new('geo_distance', { :distance => '12km', :location => [40, -70] }).to_json )
+      end
+
+      should "encode 'or' filter with multiple other filters" do
+        # See http://www.elasticsearch.org/guide/reference/query-dsl/or-filter.html
+        assert_equal( { :or => [ {:terms => {:tags => ['foo']}}, {:terms => {:tags => ['bar']}} ] }.to_json,
+                      Filter.new('or', {:terms => {:tags => ['foo']}}, {:terms => {:tags => ['bar']}}).to_json )
+      end
+
+      should "encode 'bool' filter with multiple filters" do
+        # http://www.elasticsearch.org/guide/reference/query-dsl/bool-filter.html
+        assert_equal( { :bool => [ {:must => {:terms => {:tags => ['foo']}}}, {:should => {:terms => {:tags => ['bar']}}} ] }.to_json,
+                      Filter.new('bool', {:must => {:terms => {:tags => ['foo']}}}, { :should => {:terms => {:tags => ['bar']}}}).to_json )
+      end
+
+    end
+
+  end
+end

data/test/unit/search_highlight_test.rb

@@ -0,0 +1,46 @@
+require 'test_helper'
+
+module Tire::Search
+
+  class HighlightTest < Test::Unit::TestCase
+
+    context "Highlight" do
+
+      should "be serialized to JSON" do
+        assert_respond_to Highlight.new(:body), :to_json
+      end
+
+      should "specify highlight for single field" do
+        assert_equal( {:fields => { :body => {} }}.to_json,
+                      Highlight.new(:body).to_json )
+      end
+
+      should "specify highlight for more fields" do
+        assert_equal( {:fields => { :title => {}, :body => {} }}.to_json,
+                      Highlight.new(:title, :body).to_json )
+      end
+
+      should "specify highlight for more fields with options" do
+        assert_equal( {:fields => { :title => {}, :body => { :a => 1, :b => 2 } }}.to_json,
+                      Highlight.new(:title, :body => { :a => 1, :b => 2 }).to_json )
+      end
+
+      should "specify highlight for more fields with highlight options" do
+        # p Highlight.new(:title, :body => {}, :options => { :tag => '<strong>' }).to_hash
+        assert_equal( {:fields => { :title => {}, :body => {} }, :pre_tags => ['<strong>'], :post_tags => ['</strong>'] }.to_json,
+                      Highlight.new(:title, :body => {}, :options => { :tag => '<strong>' }).to_json )
+      end
+    
+      context "with custom tags" do
+
+        should "properly parse tags with class" do
+          assert_equal( {:fields => { :title => {} }, :pre_tags => ['<strong class="highlight">'], :post_tags => ['</strong>'] }.to_json,
+                        Highlight.new(:title, :options => { :tag => '<strong class="highlight">' }).to_json )
+        end
+
+      end
+
+    end
+
+  end
+end

data/test/unit/search_query_test.rb

@@ -0,0 +1,301 @@
+require 'test_helper'
+
+module Tire::Search
+
+  class QueryTest < Test::Unit::TestCase
+
+    context "Query" do
+      should "be serialized to JSON" do
+        assert_respond_to Query.new, :to_json
+      end
+
+      should "return itself as a Hash" do
+        assert_respond_to Query.new, :to_hash
+        assert_equal( { :term => { :foo => { :term => 'bar' } } }, Query.new.term(:foo, 'bar').to_hash )
+      end
+
+      should "allow a block to be given" do
+        assert_equal( { :term => { :foo => { :term => 'bar' } } }.to_json, Query.new do
+          term(:foo, 'bar')
+        end.to_json)
+      end
+    end
+
+    context "Term query" do
+      should "allow search for single term" do
+        assert_equal( { :term => { :foo => { :term => 'bar' } } }, Query.new.term(:foo, 'bar') )
+      end
+
+      should "allow search for single term passing an options hash" do
+        assert_equal( { :term => { :foo => { :term => 'bar', :boost => 2.0 } } }, Query.new.term(:foo, 'bar', :boost => 2.0) )
+      end
+    end
+
+    context "Terms query" do
+      should "allow search for multiple terms" do
+        assert_equal( { :terms => { :foo => ['bar', 'baz'] } }, Query.new.terms(:foo, ['bar', 'baz']) )
+      end
+
+      should "allow set minimum match when searching for multiple terms" do
+        assert_equal( { :terms => { :foo => ['bar', 'baz'], :minimum_match => 2 } },
+                      Query.new.terms(:foo, ['bar', 'baz'], :minimum_match => 2) )
+      end
+    end
+
+    context "Range query" do
+      should "allow search for a range" do
+        assert_equal( { :range => { :age => { :gte => 21 } } }, Query.new.range(:age, { :gte => 21 }) )
+      end
+    end
+
+    context "Text query" do
+      should "allow search with a text search" do
+        assert_equal( { :text => {'field' => {:query => 'foo'}}}, Query.new.text('field', 'foo'))
+      end
+
+      should "allow search with a different operator for text search" do
+        assert_equal( { :text => {'field' => {:query => 'foo', :operator => 'and'}}},
+                      Query.new.text('field', 'foo', :operator => 'and'))
+      end
+    end
+
+    context "Query String query" do
+      should "allow search with a query string" do
+        assert_equal( { :query_string => { :query => 'title:foo' } },
+                      Query.new.string('title:foo') )
+      end
+
+      should "allow set default field when searching with a query string" do
+        assert_equal( { :query_string => { :query => 'foo', :default_field => 'title' } },
+                      Query.new.string('foo', :default_field => 'title') )
+      end
+
+      should "allow set default operator when searching with a query string" do
+        assert_equal( { :query_string => { :query => 'foo', :default_operator => 'AND' } },
+                      Query.new.string('foo', :default_operator => 'AND') )
+      end
+
+      should "allow to set options when searching with a query string" do
+        assert_equal( { :query_string => { :query => 'foo', :fields => ['title.*'], :use_dis_max => true } },
+                      Query.new.string('foo', :fields => ['title.*'], :use_dis_max => true) )
+      end
+    end
+
+    context "Custom Score query" do
+      should "allow to set script for custom score queries" do
+        query = Query.new.custom_score(:script => "_score * doc['price'].value") do
+          string 'foo'
+        end
+
+        assert_equal "_score * doc['price'].value", query[:custom_score][:script]
+      end
+
+      should "allow to pass parameters for custom score queries" do
+        query = Query.new.custom_score(:script => "_score * doc['price'].value / max(a, b)",
+                                       :params => { :a => 1, :b => 2 }) do
+          string 'foo'
+        end
+
+        assert_equal 1, query[:custom_score][:params][:a]
+        assert_equal 2, query[:custom_score][:params][:b]
+      end
+    end
+
+    context "All query" do
+      should "search for all documents" do
+        assert_equal( { :match_all => { } }, Query.new.all )
+      end
+    end
+
+    context "IDs query" do
+      should "search for documents by IDs" do
+        assert_equal( { :ids => { :values => [1, 2], :type => 'foo' }  },
+                      Query.new.ids([1, 2], 'foo') )
+      end
+    end
+
+    context "FuzzyQuery" do
+
+      should "allow a fuzzy search" do
+        assert_equal( { :fuzzy => { :foo => { :term => 'bar' } } }, Query.new.fuzzy(:foo, 'bar') )
+      end
+
+      should "allow a fuzzy search with an options hash" do
+        assert_equal( { :term => { :foo => { :term => 'bar', :boost => 1.0, :min_similarity => 0.5 } } }, Query.new.term(:foo, 'bar', :boost => 1.0, :min_similarity => 0.5 ) )
+      end
+
+    end
+
+    context "BooleanQuery" do
+
+      should "not raise an error when no block is given" do
+        assert_nothing_raised { Query.new.boolean }
+      end
+
+      should "encode options" do
+        query = Query.new.boolean(:minimum_number_should_match => 1) do
+          must { string 'foo' }
+        end
+
+        assert_equal 1, query[:bool][:minimum_number_should_match]
+      end
+
+      should "wrap single query" do
+        assert_equal( { :bool => {:must => [{ :query_string => { :query => 'foo' } }] }},
+                      Query.new.boolean { must { string 'foo' } } )
+      end
+
+      should "wrap multiple queries for the same condition" do
+        query = Query.new.boolean do
+          must { string 'foo' }
+          must { string 'bar' }
+        end
+
+        assert_equal( 2, query[:bool][:must].size, query[:bool][:must].inspect )
+        assert_equal( { :query_string => {:query => 'foo'} }, query[:bool][:must].first )
+        assert_equal( { :query_string => {:query => 'bar'} }, query[:bool][:must].last )
+      end
+
+      should "wrap queries for multiple conditions" do
+        query = Query.new.boolean do
+          should   { string 'foo' }
+          must     { string 'bar' }
+          must     { string 'baz' }
+          must_not { string 'fuu' }
+        end
+
+        assert_equal 2, query[:bool][:must].size
+        assert_equal 1, query[:bool][:should].size
+        assert_equal 1, query[:bool][:must_not].size
+
+        assert_equal( { :query_string => {:query => 'foo'} }, query[:bool][:should].first )
+        assert_equal( { :query_string => {:query => 'bar'} }, query[:bool][:must].first )
+        assert_equal( { :query_string => {:query => 'baz'} }, query[:bool][:must].last )
+        assert_equal( { :query_string => {:query => 'fuu'} }, query[:bool][:must_not].first )
+      end
+
+      should "allow passing variables from outer scope" do
+        @q1 = 'foo'
+        @q2 = 'bar'
+        query = Query.new.boolean do |boolean|
+          boolean.must { |query| query.string @q1 }
+          boolean.must { |query| query.string @q2 }
+        end
+
+        assert_equal( 2, query[:bool][:must].size, query[:bool][:must].inspect )
+        assert_equal( { :query_string => {:query => 'foo'} }, query[:bool][:must].first )
+        assert_equal( { :query_string => {:query => 'bar'} }, query[:bool][:must].last )
+      end
+
+    end
+
+    context "FilteredQuery" do
+
+      should "not raise an error when no block is given" do
+        assert_nothing_raised { Query.new.filtered }
+      end
+
+      should "properly encode filter" do
+        query = Query.new.filtered do
+          query { term :foo, 'bar' }
+          filter :terms, :tags => ['ruby']
+        end
+
+        query[:filtered].tap do |f|
+          assert_equal( { :term => { :foo => { :term => 'bar' } } }, f[:query].to_hash )
+          assert_equal( { :tags => ['ruby'] }, f[:filter][:and].first[:terms] )
+        end
+      end
+
+      should "properly encode multiple filters" do
+        query = Query.new.filtered do
+          query { term :foo, 'bar' }
+          filter :terms, :tags => ['ruby']
+          filter :terms, :tags => ['python']
+        end
+
+        query[:filtered][:filter].tap do |filter|
+          assert_equal 1, filter.size
+          assert_equal( { :tags => ['ruby'] },   filter[:and].first[:terms] )
+          assert_equal( { :tags => ['python'] }, filter[:and].last[:terms] )
+        end
+      end
+
+      should "allow passing variables from outer scope" do
+        @my_query  = 'bar'
+        @my_filter = { :tags => ['ruby'] }
+
+        query = Query.new.filtered do |f|
+          f.query { |q| q.term :foo, @my_query }
+          f.filter :terms, @my_filter
+        end
+
+        query[:filtered].tap do |f|
+          assert_equal( { :term => { :foo => { :term => 'bar' } } }, f[:query].to_hash )
+          assert_equal( { :tags => ['ruby'] }, f[:filter][:and].first[:terms] )
+        end
+      end
+
+      context "Prefix query" do
+        should "allow search for a prefix" do
+          assert_equal( { :prefix => { :user => "foo" } }, Query.new.prefix(:user, "foo") )
+        end
+
+        should "allow setting boost for prefix" do
+          assert_equal( { :prefix => {:user => {:prefix => "foo", :boost => 2.0 } } },
+                        Query.new.prefix(:user, "foo", :boost => 2.0) )
+        end
+      end
+
+    end
+
+    context "DisMaxQuery" do
+
+      should "not raise an error when no block is given" do
+        assert_nothing_raised { Query.new.dis_max }
+      end
+
+      should "encode options" do
+        query = Query.new.dis_max(:tie_breaker => 0.7) do
+          query { string 'foo' }
+        end
+
+        assert_equal 0.7, query[:dis_max][:tie_breaker]
+      end
+
+      should "wrap single query" do
+        assert_equal( { :dis_max => {:queries => [{ :query_string => { :query => 'foo' } }] }},
+                      Query.new.dis_max { query { string 'foo' } } )
+      end
+
+      should "wrap multiple queries" do
+        query = Query.new.dis_max do
+          query   { string 'foo' }
+          query   { string 'bar' }
+          query   { string 'baz' }
+        end
+
+        assert_equal 3, query[:dis_max][:queries].size
+
+        assert_equal( { :query_string => {:query => 'foo'} }, query[:dis_max][:queries][0] )
+        assert_equal( { :query_string => {:query => 'bar'} }, query[:dis_max][:queries][1] )
+        assert_equal( { :query_string => {:query => 'baz'} }, query[:dis_max][:queries][2] )
+      end
+
+      should "allow passing variables from outer scope" do
+        @q1 = 'foo'
+        @q2 = 'bar'
+        query = Query.new.dis_max do |dis_max|
+          dis_max.query { |query| query.string @q1 }
+          dis_max.query { |query| query.string @q2 }
+        end
+
+        assert_equal( 2, query[:dis_max][:queries].size, query[:dis_max][:queries].inspect )
+        assert_equal( { :query_string => {:query => 'foo'} }, query[:dis_max][:queries].first )
+        assert_equal( { :query_string => {:query => 'bar'} }, query[:dis_max][:queries].last )
+      end
+
+    end
+
+  end
+end