tire-erez 0.5.4

data/test/unit/multi_search_test.rb

@@ -0,0 +1,304 @@
+require 'test_helper'
+
+module Tire
+  class MultiSearchTest < Test::Unit::TestCase
+
+    context "Multi::Search" do
+      setup { Configuration.reset }
+
+      should "be initialized with index" do
+        @search = Tire::Search::Multi::Search.new 'foo'
+        assert_equal ['foo'], @search.indices
+      end
+
+      context "search definition" do
+        setup do
+          @search_definitions = Tire::Search::Multi::SearchDefinitions.new
+        end
+
+        should "be enumerable" do
+          assert_respond_to @search_definitions, :each
+          assert_respond_to @search_definitions, :size
+        end
+
+        should "allow to add definition" do
+          @search_definitions << { :name => 'foo', :search => { 'query' => 'bar' } }
+          assert_equal 1, @search_definitions.size
+        end
+
+        should "return definition" do
+          @search_definitions << { :name => 'foo', :search => { 'query' => 'bar' } }
+          assert_equal 'bar', @search_definitions['foo']['query']
+        end
+
+        should "have names" do
+          @search_definitions << { :name => 'foo', :search => { 'query' => 'bar' } }
+          assert_equal ['foo'], @search_definitions.names
+        end
+      end
+
+      context "search results" do
+        setup do
+          @search_definitions = Tire::Search::Multi::SearchDefinitions.new
+          @search_definitions << { :name => 'foo', :search => Tire::Search::Search.new }
+          @responses          = [{ 'hits' => { 'hits' => [{'_id' => 1},
+                                                          {'_id' => 2},
+                                                          {'_id' => 3}] }
+                                }]
+
+          @results = Tire::Search::Multi::Results.new @search_definitions, @responses
+        end
+
+        should "be enumerable" do
+          assert_respond_to @results, :each
+          assert_respond_to @results, :each_pair
+          assert_respond_to @results, :each_with_index
+          assert_respond_to @results, :size
+        end
+
+        should "return named results" do
+          assert_instance_of Tire::Results::Collection, @results['foo']
+          assert_equal 1, @results['foo'].first.id
+        end
+
+        should "return nil for incorrect index" do
+          assert_nil @results['moo']
+          assert_nil @results[999]
+        end
+
+        should "iterate over results" do
+          @results.each do |results|
+            assert_instance_of Tire::Results::Collection, results
+          end
+        end
+
+        should "iterate over named results" do
+          @results.each_pair do |name, results|
+            assert_equal       'foo', name
+            assert_instance_of Tire::Results::Collection, results
+          end
+        end
+
+        should "be serializable to Hash" do
+          assert_instance_of Tire::Results::Collection, @results.to_hash['foo']
+        end
+
+        should "pass search options to collection" do
+          @search_definitions = Tire::Search::Multi::SearchDefinitions.new
+          @search_definitions << { :name => 'foo', :search => Tire::Search::Search.new(nil, :foo => 'bar') }
+          @responses          = [{ 'hits' => { 'hits' => [{'_id' => 1}] } }]
+
+          @results = Tire::Search::Multi::Results.new @search_definitions, @responses
+
+          assert_equal 'bar', @results['foo'].options[:foo]
+        end
+
+        context "error responses" do
+          setup do
+            @search_definitions = Tire::Search::Multi::SearchDefinitions.new
+            @search_definitions << { :name => 'foo', :search => Tire::Search::Search.new }
+            @search_definitions << { :name => 'xoo', :search => Tire::Search::Search.new }
+            @responses          = [{ 'hits' => { 'hits' => [{'_id' => 1},
+                                                            {'_id' => 2},
+                                                            {'_id' => 3}] }
+                                   },
+                                   {'error' => 'SearchPhaseExecutionException ...'}
+                                  ]
+
+            @results = Tire::Search::Multi::Results.new @search_definitions, @responses
+          end
+
+          should "return success/failure state" do
+            assert_equal true, @results['foo'].success?
+            assert_equal 3,    @results['foo'].size
+            assert_equal true, @results['xoo'].failure?
+          end
+        end
+      end
+
+      context "URL" do
+
+        should "have no index and type by default" do
+          @search = Tire::Search::Multi::Search.new
+          assert_equal '/_msearch', @search.path
+        end
+
+        should "have an index" do
+          @search = Tire::Search::Multi::Search.new 'foo'
+          assert_equal '/foo/_msearch', @search.path
+        end
+
+        should "have multiple indices" do
+          @search = Tire::Search::Multi::Search.new ['foo', 'bar']
+          assert_equal '/foo,bar/_msearch', @search.path
+        end
+
+        should "have index and type" do
+          @search = Tire::Search::Multi::Search.new 'foo', :type => 'bar'
+          assert_equal '/foo/bar/_msearch', @search.path
+        end
+
+        should "have index and multiple types" do
+          @search = Tire::Search::Multi::Search.new 'foo', :type => ['bar', 'bam']
+          assert_equal '/foo/bar,bam/_msearch', @search.path
+        end
+
+        should "contain host" do
+          @search = Tire::Search::Multi::Search.new
+          assert_equal 'http://localhost:9200/_msearch', @search.url
+        end
+
+      end
+
+      context "URL params" do
+
+        should "be empty when no params passed" do
+          @search = Tire::Search::Multi::Search.new 'foo'
+          assert_equal '', @search.params
+        end
+
+        should "serialize parameters" do
+          @search = Tire::Search::Multi::Search.new 'foo', :search_type => 'count'
+          assert_equal '?search_type=count', @search.params
+        end
+
+      end
+
+      context "search request" do
+        setup do
+          @search = Tire::Search::Multi::Search.new
+        end
+
+        should "have a collection of searches" do
+          @search.search :one
+          assert_instance_of Tire::Search::Multi::SearchDefinitions, @search.searches
+        end
+
+        should "be initialized with name" do
+          @search.search :one
+          assert_instance_of Tire::Search::Search, @search.searches[:one]
+        end
+
+        should "be initialized with options" do
+          @search.search :foo => 'bar'
+          assert_equal 'bar', @search.searches[0].options[:foo]
+        end
+
+        should "be initialized with name and options" do
+          @search.search :one, :foo => 'bar'
+          assert_instance_of Tire::Search::Search, @search.searches[:one]
+          assert_equal 'bar', @search.searches[:one].options[:foo]
+          assert_equal 'bar', @search.searches(:one).options[:foo]
+        end
+
+        should "pass the index name and options to the search object" do
+          @search.search :index => 'foo', :type => 'bar'
+          assert_equal ['foo'], @search.searches[0].indices
+          assert_equal ['bar'], @search.searches[0].types
+          assert_equal ['foo'], @search.searches(0).indices
+        end
+
+        should "pass options to Search object" do
+          @search.search :search_type => 'count'
+          assert_equal 'count', @search.searches[0].options[:search_type]
+        end
+
+      end
+
+      context "payload" do
+
+        should "serialize search payload header and body as Array" do
+          @search = Tire::Search::Multi::Search.new do
+            search :index => 'foo' do
+              query { all }
+              size 100
+            end
+          end
+
+          assert_equal 1, @search.searches.size
+          assert_equal 2, @search.to_array.size
+
+          assert_equal( 'foo', @search.to_array[0][:index] )
+          assert_equal( {:match_all => {}}, @search.to_array[1][:query] )
+          assert_equal( 100,   @search.to_array[1][:size] )
+        end
+
+        should "serialize search payload header and body for multiple searches" do
+          @search = Tire::Search::Multi::Search.new do
+            search(:index => 'foo') { query { all } }
+            search(:index => 'ooo') { query { term :foo, 'bar' } }
+          end
+
+          assert_equal 2, @search.searches.size
+          assert_equal 4, @search.to_array.size
+
+          assert_equal 'foo', @search.to_array[0][:index]
+          assert_equal 'ooo', @search.to_array[2][:index]
+          assert_equal 'match_all', @search.to_array[1][:query].keys.first.to_s
+          assert_equal 'term',      @search.to_array[3][:query].keys.first.to_s
+        end
+
+        should "serialize search parameters" do
+          @search = Tire::Search::Multi::Search.new do
+            search(:search_type => 'count') { query { all } }
+          end
+
+          assert_equal 'count', @search.to_array[0][:search_type]
+        end
+
+        should "serialize search payload as a string" do
+          @search = Tire::Search::Multi::Search.new do
+            search(:index => 'foo') { query { all } }
+          end
+
+          assert_equal 2, @search.to_payload.split("\n").size
+        end
+
+        should "end with a new line" do
+          @search = Tire::Search::Multi::Search.new { search(:index => 'foo') { query { all } } }
+          assert_match /.*\n$/, @search.to_payload
+        end
+
+        should "leave header empty when no index is passed" do
+          @search = Tire::Search::Multi::Search.new do
+            search() { query { all } }
+          end
+
+          assert_equal( {}, @search.to_array.first )
+        end
+
+      end
+
+      context "perform" do
+        setup do
+          @search = Tire::Search::Multi::Search.new do
+            search(:index => 'foo') do
+              query { all }
+              size 100
+            end
+          end
+          @response = mock_response '{ "responses" : [{"took":1,"hits":{"total":0,"hits":[]}}] }', 200
+        end
+
+        should "perform the request" do
+          Configuration.client.expects(:get).
+            with do |url, payload|
+              assert_equal 'http://localhost:9200/_msearch', url
+              assert       payload.include?('match_all')
+            end.
+            returns(@response)
+          @search.perform
+        end
+
+        should "log the request" do
+          Configuration.client.expects(:get).returns(@response)
+          @search.expects(:logged)
+          @search.perform
+        end
+
+      end
+
+    end
+
+  end
+end

