chewy 0.9.0 → 5.2.0

data/lib/chewy/version.rb

@@ -1,3 +1,3 @@
 module Chewy
-  VERSION = '0.9.0'.freeze
+  VERSION = '5.2.0'.freeze
 end

data/lib/sequel/plugins/chewy_observe.rb

@@ -36,40 +36,25 @@ module Sequel
           callback_options = ChewyObserve.extract_callback_options!(args)
           update_proc = ChewyObserve.update_proc(type_name, *args, &block)
 
-          if Chewy.use_after_commit_callbacks
-            set_callback(:commit, callback_options, &update_proc)
-            set_callback(:destroy_commit, callback_options, &update_proc)
-          else
-            set_callback(:save, callback_options, &update_proc)
-            set_callback(:destroy, callback_options, &update_proc)
-          end
+          set_callback(:save, callback_options, &update_proc)
+          set_callback(:destroy, callback_options, &update_proc)
         end
       end
 
       # Instance level methods for Sequel::Model
       #
       module InstanceMethods
-        def after_commit
-          run_callbacks(:commit) do
-            super
-          end
-        end
-
-        def after_destroy_commit
-          run_callbacks(:destroy_commit) do
-            super
-          end
-        end
-
         def after_save
           run_callbacks(:save) do
             super
+            db.after_commit {} if Chewy.use_after_commit_callbacks
           end
         end
 
         def after_destroy
           run_callbacks(:destroy) do
             super
+            db.after_commit {} if Chewy.use_after_commit_callbacks
           end
         end
       end

data/lib/tasks/chewy.rake

@@ -1,34 +1,96 @@
 require 'chewy/rake_helper'
 
+def parse_classes(args)
+  if args.present? && args.first.tr!('-', '')
+    {except: args}
+  else
+    {only: args}
+  end
+end
+
+def parse_parallel_args(args)
+  options = {}
+  options[:parallel] = args.first =~ /\A\d+\z/ ? Integer(args.shift) : true
+  options.merge!(parse_classes(args))
+end
+
+def parse_journal_args(args)
+  options = {}
+  options[:time] = Time.parse(args.shift) if args.first =~ /\A\d+/
+  options.merge!(parse_classes(args))
+end
+
 namespace :chewy do
-  desc 'Destroy, recreate and import data to specified index'
+  desc 'Destroys, recreates and imports data for the specified indexes or all of them'
   task reset: :environment do |_task, args|
-    Chewy::RakeHelper.subscribed_task_stats do
-      indexes = args.extras
+    Chewy::RakeHelper.reset(parse_classes(args.extras))
+  end
 
-      if indexes.empty? || indexes.first.tr!('-', '')
-        Chewy::RakeHelper.reset_all(indexes)
-      else
-        Chewy::RakeHelper.reset_index(indexes)
-      end
-    end
+  desc 'Resets data for the specified indexes or all of them only if the index specification is changed'
+  task upgrade: :environment do |_task, args|
+    Chewy::RakeHelper.upgrade(parse_classes(args.extras))
   end
 
-  desc 'Updates data specified index'
+  desc 'Updates data for the specified indexes/types or all of them'
   task update: :environment do |_task, args|
-    Chewy::RakeHelper.subscribed_task_stats do
-      indexes = args.extras
+    Chewy::RakeHelper.update(parse_classes(args.extras))
+  end
 
