elasticsearch-model 6.0.0 → 6.1.0

data/spec/elasticsearch/model/client_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Elasticsearch::Model::Client do
+
+  before(:all) do
+    class ::DummyClientModel
+      extend  Elasticsearch::Model::Client::ClassMethods
+      include Elasticsearch::Model::Client::InstanceMethods
+    end
+  end
+
+  after(:all) do
+    remove_classes(DummyClientModel)
+  end
+
+  context 'when a class includes the client module class methods' do
+
+    it 'defines the client module class methods on the model' do
+      expect(DummyClientModel.client).to be_a(Elasticsearch::Transport::Client)
+    end
+  end
+
+  context 'when a class includes the client module instance methods' do
+
+    it 'defines the client module class methods on the model' do
+      expect(DummyClientModel.new.client).to be_a(Elasticsearch::Transport::Client)
+    end
+  end
+
+  context 'when the client is set on the class' do
+
+    around do |example|
+      original_client = DummyClientModel.client
+      DummyClientModel.client = 'foobar'
+      example.run
+      DummyClientModel.client = original_client
+    end
+
+    it 'sets the client on the class' do
+      expect(DummyClientModel.client).to eq('foobar')
+    end
+
+    it 'sets the client on an instance' do
+      expect(DummyClientModel.new.client).to eq('foobar')
+    end
+  end
+
+  context 'when the client is set on an instance' do
+
+    before do
+      model_instance.client = 'foo'
+    end
+
+    let(:model_instance) do
+      DummyClientModel.new
+    end
+
+    it 'sets the client on an instance' do
+      expect(model_instance.client).to eq('foo')
+    end
+
+    it 'does not set the client on the class' do
+      expect(DummyClientModel.client).to be_a(Elasticsearch::Transport::Client)
+    end
+  end
+end

data/spec/elasticsearch/model/hash_wrapper_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Elasticsearch::Model::HashWrapper, if: Hashie::VERSION >= '3.5.3' do
+
+  before do
+    expect(Hashie.logger).to receive(:warn).never
+  end
+
+  it 'does not print a warning for re-defined methods' do
+    Elasticsearch::Model::HashWrapper.new(:foo => 'bar', :sort => true)
+  end
+end

data/spec/elasticsearch/model/importing_spec.rb

