chewy 0.10.0 → 6.0.0

data/spec/chewy/search/scrolling_spec.rb

@@ -7,12 +7,13 @@ describe Chewy::Search::Scrolling, :orm do
     stub_model(:city)
     stub_model(:country)
 
-    stub_index(:places) do
+    stub_index(:cities) do
       define_type City do
         field :name
         field :rating, type: 'integer'
       end
-
+    end
+    stub_index(:countries) do
       define_type Country do
         field :name
         field :rating, type: 'integer'
@@ -20,12 +21,15 @@ describe Chewy::Search::Scrolling, :orm do
     end
   end
 
-  let(:request) { Chewy::Search::Request.new(PlacesIndex).order(:rating) }
+  let(:request) { Chewy::Search::Request.new(CitiesIndex, CountriesIndex).order(:rating) }
 
   specify { expect(request.scroll_batches.to_a).to eq([]) }
 
   context do
-    before { PlacesIndex.import!(cities: cities, countries: countries) }
+    before do
+      CitiesIndex.import!(cities)
+      CountriesIndex.import!(countries: countries)
+    end
 
     let(:cities) { Array.new(2) { |i| City.create!(rating: i, name: "city #{i}") } }
     let(:countries) { Array.new(3) { |i| Country.create!(rating: i + 2, name: "country #{i}") } }
@@ -61,9 +65,9 @@ describe Chewy::Search::Scrolling, :orm do
       context do
         before { expect(Chewy.client).not_to receive(:scroll) }
         it 'respects limit and terminate_after' do
-          expect(request.terminate_after(2).limit(4).scroll_batches(batch_size: 3).map do |batch|
+          expect(request.terminate_after(1).limit(4).scroll_batches(batch_size: 3).map do |batch|
             batch.map { |hit| hit['_source']['rating'] }
-          end).to eq([[0, 1]])
+          end).to eq([[0, 2]])
         end
       end
 
@@ -103,6 +107,11 @@ describe Chewy::Search::Scrolling, :orm do
         end
       end
 
+      it 'clears the scroll after completion' do
+        expect(Chewy.client).to receive(:clear_scroll).with(scroll_id: anything).once.and_call_original
+        request.scroll_batches(batch_size: 3) {}
+      end
+
       context 'instrumentation' do
         specify do
           outer_payload = []
@@ -113,18 +122,18 @@ describe Chewy::Search::Scrolling, :orm do
 
           expect(outer_payload).to match_array([
             hash_including(
-              index: PlacesIndex,
-              indexes: [PlacesIndex],
-              request: {index: ['places'], type: %w[city country], body: {sort: ['rating']}, size: 3, scroll: '1m'},
-              type: [PlacesIndex::City, PlacesIndex::Country],
-              types: [PlacesIndex::City, PlacesIndex::Country]
+              index: [CitiesIndex, CountriesIndex],
+              indexes: [CitiesIndex, CountriesIndex],
+              request: {index: %w[cities countries], type: %w[city country], body: {sort: ['rating']}, size: 3, scroll: '1m'},
+              type: [CitiesIndex::City, CountriesIndex::Country],
+              types: [CitiesIndex::City, CountriesIndex::Country]
             ),
             hash_including(
-              index: PlacesIndex,
-              indexes: [PlacesIndex],
+              index: [CitiesIndex, CountriesIndex],
+              indexes: [CitiesIndex, CountriesIndex],
               request: {scroll: '1m', scroll_id: an_instance_of(String)},
-              type: [PlacesIndex::City, PlacesIndex::Country],
-              types: [PlacesIndex::City, PlacesIndex::Country]
+              type: [CitiesIndex::City, CountriesIndex::Country],
+              types: [CitiesIndex::City, CountriesIndex::Country]
             )
           ])
         end
@@ -149,7 +158,7 @@ describe Chewy::Search::Scrolling, :orm do
       end
       specify do
         expect(request.scroll_wrappers(batch_size: 2).map(&:class).uniq)
-          .to eq([PlacesIndex::City, PlacesIndex::Country])
+          .to eq([CitiesIndex::City, CountriesIndex::Country])
       end
     end
 

data/spec/chewy/search_spec.rb

@@ -6,7 +6,6 @@ describe Chewy::Search do
   before do
     stub_index(:products) do
       define_type :product
-      define_type :product2
     end
   end
 
@@ -38,12 +37,12 @@ describe Chewy::Search do
     end
 
     specify do