-      if indexes.empty? || indexes.first.tr!('-', '')
-        Chewy::RakeHelper.update_all(indexes)
-      else
-        Chewy::RakeHelper.update_index(indexes)
-      end
+  desc 'Synchronizes data for the specified indexes/types or all of them'
+  task sync: :environment do |_task, args|
+    Chewy::RakeHelper.sync(parse_classes(args.extras))
+  end
+
+  desc 'Resets all the indexes with the specification changed and synchronizes the rest of them'
+  task deploy: :environment do
+    processed = Chewy::RakeHelper.upgrade
+    Chewy::RakeHelper.sync(except: processed)
+  end
+
+  namespace :parallel do
+    desc 'Parallel version of `rake chewy:reset`'
+    task reset: :environment do |_task, args|
+      Chewy::RakeHelper.reset(parse_parallel_args(args.extras))
+    end
+
+    desc 'Parallel version of `rake chewy:upgrade`'
+    task upgrade: :environment do |_task, args|
+      Chewy::RakeHelper.upgrade(parse_parallel_args(args.extras))
+    end
+
+    desc 'Parallel version of `rake chewy:update`'
+    task update: :environment do |_task, args|
+      Chewy::RakeHelper.update(parse_parallel_args(args.extras))
+    end
+
+    desc 'Parallel version of `rake chewy:sync`'
+    task sync: :environment do |_task, args|
+      Chewy::RakeHelper.sync(parse_parallel_args(args.extras))
+    end
+
+    desc 'Parallel version of `rake chewy:deploy`'
+    task deploy: :environment do |_task, args|
+      parallel = args.extras.first =~ /\A\d+\z/ ? Integer(args.extras.first) : true
+      processed = Chewy::RakeHelper.upgrade(parallel: parallel)
+      Chewy::RakeHelper.sync(except: processed, parallel: parallel)
+    end
+  end
+
+  namespace :journal do
+    desc 'Applies changes that were done after the specified time for the specified indexes/types or all of them'
+    task apply: :environment do |_task, args|
+      Chewy::RakeHelper.journal_apply(parse_journal_args(args.extras))
+    end
+
+    desc 'Removes journal records created before the specified timestamp for the specified indexes/types or all of them'
+    task clean: :environment do |_task, args|
+      Chewy::RakeHelper.journal_clean(parse_journal_args(args.extras))
     end
   end
 
-  desc 'Applies changes that were done from specified moment (as a timestamp)'
   task apply_changes_from: :environment do |_task, args|
+    ActiveSupport::Deprecation.warn '`rake chewy:apply_changes_from` is deprecated and will be removed soon, use `rake chewy:journal:apply` instead'
+
     Chewy::RakeHelper.subscribed_task_stats do
       params = args.extras
 
@@ -37,18 +99,14 @@ namespace :chewy do
       else
         timestamp, retries = params
         time = Time.at(timestamp.to_i)
-        Chewy::Journal::Apply.since(time, retries: (retries.to_i if retries))
+        Chewy::Journal.new.apply(time, retries: (retries.to_i if retries))
       end
     end
   end
 
-  desc 'Cleans journal index. It accepts timestamp until which journal will be cleaned'
   task clean_journal: :environment do |_task, args|
-    timestamp = args.extras.first
-    if timestamp
-      Chewy::Journal::Clean.until(Time.at(timestamp.to_i))
-    else
-      Chewy::Journal.delete!
-    end
+    ActiveSupport::Deprecation.warn '`rake chewy:clean_journal` is deprecated and will be removed soon, use `rake chewy:journal:clean` instead'
+
+    Chewy::Journal.new.clean(args.extras.first)
   end
 end

data/spec/chewy/config_spec.rb

@@ -13,6 +13,10 @@ describe Chewy::Config do
   its(:request_strategy) { should == :atomic }
   its(:use_after_commit_callbacks) { should == true }
   its(:indices_path) { should == 'app/chewy' }
+  its(:reset_disable_refresh_interval) { should == false }
+  its(:reset_no_replicas) { should == false }
+  its(:disable_refresh_async) { should == false }
+  its(:search_class) { should be < Chewy::Search::Request }
 
   describe '#transport_logger=' do
     let(:logger) { Logger.new('/dev/null') }
@@ -50,11 +54,104 @@ describe Chewy::Config do
     end
   end
 
