chewy 0.6.2 → 0.7.0

data/lib/chewy/type/import.rb

@@ -26,8 +26,9 @@ module Chewy
 
           ActiveSupport::Notifications.instrument 'import_objects.chewy', type: self do |payload|
             adapter.import(*args, import_options) do |action_objects|
-              indexed_objects = self.root_object.parent_id && fetch_indexed_objects(action_objects.values.flatten, bulk_options)
+              indexed_objects = self.root_object.parent_id && fetch_indexed_objects(action_objects.values.flatten)
               body = bulk_body(action_objects, indexed_objects)
+
               errors = bulk(bulk_options.merge(body: body)) if body.any?
 
               fill_payload_import payload, action_objects
@@ -76,33 +77,54 @@ module Chewy
 
         def bulk_body(action_objects, indexed_objects = nil)
           action_objects.inject([]) do |result, (action, objects)|
-            result.concat(objects.map { |object| bulk_entries(action, object, indexed_objects) }.flatten)
+            method = "#{action}_bulk_entry"
+            result.concat(objects.map { |object| send(method, object, indexed_objects) }.flatten)
           end
         end
 
-        def bulk_entries(action, object, indexed_objects = nil)
+        def delete_bulk_entry(object, indexed_objects = nil)
           entry = {}
 
-          entry[:_id] = object.respond_to?(:id) ? object.id : object
-          entry[:_id] = entry[:_id].to_s if defined?(BSON) && entry[:_id].is_a?(BSON::ObjectId)
-          entry[:data] = object_data(object) unless action == :delete
+          if self.root_object.id
+            entry[:_id] = self.root_object.compose_id(object)
+          else
+            entry[:_id] = object.id if object.respond_to?(:id)
+            entry[:_id] ||= object[:id] || object['id'] if object.is_a?(Hash)
+            entry[:_id] ||= object
+            entry[:_id] = entry[:_id].to_s if defined?(BSON) && entry[:_id].is_a?(BSON::ObjectId)
+          end
 
           if self.root_object.parent_id
-            entry[:parent] = self.root_object.compose_parent(object) if object.respond_to?(:id)
+            existing_object = entry[:_id].present? && indexed_objects && indexed_objects[entry[:_id].to_s]
+            entry.merge!(parent: existing_object[:parent]) if existing_object
           end
-          
+
+          [{ delete: entry }]
+        end
+
+        def index_bulk_entry(object, indexed_objects = nil)
+          entry = {}
+
           if self.root_object.id
             entry[:_id] = self.root_object.compose_id(object)
+          else
+            entry[:_id] = object.id if object.respond_to?(:id)
+            entry[:_id] ||= object[:id] || object['id'] if object.is_a?(Hash)
+            entry[:_id] = entry[:_id].to_s if defined?(BSON) && entry[:_id].is_a?(BSON::ObjectId)
+          end
+          entry.delete(:_id) if entry[:_id].blank?
+
+          if self.root_object.parent_id
+            entry[:parent] = self.root_object.compose_parent(object)
+            existing_object = entry[:_id].present? && indexed_objects && indexed_objects[entry[:_id].to_s]
           end
 
-          indexed_object = indexed_objects && indexed_objects[entry[:_id].to_s]
+          entry[:data] = object_data(object)
 
-          if indexed_object && self.root_object.parent_id && action == :delete
-            [{ action => entry.merge(parent: indexed_object[:parent]) }]
-          elsif indexed_object && self.root_object.parent_id && entry[:parent].to_s != indexed_object[:parent]
-            [{ :delete => entry.except(:data).merge(parent: indexed_object[:parent]) }, { action => entry }]
+          if existing_object && entry[:parent].to_s != existing_object[:parent]
+            [{ delete: entry.except(:data).merge(parent: existing_object[:parent]) }, { index: entry }]
           else
-            [{ action => entry }]
+            [{ index: entry }]
           end
         end
 
@@ -143,9 +165,14 @@ module Chewy
           end.reduce(&:merge) || {}
         end
 
-        def fetch_indexed_objects(objects, options = {})
+        def fetch_indexed_objects(objects)
           ids = objects.map { |object| object.respond_to?(:id) ? object.id : object }
