rails_admin 0.1.1 → 0.1.2

data/spec/unit/adapters/mongoid_spec.rb

@@ -68,151 +68,151 @@ describe 'RailsAdmin::Adapters::Mongoid', :mongoid => true do
     end
 
     it 'lists associations' do
-      @post.associations.map{|a| a[:name]}.should =~ [:mongo_blog, :mongo_categories, :mongo_comments, :mongo_note]
+      expect(@post.associations.map{|a| a[:name]}).to match_array [:mongo_blog, :mongo_categories, :mongo_comments, :mongo_note]
     end
 
     it 'reads correct and know types in [:belongs_to, :has_and_belongs_to_many, :has_many, :has_one]' do
-      (@post.associations + @blog.associations + @user.associations).map{|a|a[:type].to_s}.uniq.should =~ ['belongs_to', 'has_and_belongs_to_many', 'has_many', 'has_one']
+      expect((@post.associations + @blog.associations + @user.associations).map{|a|a[:type].to_s}.uniq).to match_array ['belongs_to', 'has_and_belongs_to_many', 'has_many', 'has_one']
     end
 
     it "has correct parameter of belongs_to association" do
       param = @post.associations.find{|a| a[:name] == :mongo_blog}
-      param.reject{|k, v| [:primary_key_proc, :model_proc].include? k }.should == {
-        :name=>:mongo_blog,
-        :pretty_name=>"Mongo blog",
-        :type=>:belongs_to,
-        :foreign_key=>:mongo_blog_id,
-        :foreign_type=>nil,
-        :foreign_inverse_of=>nil,
-        :as=>nil,
-        :polymorphic=>false,
-        :inverse_of=>nil,
-        :read_only=>nil,
-        :nested_form=>nil
-      }
-      param[:primary_key_proc].call.should == :_id
-      param[:model_proc].call.should == MongoBlog
+      expect(param.reject{|k, v| [:primary_key_proc, :model_proc].include? k }).to eq({
+        :name => :mongo_blog,
+        :pretty_name => "Mongo blog",
+        :type => :belongs_to,
+        :foreign_key => :mongo_blog_id,
+        :foreign_type => nil,
+        :foreign_inverse_of => nil,
+        :as => nil,
+        :polymorphic => false,
+        :inverse_of => nil,
+        :read_only => nil,
+        :nested_form => nil
+      })
+      expect(param[:primary_key_proc].call).to eq(:_id)
+      expect(param[:model_proc].call).to eq(MongoBlog)
     end
 
     it "has correct parameter of has_many association" do
       param = @blog.associations.find{|a| a[:name] == :mongo_posts}
-      param.reject{|k, v| [:primary_key_proc, :model_proc].include? k }.should == {
-        :name=>:mongo_posts,
-        :pretty_name=>"Mongo posts",
-        :type=>:has_many,
-        :foreign_key=>:mongo_blog_id,
-        :foreign_type=>nil,
-        :foreign_inverse_of=>nil,
-        :as=>nil,
-        :polymorphic=>false,
-        :inverse_of=>nil,
-        :read_only=>nil,
-        :nested_form=>nil
-      }
-      param[:primary_key_proc].call.should == :_id
-      param[:model_proc].call.should == MongoPost
-      @post.properties.find{|f| f[:name] == :mongo_blog_id}[:type].should == :bson_object_id
+      expect(param.reject{|k, v| [:primary_key_proc, :model_proc].include? k }).to eq({
+        :name => :mongo_posts,
+        :pretty_name => "Mongo posts",
+        :type => :has_many,
+        :foreign_key => :mongo_blog_id,
+        :foreign_type => nil,
+        :foreign_inverse_of => nil,
+        :as => nil,
+        :polymorphic => false,
+        :inverse_of => nil,
+        :read_only => nil,
+        :nested_form => nil
+      })
+      expect(param[:primary_key_proc].call).to eq(:_id)
+      expect(param[:model_proc].call).to eq(MongoPost)
+      expect(@post.properties.find{|f| f[:name] == :mongo_blog_id}[:type]).to eq(:bson_object_id)
     end
 
     it "should not confuse foreign_key column which belongs to associated model" do
-      @blog.properties.find{|f| f[:name] == :mongo_blog_id}[:type].should == :string
+      expect(@blog.properties.find{|f| f[:name] == :mongo_blog_id}[:type]).to eq(:string)
     end
 
     it "has correct parameter of has_and_belongs_to_many association" do
       param = @post.associations.find{|a| a[:name] == :mongo_categories}