+  describe '#search_class=' do
+    specify do
+      expect { subject.search_class = Chewy::Query }
+        .to change { subject.search_class }
+        .from(be < Chewy::Search::Request)
+        .to(be < Chewy::Query)
+    end
+
+    context do
+      before { hide_const('Kaminari') }
+
+      specify do
+        expect(subject.search_class.included_modules)
+          .to include(Chewy::Search::Pagination::WillPaginate)
+      end
+    end
+  end
+
+  describe '#search_class' do
+    context 'nothing is defined' do
+      before do
+        hide_const('Kaminari')
+        hide_const('WillPaginate')
+      end
+
+      specify do
+        expect(subject.search_class.included_modules)
+          .not_to include(Chewy::Search::Pagination::Kaminari)
+      end
+
+      specify do
+        expect(subject.search_class.included_modules)
+          .not_to include(Chewy::Search::Pagination::WillPaginate)
+      end
+    end
+
+    context 'kaminari' do
+      before { hide_const('WillPaginate') }
+
+      specify do
+        expect(subject.search_class.included_modules)
+          .to include(Chewy::Search::Pagination::Kaminari)
+      end
+
+      specify do
+        expect(subject.search_class.included_modules)
+          .not_to include(Chewy::Search::Pagination::WillPaginate)
+      end
+    end
+
+    context 'will_paginate' do
+      before { hide_const('Kaminari') }
+
+      specify do
+        expect(subject.search_class.included_modules)
+          .not_to include(Chewy::Search::Pagination::Kaminari)
+      end
+
+      specify do
+        expect(subject.search_class.included_modules)
+          .to include(Chewy::Search::Pagination::WillPaginate)
+      end
+    end
+
+    context 'both are defined' do
+      specify do
+        expect(subject.search_class.included_modules)
+          .to include(Chewy::Search::Pagination::Kaminari)
+      end
+
+      specify do
+        expect(subject.search_class.included_modules)
+          .not_to include(Chewy::Search::Pagination::WillPaginate)
+      end
+    end
+  end
+
   describe '#configuration' do
-    before { subject.settings = { indices_path: 'app/custom_indices_path' } }
+    before { subject.settings = {indices_path: 'app/custom_indices_path'} }
 
     specify do
       expect(subject.configuration).to include(indices_path: 'app/custom_indices_path')
     end
+
+    context 'when Rails::VERSION constant is defined' do
+      it 'looks for configuration in "config/chewy.yml"' do
+        module Rails
+          VERSION = '5.1.1'.freeze
+
+          def self.root
+            Pathname.new(__dir__)
+          end
+        end
+
+        expect(File).to receive(:exist?)
+          .with(Pathname.new(__dir__).join('config', 'chewy.yml'))
+        subject.configuration
+      end
+    end
   end
 end

data/spec/chewy/fields/base_spec.rb

@@ -8,8 +8,10 @@ describe Chewy::Fields::Base do
     let(:field) { described_class.new(:name, value: ->(o) { o.value }) }
 
     specify { expect(field.compose(double(value: 'hello'))).to eq(name: 'hello') }
-    specify { expect(field.compose(double(value: %w(hello world)))).to eq(name: %w(hello world)) }
+    specify { expect(field.compose(double(value: %w[hello world]))).to eq(name: %w[hello world]) }
 
+    specify { expect(described_class.new(:name, value: :last_name).compose(double(last_name: 'hello'))).to eq(name: 'hello') }
+    specify { expect(described_class.new(:name, value: :last_name).compose('last_name' => 'hello')).to eq(name: 'hello') }
     specify { expect(described_class.new(:name).compose(double(name: 'hello'))).to eq(name: 'hello') }
     specify { expect(described_class.new(:false_value).compose(false_value: false)).to eq(false_value: false) }
     specify { expect(described_class.new(:true_value).compose(true_value: true)).to eq(true_value: true) }
@@ -24,23 +26,24 @@ describe Chewy::Fields::Base do
 
       specify do
         expect(field.compose(double(value: double(subvalue1: 'hello', subvalue2: 'value', subname3: 'world'))))
