slingshot-rb 0.0.8 → 0.0.9

data/test/unit/model_search_test.rb

@@ -0,0 +1,289 @@
+require 'test_helper'
+
+module Slingshot
+  module Model
+
+    class SearchTest < Test::Unit::TestCase
+
+      context "Model::Search" do
+
+        setup do
+          @stub = stub('search') { stubs(:query).returns(self); stubs(:perform).returns(self); stubs(:results).returns([]) }
+        end
+
+        teardown do
+          ActiveModelArticleWithCustomIndexName.index_name 'custom-index-name'
+        end
+
+        should "have the search method" do
+          assert_respond_to Model::Search, :search
+          assert_respond_to ActiveModelArticle, :search
+        end
+
+        should "search in index named after class name by default" do
+          i = 'active_model_articles'
+          Slingshot::Search::Search.expects(:new).with(i, {}).returns(@stub)
+
+          ActiveModelArticle.search 'foo'
+        end
+
+        should "search in custom name" do
+          first  = 'custom-index-name'
+          second = 'another-custom-index-name'
+
+          Slingshot::Search::Search.expects(:new).with(first, {}).returns(@stub)
+          ActiveModelArticleWithCustomIndexName.index_name 'custom-index-name'
+          ActiveModelArticleWithCustomIndexName.search 'foo'
+
+          Slingshot::Search::Search.expects(:new).with(second, {}).returns(@stub)
+          ActiveModelArticleWithCustomIndexName.index_name 'another-custom-index-name'
+          ActiveModelArticleWithCustomIndexName.search 'foo'
+
+          Slingshot::Search::Search.expects(:new).with(first, {}).returns(@stub)
+          ActiveModelArticleWithCustomIndexName.index_name 'custom-index-name'
+          ActiveModelArticleWithCustomIndexName.search 'foo'
+        end
+
+        should "allow to refresh index" do
+          Index.any_instance.expects(:refresh)
+
+          ActiveModelArticle.index.refresh
+        end
+
+        should "wrap results in proper class with ID and score and not change the original wrapper" do
+          response = { 'hits' => { 'hits' => [{'_id' => 1, '_score' => 0.8, '_source' => { 'title' => 'Article' }}] } }
+          Configuration.client.expects(:post).returns(mock_response(response.to_json))
+
+          collection = ActiveModelArticle.search 'foo'
+          assert_instance_of Results::Collection, collection
+
+          assert_equal Results::Item, Slingshot::Configuration.wrapper
+
+          document = collection.first
+
+          assert_instance_of ActiveModelArticle, document
+          assert_not_nil document.score
+          assert_equal 1, document.id
+          assert_equal 'Article', document.title
+        end
+
+        context "searching with a block" do
+
+          should "pass on whatever block it received" do
+            Slingshot::Search::Search.any_instance.expects(:perform).returns(@stub)
+            Slingshot::Search::Query.any_instance.expects(:string).with('foo').returns(@stub)
+
+            ActiveModelArticle.search { query { string 'foo' } }
+          end
+
+          should "allow to pass block with argument to query, allowing to use local variables from outer scope" do
+            Slingshot::Search::Query.any_instance.expects(:instance_eval).never
+            Slingshot::Search::Search.any_instance.expects(:perform).returns(@stub)
+            Slingshot::Search::Query.any_instance.expects(:string).with('foo').returns(@stub)
+
+            my_query = 'foo'
+            ActiveModelArticle.search do
+              query do |query|
+                query.string(my_query)
+              end
+            end
+          end
+
+        end
+
+        context "searching with query string" do
+
+          setup do
+            @q = 'foo AND bar'
+
+            Slingshot::Search::Query.any_instance.expects(:string).with( @q ).returns(@stub)
+            Slingshot::Search::Search.any_instance.expects(:perform).returns(@stub)
+          end
+
+          should "search for query string" do
+            ActiveModelArticle.search @q
+          end
+
+          should "allow to pass :order option" do
+            Slingshot::Search::Sort.any_instance.expects(:title)
+
+            ActiveModelArticle.search @q, :order => 'title'
+          end
+
+          should "allow to pass :sort option as :order option" do
+            Slingshot::Search::Sort.any_instance.expects(:title)
+
+            ActiveModelArticle.search @q, :sort => 'title'
+          end
+
+          should "allow to specify sort direction" do
+            Slingshot::Search::Sort.any_instance.expects(:title).with('DESC')
+
+            ActiveModelArticle.search @q, :order => 'title DESC'
+          end
+
+          should "allow to specify more fields to sort on" do
+            Slingshot::Search::Sort.any_instance.expects(:title).with('DESC')
+            Slingshot::Search::Sort.any_instance.expects(:field).with('author.name', nil)
+
+            ActiveModelArticle.search @q, :order => ['title DESC', 'author.name']
+          end
+
+          should "allow to specify number of results per page" do
+            Slingshot::Search::Search.any_instance.expects(:size).with(20)
+
+            ActiveModelArticle.search @q, :per_page => 20
+          end
+
+          should "allow to specify first page in paginated results" do
+            Slingshot::Search::Search.any_instance.expects(:size).with(10)
+            Slingshot::Search::Search.any_instance.expects(:from).with(0)
+
+            ActiveModelArticle.search @q, :per_page => 10, :page => 1
+          end
+
+          should "allow to specify page further in paginated results" do
+            Slingshot::Search::Search.any_instance.expects(:size).with(10)
+            Slingshot::Search::Search.any_instance.expects(:from).with(20)
+
+            ActiveModelArticle.search @q, :per_page => 10, :page => 3
+          end
+
+        end
+
+        should "not set callback when hooks are missing" do
+          @model = ActiveModelArticle.new
+          @model.expects(:update_elastic_search_index).never
+
+          @model.save
+        end
+
+        should "fire :after_save callbacks" do
+          @model = ActiveModelArticleWithCallbacks.new
+          @model.expects(:update_elastic_search_index)
+
+          @model.save
+        end
+
+        should "fire :after_destroy callbacks" do
+          @model = ActiveModelArticleWithCallbacks.new
+          @model.expects(:update_elastic_search_index)
+
+          @model.destroy
+        end
+
+        should "store the record in index on :update_elastic_search_index when saved" do
+          @model = ActiveModelArticleWithCallbacks.new
+          Slingshot::Index.any_instance.expects(:store)
+
+          @model.save
+        end
+
+        should "remove the record from index on :update_elastic_search_index when destroyed" do
+          @model = ActiveModelArticleWithCallbacks.new
+          i = mock('index') { expects(:remove) }
+          Slingshot::Index.expects(:new).with('active_model_article_with_callbacks').returns(i)
+
+          @model.destroy
+        end
+
+        context "with custom mapping" do
+
+          should "create the index with mapping" do
+            expected_mapping = {
+              :mappings => { :model_with_custom_mapping => {
+                :properties => { :title => { :type => 'string', :analyzer => 'snowball', :boost => 10 } }
+              }}
+            }
+
+            Slingshot::Index.any_instance.expects(:create).with(expected_mapping)
+
+            class ::ModelWithCustomMapping
+              extend ActiveModel::Naming
+
+              include Slingshot::Model::Search
+              include Slingshot::Model::Callbacks
+
+              mapping do
+                indexes :title, :type => 'string', :analyzer => 'snowball', :boost => 10
+              end
+
+            end
+
+            assert_equal 'snowball', ModelWithCustomMapping.mapping[:title][:analyzer]
+          end
+
+        end
+
+        context "serialization" do
+          setup { Slingshot::Index.any_instance.stubs(:create).returns(true) }
+
+          should "serialize itself into JSON without 'root'" do
+            @model = ActiveModelArticle.new 'title' => 'Test'
+            assert_equal({'title' => 'Test'}.to_json, @model.to_indexed_json)
+          end
+
+          should "serialize itself with serializable_hash when no mapping is set" do
+
+            class ::ModelWithoutMapping
+              extend  ActiveModel::Naming
+              include ActiveModel::Serialization
+              include Slingshot::Model::Search
+              include Slingshot::Model::Callbacks
+
+              # Do NOT configure any mapping
+
+              attr_reader :attributes
+
+              def initialize(attributes = {}); @attributes = attributes; end
+
+              def method_missing(name, *args, &block)
+                attributes[name.to_sym] || attributes[name.to_s] || super
+              end
+            end
+
+            model = ::ModelWithoutMapping.new :one => 1, :two => 2
+            assert_equal( {:one => 1, :two => 2}, model.serializable_hash )
+
+            # Bot properties are returned
+            assert_equal( {:one => 1, :two => 2}.to_json, model.to_indexed_json )
+          end
+
+          should "serialize only mapped properties when mapping is set" do
+
+            class ::ModelWithMapping
+              extend  ActiveModel::Naming
+              include ActiveModel::Serialization
+              include Slingshot::Model::Search
+              include Slingshot::Model::Callbacks
+
+              mapping do
+                # ONLY index the 'one' attribute
+                indexes :one, :type => 'string', :analyzer => 'keyword'
+              end
+
+              attr_reader :attributes
+
+              def initialize(attributes = {}); @attributes = attributes; end
+
+              def method_missing(name, *args, &block)
+                attributes[name.to_sym] || attributes[name.to_s] || super
+              end
+            end
+
+            model = ::ModelWithMapping.new :one => 1, :two => 2
+            assert_equal( {:one => 1, :two => 2}, model.serializable_hash )
+
+            # Only the mapped property is returned
+            assert_equal( {:one => 1}.to_json, model.to_indexed_json )
+
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+end

