load_balanced_tire 0.1

data/test/unit/results_collection_test.rb

@@ -0,0 +1,281 @@
+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'}},
+                                                     {'_id' => 2},
+                                                     {'_id' => 3}] } }
+      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 "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 "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).each do |method|
+          assert_respond_to collection, method
+        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 "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
+
+      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

data/test/unit/results_item_test.rb

@@ -0,0 +1,162 @@
+require 'test_helper'
+
+module Tire
+  class ResultsItemTest < Test::Unit::TestCase
+
+    # ActiveModel compatibility tests
+    #
+    def setup
+      super
+      begin; Object.send(:remove_const, :Rails); rescue; end
+      @model = Results::Item.new :title => 'Test'
+    end
+    include ActiveModel::Lint::Tests
+
+    context "Item" do
+
+      setup do
+        @document = Results::Item.new :title  => 'Test',
+                                      :author => { :name => 'Kafka' },
+                                      :awards => { :best_fiction => { :year => '1925' } }
+      end
+
+      should "be initialized with a Hash or Hash like object" do
+        assert_raise(ArgumentError) { Results::Item.new('FUUUUUUU') }
+
+        assert_nothing_raised do
+          d = Results::Item.new(:id => 1)
+          assert_instance_of Results::Item, d
+        end
+
+        assert_nothing_raised do
+          class AlmostHash < Hash; end
+          d = Results::Item.new(AlmostHash.new(:id => 1))
+        end
+      end
+
+      should "have an 'id' method" do
+        a = Results::Item.new(:_id => 1)
+        b = Results::Item.new(:id => 1)
+        assert_equal 1, a.id
+        assert_equal 1, b.id
+      end
+
+      should "have a 'type' method" do
+        a = Results::Item.new(:_type => 'foo')
+        b = Results::Item.new(:type => 'foo')
+        assert_equal 'foo', a.type
+        assert_equal 'foo', b.type
+      end
+
+      should "respond to :to_indexed_json" do
+        assert_respond_to Results::Item.new, :to_indexed_json
+      end
+
+      should "retrieve simple values from underlying hash" do
+        assert_equal 'Test', @document[:title]
+      end
+
+      should "retrieve hash values from underlying hash" do
+        assert_equal 'Kafka', @document[:author][:name]
+      end
+
+      should "allow to retrieve value by methods" do
+        assert_not_nil @document.title
+        assert_equal 'Test', @document.title
+      end
+
+      should "return nil for non-existing keys/methods" do
+        assert_nothing_raised { @document.whatever }
+        assert_nil @document.whatever
+      end
+
+      should "not care about symbols or strings in keys" do
+        @document = Results::Item.new 'title' => 'Test'
+        assert_not_nil @document.title
+        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
+      end
+
+      should "wrap arrays" do
+        @document = Results::Item.new :stats => [1, 2, 3]
+        assert_equal [1, 2, 3], @document.stats
+      end
+
+      should "wrap hashes in arrays" do
+        @document = Results::Item.new :comments => [{:title => 'one'}, {:title => 'two'}]
+        assert_equal 2,    @document.comments.size
+        assert_instance_of Results::Item, @document.comments.first
+        assert_equal       'one', @document.comments.first.title
+        assert_equal       'two', @document.comments.last.title
+      end
+
+      should "be an Item instance" do
+        assert_instance_of Tire::Results::Item, @document
+      end
+
+      should "be convertible to hash" do
+        assert_instance_of Hash, @document.to_hash
+        assert_instance_of Hash, @document.to_hash[:author]
+        assert_instance_of Hash, @document.to_hash[:awards][:best_fiction]
+
+        assert_equal 'Kafka', @document.to_hash[:author][:name]
+        assert_equal '1925',  @document.to_hash[:awards][:best_fiction][:year]
+      end
+
+      should "be inspectable" do
+        assert_match /<Item .* title|Item .* author/, @document.inspect
+      end
+
+      context "within Rails" do
+
+        setup do
+          module ::Rails
+          end
+
+          class ::FakeRailsModel
+            extend  ActiveModel::Naming
+            include ActiveModel::Conversion
+            def self.find(id, options); new; end
+          end
+
+          @document = Results::Item.new :id => 1, :_type => 'fake_rails_model', :title => 'Test'
+        end
+
+        should "be an instance of model, based on _type" do
+          assert_equal FakeRailsModel, @document.class
+        end
+
+        should "be inspectable with masquerade" do
+          assert_match /<Item \(FakeRailsModel\)/, @document.inspect
+        end
+
+        should "return proper singular and plural forms" do
+          assert_equal 'fake_rails_model',  ActiveModel::Naming.singular(@document)
+          assert_equal 'fake_rails_models', ActiveModel::Naming.plural(@document)
+        end
+
+        should "instantiate itself for deep hashes, not a Ruby class corresponding to type" do
+          document = Results::Item.new :_type => 'my_model', :title => 'Test', :author => { :name => 'John' }
+
+          assert_equal Tire::Results::Item, document.class
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/unit/rubyext_test.rb

@@ -0,0 +1,66 @@
+require 'test_helper'
+
+module Tire
+
+  class RubyCoreExtensionsTest < Test::Unit::TestCase
+
+    context "Hash" do
+
+      context "with no to_json method provided" do
+
+        setup do
+          @hash = { :one => 1}
+          # Undefine the `to_json` method...
+          ::Hash.class_eval { remove_method(:to_json) rescue nil }
+          # ... and reload the extension, so it's added
+          load 'tire/rubyext/hash.rb'
+        end
+
+        should "have its own to_json method" do
+          assert_respond_to( @hash, :to_json )
+          assert_equal '{"one":1}', @hash.to_json
+        end
+
+        should "allow to pass options to to_json for compatibility" do
+          assert_nothing_raised do
+            assert_equal '{"one":1}', @hash.to_json({})
+          end
+        end
+
+      end
+
+      should "have a to_json method from a JSON serialization library" do
+        assert_respond_to( {}, :to_json )
+        assert_equal '{"one":1}', { :one => 1}.to_json
+      end
+
+      should "have to_indexed_json method doing the same as to_json" do
+        [{}, { 1 => 2 }, { 3 => 4, 5 => 6 }, { nil => [7,8,9] }].each do |h|
+          assert_equal MultiJson.decode(h.to_json), MultiJson.decode(h.to_indexed_json)
+        end
+      end
+
+      should "properly serialize Time into JSON" do
+        json = { :time => Time.mktime(2011, 01, 01, 11, 00).to_json  }.to_json
+        assert_match /"2011-01-01T11:00:00.*"/, MultiJson.decode(json)['time']
+      end
+
+    end
+
+    context "Array" do
+
+      should "encode itself to JSON" do
+        assert_equal '["one","two"]', ['one','two'].to_json
+      end
+
+    end
+
+    context "Ruby Test::Unit" do
+      should "actually return true from assert..." do
+        assert_equal true, assert(true)
+      end
+    end
+
+  end
+
+end