-      expect(ProductsIndex.client).to receive(:search).with(hash_including(index: ['products'], type: %w[product product2]))
+      expect(ProductsIndex.client).to receive(:search).with(hash_including(index: ['products'], type: %w[product]))
       ProductsIndex.search_string('hello')
     end
 
     specify do
-      expect(ProductsIndex.client).to receive(:search).with(hash_including(index: ['products'], type: ['product']))
+      expect(ProductsIndex.client).to receive(:search).with(hash_including(index: ['products'], type: %w[product]))
       product.search_string('hello')
     end
   end
@@ -53,7 +52,7 @@ describe Chewy::Search do
       stub_model(:city)
       stub_model(:country)
 
-      stub_index(:places) do
+      stub_index(:cities) do
         def self.by_rating(value)
           filter { match rating: value }
         end
@@ -63,45 +62,60 @@ describe Chewy::Search do
         end
 
         define_type City do
-          def self.by_rating
-            filter { match rating: yield }
-          end
-
-          field :name, index: 'not_analyzed'
+          field :name, type: 'keyword'
           field :rating, type: :integer
         end
+      end
+
+      stub_index(:countries) do
+        def self.by_rating(value)
+          filter { match rating: value }
+        end
+
+        def self.by_name(index)
+          filter { match name: "Name#{index}" }
+        end
 
         define_type Country do
-          field :name, index: 'not_analyzed'
+          field :name, type: 'keyword'
           field :rating, type: :integer
         end
       end
     end
 