@@ -0,0 +1,214 @@
+require 'spec_helper'
+
+describe Elasticsearch::Model::Importing do
+
+  before(:all) 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
+  end
+
+  after(:all) do
+    remove_classes(DummyImportingModel, DummyImportingAdapter)
+  end
+
+  before do
+    allow(Elasticsearch::Model::Adapter).to receive(:from_class).with(DummyImportingModel).and_return(DummyImportingAdapter)
+    DummyImportingModel.__send__ :include, Elasticsearch::Model::Importing
+  end
+
+  context 'when a model includes the Importing module' do
+
+    it 'provides importing methods' do
+      expect(DummyImportingModel.respond_to?(:import)).to be(true)
+      expect(DummyImportingModel.respond_to?(:__find_in_batches)).to be(true)
+    end
+  end
+
+  describe '#import' do
+
+    before do
+      allow(DummyImportingModel).to receive(:index_name).and_return('foo')
+      allow(DummyImportingModel).to receive(:document_type).and_return('foo')
+      allow(DummyImportingModel).to receive(:index_exists?).and_return(true)
+      allow(DummyImportingModel).to receive(:__batch_to_bulk)
+      allow(client).to receive(:bulk).and_return(response)
+    end
+
+    let(:client) do
+      double('client')
+    end
+
+    let(:response) do
+      { 'items' => [] }
+    end
+
+    context 'when no options are provided' do
+
+      before do
+        expect(DummyImportingModel).to receive(:client).and_return(client)
+        allow(DummyImportingModel).to receive(:index_exists?).and_return(true)
+      end
+
+      it 'uses the client to import documents' do
+        expect(DummyImportingModel.import).to eq(0)
+      end
+    end
+
+    context 'when there is an error' do
+
+      before do
+        expect(DummyImportingModel).to receive(:client).and_return(client)
+        allow(DummyImportingModel).to receive(:index_exists?).and_return(true)
+      end
+
+      let(:response) do
+        { 'items' => [{ 'index' => { } }, { 'index' => { 'error' => 'FAILED' } }] }
+      end
+
+      it 'returns the number of errors' do
+        expect(DummyImportingModel.import).to eq(1)
+      end
+
+      context 'when the method is called with the option to return the errors' do
+
+        it 'returns the errors' do
+          expect(DummyImportingModel.import(return: 'errors')).to eq([{ 'index' => { 'error' => 'FAILED' } }])
+        end
+      end
+
+      context 'when the method is called with a block' do
+
+        it 'yields the response to the block' do
+          DummyImportingModel.import do |response|
+            expect(response['items'].size).to eq(2)
+          end
+        end
+      end
+    end
+
+    context 'when the index does not exist' do
+
+      before do
+        allow(DummyImportingModel).to receive(:index_exists?).and_return(false)
+      end
+
+      it 'raises an exception' do
+        expect {
+          DummyImportingModel.import
+        }.to raise_exception(ArgumentError)
+      end
+    end
+
+    context 'when the method is called with the force option' do
+
+      before do
+        expect(DummyImportingModel).to receive(:create_index!).with(force: true, index: 'foo').and_return(true)
+        expect(DummyImportingModel).to receive(:__find_in_batches).with(foo: 'bar').and_return(true)
+      end
+
+      it 'deletes and creates the index' do
+        expect(DummyImportingModel.import(force: true, foo: 'bar')).to eq(0)
+      end
+    end
+
+    context 'when the method is called with the refresh option' do
+
+      before do
+        expect(DummyImportingModel).to receive(:refresh_index!).with(index: 'foo').and_return(true)
+        expect(DummyImportingModel).to receive(:__find_in_batches).with(foo: 'bar').and_return(true)
+      end
+
+      it 'refreshes the index' do
+        expect(DummyImportingModel.import(refresh: true, foo: 'bar')).to eq(0)
+      end
+    end
+
+    context 'when a different index name is provided' do
+
+      before do
+        expect(DummyImportingModel).to receive(:client).and_return(client)
+        expect(client).to receive(:bulk).with(body: nil, index: 'my-new-index', type: 'foo').and_return(response)
+      end
+
+      it 'uses the alternate index name' do
+        expect(DummyImportingModel.import(index: 'my-new-index')).to eq(0)
+      end
+    end
+
+    context 'when a different document type is provided' do
+
+      before do
+        expect(DummyImportingModel).to receive(:client).and_return(client)
+        expect(client).to receive(:bulk).with(body: nil, index: 'foo', type: 'my-new-type').and_return(response)
+      end
+
+      it 'uses the alternate index name' do
+        expect(DummyImportingModel.import(type: 'my-new-type')).to eq(0)
+      end
+    end
+
+    context 'the transform method' do
+
+      before do
+        expect(DummyImportingModel).to receive(:client).and_return(client)
+        expect(DummyImportingModel).to receive(:__transform).and_return(transform)
+        expect(DummyImportingModel).to receive(:__batch_to_bulk).with(anything, transform)
+      end
+
+      let(:transform) do
+        lambda {|a|}
+      end
+
+      it 'applies the transform method to the results' do
+        expect(DummyImportingModel.import).to eq(0)
+      end
+    end
+
+    context 'when a transform is provided as an option' do
+
+      context 'when the transform option is not a lambda' do
+
+        let(:transform) do
+          'not_callable'
+        end
+
+        it 'raises an error' do
+          expect {
+            DummyImportingModel.import(transform: transform)
+          }.to raise_exception(ArgumentError)
+        end
+      end
+
+      context 'when the transform option is a lambda' do
+
+        before do
+          expect(DummyImportingModel).to receive(:client).and_return(client)
+          expect(DummyImportingModel).to receive(:__batch_to_bulk).with(anything, transform)
+        end
+
+        let(:transform) do
+          lambda {|a|}
+        end
+
+        it 'applies the transform lambda to the results' do
+          expect(DummyImportingModel.import(transform: transform)).to eq(0)
+        end
+      end
+    end
+  end
+end

data/spec/elasticsearch/model/indexing_spec.rb

