chewy 0.5.2 → 0.6.0

data/lib/chewy/query/compose.rb

@@ -30,11 +30,11 @@ module Chewy
       def _queries_join queries, logic
         queries = queries.compact
 
-        if queries.many?
+        if queries.many? || (queries.any? && logic == :must_not)
           case logic
           when :dis_max
             { dis_max: { queries: queries } }
-          when :must, :should
+          when :must, :should, :must_not
             { bool: { logic => queries } }
           else
             if logic.is_a?(Float)
@@ -51,11 +51,11 @@ module Chewy
       def _filters_join filters, logic
         filters = filters.compact
 
-        if filters.many?
+        if filters.many? || (filters.any? && logic == :must_not)
           case logic
           when :and, :or
             { logic => filters }
-          when :must, :should
+          when :must, :should, :must_not
             { bool: { logic => filters } }
           else
             { bool: { should: filters, minimum_should_match: logic } }

data/lib/chewy/query/pagination.rb

@@ -3,13 +3,14 @@ module Chewy
     module Pagination
       # Returns request total found documents count
       #
-      #   PlacesIndex.query(...).filter(...).total_count
+      #   PlacesIndex.query(...).filter(...).total
       #
-      def total_count
+      def total
         _response['hits'].try(:[], 'total') || 0
       end
+
+      alias_method :total_count, :total
+      alias_method :total_entries, :total
     end
   end
 end
-
-require 'chewy/query/pagination/kaminari' if defined?(::Kaminari)

data/lib/chewy/query/pagination/kaminari.rb

@@ -34,4 +34,4 @@ module Chewy
   end
 end
 
-Chewy::Query::Pagination.send :include, Chewy::Query::Pagination::Kaminari
+Chewy::Query.send :include, Chewy::Query::Pagination::Kaminari

data/lib/chewy/query/pagination/will_paginate.rb

@@ -0,0 +1,27 @@
+module Chewy
+  class Query
+    module Pagination
+      module WillPaginate
+        extend ActiveSupport::Concern
+        include ::WillPaginate::CollectionMethods
+
+        attr_reader :current_page, :per_page
+
+        def paginate(options={})
+          @current_page = ::WillPaginate::PageNumber(options[:page] || @current_page || 1)
+          @page_multiplier = @current_page - 1
+          @per_page = (options[:per_page] || @per_page || ::WillPaginate.per_page).to_i
+
+          #call Chewy::Query methods to limit results
+          limit(@per_page).offset(@page_multiplier * @per_page)
+        end
+
+        def page(page)
+          paginate(page: page)
+        end
+      end
+    end
+  end
+end
+
+Chewy::Query.send :include, Chewy::Query::Pagination::WillPaginate

data/lib/chewy/type.rb

@@ -6,6 +6,7 @@ require 'chewy/type/actions'
 require 'chewy/type/import'
 require 'chewy/type/adapter/object'
 require 'chewy/type/adapter/active_record'
+require 'chewy/type/adapter/mongoid'
 
 module Chewy
   class Type

data/lib/chewy/type/adapter/active_record.rb

@@ -72,7 +72,7 @@ module Chewy
             result
           else
             if collection.all? { |object| object.respond_to?(:id) }
-              collection.in_groups_of(import_options[:batch_size], false).map do |group|
+              collection.each_slice(import_options[:batch_size]).map do |group|
                 block.call grouped_objects(group)
               end.all?
             else
@@ -112,7 +112,7 @@ module Chewy
             indexed &= block.call(grouped_objects(objects))
           end
 
-          deleted = ids.in_groups_of(import_options[:batch_size], false).map do |group|
+          deleted = ids.each_slice(import_options[:batch_size]).map do |group|
             block.call(delete: group)
           end.all?
 

data/lib/chewy/type/adapter/mongoid.rb