-    let!(:cities) { Array.new(3) { |i| City.create! rating: i + 1, name: "Name#{i + 1}" } }
-    let!(:countries) { Array.new(3) { |i| Country.create! rating: i + 1, name: "Name#{i + 4}" } }
-
-    before { PlacesIndex.import! city: cities, country: countries }
-
-    specify { expect(PlacesIndex.by_rating(1).map(&:rating)).to eq([1, 1]) }
-    specify { expect(PlacesIndex.by_rating(1).map(&:class)).to match_array([PlacesIndex::City, PlacesIndex::Country]) }
-    specify { expect(PlacesIndex.by_rating(1).by_name(1).map(&:rating)).to eq([1]) }
-    specify { expect(PlacesIndex.by_rating(1).by_name(1).map(&:class)).to eq([PlacesIndex::City]) }
-    specify { expect(PlacesIndex.order(:name).by_rating(1).map(&:rating)).to eq([1, 1]) }
-    specify { expect(PlacesIndex.order(:name).by_rating(1).map(&:class)).to match_array([PlacesIndex::City, PlacesIndex::Country]) }
-
-    specify { expect(PlacesIndex::City.by_rating { 2 }.map(&:rating)).to eq([2]) }
-    specify { expect(PlacesIndex::City.by_rating { 2 }.map(&:class)).to eq([PlacesIndex::City]) }
-    specify { expect(PlacesIndex::City.by_rating { 2 }.by_name(2).map(&:rating)).to eq([2]) }
-    specify { expect(PlacesIndex::City.by_rating { 2 }.by_name(2).map(&:class)).to eq([PlacesIndex::City]) }
-    specify { expect(PlacesIndex::City.order(:name).by_rating { 2 }.map(&:rating)).to eq([2]) }
-    specify { expect(PlacesIndex::City.order(:name).by_rating { 2 }.map(&:class)).to eq([PlacesIndex::City]) }
-
-    specify { expect(PlacesIndex::Country.by_rating(3).map(&:rating)).to eq([3]) }
-    specify { expect(PlacesIndex::Country.by_rating(3).map(&:class)).to eq([PlacesIndex::Country]) }
-    specify { expect(PlacesIndex::Country.by_rating(3).by_name(6).map(&:rating)).to eq([3]) }
-    specify { expect(PlacesIndex::Country.by_rating(3).by_name(6).map(&:class)).to eq([PlacesIndex::Country]) }
-    specify { expect(PlacesIndex::Country.order(:name).by_rating(3).map(&:rating)).to eq([3]) }
-    specify { expect(PlacesIndex::Country.order(:name).by_rating(3).map(&:class)).to eq([PlacesIndex::Country]) }
+    let!(:cities) { Array.new(3) { |i| City.create! rating: i + 1, name: "Name#{i + 2}" } }
+    let!(:countries) { Array.new(3) { |i| Country.create! rating: i + 1, name: "Name#{i + 3}" } }
+
+    before do
+      CitiesIndex.import!(cities)
+      CountriesIndex.import!(country: countries)
+    end
+
+    specify { expect(CitiesIndex.indices(CountriesIndex).by_rating(1).map(&:rating)).to eq([1, 1]) }
+    specify { expect(CitiesIndex.indices(CountriesIndex).by_rating(1).map(&:class)).to match_array([CitiesIndex::City, CountriesIndex::Country]) }
+    specify { expect(CitiesIndex.indices(CountriesIndex).by_rating(1).by_name(2).map(&:rating)).to eq([1]) }
+    specify { expect(CitiesIndex.indices(CountriesIndex).by_rating(1).by_name(2).map(&:class)).to eq([CitiesIndex::City]) }
+    specify { expect(CitiesIndex.indices(CountriesIndex).by_name(3).map(&:rating)).to eq([2, 1]) }
+    specify { expect(CitiesIndex.indices(CountriesIndex).by_name(3).map(&:class)).to eq([CitiesIndex::City, CountriesIndex::Country]) }
+    specify { expect(CitiesIndex.indices(CountriesIndex).order(:name).by_rating(1).map(&:rating)).to eq([1, 1]) }
+    specify { expect(CitiesIndex.indices(CountriesIndex).order(:name).by_rating(1).map(&:class)).to match_array([CitiesIndex::City, CountriesIndex::Country]) }
+
+    specify { expect(CitiesIndex.by_rating(2).map(&:rating)).to eq([2]) }
+    specify { expect(CitiesIndex.by_rating(2).map(&:class)).to eq([CitiesIndex::City]) }
+    specify { expect(CitiesIndex.by_rating(2).by_name(3).map(&:rating)).to eq([2]) }
+    specify { expect(CitiesIndex.by_rating(2).by_name(3).map(&:class)).to eq([CitiesIndex::City]) }
+    specify { expect(CitiesIndex.by_name(3).map(&:rating)).to eq([2]) }
+    specify { expect(CitiesIndex.by_name(3).map(&:rating)).to eq([2]) }
+    specify { expect(CitiesIndex.order(:name).by_name(3).map(&:rating)).to eq([2]) }
+    specify { expect(CitiesIndex.order(:name).by_name(3).map(&:rating)).to eq([2]) }
+    specify { expect(CitiesIndex.order(:name).by_rating(2).map(&:rating)).to eq([2]) }
+    specify { expect(CitiesIndex.order(:name).by_rating(2).map(&:class)).to eq([CitiesIndex::City]) }
+
+    specify { expect(CountriesIndex.by_rating(3).map(&:rating)).to eq([3]) }
+    specify { expect(CountriesIndex.by_rating(3).map(&:class)).to eq([CountriesIndex::Country]) }
+    specify { expect(CountriesIndex.by_rating(3).by_name(5).map(&:rating)).to eq([3]) }
+    specify { expect(CountriesIndex.by_rating(3).by_name(5).map(&:class)).to eq([CountriesIndex::Country]) }
+    specify { expect(CountriesIndex.order(:name).by_rating(3).map(&:rating)).to eq([3]) }
+    specify { expect(CountriesIndex.order(:name).by_rating(3).map(&:class)).to eq([CountriesIndex::Country]) }
   end
 end

data/spec/chewy/stash_spec.rb

@@ -9,8 +9,10 @@ describe Chewy::Stash::Journal, :orm do
 
   before do
     stub_model(:city)
-    stub_index(:places) do
+    stub_index(:cities) do
       define_type City
+    end
+    stub_index(:countries) do
       define_type :country
     end
     stub_index(:users) { define_type :user }
@@ -21,9 +23,9 @@ describe Chewy::Stash::Journal, :orm do
   after { Timecop.return }
 
   before do
-    PlacesIndex::City.import!(City.new(id: 1, name: 'City'), journal: true)
+    CitiesIndex.import!(City.new(id: 1, name: 'City'), journal: true)
     Timecop.travel(Time.now + 1.minute) do
-      PlacesIndex::Country.import!([id: 2, name: 'Country'], journal: true)
+      CountriesIndex.import!([id: 2, name: 'Country'], journal: true)
     end
     Timecop.travel(Time.now + 2.minutes) do
       UsersIndex::User.import!([id: 3, name: 'User'], journal: true)
@@ -49,11 +51,11 @@ describe Chewy::Stash::Journal, :orm do
         .to contain_exactly([{'id' => 3, 'name' => 'User'}])
     end
     specify do
