elasticsearch-model 7.2.1 → 8.0.0.pre

data/spec/elasticsearch/model/indexing_spec.rb

@@ -18,7 +18,6 @@
 require 'spec_helper'
 
 describe Elasticsearch::Model::Indexing do
-
   before(:all) do
     class ::DummyIndexingModel
       extend ActiveModel::Naming
@@ -38,7 +37,6 @@ describe Elasticsearch::Model::Indexing do
   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
@@ -49,13 +47,11 @@ describe Elasticsearch::Model::Indexing do
   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')
@@ -67,7 +63,6 @@ describe Elasticsearch::Model::Indexing do
     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'
@@ -79,7 +74,6 @@ describe Elasticsearch::Model::Indexing do
     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'
@@ -92,68 +86,23 @@ describe Elasticsearch::Model::Indexing do
   end
 
   describe '#mappings' do
-
     let(:expected_mapping_hash) do
-      { :mytype => { foo: 'bar', :properties => {} } }
+      { 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 'does not raise an exception when there is no type passed to the #initialize method' do
-      expect(Elasticsearch::Model::Indexing::Mappings.new)
-    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)
+      expect(Elasticsearch::Model::Indexing::Mappings.new({ 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 a type is specified' 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 field type' do
-        expect(mappings.to_hash[:mytype][:properties][:bar][:type]).to eq('text')
-      end
-
-      context 'when the \'include_type_name\' option is specified' do
-
-        let(:mappings) do
-          Elasticsearch::Model::Indexing::Mappings.new(:mytype, include_type_name: true)
-        end
-
-        before do
-          mappings.indexes :foo, { type: 'boolean', include_in_all: false }
-        end
-
-        it 'creates the correct mapping definition' do
-          expect(mappings.to_hash[:mytype][:properties][:foo][:type]).to eq('boolean')
-        end
-
-        it 'sets the \'include_type_name\' option' do
-          expect(mappings.to_hash[:mytype][:include_type_name]).to eq(true)
-        end
-      end
+      expect(Elasticsearch::Model::Indexing::Mappings.new({ foo: 'bar' }).as_json).to eq(expected_mapping_hash)
     end
 
-    context 'when a type is not specified' do
-
+    context 'basic mappings' do
       let(:mappings) do
         Elasticsearch::Model::Indexing::Mappings.new
       end
@@ -173,9 +122,8 @@ describe Elasticsearch::Model::Indexing do
     end
 
     context 'when specific mappings are defined' do
-
       let(:mappings) do
-        Elasticsearch::Model::Indexing::Mappings.new(:mytype, include_type_name: true)
+        Elasticsearch::Model::Indexing::Mappings.new(include_type_name: true)
       end
 
       before do
@@ -184,15 +132,14 @@ describe Elasticsearch::Model::Indexing do
       end
 
       it 'creates the correct mapping definition' do
-        expect(mappings.to_hash[:mytype][:properties][:foo][:type]).to eq('boolean')
+        expect(mappings.to_hash[: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')
+        expect(mappings.to_hash[: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'
@@ -200,14 +147,13 @@ describe Elasticsearch::Model::Indexing do
         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
+          expect(mappings.to_hash[:properties][:my_field][:type]).to eq('text')
+          expect(mappings.to_hash[:properties][:my_field][:fields][:raw][:type]).to eq('keyword')
+          expect(mappings.to_hash[: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
@@ -227,31 +173,30 @@ describe Elasticsearch::Model::Indexing do
         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[:properties][:foo][:type]).to eq('object')
+          expect(mappings.to_hash[:properties][:foo][:properties][:bar][:type]).to eq('text')
+          expect(mappings.to_hash[: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[:properties][:foo_object][:type]).to eq('object')
+          expect(mappings.to_hash[:properties][:foo_object][:properties][:bar][:type]).to eq('text')
+          expect(mappings.to_hash[: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[:properties][:foo_nested][:type]).to eq('nested')
+          expect(mappings.to_hash[:properties][:foo_nested][:properties][:bar][:type]).to eq('text')
+          expect(mappings.to_hash[: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
+          expect(mappings.to_hash[:properties][:foo_nested_as_symbol][:type]).to eq(:nested)
+          expect(mappings.to_hash[:properties][:foo_nested_as_symbol][:properties]).not_to be_nil
+          expect(mappings.to_hash[:properties][:foo_nested_as_symbol][:fields]).to be_nil
         end
 
         it 'defines the settings' do
-          expect(mappings.to_hash[:mytype][:include_type_name]).to be(true)
+          expect(mappings.to_hash[:include_type_name]).to be(true)
         end
       end
     end
 
     context 'when the method is called on a class' do
-
       before do
         DummyIndexingModel.mappings(foo: 'boo')
         DummyIndexingModel.mappings(bar: 'bam')
@@ -266,7 +211,6 @@ describe Elasticsearch::Model::Indexing do
       end
 
       context 'when the method is called with a block' do
-
         before do
           DummyIndexingModel.mapping do
             indexes :foo, type: 'boolean'
@@ -279,16 +223,14 @@ describe Elasticsearch::Model::Indexing do
       end
 
       context 'when the class has a document_type' do
-
         before do
           DummyIndexingModel.instance_variable_set(:@mapping, nil)
-          DummyIndexingModel.document_type(:mytype)
           DummyIndexingModel.mappings(foo: 'boo')
           DummyIndexingModel.mappings(bar: 'bam')
         end
 
         let(:expected_mappings_hash) do
-          { mytype: { foo: "boo", bar: "bam", properties: {} } }
+          { foo: "boo", bar: "bam", properties: {} }
         end
 
         it 'sets the mappings' do
@@ -299,7 +241,6 @@ describe Elasticsearch::Model::Indexing do
   end
 
   describe 'instance methods' do
-
     before(:all) do
       class ::DummyIndexingModelWithCallbacks
         extend  Elasticsearch::Model::Indexing::ClassMethods
@@ -366,9 +307,7 @@ describe Elasticsearch::Model::Indexing do
     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
@@ -390,7 +329,6 @@ describe Elasticsearch::Model::Indexing do
       end
 
       context 'when the model users the current ActiveModel::Dirty' do
-
         before do
           DummyIndexingModelWithCallbacks.__send__ :include, Elasticsearch::Model::Indexing::InstanceMethods
         end
@@ -413,12 +351,10 @@ describe Elasticsearch::Model::Indexing do
     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).twice.and_return('bar')
         expect(instance).to receive(:id).and_return('1')
       end
 
@@ -431,9 +367,8 @@ describe Elasticsearch::Model::Indexing do
       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)
+          expect(client).to receive(:index).with({ index: 'foo', id: '1', body: 'JSON' }).and_return(true)
         end
 
         it 'provides the method on an instance' do
@@ -442,9 +377,8 @@ describe Elasticsearch::Model::Indexing do
       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)
+          expect(client).to receive(:index).with({ index: 'foo', id: '1', body: 'JSON', parent: 'A' }).and_return(true)
         end
 
         it 'passes the extra options to the method call on the client' do
@@ -454,11 +388,9 @@ describe Elasticsearch::Model::Indexing do
     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).twice.and_return('bar')
         expect(instance).to receive(:id).and_return('1')
       end
 
@@ -471,9 +403,8 @@ describe Elasticsearch::Model::Indexing do
       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)
+          expect(client).to receive(:delete).with({ index: 'foo', id: '1' }).and_return(true)
         end
 
         it 'provides the method on an instance' do
@@ -482,9 +413,8 @@ describe Elasticsearch::Model::Indexing do
       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)
+          expect(client).to receive(:delete).with({ index: 'foo', id: '1', parent: 'A' }).and_return(true)
         end
 
         it 'passes the extra options to the method call on the client' do
@@ -494,7 +424,6 @@ describe Elasticsearch::Model::Indexing do
     end
 
     describe '#update_document' do
-
       let(:client) do
         double('client')
       end
@@ -504,7 +433,6 @@ describe Elasticsearch::Model::Indexing do
       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
@@ -517,19 +445,16 @@ describe Elasticsearch::Model::Indexing do
       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)
+            expect(client).to receive(:update).with({ index: 'foo', id: '1', body: { doc: { foo: 'bar' } } }).and_return(true)
           end
 
           it 'updates the document' do
@@ -538,14 +463,13 @@ describe Elasticsearch::Model::Indexing do
         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)
+            expect(client).to receive(:update).with({ index: 'foo', id: '1', body: { doc: { foo: 'B' } } }).and_return(true)
           end
 
           it 'updates the document' do
@@ -554,7 +478,6 @@ describe Elasticsearch::Model::Indexing do
         end
 
         context 'when none of the changes are included in the as_indexed_json representation' do
-
           let(:instance) do
             DummyIndexingModelWithCallbacksAndCustomAsIndexedJson.new
           end
@@ -569,7 +492,6 @@ describe Elasticsearch::Model::Indexing do
         end
 
         context 'when there are partial updates' do
-
           let(:instance) do
             DummyIndexingModelWithCallbacksAndCustomAsIndexedJson.new
           end
@@ -577,7 +499,7 @@ describe Elasticsearch::Model::Indexing do
           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)
+            expect(client).to receive(:update).with({ index: 'foo', id: '1', body: { doc: { 'foo' => 'BAR' } } }).and_return(true)
           end
 
           it 'updates the document' do
@@ -588,7 +510,6 @@ describe Elasticsearch::Model::Indexing do
     end
 
     describe '#update_document_attributes' do
-
       let(:client) do
         double('client')
       end
@@ -598,19 +519,16 @@ describe Elasticsearch::Model::Indexing do
       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).twice.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)
+            expect(client).to receive(:update).with({ index: 'foo', id: '1', body: { doc: { title: 'green' } } }).and_return(true)
           end
 
           it 'updates the document' do
@@ -619,9 +537,8 @@ describe Elasticsearch::Model::Indexing do
         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)