@@ -0,0 +1,147 @@
+require 'chewy/type/adapter/base'
+
+module Chewy
+  class Type
+    module Adapter
+      class Mongoid < Base
+        def initialize *args
+          @options = args.extract_options!
+          subject = args.first
+          if subject.is_a?(::Mongoid::Criteria)
+            @model = subject.klass
+            @scope = subject
+          else
+            @model = subject
+          end
+        end
+
+        def name
+          @name ||= (options[:name].present? ? options[:name].to_s.camelize : model.model_name.to_s).demodulize
+        end
+
+        # Import method for Mongoid takes import data and import options
+        #
+        # Import data types:
+        #
+        #   * Nothing passed - imports all the model data
+        #   * ActiveRecord scope
+        #   * Objects collection
+        #   * Ids collection
+        #
+        # Import options:
+        #
+        #   <tt>:batch_size</tt> - import batch size, 1000 objects by default
+        #
+        # Method handles destroyed objects as well. In case of objects AcriveRecord::Relation
+        # or array passed, objects, responding with true to `destroyed?` method will be deleted
+        # from index. In case of ids array passed - documents with missing records ids will be
+        # deleted from index:
+        #
+        #   users = User.all
+        #   users.each { |user| user.destroy if user.incative? }
+        #   UsersIndex::User.import users # inactive users will be deleted from index
+        #   # or
+        #   UsersIndex::User.import users.map(&:id) # deleted user ids will be deleted from index
+        #
+        # Also there is custom API method `delete_from_index?`. It it returns `true`
+        # object will be deleted from index. Note that if this method is defined and
+        # return `false` Chewy will still check `destroyed?` method. This is useful
+        # for paranoid objects sdeleting implementation.
+        #
+        #   class User
+        #     alias_method :delete_from_index?, :deleted_at?
+        #   end
+        #
+        #   users = User.all
+        #   users.each { |user| user.deleted_at = Time.now }
+        #   UsersIndex::User.import users # paranoid deleted users will be deleted from index
+        #   # or
+        #   UsersIndex::User.import users.map(&:id) # user ids will be deleted from index
+        #
+        def import *args, &block
+          import_options = args.extract_options!
+          import_options[:batch_size] ||= BATCH_SIZE
+          batch_size = import_options[:batch_size]
+
+          collection = args.none? ? model_all :
+            (args.one? && args.first.is_a?(::Mongoid::Criteria) ? args.first : args.flatten.compact)
+
+          if collection.is_a?(::Mongoid::Criteria)
+            result = true
+            merged_scope(collection).batch_size(batch_size).no_timeout.each_slice(batch_size) do |batch|
+              result &= block.call grouped_objects(batch)
+            end
+            result
+          else
+            if collection.all? { |object| object.respond_to?(:id) }
+              collection.each_slice(batch_size).map do |group|
+                block.call grouped_objects(group)
+              end.all?
+            else
+              import_ids(collection, import_options, &block)
+            end
+          end
+        end
+
+        def load *args
+          load_options = args.extract_options!
+          objects = args.flatten
+
+          additional_scope = load_options[load_options[:_type].type_name.to_sym].try(:[], :scope) || load_options[:scope]
+
+          scope = scoped_model(objects.map(&:id))
+          loaded_objects = if additional_scope.is_a?(Proc)
+            scope.instance_exec(&additional_scope)
+          elsif additional_scope.is_a?(::Mongoid::Criteria)
+            scope.merge(additional_scope)
+          else
+            scope
+          end.index_by { |object| object.id.to_s }
+
+          objects.map { |object| loaded_objects[object.id.to_s] }
+        end
+
+      private
+
+        attr_reader :model, :scope, :options
+
+        def import_ids(ids, import_options = {}, &block)
+          ids.uniq!
+          batch_size = import_options[:batch_size] || BATCH_SIZE
+
+          indexed = true
+          merged_scope(scoped_model(ids)).batch_size(batch_size).no_timeout.each_slice(batch_size) do |batch|
+            ids -= batch.map(&:id)
+            indexed &= block.call(grouped_objects(batch))
+          end
+
+          deleted = ids.each_slice(batch_size).map do |group|
+            block.call(delete: group)
+          end.all?
+
+          indexed && deleted
+        end
+
+        def grouped_objects(objects)
+          objects.group_by do |object|
+            delete = object.delete_from_index? if object.respond_to?(:delete_from_index?)
+            delete ||= object.destroyed?
+            delete ? :delete : :index
+          end
+        end
+
+        def merged_scope(target)
+          scope ? scope.clone.merge(target) : target
+        end
+
+        def scoped_model(ids)
+          model.where(:_id.in => ids)
+        end
+
+        def model_all
+          model.all
+        end
+      end
+    end
+  end
+end

data/lib/chewy/type/adapter/object.rb

@@ -33,7 +33,7 @@ module Chewy
           batch_size = import_options.delete(:batch_size) || BATCH_SIZE
           objects = args.flatten.compact
 