-          .to eq(name: { subname1: 'hello', subname2: 'value', subname3: 'world' })
+          .to eq(name: {subname1: 'hello', subname2: 'value', subname3: 'world'})
       end
       specify do
         expect(field.compose(double(value: [
           double(subvalue1: 'hello1', subvalue2: 'value1', subname3: 'world1'),
           double(subvalue1: 'hello2', subvalue2: 'value2', subname3: 'world2')
         ]))).to eq(name: [
-          { subname1: 'hello1', subname2: 'value1', subname3: 'world1' },
-          { subname1: 'hello2', subname2: 'value2', subname3: 'world2' }
+          {subname1: 'hello1', subname2: 'value1', subname3: 'world1'},
+          {subname1: 'hello2', subname2: 'value2', subname3: 'world2'}
         ])
       end
     end
 
     context 'parent objects' do
-      let!(:country) { described_class.new(:name, value: ->(country) { country.cities }) }
-      let!(:city) { described_class.new(:name, value: ->(city, country) { city.districts.map { |district| [district, country.name] } }) }
-      let!(:district) { described_class.new(:name, value: ->(district, city, country) { [district, city.name, country.name] }) }
+      let!(:country) { described_class.new(:name, value: ->(country, crutches) { country.cities.map { |city| double(districts: city.districts, name: crutches.city_name) } }) }
+      let!(:city) { described_class.new(:name, value: ->(city, country, crutches) { city.districts.map { |district| [district, country.name, crutches.suffix] } }) }
+      let!(:district) { described_class.new(:name, value: ->(district, city, country, crutches) { [district, city.name, country.name, crutches] }) }
+      let(:crutches) { double(suffix: 'suffix', city_name: 'Bangkok') }
 
       before do
         country.children.push(city)
@@ -49,18 +52,18 @@ describe Chewy::Fields::Base do
 
       specify do
         expect(country.compose(double(name: 'Thailand', cities: [
-          double(name: 'Bangkok', districts: %w(First Second))
-        ]))).to eq(name: [
-          { name: [
-            { name: [%w(First Thailand), 'Bangkok', 'Thailand'] },
-            { name: [%w(Second Thailand), 'Bangkok', 'Thailand'] }
-          ] }
+          double(districts: %w[First Second])
+        ]), crutches)).to eq(name: [
+          {name: [
+            {name: [%w[First Thailand suffix], 'Bangkok', 'Thailand', crutches]},
+            {name: [%w[Second Thailand suffix], 'Bangkok', 'Thailand', crutches]}
+          ]}
         ])
       end
     end
 
     context 'implicit values' do
-      let(:field) { described_class.new(:name, type: 'string') }
+      let(:field) { described_class.new(:name, type: 'integer') }
       before do
         field.children.push(described_class.new(:name))
         field.children.push(described_class.new(:untouched))
@@ -71,50 +74,52 @@ describe Chewy::Fields::Base do
 
     context 'hash values' do
       let(:field) { described_class.new(:name, type: 'object') }
-      let(:object) { double(name: { key1: 'value1', key2: 'value2' }) }
+      let(:object) { double(name: {key1: 'value1', key2: 'value2'}) }
 
       before do
         field.children.push(described_class.new(:key1, value: ->(h) { h[:key1] }))
         field.children.push(described_class.new(:key2, value: ->(h) { h[:key2] }))
       end
 
-      specify { expect(field.compose(object)).to eq(name: { key1: 'value1', key2: 'value2' }) }
+      specify { expect(field.compose(object)).to eq(name: {key1: 'value1', key2: 'value2'}) }
     end
   end
 
   describe '#mappings_hash' do
     let(:field) { described_class.new(:name, type: :object) }
