elasticsearch-model 6.0.0 → 6.1.0

data/test/unit/adapter_mongoid_test.rb

@@ -1,161 +0,0 @@
-require 'test_helper'
-
-class Elasticsearch::Model::AdapterMongoidTest < Test::Unit::TestCase
-  context "Adapter Mongoid module: " do
-    class ::DummyClassForMongoid
-      RESPONSE = Struct.new('DummyMongoidResponse') do
-        def response
-          { 'hits' => {'hits' => [ {'_id' => 2}, {'_id' => 1} ]} }
-        end
-      end.new
-
-      def response
-        RESPONSE
-      end
-
-      def ids
-        [2, 1]
-      end
-    end
-
-    setup do
-      @records = [ stub(id: 1, inspect: '<Model-1>'), stub(id: 2, inspect: '<Model-2>') ]
-      ::Symbol.any_instance.stubs(:in).returns(@records)
-    end
-
-    should "have the register condition" do
-      assert_not_nil Elasticsearch::Model::Adapter.adapters[Elasticsearch::Model::Adapter::Mongoid]
-      assert_equal false, Elasticsearch::Model::Adapter.adapters[Elasticsearch::Model::Adapter::Mongoid].call(DummyClassForMongoid)
-    end
-
-    context "Records" do
-      setup do
-        DummyClassForMongoid.__send__ :include, Elasticsearch::Model::Adapter::Mongoid::Records
-      end
-
-      should "have the implementation" do
-        assert_instance_of Module, Elasticsearch::Model::Adapter::Mongoid::Records
-
-        instance = DummyClassForMongoid.new
-        instance.expects(:klass).returns(mock('class', where: @records))
-
-        assert_equal @records, instance.records
-      end
-
-      should "reorder the records based on hits order" do
-        @records.instance_variable_set(:@records, @records)
-
-        instance = DummyClassForMongoid.new
-        instance.expects(:klass).returns(mock('class', where: @records))
-
-        assert_equal [1, 2], @records.        to_a.map(&:id)
-        assert_equal [2, 1], instance.records.to_a.map(&:id)
-      end
-
-      should "not reorder records when SQL order is present" do
-        @records.instance_variable_set(:@records, @records)
-
-        instance = DummyClassForMongoid.new
-        instance.expects(:klass).returns(stub('class', where: @records)).at_least_once
-        instance.records.expects(:asc).returns(@records)
-
-        assert_equal [2, 1], instance.records.to_a.map(&:id)
-        assert_equal [1, 2], instance.asc.to_a.map(&:id)
-      end
-    end
-
-    context "Callbacks" do
-      should "register hooks for automatically updating the index" do
-        DummyClassForMongoid.expects(:after_create)
-        DummyClassForMongoid.expects(:after_update)
-        DummyClassForMongoid.expects(:after_destroy)
-
-        Elasticsearch::Model::Adapter::Mongoid::Callbacks.included(DummyClassForMongoid)
-      end
-    end
-
-    context "Importing" do
-      should "implement the __find_in_batches method" do
-        relation = mock()
-        relation.stubs(:no_timeout).returns([])
-        DummyClassForMongoid.expects(:all).returns(relation)
-
-        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
-
-      should "limit the relation to a specific scope" do
-        relation = mock()
-        relation.stubs(:no_timeout).returns(relation)
-        relation.expects(:published).returns(relation)
-        relation.expects(:each_slice).returns([])
-        DummyClassForMongoid.expects(:all).returns(relation)
-
-        DummyClassForMongoid.__send__ :extend, Elasticsearch::Model::Adapter::Mongoid::Importing
-        DummyClassForMongoid.__find_in_batches(scope: :published) do; end
-      end
-
-      context "when limit the relation with proc" do
-        setup do
-          @query = Proc.new { where(color: "red") }
-        end
-        should "query with a specific criteria" do
-          relation = mock()
-          relation.stubs(:no_timeout).returns(relation)
-          relation.expects(:class_exec).returns(relation)
-          relation.expects(:each_slice).returns([])
-          DummyClassForMongoid.expects(:all).returns(relation)
-
-          DummyClassForMongoid.__find_in_batches(query: @query) do; end
-        end
-      end
-
-      context "when limit the relation with hash" do
-        setup do
-          @query = { color: "red" }
-        end
-        should "query with a specific criteria" do
-          relation = mock()
-          relation.stubs(:no_timeout).returns(relation)
-          relation.expects(:where).with(@query).returns(relation)
-          relation.expects(:each_slice).returns([])
-          DummyClassForMongoid.expects(:all).returns(relation)
-
-          DummyClassForMongoid.__find_in_batches(query: @query) do; end
-        end
-      end
-
-      should "preprocess the batch if option provided" do
-        class << DummyClassForMongoid
-          # Updates/transforms the batch while fetching it from the database
-          # (eg. with information from an external system)
-          #
-          def update_batch(batch)
-            batch.collect { |b| b.to_s + '!' }
-          end
-        end
-
-        DummyClassForMongoid.expects(:__find_in_batches).returns( [:a, :b] )
-
-        DummyClassForMongoid.__find_in_batches(preprocess: :update_batch) do |batch|
-          assert_same_elements ["a!", "b!"], batch
-        end
-      end
-    end
-  end
-end