-          objects.in_groups_of(batch_size, false).map do |group|
+          objects.each_slice(batch_size).map do |group|
             action_groups = group.group_by do |object|
               raise "Object is not a `#{target}`" if class_target? && !object.is_a?(target)
               delete = object.delete_from_index? if object.respond_to?(:delete_from_index?)

data/lib/chewy/type/import.rb

@@ -84,6 +84,7 @@ module Chewy
           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.parent_id

data/lib/chewy/type/observe.rb

@@ -3,14 +3,35 @@ module Chewy
     module Observe
       extend ActiveSupport::Concern
 
+      module MongoidMethods
+        def update_index(type_name, *args, &block)
+          options = args.extract_options!
+          method = args.first
+
+          update = Proc.new do
+            backreference = if method && method.to_s == 'self'
+              self
+            elsif method
+              send(method)
+            else
+              instance_eval(&block)
+            end
+
+            Chewy.derive_type(type_name).update_index(backreference, options)
+          end
+
+          after_save &update
+          after_destroy &update
+        end
+      end
+
       module ActiveRecordMethods
         def update_index(type_name, *args, &block)
           options = args.extract_options!
           method = args.first
 
           update = Proc.new do
-            update_options = options.reverse_merge(urgent: Chewy.urgent_update)
-            clear_association_cache if update_options[:urgent]
+            clear_association_cache if Chewy.urgent_update
 
             backreference = if method && method.to_s == 'self'
               self
@@ -20,7 +41,7 @@ module Chewy
               instance_eval(&block)
             end
 
-            Chewy.derive_type(type_name).update_index(backreference, update_options)
+            Chewy.derive_type(type_name).update_index(backreference, options)
           end
 
           after_save &update
@@ -31,14 +52,21 @@ module Chewy
       module ClassMethods
         def update_index(objects, options = {})
           if Chewy.atomic?
-            ids = if objects.is_a?(::ActiveRecord::Relation)
+            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
-          else
-            import(objects) if options[:urgent]
+          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
 
           true

data/lib/chewy/version.rb

@@ -1,3 +1,3 @@
 module Chewy
-  VERSION = '0.5.2'
+  VERSION = '0.6.0'
 end

data/spec/chewy/config_spec.rb

@@ -14,42 +14,42 @@ describe Chewy::Config do
   its(:char_filters) { should == {} }
 
   describe '#analyzer' do
-    specify { subject.analyzer(:name).should be_nil }
+    specify { expect(subject.analyzer(:name)).to be_nil }
 
     context do
       before { subject.analyzer(:name, option: :foo) }
