elasticsearch-model 0.1.1 → 0.1.2

data/test/integration/mongoid_basic_test.rb

@@ -95,6 +95,18 @@ if ENV["MONGODB_AVAILABLE"]
             end
           end
 
+          should "preserve the search results order for records" do
+            response = MongoidArticle.search('title:code')
+
+            response.records.each_with_hit do |r, h|
+              assert_equal h._id, r.id.to_s
+            end
+
+            response.records.map_with_hit do |r, h|
+              assert_equal h._id, r.id.to_s
+            end
+          end
+
           should "remove document from index on destroy" do
             article = MongoidArticle.first
 

data/test/unit/adapter_active_record_test.rb

@@ -82,13 +82,42 @@ class Elasticsearch::Model::AdapterActiveRecordTest < Test::Unit::TestCase
     end
 
     context "Importing" do
+      setup do
+        DummyClassForActiveRecord.__send__ :extend, Elasticsearch::Model::Adapter::ActiveRecord::Importing
+      end
+
+      should "raise an exception when passing an invalid scope" do
+        assert_raise NoMethodError do
+          DummyClassForActiveRecord.__find_in_batches(scope: :not_found_method) do; end
+        end
+      end
+
       should "implement the __find_in_batches method" do
         DummyClassForActiveRecord.expects(:find_in_batches).returns([])
-
-        DummyClassForActiveRecord.__send__ :extend, Elasticsearch::Model::Adapter::ActiveRecord::Importing
         DummyClassForActiveRecord.__find_in_batches do; end
       end
-    end
 
+      should "limit the relation to a specific scope" do
+        DummyClassForActiveRecord.expects(:find_in_batches).returns([])
+        DummyClassForActiveRecord.expects(:published).returns(DummyClassForActiveRecord)
+
+        DummyClassForActiveRecord.__find_in_batches(scope: :published) do; end
+      end
+
+      context "when transforming models" do
+        setup do
+          @transform = DummyClassForActiveRecord.__transform
+        end
+
+        should "provide an object that responds to #call" do
+          assert_respond_to @transform, :call
+        end
+
+        should "provide default transformation" do
+          model = mock("model", id: 1, __elasticsearch__: stub(as_indexed_json: {}))
+          assert_equal @transform.call(model), { index: { _id: 1, data: {} } }
+        end
+      end
+    end
   end
 end

data/test/unit/adapter_default_test.rb

@@ -19,11 +19,21 @@ class Elasticsearch::Model::AdapterDefaultTest < Test::Unit::TestCase
       assert_instance_of Module, Elasticsearch::Model::Adapter::Default::Callbacks
     end
 
-    should "have the default Importing implementation" do
-      DummyClassForDefaultAdapter.__send__ :include, Elasticsearch::Model::Adapter::Default::Importing
+    context "concerning abstract methods" do
+      setup do
+        DummyClassForDefaultAdapter.__send__ :include, Elasticsearch::Model::Adapter::Default::Importing
+      end
+
+      should "have the default Importing implementation" do
+        assert_raise Elasticsearch::Model::NotImplemented do
+          DummyClassForDefaultAdapter.new.__find_in_batches
+        end
+      end
 
-      assert_raise Elasticsearch::Model::NotImplemented do
-        DummyClassForDefaultAdapter.new.__find_in_batches
+      should "have the default transform implementation" do
+        assert_raise Elasticsearch::Model::NotImplemented do
+          DummyClassForDefaultAdapter.new.__transform
+        end
       end
     end
 

data/test/unit/adapter_mongoid_test.rb

@@ -81,6 +81,21 @@ class Elasticsearch::Model::AdapterMongoidTest < Test::Unit::TestCase
         DummyClassForMongoid.__send__ :extend, Elasticsearch::Model::Adapter::Mongoid::Importing
         DummyClassForMongoid.__find_in_batches do; end
       end
+
+      context "when transforming models" do
+        setup do
+          @transform = DummyClassForMongoid.__transform
+        end
+
+        should "provide an object that responds to #call" do
+          assert_respond_to @transform, :call
+        end
+
+        should "provide basic transformation" do
+          model = mock("model", id: 1, as_indexed_json: {})
+          assert_equal @transform.call(model), { index: { _id: "1", data: {} } }
+        end
+      end
     end
 
   end

data/test/unit/importing_test.rb