data/test/unit/adapter_multiple_test.rb

@@ -1,106 +0,0 @@
-require 'test_helper'
-
-class Elasticsearch::Model::MultipleTest < Test::Unit::TestCase
-
-  context "Adapter for multiple models" do
-
-    class ::DummyOne
-      include Elasticsearch::Model
-
-      index_name 'dummy'
-      document_type 'dummy_one'
-
-      def self.find(ids)
-        ids.map { |id| new(id) }
-      end
-
-      attr_reader :id
-
-      def initialize(id)
-        @id = id.to_i
-      end
-    end
-
-    module ::Namespace
-      class DummyTwo
-        include Elasticsearch::Model
-
-        index_name 'dummy'
-        document_type 'dummy_two'
-
-        def self.find(ids)
-          ids.map { |id| new(id) }
-        end
-
-        attr_reader :id
-
-        def initialize(id)
-          @id = id.to_i
-        end
-      end
-    end
-
-    class ::DummyTwo
-      include Elasticsearch::Model
-
-      index_name 'other_index'
-      document_type 'dummy_two'
-
-      def self.find(ids)
-        ids.map { |id| new(id) }
-      end
-
-      attr_reader :id
-
-      def initialize(id)
-        @id = id.to_i
-      end
-    end
-
-    HITS = [{_index: 'dummy',
-             _type: 'dummy_two',
-             _id: '2',
-            }, {
-              _index: 'dummy',
-              _type: 'dummy_one',
-              _id: '2',
-            }, {
-              _index: 'other_index',
-              _type: 'dummy_two',
-              _id: '1',
-            }, {
-              _index: 'dummy',
-              _type: 'dummy_two',
-              _id: '1',
-            }, {
-              _index: 'dummy',
-              _type: 'dummy_one',
-              _id: '3'}]
-
-    setup do
-      @multimodel = Elasticsearch::Model::Multimodel.new(DummyOne, DummyTwo, Namespace::DummyTwo)
-    end
-
-    context "when returning records" do
-      setup do
-        @multimodel.class.send :include, Elasticsearch::Model::Adapter::Multiple::Records
-        @multimodel.expects(:response).at_least_once.returns(stub(response: { 'hits' => { 'hits' => HITS } }))
-      end
-
-      should "keep the order from response" do
-        assert_instance_of Module, Elasticsearch::Model::Adapter::Multiple::Records
-        records = @multimodel.records
-
-        assert_equal 5, records.count
-
-        assert_kind_of ::Namespace::DummyTwo, records[0]
-        assert_kind_of ::DummyOne,            records[1]
-        assert_kind_of ::DummyTwo,            records[2]
-        assert_kind_of ::Namespace::DummyTwo, records[3]
-        assert_kind_of ::DummyOne,            records[4]
-
-        assert_equal [2, 2, 1, 1, 3], records.map(&:id)
-      end
-    end
-  end
-end

data/test/unit/adapter_test.rb