-      specify { subject.analyzer(:name).should == {option: :foo} }
-      specify { subject.analyzers.should == {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 { subject.tokenizer(:name).should be_nil }
+    specify { expect(subject.tokenizer(:name)).to be_nil }
 
     context do
       before { subject.tokenizer(:name, option: :foo) }
-      specify { subject.tokenizer(:name).should == {option: :foo} }
-      specify { subject.tokenizers.should == {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 { subject.filter(:name).should be_nil }
+    specify { expect(subject.filter(:name)).to be_nil }
 
     context do
       before { subject.filter(:name, option: :foo) }
-      specify { subject.filter(:name).should == {option: :foo} }
-      specify { subject.filters.should == {name: {option: :foo}} }
+      specify { expect(subject.filter(:name)).to eq({option: :foo}) }
+      specify { expect(subject.filters).to eq({name: {option: :foo}}) }
     end
   end
 
   describe '#char_filter' do
-    specify { subject.char_filter(:name).should be_nil }
+    specify { expect(subject.char_filter(:name)).to be_nil }
 
     context do
       before { subject.char_filter(:name, option: :foo) }
-      specify { subject.char_filter(:name).should == {option: :foo} }
-      specify { subject.char_filters.should == {name: {option: :foo}} }
+      specify { expect(subject.char_filter(:name)).to eq({option: :foo}) }
+      specify { expect(subject.char_filters).to eq({name: {option: :foo}}) }
     end
   end
 
@@ -62,8 +62,8 @@ describe Chewy::Config do
 
   describe '#atomic?' do
     its(:atomic?) { should eq(false) }
-    specify { subject.atomic { subject.atomic?.should eq(true) } }
-    specify { subject.atomic { }; subject.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
@@ -74,9 +74,9 @@ describe Chewy::Config do
     end
     let(:dummy_type) { DummiesIndex::Dummy }
 
-    specify { subject.atomic { 42 }.should == 42 }
+    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 { subject.stash.should == [{}, {}] } } }
+    specify { subject.atomic { subject.atomic { expect(subject.stash).to eq([{}, {}]) } } }
 
     specify do
       expect(dummy_type).to receive(:import).with([1, 2, 3]).once
@@ -107,6 +107,6 @@ describe Chewy::Config do
   end
 
   describe '#stash' do
-    specify { subject.atomic { subject.stash.should == [{}] } }
+    specify { subject.atomic { expect(subject.stash).to eq([{}]) } }
   end
 end

data/spec/chewy/fields/base_spec.rb

@@ -1,16 +1,16 @@
 require 'spec_helper'
 
 describe Chewy::Fields::Base do
-  specify { described_class.new('name').name.should == :name }
-  specify { described_class.new('name', type: 'integer').options[:type].should == 'integer' }
+  specify { expect(described_class.new('name').name).to eq(:name) }
+  specify { expect(described_class.new('name', type: 'integer').options[:type]).to eq('integer') }
 
   describe '#compose' do
     let(:field) { described_class.new(:name, value: ->(o){ o.value }) }
 
-    specify { field.compose(double(value: 'hello')).should == {name: 'hello'} }
-    specify { field.compose(double(value: ['hello', 'world'])).should == {name: ['hello', 'world']} }
+    specify { expect(field.compose(double(value: 'hello'))).to eq({name: 'hello'}) }
+    specify { expect(field.compose(double(value: ['hello', 'world']))).to eq({name: ['hello', 'world']}) }
 
-    specify { described_class.new(:name).compose(double(name: 'hello')).should == {name: 'hello'} }
+    specify { expect(described_class.new(:name).compose(double(name: 'hello'))).to eq({name: 'hello'}) }
 
     context do
       before do
@@ -19,15 +19,15 @@ describe Chewy::Fields::Base do
         field.nested(described_class.new(:subname3))
       end
 
-      specify { field.compose(double(value: double(subvalue1: 'hello', subvalue2: 'value', subname3: 'world')))
-        .should == {name: {'subname1' => 'hello', 'subname2' => 'value', 'subname3' => 'world'}} }
-      specify { field.compose(double(value: [
+      specify { expect(field.compose(double(value: double(subvalue1: 'hello', subvalue2: 'value', subname3: 'world'))))
+        .to eq({name: {'subname1' => 'hello', 'subname2' => 'value', 'subname3' => 'world'}}) }
+      specify { expect(field.compose(double(value: [
         double(subvalue1: 'hello1', subvalue2: 'value1', subname3: 'world1'),
         double(subvalue1: 'hello2', subvalue2: 'value2', subname3: 'world2')
-      ])).should == {name: [
+      ]))).to eq({name: [
         {'subname1' => 'hello1', 'subname2' => 'value1', 'subname3' => 'world1'},
         {'subname1' => 'hello2', 'subname2' => 'value2', 'subname3' => 'world2'}
-      ]} }
+      ]}) }
     end
 
     context do
@@ -37,7 +37,7 @@ describe Chewy::Fields::Base do
         field.nested(described_class.new(:untouched))
       end
 
-      specify { field.compose(double(name: 'Alex')).should == {name: 'Alex'} }
+      specify { expect(field.compose(double(name: 'Alex'))).to eq({name: 'Alex'}) }
     end
 
     context do
@@ -49,7 +49,7 @@ describe Chewy::Fields::Base do
         field.nested(described_class.new(:key2, value: ->(h){ h[:key2] }))
       end
 
-      specify{ field.compose(object).should == { name: { 'key1' => 'value1', 'key2' => 'value2' } } }
+      specify{ expect(field.compose(object)).to eq({ name: { 'key1' => 'value1', 'key2' => 'value2' } }) }
     end
   end
 
@@ -69,21 +69,21 @@ describe Chewy::Fields::Base do
       fields2.each { |m| fields1[0].nested(m) }
     end
 
-    specify { field.mappings_hash.should == {name: {type: :object, properties: {
+    specify { expect(field.mappings_hash).to eq({name: {type: :object, properties: {
       name1: {type: 'string1', fields: {
         name3: {type: 'string3'}, name4: {type: 'string4'}
       }}, name2: {type: 'string2'}
-    }}} }
+    }}}) }
 
     context do
       let(:field) { described_class.new(:name, type: :string) }
       let(:fields1) { 2.times.map { |i| described_class.new("name#{i+1}") } }
 
-      specify { field.mappings_hash.should == {name: {type: :string, fields: {
+      specify { expect(field.mappings_hash).to eq({name: {type: :string, fields: {
         name1: {type: 'object', properties: {
           name3: {type: 'string3'}, name4: {type: 'string4'}
         }}, name2: {type: 'string'}
-      }}} }
+      }}}) }
     end
   end
 
@@ -105,7 +105,7 @@ describe Chewy::Fields::Base do
       end
 
       specify do
-        EventsIndex::Event.mappings_hash.should == { event: {
+        expect(EventsIndex::Event.mappings_hash).to eq({ event: {
           properties: {
             id: { type: 'string' },
             category: {
@@ -116,99 +116,99 @@ describe Chewy::Fields::Base do
                   type: 'object',
                   properties: {
                     id: { type: 'string' },
-                    name: { type: 'string' } } } } } } } }
+                    name: { type: 'string' } } } } } } } })
       end
 
       specify do