data/test/unit/results_collection_test.rb

@@ -7,17 +7,24 @@ module Slingshot
     context "Collection" do
       setup do
         Configuration.reset :wrapper
-        @default_response = { 'hits' => { 'hits' => [{:_id => 1}, {:_id => 2}, {:_id => 3}] } }
+        @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 }
+          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" do
+        assert_equal 3, Results::Collection.new(@default_response).size
+      end
+
       should "be initialized with parsed json" do
         assert_nothing_raised do
           collection = Results::Collection.new( @default_response )
@@ -25,10 +32,16 @@ module Slingshot
         end
       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
+
       context "wrapping results" do
 
         setup do
-          @response = { 'hits' => { 'hits' => [ { '_id' => 1, '_source' => { :title => 'Test', :body => 'Lorem' } } ] } }
+          @response = { 'hits' => { 'hits' => [ { '_id' => 1, '_score' => 0.5, '_source' => { :title => 'Test', :body => 'Lorem' } } ] } }
         end
 
         should "wrap hits in Item by default" do
@@ -37,10 +50,10 @@ module Slingshot
           assert_equal 'Test', document.title
         end
 
-        should "allow access to raw underlying Hash in Item" do
+        should "NOT allow access to raw underlying Hash in Item" do
           document = Results::Collection.new(@response).first