-          result = client.search index: index.build_index_name(suffix: options[:suffix]), type: type_name, fields: '_parent', body: { query: { ids: { values: ids } } }, search_type: 'scan', scroll: '1m'
+          result = client.search index: index_name,
+                                 type: type_name,
+                                 fields: '_parent',
+                                 body: { filter: { ids: { values: ids } } },
+                                 search_type: 'scan',
+                                 scroll: '1m'
 
           indexed_objects = {}
 

data/lib/chewy/type/observe.rb

@@ -31,7 +31,7 @@ module Chewy
           method = args.first
 
           update = Proc.new do
-            clear_association_cache if Chewy.urgent_update
+            # clear_association_cache if Chewy.strategy.current.name == :urgent
 
             backreference = if method && method.to_s == 'self'
               self
@@ -44,31 +44,18 @@ module Chewy
             Chewy.derive_type(type_name).update_index(backreference, options)
           end
 
-          after_save &update
-          after_destroy &update
+          if Chewy.use_after_commit_callbacks
+            after_commit &update
+          else
+            after_save &update
+            after_destroy &update
+          end
         end
       end
 
       module ClassMethods
         def update_index(objects, options = {})
-          if Chewy.atomic?
-            relation = (defined?(::ActiveRecord) && objects.is_a?(::ActiveRecord::Relation)) ||
-                       (defined?(::Mongoid) && objects.is_a?(::Mongoid::Criteria))
-
-            ids = if relation
-              objects.pluck(:id)
-            else
-              Array.wrap(objects).map { |object| object.respond_to?(:id) ? object.id : object.to_i }
-            end
-
-            Chewy.stash self, ids
-          elsif options[:urgent]
-            ActiveSupport::Deprecation.warn("`urgent: true` option is deprecated and will be removed soon, use `Chewy.atomic` block instead")
-            import(objects)
-          elsif Chewy.urgent_update
-            import(objects)
-          end if objects
-
+          Chewy.strategy.current.update(self, objects, options)
           true
         end
       end

data/lib/chewy/version.rb

@@ -1,3 +1,3 @@
 module Chewy
-  VERSION = '0.6.2'
+  VERSION = '0.7.0'
 end

data/lib/tasks/chewy.rake

@@ -1,7 +1,7 @@
 def subscribe_task_stats!
   ActiveSupport::Notifications.subscribe('import_objects.chewy') do |name, start, finish, id, payload|
-    duration = ((finish - start).to_f * 100).round / 100.0
-    puts "  Imported #{payload[:type]} for #{duration}s, documents total: #{payload[:import]}"
+    duration = (finish - start).round(2)
+    puts "  Imported #{payload[:type]} for #{duration}s, documents total: #{payload[:import].try(:[], :index).to_i}"
     payload[:errors].each do |action, errors|
       puts "    #{action.to_s.humanize} errors:"
       errors.each do |error, documents|
@@ -13,8 +13,12 @@ def subscribe_task_stats!
 end
 
 def eager_load_chewy!
-  Rails.application.config.paths['app/chewy'].existent.each do |dir|
-    Dir.glob(File.join(dir, '**/*.rb')).each { |file| require_dependency file }
+  dirs = Chewy::Railtie.all_engines.map { |engine| engine.paths['app/chewy'].existent }.flatten.uniq
+
+  dirs.each do |dir|
+    Dir.glob(File.join(dir, '**/*.rb')).each do |file|
+      require_dependency file
+    end
   end
 end
 

data/spec/chewy/config_spec.rb

@@ -3,110 +3,33 @@ require 'spec_helper'
 describe Chewy::Config do
   subject { described_class.send(:new) }
 
+  its(:logger) { should be_nil }
+  its(:transport_logger) { should be_nil }
+  its(:transport_logger) { should be_nil }
   its(:query_mode) { should == :must }
   its(:filter_mode) { should == :and }
   its(:post_filter_mode) { should be_nil }