+            expect(client).to receive(:update).with({ index: 'foo', id: '1', body: { doc: { title: 'green' } }, refresh: true }).and_return(true)
           end
 
           it 'updates the document' do
@@ -633,7 +550,6 @@ describe Elasticsearch::Model::Indexing do
   end
 
   describe '#index_exists?' do
-
     before do
       expect(DummyIndexingModel).to receive(:client).and_return(client)
     end
@@ -649,8 +565,7 @@ describe Elasticsearch::Model::Indexing do
       end
     end
 
-    context 'when the index does not exists' do
-
+    context 'when the index does not exist' do
       let(:client) do
         double('client', indices: double('indices', exists: false))
       end
@@ -662,7 +577,6 @@ describe Elasticsearch::Model::Indexing do
   end
 
   describe '#delete_index!' do
-
     before(:all) do
       class ::DummyIndexingModelForRecreate
         extend ActiveModel::Naming
@@ -677,19 +591,7 @@ describe Elasticsearch::Model::Indexing do
 
     context 'when the index is not found' do
       let(:logger) { nil }
-      let(:transport) do
-        Elasticsearch::Transport::Client.new(logger: logger)
-      end
-
-      let(:client) do
-        double('client', indices: indices, transport: transport)
-      end
-
-      let(:indices) do
-        double('indices').tap do |ind|
-          expect(ind).to receive(:delete).and_raise(NotFound)
-        end
-      end
+      let(:client) { Elasticsearch::Client.new(logger: logger, transport_options: { ssl: { verify: false } }) }
 
       before do
         expect(DummyIndexingModelForRecreate).to receive(:client).at_most(3).times.and_return(client)