-          assert_not_nil document[:_source][:title]
-          assert_equal 'Test', document[:_source][:title]
+          assert_nil document[:_source]
+          assert_nil document['_source']
         end
 
         should "allow wrapping hits in a Hash" do
@@ -60,6 +73,55 @@ module Slingshot
           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
+
+      end
+
+      context "while paginating results" do
+
+        setup do
+          @default_response = { 'hits' => { 'hits' => [{'_id' => 1, '_score' => 1, '_source' => {:title => 'Test'}},
+                                                       {'_id' => 2},
+                                                       {'_id' => 3}],
+                                            'total' => 3,
+                                            'took'  => 1 } }
+          @collection = Results::Collection.new( @default_response, :per_page => 1, :page => 2 )
+        end
+
+        should "return total entries" do
+          assert_equal 3, @collection.total
+          assert_equal 3, @collection.total_entries
+        end
+
+        should "return total pages" do
+          assert_equal 3, @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 previous page" do
+          assert_equal 1, @collection.previous_page
+        end
+
+        should "return next page" do
+          assert_equal 3, @collection.next_page
+        end
+
       end
 
     end

data/test/unit/results_item_test.rb

@@ -11,17 +11,11 @@ module Slingshot
       end
 
       should "be initialized with a Hash" do
-        assert_nothing_raised do
-          d = Results::Item.new(:id => 1)
-          assert_instance_of Results::Item, d
-        end
-      end
+        assert_raise(ArgumentError) { Results::Item.new('FUUUUUUU') }
 
-      should "delegate non-Hash params to Hash when initializing" do
         assert_nothing_raised do
-          d = Results::Item.new('foo')
+          d = Results::Item.new(:id => 1)
           assert_instance_of Results::Item, d
-          assert_equal 'foo', d[:bar] # See http://www.ruby-doc.org/core/classes/Hash.html#M000718
         end
       end
 
@@ -29,11 +23,15 @@ module Slingshot
         assert_respond_to Results::Item.new, :to_indexed_json
       end
 
-      should "retrieve the values from underlying hash" do
+      should "retrieve simple values from underlying hash" do
         assert_equal 'Test', @document[:title]
       end
 
-      should "allow to retrieve the values by methods" do
+      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
@@ -49,10 +47,6 @@ module Slingshot
         assert_equal 'Test', @document.title
       end
 
-      should "allow to retrieve hashes" do
-        assert_equal 'Kafka', @document.author[:name]
-      end
-
       should "allow to retrieve values from nested hashes" do
         assert_not_nil   @document.author.name
         assert_equal 'Kafka', @document.author.name