rails_admin 0.1.1 → 0.1.2

data/spec/unit/adapters/active_record_spec.rb

@@ -50,115 +50,114 @@ describe 'RailsAdmin::Adapters::ActiveRecord', :active_record => true do
     end
 
     it 'lists associations' do
-      @post.associations.map{|a|a[:name].to_s}.should =~ ['a_r_blog', 'a_r_categories', 'a_r_comments']
+      expect(@post.associations.map{|a|a[:name].to_s}).to match_array ['a_r_blog', 'a_r_categories', 'a_r_comments']
     end
 
     it 'list associations types in supported [:belongs_to, :has_and_belongs_to_many, :has_many, :has_one]' do
-      (@post.associations + @blog.associations + @user.associations).map{|a|a[:type]}.uniq.map(&:to_s).should =~ ['belongs_to', 'has_and_belongs_to_many', 'has_many', 'has_one']
+      expect((@post.associations + @blog.associations + @user.associations).map{|a|a[:type]}.uniq.map(&:to_s)).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.select{|a| a[:name] == :a_r_blog}.first
-      param.reject{|k, v| [:primary_key_proc, :model_proc].include? k }.should == {
-        :name=>:a_r_blog,
-        :pretty_name=>"A r blog",
-        :type=>:belongs_to,
-        :foreign_key=>:a_r_blog_id,
-        :foreign_type=>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 == ARBlog
+      expect(param.reject{|k, v| [:primary_key_proc, :model_proc].include? k }).to eq({
+        :name => :a_r_blog,
+        :pretty_name => "A r blog",
+        :type => :belongs_to,
+        :foreign_key => :a_r_blog_id,
+        :foreign_type => 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(ARBlog)
     end
 
     it "has correct parameter of has_many association" do
       param = @blog.associations.select{|a| a[:name] == :a_r_posts}.first
-      param.reject{|k, v| [:primary_key_proc, :model_proc].include? k }.should == {
-        :name=>:a_r_posts,
-        :pretty_name=>"A r posts",
-        :type=>:has_many,
-        :foreign_key=>:ar_blog_id,
-        :foreign_type=>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 == ARPost
+      expect(param.reject{|k, v| [:primary_key_proc, :model_proc].include? k }).to eq({
+        :name => :a_r_posts,
+        :pretty_name => "A r posts",
+        :type => :has_many,
+        :foreign_key => :ar_blog_id,
+        :foreign_type => 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(ARPost)
     end
 
     it "has correct parameter of has_and_belongs_to_many association" do
       param = @post.associations.select{|a| a[:name] == :a_r_categories}.first
-      param.reject{|k, v| [:primary_key_proc, :model_proc].include? k }.should == {
-        :name=>:a_r_categories,
-        :pretty_name=>"A r categories",
-        :type=>:has_and_belongs_to_many,
-        :foreign_key=>:ar_post_id,
-        :foreign_type=>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 == ARCategory
+      expect(param.reject{|k, v| [:primary_key_proc, :model_proc].include? k }).to eq({
+        :name => :a_r_categories,
+        :pretty_name => "A r categories",
+        :type => :has_and_belongs_to_many,
+        :foreign_key => :ar_post_id,
+        :foreign_type => 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(ARCategory)
     end
 
     it "has correct parameter of polymorphic belongs_to association" do
       RailsAdmin::Config.stub!(:models_pool).and_return(["ARBlog", "ARPost", "ARCategory", "ARUser", "ARProfile", "ARComment"])
       param = @comment.associations.select{|a| a[:name] == :commentable}.first
-      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,
-        :as=>nil,
-        :polymorphic=>true,
-        :inverse_of=>nil,
-        :read_only=>nil,
-        :nested_form=>nil
-      }
-      # param[:primary_key_proc].call.should == 'id' Should not be called for polymorphic relations. Todo, Handle this niver
-      param[:model_proc].call.should == [ARBlog, ARPost]
+      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,
+        :as => nil,
+        :polymorphic => true,
+        :inverse_of => nil,
+        :read_only => nil,
+        :nested_form => nil
+      })
+      # Should not be called for polymorphic relations.
+      # TODO: Handle this case
+      # expect(param[:primary_key_proc].call).to eq('id')
+      expect(param[:model_proc].call).to eq([ARBlog, ARPost])
     end
 
     it "has correct parameter of polymorphic inverse has_many association" do
       param = @blog.associations.select{|a| a[:name] == :a_r_comments}.first
-      param.reject{|k, v| [:primary_key_proc, :model_proc].include? k }.should == {
-        :name=>:a_r_comments,
-        :pretty_name=>"A r comments",
-        :type=>:has_many,
-        :foreign_key=>:commentable_id,
-        :foreign_type=>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 == ARComment
+      expect(param.reject{|k, v| [:primary_key_proc, :model_proc].include? k }).to eq({
+        :name => :a_r_comments,
+        :pretty_name => "A r comments",
+        :type => :has_many,
+        :foreign_key => :commentable_id,
+        :foreign_type => 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(ARComment)
     end
   end
-  
 
   describe "#properties" do
     it "returns parameters of string-type field" do
-      RailsAdmin::AbstractModel.new('Player').properties.select{|f| f[:name] == :name}.should ==
-        [{:name => :name, :pretty_name => "Name", :type => :string, :length => 100, :nullable? => false, :serial? => false}]
+      expect(RailsAdmin::AbstractModel.new('Player').properties.select{|f| f[:name] == :name}).to eq([{:name => :name, :pretty_name => "Name", :type => :string, :length => 100, :nullable? => false, :serial? => false}])
     end
 
     it "maps serialized attribute to :serialized field type" do
-      RailsAdmin::AbstractModel.new('User').properties.find{|f| f[:name] == :roles}.should ==
-        {:name => :roles, :pretty_name => "Roles", :length => 255, :nullable? => true, :serial? => false, :type => :serialized}
+      expect(RailsAdmin::AbstractModel.new('User').properties.find{|f| f[:name] == :roles}).to eq({:name => :roles, :pretty_name => "Roles", :length => 255, :nullable? => true, :serial? => false, :type => :serialized})
     end
   end
 
@@ -169,66 +168,66 @@ describe 'RailsAdmin::Adapters::ActiveRecord', :active_record => 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).object.should == @players.first
+      expect(@abstract_model.get(@players.first.id).object).to eq(@players.first)
     end
 
     it "#get returns nil when id does not exist" do
-      @abstract_model.get('abc').should be_nil
+      expect(@abstract_model.get('abc')).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).should == [@players.first]
+      expect(@abstract_model.where(:name => @players.first.name)).to eq([@players.first])
     end
 
     describe "#all" do
       it "works without options" do
-        @abstract_model.all.should =~ @players
+        expect(@abstract_model.all).to match_array @players
       end
 
       it "supports eager loading" do
-        @abstract_model.all(:include => :team).includes_values.should == [:team]
+        expect(@abstract_model.all(:include => :team).includes_values).to eq([:team])
       end
 
       it "supports limiting" do
-        @abstract_model.all(:limit => 2).should have(2).items
+        expect(@abstract_model.all(:limit => 2)).to have(2).items
       end
 
       it "supports retrieval by bulk_ids" do
-        @abstract_model.all(:bulk_ids => @players[0..1].map(&:id)).should =~ @players[0..1]
+        expect(@abstract_model.all(:bulk_ids => @players[0..1].map(&:id))).to match_array @players[0..1]
       end
 
       it "supports pagination" do
-        @abstract_model.all(:sort => "id", :page => 2, :per => 1).should == @players[1..1]
-        @abstract_model.all(:sort => "id", :page => 1, :per => 2).should == @players[1..2].reverse
+        expect(@abstract_model.all(:sort => "id", :page => 2, :per => 1)).to eq(@players[1..1])
+        expect(@abstract_model.all(:sort => "id", :page => 1, :per => 2)).to eq(@players[1..2].reverse)
       end
 
       it "supports ordering" do
-        @abstract_model.all(:sort => "id", :sort_reverse => true).should == @players.sort
+        expect(@abstract_model.all(:sort => "id", :sort_reverse => true)).to eq(@players.sort)
       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
     end
   end
@@ -236,12 +235,12 @@ describe 'RailsAdmin::Adapters::ActiveRecord', :active_record => true do
   describe "#query_conditions" do
     before do
       @abstract_model = RailsAdmin::AbstractModel.new('Team')
-      @teams = [{}, {:name=>'somewhere foos'}, {:manager=>'foo junior'}].
+      @teams = [{}, {:name => 'somewhere foos'}, {:manager => 'foo junior'}].
         map{|h| FactoryGirl.create :team, h}
     end
 
     it "makes conrrect query" do
-      @abstract_model.all(:query => "foo").should =~ @teams[1..2]
+      expect(@abstract_model.all(:query => "foo")).to match_array @teams[1..2]
     end
   end
 
@@ -249,16 +248,16 @@ describe 'RailsAdmin::Adapters::ActiveRecord', :active_record => true do
     before do
       @abstract_model = RailsAdmin::AbstractModel.new('Team')
       @division = FactoryGirl.create :division, :name => 'bar division'
-      @teams = [{}, {:division=>@division}, {:name=>'somewhere foos', :division=>@division}, {:name=>'nowhere foos'}].
+      @teams = [{}, {:division => @division}, {:name => 'somewhere foos', :division => @division}, {:name => 'nowhere foos'}].
         map{|h| FactoryGirl.create :team, h}
     end
 
     it "makes conrrect query" do
-      @abstract_model.all(
-        :filters => {"name" => {"0000" => {:o=>"like", :v=>"foo"}},
-                     "division" => {"0001" => {:o=>"like", :v=>"bar"}}},
+      expect(@abstract_model.all(
+        :filters => {"name" => {"0000" => {:o => "like", :v => "foo"}},
+                     "division" => {"0001" => {:o => "like", :v => "bar"}}},
         :include => :division
-      ).should == [@teams[2]]
+      )).to eq([@teams[2]])
     end
   end
 
@@ -269,93 +268,93 @@ describe 'RailsAdmin::Adapters::ActiveRecord', :active_record => 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 IS NULL OR name = '')"]
+        expect(@abstract_model.send(:build_statement, :name, :string, value, operator)).to eq(["(name IS NULL OR name = '')"])
       end
     end
 
     it "supports '_present' operator" do
       [["_present", ""], ["", "_present"]].each do |value, operator|
-        @abstract_model.send(:build_statement, :name, :string, value, operator).should == ["(name IS NOT NULL AND name != '')"]
+        expect(@abstract_model.send(:build_statement, :name, :string, value, operator)).to eq(["(name IS NOT NULL AND name != '')"])
       end
     end
 
     it "supports '_null' operator" do
       [["_null", ""], ["", "_null"]].each do |value, operator|
-        @abstract_model.send(:build_statement, :name, :string, value, operator).should == ["(name IS NULL)"]
+        expect(@abstract_model.send(:build_statement, :name, :string, value, operator)).to eq(["(name IS NULL)"])
       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 IS NOT NULL)"]
+        expect(@abstract_model.send(:build_statement, :name, :string, value, operator)).to eq(["(name IS NOT NULL)"])
       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 != '')"]
+        expect(@abstract_model.send(:build_statement, :name, :string, value, operator)).to eq(["(name != '')"])
       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 IS NULL OR field = ?)", false]
+        expect(@abstract_model.send(:build_statement, :field, :boolean, value, nil)).to eq(["(field IS NULL OR 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 decimal type query" do
-      @abstract_model.send(:build_statement, :field, :decimal, "1.1", nil).should == ["(field = ?)", 1.1]
-      @abstract_model.send(:build_statement, :field, :decimal, 'word', nil).should be_nil
+      expect(@abstract_model.send(:build_statement, :field, :decimal, "1.1", nil)).to eq(["(field = ?)", 1.1])
+      expect(@abstract_model.send(:build_statement, :field, :decimal, '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 #{@like} ?)", "%foo%"]
-      @abstract_model.send(:build_statement, :field, :string, "foo", "like").should == ["(field #{@like} ?)", "%foo%"]
-      @abstract_model.send(:build_statement, :field, :string, "foo", "starts_with").should == ["(field #{@like} ?)", "foo%"]
-      @abstract_model.send(:build_statement, :field, :string, "foo", "ends_with").should == ["(field #{@like} ?)", "%foo"]
-      @abstract_model.send(:build_statement, :field, :string, "foo", "is").should == ["(field #{@like} ?)", "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 #{@like} ?)", "%foo%"])
+      expect(@abstract_model.send(:build_statement, :field, :string, "foo", "like")).to eq(["(field #{@like} ?)", "%foo%"])
+      expect(@abstract_model.send(:build_statement, :field, :string, "foo", "starts_with")).to eq(["(field #{@like} ?)", "foo%"])
+      expect(@abstract_model.send(:build_statement, :field, :string, "foo", "ends_with")).to eq(["(field #{@like} ?)", "%foo"])
+      expect(@abstract_model.send(:build_statement, :field, :string, "foo", "is")).to eq(["(field #{@like} ?)", "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 == ["((field_tests.date_field BETWEEN ? AND ?))", Date.new(2012,1,2), Date.new(2012,1,3)]
-      @abstract_model.send(:filter_conditions, { "date_field" => { "1" => { :v => ["", "01/03/2012", ""], :o => 'between' } } } ).should == ["((field_tests.date_field >= ?))", Date.new(2012,1,3)]
-      @abstract_model.send(:filter_conditions, { "date_field" => { "1" => { :v => ["", "", "01/02/2012"], :o => 'between' } } } ).should == ["((field_tests.date_field <= ?))", Date.new(2012,1,2)]
-      @abstract_model.send(:filter_conditions, { "date_field" => { "1" => { :v => ["01/02/2012"], :o => 'default' } } } ).should == ["((field_tests.date_field BETWEEN ? AND ?))", Date.new(2012,1,2), 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(["((field_tests.date_field BETWEEN ? AND ?))", Date.new(2012,1,2), Date.new(2012,1,3)])
+      expect(@abstract_model.send(:filter_conditions, { "date_field" => { "1" => { :v => ["", "01/03/2012", ""], :o => 'between' } } } )).to eq(["((field_tests.date_field >= ?))", Date.new(2012,1,3)])
+      expect(@abstract_model.send(:filter_conditions, { "date_field" => { "1" => { :v => ["", "", "01/02/2012"], :o => 'between' } } } )).to eq(["((field_tests.date_field <= ?))", Date.new(2012,1,2)])
+      expect(@abstract_model.send(:filter_conditions, { "date_field" => { "1" => { :v => ["01/02/2012"], :o => 'default' } } } )).to eq(["((field_tests.date_field BETWEEN ? AND ?))", Date.new(2012,1,2), 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 == ["((field_tests.datetime_field BETWEEN ? AND ?))", Time.local(2012,1,2), Time.local(2012,1,3).end_of_day]
-      @abstract_model.send(:filter_conditions, { "datetime_field" => { "1" => { :v => ["", "01/03/2012", ""], :o => 'between' } } } ).should == ["((field_tests.datetime_field >= ?))", Time.local(2012,1,3)]
-      @abstract_model.send(:filter_conditions, { "datetime_field" => { "1" => { :v => ["", "", "01/02/2012"], :o => 'between' } } } ).should == ["((field_tests.datetime_field <= ?))", Time.local(2012,1,2).end_of_day]
-      @abstract_model.send(:filter_conditions, { "datetime_field" => { "1" => { :v => ["01/02/2012"], :o => 'default' } } } ).should == ["((field_tests.datetime_field BETWEEN ? AND ?))", Time.local(2012,1,2), 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(["((field_tests.datetime_field BETWEEN ? AND ?))", Time.local(2012,1,2), 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(["((field_tests.datetime_field >= ?))", Time.local(2012,1,3)])
+      expect(@abstract_model.send(:filter_conditions, { "datetime_field" => { "1" => { :v => ["", "", "01/02/2012"], :o => 'between' } } } )).to eq(["((field_tests.datetime_field <= ?))", 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(["((field_tests.datetime_field BETWEEN ? AND ?))", Time.local(2012,1,2), 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
 
@@ -365,11 +364,11 @@ describe 'RailsAdmin::Adapters::ActiveRecord', :active_record => true do
     end
 
     it "#scoped returns relation object" do
-      @abstract_model.scoped.should be_instance_of(ActiveRecord::Relation)
+      expect(@abstract_model.scoped).to be_instance_of(ActiveRecord::Relation)
     end
 
     it "#table_name works" do
-      @abstract_model.table_name.should == 'players'
+      expect(@abstract_model.table_name).to eq('players')
     end
   end
 end

data/spec/unit/adapters/mongoid/abstract_object_spec.rb

@@ -9,23 +9,23 @@ describe "Mongoid::AbstractObject", :mongoid => true do
 
   describe "references_many association" do
     it "supports retrieval of ids through foo_ids" do
-      @team.player_ids.should == []
+      expect(@team.player_ids).to eq([])
       player = FactoryGirl.create :player, :team => @team
-      @team.player_ids.should == [player.id]
+      expect(@team.player_ids).to eq([player.id])
     end
 
     it "supports assignment of items through foo_ids=" do
-      @team.players.should == []
+      expect(@team.players).to eq([])
       @team.player_ids = @players.map(&:id)
       @team.reload
-      @team.players.map(&:id).should =~ @players.map(&:id)
+      expect(@team.players.map(&:id)).to match_array @players.map(&:id)
     end
 
     it "skips invalid id on assignment through foo_ids=" do
       @team.player_ids = @players.map{|item| item.id.to_s }.unshift('4f431021dcf2310db7000006')
       @team.reload
       @players.each &:reload
-      @team.players.map(&:id).should =~ @players.map(&:id)
+      expect(@team.players.map(&:id)).to match_array @players.map(&:id)
     end
   end
 end