@@ -705,32 +607,26 @@ describe Elasticsearch::Model::Indexing do
             Logger.new(STDOUT).tap { |l| l.level = Logger::DEBUG }
           end
 
-          let(:client) do
-            double('client', indices: indices, transport: transport)
-          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(logger).to receive(:debug).at_least(:once)
             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)
+          }.to raise_exception(Elastic::Transport::Transport::Errors::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)
@@ -746,7 +642,6 @@ describe Elasticsearch::Model::Indexing do
     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')
@@ -767,7 +662,6 @@ describe Elasticsearch::Model::Indexing do
   end
 
   describe '#create_index' do
-
     before(:all) do
       class ::DummyIndexingModelForCreate
         extend ActiveModel::Naming
@@ -797,14 +691,12 @@ describe Elasticsearch::Model::Indexing do
     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: { properties: { foo: { analyzer: 'keyword',
                                                      type: 'text' } } },
@@ -812,7 +704,7 @@ describe Elasticsearch::Model::Indexing do
         end
 
         before do
-          expect(indices).to receive(:create).with(index: 'foo', body: expected_body).and_return(true)
+          expect(indices).to receive(:create).with({ index: 'foo', body: expected_body }).and_return(true)
         end
 
         it 'creates the index' do
@@ -821,14 +713,13 @@ describe Elasticsearch::Model::Indexing do
       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)