-  its(:logger) { should be_nil }
-  its(:configuration) { should_not have_key :logger }
-  its(:analyzers) { should == {} }
-  its(:tokenizers) { should == {} }
-  its(:filters) { should == {} }
-  its(:char_filters) { should == {} }
-
-  describe '#analyzer' do
-    specify { expect(subject.analyzer(:name)).to be_nil }
-
-    context do
-      before { subject.analyzer(:name, option: :foo) }
-      specify { expect(subject.analyzer(:name)).to eq({option: :foo}) }
-      specify { expect(subject.analyzers).to eq({name: {option: :foo}}) }
-    end
-  end
-
-  describe '#tokenizer' do
-    specify { expect(subject.tokenizer(:name)).to be_nil }
-
-    context do
-      before { subject.tokenizer(:name, option: :foo) }
-      specify { expect(subject.tokenizer(:name)).to eq({option: :foo}) }
-      specify { expect(subject.tokenizers).to eq({name: {option: :foo}}) }
-    end
-  end
-
-  describe '#filter' do
-    specify { expect(subject.filter(:name)).to be_nil }
-
-    context do
-      before { subject.filter(:name, option: :foo) }
-      specify { expect(subject.filter(:name)).to eq({option: :foo}) }
-      specify { expect(subject.filters).to eq({name: {option: :foo}}) }
-    end
-  end
+  its(:root_strategy) { should == :base }
+  its(:request_strategy) { should == :atomic }
+  its(:use_after_commit_callbacks) { should == true }
 
-  describe '#char_filter' do
-    specify { expect(subject.char_filter(:name)).to be_nil }
+  describe '#transport_logger=' do
+    let(:logger) { Logger.new('/dev/null') }
+    after { subject.transport_logger = nil }
 
-    context do
-      before { subject.char_filter(:name, option: :foo) }
-      specify { expect(subject.char_filter(:name)).to eq({option: :foo}) }
-      specify { expect(subject.char_filters).to eq({name: {option: :foo}}) }
-    end
+    specify { expect { subject.transport_logger = logger }
+      .to change { Chewy.client.transport.logger }.to(logger) }
+    specify { expect { subject.transport_logger = logger }
+      .to change { subject.transport_logger }.to(logger) }
   end
 
-  describe '#logger' do
-    before { subject.logger = double(:logger) }
-
-    its(:logger) { should_not be_nil }
-    its(:configuration) { should have_key :logger }
-  end
-
-  describe '#atomic?' do
-    its(:atomic?) { should eq(false) }
-    specify { subject.atomic { expect(subject.atomic?).to eq(true) } }
-    specify { subject.atomic { }; expect(subject.atomic?).to eq(false) }
-  end
-
-  describe '#atomic' do
-    before do
-      stub_index(:dummies) do
-        define_type :dummy
-      end
-    end
-    let(:dummy_type) { DummiesIndex::Dummy }
-
-    specify { expect(subject.atomic { 42 }).to eq(42) }
-    specify { expect { subject.atomic { subject.stash Class.new, 42 } }.to raise_error ArgumentError }
-    specify { subject.atomic { subject.atomic { expect(subject.stash).to eq([{}, {}]) } } }
-
-    specify do
-      expect(dummy_type).to receive(:import).with([1, 2, 3]).once
-      subject.atomic do
-        subject.stash dummy_type, [1, 2]
-        subject.stash dummy_type, [2, 3]
-      end
-    end
-
-    specify do
-      expect(dummy_type).to receive(:import).with([1, 2]).once
-      subject.atomic do
-        subject.stash dummy_type, [1, 2]
-        raise
-      end rescue nil
-    end
-
-    specify do
-      expect(dummy_type).to receive(:import).with([2, 3]).once
-      expect(dummy_type).to receive(:import).with([1, 2]).once
-      subject.atomic do
-        subject.stash dummy_type, [2, 3]
-        subject.atomic do
-          subject.stash dummy_type, [1, 2]
-        end
-      end
-    end
-  end
+  describe '#transport_tracer=' do
+    let(:logger) { Logger.new('/dev/null') }
+    after { subject.transport_tracer = nil }
 