@@ -1,69 +0,0 @@
-require 'test_helper'
-
-class Elasticsearch::Model::AdapterTest < Test::Unit::TestCase
-  context "Adapter module" do
-    class ::DummyAdapterClass; end
-    class ::DummyAdapterClassWithAdapter; end
-    class ::DummyAdapter
-      Records   = Module.new
-      Callbacks = Module.new
-      Importing = Module.new
-    end
-
-    should "return an Adapter instance" do
-      assert_instance_of Elasticsearch::Model::Adapter::Adapter,
-                         Elasticsearch::Model::Adapter.from_class(DummyAdapterClass)
-    end
-
-    should "return a list of adapters" do
-      Elasticsearch::Model::Adapter::Adapter.expects(:adapters)
-      Elasticsearch::Model::Adapter.adapters
-    end
-
-    should "register an adapter" do
-      begin
-        Elasticsearch::Model::Adapter::Adapter.expects(:register)
-        Elasticsearch::Model::Adapter.register(:foo, lambda { |c| false })
-      ensure
-        Elasticsearch::Model::Adapter::Adapter.instance_variable_set(:@adapters, {})
-      end
-    end
-  end
-
-  context "Adapter class" do
-    should "register an adapter" do
-      begin
-        Elasticsearch::Model::Adapter::Adapter.register(:foo, lambda { |c| false })
-        assert Elasticsearch::Model::Adapter::Adapter.adapters[:foo]
-      ensure
-        Elasticsearch::Model::Adapter::Adapter.instance_variable_set(:@adapters, {})
-      end
-    end
-
-    should "return the default adapter" do
-      adapter = Elasticsearch::Model::Adapter::Adapter.new(DummyAdapterClass)
-      assert_equal Elasticsearch::Model::Adapter::Default, adapter.adapter
-    end
-
-    should "return a specific adapter" do
-      Elasticsearch::Model::Adapter::Adapter.register(DummyAdapter,
-                                                      lambda { |c| c == DummyAdapterClassWithAdapter })
-
-      adapter = Elasticsearch::Model::Adapter::Adapter.new(DummyAdapterClassWithAdapter)
-      assert_equal DummyAdapter, adapter.adapter
-    end
-
-    should "return the modules" do
-      assert_nothing_raised do
-        Elasticsearch::Model::Adapter::Adapter.register(DummyAdapter,
-                                                      lambda { |c| c == DummyAdapterClassWithAdapter })
-
-        adapter = Elasticsearch::Model::Adapter::Adapter.new(DummyAdapterClassWithAdapter)
-
-        assert_instance_of Module, adapter.records_mixin
-        assert_instance_of Module, adapter.callbacks_mixin
-        assert_instance_of Module, adapter.importing_mixin
-      end
-    end
-  end
-end

data/test/unit/callbacks_test.rb

@@ -1,31 +0,0 @@
-require 'test_helper'
-
-class Elasticsearch::Model::CallbacksTest < Test::Unit::TestCase
-  context "Callbacks module" do
-    class ::DummyCallbacksModel
-    end
-
-    module DummyCallbacksAdapter
-      module CallbacksMixin
-      end
-
-      def callbacks_mixin
-        CallbacksMixin
-      end; module_function :callbacks_mixin
-    end
-
-    should "include the callbacks mixin from adapter" do
-      Elasticsearch::Model::Adapter.expects(:from_class)
-                                   .with(DummyCallbacksModel)
-                                   .returns(DummyCallbacksAdapter)
-
-      ::DummyCallbacksModel.expects(:__send__).with do |method, parameter|
-        assert_equal :include, method
-        assert_equal DummyCallbacksAdapter::CallbacksMixin, parameter
-        true
-      end
-
-      Elasticsearch::Model::Callbacks.included(DummyCallbacksModel)
-    end
-  end
-end

data/test/unit/client_test.rb