-    let(:fields1) { Array.new(2) { |i| described_class.new("name#{i + 1}", type: "string#{i + 1}") } }
-    let(:fields2) { Array.new(2) { |i| described_class.new("name#{i + 3}", type: "string#{i + 3}") } }
+    let(:fields1) { Array.new(2) { |i| described_class.new("name#{i + 1}", type: "integer#{i + 1}") } }
+    let(:fields2) { Array.new(2) { |i| described_class.new("name#{i + 3}", type: "integer#{i + 3}") } }
     before do
       fields1.each { |m| field.children.push(m) }
       fields2.each { |m| fields1[0].children.push(m) }
     end
 
     specify do
-      expect(field.mappings_hash).to eq(name: { type: :object, properties: {
-                                          name1: { type: 'string1', fields: {
-                                            name3: { type: 'string3' }, name4: { type: 'string4' }
-                                          } }, name2: { type: 'string2' }
-                                        } })
+      expect(field.mappings_hash).to eq(name: {type: :object, properties: {
+        name1: {type: 'integer1', fields: {
+          name3: {type: 'integer3'}, name4: {type: 'integer4'}
+        }}, name2: {type: 'integer2'}
+      }})
     end
 
     context do
-      let(:field) { described_class.new(:name, type: :string) }
-      let(:fields1) { Array.new(2) { |i| described_class.new("name#{i + 1}") } }
+      let(:field) { described_class.new(:name, type: :integer) }
+      let(:fields1) do
+        [described_class.new(:name1), described_class.new(:name2, type: 'integer')]
+      end
 
       specify do
-        expect(field.mappings_hash).to eq(name: { type: :string, fields: {
-                                            name1: { type: 'object', properties: {
-                                              name3: { type: 'string3' }, name4: { type: 'string4' }
-                                            } }, name2: { type: 'string' }
-                                          } })
+        expect(field.mappings_hash).to eq(name: {type: :integer, fields: {
+          name1: {type: 'object', properties: {
+            name3: {type: 'integer3'}, name4: {type: 'integer4'}
+          }}, name2: {type: 'integer'}
+        }})
       end
     end
   end
 
   context 'integration' do
-    context 'objects, hashes and arrays' do
+    context 'default field type' do
       before do
         stub_index(:events) do
           define_type :event do
@@ -123,108 +128,134 @@ describe Chewy::Fields::Base do
               field :id
               field :licenses do
                 field :id
-                field :name
+                field :created_at, type: 'time'
               end
             end
           end
         end
       end
 
+      around do |example|
+        previous_type = Chewy.default_field_type
+        Chewy.default_field_type = 'integer'
+        example.run
+        Chewy.default_field_type = previous_type
+      end
+
       specify do
         expect(EventsIndex::Event.mappings_hash).to eq(event: {
-                                                         properties: {
-                                                           id: { type: 'string' },
-                                                           category: {
-                                                             type: 'object',
-                                                             properties: {
-                                                               id: { type: 'string' },
-                                                               licenses: {
-                                                                 type: 'object',
-                                                                 properties: {
-                                                                   id: { type: 'string' },
-                                                                   name: { type: 'string' }
-                                                                 }
-                                                               }
-                                                             }
-                                                           }
-                                                         }
-                                                       })
+          properties: {
+            id: {type: 'integer'},
+            category: {
+              type: 'object',
+              properties: {
+                id: {type: 'integer'},
+                licenses: {
+                  type: 'object',
+                  properties: {
+                    id: {type: 'integer'},
+                    created_at: {type: 'time'}
+                  }
+                }
+              }
+            }
+          }
+        })
       end
+    end
 
+    context 'objects, hashes and arrays' do
+      before do
+        stub_index(:events) do
+          define_type :event do
+            field :id
+            field :category do
+              field :id
+              field :licenses do
+                field :id
+                field :name
+              end
+            end
+          end
+        end
+      end
+
+      # rubocop:disable Style/BracesAroundHashParameters
       specify do