@@ -0,0 +1,918 @@
+require 'spec_helper'
+
+describe Elasticsearch::Model::Indexing do
+
+  before(:all) do
+    class ::DummyIndexingModel
+      extend ActiveModel::Naming
+      extend Elasticsearch::Model::Naming::ClassMethods
+      extend Elasticsearch::Model::Indexing::ClassMethods
+
+      def self.foo
+        'bar'
+      end
+    end
+
+    class NotFound < Exception; end
+  end
+
+  after(:all) do
+    remove_classes(DummyIndexingModel, NotFound)
+  end
+
+  describe 'the Settings class' do
+
+    it 'should be convertible to a hash' do
+      expect(Elasticsearch::Model::Indexing::Settings.new(foo: 'bar').to_hash).to eq(foo: 'bar')
+    end
+
+    it 'should be convertible to json' do
+      expect(Elasticsearch::Model::Indexing::Settings.new(foo: 'bar').as_json).to eq(foo: 'bar')
+    end
+  end
+
+  describe '#settings' do
+
+    it 'returns an instance of the Settings class' do
+      expect(DummyIndexingModel.settings).to be_a(Elasticsearch::Model::Indexing::Settings)
+    end
+
+    context 'when the settings are updated' do
+
+      before do
+        DummyIndexingModel.settings(foo: 'boo')
+        DummyIndexingModel.settings(bar: 'bam')
+      end
+
+      it 'updates the settings on the class' do
+        expect(DummyIndexingModel.settings.to_hash).to eq(foo: 'boo', bar: 'bam')
+      end
+    end
+
+    context 'when the settings are updated with a yml file' do
+
+      before do
+        DummyIndexingModel.settings File.open('spec/support/model.yml')
+        DummyIndexingModel.settings bar: 'bam'
+      end
+
+      it 'updates the settings on the class' do
+        expect(DummyIndexingModel.settings.to_hash).to eq(foo: 'boo', bar: 'bam', 'baz' => 'qux')
+      end
+    end
+
+    context 'when the settings are updated with a json file' do
+
+      before do
+        DummyIndexingModel.settings File.open('spec/support/model.json')
+        DummyIndexingModel.settings bar: 'bam'
+      end
+
+      it 'updates the settings on the class' do
+        expect(DummyIndexingModel.settings.to_hash).to eq(foo: 'boo', bar: 'bam', 'baz' => 'qux', 'laz' => 'qux')
+      end
+    end
+  end
+
+  describe '#mappings' do
+
+    let(:expected_mapping_hash) do
+      { :mytype => { foo: 'bar', :properties => {} } }
+    end
+
+    it 'returns an instance of the Mappings class' do
+      expect(DummyIndexingModel.mappings).to be_a(Elasticsearch::Model::Indexing::Mappings)
+    end
+
+    it 'raises an exception when there is no type passed to the #initialize method' do
+      expect {
+        Elasticsearch::Model::Indexing::Mappings.new
+      }.to raise_exception(ArgumentError)
+    end
+
+    it 'should be convertible to a hash' do
+      expect(Elasticsearch::Model::Indexing::Mappings.new(:mytype, { foo: 'bar' }).to_hash).to eq(expected_mapping_hash)
+    end
+
+    it 'should be convertible to json' do
+      expect(Elasticsearch::Model::Indexing::Mappings.new(:mytype, { foo: 'bar' }).as_json).to eq(expected_mapping_hash)
+    end
+
+    context 'when specific mappings are defined' do
+
+      let(:mappings) do
+        Elasticsearch::Model::Indexing::Mappings.new(:mytype)
+      end
+
+      before do
+        mappings.indexes :foo, { type: 'boolean', include_in_all: false }
+        mappings.indexes :bar
+      end
+
+      it 'creates the correct mapping definition' do
+        expect(mappings.to_hash[:mytype][:properties][:foo][:type]).to eq('boolean')
+      end
+
+      it 'uses text as the default type' do
+        expect(mappings.to_hash[:mytype][:properties][:bar][:type]).to eq('text')
+      end
+
+      context 'when mappings are defined for multiple fields' do
+
+        before do
+          mappings.indexes :my_field, type: 'text' do
+            indexes :raw, type: 'keyword'
+          end
+        end
+
+        it 'defines the mapping for all the fields' do
+          expect(mappings.to_hash[:mytype][:properties][:my_field][:type]).to eq('text')
+          expect(mappings.to_hash[:mytype][:properties][:my_field][:fields][:raw][:type]).to eq('keyword')
+          expect(mappings.to_hash[:mytype][:properties][:my_field][:fields][:raw][:properties]).to be_nil
+        end
+      end
+
+      context 'when embedded properties are defined' do
+
+        before do
+          mappings.indexes :foo do
+            indexes :bar
+          end
+
+          mappings.indexes :foo_object, type: 'object' do
+            indexes :bar
+          end
+
+          mappings.indexes :foo_nested, type: 'nested' do
+            indexes :bar
+          end
+
+          mappings.indexes :foo_nested_as_symbol, type: :nested do
+            indexes :bar
+          end
+        end
+
+        it 'defines mappings for the embedded properties' do
+          expect(mappings.to_hash[:mytype][:properties][:foo][:type]).to eq('object')
+          expect(mappings.to_hash[:mytype][:properties][:foo][:properties][:bar][:type]).to eq('text')
+          expect(mappings.to_hash[:mytype][:properties][:foo][:fields]).to be_nil
+
+          expect(mappings.to_hash[:mytype][:properties][:foo_object][:type]).to eq('object')
+          expect(mappings.to_hash[:mytype][:properties][:foo_object][:properties][:bar][:type]).to eq('text')
+          expect(mappings.to_hash[:mytype][:properties][:foo_object][:fields]).to be_nil
+
+          expect(mappings.to_hash[:mytype][:properties][:foo_nested][:type]).to eq('nested')
+          expect(mappings.to_hash[:mytype][:properties][:foo_nested][:properties][:bar][:type]).to eq('text')
+          expect(mappings.to_hash[:mytype][:properties][:foo_nested][:fields]).to be_nil
+
+          expect(mappings.to_hash[:mytype][:properties][:foo_nested_as_symbol][:type]).to eq(:nested)
+          expect(mappings.to_hash[:mytype][:properties][:foo_nested_as_symbol][:properties]).not_to be_nil
+          expect(mappings.to_hash[:mytype][:properties][:foo_nested_as_symbol][:fields]).to be_nil
+        end
+      end
+    end
+
+    context 'when the method is called on a class' do
+
+      before do
+        DummyIndexingModel.mappings(foo: 'boo')
+        DummyIndexingModel.mappings(bar: 'bam')
+      end
+
+      let(:expected_mappings_hash) do
+        { _doc: { foo: "boo", bar: "bam", properties: {} } }
+      end
+
+      it 'sets the mappings' do
+        expect(DummyIndexingModel.mappings.to_hash).to eq(expected_mappings_hash)
+      end
+
+      context 'when the method is called with a block' do
+
+        before do
+          DummyIndexingModel.mapping do
+            indexes :foo, type: 'boolean'
+          end
+        end
+
+        it 'sets the mappings' do
+          expect(DummyIndexingModel.mapping.to_hash[:_doc][:properties][:foo][:type]).to eq('boolean')
+        end
+      end
+    end
+  end
+
+  describe 'instance methods' do
+
+    before(:all) do
+      class ::DummyIndexingModelWithCallbacks
+        extend  Elasticsearch::Model::Indexing::ClassMethods
+        include Elasticsearch::Model::Indexing::InstanceMethods
+
+        def self.before_save(&block)
+          (@callbacks ||= {})[block.hash] = block
+        end
+
+        def changes_to_save
+          {:foo => ['One', 'Two']}
+        end
+      end
+
+      class ::DummyIndexingModelWithNoChanges
+        extend  Elasticsearch::Model::Indexing::ClassMethods
+        include Elasticsearch::Model::Indexing::InstanceMethods
+
+        def self.before_save(&block)
+          (@callbacks ||= {})[block.hash] = block
+        end
+
+        def changes_to_save
+          {}
+        end
+      end
+
+      class ::DummyIndexingModelWithCallbacksAndCustomAsIndexedJson
+        extend  Elasticsearch::Model::Indexing::ClassMethods
+        include Elasticsearch::Model::Indexing::InstanceMethods
+
+        def self.before_save(&block)
+          (@callbacks ||= {})[block.hash] = block
+        end
+
+        def changes_to_save
+          {:foo => ['A', 'B'], :bar => ['C', 'D']}
+        end
+
+        def as_indexed_json(options={})
+          { :foo => 'B' }
+        end
+      end
+
+      class ::DummyIndexingModelWithOldDirty
+        extend  Elasticsearch::Model::Indexing::ClassMethods
+        include Elasticsearch::Model::Indexing::InstanceMethods
+
+        def self.before_save(&block)
+          (@callbacks ||= {})[block.hash] = block
+        end
+
+        def changes
+          {:foo => ['One', 'Two']}
+        end
+      end
+    end
+
+    after(:all) do
+      Object.send(:remove_const, :DummyIndexingModelWithCallbacks) if defined?(DummyIndexingModelWithCallbacks)
+      Object.send(:remove_const, :DummyIndexingModelWithNoChanges) if defined?(DummyIndexingModelWithNoChanges)
+      Object.send(:remove_const, :DummyIndexingModelWithCallbacksAndCustomAsIndexedJson) if defined?(DummyIndexingModelWithCallbacksAndCustomAsIndexedJson)
+      Object.send(:remove_const, :DummyIndexingModelWithOldDirty) if defined?(DummyIndexingModelWithOldDirty)
+    end
+
+    context 'when the module is included' do
+
+      context 'when the model uses the old ActiveModel::Dirty' do
+
+        before do
+          DummyIndexingModelWithOldDirty.__send__ :include, Elasticsearch::Model::Indexing::InstanceMethods
+        end
+
+        it 'registers callbacks' do
+          expect(DummyIndexingModelWithOldDirty.instance_variable_get(:@callbacks)).not_to be_empty
+        end
+
+        let(:instance) do
+          DummyIndexingModelWithOldDirty.new
+        end
+
+        it 'sets the @__changed_model_attributes variable before the callback' do
+          DummyIndexingModelWithOldDirty.instance_variable_get(:@callbacks).each do |n, callback|
+            instance.instance_eval(&callback)
+            expect(instance.instance_variable_get(:@__changed_model_attributes)).to eq(foo: 'Two')
+          end
+        end
+      end
+
+      context 'when the model users the current ActiveModel::Dirty' do
+
+        before do
+          DummyIndexingModelWithCallbacks.__send__ :include, Elasticsearch::Model::Indexing::InstanceMethods
+        end
+
+        it 'registers callbacks' do
+          expect(DummyIndexingModelWithCallbacks.instance_variable_get(:@callbacks)).not_to be_empty
+        end
+
+        let(:instance) do
+          DummyIndexingModelWithCallbacks.new
+        end
+
+        it 'sets the @__changed_model_attributes variable before the callback' do
+          DummyIndexingModelWithCallbacks.instance_variable_get(:@callbacks).each do |n, callback|
+            instance.instance_eval(&callback)
+            expect(instance.instance_variable_get(:@__changed_model_attributes)).to eq(foo: 'Two')
+          end
+        end
+      end
+    end
+
+    describe '#index_document' do
+
+      before do
+        expect(instance).to receive(:client).and_return(client)
+        expect(instance).to receive(:as_indexed_json).and_return('JSON')
+        expect(instance).to receive(:index_name).and_return('foo')
+        expect(instance).to receive(:document_type).and_return('bar')
+        expect(instance).to receive(:id).and_return('1')
+      end
+
+      let(:client) do
+        double('client')
+      end
+
+      let(:instance) do
+        DummyIndexingModelWithCallbacks.new
+      end
+
+      context 'when no options are passed to the method' do
+
+        before do
+          expect(client).to receive(:index).with(index: 'foo', type: 'bar', id: '1', body: 'JSON').and_return(true)
+        end
+
+        it 'provides the method on an instance' do
+          expect(instance.index_document).to be(true)
+        end
+      end
+
+      context 'when extra options are passed to the method' do
+
+        before do
+          expect(client).to receive(:index).with(index: 'foo', type: 'bar', id: '1', body: 'JSON', parent: 'A').and_return(true)
+        end
+
+        it 'passes the extra options to the method call on the client' do
+          expect(instance.index_document(parent: 'A')).to be(true)
+        end
+      end
+    end
+
+    describe '#delete_document' do
+
+      before do
+        expect(instance).to receive(:client).and_return(client)
+        expect(instance).to receive(:index_name).and_return('foo')
+        expect(instance).to receive(:document_type).and_return('bar')
+        expect(instance).to receive(:id).and_return('1')
+      end
+
+      let(:client) do
+        double('client')
+      end
+
+      let(:instance) do
+        DummyIndexingModelWithCallbacks.new
+      end
+
+      context 'when no options are passed to the method' do
+
+        before do
+          expect(client).to receive(:delete).with(index: 'foo', type: 'bar', id: '1').and_return(true)
+        end
+
+        it 'provides the method on an instance' do
+          expect(instance.delete_document).to be(true)
+        end
+      end
+
+      context 'when extra options are passed to the method' do
+
+        before do
+          expect(client).to receive(:delete).with(index: 'foo', type: 'bar', id: '1', parent: 'A').and_return(true)
+        end
+
+        it 'passes the extra options to the method call on the client' do
+          expect(instance.delete_document(parent: 'A')).to be(true)
+        end
+      end
+    end
+
+    describe '#update_document' do
+
+      let(:client) do
+        double('client')
+      end
+
+      let(:instance) do
+        DummyIndexingModelWithCallbacks.new
+      end
+
+      context 'when no changes are present' do
+
+        before do
+          expect(instance).to receive(:index_document).and_return(true)
+          expect(client).to receive(:update).never
+          instance.instance_variable_set(:@__changed_model_attributes, nil)
+        end
+
+        it 'updates the document' do
+          expect(instance.update_document).to be(true)
+        end
+      end
+
+      context 'when changes are present' do
+
+        before do
+          allow(instance).to receive(:client).and_return(client)
+          allow(instance).to receive(:index_name).and_return('foo')
+          allow(instance).to receive(:document_type).and_return('bar')
+          allow(instance).to receive(:id).and_return('1')
+        end
+
+        context 'when the changes are included in the as_indexed_json representation' do
+
+          before do
+            instance.instance_variable_set(:@__changed_model_attributes, { foo: 'bar' })
+            expect(client).to receive(:update).with(index: 'foo', type: 'bar', id: '1', body: { doc: { foo: 'bar' } }).and_return(true)
+          end
+
+          it 'updates the document' do
+            expect(instance.update_document).to be(true)
+          end
+        end
+
+        context 'when the changes are not all included in the as_indexed_json representation' do
+
+          let(:instance) do
+            DummyIndexingModelWithCallbacksAndCustomAsIndexedJson.new
+          end
+
+          before do
+            instance.instance_variable_set(:@__changed_model_attributes, {'foo' => 'B', 'bar' => 'D' })
+            expect(client).to receive(:update).with(index: 'foo', type: 'bar', id: '1', body: { doc: { foo: 'B' } }).and_return(true)
+          end
+
+          it 'updates the document' do
+            expect(instance.update_document).to be(true)
+          end
+        end
+
+        context 'when none of the changes are included in the as_indexed_json representation' do
+
+          let(:instance) do
+            DummyIndexingModelWithCallbacksAndCustomAsIndexedJson.new
+          end
+
+          before do
+            instance.instance_variable_set(:@__changed_model_attributes, {'bar' => 'D' })
+          end
+
+          it 'does not update the document' do
+            expect(instance.update_document).to_not be(true)
+          end
+        end
+
+        context 'when there are partial updates' do
+
+          let(:instance) do
+            DummyIndexingModelWithCallbacksAndCustomAsIndexedJson.new
+          end
+
+          before do
+            instance.instance_variable_set(:@__changed_model_attributes, { 'foo' => { 'bar' => 'BAR'} })
+            expect(instance).to receive(:as_indexed_json).and_return('foo' => 'BAR')
+            expect(client).to receive(:update).with(index: 'foo', type: 'bar', id: '1', body: { doc: { 'foo' => 'BAR' } }).and_return(true)
+          end
+
+          it 'updates the document' do
+            expect(instance.update_document).to be(true)
+          end
+        end
+      end
+    end
+
+    describe '#update_document_attributes' do
+
+      let(:client) do
+        double('client')
+      end
+
+      let(:instance) do
+        DummyIndexingModelWithCallbacks.new
+      end
+
+      context 'when changes are present' do
+
+        before do
+          expect(instance).to receive(:client).and_return(client)
+          expect(instance).to receive(:index_name).and_return('foo')
+          expect(instance).to receive(:document_type).and_return('bar')
+          expect(instance).to receive(:id).and_return('1')
+          instance.instance_variable_set(:@__changed_model_attributes, { author: 'john' })
+        end
+
+        context 'when no options are specified' do
+
+          before do
+            expect(client).to receive(:update).with(index: 'foo', type: 'bar', id: '1', body: { doc: { title: 'green' } }).and_return(true)
+          end
+
+          it 'updates the document' do
+            expect(instance.update_document_attributes(title: 'green')).to be(true)
+          end
+        end
+
+        context 'when extra options are provided' do
+
+          before do
+            expect(client).to receive(:update).with(index: 'foo', type: 'bar', id: '1', body: { doc: { title: 'green' } }, refresh: true).and_return(true)
+          end
+
+          it 'updates the document' do
+            expect(instance.update_document_attributes({ title: 'green' }, refresh: true)).to be(true)
+          end
+        end
+      end
+    end
+  end
+
+  describe '#index_exists?' do
+
+    before do
+      expect(DummyIndexingModel).to receive(:client).and_return(client)
+    end
+
+    context 'when the index exists' do
+
+      let(:client) do
+        double('client', indices: double('indices', exists: true))
+      end
+
+      it 'returns true' do
+        expect(DummyIndexingModel.index_exists?).to be(true)
+      end
+    end
+
+    context 'when the index does not exists' do
+
+      let(:client) do
+        double('client', indices: double('indices', exists: false))
+      end
+
+      it 'returns false' do
+        expect(DummyIndexingModel.index_exists?).to be(false)
+      end
+    end
+
+    context 'when the index API raises an error' do
+
+      let(:client) do
+        double('client').tap do |cl|
+          expect(cl).to receive(:indices).and_raise(StandardError)
+        end
+      end
+
+      it 'returns false' do
+        expect(DummyIndexingModel.index_exists?).to be(false)
+      end
+    end
+
+    context 'when the indices.exists API raises an error' do
+
+      let(:client) do
+        double('client', indices: indices)
+      end
+
+      let(:indices) do
+        double('indices').tap do |ind|
+          expect(ind).to receive(:exists).and_raise(StandardError)
+        end
+      end
+
+      it 'returns false' do
+        expect(DummyIndexingModel.index_exists?).to be(false)
+      end
+    end
+  end
+
+  describe '#delete_index!' do
+
+    before(:all) do
+      class ::DummyIndexingModelForRecreate
+        extend ActiveModel::Naming
+        extend Elasticsearch::Model::Naming::ClassMethods
+        extend Elasticsearch::Model::Indexing::ClassMethods
+      end
+    end
+
+    after(:all) do
+      Object.send(:remove_const, :DummyIndexingModelForRecreate) if defined?(DummyIndexingModelForRecreate)
+    end
+
+    context 'when the index is not found' do
+
+      let(:client) do
+        double('client', indices: indices, transport: double('transport', { logger: nil }))
+      end
+
+      let(:indices) do
+        double('indices').tap do |ind|
+          expect(ind).to receive(:delete).and_raise(NotFound)
+        end
+      end
+
+      before do
+        expect(DummyIndexingModelForRecreate).to receive(:client).at_most(3).times.and_return(client)
+      end
+
+      context 'when the force option is true' do
+
+        it 'deletes the index without raising an exception' do
+          expect(DummyIndexingModelForRecreate.delete_index!(force: true)).to be_nil
+        end
+
+        context 'when the client has a logger' do
+
+          let(:logger) do
+            Logger.new(STDOUT).tap { |l| l.level = Logger::DEBUG }
+          end
+
+          let(:client) do
+            double('client', indices: indices, transport: double('transport', { logger: logger }))
+          end
+
+          it 'deletes the index without raising an exception' do
+            expect(DummyIndexingModelForRecreate.delete_index!(force: true)).to be_nil
+          end
+
+          it 'logs the message that the index is not found' do
+            expect(logger).to receive(:debug)
+            expect(DummyIndexingModelForRecreate.delete_index!(force: true)).to be_nil
+          end
+        end
+      end
+
+      context 'when the force option is not provided' do
+
+        it 'raises an exception' do
+          expect {
+            DummyIndexingModelForRecreate.delete_index!
+          }.to raise_exception(NotFound)
+        end
+      end
+
+      context 'when the exception is not NotFound' do
+
+        let(:indices) do
+          double('indices').tap do |ind|
+            expect(ind).to receive(:delete).and_raise(Exception)
+          end
+        end
+
+        it 'raises an exception' do
+          expect {
+            DummyIndexingModelForRecreate.delete_index!
+          }.to raise_exception(Exception)
+        end
+      end
+    end
+
+    context 'when an index name is provided in the options' do
+
+      before do
+        expect(DummyIndexingModelForRecreate).to receive(:client).and_return(client)
+        expect(indices).to receive(:delete).with(index: 'custom-foo')
+      end
+
+      let(:client) do
+        double('client', indices: indices)
+      end
+
+      let(:indices) do
+        double('indices', delete: true)
+      end
+
+      it 'uses the index name' do
+        expect(DummyIndexingModelForRecreate.delete_index!(index: 'custom-foo'))
+      end
+    end
+  end
+
+  describe '#create_index' do
+
+    before(:all) do
+      class ::DummyIndexingModelForCreate
+        extend ActiveModel::Naming
+        extend Elasticsearch::Model::Naming::ClassMethods
+        extend Elasticsearch::Model::Indexing::ClassMethods
+
+        index_name 'foo'
+
+        settings index: { number_of_shards: 1 } do
+          mappings do
+            indexes :foo, analyzer: 'keyword'
+          end
+        end
+      end
+    end
+
+    after(:all) do
+      Object.send(:remove_const, :DummyIndexingModelForCreate) if defined?(DummyIndexingModelForCreate)
+    end
+
+    let(:client) do
+      double('client', indices: indices)
+    end
+
+    let(:indices) do
+      double('indices')
+    end
+
+    context 'when the index does not exist' do
+
+      before do
+        expect(DummyIndexingModelForCreate).to receive(:client).and_return(client)
+        expect(DummyIndexingModelForCreate).to receive(:index_exists?).and_return(false)
+      end
+
+      context 'when options are not provided' do
+
+        let(:expected_body) do
+          { mappings: { _doc: { properties: { foo: { analyzer: 'keyword',
+                                                     type: 'text' } } } },
+            settings: { index: { number_of_shards: 1 } } }
+        end
+
+        before do
+          expect(indices).to receive(:create).with(index: 'foo', body: expected_body).and_return(true)
+        end
+
+        it 'creates the index' do
+          expect(DummyIndexingModelForCreate.create_index!).to be(true)
+        end
+      end
+
+      context 'when options are provided' do
+
+        let(:expected_body) do
+          { mappings: { foobar: { properties: { foo: { analyzer: 'bar' } } } },
+            settings: { index: { number_of_shards: 3 } } }
+        end
+
+        before do
+          expect(indices).to receive(:create).with(index: 'foobar', body: expected_body).and_return(true)
+        end
+
+        it 'creates the index' do
+          expect(DummyIndexingModelForCreate.create_index! \
+            index: 'foobar',
+            settings: { index: { number_of_shards: 3 } },
+            mappings: { foobar: { properties: { foo: { analyzer: 'bar' } } } }
+          ).to be(true)
+        end
+      end
+    end
+
+    context 'when the index exists' do
+
+      before do
+        expect(DummyIndexingModelForCreate).to receive(:index_exists?).and_return(true)
+        expect(indices).to receive(:create).never
+      end
+
+      it 'does not create the index' do
+        expect(DummyIndexingModelForCreate.create_index!).to be_nil
+      end
+    end
+
+    context 'when creating the index raises an exception' do
+
+      before do
+        expect(DummyIndexingModelForCreate).to receive(:client).and_return(client)
+        expect(DummyIndexingModelForCreate).to receive(:index_exists?).and_return(false)
+        expect(DummyIndexingModelForCreate).to receive(:delete_index!).and_return(true)
+        expect(indices).to receive(:create).and_raise(Exception)
+      end
+
+      it 'raises the exception' do
+        expect {
+          DummyIndexingModelForCreate.create_index!(force: true)
+        }.to raise_exception(Exception)
+      end
+    end
+
+    context 'when an index name is provided in the options' do
+
+      before do
+        expect(DummyIndexingModelForCreate).to receive(:client).and_return(client).twice
+        expect(indices).to receive(:exists).and_return(false)
+        expect(indices).to receive(:create).with(index: 'custom-foo', body: expected_body)
+      end
+
+      let(:expected_body) do
+        { mappings: { _doc: { properties: { foo: { analyzer: 'keyword',
+                                                   type: 'text' } } } },
+          settings: { index: { number_of_shards: 1 } } }
+      end
+
+      it 'uses the index name' do
+        expect(DummyIndexingModelForCreate.create_index!(index: 'custom-foo'))
+      end
+    end
+
+    context 'when the logging level is debug'
+  end
+
+  describe '#refresh_index!' do
+
+    before(:all) do
+      class ::DummyIndexingModelForRefresh
+        extend ActiveModel::Naming
+        extend Elasticsearch::Model::Naming::ClassMethods
+        extend Elasticsearch::Model::Indexing::ClassMethods
+
+        index_name 'foo'
+
+        settings index: { number_of_shards: 1 } do
+          mappings do
+            indexes :foo, analyzer: 'keyword'
+          end
+        end
+      end
+    end
+
+    after(:all) do
+      Object.send(:remove_const, :DummyIndexingModelForRefresh) if defined?(DummyIndexingModelForRefresh)
+    end
+
+    let(:client) do
+      double('client', indices: indices, transport: double('transport', { logger: nil }))
+    end
+
+    let(:indices) do
+      double('indices')
+    end
+
+    before do
+      expect(DummyIndexingModelForRefresh).to receive(:client).at_most(3).times.and_return(client)
+    end
+
+    context 'when the force option is true' do
+
+      context 'when the operation raises a NotFound exception' do
+
+        before do
+          expect(indices).to receive(:refresh).and_raise(NotFound)
+        end
+
+        it 'does not raise an exception' do
+          expect(DummyIndexingModelForRefresh.refresh_index!(force: true)).to be_nil
+        end
+
+        context 'when the client has a logger' do
+
+          let(:logger) do
+            Logger.new(STDOUT).tap { |l| l.level = Logger::DEBUG }
+          end
+
+          let(:client) do
+            double('client', indices: indices, transport: double('transport', { logger: logger }))
+          end
+
+          it 'does not raise an exception' do
+            expect(DummyIndexingModelForRefresh.refresh_index!(force: true)).to be_nil
+          end
+
+          it 'logs the message that the index is not found' do
+            expect(logger).to receive(:debug)
+            expect(DummyIndexingModelForRefresh.refresh_index!(force: true)).to be_nil
+          end
+        end
+      end
+
+      context 'when the operation raises another type of exception' do
+
+        before do
+          expect(indices).to receive(:refresh).and_raise(Exception)
+        end
+
+        it 'does not raise an exception' do
+          expect {
+            DummyIndexingModelForRefresh.refresh_index!(force: true)
+          }.to raise_exception(Exception)
+        end
+      end
+    end
+
+    context 'when an index name is provided in the options' do
+
+      before do
+        expect(indices).to receive(:refresh).with(index: 'custom-foo')
+      end
+
+      it 'uses the index name' do
+        expect(DummyIndexingModelForRefresh.refresh_index!(index: 'custom-foo'))
+      end
+    end
+  end
+end