@@ -10,6 +10,9 @@ class Elasticsearch::Model::ImportingTest < Test::Unit::TestCase
         def __find_in_batches(options={}, &block)
           yield if block_given?
         end
+        def __transform
+          lambda {|a|}
+        end
       end
 
       def importing_mixin
@@ -41,7 +44,7 @@ class Elasticsearch::Model::ImportingTest < Test::Unit::TestCase
       DummyImportingModel.expects(:client).returns(client)
       DummyImportingModel.expects(:index_name).returns('foo')
       DummyImportingModel.expects(:document_type).returns('foo')
-
+      DummyImportingModel.stubs(:__batch_to_bulk)
       assert_equal 0, DummyImportingModel.import
     end
 
@@ -58,6 +61,7 @@ class Elasticsearch::Model::ImportingTest < Test::Unit::TestCase
       DummyImportingModel.stubs(:client).returns(client)
       DummyImportingModel.stubs(:index_name).returns('foo')
       DummyImportingModel.stubs(:document_type).returns('foo')
+      DummyImportingModel.stubs(:__batch_to_bulk)
 
       assert_equal 1, DummyImportingModel.import
     end
@@ -75,6 +79,7 @@ class Elasticsearch::Model::ImportingTest < Test::Unit::TestCase
       DummyImportingModel.stubs(:client).returns(client)
       DummyImportingModel.stubs(:index_name).returns('foo')
       DummyImportingModel.stubs(:document_type).returns('foo')
+      DummyImportingModel.stubs(:__batch_to_bulk)
 
       DummyImportingModel.import do |response|
         assert_equal 2, response['items'].size
@@ -116,8 +121,36 @@ class Elasticsearch::Model::ImportingTest < Test::Unit::TestCase
         .returns({'items' => [ {'index' => {} }]})
 
       DummyImportingModel.stubs(:client).returns(client)
+      DummyImportingModel.stubs(:__batch_to_bulk)
 
       DummyImportingModel.import index: 'my-new-index', type: 'my-other-type'
     end
+
+    should "use the default transform from adapter" do
+      client = mock('client', bulk: {'items' => []})
+      transform = lambda {|a|}
+
+      DummyImportingModel.stubs(:client).returns(client)
+      DummyImportingModel.expects(:__transform).returns(transform)
+      DummyImportingModel.expects(:__batch_to_bulk).with(anything, transform)
+
+      DummyImportingModel.import index: 'foo', type: 'bar'
+    end
+
+    should "use the transformer from options" do
+      client = mock('client', bulk: {'items' => []})
+      transform = lambda {|a|}
+
+      DummyImportingModel.stubs(:client).returns(client)
+      DummyImportingModel.expects(:__batch_to_bulk).with(anything, transform)
+
+      DummyImportingModel.import index: 'foo', type: 'bar', transform: transform
+    end
+
+    should "raise an ArgumentError if transform doesn't respond to the call method" do
+      assert_raise ArgumentError do
+        DummyImportingModel.import index: 'foo', type: 'bar', transform: "not_callable"
+      end
+    end
   end
 end

data/test/unit/indexing_test.rb

@@ -47,6 +47,12 @@ class Elasticsearch::Model::IndexingTest < Test::Unit::TestCase
         assert_instance_of Elasticsearch::Model::Indexing::Mappings, DummyIndexingModel.mappings
       end
 
+      should "raise an exception when not passed type" do
+        assert_raise ArgumentError do
+          Elasticsearch::Model::Indexing::Mappings.new
+        end
+      end
+
       should "be convertible to hash" do
         mappings = Elasticsearch::Model::Indexing::Mappings.new :mytype, { foo: 'bar' }
         assert_equal( { :mytype => { foo: 'bar', :properties => {} } }, mappings.to_hash )

data/test/unit/{response_pagination_test.rb → response_pagination_kaminari_test.rb}

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class Elasticsearch::Model::ResponsePaginationTest < Test::Unit::TestCase
+class Elasticsearch::Model::ResponsePaginationKaminariTest < Test::Unit::TestCase
   context "Response pagination" do
     class ModelClass
       include ::Kaminari::ConfigurationMethods

data/test/unit/response_pagination_will_paginate_test.rb