@@ -1,27 +0,0 @@
-require 'test_helper'
-
-class Elasticsearch::Model::ClientTest < Test::Unit::TestCase
-  context "Client module" do
-    class ::DummyClientModel
-      extend  Elasticsearch::Model::Client::ClassMethods
-      include Elasticsearch::Model::Client::InstanceMethods
-    end
-
-    should "have the default client method" do
-      assert_instance_of Elasticsearch::Transport::Client, DummyClientModel.client
-      assert_instance_of Elasticsearch::Transport::Client, DummyClientModel.new.client
-    end
-
-    should "set the client for the model" do
-      DummyClientModel.client = 'foobar'
-      assert_equal 'foobar', DummyClientModel.client
-      assert_equal 'foobar', DummyClientModel.new.client
-    end
-
-    should "set the client for a model instance" do
-      instance = DummyClientModel.new
-      instance.client = 'moobam'
-      assert_equal 'moobam', instance.client
-    end
-  end
-end

data/test/unit/hash_wrapper_test.rb

@@ -1,13 +0,0 @@
-require 'test_helper'
-
-require 'hashie/version'
-
-class Elasticsearch::Model::HashWrapperTest < Test::Unit::TestCase
-  context "The HashWrapper class" do
-    should "not print the warning for re-defined methods" do
-      Hashie.logger.expects(:warn).never
-
-      subject = Elasticsearch::Model::HashWrapper.new(:foo => 'bar', :sort => true)
-    end if Hashie::VERSION >= '3.5.3'
-  end
-end

data/test/unit/importing_test.rb

