tire 0.1.0

data/test/unit/rubyext_hash_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+module Tire
+
+  class RubyCoreExtensionsTest < Test::Unit::TestCase
+
+    context "Hash" do
+
+      should "have to_indexed_json doing the same as to_json" do
+        [{}, { 1 => 2 }, { 3 => 4, 5 => 6 }, { nil => [7,8,9] }].each do |h|
+          assert_equal Yajl::Parser.parse(h.to_json), Yajl::Parser.parse(h.to_indexed_json)
+        end
+      end
+
+    end
+
+  end
+
+end

data/test/unit/search_facet_test.rb

@@ -0,0 +1,69 @@
+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 "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
+
+      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
+
+      end
+
+      context "date histogram" do
+
+        should "encode the JSON with default values" do
+          f = Facet.new('date') { date :published_on, :interval => 'day' }
+          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
+
+      end
+
+    end
+
+  end
+
+end

data/test/unit/search_filter_test.rb

@@ -0,0 +1,36 @@
+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 declarations as JSON" 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
+
+    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,55 @@
+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 "allow a block to be given" do
+        assert_equal( { :term => { :foo => 'bar' } }.to_json, Query.new do
+          term(:foo, 'bar')
+        end.to_json)
+      end
+
+      should "allow search for single term" do
+        assert_equal( { :term => { :foo => 'bar' } }, Query.new.term(:foo, 'bar') )
+      end
+
+      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
+
+      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 "search for all documents" do
+        assert_equal( { :match_all => { } }, Query.new.all )
+      end
+
+      should "search for documents by IDs" do
+        assert_equal( { :ids => { :values => [1, 2], :type => 'foo' }  },
+                      Query.new.ids([1, 2], 'foo') )
+      end
+
+    end
+
+  end
+
+end

data/test/unit/search_sort_test.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+
+module Tire::Search
+
+  class SortTest < Test::Unit::TestCase
+
+    context "Sort" do
+
+      should "be serialized to JSON" do
+        assert_respond_to Sort.new, :to_json
+      end
+
+      should "encode simple strings" do
+        assert_equal [:foo].to_json, Sort.new.foo.to_json
+      end
+
+      should "encode method arguments" do
+        assert_equal [:foo => 'desc'].to_json, Sort.new.foo('desc').to_json
+      end
+
+      should "encode hash" do
+        assert_equal [ :foo => { :reverse => true } ].to_json, Sort.new.foo(:reverse => true).to_json
+      end
+
+      should "encode multiple sort fields" do
+        assert_equal [:foo, :bar].to_json, Sort.new.foo.bar.to_json
+      end
+
+      should "encode fields when passed as a block to constructor" do
+        s = Sort.new do
+          foo
+          bar 'desc'
+          _score
+        end
+        assert_equal [ :foo, {:bar => 'desc'}, :_score ].to_json, s.to_json
+      end
+
+      should "encode fields deeper in json" do
+        s = Sort.new { field 'author.name' }
+        assert_equal [ 'author.name' ].to_json, s.to_json
+
+        s = Sort.new { field 'author.name', :desc }
+        assert_equal [ {'author.name' => 'desc'} ].to_json, s.to_json
+      end
+
+    end
+
+  end
+
+end

data/test/unit/search_test.rb

