tire 0.4.0.pre → 0.4.0.rc

data/test/unit/model_import_test.rb

@@ -39,8 +39,8 @@ module Tire
         end
 
         should "call the passed block on every batch, and NOT manipulate the documents array" do
-          Tire::Index.any_instance.expects(:bulk_store).with([1, 2])
-          Tire::Index.any_instance.expects(:bulk_store).with([3, 4])
+          Tire::Index.any_instance.expects(:bulk_store).with { |c,o| c == [1, 2] }
+          Tire::Index.any_instance.expects(:bulk_store).with { |c,o| c == [3, 4] }
 
           runs = 0
           ImportModel.import :per_page => 2 do |documents|
@@ -53,8 +53,8 @@ module Tire
         end
 
         should "manipulate the documents in passed block" do
-          Tire::Index.any_instance.expects(:bulk_store).with([2, 3])
-          Tire::Index.any_instance.expects(:bulk_store).with([4, 5])
+          Tire::Index.any_instance.expects(:bulk_store).with { |c,o| c == [2, 3] }
+          Tire::Index.any_instance.expects(:bulk_store).with { |c,o| c == [4, 5] }
 
           ImportModel.import :per_page => 2 do |documents|
             # Add 1 to every "document" and return them

data/test/unit/model_search_test.rb

@@ -357,7 +357,13 @@ module Tire
                     :type => 'object',
                     :properties => {
                       :first_name => { :type => 'string' },
-                      :last_name  => { :type => 'string', :boost => 100 }
+                      :last_name  => { :type => 'string', :boost => 100 },
+                      :posts => {
+                        :type => 'object',
+                        :properties => {
+                          :title  => { :type => 'string', :boost => 10 }
+                        }
+                      }
                     }
                   }
                 }
@@ -378,6 +384,10 @@ module Tire
                 indexes :author do
                   indexes :first_name, :type => 'string'
                   indexes :last_name,  :type => 'string', :boost => 100
+
+                  indexes :posts do
+                    indexes :title, :type => 'string', :boost => 10
+                  end
                 end
               end
 
@@ -385,6 +395,7 @@ module Tire
 
             assert_not_nil ModelWithNestedMapping.mapping[:author][:properties][:last_name]
             assert_equal   100, ModelWithNestedMapping.mapping[:author][:properties][:last_name][:boost]
+            assert_equal   10, ModelWithNestedMapping.mapping[:author][:properties][:posts][:properties][:title][:boost]
           end
 
           should "define mapping for nested documents" do
@@ -519,20 +530,12 @@ module Tire
             @model = ActiveModelArticle.new 'id' => 1, 'title' => 'Test'
             assert_nil MultiJson.decode(@model.to_indexed_json)[:id]
             assert_nil MultiJson.decode(@model.to_indexed_json)['id']
-
-            @model = SupermodelArticle.new 'id' => 1, 'title' => 'Test'
-            assert_nil MultiJson.decode(@model.to_indexed_json)[:id]
-            assert_nil MultiJson.decode(@model.to_indexed_json)['id']
           end
 
           should "not include the type property in serialized document (_source)" do
             @model = ActiveModelArticle.new 'type' => 'foo', 'title' => 'Test'
             assert_nil MultiJson.decode(@model.to_indexed_json)[:type]
             assert_nil MultiJson.decode(@model.to_indexed_json)['type']
-
-            @model = SupermodelArticle.new 'type' => 'foo', 'title' => 'Test'
-            assert_nil MultiJson.decode(@model.to_indexed_json)[:type]
-            assert_nil MultiJson.decode(@model.to_indexed_json)['type']
           end
 
           should "serialize itself with serializable_hash when no mapping is set" do
@@ -592,7 +595,7 @@ module Tire
             assert_equal( {:one => 1}.to_json, model.to_indexed_json )
 
           end
-          
+
           should "serialize mapped properties when mapping procs are set" do
             class ::ModelWithMappingProcs
               extend  ActiveModel::Naming

data/test/unit/results_collection_test.rb

@@ -119,6 +119,12 @@ module Tire
           assert_equal "article", document._type
         end
 
+        should "properly decode type" do
+          @response = { 'hits' => { 'hits' => [ { '_id' => 1, '_type' => 'foo%2Fbar' } ] } }
+          document =  Results::Collection.new(@response).first
+          assert_equal "foo/bar", document._type
+        end
+
       end
 
       context "wrapping results with selected fields" do

data/test/unit/results_item_test.rb

@@ -60,6 +60,14 @@ module Tire
         assert_equal 'Test', @document.title
       end
 