@@ -1,224 +0,0 @@
-require 'test_helper'
-
-class Elasticsearch::Model::ImportingTest < Test::Unit::TestCase
-  context "Importing module" do
-    class ::DummyImportingModel
-    end
-
-    module ::DummyImportingAdapter
-      module ImportingMixin
-        def __find_in_batches(options={}, &block)
-          yield if block_given?
-        end
-        def __transform
-          lambda {|a|}
-        end
-      end
-
-      def importing_mixin
-        ImportingMixin
-      end; module_function :importing_mixin
-    end
-
-    should "include methods from the module and adapter" do
-      Elasticsearch::Model::Adapter.expects(:from_class)
-                                   .with(DummyImportingModel)
-                                   .returns(DummyImportingAdapter)
-
-      DummyImportingModel.__send__ :include, Elasticsearch::Model::Importing
-
-      assert_respond_to DummyImportingModel, :import
-      assert_respond_to DummyImportingModel, :__find_in_batches
-    end
-
-    should "call the client when importing" do
-      Elasticsearch::Model::Adapter.expects(:from_class)
-                                   .with(DummyImportingModel)
-                                   .returns(DummyImportingAdapter)
-
-      DummyImportingModel.__send__ :include, Elasticsearch::Model::Importing
-
-      client = mock('client')
-      client.expects(:bulk).returns({'items' => []})
-
-      DummyImportingModel.expects(:client).returns(client)
-      DummyImportingModel.expects(:index_name).returns('foo')
-      DummyImportingModel.expects(:document_type).returns('foo')
-      DummyImportingModel.stubs(:index_exists?).returns(true)
-      DummyImportingModel.stubs(:__batch_to_bulk)
-      assert_equal 0, DummyImportingModel.import
-    end
-
-    should "return the number of errors" do
-      Elasticsearch::Model::Adapter.expects(:from_class)
-                                   .with(DummyImportingModel)
-                                   .returns(DummyImportingAdapter)
-
-      DummyImportingModel.__send__ :include, Elasticsearch::Model::Importing
-
-      client = mock('client')
-      client.expects(:bulk).returns({'items' => [ {'index' => {}}, {'index' => {'error' => 'FAILED'}} ]})
-
-      DummyImportingModel.stubs(:client).returns(client)
-      DummyImportingModel.stubs(:index_name).returns('foo')
-      DummyImportingModel.stubs(:document_type).returns('foo')
-      DummyImportingModel.stubs(:index_exists?).returns(true)
-      DummyImportingModel.stubs(:__batch_to_bulk)
-
-      assert_equal 1, DummyImportingModel.import
-    end
-
-    should "return an array of error elements" do
-      Elasticsearch::Model::Adapter.expects(:from_class)
-                                   .with(DummyImportingModel)
-                                   .returns(DummyImportingAdapter)
-
-      DummyImportingModel.__send__ :include, Elasticsearch::Model::Importing
-
-      client = mock('client')
-      client.expects(:bulk).returns({'items' => [ {'index' => {}}, {'index' => {'error' => 'FAILED'}} ]})
-
-      DummyImportingModel.stubs(:client).returns(client)
-      DummyImportingModel.stubs(:index_name).returns('foo')
-      DummyImportingModel.stubs(:document_type).returns('foo')
-      DummyImportingModel.stubs(:index_exists?).returns(true)
-      DummyImportingModel.stubs(:__batch_to_bulk)
-
-      assert_equal [{'index' => {'error' => 'FAILED'}}], DummyImportingModel.import(return: 'errors')
-    end
-
-    should "yield the response" do
-      Elasticsearch::Model::Adapter.expects(:from_class)
-                                   .with(DummyImportingModel)
-                                   .returns(DummyImportingAdapter)
-
-      DummyImportingModel.__send__ :include, Elasticsearch::Model::Importing
-
-      client = mock('client')
-      client.expects(:bulk).returns({'items' => [ {'index' => {}}, {'index' => {'error' => 'FAILED'}} ]})
-
-      DummyImportingModel.stubs(:client).returns(client)
-      DummyImportingModel.stubs(:index_name).returns('foo')
-      DummyImportingModel.stubs(:document_type).returns('foo')
-      DummyImportingModel.stubs(:index_exists?).returns(true)
-      DummyImportingModel.stubs(:__batch_to_bulk)
-
-      DummyImportingModel.import do |response|
-        assert_equal 2, response['items'].size
-      end
-    end
-
-    context "when the index does not exist" do
-      should "raise an exception" do
-        Elasticsearch::Model::Adapter.expects(:from_class)
-                                     .with(DummyImportingModel)
-                                     .returns(DummyImportingAdapter)
-
-        DummyImportingModel.__send__ :include, Elasticsearch::Model::Importing
-
-        DummyImportingModel.expects(:index_name).returns('foo')
-        DummyImportingModel.expects(:document_type).returns('foo')
-        DummyImportingModel.expects(:index_exists?).returns(false)
-
-        assert_raise ArgumentError do
-          DummyImportingModel.import
-        end
-      end
-    end
-
-    context "with the force option" do
-      should "delete and create the index" do
-        DummyImportingModel.expects(:__find_in_batches).with do |options|
-          assert_equal 'bar', options[:foo]
-          assert_nil   options[:force]
-          true
-        end
-
-        DummyImportingModel.expects(:create_index!).with do |options|
-          assert_equal true, options[:force]
-          true
-        end
-
-        DummyImportingModel.expects(:index_name).returns('foo')
-        DummyImportingModel.expects(:document_type).returns('foo')
-
-        DummyImportingModel.import force: true, foo: 'bar'
-      end
-    end
-
-    context "with the refresh option" do
-      should "refresh the index" do
-        DummyImportingModel.expects(:__find_in_batches).with do |options|
-          assert_equal 'bar', options[:foo]
-          assert_nil   options[:refresh]
-          true
-        end
-
-        DummyImportingModel.expects(:refresh_index!).with do |options|
-          assert_equal 'foo', options[:index]
-          true
-        end
-
-        DummyImportingModel.expects(:index_name).returns('foo')
-        DummyImportingModel.expects(:document_type).returns('foo')
-        DummyImportingModel.stubs(:index_exists?).returns(true)
-
-        DummyImportingModel.import refresh: true, foo: 'bar'
-      end
-    end
-
-    should "allow passing a different index / type" do
-      Elasticsearch::Model::Adapter.expects(:from_class)
-                                   .with(DummyImportingModel)
-                                   .returns(DummyImportingAdapter)
-
-      DummyImportingModel.__send__ :include, Elasticsearch::Model::Importing
-
-      client = mock('client')
-
-      client
-        .expects(:bulk)
-          .with do |options|
-            assert_equal 'my-new-index',  options[:index]
-            assert_equal 'my-other-type', options[:type]
-            true
-          end
-        .returns({'items' => [ {'index' => {} }]})
-
-      DummyImportingModel.stubs(:client).returns(client)
-      DummyImportingModel.stubs(:index_exists?).returns(true)
-      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.stubs(:index_exists?).returns(true)
-      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.stubs(:index_exists?).returns(true)
-      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