tire 0.5.8 → 0.6.0

data/test/unit/model_import_test.rb

@@ -67,6 +67,23 @@ module Tire
           ImportModel.import :index => 'new_index'
         end
 
+        context 'Strategy' do
+          class ::CustomImportStrategy
+            include Tire::Model::Import::Strategy::Base
+          end
+
+          should 'return explicitly specified strategy from predefined strategies' do
+            strategy = Tire::Model::Import::Strategy.from_class(ImportModel, :strategy => 'WillPaginate')
+            assert_equal strategy.class.name, 'Tire::Model::Import::Strategy::WillPaginate'
+          end
+
+          should 'return custom strategy class' do
+            strategy = Tire::Model::Import::Strategy.from_class(ImportModel, :strategy => 'CustomImportStrategy')
+            assert_equal strategy.class.name, 'CustomImportStrategy'
+          end
+
+        end
+
       end
 
     end

data/test/unit/model_initialization_test.rb

@@ -12,6 +12,11 @@ class ModelWithIncorrectMapping
   end
 end
 
+class MyModelForIndexCreate
+  extend  ActiveModel::Naming
+  include Tire::Model::Search
+end
+
 module Tire
   module Model
 
@@ -19,10 +24,44 @@ module Tire
 
       context "Model initialization" do
 
-        should "display a warning when creating the index fails" do
-          STDERR.expects(:puts)
-          result = ModelWithIncorrectMapping.create_elasticsearch_index
-          assert ! result, result.inspect
+        should "display a warning and not raise exception when creating the index fails" do
+          assert_nothing_raised do
+            STDERR.expects(:puts)
+            result = ModelWithIncorrectMapping.create_elasticsearch_index
+            assert ! result, result.inspect
+          end
+        end
+
+        should "re-raise non-connection related exceptions" do
+          Tire::Index.any_instance.expects(:exists?).raises(ZeroDivisionError)
+
+          assert_raise(ZeroDivisionError) do
+            result = MyModelForIndexCreate.create_elasticsearch_index
+            assert ! result, result.inspect
+          end
+        end
+
+        unless defined?(Curl)
+
+          should "display a warning and not raise exception when cannot connect to Elasticsearch (default client)" do
+            Tire::Index.any_instance.expects(:exists?).raises(Errno::ECONNREFUSED)
+            assert_nothing_raised do
+              STDERR.expects(:puts)
+              result = MyModelForIndexCreate.create_elasticsearch_index
+              assert ! result, result.inspect
+            end
+          end
+
+        else
+          should "display a warning and not raise exception when cannot connect to Elasticsearch (Curb client)" do
+            Tire::Index.any_instance.expects(:exists?).raises(::Curl::Err::HostResolutionError)
+            assert_nothing_raised do
+              STDERR.expects(:puts)
+              result = MyModelForIndexCreate.create_elasticsearch_index
+              assert ! result, result.inspect
+            end
+          end
+
         end
 
       end

data/test/unit/results_collection_test.rb

@@ -79,6 +79,11 @@ module Tire
         assert_equal 1.0, collection.max_score
       end
 
+      should "return an array" do
+        collection = Results::Collection.new(@default_response)
+        assert_instance_of Array, collection.to_ary
+      end
+
       context "serialization" do
 
         should "be serialized to JSON" do
@@ -215,6 +220,32 @@ module Tire
 
       end
 
+      context "using fields when also returning the _source" do
+        setup do
+          Configuration.reset
+          @default_response = { 'hits' => { 'hits' =>
+            [ { '_id' => 1, '_score' => 0.5, '_index' => 'testing', '_type' => 'article',
+                '_source' => {
+                  'title' => 'Knee Deep in JSON'
+                },
+                'fields' => {
+                  '_parent' => '4f99f98ea2b279ec3d002522'
+                }
+              }
+            ] } }
+          collection = Results::Collection.new(@default_response)
+          @item      = collection.first
+        end
+
+        should "return an individual field" do
+          assert_equal '4f99f98ea2b279ec3d002522', @item._parent
+        end
+
+        should "return fields from the _source as well" do
+          assert_equal 'Knee Deep in JSON', @item.title
+        end
+      end
+
       context "returning results with hits" do
         should "yield the Item result and the raw hit" do
           response = { 'hits' => { 'hits' => [ { '_id' => 1, '_score' => 0.5, '_index' => 'testing', '_type' => 'article', '_source' => { :title => 'Test', :body => 'Lorem' } } ] } }
@@ -362,7 +393,38 @@ module Tire
           assert @collection.results.empty?, 'Collection results should be empty'
           assert_equal 0, @collection.size
         end
+      end
+
+      context "with ActiveModel::Serializers" do
+        setup do
+          require 'active_model_serializers'
+
+          Tire::Results::Collection.send :include, ActiveModel::ArraySerializerSupport
 