-      param.reject{|k, v| [:primary_key_proc, :model_proc].include? k }.should == {
-        :name=>:mongo_categories,
-        :pretty_name=>"Mongo categories",
-        :type=>:has_and_belongs_to_many,
-        :foreign_key=>:mongo_category_ids,
-        :foreign_type=>nil,
-        :foreign_inverse_of=>nil,
-        :as=>nil,
-        :polymorphic=>false,
-        :inverse_of=>nil,
-        :read_only=>nil,
-        :nested_form=>nil
-      }
-      param[:primary_key_proc].call.should == :_id
-      param[:model_proc].call.should == MongoCategory
+      expect(param.reject{|k, v| [:primary_key_proc, :model_proc].include? k }).to eq({
+        :name => :mongo_categories,
+        :pretty_name => "Mongo categories",
+        :type => :has_and_belongs_to_many,
+        :foreign_key => :mongo_category_ids,
+        :foreign_type => nil,
+        :foreign_inverse_of => nil,
+        :as => nil,
+        :polymorphic => false,
+        :inverse_of => nil,
+        :read_only => nil,
+        :nested_form => nil
+      })
+      expect(param[:primary_key_proc].call).to eq(:_id)
+      expect(param[:model_proc].call).to eq(MongoCategory)
     end
 
     it "has correct parameter of polymorphic belongs_to association" do
       RailsAdmin::Config.stub!(:models_pool).and_return(["MongoBlog", "MongoPost", "MongoCategory", "MongoUser", "MongoProfile", "MongoComment"])
       param = @comment.associations.find{|a| a[:name] == :commentable}
-      param.reject{|k, v| [:primary_key_proc, :model_proc].include? k }.should == {
-        :name=>:commentable,
-        :pretty_name=>"Commentable",
-        :type=>:belongs_to,
-        :foreign_key=>:commentable_id,
-        :foreign_type=>:commentable_type,
-        :foreign_inverse_of=>(Mongoid::VERSION >= '3.0.0' ? :commentable_field : nil),
-        :as=>nil,
-        :polymorphic=>true,
-        :inverse_of=>nil,
-        :read_only=>nil,
-        :nested_form=>nil
-      }
-      param[:primary_key_proc].call.should == :_id
-      param[:model_proc].call.should == [MongoBlog, MongoPost]
+      expect(param.reject{|k, v| [:primary_key_proc, :model_proc].include? k }).to eq({
+        :name => :commentable,
+        :pretty_name => "Commentable",
+        :type => :belongs_to,
+        :foreign_key => :commentable_id,
+        :foreign_type => :commentable_type,
+        :foreign_inverse_of => (Mongoid::VERSION >= '3.0.0' ? :commentable_field : nil),
+        :as => nil,
+        :polymorphic => true,
+        :inverse_of => nil,
+        :read_only => nil,
+        :nested_form => nil
+      })
+      expect(param[:primary_key_proc].call).to eq(:_id)
+      expect(param[:model_proc].call).to eq([MongoBlog, MongoPost])
     end
 
     it "has correct parameter of polymorphic inverse has_many association" do
       RailsAdmin::Config.stub!(:models_pool).and_return(["MongoBlog", "MongoPost", "MongoCategory", "MongoUser", "MongoProfile", "MongoComment"])
       param = @blog.associations.find{|a| a[:name] == :mongo_comments}
-      param.reject{|k, v| [:primary_key_proc, :model_proc].include? k }.should == {
-        :name=>:mongo_comments,
-        :pretty_name=>"Mongo comments",
-        :type=>:has_many,
-        :foreign_key=>:commentable_id,
-        :foreign_type=>nil,
-        :foreign_inverse_of=>nil,
-        :as=>:commentable,
-        :polymorphic=>false,
-        :inverse_of=>nil,
-        :read_only=>nil,
-        :nested_form=>nil
-      }
-      param[:primary_key_proc].call.should == :_id
-      param[:model_proc].call.should == MongoComment
+      expect(param.reject{|k, v| [:primary_key_proc, :model_proc].include? k }).to eq({
+        :name => :mongo_comments,
+        :pretty_name => "Mongo comments",
+        :type => :has_many,
+        :foreign_key => :commentable_id,
+        :foreign_type => nil,
+        :foreign_inverse_of => nil,
+        :as => :commentable,
+        :polymorphic => false,
+        :inverse_of => nil,
+        :read_only => nil,
+        :nested_form => nil
+      })
+      expect(param[:primary_key_proc].call).to eq(:_id)
+      expect(param[:model_proc].call).to eq(MongoComment)
     end
 
     it "has correct parameter of embeds_one association" do
       param = @post.associations.find{|a| a[:name] == :mongo_note}