+      should "not care about symbols or strings in composite keys" do
+        @document = Results::Item.new :highlight => { 'name.ngrams' => 'abc' }
+
+        assert_not_nil @document.highlight['name.ngrams']
+        assert_equal   'abc', @document.highlight['name.ngrams']
+        assert_equal   @document.highlight['name.ngrams'], @document.highlight['name.ngrams'.to_sym]
+      end
+
       should "allow to retrieve values from nested hashes" do
         assert_not_nil   @document.author.name
         assert_equal 'Kafka', @document.author.name

data/test/unit/search_facet_test.rb

@@ -137,6 +137,15 @@ module Tire::Search
         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

data/test/unit/search_query_test.rb

@@ -5,26 +5,33 @@ 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 => 'bar' } }, Query.new.term(:foo, 'bar').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 => 'bar' } }.to_json, Query.new 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 => 'bar' } }, Query.new.term(:foo, 'bar') )
+        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
@@ -33,11 +40,15 @@ module Tire::Search
         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
@@ -46,7 +57,9 @@ module Tire::Search
         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') )
@@ -66,7 +79,9 @@ module Tire::Search
         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'
@@ -84,15 +99,30 @@ module Tire::Search
         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
 
@@ -159,7 +189,6 @@ module Tire::Search
 
     end
 
-
     context "FilteredQuery" do
 
       should "not raise an error when no block is given" do
@@ -173,7 +202,7 @@ module Tire::Search
         end
 
         query[:filtered].tap do |f|
-          assert_equal( { :term => { :foo => 'bar' } }, f[:query].to_hash )
+          assert_equal( { :term => { :foo => { :term => 'bar' } } }, f[:query].to_hash )
           assert_equal( { :tags => ['ruby'] }, f[:filter][:and].first[:terms] )
         end
       end
@@ -202,7 +231,7 @@ module Tire::Search
         end
 
         query[:filtered].tap do |f|
-          assert_equal( { :term => { :foo => 'bar' } }, f[:query].to_hash )
+          assert_equal( { :term => { :foo => { :term => 'bar' } } }, f[:query].to_hash )
           assert_equal( { :tags => ['ruby'] }, f[:filter][:and].first[:terms] )
         end
       end

data/test/unit/search_test.rb

@@ -35,6 +35,48 @@ module Tire
         assert_match %r|index/bar/_search|, s.url
       end
 
+      should "allow to pass search parameters" do
+        s = Search::Search.new('index', :routing => 123, :timeout => 1) { query { string 'foo' } }
+
+        assert  ! s.params.empty?
+
+        assert_match %r|routing=123|, s.params
+        assert_match %r|timeout=1|,   s.params
+      end
+
+      should "encode search parameters in the request" do
+        Configuration.client.expects(:get).with do |url, payload|
+          url.include? 'routing=123&timeout=1'
+        end.returns mock_response( { 'hits' => { 'hits' => [ {:_id => 1} ] } }.to_json )
+
+        Search::Search.new('index', :routing => 123, :timeout => 1) { query { string 'foo' } }.perform
+      end
+
+      should "encode missing params as an empty string" do
+        Configuration.client.expects(:get).with do |url, payload|
+          (! url.include? '?') && (! url.include? '&')
+        end.returns mock_response( { 'hits' => { 'hits' => [ {:_id => 1} ] } }.to_json )
+
+        s = Search::Search.new('index') { query { string 'foo' } }
+        s.perform
+
+        assert_equal '', s.params
+      end
+
+      should "properly encode namespaced document type" do
+        Configuration.client.expects(:get).with do |url, payload|
+          url.match %r|index/my_application%2Farticle/_search|
+        end.returns mock_response( { 'hits' => { 'hits' => [ {:_id => 1} ] } }.to_json )
+
+        s = Search::Search.new('index', :type => 'my_application/article') do
+          query { string 'foo' }
+        end
+        s.perform
+
+        assert_match %r|index/my_application%2Farticle/_search|, s.url
+        assert_match %r|index/my_application%2Farticle/_search|, s.to_curl
+      end
+
       should "allow to pass block to query" do
         Search::Query.any_instance.expects(:instance_eval)
 
@@ -180,7 +222,7 @@ module Tire
           hash = MultiJson.decode( s.to_json )
           assert_equal [{'title' => 'desc'}, '_score'], hash['sort']
         end
-        
+
       end
 
       context "facets" do
@@ -343,6 +385,33 @@ module Tire
 
       end
 
+      context "explain" do
+
+        should "default to false" do
+          s = Search::Search.new('index') do
+          end
+          hash = MultiJson.decode( s.to_json )
+          assert_nil hash['explain']
+        end
+
+        should "set the explain field in the request when true" do
+          s = Search::Search.new('index') do
+            explain true
+          end
+          hash = MultiJson.decode( s.to_json )
+          assert_equal true, hash['explain']
+        end
+
+        should "not set the explain field when false" do
+          s = Search::Search.new('index') do
+            explain false
+          end
+          hash = MultiJson.decode( s.to_json )
+          assert_nil hash['explain']
+        end
+
+      end
+
       context "boolean queries" do
 
         should "wrap other queries" do