-        EventsIndex::Event.root_object.compose(
+        expect(EventsIndex::Event.root_object.compose(
           id: 1, category: { id: 2, licenses: { id: 3, name: 'Name' } }
-        ).should == {
+        )).to eq({
           event: { 'id' => 1, 'category' => { 'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name'}}}
-        }
+        })
       end
 
       specify do
-        EventsIndex::Event.root_object.compose(id: 1, category: [
+        expect(EventsIndex::Event.root_object.compose(id: 1, category: [
           { id: 2, 'licenses' => { id: 3, name: 'Name1' } },
           { id: 4, licenses: nil}
-        ]).should == {
+        ])).to eq({
           event: { 'id' => 1, 'category' => [
             { 'id' => 2, 'licenses' => { 'id' => 3, 'name' => 'Name1' } },
             {'id' => 4, 'licenses' => nil }
           ] }
-        }
+        })
       end
 
       specify do
-        EventsIndex::Event.root_object.compose('id' => 1, category: { id: 2, licenses: [
+        expect(EventsIndex::Event.root_object.compose('id' => 1, category: { id: 2, licenses: [
           { id: 3, name: 'Name1' }, { id: 4, name: 'Name2' }
-        ] }).should == {
+        ] })).to eq({
           event: { 'id' => 1, 'category' => { 'id' => 2, 'licenses' => [
             {'id' => 3, 'name' => 'Name1'}, {'id' => 4, 'name' => 'Name2'}
           ] } }
-        }
+        })
       end
 
       specify do
-        EventsIndex::Event.root_object.compose(id: 1, category: [
+        expect(EventsIndex::Event.root_object.compose(id: 1, category: [
           { id: 2, licenses: [
             { id: 3, 'name' => 'Name1' }, { id: 4, name: 'Name2' }
           ] },
           { id: 5, licenses: [] }
-        ]).should == {
+        ])).to eq({
           event: { 'id' => 1, 'category' => [
             { 'id' => 2, 'licenses' => [
               { 'id' => 3, 'name' => 'Name1' }, { 'id' => 4, 'name' => 'Name2' }
             ] },
             {'id' => 5, 'licenses' => [] }
           ] }
-        }
+        })
       end
 
       specify do
-        EventsIndex::Event.root_object.compose(
+        expect(EventsIndex::Event.root_object.compose(
           double(id: 1, category: double(id: 2, licenses: double(id: 3, name: 'Name')))
-        ).should == {
+        )).to eq({
           event: { 'id' => 1, 'category' => { 'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name'}}}
-        }
+        })
       end
 
       specify do
-        EventsIndex::Event.root_object.compose(double(id: 1, category: [
+        expect(EventsIndex::Event.root_object.compose(double(id: 1, category: [
           double(id: 2, licenses: double(id: 3, name: 'Name1')),
           double(id: 4, licenses: nil)
-        ])).should == {
+        ]))).to eq({
           event: { 'id' => 1, 'category' => [
             { 'id' => 2, 'licenses' => { 'id' => 3, 'name' => 'Name1' } },
             {'id' => 4, 'licenses' => nil }
           ] }
-        }
+        })
       end
 
       specify do