@@ -0,0 +1,204 @@
+require 'test_helper'
+
+module Tire
+
+  class SearchTest < Test::Unit::TestCase
+
+    context "Search" do
+      setup { Configuration.reset :logger }
+
+      should "be initialized with index/indices" do
+        assert_raise(ArgumentError) { Search::Search.new }
+      end
+
+      should "have the query method" do
+        assert_respond_to Search::Search.new('index'), :query
+      end
+
+      should "allow to pass block to query" do
+        Search::Query.any_instance.expects(:instance_eval)
+
+        Search::Search.new('index').query { string 'foo' }
+      end
+
+      should "allow to pass block with argument to query, allowing to use local variables from outer scope" do
+        foo = 'bar'
+        query_block = lambda { |query| query.string foo }
+        Search::Query.any_instance.expects(:instance_eval).never
+
+        Search::Search.new('index').query &query_block
+      end
+
+      should "store indices as an array" do
+        s = Search::Search.new('index1') do;end
+        assert_equal ['index1'], s.indices
+
+        s = Search::Search.new('index1', 'index2') do;end
+        assert_equal ['index1', 'index2'], s.indices
+      end
+
+      should "return curl snippet for debugging" do
+        s = Search::Search.new('index') do
+          query { string 'title:foo' }
+        end
+        assert_equal %q|curl -X POST "http://localhost:9200/index/_search?pretty=true" -d | +
+                     %q|'{"query":{"query_string":{"query":"title:foo"}}}'|,
+                     s.to_curl
+      end
+
+      should "return curl snippet with multiple indices for debugging" do
+        s = Search::Search.new('index_1', 'index_2') do
+          query { string 'title:foo' }
+        end
+        assert_match /index_1,index_2/, s.to_curl
+      end
+
+      should "allow chaining" do
+        assert_nothing_raised do
+          Search::Search.new('index').query { }.sort { title 'desc' }.size(5).sort { name 'asc' }.from(1)
+        end
+      end
+
+      should "perform the search" do
+        response = stub(:body => '{"took":1,"hits":[]}', :code => 200)
+        Configuration.client.expects(:post).returns(response)
+        Results::Collection.expects(:new).returns([])
+
+        s = Search::Search.new('index')
+        s.perform
+        assert_not_nil s.results
+        assert_not_nil s.response
+      end
+
+      should "print debugging information on exception and re-raise it" do
+        Configuration.client.expects(:post).raises(RestClient::InternalServerError)
+        STDERR.expects(:puts)
+
+        s = Search::Search.new('index')
+        assert_raise(RestClient::InternalServerError) { s.perform }
+      end
+
+      should "log request, but not response, when logger is set" do
+        Configuration.logger STDERR
+
+        response = stub(:body => '{"took":1,"hits":[]}', :code => 200)
+        Configuration.client.expects(:post).returns(response)
+
+        Results::Collection.expects(:new).returns([])
+        Configuration.logger.expects(:log_request).returns(true)
+        Configuration.logger.expects(:log_response).with(200, 1, '')
+
+        Search::Search.new('index').perform
+      end
+
+      context "sort" do
+
+        should "allow sorting by multiple fields" do
+          s = Search::Search.new('index') do
+            sort do
+              title 'desc'
+              _score
+            end
+          end
+          hash = JSON.load( s.to_json )
+          assert_equal [{'title' => 'desc'}, '_score'], hash['sort']
+        end
+        
+      end
+
+      context "facets" do
+
+        should "retrieve terms facets" do
+          s = Search::Search.new('index') do
+            facet('foo1') { terms :bar, :global => true }
+            facet('foo2', :global => true) { terms :bar }
+            facet('foo3') { terms :baz }
+          end
+          assert_equal 3, s.facets.keys.size
+          assert_not_nil s.facets['foo1']
+          assert_not_nil s.facets['foo2']
+          assert_not_nil s.facets['foo3']
+        end
+
+        should "retrieve date histogram facets" do
+          s = Search::Search.new('index') do
+            facet('date') { date :published_on }
+          end
+          assert_equal 1, s.facets.keys.size
+          assert_not_nil  s.facets['date']
+        end
+
+      end
+
+      context "filter" do
+
+        should "allow to specify filter" do
+          s = Search::Search.new('index') do
+            filter :terms, :tags => ['foo']
+          end
+
+          assert_equal 1, s.filters.size
+          assert_not_nil s.filters.first
+          assert_not_nil s.filters.first[:terms]
+        end
+
+      end
+
+      context "highlight" do
+
+        should "allow to specify highlight for single field" do
+          s = Search::Search.new('index') do
+            highlight :body
+          end
+
+          assert_not_nil s.highlight
+          assert_instance_of Tire::Search::Highlight, s.highlight
+        end
+
+        should "allow to specify highlight for more fields" do
+          s = Search::Search.new('index') do
+            highlight :body, :title
+          end
+
+          assert_not_nil s.highlight
+          assert_instance_of Tire::Search::Highlight, s.highlight
+        end
+
+        should "allow to specify highlight with for more fields with options" do
+          s = Search::Search.new('index') do
+            highlight :body, :title => { :fragment_size => 150, :number_of_fragments => 3 }
+          end
+
+          assert_not_nil s.highlight
+          assert_instance_of Tire::Search::Highlight, s.highlight
+        end
+
+      end
+
+      context "with from/size" do
+
+        should "set the values in request" do
+          s = Search::Search.new('index') do
+            size 5
+            from 3
+          end
+          hash = JSON.load( s.to_json )
+          assert_equal 5, hash['size']
+          assert_equal 3, hash['from']
+        end
+
+        should "set the fields limit in request" do
+          s = Search::Search.new('index') do
+            fields :title
+          end
+          hash = JSON.load( s.to_json )
+          assert_equal 'title', hash['fields']
+        end
+
+      end
+
+    end
+
+  end
+
+end