chewy 6.0.0 → 7.6.0

data/spec/chewy/{type → index}/import/routine_spec.rb

@@ -1,24 +1,22 @@
 require 'spec_helper'
 
 # TODO: add more specs here later
-describe Chewy::Type::Import::Routine do
+describe Chewy::Index::Import::Routine do
   before { Chewy.massacre }
   before do
     stub_index(:cities) do
-      define_type :city do
-        field :name
-        field :object, type: 'object'
-      end
+      field :name
+      field :object, type: 'object'
     end
     CitiesIndex.create!
   end
 
-  let(:index) { [double(id: 1, name: 'Name', object: {}), double(id: 2, name: 'Name', object: {})] }
-  let(:delete) { [double(id: 3, name: 'Name')] }
+  let(:index) { [double('city_1', id: 1, name: 'Name', object: {}), double('city_2', id: 2, name: 'Name', object: {})] }
+  let(:delete) { [double('city_3', id: 3, name: 'Name', object: {})] }
 
   describe '#options' do
     specify do
-      expect(described_class.new(CitiesIndex::City).options).to eq(
+      expect(described_class.new(CitiesIndex).options).to eq(
         journal: nil,
         refresh: true,
         update_failover: true,
@@ -29,7 +27,7 @@ describe Chewy::Type::Import::Routine do
 
     specify do
       expect(described_class.new(
-        CitiesIndex::City, batch_size: 100, bulk_size: 1.megabyte, refresh: false
+        CitiesIndex, batch_size: 100, bulk_size: 1.megabyte, refresh: false
       ).options).to eq(
         journal: nil,
         refresh: false,
@@ -43,7 +41,7 @@ describe Chewy::Type::Import::Routine do
     context do
       before { allow(Chewy).to receive_messages(configuration: Chewy.configuration.merge(journal: true)) }
       specify do
-        expect(described_class.new(CitiesIndex::City).options).to eq(
+        expect(described_class.new(CitiesIndex).options).to eq(
           journal: true,
           refresh: true,
           update_failover: true,
@@ -55,24 +53,26 @@ describe Chewy::Type::Import::Routine do
 
     specify do
       expect(CitiesIndex.client).to receive(:bulk).with(hash_including(refresh: true))
-      described_class.new(CitiesIndex::City).process(index: index)
+      described_class.new(CitiesIndex).process(index: index)
     end
 
     specify do
       expect(CitiesIndex.client).to receive(:bulk).with(hash_including(refresh: false))
-      described_class.new(CitiesIndex::City, refresh: false).process(index: index)
+      described_class.new(CitiesIndex, refresh: false).process(index: index)
     end
   end
 
   describe '#parallel_options' do
-    specify { expect(described_class.new(CitiesIndex::City).parallel_options).to be_nil }
-    specify { expect(described_class.new(CitiesIndex::City, parallel: true).parallel_options).to eq({}) }
-    specify { expect(described_class.new(CitiesIndex::City, parallel: 3).parallel_options).to eq(in_processes: 3) }
-    specify { expect(described_class.new(CitiesIndex::City, parallel: {in_threads: 2}).parallel_options).to eq(in_threads: 2) }
+    specify { expect(described_class.new(CitiesIndex).parallel_options).to be_nil }
+    specify { expect(described_class.new(CitiesIndex, parallel: true).parallel_options).to eq({}) }
+    specify { expect(described_class.new(CitiesIndex, parallel: 3).parallel_options).to eq(in_processes: 3) }
+    specify do
+      expect(described_class.new(CitiesIndex, parallel: {in_threads: 2}).parallel_options).to eq(in_threads: 2)
+    end
   end
 
   describe '#stats' do
-    subject { described_class.new(CitiesIndex::City) }
+    subject { described_class.new(CitiesIndex) }
 
     specify { expect(subject.stats).to eq({}) }
     specify do
@@ -92,8 +92,8 @@ describe Chewy::Type::Import::Routine do
   end
 
   describe '#errors' do
-    subject { described_class.new(CitiesIndex::City) }
-    let(:index) { [double(id: 1, name: 'Name', object: ''), double(id: 2, name: 'Name', object: {})] }
+    subject { described_class.new(CitiesIndex) }
+    let(:index) { [double('city_1', id: 1, name: 'Name', object: ''), double('city_2', id: 2, name: 'Name', object: {})] }
 
     specify { expect(subject.errors).to eq([]) }
     specify do

data/spec/chewy/{type → index}/import_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Chewy::Type::Import do
+describe Chewy::Index::Import do
   before { Chewy.massacre }
 
   before do
@@ -9,14 +9,13 @@ describe Chewy::Type::Import do
 
   before do
     stub_index(:cities) do
-      define_type City do
-        field :name
-      end
+      index_scope City
+      field :name
     end
   end
 
   def imported_cities
-    CitiesIndex::City.all.map do |city|
+    CitiesIndex.all.map do |city|
       city.attributes.except('_score', '_explanation')
     end
   end
@@ -37,13 +36,13 @@ describe Chewy::Type::Import do
     specify 'lazy (default)' do
       expect(CitiesIndex).to receive(:exists?).and_call_original
       expect(CitiesIndex).to receive(:create!).and_call_original
-      CitiesIndex::City.import(dummy_city)
+      CitiesIndex.import(dummy_city)
     end
 
     specify 'lazy without objects' do
       expect(CitiesIndex).not_to receive(:exists?)
       expect(CitiesIndex).not_to receive(:create!)
-      CitiesIndex::City.import([])
+      CitiesIndex.import([])
     end
 
     context 'skip' do
@@ -58,7 +57,20 @@ describe Chewy::Type::Import do
       specify do
         expect(CitiesIndex).not_to receive(:exists?)
         expect(CitiesIndex).not_to receive(:create!)
-        CitiesIndex::City.import(dummy_city)
+        CitiesIndex.import(dummy_city)
+      end
+    end
+
+    context 'skip journal creation on import' do
+      before do
+        Chewy::Stash::Journal.create!
+        Chewy.config.settings[:skip_journal_creation_on_import] = true
+      end
+      after { Chewy.config.settings[:skip_journal_creation_on_import] = nil }
+
+      specify do
+        expect(Chewy::Stash::Journal).not_to receive(:create!)
+        CitiesIndex.import(dummy_city, journal: true)
       end
     end
   end
@@ -69,35 +81,36 @@ describe Chewy::Type::Import do
     specify { expect(import(dummy_cities)).to eq(true) }
     specify { expect(import(dummy_cities.map(&:id))).to eq(true) }
 
-    specify { expect { import([]) }.not_to update_index(CitiesIndex::City) }
-    specify { expect { import }.to update_index(CitiesIndex::City).and_reindex(dummy_cities) }
-    specify { expect { import dummy_cities }.to update_index(CitiesIndex::City).and_reindex(dummy_cities) }
-    specify { expect { import dummy_cities.map(&:id) }.to update_index(CitiesIndex::City).and_reindex(dummy_cities) }
+    specify { expect { import([]) }.not_to update_index(CitiesIndex) }
+    specify { expect { import }.to update_index(CitiesIndex).and_reindex(dummy_cities) }
+    specify { expect { import dummy_cities }.to update_index(CitiesIndex).and_reindex(dummy_cities) }
+    specify { expect { import dummy_cities.map(&:id) }.to update_index(CitiesIndex).and_reindex(dummy_cities) }
 
     describe 'criteria-driven importing' do
       let(:names) { %w[name0 name1] }
 
-      context 'mongoid', :mongoid do
-        specify { expect { import(City.where(:name.in => names)) }.to update_index(CitiesIndex::City).and_reindex(dummy_cities.first(2)) }
-        specify { expect { import(City.where(:name.in => names).map(&:id)) }.to update_index(CitiesIndex::City).and_reindex(dummy_cities.first(2)) }
-      end
-
       context 'active record', :active_record do
-        specify { expect { import(City.where(name: names)) }.to update_index(CitiesIndex::City).and_reindex(dummy_cities.first(2)) }
-        specify { expect { import(City.where(name: names).map(&:id)) }.to update_index(CitiesIndex::City).and_reindex(dummy_cities.first(2)) }
+        specify do
+          expect { import(City.where(name: names)) }
+            .to update_index(CitiesIndex).and_reindex(dummy_cities.first(2))
+        end
+        specify do
+          expect { import(City.where(name: names).map(&:id)) }
+            .to update_index(CitiesIndex).and_reindex(dummy_cities.first(2))
+        end
       end
     end
 
     specify do
       dummy_cities.first.destroy
       expect { import dummy_cities }
-        .to update_index(CitiesIndex::City).and_reindex(dummy_cities.from(1)).and_delete(dummy_cities.first)
+        .to update_index(CitiesIndex).and_reindex(dummy_cities.from(1)).and_delete(dummy_cities.first)
     end
 
     specify do
       dummy_cities.first.destroy
       expect { import dummy_cities.map(&:id) }
-        .to update_index(CitiesIndex::City).and_reindex(dummy_cities.from(1)).and_delete(dummy_cities.first)
+        .to update_index(CitiesIndex).and_reindex(dummy_cities.from(1)).and_delete(dummy_cities.first)
     end
 
     specify do
@@ -120,7 +133,10 @@ describe Chewy::Type::Import do
     context ':bulk_size' do
       let!(:dummy_cities) { Array.new(3) { |i| City.create(id: i + 1, name: "name#{i}" * 20) } }
 
-      specify { expect { import(dummy_cities, bulk_size: 1.2.kilobyte) }.to update_index(CitiesIndex::City).and_reindex(dummy_cities) }
+      specify do
+        expect { import(dummy_cities, bulk_size: 1.2.kilobyte) }
+          .to update_index(CitiesIndex).and_reindex(dummy_cities)
+      end
 
       context do
         before { expect(Chewy.client).to receive(:bulk).exactly(3).times.and_call_original }
@@ -132,31 +148,29 @@ describe Chewy::Type::Import do
       before do
         names = %w[name0 name1]
 
-        criteria = case adapter
-        when :mongoid
-          {:name.in => names}
-        else
-          {name: names}
-        end
+        criteria = {name: names}
 
         stub_index(:cities) do
-          define_type City.where(criteria) do
-            field :name
-          end
+          index_scope City.where(criteria)
+          field :name
         end
       end
 
-      specify { expect { import }.to update_index(CitiesIndex::City).and_reindex(dummy_cities.first(2)) }
+      specify { expect { import }.to update_index(CitiesIndex).and_reindex(dummy_cities.first(2)) }
 
-      context 'mongoid', :mongoid do
+      context 'active record', :active_record do
         specify do
-          expect { import City.where(_id: dummy_cities.first.id) }.to update_index(CitiesIndex::City).and_reindex(dummy_cities.first).only
+          expect { import City.where(id: dummy_cities.first.id) }
+            .to update_index(CitiesIndex).and_reindex(dummy_cities.first).only
         end
-      end
 
-      context 'active record', :active_record do
         specify do
-          expect { import City.where(id: dummy_cities.first.id) }.to update_index(CitiesIndex::City).and_reindex(dummy_cities.first).only
+          allow(CitiesIndex).to receive(:import_linear).and_return(double(present?: false))
+          allow(CitiesIndex).to receive(:import_parallel).and_return(double(present?: false))
+
+          expects_no_query(except: /SELECT\s+1\s+AS\s+one\s+FROM/) do
+            import City.where(id: dummy_cities.first.id)
+          end
         end
       end
     end
@@ -166,28 +180,27 @@ describe Chewy::Type::Import do
         payload = subscribe_notification
         dummy_cities.first.destroy
         import dummy_cities
-        expect(payload).to eq(type: CitiesIndex::City, import: {delete: 1, index: 2})
+        expect(payload).to eq(index: CitiesIndex, import: {delete: 1, index: 2})
       end
 
       specify do
         payload = subscribe_notification
         dummy_cities.first.destroy
         import dummy_cities, batch_size: 2
-        expect(payload).to eq(type: CitiesIndex::City, import: {delete: 1, index: 2})
+        expect(payload).to eq(index: CitiesIndex, import: {delete: 1, index: 2})
       end
 
       specify do
         payload = subscribe_notification
         import dummy_cities, batch_size: 2
-        expect(payload).to eq(type: CitiesIndex::City, import: {index: 3})
+        expect(payload).to eq(index: CitiesIndex, import: {index: 3})
       end
 
       context do
         before do
           stub_index(:cities) do
-            define_type City do
-              field :name, type: 'object'
-            end
+            index_scope City
+            field :name, type: 'object'
           end
         end
 
@@ -201,15 +214,15 @@ describe Chewy::Type::Import do
         specify do
           payload = subscribe_notification
           import dummy_cities, batch_size: 2
-          expect(payload).to eq(type: CitiesIndex::City,
-            errors: {index: {mapper_parsing_exception => %w[1 2 3]}},
-            import: {index: 3})
+          expect(payload).to eq(index: CitiesIndex,
+                                errors: {index: {mapper_parsing_exception => %w[1 2 3]}},
+                                import: {index: 3})
         end
       end
     end
 
     context 'fields' do
-      before { CitiesIndex::City.import!(dummy_cities.first(2)) }
+      before { CitiesIndex.import!(dummy_cities.first(2)) }
 
       context do
         before { expect(Chewy.client).to receive(:bulk).twice.and_call_original }
@@ -217,7 +230,7 @@ describe Chewy::Type::Import do
       end
 
       context do
-        before { CitiesIndex::City.import!(dummy_cities.last) }
+        before { CitiesIndex.import!(dummy_cities.last) }
         before { expect(Chewy.client).to receive(:bulk).once.and_call_original }
         specify { expect(import(dummy_cities, update_fields: [:name])).to eq(true) }
       end
@@ -226,10 +239,8 @@ describe Chewy::Type::Import do
     context 'fields integrational' do
       before do
         stub_index(:cities) do
-          define_type :city do
-            field :name
-            field :object, type: 'object'
-          end
+          field :name
+          field :object, type: 'object'
         end
       end
 
@@ -257,9 +268,14 @@ describe Chewy::Type::Import do
         import(objects, update_fields: %i[name])
 
         expect(payload).to eq(
-          errors: {index: {{'type' => 'mapper_parsing_exception', 'reason' => 'object mapping for [object] tried to parse field [object] as object, but found a concrete value'} => %w[2 4]}},
+          errors: {
+            index: {{
+              'type' => 'mapper_parsing_exception',
+              'reason' => 'object mapping for [object] tried to parse field [object] as object, but found a concrete value'
+            } => %w[2 4]}
+          },
           import: {index: 6},
-          type: CitiesIndex::City
+          index: CitiesIndex
         )
         expect(imported_cities).to match_array([
           {'id' => '1', 'name' => 'Name11', 'object' => {'foo' => 11}},
@@ -275,9 +291,14 @@ describe Chewy::Type::Import do
         import(objects, batch_size: 2, update_fields: %i[name])
 
         expect(payload).to eq(
-          errors: {index: {{'type' => 'mapper_parsing_exception', 'reason' => 'object mapping for [object] tried to parse field [object] as object, but found a concrete value'} => %w[2 4]}},
+          errors: {
+            index: {{
+              'type' => 'mapper_parsing_exception',
+              'reason' => 'object mapping for [object] tried to parse field [object] as object, but found a concrete value'
+            } => %w[2 4]}
+          },
           import: {index: 6},
-          type: CitiesIndex::City
+          index: CitiesIndex
         )
         expect(imported_cities).to match_array([
           {'id' => '1', 'name' => 'Name11', 'object' => {'foo' => 11}},
@@ -287,7 +308,7 @@ describe Chewy::Type::Import do
       end
 
       context do
-        before { CitiesIndex::City.import!(objects[4]) }
+        before { CitiesIndex.import!(objects[4]) }
 
         specify do
           payload = subscribe_notification
@@ -296,9 +317,14 @@ describe Chewy::Type::Import do
           import(objects, batch_size: 2, update_fields: %i[name])
 
           expect(payload).to eq(
-            errors: {index: {{'type' => 'mapper_parsing_exception', 'reason' => 'object mapping for [object] tried to parse field [object] as object, but found a concrete value'} => %w[2 4]}},
+            errors: {
+              index: {{
+                'type' => 'mapper_parsing_exception',
+                'reason' => 'object mapping for [object] tried to parse field [object] as object, but found a concrete value'
+              } => %w[2 4]}
+            },
             import: {index: 6},
-            type: CitiesIndex::City
+            index: CitiesIndex
           )
           expect(imported_cities).to match_array([
             {'id' => '1', 'name' => 'Name11', 'object' => {'foo' => 11}},
@@ -309,7 +335,7 @@ describe Chewy::Type::Import do
       end
 
       context do
-        before { CitiesIndex::City.import!(old_objects[1], old_objects[3], objects[4]) }
+        before { CitiesIndex.import!(old_objects[1], old_objects[3], objects[4]) }
 
         specify do
           payload = subscribe_notification
@@ -319,7 +345,7 @@ describe Chewy::Type::Import do
 
           expect(payload).to eq(
             import: {index: 6},
-            type: CitiesIndex::City
+            index: CitiesIndex
           )
           expect(imported_cities).to match_array([
             {'id' => '1', 'name' => 'Name11', 'object' => {'foo' => 11}},
@@ -338,7 +364,7 @@ describe Chewy::Type::Import do
 
           expect(payload).to eq(
             import: {index: 6},
-            type: CitiesIndex::City
+            index: CitiesIndex
           )
           expect(imported_cities).to match_array([
             {'id' => '1', 'name' => 'Name11', 'object' => {'foo' => 11}},
@@ -357,8 +383,8 @@ describe Chewy::Type::Import do
 
           # Full match doesn't work here.
           expect(payload[:errors][:update].keys).to match([
-            hash_including('type' => 'document_missing_exception', 'reason' => '[city][1]: document missing'),
-            hash_including('type' => 'document_missing_exception', 'reason' => '[city][3]: document missing')
+            hash_including('type' => 'document_missing_exception', 'reason' => '[_doc][1]: document missing'),
+            hash_including('type' => 'document_missing_exception', 'reason' => '[_doc][3]: document missing')
           ])
           expect(payload[:errors][:update].values).to eq([['1'], ['3']])
           expect(imported_cities).to match_array([
@@ -370,7 +396,7 @@ describe Chewy::Type::Import do
       end
 
       context do
-        before { CitiesIndex::City.import!(old_objects) }
+        before { CitiesIndex.import!(old_objects) }
 
         specify do
           payload = subscribe_notification
@@ -380,7 +406,7 @@ describe Chewy::Type::Import do
 
           expect(payload).to eq(
             import: {index: 6},
-            type: CitiesIndex::City
+            index: CitiesIndex
           )
           expect(imported_cities).to match_array([
             {'id' => '1', 'name' => 'Name11', 'object' => {'foo' => 1}},
@@ -394,7 +420,7 @@ describe Chewy::Type::Import do
       end
 
       context do
-        before { CitiesIndex::City.import!(old_objects) }
+        before { CitiesIndex.import!(old_objects) }
 
         specify do
           payload = subscribe_notification
@@ -403,9 +429,14 @@ describe Chewy::Type::Import do
           import(objects, update_fields: %i[object])
 
           expect(payload).to eq(
-            errors: {update: {{'type' => 'mapper_parsing_exception', 'reason' => 'object mapping for [object] tried to parse field [object] as object, but found a concrete value'} => %w[2 4]}},
+            errors: {
+              update: {{
+                'type' => 'mapper_parsing_exception',
+                'reason' => 'object mapping for [object] tried to parse field [object] as object, but found a concrete value'
+              } => %w[2 4]}
+            },
             import: {index: 6},
-            type: CitiesIndex::City
+            index: CitiesIndex
           )
           expect(imported_cities).to match_array([
             {'id' => '1', 'name' => 'Name1', 'object' => {'foo' => 11}},
@@ -423,9 +454,8 @@ describe Chewy::Type::Import do
       context do
         before do
           stub_index(:cities) do
-            define_type City do
-              field :name, type: 'object'
-            end
+            index_scope City
+            field :name, type: 'object'
           end
         end
 
@@ -437,9 +467,8 @@ describe Chewy::Type::Import do
       context do
         before do
           stub_index(:cities) do
-            define_type City do
-              field :name, type: 'object', value: -> { name == 'name1' ? name : {name: name} }
-            end
+            index_scope City
+            field :name, type: 'object', value: -> { name == 'name1' ? name : {name: name} }
           end
         end
 
@@ -451,19 +480,19 @@ describe Chewy::Type::Import do
 
     context 'default_import_options are set' do
       before do
-        CitiesIndex::City.default_import_options(batch_size: 500)
+        CitiesIndex.default_import_options(batch_size: 500)
       end
 
       specify do
-        expect(CitiesIndex::City.adapter).to receive(:import).with(any_args, hash_including(batch_size: 500))
-        CitiesIndex::City.import
+        expect(CitiesIndex.adapter).to receive(:import).with(any_args, hash_including(batch_size: 500))
+        CitiesIndex.import
       end
     end
   end
 
   describe '.import', :orm do
     def import(*args)
-      CitiesIndex::City.import(*args)
+      CitiesIndex.import(*args)
     end
 
     it_behaves_like 'importing'
@@ -472,62 +501,99 @@ describe Chewy::Type::Import do
       def import(*args)
         options = args.extract_options!
         options[:parallel] = 0
-        CitiesIndex::City.import(*args, options)
+        CitiesIndex.import(*args, options)
       end
 
       it_behaves_like 'importing'
     end
+
+    context 'with parent-child relationship' do
+      before do
+        stub_model(:comment)
+        stub_index(:comments) do
+          index_scope Comment
+          field :content
+          field :comment_type, type: :join, relations: {question: %i[answer comment], answer: :vote}, join: {type: :comment_type, id: :commented_id}
+        end
+      end
+
+      let!(:comments) do
+        [
+          Comment.create!(id: 1, content: 'Where is Nemo?', comment_type: :question),
+          Comment.create!(id: 2, content: 'Here.', comment_type: :answer, commented_id: 1),
+          Comment.create!(id: 3, content: 'There!', comment_type: :answer, commented_id: 1),
+          Comment.create!(id: 4, content: 'Yes, he is here.', comment_type: :vote, commented_id: 2)
+        ]
+      end
+
+      def imported_comments
+        CommentsIndex.all.map do |comment|
+          comment.attributes.except('_score', '_explanation')
+        end
+      end
+
+      it 'imports parent and children' do
+        CommentsIndex.import!(comments.map(&:id))
+
+        expect(imported_comments).to match_array([
+          {'id' => '1', 'content' => 'Where is Nemo?', 'comment_type' => 'question'},
+          {'id' => '2', 'content' => 'Here.', 'comment_type' => {'name' => 'answer', 'parent' => 1}},
+          {'id' => '3', 'content' => 'There!', 'comment_type' => {'name' => 'answer', 'parent' => 1}},
+          {'id' => '4', 'content' => 'Yes, he is here.', 'comment_type' => {'name' => 'vote', 'parent' => 2}}
+        ])
+
+        answer_ids = CommentsIndex.query(has_parent: {parent_type: 'question', query: {match: {content: 'Where'}}}).pluck(:_id)
+        expect(answer_ids).to match_array(%w[2 3])
+      end
+    end
   end
 
   describe '.import!', :orm do
-    specify { expect { CitiesIndex::City.import! }.not_to raise_error }
+    specify { expect { CitiesIndex.import! }.not_to raise_error }
 
     context do
       before do
         stub_index(:cities) do
-          define_type City do
-            field :name, type: 'object'
-          end
+          index_scope City
+          field :name, type: 'object'
         end
       end
 
-      specify { expect { CitiesIndex::City.import!(dummy_cities) }.to raise_error Chewy::ImportFailed }
+      specify { expect { CitiesIndex.import!(dummy_cities) }.to raise_error Chewy::ImportFailed }
     end
   end
 
   describe '.compose' do
     before do
       stub_index(:cities) do
-        define_type :city do
-          crutch :names do |collection|
-            collection.map { |o| [o.name, o.name + '42'] }.to_h
-          end
-          field :name, value: ->(o, c) { c.names[o.name] }
-          field :rating
+        crutch :names do |collection|
+          collection.to_h { |o| [o.name, "#{o.name}42"] }
         end
+        field :name, value: ->(o, c) { c.names[o.name] }
+        field :rating
       end
     end
 
     specify do
-      expect(CitiesIndex::City.compose(double(name: 'Name', rating: 42)))
+      expect(CitiesIndex.compose(double(name: 'Name', rating: 42)))
         .to eq('name' => 'Name42', 'rating' => 42)
     end
 
     specify do
-      expect(CitiesIndex::City.compose(double(name: 'Name', rating: 42), fields: %i[name]))
+      expect(CitiesIndex.compose(double(name: 'Name', rating: 42), fields: %i[name]))
         .to eq('name' => 'Name42')
     end
 
     context 'witchcraft' do
-      before { CitiesIndex::City.witchcraft! }
+      before { CitiesIndex.witchcraft! }
 
       specify do
-        expect(CitiesIndex::City.compose(double(name: 'Name', rating: 42)))
+        expect(CitiesIndex.compose(double(name: 'Name', rating: 42)))
           .to eq('name' => 'Name42', 'rating' => 42)
       end
 
       specify do
-        expect(CitiesIndex::City.compose(double(name: 'Name', rating: 42), fields: %i[name]))
+        expect(CitiesIndex.compose(double(name: 'Name', rating: 42), fields: %i[name]))
           .to eq('name' => 'Name42')
       end
     end
@@ -536,12 +602,12 @@ describe Chewy::Type::Import do
       let(:crutches) { double(names: {'Name' => 'Name43'}) }
 
       specify do
-        expect(CitiesIndex::City.compose(double(name: 'Name', rating: 42), crutches))
+        expect(CitiesIndex.compose(double(name: 'Name', rating: 42), crutches))
           .to eq('name' => 'Name43', 'rating' => 42)
       end
 
       specify do
-        expect(CitiesIndex::City.compose(double(name: 'Name', rating: 42), crutches, fields: %i[name]))
+        expect(CitiesIndex.compose(double(name: 'Name', rating: 42), crutches, fields: %i[name]))
           .to eq('name' => 'Name43')
       end
     end