-      expect(described_class.entries(Time.now - 30.seconds, only: [PlacesIndex::City, UsersIndex]).map(&:references))
+      expect(described_class.entries(Time.now - 30.seconds, only: [CitiesIndex, UsersIndex]).map(&:references))
         .to contain_exactly([1], [{'id' => 3, 'name' => 'User'}])
     end
     specify do
-      expect(described_class.entries(Time.now + 30.seconds, only: [PlacesIndex::City, UsersIndex]).map(&:references))
+      expect(described_class.entries(Time.now + 30.seconds, only: [CitiesIndex, UsersIndex]).map(&:references))
         .to contain_exactly([{'id' => 3, 'name' => 'User'}])
     end
     specify do
@@ -68,28 +70,28 @@ describe Chewy::Stash::Journal, :orm do
     specify { expect(fetch_deleted_number(described_class.clean(Time.now + 90.seconds))).to eq(2) }
     specify { expect(fetch_deleted_number(described_class.clean(only: BorogovesIndex))).to eq(0) }
     specify { expect(fetch_deleted_number(described_class.clean(only: UsersIndex))).to eq(1) }
-    specify { expect(fetch_deleted_number(described_class.clean(only: [PlacesIndex::City, UsersIndex]))).to eq(2) }
+    specify { expect(fetch_deleted_number(described_class.clean(only: [CitiesIndex, UsersIndex]))).to eq(2) }
 
-    specify { expect(fetch_deleted_number(described_class.clean(Time.now + 30.seconds, only: PlacesIndex::Country))).to eq(0) }
-    specify { expect(fetch_deleted_number(described_class.clean(Time.now + 30.seconds, only: PlacesIndex::City))).to eq(1) }
+    specify { expect(fetch_deleted_number(described_class.clean(Time.now + 30.seconds, only: CountriesIndex))).to eq(0) }
+    specify { expect(fetch_deleted_number(described_class.clean(Time.now + 30.seconds, only: CitiesIndex))).to eq(1) }
   end
 
   describe '.for' do
     specify { expect(described_class.for(UsersIndex).map(&:index_name)).to eq(['users']) }
-    specify { expect(described_class.for(PlacesIndex).map(&:type_name)).to contain_exactly('city', 'country') }
-    specify { expect(described_class.for(PlacesIndex::City, UsersIndex).map(&:index_name)).to contain_exactly('places', 'users') }
+    specify { expect(described_class.for(CitiesIndex, CountriesIndex).map(&:type_name)).to contain_exactly('city', 'country') }
+    specify { expect(described_class.for(CitiesIndex, UsersIndex).map(&:index_name)).to contain_exactly('cities', 'users') }
   end
 
   describe '#type' do
     let(:index_name) { 'users' }
     let(:type_name) { 'city' }
-    subject { described_class.new('index_name' => index_name, 'type_name' => type_name).type }
+    subject { described_class::Journal.new('index_name' => index_name, 'type_name' => type_name).type }
 
     specify { expect { subject }.to raise_error(Chewy::UnderivableType) }
 
     context do
-      let(:index_name) { 'places' }
-      it { is_expected.to eq(PlacesIndex::City) }
+      let(:index_name) { 'cities' }
+      it { is_expected.to eq(CitiesIndex::City) }
     end
   end
 end

data/spec/chewy/strategy/active_job_spec.rb

@@ -2,7 +2,12 @@ require 'spec_helper'
 
 if defined?(::ActiveJob)
   describe Chewy::Strategy::ActiveJob do
-    around { |example| Chewy.strategy(:bypass) { example.run } }
+    around do |example|
+      active_job_settings = Chewy.settings[:active_job]
+      Chewy.settings[:active_job] = {queue: 'low'}
+      Chewy.strategy(:bypass) { example.run }
+      Chewy.settings[:active_job] = active_job_settings
+    end
     before(:all) do
       ::ActiveJob::Base.logger = Chewy.logger
     end
@@ -36,7 +41,15 @@ if defined?(::ActiveJob)
       end
       enqueued_job = ::ActiveJob::Base.queue_adapter.enqueued_jobs.first
       expect(enqueued_job[:job]).to eq(Chewy::Strategy::ActiveJob::Worker)
-      expect(enqueued_job[:queue]).to eq('chewy')
+      expect(enqueued_job[:queue]).to eq('low')
+    end
+
+    specify do
+      Chewy.strategy(:active_job) do
+        [city, other_city].map(&:save!)
+      end
+      enqueued_job = ::ActiveJob::Base.queue_adapter.enqueued_jobs.first
+      expect(enqueued_job[:queue]).to eq('low')
     end
 
     specify do