data/test/unit/results_collection_test.rb

@@ -0,0 +1,372 @@
+require 'test_helper'
+
+module Tire
+
+  class ResultsCollectionTest < Test::Unit::TestCase
+
+    context "Collection" do
+      setup do
+        begin; Object.send(:remove_const, :Rails); rescue; end
+        Configuration.reset
+        @default_response = { 'hits' => { 'hits' => [{'_id' => 1, '_score' => 1, '_source' => {:title => 'Test', :author => 'John'}},
+                                                     {'_id' => 2},
+                                                     {'_id' => 3}],
+                                          'max_score' => 1.0 } }
+      end
+
+      should "be iterable" do
+        assert_respond_to Results::Collection.new(@default_response), :each
+        assert_respond_to Results::Collection.new(@default_response), :size
+        assert_nothing_raised do
+          Results::Collection.new(@default_response).each { |item| item.id + 1 }
+          Results::Collection.new(@default_response).map  { |item| item.id + 1 }
+        end
+      end
+
+      should "have size/length" do
+        assert_equal 3, Results::Collection.new(@default_response).size
+        assert_equal 3, Results::Collection.new(@default_response).length
+      end
+
+      should "allow access to items" do
+        assert_not_nil  Results::Collection.new(@default_response)[1]
+        assert_equal 2, Results::Collection.new(@default_response)[1][:id]
+      end
+
+      should "allow slicing" do
+        assert_equal [2,3], Results::Collection.new(@default_response)[1,2].map  {|res| res[:id]}
+        assert_equal [3],   Results::Collection.new(@default_response)[-1,1].map {|res| res[:id]}
+      end
+
+      should "be initialized with parsed JSON" do
+        assert_nothing_raised do
+          collection = Results::Collection.new( @default_response )
+          assert_equal 3, collection.results.count
+        end
+      end
+
+      should "return success/failure state" do
+        assert Results::Collection.new( @default_response ).success?
+      end
+
+      should "be populated lazily" do
+        collection = Results::Collection.new(@default_response)
+        assert_nil collection.instance_variable_get(:@results)
+      end
+
+      should "store passed options" do
+        collection = Results::Collection.new( @default_response, :per_page => 20, :page => 2 )
+        assert_equal 20, collection.options[:per_page]
+        assert_equal 2,  collection.options[:page]
+      end
+
+      should "be will_paginate compatible" do
+        collection = Results::Collection.new(@default_response)
+        %w(total_pages offset current_page per_page total_entries).each do |method|
+          assert_respond_to collection, method
+        end
+      end
+
+      should "be kaminari compatible" do
+        collection = Results::Collection.new(@default_response)
+        %w(limit_value total_count num_pages offset_value first_page? last_page?).each do |method|
+          assert_respond_to collection, method
+        end
+      end
+
+      should "have max_score" do
+        collection = Results::Collection.new(@default_response)
+        assert_equal 1.0, collection.max_score
+      end
+
+      context "serialization" do
+
+        should "be serialized to JSON" do
+          collection = Results::Collection.new(@default_response)
+          assert_instance_of Array, collection.as_json
+          assert_equal 'Test', collection.as_json.first['title']
+          assert_equal 'John', collection.as_json.first['author']
+        end
+
+        should "pass options to as_json" do
+          collection = Results::Collection.new(@default_response)
+          assert_equal 'Test', collection.as_json(:only => 'title').first['title']
+          assert_nil           collection.as_json(:only => 'title').first['author']
+        end
+
+      end
+
+      context "with error response" do
+        setup do
+          @collection = Results::Collection.new({'error' => 'SearchPhaseExecutionException...'})
+        end
+
+        should "return the error" do
+          assert_equal 'SearchPhaseExecutionException...', @collection.error
+        end
+
+        should "return the success/failure state" do
+          assert @collection.failure?
+        end
+
+        should "return empty results" do
+          assert @collection.empty?
+        end
+      end
+
+      context "wrapping results" do
+
+        setup do
+          @response = { 'hits' => { 'hits' => [ { '_id' => 1, '_score' => 0.5, '_index' => 'testing', '_type' => 'article', '_source' => { :title => 'Test', :body => 'Lorem' } } ] } }
+        end
+
+        should "wrap hits in Item by default" do
+          document =  Results::Collection.new(@response).first
+          assert_kind_of Results::Item, document
+          assert_equal 'Test', document.title
+        end
+
+        should "NOT allow access to raw underlying Hash in Item" do
+          document = Results::Collection.new(@response).first
+          assert_nil document[:_source]
+          assert_nil document['_source']
+        end
+
+        should "allow wrapping hits in a Hash" do
+          Configuration.wrapper(Hash)
+
+          document =  Results::Collection.new(@response).first
+          assert_kind_of Hash, document
+          assert_raise(NoMethodError) { document.title }
+          assert_equal   'Test', document['_source'][:title]
+        end
+
+        should "allow wrapping hits in custom class" do
+          Configuration.wrapper(Article)
+
+          article =  Results::Collection.new(@response).first
+          assert_kind_of Article, article
+          assert_equal   'Test',  article.title
+        end
+
+        should "return score" do
+          document =  Results::Collection.new(@response).first
+          assert_equal 0.5, document._score
+        end
+
+        should "return id" do
+          document =  Results::Collection.new(@response).first
+          assert_equal 1, document.id
+        end
+
+        should "return index" do
+          document =  Results::Collection.new(@response).first
+          assert_equal "testing", document._index
+        end
+
+        should "return type" do
+          document =  Results::Collection.new(@response).first
+          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
+        # When limiting fields from _source to return ES returns them prefixed, not as "real" Hashes.
+        # Underlying issue: https://github.com/karmi/tire/pull/31#issuecomment-1340967
+        #
+        setup do
+          Configuration.reset
+          @default_response = { 'hits' => { 'hits' =>
+            [ { '_id' => 1, '_score' => 0.5, '_index' => 'testing', '_type' => 'article',
+                'fields' => {
+                  'title'       => 'Knee Deep in JSON',
+                  'crazy.field' => 'CRAAAAZY!',
+                  '_source.artist' => {
+                    'name' => 'Elastiq',
+                    'meta' => {
+                      'favorited' => 1000,
+                      'url'       => 'http://first.fm/abc123/xyz567'
+                    }
+                  },
+                  '_source.track.info.duration' => {
+                    'minutes' => 3
+                  }
+                } } ] } }
+          collection = Results::Collection.new(@default_response)
+          @item      = collection.first
+        end
+
+        should "return fields from the first level" do
+          assert_equal 'Knee Deep in JSON', @item.title
+        end
+
+        should "return fields from the _source prefixed and nested fields" do
+          assert_equal 'Elastiq', @item.artist.name
+          assert_equal 1000,      @item.artist.meta.favorited
+          assert_equal 3,         @item.track.info.duration.minutes
+        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' } } ] } }
+
+          Results::Collection.new(response).each_with_hit do |result, hit|
+            assert_instance_of Tire::Results::Item, result
+            assert_instance_of Hash, hit
+            assert_equal 'Test',   result.title
+            assert_equal 0.5, hit['_score']
+          end
+        end
+
+        should "yield the model instance and the raw hit" do
+          response = { 'hits' => { 'hits' => [ {'_id' => 1, '_score' => 0.5, '_type' => 'active_record_article'} ] } }
+
+          ActiveRecord::Base.establish_connection( :adapter => 'sqlite3', :database => ":memory:" )
+          ActiveRecord::Migration.verbose = false
+          ActiveRecord::Schema.define(:version => 1) { create_table(:active_record_articles) { |t| t.string(:title) } }
+          model = ActiveRecordArticle.new(:title => 'Test'); model.id = 1
+
+          ActiveRecordArticle.expects(:find).with([1]).returns([ model] )
+
+          Results::Collection.new(response, :load => true).each_with_hit do |result, hit|
+            assert_instance_of ActiveRecordArticle, result
+            assert_instance_of Hash, hit
+            assert_equal 'Test',   result.title
+            assert_equal 0.5, hit['_score']
+          end
+
+        end
+
+
+      end
+
+      context "while paginating results" do
+
+        setup do
+          @default_response = { 'hits' => { 'hits' => [{'_id' => 1, '_score' => 1, '_source' => {:title => 'Test'}},
+                                                       {'_id' => 2},
+                                                       {'_id' => 3},
+                                                       {'_id' => 4}],
+                                            'total' => 4 },
+                                'took' => 1 }
+          @collection = Results::Collection.new( @default_response, :per_page => 1, :page => 2 )
+        end
+
+        should "return total entries" do
+          assert_equal 4, @collection.total
+          assert_equal 4, @collection.total_entries
+        end
+
+        should "return total pages" do
+          assert_equal 4, @collection.total_pages
+          @collection = Results::Collection.new( @default_response, :per_page => 2, :page => 2 )
+          assert_equal 2, @collection.total_pages
+          @collection = Results::Collection.new( @default_response, :per_page => 3, :page => 2 )
+          assert_equal 2, @collection.total_pages
+        end
+
+        should "return total pages when per_page option not set" do
+          collection = Results::Collection.new( @default_response, :page => 1 )
+          assert_equal 1, collection.total_pages
+        end
+
+        should "return current page" do
+          assert_equal 2, @collection.current_page
+        end
+
+        should "return current page for empty result" do
+          collection = Results::Collection.new( { 'hits' => { 'hits' => [], 'total' => 0 } } )
+          assert_equal 1, collection.current_page
+        end
+
+        should "return previous page" do
+          assert_equal 1, @collection.previous_page
+        end
+
+        should "return next page" do
+          assert_equal 3, @collection.next_page
+        end
+
+        should "have default per_page" do
+          assert_equal 10, Tire::Results::Pagination::default_per_page
+
+          collection = Results::Collection.new @default_response
+          assert_equal 10, collection.per_page
+        end
+
+      end
+
+      context "with eager loading" do
+        setup do
+          @response = { 'hits' => { 'hits' => [ {'_id' => 1, '_type' => 'active_record_article'},
+                                                {'_id' => 2, '_type' => 'active_record_article'},
+                                                {'_id' => 3, '_type' => 'active_record_article'}] } }
+          ActiveRecordArticle.stubs(:inspect).returns("<ActiveRecordArticle>")
+        end
+
+        should "load the records via model find method from database" do
+          ActiveRecordArticle.expects(:find).with([1,2,3]).
+                              returns([ Results::Item.new(:id => 3),
+                                        Results::Item.new(:id => 1),
+                                        Results::Item.new(:id => 2)  ])
+          Results::Collection.new(@response, :load => true).results
+        end
+
+        should "pass the :load option Hash to model find metod" do
+          ActiveRecordArticle.expects(:find).with([1,2,3], :include => 'comments').
+                              returns([ Results::Item.new(:id => 3),
+                                        Results::Item.new(:id => 1),
+                                        Results::Item.new(:id => 2)  ])
+          Results::Collection.new(@response, :load => { :include => 'comments' }).results
+        end
+
+        should "preserve the order of records returned from search" do
+          ActiveRecordArticle.expects(:find).with([1,2,3]).
+                              returns([ Results::Item.new(:id => 3),
+                                        Results::Item.new(:id => 1),
+                                        Results::Item.new(:id => 2)  ])
+          assert_equal [1,2,3], Results::Collection.new(@response, :load => true).results.map(&:id)
+        end
+
+        should "raise error when model class cannot be inferred from _type" do
+          assert_raise(NameError) do
+            response = { 'hits' => { 'hits' => [ {'_id' => 1, '_type' => 'hic_sunt_leones'}] } }
+            Results::Collection.new(response, :load => true).results
+          end
+        end
+
+        should "raise error when _type is missing" do
+          assert_raise(NoMethodError) do
+            response = { 'hits' => { 'hits' => [ {'_id' => 1}] } }
+            Results::Collection.new(response, :load => true).results
+          end
+        end
+
+        should "return empty array for empty hits" do
+          response = { 'hits'  => {
+                         'hits' => [],
+                         'total' => 4
+                       },
+                       'took'  => 1 }
+          @collection = Results::Collection.new( response, :load => true )
+          assert @collection.empty?, 'Collection should be empty'
+          assert @collection.results.empty?, 'Collection results should be empty'
+          assert_equal 0, @collection.size
+        end
+
+      end
+
+    end
+
+  end
+
+end