+          class ::MyItemWithSerializer < Tire::Results::Item
+            include ActiveModel::SerializerSupport
+
+            def active_model_serializer
+              ::MyItemSerializer
+            end
+          end
+
+          class ::MyItemSerializer < ActiveModel::Serializer
+            attribute :title,  :key => :name
+            attribute :author, :key => :owner
+          end
+        end
+
+        should "be serializable" do
+          assert_nothing_raised do
+            collection = Results::Collection.new(@default_response, :wrapper => ::MyItemWithSerializer)
+            serializer = collection.active_model_serializer.new(collection)
+
+            hash = serializer.as_json.first
+            assert_equal 'Test',    hash[:name]
+            assert_equal 'John', hash[:owner]
+          end
+        end
       end
 
     end

data/test/unit/results_item_test.rb

@@ -20,7 +20,7 @@ module Tire
                                       :awards  => { :best_fiction => { :year => '1925' } },
                                       :reviews => [ { :stars => 5, :comment => 'great' },
                                                     { :stars => 3, :comment => 'decent' } ]
-                                                     
+
       end
 
       should "be initialized with a Hash or Hash like object" do
@@ -63,6 +63,15 @@ module Tire
         assert_equal 'Kafka', @document[:author][:name]
       end
 
+      should "retrieve simple values from read_attribute_for_serialization" do
+        assert_equal 'Test', @document.read_attribute_for_serialization(:title)
+      end
+
+      should "retrieve hash values from read_attribute_for_serialization" do
+        assert_equal 'Kafka', @document.read_attribute_for_serialization(:author)[:name]
+      end
+
+
       should "allow to retrieve value by methods" do
         assert_not_nil @document.title
         assert_equal 'Test', @document.title
@@ -171,6 +180,35 @@ module Tire
 
       end
 
+      context "with ActiveModel::Serializers" do
+        setup do
+          require 'active_model_serializers'
+
+          class ::MyItemWithSerializer < Tire::Results::Item
+            include ActiveModel::SerializerSupport
+          end
+          class ::MyItemSerializer < ActiveModel::Serializer
+            attribute :tags
+            attribute :title, :key => :name
+
+            def tags
+              object.tags.join('-')
+            end
+          end
+        end
+
+        should "be serializable" do
+          assert_nothing_raised do
+            doc = ::MyItemWithSerializer.new :title => 'Test', :tags => ['foo', 'bar']
+            doc_serializer = ::MyItemSerializer.new(doc)
+
+            hash = doc_serializer.as_json
+            assert_equal 'Test',    hash[:my_item][:name]
+            assert_equal 'foo-bar', hash[:my_item][:tags]
+          end
+        end
+      end
+
     end
 
   end

data/test/unit/search_facet_test.rb

@@ -168,6 +168,21 @@ module Tire::Search
         end
       end
 
+      context "geo_distance facet" do
+        should "encode facet options" do
+          f = Facet.new('geo_distance') { geo_distance :location, {:lat => 50, :lon => 9}, [{:to => 1}] }
+          assert_equal({:geo_distance => {:geo_distance => {:location => {:lat => 50, :lon => 9}, :ranges => [{:to => 1}]}}}.to_json,
+                       f.to_json)
+        end
+
+        should "encode custom options" do
+          f = Facet.new('geo_distance') { geo_distance :location, {:lat => 50, :lon => 9}, [{:to => 1}],
+                                                       :unit => 'km', :value_script => 'doc["field"].value'}
+          assert_equal({:geo_distance => {:geo_distance => {:location => {:lat => 50, :lon => 9}, :ranges => [{:to => 1}],
+                                                            :unit => "km", :value_script => 'doc["field"].value'}}}.to_json, f.to_json)
+        end
+      end
+
       context "filter facet" do
 
         should "encode facet options" do

data/test/unit/search_query_test.rb

@@ -68,17 +68,6 @@ module Tire::Search
       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' } },
@@ -121,6 +110,121 @@ module Tire::Search
       end
     end
 