-  describe '#stash' do
-    specify { subject.atomic { expect(subject.stash).to eq([{}]) } }
+    specify { expect { subject.transport_tracer = logger }
+      .to change { Chewy.client.transport.tracer }.to(logger) }
+    specify { expect { subject.transport_tracer = logger }
+      .to change { subject.transport_tracer }.to(logger) }
   end
 end

data/spec/chewy/fields/base_spec.rb

@@ -12,7 +12,7 @@ describe Chewy::Fields::Base do
 
     specify { expect(described_class.new(:name).compose(double(name: 'hello'))).to eq({name: 'hello'}) }
 
-    context do
+    context 'nested fields' do
       before do
         field.nested(described_class.new(:subname1, value: ->(o){ o.subvalue1 }))
         field.nested(described_class.new(:subname2, value: ->{ subvalue2 }))
@@ -30,7 +30,22 @@ describe Chewy::Fields::Base do
       ]}) }
     end
 
-    context do
+    context 'parent objects' do
+      let!(:country) { described_class.new(:name, value: ->(country){ country.cities }) }
+      let!(:city) { country.nested(described_class.new(:name, value: ->(city, country) { city.districts.map { |district| [district, country.name] } })) }
+      let!(:district) { city.nested(described_class.new(:name, value: ->(district, city, country) { [district, city.name, country.name] })) }
+
+      specify { expect(country.compose(double(name: 'Thailand', cities: [
+        double(name: 'Bangkok', districts: ['First', 'Second'])
+      ]))).to eq(name: [
+        { 'name' => [
+          { 'name' => [['First', 'Thailand'], 'Bangkok', 'Thailand'] },
+          { 'name' => [['Second', 'Thailand'], 'Bangkok', 'Thailand'] }
+        ] }
+      ]) }
+    end
+
+    context 'implicit values' do
       let(:field) { described_class.new(:name, type: 'string') }
       before do
         field.nested(described_class.new(:name))
@@ -40,7 +55,7 @@ describe Chewy::Fields::Base do
       specify { expect(field.compose(double(name: 'Alex'))).to eq({name: 'Alex'}) }
     end
 
-    context do
+    context 'hash values' do
       let(:field) { described_class.new(:name, type: 'object') }
       let(:object) { double(name: { key1: 'value1', key2: 'value2' }) }
 
@@ -134,7 +149,7 @@ describe Chewy::Fields::Base do
         ])).to eq({
           event: { 'id' => 1, 'category' => [
             { 'id' => 2, 'licenses' => { 'id' => 3, 'name' => 'Name1' } },
-            {'id' => 4, 'licenses' => nil }
+            {'id' => 4, 'licenses' => nil.as_json }
           ] }
         })
       end
@@ -180,7 +195,7 @@ describe Chewy::Fields::Base do
         ]))).to eq({
           event: { 'id' => 1, 'category' => [
             { 'id' => 2, 'licenses' => { 'id' => 3, 'name' => 'Name1' } },
-            {'id' => 4, 'licenses' => nil }
+            {'id' => 4, 'licenses' => nil.as_json }
           ] }
         })
       end
@@ -298,13 +313,11 @@ describe Chewy::Fields::Base do
 
     context 'objects and scopes', :orm do
       before do
-        stub_model(:city) do
-          belongs_to :country
-        end
+        stub_model(:city)
+        stub_model(:country)
 
-        stub_model(:country) do
-          has_many :cities
-        end
+        City.belongs_to :country
+        Country.has_many :cities
 
         stub_index(:countries) do
           define_type Country do

data/spec/chewy/fields/time_fields_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe 'Time fields' do
+  before { Chewy.massacre }
+
+  before do
+    stub_index(:posts) do
+      define_type :post do
+        field :published_at, type: 'date'
+      end
+    end
+  end
+
+  before { PostsIndex::Post.import(
+    double(published_at: ActiveSupport::TimeZone[-28800].parse('2014/12/18 18:00')),
+    double(published_at: ActiveSupport::TimeZone[-21600].parse('2014/12/18 20:00')),
+    double(published_at: ActiveSupport::TimeZone[-21600].parse('2014/12/17 20:00')),
+  ) }
+
+  let(:time) { ActiveSupport::TimeZone[-14400].parse('2014/12/18 22:00') }
+  let(:range) { (time - 1.minute)..(time + 1.minute) }
+
+  specify { expect(PostsIndex.total).to eq(3) }
+  specify { expect(PostsIndex.filter { published_at == o{range} }.count).to eq(2) }
+  specify { expect(PostsIndex.filter { published_at == o{range.min.utc..range.max.utc} }.count).to eq(2) }
+  specify { expect(PostsIndex.filter { published_at == o{[range.min.to_date..range.max.to_date]} }.count).to eq(1) }
+end