@@ -0,0 +1,189 @@
+require 'test_helper'
+require 'will_paginate'
+require 'will_paginate/collection'
+
+class Elasticsearch::Model::ResponsePaginationWillPaginateTest < Test::Unit::TestCase
+  context "Response pagination" do
+    class ModelClass
+      def self.index_name;    'foo'; end
+      def self.document_type; 'bar'; end
+
+      # WillPaginate adds this method to models (see WillPaginate::PerPage module)
+      def self.per_page
+        33
+      end
+    end
+
+    # Subsclass Response so we can include WillPaginate module without conflicts with Kaminari.
+    class WillPaginateResponse < Elasticsearch::Model::Response::Response
+      include Elasticsearch::Model::Response::Pagination::WillPaginate
+    end
+
+    RESPONSE = { 'took' => '5', 'timed_out' => false, '_shards' => {'one' => 'OK'},
+                 'hits' => { 'total' => 100, 'hits' => (1..100).to_a.map { |i| { _id: i } } } }
+
+    setup do
+      @search   = Elasticsearch::Model::Searching::SearchRequest.new ModelClass, '*'
+      @response = WillPaginateResponse.new ModelClass, @search, RESPONSE
+      @response.klass.stubs(:client).returns mock('client')
+
+      @expected_methods = [
+        # methods needed by WillPaginate::CollectionMethods
+        :current_page,
+        :per_page,
+        :total_entries,
+
+        # methods defined by WillPaginate::CollectionMethods
+        :total_pages,
+        :previous_page,
+        :next_page,
+        :out_of_bounds?,
+      ]
+    end
+
+    should "have pagination methods" do
+      assert_respond_to @response, :paginate
+
+      @expected_methods.each do |method|
+        assert_respond_to @response, method
+      end
+    end
+
+    context "response.results" do
+      should "have pagination methods" do
+        @expected_methods.each do |method|
+          assert_respond_to @response.results, method
+        end
+      end
+    end
+
+    context "response.records" do
+      should "have pagination methods" do
+        @expected_methods.each do |method|
+          @response.klass.stubs(:find).returns([])
+          assert_respond_to @response.records, method
+        end
+      end
+    end
+
+    context "#paginate method" do
+      should "set from/size using defaults" do
+        @response.klass.client
+          .expects(:search)
+            .with do |definition|
+              assert_equal 0, definition[:from]
+              assert_equal 33, definition[:size]
+            end
+          .returns(RESPONSE)
+
+        assert_nil @response.search.definition[:from]
+        assert_nil @response.search.definition[:size]
+
+        @response.paginate(page: nil).to_a
+        assert_equal 0, @response.search.definition[:from]
+        assert_equal 33, @response.search.definition[:size]
+      end
+
+      should "set from/size using default per_page" do
+        @response.klass.client
+          .expects(:search)
+            .with do |definition|
+              assert_equal 33, definition[:from]
+              assert_equal 33, definition[:size]
+            end
+          .returns(RESPONSE)
+
+        assert_nil @response.search.definition[:from]
+        assert_nil @response.search.definition[:size]
+
+        @response.paginate(page: 2).to_a
+        assert_equal 33, @response.search.definition[:from]
+        assert_equal 33, @response.search.definition[:size]
+      end
+
+      should "set from/size using custom page and per_page" do
+        @response.klass.client
+          .expects(:search)
+            .with do |definition|
+              assert_equal 18, definition[:from]
+              assert_equal 9, definition[:size]
+            end
+          .returns(RESPONSE)
+
+        assert_nil @response.search.definition[:from]
+        assert_nil @response.search.definition[:size]
+
+        @response.paginate(page: 3, per_page: 9).to_a
+        assert_equal 18, @response.search.definition[:from]
+        assert_equal 9, @response.search.definition[:size]
+      end
+
+      should "searches for page 1 if specified page is < 1" do
+        @response.klass.client
+          .expects(:search)
+            .with do |definition|
+              assert_equal 0, definition[:from]
+              assert_equal 33, definition[:size]
+            end
+          .returns(RESPONSE)
+
+        assert_nil @response.search.definition[:from]
+        assert_nil @response.search.definition[:size]
+
+        @response.paginate(page: "-1").to_a
+        assert_equal 0, @response.search.definition[:from]
+        assert_equal 33, @response.search.definition[:size]
+      end
+    end
+
+    context "#page and #per_page shorthand methods" do
+      should "set from/size using default per_page" do
+        @response.page(5)
+        assert_equal 132, @response.search.definition[:from]
+        assert_equal 33, @response.search.definition[:size]
+      end
+
+      should "set from/size when calling #page then #per_page" do
+        @response.page(5).per_page(3)
+        assert_equal 12, @response.search.definition[:from]
+        assert_equal 3, @response.search.definition[:size]
+      end
+
+      should "set from/size when calling #per_page then #page" do
+        @response.per_page(3).page(5)
+        assert_equal 12, @response.search.definition[:from]
+        assert_equal 3, @response.search.definition[:size]
+      end
+    end
+
+    context "#current_page method" do
+      should "return 1 by default" do
+        @response.paginate({})
+        assert_equal 1, @response.current_page
+      end
+
+      should "return current page number" do
+        @response.paginate(page: 3, per_page: 9)
+        assert_equal 3, @response.current_page
+      end
+
+      should "return nil if not pagination set" do
+        assert_equal nil, @response.current_page
+      end
+    end
+
+    context "#per_page method" do
+      should "return value set in paginate call" do
+        @response.paginate(per_page: 8)
+        assert_equal 8, @response.per_page
+      end
+    end
+
+    context "#total_entries method" do
+      should "return total from response" do
+        @response.expects(:results).returns(mock('results', total: 100))
+        assert_equal 100, @response.total_entries
+      end
+    end
+  end
+end