data/test/unit/tire_test.rb

@@ -23,21 +23,17 @@ module Tire
         end
 
         should "allow searching with a Ruby Hash" do
-          Tire::Configuration.client.expects(:post).
-            with('http://localhost:9200/dummy/_search','{"query":{"query_string":{"query":"foo"}}}').
-            returns( mock_response('{}') )
-          Tire::Results::Collection.expects(:new)
+          payload = { :query => { :query_string => { :query => 'foo' } } }
+          Search::Search.expects(:new).with('dummy', :payload => payload).returns( stub(:perform => true) )
 
-          Tire.search 'dummy', :query => { :query_string => { :query => 'foo' }}
+          Tire.search 'dummy', payload
         end
 
         should "allow searching with a JSON string" do
-          Tire::Configuration.client.expects(:post).
-            with('http://localhost:9200/dummy/_search','{"query":{"query_string":{"query":"foo"}}}').
-            returns( mock_response('{}') )
-          Tire::Results::Collection.expects(:new)
+          payload = '{"query":{"query_string":{"query":"foo"}}}'
+          Search::Search.expects(:new).with('dummy', :payload => payload).returns( stub(:perform => true) )
 
-          Tire.search 'dummy', '{"query":{"query_string":{"query":"foo"}}}'
+          Tire.search 'dummy', payload
         end
 
         should "raise an error when passed incorrect payload" do
@@ -48,8 +44,8 @@ module Tire
 
         should "raise SearchRequestFailed when receiving bad response from backend" do
           assert_raise(Search::SearchRequestFailed) do
-            Tire::Configuration.client.expects(:post).returns( mock_response('INDEX DOES NOT EXIST', 404) )
-            Tire.search 'not-existing', :query => { :query_string => { :query => 'foo' }}
+            Tire::Configuration.client.expects(:get).returns( mock_response('INDEX DOES NOT EXIST', 404) )
+            Tire.search('not-existing', :query => { :query_string => { :query => 'foo' }}).results
           end
         end
 
@@ -70,6 +66,21 @@ module Tire
 
       end
 
+      context "utils" do
+
+        should "encode a string for URL" do
+          assert_equal 'foo+bar',   Utils.escape('foo bar')
+          assert_equal 'foo%2Fbar', Utils.escape('foo/bar')
+          assert_equal 'foo%21',    Utils.escape('foo!')
+        end
+
+        should "encode a string from URL" do
+          assert_equal 'foo bar', Utils.unescape('foo+bar')
+          assert_equal 'foo/bar', Utils.unescape('foo%2Fbar')
+          assert_equal 'foo!',    Utils.unescape('foo%21')
+        end
+
+      end
     end
 
   end

data/tire.gemspec

@@ -28,27 +28,30 @@ Gem::Specification.new do |s|
   #
   s.add_dependency "rake"
   s.add_dependency "rest-client", "~> 1.6.0"
-  s.add_dependency "multi_json",  "~> 1.0"
-  s.add_dependency "activemodel", "~> 3.0"
-  s.add_dependency "hashr",       "~> 0.0.16"
+  s.add_dependency "multi_json",  "~> 1.1"
+  s.add_dependency "activemodel", ">= 3.0"
+  s.add_dependency "hashr",       "~> 0.0.19"
+  s.add_dependency "rack",        ">= 1.4" if defined?(RUBY_VERSION) && RUBY_VERSION < '1.9'
 
   # = Development dependencies
   #
-  s.add_development_dependency "bundler",     "~> 1.0"
+  s.add_development_dependency "bundler",     ">= 1.1"
   s.add_development_dependency "yajl-ruby",   "~> 0.8.0"
   s.add_development_dependency "shoulda"
   s.add_development_dependency "mocha"
-  s.add_development_dependency "activerecord", "~> 3"
-  s.add_development_dependency "mongoid",      "~> 2.2.1"
+  s.add_development_dependency "activerecord", ">= 3.0"
   s.add_development_dependency "sqlite3"
-  s.add_development_dependency "supermodel",   "~> 0.1.6"
+  s.add_development_dependency "mongoid",      "~> 2.2.1"
+  s.add_development_dependency "bson_ext"
+  s.add_development_dependency "redis-persistence"
   s.add_development_dependency "curb"
+  s.add_development_dependency "minitest"
 
   # These gems are not needed for CI at <http://travis-ci.org/#!/karmi/tire>
   #
   unless ENV["CI"]
     s.add_development_dependency "rdoc"
-    s.add_development_dependency "turn", "~> 0.9"
+    s.add_development_dependency "turn", "~> 0.9" if defined?(RUBY_VERSION) && RUBY_VERSION > '1.9'
   end
 
   s.description = <<-DESC