data/spec/chewy/index/settings_spec.rb

@@ -3,6 +3,7 @@ require 'spec_helper'
 describe Chewy::Index::Settings do
   describe '#to_hash' do
     before { allow(Chewy).to receive_messages(config: Chewy::Config.send(:new)) }
+    before { allow(Chewy).to receive_messages(repository: Chewy::Repository.send(:new)) }
 
     specify { expect(described_class.new.to_hash).to eq({}) }
     specify { expect(described_class.new(number_of_nodes: 3).to_hash).to eq({settings: {number_of_nodes: 3}}) }
@@ -70,7 +71,7 @@ describe Chewy::Index::Settings do
         .to eq({settings: {index: {number_of_shards: 3}}}) }
 
       context do
-        before { Chewy.configuration = {index: {number_of_shards: 7, number_of_replicas: 2}} }
+        before { allow(Chewy).to receive_messages(configuration: {index: {number_of_shards: 7, number_of_replicas: 2}}) }
 
         specify { expect(described_class.new.to_hash)
           .to eq({settings: {index: {number_of_shards: 7, number_of_replicas: 2}}}) }

data/spec/chewy/index_spec.rb

@@ -7,6 +7,41 @@ describe Chewy::Index do
     end
   end
 
+  describe '.import', :orm do
+    before do
+      stub_model(:city)
+      stub_model(:country)
+
+      stub_index(:places) do
+        define_type City
+        define_type Country
+      end
+    end
+
+    let!(:cities) { 2.times.map { |i| City.create! id: i + 1 } }
+    let!(:countries) { 2.times.map { |i| Country.create! id: i + 1 } }
+
+    specify do
+      expect { PlacesIndex.import }.to update_index(PlacesIndex::City).and_reindex(cities)
+      expect { PlacesIndex.import }.to update_index(PlacesIndex::Country).and_reindex(countries)
+    end
+
+    specify do
+      expect { PlacesIndex.import city: cities.first }.to update_index(PlacesIndex::City).and_reindex(cities.first).only
+      expect { PlacesIndex.import city: cities.first }.to update_index(PlacesIndex::Country).and_reindex(countries)
+    end
+
+    specify do
+      expect { PlacesIndex.import city: cities.first, country: countries.last }.to update_index(PlacesIndex::City).and_reindex(cities.first).only
+      expect { PlacesIndex.import city: cities.first, country: countries.last }.to update_index(PlacesIndex::Country).and_reindex(countries.last).only
+    end
+
+    specify do
+      expect(PlacesIndex.client).to receive(:bulk).with(hash_including(refresh: false)).twice
+      PlacesIndex.import city: cities.first, refresh: false
+    end
+  end
+
   describe '.client' do
     specify { expect(stub_index(:dummies1).client).to eq(stub_index(:dummies2).client) }
 
@@ -20,28 +55,17 @@ describe Chewy::Index do
     end
   end
 
-  describe '.settings' do
-    before do
-      allow(Chewy).to receive_messages(config: Chewy::Config.send(:new))
+  describe '.index_name' do
+    specify { expect { Class.new(Chewy::Index).index_name }.to raise_error Chewy::UndefinedIndex }
+    specify { expect(Class.new(Chewy::Index) { index_name :myindex }.index_name).to eq('myindex') }
+    specify { expect(stub_const('DeveloperIndex', Class.new(Chewy::Index)).index_name).to eq('developer') }
+    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name).to eq('developers') }
 