+          expect(indices).to receive(:create).with({ index: 'foobar', body: expected_body }).and_return(true)
         end
 
         it 'creates the index' do
@@ -842,7 +733,6 @@ describe Elasticsearch::Model::Indexing do
     end
 
     context 'when the index exists' do
-
       before do
         expect(DummyIndexingModelForCreate).to receive(:index_exists?).and_return(true)
         expect(indices).to receive(:create).never
@@ -854,7 +744,6 @@ describe Elasticsearch::Model::Indexing do
     end
 
     context 'when creating the index raises an exception' do
-
       before do
         expect(DummyIndexingModelForCreate).to receive(:client).and_return(client)
         expect(DummyIndexingModelForCreate).to receive(:delete_index!).and_return(true)
@@ -870,11 +759,10 @@ describe Elasticsearch::Model::Indexing do
     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)
+        expect(indices).to receive(:create).with({ index: 'custom-foo', body: expected_body })
       end
 
       let(:expected_body) do
@@ -892,7 +780,6 @@ describe Elasticsearch::Model::Indexing do
   end
 
   describe '#refresh_index!' do
-
     before(:all) do
       class ::DummyIndexingModelForRefresh
         extend ActiveModel::Naming
@@ -914,15 +801,7 @@ describe Elasticsearch::Model::Indexing do
     end
 
     let(:client) do
-      double('client', indices: indices, transport: transport)
-    end
-
-    let(:transport) do
-      Elasticsearch::Transport::Client.new(logger: nil)
-    end
-
-    let(:indices) do
-      double('indices')
+      Elasticsearch::Client.new(logger: nil)
     end
 
     before do
@@ -932,7 +811,7 @@ describe Elasticsearch::Model::Indexing do
     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)
+          expect(client).to receive_message_chain(:indices, :refresh).and_raise(NotFound)
         end
 
         it 'does not raise an exception' do
@@ -945,11 +824,7 @@ describe Elasticsearch::Model::Indexing do
           end
 
           let(:client) do
-            double('client', indices: indices, transport: transport)
-          end
-
-          let(:transport) do
-            Elasticsearch::Transport::Client.new(logger: logger)
+            Elasticsearch::Client.new(logger: logger)
           end
 
           it 'does not raise an exception' do
@@ -965,7 +840,7 @@ describe Elasticsearch::Model::Indexing do
 
       context 'when the operation raises another type of exception' do
         before do
-          expect(indices).to receive(:refresh).and_raise(Exception)
+          expect(client).to receive_message_chain(:indices, :refresh).and_raise(Exception)
         end
 
         it 'does not raise an exception' do
@@ -978,7 +853,7 @@ describe Elasticsearch::Model::Indexing do
 
     context 'when an index name is provided in the options' do
       before do
-        expect(indices).to receive(:refresh).with(index: 'custom-foo')
+        expect(client).to receive_message_chain(:indices, :refresh).with(index: 'custom-foo')
       end
 
       it 'uses the index name' do

data/spec/elasticsearch/model/module_spec.rb

@@ -65,7 +65,6 @@ describe Elasticsearch::Model do
       expect(DummyIncludingModel).to respond_to(:mapping)
       expect(DummyIncludingModel).to respond_to(:settings)
       expect(DummyIncludingModel).to respond_to(:index_name)
-      expect(DummyIncludingModel).to respond_to(:document_type)
       expect(DummyIncludingModel).to respond_to(:import)
     end