data/test/unit/response_result_test.rb

@@ -15,6 +15,20 @@ class Elasticsearch::Model::ResultTest < Test::Unit::TestCase
       assert_raise(NoMethodError) { result.xoxo }
     end
 
+    should "return _id as #id" do
+      result = Elasticsearch::Model::Response::Result.new foo: 'bar', _id: 42, _source: { id: 12 }
+
+      assert_equal 42, result.id
+      assert_equal 12, result._source.id
+    end
+
+    should "return _type as #type" do
+      result = Elasticsearch::Model::Response::Result.new foo: 'bar', _type: 'baz', _source: { type: 'BAM' }
+
+      assert_equal 'baz', result.type
+      assert_equal 'BAM', result._source.type
+    end
+
     should "delegate method calls to `_source` when available" do
       result = Elasticsearch::Model::Response::Result.new foo: 'bar', _source: { bar: 'baz' }
 
@@ -27,12 +41,27 @@ class Elasticsearch::Model::ResultTest < Test::Unit::TestCase
       assert_equal 'baz', result.bar
     end
 
+    should "delegate existence method calls to `_source`" do
+      result = Elasticsearch::Model::Response::Result.new foo: 'bar', _source: { bar: { bam: 'baz' } }
+
+      assert_respond_to result._source, :bar?
+      assert_respond_to result, :bar?
+
+      assert_equal true,  result._source.bar?
+      assert_equal true,  result.bar?
+      assert_equal false, result.boo?
+
+      assert_equal true,  result.bar.bam?
+      assert_equal false, result.bar.boo?
+    end
+
     should "delegate methods to @result" do
       result = Elasticsearch::Model::Response::Result.new foo: 'bar'
 
-      assert_equal 'bar', result.foo
-      assert_equal 'bar', result.fetch('foo')
-      assert_equal 'moo', result.fetch('NOT_EXIST', 'moo')
+      assert_equal 'bar',   result.foo
+      assert_equal 'bar',   result.fetch('foo')
+      assert_equal 'moo',   result.fetch('NOT_EXIST', 'moo')
+      assert_equal ['foo'], result.keys
 
       assert_respond_to result, :to_hash
       assert_equal({'foo' => 'bar'}, result.to_hash)
@@ -40,6 +69,16 @@ class Elasticsearch::Model::ResultTest < Test::Unit::TestCase
       assert_raise(NoMethodError) { result.does_not_exist }
     end
 
+    should "delegate existence method calls to @result" do
+      result = Elasticsearch::Model::Response::Result.new foo: 'bar', _source: { bar: 'bam' }
+      assert_respond_to result, :foo?
+
+      assert_equal true,  result.foo?
+      assert_equal false, result.boo?
+      assert_equal false, result._source.foo?
+      assert_equal false, result._source.boo?
+    end
+
     should "delegate as_json to @result even when ActiveSupport changed half of Ruby" do
       require 'active_support/json/encoding'
       result = Elasticsearch::Model::Response::Result.new foo: 'bar'
@@ -47,6 +86,5 @@ class Elasticsearch::Model::ResultTest < Test::Unit::TestCase
       result.instance_variable_get(:@result).expects(:as_json)
       result.as_json(except: 'foo')
     end
-
   end
 end