-      Chewy.analyzer :name, filter: ['lowercase', 'icu_folding', 'names_nysiis']
-      Chewy.analyzer :phone, tokenizer: 'ngram', char_filter: ['phone']
-      Chewy.tokenizer :ngram, type: 'nGram', min_gram: 3, max_gram: 3
-      Chewy.char_filter :phone, type: 'pattern_replace', pattern: '[^\d]', replacement: ''
-      Chewy.filter :names_nysiis, type: 'phonetic', encoder: 'nysiis', replace: false
+    context do
+      before { allow(Chewy).to receive_messages(configuration: {prefix: 'testing'}) }
+      specify { expect(DummiesIndex.index_name).to eq('testing_dummies') }
+      specify { expect(stub_index(:dummies) { index_name :users }.index_name).to eq('testing_users') }
     end
-
-    let(:documents) { stub_index(:documents) { settings analysis: {analyzer: [:name, :phone, {sorted: {option: :baz}}]} } }
-
-    specify { expect { documents.settings_hash }.to_not change(documents._settings, :inspect)  }
-    specify { expect(documents.settings_hash).to eq({settings: {analysis: {
-      analyzer: {name: {filter: ['lowercase', 'icu_folding', 'names_nysiis']},
-                 phone: {tokenizer: 'ngram', char_filter: ['phone']},
-                 sorted: {option: :baz}},
-      tokenizer: {ngram: {type: 'nGram', min_gram: 3, max_gram: 3}},
-      char_filter: {phone: {type: 'pattern_replace', pattern: '[^\d]', replacement: ''}},
-      filter: {names_nysiis: {type: 'phonetic', encoder: 'nysiis', replace: false}}
-    }}}) }
   end
 
   describe '.define_type' do
@@ -58,7 +82,6 @@ describe Chewy::Index do
       specify { expect(DummiesIndex.type_hash['country']).to eq(DummiesIndex::Country) }
     end
 
-
     context do
       before { stub_class('City') }
       before { stub_class('City::District', City) }
@@ -102,17 +125,48 @@ describe Chewy::Index do
     specify { expect(DummiesIndex.types(:user)).to be_a Chewy::Query }
   end
 
-  describe '.index_name' do
-    specify { expect { Class.new(Chewy::Index).index_name }.to raise_error Chewy::UndefinedIndex }
-    specify { expect(Class.new(Chewy::Index) { index_name :myindex }.index_name).to eq('myindex') }
-    specify { expect(stub_const('DeveloperIndex', Class.new(Chewy::Index)).index_name).to eq('developer') }
-    specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).index_name).to eq('developers') }
+  describe '.settings' do
+    before do
+      allow(Chewy).to receive_messages(config: Chewy::Config.send(:new))
 
-    context do
-      before { allow(Chewy).to receive_messages(configuration: {prefix: 'testing'}) }
-      specify { expect(DummiesIndex.index_name).to eq('testing_dummies') }
-      specify { expect(stub_index(:dummies) { index_name :users }.index_name).to eq('testing_users') }
+      Chewy.analyzer :name, filter: ['lowercase', 'icu_folding', 'names_nysiis']
+      Chewy.analyzer :phone, tokenizer: 'ngram', char_filter: ['phone']
+      Chewy.tokenizer :ngram, type: 'nGram', min_gram: 3, max_gram: 3
+      Chewy.char_filter :phone, type: 'pattern_replace', pattern: '[^\d]', replacement: ''
+      Chewy.filter :names_nysiis, type: 'phonetic', encoder: 'nysiis', replace: false
+    end
+
+    let(:documents) { stub_index(:documents) { settings analysis: {analyzer: [:name, :phone, {sorted: {option: :baz}}]} } }
+
+    specify { expect { documents.settings_hash }.to_not change(documents._settings, :inspect)  }
+    specify { expect(documents.settings_hash).to eq({settings: {analysis: {
+      analyzer: {name: {filter: ['lowercase', 'icu_folding', 'names_nysiis']},
+                 phone: {tokenizer: 'ngram', char_filter: ['phone']},
+                 sorted: {option: :baz}},
+      tokenizer: {ngram: {type: 'nGram', min_gram: 3, max_gram: 3}},
+      char_filter: {phone: {type: 'pattern_replace', pattern: '[^\d]', replacement: ''}},
+      filter: {names_nysiis: {type: 'phonetic', encoder: 'nysiis', replace: false}}
+    }}}) }
+  end
+
+  describe '.scopes' do
+    before do
+      stub_index(:places) do
+        def self.by_rating
+        end
+
+        def self.by_name
+        end
+
+        define_type :city do
+          def self.by_id
+          end
+        end
+      end
     end