+    context 'CustomFiltersScoreQuery' do
+      should "not raise an error when no block is given" do
+        assert_nothing_raised { Query.new.custom_filters_score }
+      end
+
+      should "provides a default filter if no filter is given" do
+        query = Query.new.custom_filters_score do
+          query { term :foo, 'bar' }
+        end
+
+        f = query[:custom_filters_score]
+
+        assert_equal( { :term => { :foo => { :term => 'bar' } } }, f[:query].to_hash )
+        assert_equal( { :match_all => {} }, f[:filters].first[:filter])
+        assert_equal( 1.0, f[:filters].first[:boost])
+      end
+
+      should "properly encode filter with boost" do
+        query = Query.new.custom_filters_score do
+          query { term :foo, 'bar' }
+          filter do
+            filter :terms, :tags => ['ruby']
+            boost 2.0
+          end
+        end
+
+        f = query[:custom_filters_score]
+
+        assert_equal( { :term => { :foo => { :term => 'bar' } } }, f[:query].to_hash )
+        assert_equal( { :tags => ['ruby'] }, f[:filters].first[:filter][:terms])
+        assert_equal( 2.0, f[:filters].first[:boost])
+      end
+
+      should "properly encode filter with script" do
+        query = Query.new.custom_filters_score do
+          query { term :foo, 'bar' }
+          filter do
+            filter :terms, :tags => ['ruby']
+            script '2.0'
+          end
+        end
+
+        f = query[:custom_filters_score]
+
+        assert_equal( { :term => { :foo => { :term => 'bar' } } }, f[:query].to_hash )
+        assert_equal( { :tags => ['ruby'] }, f[:filters].first[:filter][:terms])
+        assert_equal( '2.0', f[:filters].first[:script])
+      end
+
+      should "properly encode multiple filters" do
+        query = Query.new.custom_filters_score do
+          query { term :foo, 'bar' }
+          filter do
+            filter :terms, :tags => ['ruby']
+            boost 2.0
+          end
+          filter do
+            filter :terms, :tags => ['python']
+            script '2.0'
+          end
+        end
+
+        f = query[:custom_filters_score]
+
+        assert_equal( { :term => { :foo => { :term => 'bar' } } }, f[:query].to_hash )
+        assert_equal( { :tags => ['ruby'] }, f[:filters].first[:filter][:terms])
+        assert_equal( 2.0, f[:filters].first[:boost])
+        assert_equal( { :tags => ['python'] }, f[:filters].last[:filter][:terms])
+        assert_equal( '2.0', f[:filters].last[:script])
+      end
+
+      should "allow setting the score_mode" do
+        query = Query.new.custom_filters_score do
+          query { term :foo, 'bar' }
+          score_mode 'total'
+        end
+
+        f = query[:custom_filters_score]
+
+        assert_equal( { :term => { :foo => { :term => 'bar' } } }, f[:query].to_hash )
+        assert_equal( 'total', f[:score_mode])
+      end
+
+      should "allow setting params" do
+        query = Query.new.custom_filters_score do
+          query { term :foo, 'bar' }
+          params :a => 'b'
+        end
+
+        f = query[:custom_filters_score]
+
+        assert_equal( { :term => { :foo => { :term => 'bar' } } }, f[:query].to_hash )
+        assert_equal( { :a => 'b' }, f[:params] )
+      end
+
+      should "allow using script parameters" do
+        score_script = "foo * 2"
+
+        query = Query.new.custom_filters_score do
+          query { string 'foo' }
+
+          params :foo => 42
+
+          filter do
+            filter :exists, :field => 'date'
+            script score_script
+          end
+        end
+
+        f = query[:custom_filters_score]
+
+        assert_equal 42, f[:params][:foo]
+      end
+    end
+
     context "All query" do
       should "search for all documents" do
         assert_equal( { :match_all => { } }, Query.new.all )
@@ -133,9 +237,17 @@ module Tire::Search
 
     context "IDs query" do
       should "search for documents by IDs" do
+        assert_equal( { :ids => { :values => [1, 2] }  },
+                      Query.new.ids([1, 2]) )
+      end
+      should "search for documents by IDs and type" do
         assert_equal( { :ids => { :values => [1, 2], :type => 'foo' }  },
                       Query.new.ids([1, 2], 'foo') )
       end
+      should "convert argument to Array" do
+        assert_equal( { :ids => { :values => [1] }  },
+                      Query.new.ids(1) )
+      end
     end
 
     context "FuzzyQuery" do
@@ -430,9 +542,12 @@ module Tire::Search
                       Query.new.constant_score { query { term :attr, 'foo' } } )
       end
 
-      should "wrap filter" do
-        assert_equal( { :constant_score => {:filter => { :term => { :attr => 'foo' } } } },
-                      Query.new.constant_score { filter :term, :attr => 'foo' } )
+      should "wrap multiple filters" do
+        assert_equal( { :constant_score => {:filter => {:and => [ { :term => { :attr => 'foo' } }, { :term => { :attr => 'bar' } } ] } } },
+                      Query.new.constant_score do
+                        filter :term, :attr => 'foo'
+                        filter :term, :attr => 'bar'
+                      end )
       end
 
       should "wrap the boost" do

data/test/unit/tire_test.rb

@@ -41,6 +41,19 @@ module Tire
           end
         end
 
+        should "convert params objects to hash" do
+          class ::MyParamsObject;
+            def initialize(hash)
+              @hash = hash
+            end
+            def to_hash
+              @hash
+            end
+          end
+
+          Tire.search 'dummy', ::MyParamsObject.new(:foo => 'bar')
+        end
+
         should "extract URL parameters from options" do
           payload = { :query => { :match => { :foo => 'bar' } } }
 

data/tire.gemspec

@@ -41,6 +41,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency "mocha",        "~> 0.13"
   s.add_development_dependency "minitest",     "~> 2.12"
   s.add_development_dependency "activerecord", ">= 3.0"
+  s.add_development_dependency "active_model_serializers"
   s.add_development_dependency "mongoid",      "~> 2.2"
   s.add_development_dependency "redis-persistence"
   s.add_development_dependency "faraday"