-      param.reject{|k, v| [:primary_key_proc, :model_proc].include? k }.should == {
-        :name=>:mongo_note,
-        :pretty_name=>"Mongo note",
-        :type=>:has_one,
-        :foreign_key=>nil,
-        :foreign_type=>nil,
-        :foreign_inverse_of=>nil,
-        :as=>nil,
-        :polymorphic=>false,
-        :inverse_of=>nil,
-        :read_only=>nil,
-        :nested_form=>{:allow_destroy=>false, :update_only=>false}
-      }
-      param[:primary_key_proc].call.should == :_id
-      param[:model_proc].call.should == MongoNote
+      expect(param.reject{|k, v| [:primary_key_proc, :model_proc].include? k }).to eq({
+        :name => :mongo_note,
+        :pretty_name => "Mongo note",
+        :type => :has_one,
+        :foreign_key => nil,
+        :foreign_type => nil,
+        :foreign_inverse_of => nil,
+        :as => nil,
+        :polymorphic => false,
+        :inverse_of => nil,
+        :read_only => nil,
+        :nested_form => {:allow_destroy => false, :update_only => false}
+      })
+      expect(param[:primary_key_proc].call).to eq(:_id)
+      expect(param[:model_proc].call).to eq(MongoNote)
     end
 
     it "has correct parameter of embeds_many association" do
       param = @user.associations.find{|a| a[:name] == :mongo_notes}
-      param.reject{|k, v| [:primary_key_proc, :model_proc].include? k }.should == {
-        :name=>:mongo_notes,
-        :pretty_name=>"Mongo notes",
-        :type=>:has_many,
-        :foreign_key=>nil,
-        :foreign_type=>nil,
-        :foreign_inverse_of=>nil,
-        :as=>nil,
-        :polymorphic=>false,
-        :inverse_of=>nil,
-        :read_only=>nil,
-        :nested_form=>{:allow_destroy=>false, :update_only=>false}
-      }
-      param[:primary_key_proc].call.should == :_id
-      param[:model_proc].call.should == MongoNote
+      expect(param.reject{|k, v| [:primary_key_proc, :model_proc].include? k }).to eq({
+        :name => :mongo_notes,
+        :pretty_name => "Mongo notes",
+        :type => :has_many,
+        :foreign_key => nil,
+        :foreign_type => nil,
+        :foreign_inverse_of => nil,
+        :as => nil,
+        :polymorphic => false,
+        :inverse_of => nil,
+        :read_only => nil,
+        :nested_form => {:allow_destroy => false, :update_only => false}
+      })
+      expect(param[:primary_key_proc].call).to eq(:_id)
+      expect(param[:model_proc].call).to eq(MongoNote)
     end
 
     it "should raise error when embeds_* is used without accepts_nested_attributes_for" do
@@ -232,10 +232,10 @@ describe 'RailsAdmin::Adapters::Mongoid', :mongoid => true do
         embedded_in :mongo_embeds_many
       end
 