-        expect(EventsIndex::Event.root_object.compose(
-                 id: 1, category: { id: 2, licenses: { id: 3, name: 'Name' } }
-        )).to eq('event' => { 'id' => 1, 'category' => { 'id' => 2, 'licenses' => { 'id' => 3, 'name' => 'Name' } } })
+        expect(EventsIndex::Event.root.compose({
+          id: 1, category: {id: 2, licenses: {id: 3, name: 'Name'}}
+        })).to eq('id' => 1, 'category' => {'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name'}})
       end
 
       specify do
-        expect(EventsIndex::Event.root_object.compose(id: 1, category: [
-          { id: 2, 'licenses' => { id: 3, name: 'Name1' } },
-          { id: 4, licenses: nil }
-        ])).to eq('event' => { 'id' => 1, 'category' => [
-          { 'id' => 2, 'licenses' => { 'id' => 3, 'name' => 'Name1' } },
-          { 'id' => 4, 'licenses' => nil.as_json }
-        ] })
+        expect(EventsIndex::Event.root.compose({id: 1, category: [
+          {id: 2, 'licenses' => {id: 3, name: 'Name1'}},
+          {id: 4, licenses: nil}
+        ]})).to eq('id' => 1, 'category' => [
+          {'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name1'}},
+          {'id' => 4, 'licenses' => nil.as_json}
+        ])
       end
 
       specify do
-        expect(EventsIndex::Event.root_object.compose('id' => 1, category: { id: 2, licenses: [
-          { id: 3, name: 'Name1' }, { id: 4, name: 'Name2' }
-        ] })).to eq('event' => { 'id' => 1, 'category' => { 'id' => 2, 'licenses' => [
-          { 'id' => 3, 'name' => 'Name1' }, { 'id' => 4, 'name' => 'Name2' }
-        ] } })
+        expect(EventsIndex::Event.root.compose({'id' => 1, category: {id: 2, licenses: [
+          {id: 3, name: 'Name1'}, {id: 4, name: 'Name2'}
+        ]}})).to eq('id' => 1, 'category' => {'id' => 2, 'licenses' => [
+          {'id' => 3, 'name' => 'Name1'}, {'id' => 4, 'name' => 'Name2'}
+        ]})
       end
 
       specify do
-        expect(EventsIndex::Event.root_object.compose(id: 1, category: [
-          { id: 2, licenses: [
-            { id: 3, 'name' => 'Name1' }, { id: 4, name: 'Name2' }
-          ] },
-          { id: 5, licenses: [] }
-        ])).to eq('event' => { 'id' => 1, 'category' => [
-          { 'id' => 2, 'licenses' => [
-            { 'id' => 3, 'name' => 'Name1' }, { 'id' => 4, 'name' => 'Name2' }
-          ] },
-          { 'id' => 5, 'licenses' => [] }
-        ] })
+        expect(EventsIndex::Event.root.compose({id: 1, category: [
+          {id: 2, licenses: [
+            {id: 3, 'name' => 'Name1'}, {id: 4, name: 'Name2'}
+          ]},
+          {id: 5, licenses: []}
+        ]})).to eq('id' => 1, 'category' => [
+          {'id' => 2, 'licenses' => [
+            {'id' => 3, 'name' => 'Name1'}, {'id' => 4, 'name' => 'Name2'}
+          ]},
+          {'id' => 5, 'licenses' => []}
+        ])
       end
+      # rubocop:enable Style/BracesAroundHashParameters
 
       specify do
-        expect(EventsIndex::Event.root_object.compose(
+        expect(EventsIndex::Event.root.compose(
                  double(id: 1, category: double(id: 2, licenses: double(id: 3, name: 'Name')))
-        )).to eq('event' => { 'id' => 1, 'category' => { 'id' => 2, 'licenses' => { 'id' => 3, 'name' => 'Name' } } })
+        )).to eq('id' => 1, 'category' => {'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name'}})
       end
 
       specify do