data/spec/chewy/strategy/shoryuken_spec.rb

@@ -1,8 +1,15 @@
 require 'spec_helper'
 
 if defined?(::Shoryuken)
+  require 'aws-sdk-sqs'
+
   describe Chewy::Strategy::Shoryuken do
-    around { |example| Chewy.strategy(:bypass) { example.run } }
+    around do |example|
+      shoryuken_settings = Chewy.settings[:shoryuken]
+      Chewy.settings[:shoryuken] = {queue: 'low'}
+      Chewy.strategy(:bypass) { example.run }
+      Chewy.settings[:shoryuken] = shoryuken_settings
+    end
     before { ::Shoryuken.groups.clear }
     before do
       stub_model(:city) do
@@ -29,7 +36,6 @@ if defined?(::Shoryuken)
     end
 
     specify do
-      Chewy.settings[:shoryuken] = {queue: 'low'}
       expect(Chewy::Strategy::Shoryuken::Worker).to receive(:perform_async)
         .with(hash_including(type: 'CitiesIndex::City', ids: [city.id, other_city.id]), hash_including(queue: 'low'))
       Chewy.strategy(:shoryuken) do

data/spec/chewy/strategy/sidekiq_spec.rb

@@ -4,7 +4,12 @@ if defined?(::Sidekiq)
   require 'sidekiq/testing'
 
   describe Chewy::Strategy::Sidekiq do
-    around { |example| Chewy.strategy(:bypass) { example.run } }
+    around do |example|
+      sidekiq_settings = Chewy.settings[:sidekiq]
+      Chewy.settings[:sidekiq] = {queue: 'low'}
+      Chewy.strategy(:bypass) { example.run }
+      Chewy.settings[:sidekiq] = sidekiq_settings
+    end
     before { ::Sidekiq::Worker.clear_all }
     before do
       stub_model(:city) do
@@ -25,7 +30,6 @@ if defined?(::Sidekiq)
     end
 
     specify do
-      Chewy.settings[:sidekiq] = {queue: 'low'}
       expect(::Sidekiq::Client).to receive(:push).with(hash_including('queue' => 'low')).and_call_original
       ::Sidekiq::Testing.inline! do
         expect { [city, other_city].map(&:save!) }

data/spec/chewy/type/adapter/active_record_spec.rb

@@ -86,7 +86,19 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record do
           .to eq([{index: cities.first(2)}, {index: cities.last(1)}])
       end
 
-      specify { expect(import(cities)).to eq([{index: cities}]) }
+      specify do
+        cities
+        expects_db_queries do
+          expect(import(cities, direct_import: false)).to eq([{index: cities}])
+        end
+      end
+      specify do
+        cities
+        expects_no_query do
+          expect(import(cities, direct_import: true)).to eq([{index: cities}])
+        end
+      end
+
       specify do
         expect(import(cities, batch_size: 2))
           .to eq([{index: cities.first(2)}, {index: cities.last(1)}])