-      lambda{ RailsAdmin::AbstractModel.new(MongoEmbedsOne).associations }.should raise_error(RuntimeError,
+      expect(lambda{ RailsAdmin::AbstractModel.new(MongoEmbedsOne).associations }).to raise_error(RuntimeError,
         "Embbeded association without accepts_nested_attributes_for can't be handled by RailsAdmin,\nbecause embedded model doesn't have top-level access.\nPlease add `accepts_nested_attributes_for :mongo_embedded' line to `MongoEmbedsOne' model.\n"
       )
-      lambda{ RailsAdmin::AbstractModel.new(MongoEmbedsMany).associations }.should raise_error(RuntimeError,
+      expect(lambda{ RailsAdmin::AbstractModel.new(MongoEmbedsMany).associations }).to raise_error(RuntimeError,
         "Embbeded association without accepts_nested_attributes_for can't be handled by RailsAdmin,\nbecause embedded model doesn't have top-level access.\nPlease add `accepts_nested_attributes_for :mongo_embeddeds' line to `MongoEmbedsMany' model.\n"
       )
     end
@@ -254,7 +254,7 @@ describe 'RailsAdmin::Adapters::Mongoid', :mongoid => true do
 
       class MongoEmbedsChild < MongoEmbedsParent; end
 
-      lambda{ RailsAdmin::AbstractModel.new(MongoEmbedsChild).associations }.should_not raise_error
+      expect(lambda{ RailsAdmin::AbstractModel.new(MongoEmbedsChild).associations }).not_to raise_error
     end
   end
 
@@ -264,11 +264,11 @@ describe 'RailsAdmin::Adapters::Mongoid', :mongoid => true do
     end
 
     it "maps Mongoid column types to RA types" do
-      @abstract_model.properties.select{|p| %w(_id _type array_field big_decimal_field
+      expect(@abstract_model.properties.select{|p| %w(_id _type array_field big_decimal_field
         boolean_field bson_object_id_field date_field datetime_field default_field float_field
         hash_field integer_field name object_field range_field short_text string_field subject
         symbol_field text_field time_field title).
-        include? p[:name].to_s}.should =~ [
+        include? p[:name].to_s}).to match_array [
         { :name => :_id,
           :pretty_name => "Id",
           :nullable? => true,
@@ -404,7 +404,7 @@ describe 'RailsAdmin::Adapters::Mongoid', :mongoid => true do
         field :text, :type => String
         validates :text, :length => {:maximum => 50}
       end
-      RailsAdmin::AbstractModel.new('LengthValiated').send(:length_validation_lookup, :text).should == 50
+      expect(RailsAdmin::AbstractModel.new('LengthValiated').send(:length_validation_lookup, :text)).to eq(50)
     end
 
     it "should not cause problem with custom validators" do
@@ -416,7 +416,7 @@ describe 'RailsAdmin::Adapters::Mongoid', :mongoid => true do
         field :text, :type => String
         validates_with MyCustomValidator
       end
-      lambda{ RailsAdmin::AbstractModel.new('CustomValiated').send(:length_validation_lookup, :text) }.should_not raise_error
+      expect(lambda{ RailsAdmin::AbstractModel.new('CustomValiated').send(:length_validation_lookup, :text) }).not_to raise_error
     end
   end
 
@@ -427,73 +427,73 @@ describe 'RailsAdmin::Adapters::Mongoid', :mongoid => true do
     end
 
     it "#new returns instance of AbstractObject" do
-      @abstract_model.new.object.should be_instance_of(Player)
+      expect(@abstract_model.new.object).to be_instance_of(Player)
     end
 
     it "#get returns instance of AbstractObject" do
-      @abstract_model.get(@players.first.id.to_s).object.should == @players.first
+      expect(@abstract_model.get(@players.first.id.to_s).object).to eq(@players.first)
     end
 
     it "#get returns nil when id does not exist" do
-      @abstract_model.get('4f4f0824dcf2315093000000').should be_nil
+      expect(@abstract_model.get('4f4f0824dcf2315093000000')).to be_nil
     end
 
     it "#first returns a player" do
-      @players.should include @abstract_model.first
+      expect(@players).to include @abstract_model.first
     end
 
     it "#count returns count of items" do
-      @abstract_model.count.should == @players.count
+      expect(@abstract_model.count).to eq(@players.count)
     end
 
     it "#destroy destroys multiple items" do
       @abstract_model.destroy(@players[0..1])
-      Player.all.should == @players[2..2]
+      expect(Player.all).to eq(@players[2..2])
     end
 
     it "#where returns filtered results" do
-      @abstract_model.where(:name => @players.first.name).to_a.should == [@players.first]
+      expect(@abstract_model.where(:name => @players.first.name).to_a).to eq([@players.first])
     end
 
     describe "#all" do
       it "works without options" do
-        @abstract_model.all.to_a.should =~ @players
+        expect(@abstract_model.all.to_a).to match_array @players
       end
 
       it "supports eager loading" do
-        @abstract_model.all(:include => :team).inclusions.map{|i| i.class_name}.should == ["Team"]
+        expect(@abstract_model.all(:include => :team).inclusions.map{|i| i.class_name}).to eq(["Team"])
       end
 
       it "supports limiting" do
-        @abstract_model.all(:limit => 2).to_a.should have(2).items
+        expect(@abstract_model.all(:limit => 2).to_a).to have(2).items
       end
 
       it "supports retrieval by bulk_ids" do
-        @abstract_model.all(:bulk_ids => @players[0..1].map{|player| player.id.to_s }).to_a.should =~ @players[0..1]
+        expect(@abstract_model.all(:bulk_ids => @players[0..1].map{|player| player.id.to_s }).to_a).to match_array @players[0..1]
       end
 
       it "supports pagination" do
-        @abstract_model.all(:sort => 'players._id', :page => 2, :per => 1).to_a.should == @players[1..1]
+        expect(@abstract_model.all(:sort => 'players._id', :page => 2, :per => 1).to_a).to eq(@players[1..1])
         # To prevent RSpec matcher to call Mongoid::Criteria#== method,
         # (we want to test equality of query result, not of Mongoid criteria)
         # to_a is added to invoke Mongoid query
       end
 
       it "supports ordering" do
-        @abstract_model.all(:sort => 'players._id', :sort_reverse => true).to_a.should == @players.sort
-        @abstract_model.all(:sort => 'players._id', :sort_reverse => false).to_a.should == @players.sort.reverse
+        expect(@abstract_model.all(:sort => 'players._id', :sort_reverse => true).to_a).to eq(@players.sort)
+        expect(@abstract_model.all(:sort => 'players._id', :sort_reverse => false).to_a).to eq(@players.sort.reverse)
       end
 
       it "supports querying" do
-        @abstract_model.all(:query => @players[1].name).should == @players[1..1]
+        expect(@abstract_model.all(:query => @players[1].name)).to eq(@players[1..1])
       end
 
       it "supports filtering" do
-        @abstract_model.all(:filters => {"name" => {"0000" => {:o=>"is", :v=>@players[1].name}}}).should == @players[1..1]
+        expect(@abstract_model.all(:filters => {"name" => {"0000" => {:o => "is", :v => @players[1].name}}})).to eq(@players[1..1])
       end
 
       it "ignores non-existent field name on filtering" do
-        lambda{ @abstract_model.all(:filters => {"dummy" => {"0000" => {:o=>"is", :v=>@players[1].name}}}) }.should_not raise_error
+        expect(lambda{ @abstract_model.all(:filters => {"dummy" => {"0000" => {:o => "is", :v => @players[1].name}}}) }).not_to raise_error
       end
     end
   end
@@ -513,11 +513,11 @@ describe 'RailsAdmin::Adapters::Mongoid', :mongoid => true do
       end
 
       it "supports querying" do
-        @abstract_model.all(:query => 'foobar').to_a.should == @players[1..1]
+        expect(@abstract_model.all(:query => 'foobar').to_a).to eq(@players[1..1])
       end
 
       it "supports filtering" do
-        @abstract_model.all(:filters => {"team" => {"0000" => {:o=>"is", :v=>'foobar'}}}).to_a.should == @players[1..1]
+        expect(@abstract_model.all(:filters => {"team" => {"0000" => {:o => "is", :v => 'foobar'}}}).to_a).to eq(@players[1..1])
       end
     end
 
@@ -537,11 +537,11 @@ describe 'RailsAdmin::Adapters::Mongoid', :mongoid => true do
       end
 
       it "supports querying" do
-        @abstract_model.all(:query => 'foobar').to_a.should == @teams[1..1]
+        expect(@abstract_model.all(:query => 'foobar').to_a).to eq(@teams[1..1])
       end
 
       it "supports filtering" do
-        @abstract_model.all(:filters => {"players" => {"0000" => {:o=>"is", :v=>'foobar'}}}).to_a.should == @teams[1..1]
+        expect(@abstract_model.all(:filters => {"players" => {"0000" => {:o => "is", :v => 'foobar'}}}).to_a).to eq(@teams[1..1])
       end
     end
 
@@ -561,11 +561,11 @@ describe 'RailsAdmin::Adapters::Mongoid', :mongoid => true do
       end
 
       it "supports querying" do
-        @abstract_model.all(:query => 'foobar').to_a.should == @teams[1..1]
+        expect(@abstract_model.all(:query => 'foobar').to_a).to eq(@teams[1..1])
       end
 
       it "supports filtering" do
-        @abstract_model.all(:filters => {"fans" => {"0000" => {:o=>"is", :v=>'foobar'}}}).to_a.should == @teams[1..1]
+        expect(@abstract_model.all(:filters => {"fans" => {"0000" => {:o => "is", :v => 'foobar'}}}).to_a).to eq(@teams[1..1])
       end
     end
 
@@ -584,11 +584,11 @@ describe 'RailsAdmin::Adapters::Mongoid', :mongoid => true do
       end
 
       it "supports querying" do
-        @abstract_model.all(:query => 'bar').to_a.should == @field_tests[1..1]
+        expect(@abstract_model.all(:query => 'bar').to_a).to eq(@field_tests[1..1])
       end
 
       it "supports filtering" do
-        @abstract_model.all(:filters => {"embeds" => {"0000" => {:o=>"is", :v=>'bar'}}}).to_a.should == @field_tests[1..1]
+        expect(@abstract_model.all(:filters => {"embeds" => {"0000" => {:o => "is", :v => 'bar'}}}).to_a).to eq(@field_tests[1..1])
       end
     end
   end
@@ -596,12 +596,12 @@ describe 'RailsAdmin::Adapters::Mongoid', :mongoid => true do
   describe "#query_conditions" do
     before do
       @abstract_model = RailsAdmin::AbstractModel.new('Player')
-      @players = [{}, {:name=>'Many foos'}, {:position=>'foo shortage'}].
+      @players = [{}, {:name => 'Many foos'}, {:position => 'foo shortage'}].
         map{|h| FactoryGirl.create :player, h}
     end
 
     it "makes conrrect query" do
-      @abstract_model.all(:query => "foo").to_a.should =~ @players[1..2]
+      expect(@abstract_model.all(:query => "foo").to_a).to match_array @players[1..2]
     end
   end
 
@@ -609,15 +609,15 @@ describe 'RailsAdmin::Adapters::Mongoid', :mongoid => true do
     before do
       @abstract_model = RailsAdmin::AbstractModel.new('Player')
       @team = FactoryGirl.create :team, :name => 'king of bar'
-      @players = [{}, {:team=>@team}, {:name=>'Many foos', :team=>@team}, {:name=>'Great foo'}].
+      @players = [{}, {:team => @team}, {:name => 'Many foos', :team => @team}, {:name => 'Great foo'}].
         map{|h| FactoryGirl.create :player, h}
     end
 
     it "makes conrrect query" do
-      @abstract_model.all(:filters =>
-        {"name" => {"0000" => {:o=>"like", :v=>"foo"}},
-         "team" => {"0001" => {:o=>"like", :v=>"bar"}}}
-      ).should == [@players[2]]
+      expect(@abstract_model.all(:filters  =>
+        {"name" => {"0000" => {:o => "like", :v => "foo"}},
+         "team" => {"0001" => {:o => "like", :v => "bar"}}}
+      )).to eq([@players[2]])
     end
   end
 
@@ -628,87 +628,87 @@ describe 'RailsAdmin::Adapters::Mongoid', :mongoid => true do
 
     it "ignores '_discard' operator or value" do
       [["_discard", ""], ["", "_discard"]].each do |value, operator|
-        @abstract_model.send(:build_statement, :name, :string, value, operator).should be_nil
+        expect(@abstract_model.send(:build_statement, :name, :string, value, operator)).to be_nil
       end
     end
 
     it "supports '_blank' operator" do
       [["_blank", ""], ["", "_blank"]].each do |value, operator|
-        @abstract_model.send(:build_statement, :name, :string, value, operator).should == {:name=>{"$in"=>[nil, ""]}}
+        expect(@abstract_model.send(:build_statement, :name, :string, value, operator)).to eq({:name => {"$in" => [nil, ""]}})
       end
     end
 
     it "supports '_present' operator" do
       [["_present", ""], ["", "_present"]].each do |value, operator|
-        @abstract_model.send(:build_statement, :name, :string, value, operator).should == {:name=>{"$nin"=>[nil, ""]}}
+        expect(@abstract_model.send(:build_statement, :name, :string, value, operator)).to eq({:name => {"$nin" => [nil, ""]}})
       end
     end
 
     it "supports '_null' operator" do
       [["_null", ""], ["", "_null"]].each do |value, operator|
-        @abstract_model.send(:build_statement, :name, :string, value, operator).should == {:name=>nil}
+        expect(@abstract_model.send(:build_statement, :name, :string, value, operator)).to eq({:name => nil})
       end
     end
 
     it "supports '_not_null' operator" do
       [["_not_null", ""], ["", "_not_null"]].each do |value, operator|
-        @abstract_model.send(:build_statement, :name, :string, value, operator).should == {:name=>{"$ne"=>nil}}
+        expect(@abstract_model.send(:build_statement, :name, :string, value, operator)).to eq({:name => {"$ne" => nil}})
       end
     end
 
     it "supports '_empty' operator" do
       [["_empty", ""], ["", "_empty"]].each do |value, operator|
-        @abstract_model.send(:build_statement, :name, :string, value, operator).should == {:name=>""}
+        expect(@abstract_model.send(:build_statement, :name, :string, value, operator)).to eq({:name => ""})
       end
     end
 
     it "supports '_not_empty' operator" do
       [["_not_empty", ""], ["", "_not_empty"]].each do |value, operator|
-        @abstract_model.send(:build_statement, :name, :string, value, operator).should == {:name=>{"$ne"=>""}}
+        expect(@abstract_model.send(:build_statement, :name, :string, value, operator)).to eq({:name => {"$ne" => ""}})
       end
     end
 
     it "supports boolean type query" do
       ['false', 'f', '0'].each do |value|
-        @abstract_model.send(:build_statement, :field, :boolean, value, nil).should == {:field => false}
+        expect(@abstract_model.send(:build_statement, :field, :boolean, value, nil)).to eq({:field => false})
       end
       ['true', 't', '1'].each do |value|
-        @abstract_model.send(:build_statement, :field, :boolean, value, nil).should == {:field => true}
+        expect(@abstract_model.send(:build_statement, :field, :boolean, value, nil)).to eq({:field => true})
       end
-      @abstract_model.send(:build_statement, :field, :boolean, 'word', nil).should be_nil
+      expect(@abstract_model.send(:build_statement, :field, :boolean, 'word', nil)).to be_nil
     end
 
     it "supports integer type query" do
-      @abstract_model.send(:build_statement, :field, :integer, "1", nil).should == {:field => 1}
-      @abstract_model.send(:build_statement, :field, :integer, 'word', nil).should be_nil
+      expect(@abstract_model.send(:build_statement, :field, :integer, "1", nil)).to eq({:field => 1})
+      expect(@abstract_model.send(:build_statement, :field, :integer, 'word', nil)).to be_nil
     end
 
     it "supports string type query" do
-      @abstract_model.send(:build_statement, :field, :string, "", nil).should be_nil
-      @abstract_model.send(:build_statement, :field, :string, "foo", "was").should be_nil
-      @abstract_model.send(:build_statement, :field, :string, "foo", "default").should == {:field=>/foo/i}
-      @abstract_model.send(:build_statement, :field, :string, "foo", "like").should == {:field=>/foo/i}
-      @abstract_model.send(:build_statement, :field, :string, "foo", "starts_with").should == {:field=>/^foo/i}
-      @abstract_model.send(:build_statement, :field, :string, "foo", "ends_with").should == {:field=>/foo$/i}
-      @abstract_model.send(:build_statement, :field, :string, "foo", "is").should == {:field=>'foo'}
+      expect(@abstract_model.send(:build_statement, :field, :string, "", nil)).to be_nil
+      expect(@abstract_model.send(:build_statement, :field, :string, "foo", "was")).to be_nil
+      expect(@abstract_model.send(:build_statement, :field, :string, "foo", "default")).to eq({:field => /foo/i})
+      expect(@abstract_model.send(:build_statement, :field, :string, "foo", "like")).to eq({:field => /foo/i})
+      expect(@abstract_model.send(:build_statement, :field, :string, "foo", "starts_with")).to eq({:field => /^foo/i})
+      expect(@abstract_model.send(:build_statement, :field, :string, "foo", "ends_with")).to eq({:field => /foo$/i})
+      expect(@abstract_model.send(:build_statement, :field, :string, "foo", "is")).to eq({:field => 'foo'})
     end
 
     it 'supports date type query' do
-      @abstract_model.send(:filter_conditions, { "date_field" => { "1" => { :v => ["", "01/02/2012", "01/03/2012"], :o => 'between' } } }).should == {"$and"=>[{"date_field"=>{"$gte"=>Date.new(2012,1,2), "$lte"=>Date.new(2012,1,3)}}]}
-      @abstract_model.send(:filter_conditions, { "date_field" => { "1" => { :v => ["", "01/03/2012", ""], :o => 'between' } } } ).should == {"$and"=>[{"date_field"=>{"$gte"=>Date.new(2012,1,3)}}]}
-      @abstract_model.send(:filter_conditions, { "date_field" => { "1" => { :v => ["", "", "01/02/2012"], :o => 'between' } } } ).should == {"$and"=>[{"date_field"=>{"$lte"=>Date.new(2012,1,2)}}]}
-      @abstract_model.send(:filter_conditions, { "date_field" => { "1" => { :v => ["01/02/2012"], :o => 'default' } } } ).should == {"$and"=>[{"date_field"=>{"$gte"=>Date.new(2012,1,2), "$lte"=>Date.new(2012,1,2)}}]}
+      expect(@abstract_model.send(:filter_conditions, { "date_field" => { "1" => { :v => ["", "01/02/2012", "01/03/2012"], :o => 'between' } } })).to eq({"$and" => [{"date_field" => {"$gte" => Date.new(2012,1,2), "$lte" => Date.new(2012,1,3)}}]})
+      expect(@abstract_model.send(:filter_conditions, { "date_field" => { "1" => { :v => ["", "01/03/2012", ""], :o => 'between' } } } )).to eq({"$and" => [{"date_field" => {"$gte" => Date.new(2012,1,3)}}]})
+      expect(@abstract_model.send(:filter_conditions, { "date_field" => { "1" => { :v => ["", "", "01/02/2012"], :o => 'between' } } } )).to eq({"$and" => [{"date_field" => {"$lte" => Date.new(2012,1,2)}}]})
+      expect(@abstract_model.send(:filter_conditions, { "date_field" => { "1" => { :v => ["01/02/2012"], :o => 'default' } } } )).to eq({"$and" => [{"date_field" => {"$gte" => Date.new(2012,1,2), "$lte" => Date.new(2012,1,2)}}]})
     end
 
     it 'supports datetime type query' do
-      @abstract_model.send(:filter_conditions, { "datetime_field" => { "1" => { :v => ["", "01/02/2012", "01/03/2012"], :o => 'between' } } } ).should == {"$and"=>[{"datetime_field"=>{"$gte"=>Time.local(2012,1,2), "$lte"=>Time.local(2012,1,3).end_of_day}}]}
-      @abstract_model.send(:filter_conditions, { "datetime_field" => { "1" => { :v => ["", "01/03/2012", ""], :o => 'between' } } } ).should == {"$and"=>[{"datetime_field"=>{"$gte"=>Time.local(2012,1,3)}}]}
-      @abstract_model.send(:filter_conditions, { "datetime_field" => { "1" => { :v => ["", "", "01/02/2012"], :o => 'between' } } } ).should == {"$and"=>[{"datetime_field"=>{"$lte"=>Time.local(2012,1,2).end_of_day}}]}
-      @abstract_model.send(:filter_conditions, { "datetime_field" => { "1" => { :v => ["01/02/2012"], :o => 'default' } } } ).should == {"$and"=>[{"datetime_field"=>{"$gte"=>Time.local(2012,1,2), "$lte"=>Time.local(2012,1,2).end_of_day}}]}
+      expect(@abstract_model.send(:filter_conditions, { "datetime_field" => { "1" => { :v => ["", "01/02/2012", "01/03/2012"], :o => 'between' } } } )).to eq({"$and" => [{"datetime_field" => {"$gte" => Time.local(2012,1,2), "$lte" => Time.local(2012,1,3).end_of_day}}]})
+      expect(@abstract_model.send(:filter_conditions, { "datetime_field" => { "1" => { :v => ["", "01/03/2012", ""], :o => 'between' } } } )).to eq({"$and" => [{"datetime_field" => {"$gte" => Time.local(2012,1,3)}}]})
+      expect(@abstract_model.send(:filter_conditions, { "datetime_field" => { "1" => { :v => ["", "", "01/02/2012"], :o => 'between' } } } )).to eq({"$and" => [{"datetime_field" => {"$lte" => Time.local(2012,1,2).end_of_day}}]})
+      expect(@abstract_model.send(:filter_conditions, { "datetime_field" => { "1" => { :v => ["01/02/2012"], :o => 'default' } } } )).to eq({"$and" => [{"datetime_field" => {"$gte" => Time.local(2012,1,2), "$lte" => Time.local(2012,1,2).end_of_day}}]})
     end
 
     it "supports enum type query" do
-      @abstract_model.send(:build_statement, :field, :enum, "1", nil).should == {:field => {"$in" => ["1"]}}
+      expect(@abstract_model.send(:build_statement, :field, :enum, "1", nil)).to eq({:field => {"$in" => ["1"]}})
     end
   end
 
@@ -718,11 +718,11 @@ describe 'RailsAdmin::Adapters::Mongoid', :mongoid => true do
     end
 
     it "#scoped returns relation object" do
-      @abstract_model.scoped.should be_instance_of(Mongoid::Criteria)
+      expect(@abstract_model.scoped).to be_instance_of(Mongoid::Criteria)
     end
 
     it "#table_name works" do
-      @abstract_model.table_name.should == 'players'
+      expect(@abstract_model.table_name).to eq('players')
     end
   end
 
@@ -735,13 +735,13 @@ describe 'RailsAdmin::Adapters::Mongoid', :mongoid => true do
     it "accepts array value" do
       params = {:array_field => '[1, 3]'}
       @controller.send(:sanitize_params_for!, 'create', @abstract_model.config, params)
-      params[:array_field].should == [1, 3]
+      expect(params[:array_field]).to eq([1, 3])
     end
 
     it "accepts hash value" do
       params = {:hash_field => '{a: 1, b: 3}'}
       @controller.send(:sanitize_params_for!, 'create', @abstract_model.config, params)
-      params[:hash_field].should == {"a"=>1, "b"=>3}
+      expect(params[:hash_field]).to eq({"a" => 1, "b" => 3})
     end
   end
 end