tire 0.1.0

data/test/unit/model_search_test.rb

@@ -0,0 +1,289 @@
+require 'test_helper'
+
+module Tire
+  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'
+          Tire::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'
+
+          Tire::Search::Search.expects(:new).with(first, {}).returns(@stub)
+          ActiveModelArticleWithCustomIndexName.index_name 'custom-index-name'
+          ActiveModelArticleWithCustomIndexName.search 'foo'
+
+          Tire::Search::Search.expects(:new).with(second, {}).returns(@stub)
+          ActiveModelArticleWithCustomIndexName.index_name 'another-custom-index-name'
+          ActiveModelArticleWithCustomIndexName.search 'foo'
+
+          Tire::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, Tire::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
+            Tire::Search::Search.any_instance.expects(:perform).returns(@stub)
+            Tire::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
+            Tire::Search::Query.any_instance.expects(:instance_eval).never
+            Tire::Search::Search.any_instance.expects(:perform).returns(@stub)
+            Tire::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'
+
+            Tire::Search::Query.any_instance.expects(:string).with( @q ).returns(@stub)
+            Tire::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
+            Tire::Search::Sort.any_instance.expects(:title)
+
+            ActiveModelArticle.search @q, :order => 'title'
+          end
+
+          should "allow to pass :sort option as :order option" do
+            Tire::Search::Sort.any_instance.expects(:title)
+
+            ActiveModelArticle.search @q, :sort => 'title'
+          end
+
+          should "allow to specify sort direction" do
+            Tire::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
+            Tire::Search::Sort.any_instance.expects(:title).with('DESC')
+            Tire::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
+            Tire::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
+            Tire::Search::Search.any_instance.expects(:size).with(10)
+            Tire::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
+            Tire::Search::Search.any_instance.expects(:size).with(10)
+            Tire::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
+          Tire::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) }
+          Tire::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 } }
+              }}
+            }
+
+            Tire::Index.any_instance.expects(:create).with(expected_mapping)
+
+            class ::ModelWithCustomMapping
+              extend ActiveModel::Naming
+
+              include Tire::Model::Search
+              include Tire::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 { Tire::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 Tire::Model::Search
+              include Tire::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 Tire::Model::Search
+              include Tire::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

@@ -0,0 +1,131 @@
+require 'test_helper'
+
+module Tire
+
+  class ResultsCollectionTest < Test::Unit::TestCase
+
+    context "Collection" do
+      setup do
+        Configuration.reset :wrapper
+        @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" 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 )
+          assert_equal 3, collection.results.count
+        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, '_score' => 0.5, '_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
+
+      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
+
+  end
+
+end

data/test/unit/results_item_test.rb

@@ -0,0 +1,59 @@
+require 'test_helper'
+
+module Tire
+
+  class ResultsItemTest < Test::Unit::TestCase
+
+    context "Item" do
+
+      setup do
+        @document = Results::Item.new :title => 'Test', :author => { :name => 'Kafka' }
+      end
+
+      should "be initialized with a Hash" 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
+      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 "allow to retrieve values from nested hashes" do
+        assert_not_nil   @document.author.name
+        assert_equal 'Kafka', @document.author.name
+      end
+
+    end
+
+  end
+
+end