+
+    specify { expect(described_class.scopes).to eq([]) }
+    specify { expect(PlacesIndex.scopes).to match_array([:by_rating, :by_name]) }
   end
 
   describe '.build_index_name' do
@@ -123,24 +177,6 @@ describe Chewy::Index do
     specify { expect(stub_const('DevelopersIndex', Class.new(Chewy::Index)).build_index_name(:users, prefix: 'test', suffix: '2013')).to eq('test_users_2013') }
   end
 
-  describe '.index_params' do
-    before { allow(Chewy).to receive_messages(config: Chewy::Config.send(:new)) }
-
-    specify { expect(stub_index(:documents).index_params).to eq({}) }
-    specify { expect(stub_index(:documents) { settings number_of_shards: 1 }.index_params.keys).to eq([:settings]) }
-    specify { expect(stub_index(:documents) do
-      define_type :document do
-        field :name, type: 'string'
-      end
-    end.index_params.keys).to eq([:mappings]) }
-    specify { expect(stub_index(:documents) do
-      settings number_of_shards: 1
-      define_type :document do
-        field :name, type: 'string'
-      end
-    end.index_params.keys).to match_array([:mappings, :settings]) }
-  end
-
   describe '.settings_hash' do
     before { allow(Chewy).to receive_messages(config: Chewy::Config.send(:new)) }
 
@@ -166,38 +202,21 @@ describe Chewy::Index do
     end.mappings_hash[:mappings].keys).to match_array([:document, :document2]) }
   end
 
-  describe '.import', :orm do
-    before do
-      stub_model(:city)
-      stub_model(:country)
+  describe '.index_params' do
+    before { allow(Chewy).to receive_messages(config: Chewy::Config.send(:new)) }
 
-      stub_index(:places) do
-        define_type City
-        define_type Country
+    specify { expect(stub_index(:documents).index_params).to eq({}) }
+    specify { expect(stub_index(:documents) { settings number_of_shards: 1 }.index_params.keys).to eq([:settings]) }
+    specify { expect(stub_index(:documents) do
+      define_type :document do
+        field :name, type: 'string'
       end
-    end
-
-    let!(:cities) { 2.times.map { |i| City.create! id: i + 1 } }
-    let!(:countries) { 2.times.map { |i| Country.create! id: i + 1 } }
-
-    specify do
-      expect { PlacesIndex.import }.to update_index(PlacesIndex::City).and_reindex(cities)
-      expect { PlacesIndex.import }.to update_index(PlacesIndex::Country).and_reindex(countries)
-    end
-
-    specify do
-      expect { PlacesIndex.import city: cities.first }.to update_index(PlacesIndex::City).and_reindex(cities.first).only
-      expect { PlacesIndex.import city: cities.first }.to update_index(PlacesIndex::Country).and_reindex(countries)
-    end
-
-    specify do
-      expect { PlacesIndex.import city: cities.first, country: countries.last }.to update_index(PlacesIndex::City).and_reindex(cities.first).only
-      expect { PlacesIndex.import city: cities.first, country: countries.last }.to update_index(PlacesIndex::Country).and_reindex(countries.last).only
-    end
-
-    specify do
-      expect(PlacesIndex.client).to receive(:bulk).with(hash_including(refresh: false)).twice
-      PlacesIndex.import city: cities.first, refresh: false
-    end
+    end.index_params.keys).to eq([:mappings]) }
+    specify { expect(stub_index(:documents) do
+      settings number_of_shards: 1
+      define_type :document do
+        field :name, type: 'string'
+      end
+    end.index_params.keys).to match_array([:mappings, :settings]) }
   end
 end