-        EventsIndex::Event.root_object.compose(double(id: 1, category: double(id: 2, licenses: [
+        expect(EventsIndex::Event.root_object.compose(double(id: 1, category: double(id: 2, licenses: [
           double(id: 3, name: 'Name1'), double(id: 4, name: 'Name2')
-        ]))).should == {
+        ])))).to eq({
           event: { 'id' => 1, 'category' => { 'id' => 2, 'licenses' => [
             {'id' => 3, 'name' => 'Name1'}, {'id' => 4, 'name' => 'Name2'}
           ] } }
-        }
+        })
       end
 
       specify do
-        EventsIndex::Event.root_object.compose(double(id: 1, category: [
+        expect(EventsIndex::Event.root_object.compose(double(id: 1, category: [
           double(id: 2, licenses: [
             double(id: 3, name: 'Name1'), double(id: 4, name: 'Name2')
           ]),
           double(id: 5, licenses: [])
-        ])).should == {
+        ]))).to eq({
           event: { 'id' => 1, 'category' => [
             { 'id' => 2, 'licenses' => [
               { 'id' => 3, 'name' => 'Name1' }, { 'id' => 4, 'name' => 'Name2' }
             ] },
             {'id' => 5, 'licenses' => [] }
           ] }
-        }
+        })
       end
     end
 
@@ -229,11 +229,11 @@ describe Chewy::Fields::Base do
       end
 
       specify do
-        EventsIndex::Event.root_object.compose(
+        expect(EventsIndex::Event.root_object.compose(
           double(id: 1, categories: double(id: 2, license: double(id: 3, name: 'Name')))
-        ).should == {
+        )).to eq({
           event: { 'id' => 1, 'category' => { 'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name'}}}
-        }
+        })
       end
     end
 
@@ -251,7 +251,7 @@ describe Chewy::Fields::Base do
       end
 
       specify do
-        EventsIndex::Event.mappings_hash.should == { event: {
+        expect(EventsIndex::Event.mappings_hash).to eq({ event: {
           properties: {
             id: { type: 'string' },
             name: {
@@ -262,28 +262,28 @@ describe Chewy::Fields::Base do
             },
             category: { type: 'object' }
           }
-        } }
+        } })
       end
 
       specify do
-        EventsIndex::Event.root_object.compose(
+        expect(EventsIndex::Event.root_object.compose(
           double(id: 1, name: 'Jonny', category: double(id: 2, as_json: {name: 'Borogoves'}))
-        ).should == {
+        )).to eq({
           event: {
             'id' => 1,
             'name' => 'Jonny',
             'category' => { 'name' => 'Borogoves' }
           }
-        }
+        })
       end
 
       specify do
-        EventsIndex::Event.root_object.compose(
+        expect(EventsIndex::Event.root_object.compose(
           double(id: 1, name: 'Jonny', category: [
             double(id: 2, as_json: { name: 'Borogoves1' }),
             double(id: 3, as_json: { name: 'Borogoves2' })
           ])
-        ).should == {
+        )).to eq({
           event: {
             'id' => 1,
             'name' => 'Jonny',
@@ -292,11 +292,11 @@ describe Chewy::Fields::Base do
               { 'name' => 'Borogoves2' }
             ]
           }
-        }
+        })
       end
     end
 
-    context 'objects and scopes' do
+    context 'objects and scopes', :orm do
       before do
         stub_model(:city) do
           belongs_to :country
@@ -318,13 +318,13 @@ describe Chewy::Fields::Base do
       end
 
       specify do
-        CountriesIndex::Country.root_object.compose(
-          Country.create!(cities: [City.create!(name: 'City1'), City.create!(name: 'City2')])
-        ).should == {
+        expect(CountriesIndex::Country.root_object.compose(
+          Country.create!(id: 1, cities: [City.create!(id: 1, name: 'City1'), City.create!(id: 2, name: 'City2')])
+        )).to eq({
           country: { 'id' => 1, 'cities' => [
             { 'id' => 1, 'name' => 'City1' }, { 'id' => 2, 'name' => 'City2' }
           ] }
-        }
+        })
       end
 
       context 'nested object' do
@@ -341,11 +341,11 @@ describe Chewy::Fields::Base do
         end
 
         specify do
-          CitiesIndex::City.root_object.compose(
-            City.create!(country: Country.create!(name: 'Country'))
-          ).should == {
+          expect(CitiesIndex::City.root_object.compose(
+            City.create!(id: 1, country: Country.create!(id: 1, name: 'Country'))
+          )).to eq({
             city: { 'id' => 1, 'country' => { 'id' => 1, 'name' => 'Country' } }
-          }
+          })
         end
       end
     end