-        expect(EventsIndex::Event.root_object.compose(double(id: 1, category: [
+        expect(EventsIndex::Event.root.compose(double(id: 1, category: [
           double(id: 2, licenses: double(id: 3, name: 'Name1')),
           double(id: 4, licenses: nil)
-        ]))).to eq('event' => { 'id' => 1, 'category' => [
-          { 'id' => 2, 'licenses' => { 'id' => 3, 'name' => 'Name1' } },
-          { 'id' => 4, 'licenses' => nil.as_json }
-        ] })
+        ]))).to eq('id' => 1, 'category' => [
+          {'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name1'}},
+          {'id' => 4, 'licenses' => nil.as_json}
+        ])
       end
 
       specify do
-        expect(EventsIndex::Event.root_object.compose(double(id: 1, category: double(id: 2, licenses: [
+        expect(EventsIndex::Event.root.compose(double(id: 1, category: double(id: 2, licenses: [
           double(id: 3, name: 'Name1'), double(id: 4, name: 'Name2')
-        ])))).to eq('event' => { 'id' => 1, 'category' => { 'id' => 2, 'licenses' => [
-          { 'id' => 3, 'name' => 'Name1' }, { 'id' => 4, 'name' => 'Name2' }
-        ] } })
+        ])))).to eq('id' => 1, 'category' => {'id' => 2, 'licenses' => [
+          {'id' => 3, 'name' => 'Name1'}, {'id' => 4, 'name' => 'Name2'}
+        ]})
       end
 
       specify do
-        expect(EventsIndex::Event.root_object.compose(double(id: 1, category: [
+        expect(EventsIndex::Event.root.compose(double(id: 1, category: [
           double(id: 2, licenses: [
             double(id: 3, name: 'Name1'), double(id: 4, name: 'Name2')
           ]),
           double(id: 5, licenses: [])
-        ]))).to eq('event' => { 'id' => 1, 'category' => [
-          { 'id' => 2, 'licenses' => [
-            { 'id' => 3, 'name' => 'Name1' }, { 'id' => 4, 'name' => 'Name2' }
-          ] },
-          { 'id' => 5, 'licenses' => [] }
-        ] })
+        ]))).to eq('id' => 1, 'category' => [
+          {'id' => 2, 'licenses' => [
+            {'id' => 3, 'name' => 'Name1'}, {'id' => 4, 'name' => 'Name2'}
+          ]},
+          {'id' => 5, 'licenses' => []}
+        ])
       end
     end
 
@@ -232,11 +263,11 @@ describe Chewy::Fields::Base do
       before do
         stub_index(:events) do
           define_type :event do
-            field :id
+            field :id, type: 'integer'
             field :category, value: -> { categories } do
-              field :id
+              field :id, type: 'integer'
               field :licenses, value: -> { license } do
-                field :id
+                field :id, type: 'integer'
                 field :name
               end
             end
@@ -245,9 +276,9 @@ describe Chewy::Fields::Base do
       end
 
       specify do
-        expect(EventsIndex::Event.root_object.compose(
+        expect(EventsIndex::Event.root.compose(
                  double(id: 1, categories: double(id: 2, license: double(id: 3, name: 'Name')))
-        )).to eq('event' => { 'id' => 1, 'category' => { 'id' => 2, 'licenses' => { 'id' => 3, 'name' => 'Name' } } })
+        )).to eq('id' => 1, 'category' => {'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name'}})
       end
     end
 
@@ -255,8 +286,8 @@ describe Chewy::Fields::Base do
       before do
         stub_index(:events) do
           define_type :event do
-            field :id
-            field :name, type: 'string' do
+            field :id, type: 'integer'
+            field :name, type: 'integer' do
               field :raw, analyzer: 'my_own'
             end
             field :category, type: 'object'