@@ -454,9 +466,9 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record do
       specify do
         expect(subject.import_fields(fields: [:updated_at], typecast: false))
           .to match([contain_exactly(
-            [1, match(/#{Time.now.strftime('%Y-%m-%d')}/)],
-            [2, match(/#{Time.now.strftime('%Y-%m-%d')}/)],
-            [3, match(/#{Time.now.strftime('%Y-%m-%d')}/)]
+            [1, match(/#{Time.now.utc.strftime('%Y-%m-%d')}/)],
+            [2, match(/#{Time.now.utc.strftime('%Y-%m-%d')}/)],
+            [3, match(/#{Time.now.utc.strftime('%Y-%m-%d')}/)]
           )])
       end
     end

data/spec/chewy/type/import/bulk_builder_spec.rb

@@ -4,7 +4,7 @@ describe Chewy::Type::Import::BulkBuilder do
   before { Chewy.massacre }
 
   subject { described_class.new(type, index: index, delete: delete, fields: fields) }
-  let(:type) { PlacesIndex::City }
+  let(:type) { CitiesIndex::City }
   let(:index) { [] }
   let(:delete) { [] }
   let(:fields) { [] }
@@ -13,7 +13,7 @@ describe Chewy::Type::Import::BulkBuilder do
     context 'simple bulk', :orm do
       before do
         stub_model(:city)
-        stub_index(:places) do
+        stub_index(:cities) do
           define_type City do
             field :name, :rating
           end
@@ -67,98 +67,13 @@ describe Chewy::Type::Import::BulkBuilder do
       end
     end
 
-    context 'parent-child relationship', :orm do
-      before do
-        stub_model(:country)
-        stub_model(:city)
-        adapter == :sequel ? City.many_to_one(:country) : City.belongs_to(:country)
-      end
-
-      before do
-        stub_index(:places) do
-          define_type Country do
-            field :name
-          end
-
-          define_type City do
-            root parent: 'country', parent_id: -> { country_id } do
-              field :name
-              field :rating
-            end
-          end
-        end
-      end
-
-      before { PlacesIndex::Country.import(country) }
-      let(:country) { Country.create!(id: 1, name: 'country') }
-      let(:another_country) { Country.create!(id: 2, name: 'another country') }
-      let(:city) { City.create!(id: 4, country_id: country.id, name: 'city', rating: 42) }
-
-      context 'indexing' do
-        let(:index) { [city] }
-
-        specify do
-          expect(subject.bulk_body).to eq([
-            {index: {_id: city.id, parent: country.id, data: {'name' => 'city', 'rating' => 42}}}
-          ])
-        end
-
-        context do
-          let(:fields) { %w[name] }
-
-          specify do
-            expect(subject.bulk_body).to eq([
-              {update: {_id: city.id, parent: country.id, data: {doc: {'name' => 'city'}}}}
-            ])
-          end
-        end
-      end
-
-      context 'updating parent' do
-        before do
-          PlacesIndex::City.import(city)
-          city.update_attributes(country_id: another_country.id)
-        end
-        let(:index) { [city] }
-
-        specify do
-          expect(subject.bulk_body).to eq([
-            {delete: {_id: city.id, parent: country.id.to_s}},
-            {index: {_id: city.id, parent: another_country.id, data: {'name' => 'city', 'rating' => 42}}}
-          ])
-        end
-
-        context do
-          let(:fields) { %w[name] }
-
-          specify do
-            expect(subject.bulk_body).to eq([
-              {delete: {_id: city.id, parent: country.id.to_s}},
-              {index: {_id: city.id, parent: another_country.id, data: {'name' => 'city', 'rating' => 42}}}
-            ])
-          end
-        end
-      end
-
-      context 'destroying' do
-        before { PlacesIndex::City.import(city) }
-        let(:delete) { [city] }
-
-        specify do
-          expect(subject.bulk_body).to eq([
-            {delete: {_id: city.id, parent: country.id.to_s}}
-          ])
-        end
-      end
-    end
-
     context 'custom id', :orm do
       before do
         stub_model(:city)
       end
 
       before do
-        stub_index(:places) do
+        stub_index(:cities) do
           define_type City do
             root id: -> { name } do
               field :rating
@@ -170,8 +85,8 @@ describe Chewy::Type::Import::BulkBuilder do
       let(:london) { City.create(id: 1, name: 'London', rating: 4) }
 
       specify do
-        expect { PlacesIndex::City.import(london) }
-          .to update_index(PlacesIndex::City).and_reindex(london.name)
+        expect { CitiesIndex.import(london) }
+          .to update_index(CitiesIndex).and_reindex(london.name)
       end
 
       context 'indexing' do
@@ -197,7 +112,7 @@ describe Chewy::Type::Import::BulkBuilder do
 
     context 'crutches' do
       before do
-        stub_index(:places) do
+        stub_index(:cities) do
           define_type :city do
             crutch :names do |collection|
               collection.map { |item| [item.id, "Name#{item.id}"] }.to_h
@@ -217,7 +132,7 @@ describe Chewy::Type::Import::BulkBuilder do
       end
 
       context 'witchcraft' do
-        before { PlacesIndex::City.witchcraft! }
+        before { CitiesIndex::City.witchcraft! }
         specify do
           expect(subject.bulk_body).to eq([
             {index: {_id: 42, data: {'name' => 'Name42'}}}
@@ -228,7 +143,7 @@ describe Chewy::Type::Import::BulkBuilder do
 
     context 'empty ids' do
       before do
-        stub_index(:places) do
+        stub_index(:cities) do
           define_type :city do
             field :name
           end
@@ -264,7 +179,7 @@ describe Chewy::Type::Import::BulkBuilder do
 
   describe '#index_objects_by_id' do
     before do
-      stub_index(:places) do
+      stub_index(:cities) do
         define_type :city do
           field :name
         end