@@ -266,43 +297,43 @@ describe Chewy::Fields::Base do
 
       specify do
         expect(EventsIndex::Event.mappings_hash).to eq(event: {
-                                                         properties: {
-                                                           id: { type: 'string' },
-                                                           name: {
-                                                             type: 'string',
-                                                             fields: {
-                                                               raw: { analyzer: 'my_own', type: 'string' }
-                                                             }
-                                                           },
-                                                           category: { type: 'object' }
-                                                         }
-                                                       })
+          properties: {
+            id: {type: 'integer'},
+            name: {
+              type: 'integer',
+              fields: {
+                raw: {analyzer: 'my_own', type: Chewy.default_field_type}
+              }
+            },
+            category: {type: 'object'}
+          }
+        })
       end
 
       specify do
-        expect(EventsIndex::Event.root_object.compose(
-                 double(id: 1, name: 'Jonny', category: double(id: 2, as_json: { 'name' => 'Borogoves' }))
-        )).to eq('event' => {
-                   'id' => 1,
-                   'name' => 'Jonny',
-                   'category' => { 'name' => 'Borogoves' }
-                 })
+        expect(EventsIndex::Event.root.compose(
+                 double(id: 1, name: 'Jonny', category: double(id: 2, as_json: {'name' => 'Borogoves'}))
+        )).to eq(
+          'id' => 1,
+          'name' => 'Jonny',
+          'category' => {'name' => 'Borogoves'}
+        )
       end
 
       specify do
-        expect(EventsIndex::Event.root_object.compose(
+        expect(EventsIndex::Event.root.compose(
                  double(id: 1, name: 'Jonny', category: [
-                   double(id: 2, as_json: { 'name' => 'Borogoves1' }),
-                   double(id: 3, as_json: { 'name' => 'Borogoves2' })
+                   double(id: 2, as_json: {'name' => 'Borogoves1'}),
+                   double(id: 3, as_json: {'name' => 'Borogoves2'})
                  ])
-        )).to eq('event' => {
-                   'id' => 1,
-                   'name' => 'Jonny',
-                   'category' => [
-                     { 'name' => 'Borogoves1' },
-                     { 'name' => 'Borogoves2' }
-                   ]
-                 })
+        )).to eq(
+          'id' => 1,
+          'name' => 'Jonny',
+          'category' => [
+            {'name' => 'Borogoves1'},
+            {'name' => 'Borogoves2'}
+          ]
+        )
       end
     end
 
@@ -320,7 +351,11 @@ describe Chewy::Fields::Base do
             Country.has_many :cities, order: :id
           end
         when :mongoid
-          City.belongs_to :country
+          if Mongoid::VERSION.start_with?('6')
+            City.belongs_to :country, optional: true
+          else
+            City.belongs_to :country
+          end
           Country.has_many :cities, order: :id.asc
         when :sequel
           City.many_to_one :country
@@ -351,9 +386,9 @@ describe Chewy::Fields::Base do
       end
 
       specify do
-        expect(CountriesIndex::Country.root_object.compose(country_with_cities)).to eq('country' => { 'id' => 1, 'cities' => [
-          { 'id' => 1, 'name' => 'City1' }, { 'id' => 2, 'name' => 'City2' }
-        ] })
+        expect(CountriesIndex::Country.root.compose(country_with_cities)).to eq('id' => 1, 'cities' => [
+          {'id' => 1, 'name' => 'City1'}, {'id' => 2, 'name' => 'City2'}
+        ])
       end
 
       context 'nested object' do
@@ -370,9 +405,9 @@ describe Chewy::Fields::Base do
         end
 
         specify do
-          expect(CitiesIndex::City.root_object.compose(
+          expect(CitiesIndex::City.root.compose(
                    City.create!(id: 1, country: Country.create!(id: 1, name: 'Country'))
-          )).to eq('city' => { 'id' => 1, 'country' => { 'id' => 1, 'name' => 'Country' } })
+          )).to eq('id' => 1, 'country' => {'id' => 1, 'name' => 'Country'})
         end
       end
     end