rails_admin 0.1.1 → 0.1.2

data/spec/unit/config/actions/base_spec.rb

@@ -11,9 +11,9 @@ describe RailsAdmin::Config::Actions::Base do
           end
         end
       end
-      RailsAdmin::Config::Actions.find(:index, {:controller => double(:authorized? => true), :abstract_model => RailsAdmin::AbstractModel.new(Player)}).should be_visible
-      RailsAdmin::Config::Actions.find(:index, {:controller => double(:authorized? => true), :abstract_model => RailsAdmin::AbstractModel.new(Team)}).should be_nil
-      RailsAdmin::Config::Actions.find(:index, {:controller => double(:authorized? => true), :abstract_model => RailsAdmin::AbstractModel.new(Cms::BasicPage)}).should be_visible
+      expect(RailsAdmin::Config::Actions.find(:index, {:controller => double(:authorized? => true), :abstract_model => RailsAdmin::AbstractModel.new(Player)})).to be_visible
+      expect(RailsAdmin::Config::Actions.find(:index, {:controller => double(:authorized? => true), :abstract_model => RailsAdmin::AbstractModel.new(Team)})).to be_nil
+      expect(RailsAdmin::Config::Actions.find(:index, {:controller => double(:authorized? => true), :abstract_model => RailsAdmin::AbstractModel.new(Cms::BasicPage)})).to be_visible
     end
     
     it 'should exclude models referenced in the except array' do
@@ -24,9 +24,9 @@ describe RailsAdmin::Config::Actions::Base do
           end
         end
       end
-      RailsAdmin::Config::Actions.find(:index, {:controller => double(:authorized? => true), :abstract_model => RailsAdmin::AbstractModel.new(Player)}).should be_nil
-      RailsAdmin::Config::Actions.find(:index, {:controller => double(:authorized? => true), :abstract_model => RailsAdmin::AbstractModel.new(Team)}).should be_visible
-      RailsAdmin::Config::Actions.find(:index, {:controller => double(:authorized? => true), :abstract_model => RailsAdmin::AbstractModel.new(Cms::BasicPage)}).should be_nil
+      expect(RailsAdmin::Config::Actions.find(:index, {:controller => double(:authorized? => true), :abstract_model => RailsAdmin::AbstractModel.new(Player)})).to be_nil
+      expect(RailsAdmin::Config::Actions.find(:index, {:controller => double(:authorized? => true), :abstract_model => RailsAdmin::AbstractModel.new(Team)})).to be_visible
+      expect(RailsAdmin::Config::Actions.find(:index, {:controller => double(:authorized? => true), :abstract_model => RailsAdmin::AbstractModel.new(Cms::BasicPage)})).to be_nil
     end
   end
 end

data/spec/unit/config/actions_spec.rb

@@ -4,7 +4,7 @@ describe RailsAdmin::Config::Actions do
 
   describe "default" do
     it 'should be as before' do
-      RailsAdmin::Config::Actions.all.map(&:key).should == [:dashboard, :index, :show, :new, :edit, :export, :delete, :bulk_delete, :history_show, :history_index, :show_in_app]
+      expect(RailsAdmin::Config::Actions.all.map(&:key)).to eq([:dashboard, :index, :show, :new, :edit, :export, :delete, :bulk_delete, :history_show, :history_index, :show_in_app])
     end
   end
 
@@ -22,13 +22,13 @@ describe RailsAdmin::Config::Actions do
         end
       end
 
-      RailsAdmin::Config::Actions.find(:custom_dashboard).should be_a(RailsAdmin::Config::Actions::Dashboard)
-      RailsAdmin::Config::Actions.find(:custom_collection).should be_a(RailsAdmin::Config::Actions::Index)
-      RailsAdmin::Config::Actions.find(:show).should be_a(RailsAdmin::Config::Actions::Show)
+      expect(RailsAdmin::Config::Actions.find(:custom_dashboard)).to be_a(RailsAdmin::Config::Actions::Dashboard)
+      expect(RailsAdmin::Config::Actions.find(:custom_collection)).to be_a(RailsAdmin::Config::Actions::Index)
+      expect(RailsAdmin::Config::Actions.find(:show)).to be_a(RailsAdmin::Config::Actions::Show)
     end
 
     it 'should return nil when no action is found by the custom key' do
-      RailsAdmin::Config::Actions.find(:non_existent_action_key).should be_nil
+      expect(RailsAdmin::Config::Actions.find(:non_existent_action_key)).to be_nil
     end
 
     it 'should return visible action passing binding if controller binding is given, and pass action visible or not if no' do
@@ -41,9 +41,9 @@ describe RailsAdmin::Config::Actions do
           end
         end
       end
-      RailsAdmin::Config::Actions.find(:custom_root).should be_a(RailsAdmin::Config::Actions::Base)
-      RailsAdmin::Config::Actions.find(:custom_root, {:controller => "not_controller"}).should be_nil
-      RailsAdmin::Config::Actions.find(:custom_root, {:controller => "controller"}).should be_a(RailsAdmin::Config::Actions::Base)
+      expect(RailsAdmin::Config::Actions.find(:custom_root)).to be_a(RailsAdmin::Config::Actions::Base)
+      expect(RailsAdmin::Config::Actions.find(:custom_root, {:controller => "not_controller"})).to be_nil
+      expect(RailsAdmin::Config::Actions.find(:custom_root, {:controller => "controller"})).to be_a(RailsAdmin::Config::Actions::Base)
     end
 
     it 'should check bindings[:abstract_model] visibility while checking action\'s visibility' do
@@ -51,16 +51,16 @@ describe RailsAdmin::Config::Actions do
         hide
       end
 
-      RailsAdmin::Config::Actions.find(:index, {:controller => double(:authorized? => true), :abstract_model => RailsAdmin::AbstractModel.new(Comment)}).should be_a(RailsAdmin::Config::Actions::Index) #decoy
-      RailsAdmin::Config::Actions.find(:index, {:controller => double(:authorized? => true), :abstract_model => RailsAdmin::AbstractModel.new(Team)}).should be_nil
+      expect(RailsAdmin::Config::Actions.find(:index, {:controller => double(:authorized? => true), :abstract_model => RailsAdmin::AbstractModel.new(Comment)})).to be_a(RailsAdmin::Config::Actions::Index) #decoy
+      expect(RailsAdmin::Config::Actions.find(:index, {:controller => double(:authorized? => true), :abstract_model => RailsAdmin::AbstractModel.new(Team)})).to be_nil
     end
 
     it 'should check bindings[:abstract_model] presence while checking action\'s visibility' do
       RailsAdmin.config do |config|
         config.excluded_models << Team
       end
-      RailsAdmin::Config::Actions.find(:index, {:controller => double(:authorized? => true), :abstract_model => RailsAdmin::AbstractModel.new(Comment)}).should be_a(RailsAdmin::Config::Actions::Index) #decoy
-      RailsAdmin::Config::Actions.find(:index, {:controller => double(:authorized? => true), :abstract_model => RailsAdmin::AbstractModel.new(Team)}).should be_nil
+      expect(RailsAdmin::Config::Actions.find(:index, {:controller => double(:authorized? => true), :abstract_model => RailsAdmin::AbstractModel.new(Comment)})).to be_a(RailsAdmin::Config::Actions::Index) #decoy
+      expect(RailsAdmin::Config::Actions.find(:index, {:controller => double(:authorized? => true), :abstract_model => RailsAdmin::AbstractModel.new(Team)})).to be_nil
     end
   end
 
@@ -73,7 +73,7 @@ describe RailsAdmin::Config::Actions do
         end
       end
 
-      RailsAdmin::Config::Actions.all.map(&:key).should == [:dashboard, :index]
+      expect(RailsAdmin::Config::Actions.all.map(&:key)).to eq([:dashboard, :index])
     end
 
     it 'should restrict by scope' do
@@ -84,9 +84,9 @@ describe RailsAdmin::Config::Actions do
           member :custom_member
         end
       end
-      RailsAdmin::Config::Actions.all(:root).map(&:key).should == [:custom_root]
-      RailsAdmin::Config::Actions.all(:collection).map(&:key).should == [:custom_collection]
-      RailsAdmin::Config::Actions.all(:member).map(&:key).should == [:custom_member]
+      expect(RailsAdmin::Config::Actions.all(:root).map(&:key)).to eq([:custom_root])
+      expect(RailsAdmin::Config::Actions.all(:collection).map(&:key)).to eq([:custom_collection])
+      expect(RailsAdmin::Config::Actions.all(:member).map(&:key)).to eq([:custom_member])
     end
 
     it 'should return all visible actions passing binding if controller binding is given, and pass all actions if no' do
@@ -99,9 +99,9 @@ describe RailsAdmin::Config::Actions do
           end
         end
       end
-      RailsAdmin::Config::Actions.all(:root).map(&:custom_key).should == [:custom_root]
-      RailsAdmin::Config::Actions.all(:root, {:controller => "not_controller"}).map(&:custom_key).should == []
-      RailsAdmin::Config::Actions.all(:root, {:controller => "controller"}).map(&:custom_key).should == [:custom_root]
+      expect(RailsAdmin::Config::Actions.all(:root).map(&:custom_key)).to eq([:custom_root])
+      expect(RailsAdmin::Config::Actions.all(:root, {:controller => "not_controller"}).map(&:custom_key)).to eq([])
+      expect(RailsAdmin::Config::Actions.all(:root, {:controller => "controller"}).map(&:custom_key)).to eq([:custom_root])
     end
   end
 
@@ -115,7 +115,7 @@ describe RailsAdmin::Config::Actions do
         end
       end
 
-      RailsAdmin::Config::Actions.all.map(&:key).should == [:dashboard, :index, :show]
+      expect(RailsAdmin::Config::Actions.all.map(&:key)).to eq([:dashboard, :index, :show])
     end
 
     it 'should allow to customize the custom_key when customizing an existing action' do
@@ -126,8 +126,8 @@ describe RailsAdmin::Config::Actions do
           end
         end
       end
-      RailsAdmin::Config::Actions.all.map(&:custom_key).should == [:my_dashboard]
-      RailsAdmin::Config::Actions.all.map(&:key).should == [:dashboard]
+      expect(RailsAdmin::Config::Actions.all.map(&:custom_key)).to eq([:my_dashboard])
+      expect(RailsAdmin::Config::Actions.all.map(&:key)).to eq([:dashboard])
     end
 
     it 'should allow to change the key and the custom_key when "subclassing" an existing action' do
@@ -138,30 +138,29 @@ describe RailsAdmin::Config::Actions do
           end
         end
       end
-      RailsAdmin::Config::Actions.all.map(&:custom_key).should == [:my_dashboard_custom_key]
-      RailsAdmin::Config::Actions.all.map(&:key).should == [:my_dashboard_key]
-      RailsAdmin::Config::Actions.all.map(&:class).should == [RailsAdmin::Config::Actions::Dashboard]
+      expect(RailsAdmin::Config::Actions.all.map(&:custom_key)).to eq([:my_dashboard_custom_key])
+      expect(RailsAdmin::Config::Actions.all.map(&:key)).to eq([:my_dashboard_key])
+      expect(RailsAdmin::Config::Actions.all.map(&:class)).to eq([RailsAdmin::Config::Actions::Dashboard])
     end
 
     it 'should not add the same custom_key twice' do
-      lambda do
+      expect do
         RailsAdmin.config do |config|
           config.actions do
             dashboard
             dashboard
           end
         end
-      end.should raise_error("Action dashboard already exist. Please change its custom key")
+      end.to raise_error("Action dashboard already exist. Please change its custom key")
 
-
-      lambda do
+      expect do
         RailsAdmin.config do |config|
           config.actions do
             index
             collection :index
           end
         end
-      end.should raise_error("Action index already exist. Please change its custom key")
+      end.to raise_error("Action index already exist. Please change its custom key")
     end
 
     it 'should add the same key with different custom key' do
@@ -174,8 +173,8 @@ describe RailsAdmin::Config::Actions do
         end
       end
 
-      RailsAdmin::Config::Actions.all.map(&:custom_key).should == [:dashboard, :my_dashboard]
-      RailsAdmin::Config::Actions.all.map(&:key).should == [:dashboard, :dashboard]
+      expect(RailsAdmin::Config::Actions.all.map(&:custom_key)).to eq([:dashboard, :my_dashboard])
+      expect(RailsAdmin::Config::Actions.all.map(&:key)).to eq([:dashboard, :dashboard])
     end
   end
 end

data/spec/unit/config/fields/base_spec.rb

@@ -7,9 +7,9 @@ describe RailsAdmin::Config::Fields::Base do
       RailsAdmin.config Ball do
         field 'color'
       end
-      
-      RailsAdmin.config('Ball').fields.first.with(:object => Ball.new).should be_required
-      RailsAdmin.config('Ball').fields.first.with(:object => FactoryGirl.create(:ball)).should_not be_required
+
+      expect(RailsAdmin.config('Ball').fields.first.with(:object => Ball.new)).to be_required
+      expect(RailsAdmin.config('Ball').fields.first.with(:object => FactoryGirl.create(:ball))).not_to be_required
     end
   end
 
@@ -18,7 +18,7 @@ describe RailsAdmin::Config::Fields::Base do
       RailsAdmin.config Team do
         field 'name'
       end
-      RailsAdmin.config('Team').fields.first.name.should == :name
+      expect(RailsAdmin.config('Team').fields.first.name).to eq(:name)
     end
   end
 
@@ -31,15 +31,15 @@ describe RailsAdmin::Config::Fields::Base do
       end
 
     it 'should be empty by default' do
-      RailsAdmin.config(Team).fields.find{ |f| f.name == :name }.children_fields.should == []
+      expect(RailsAdmin.config(Team).fields.find{ |f| f.name == :name }.children_fields).to eq([])
     end
 
     it 'should contain child key for belongs to associations' do
-      RailsAdmin.config(Team).fields.find{ |f| f.name == :division }.children_fields.should == [:division_id]
+      expect(RailsAdmin.config(Team).fields.find{ |f| f.name == :division }.children_fields).to eq([:division_id])
     end
 
     it 'should contain child keys for polymorphic belongs to associations' do
-      RailsAdmin.config(Comment).fields.find{ |f| f.name == :commentable }.children_fields.should =~ POLYMORPHIC_CHILDREN
+      expect(RailsAdmin.config(Comment).fields.find{ |f| f.name == :commentable }.children_fields).to match_array POLYMORPHIC_CHILDREN
     end
 
     it "should have correct fields when polymorphic_type column comes ahead of polymorphic foreign_key column" do
@@ -48,32 +48,31 @@ describe RailsAdmin::Config::Fields::Base do
         column :commentable_id, :integer
         belongs_to :commentable, :polymorphic => true
       end
-      RailsAdmin.config(CommentReversed).fields.map{|f| f.name.to_s}.
-        select{|f| /^comment/ =~ f}.should =~ ['commentable'].concat(POLYMORPHIC_CHILDREN.map(&:to_s))
+      expect(RailsAdmin.config(CommentReversed).fields.map{|f| f.name.to_s}.select{|f| /^comment/ =~ f}).to match_array ['commentable'].concat(POLYMORPHIC_CHILDREN.map(&:to_s))
     end
 
     context 'of a Paperclip installation' do
       it 'should be a _file_name field' do
-        RailsAdmin.config(FieldTest).fields.find{ |f| f.name == :paperclip_asset }.children_fields.include?(:paperclip_asset_file_name).should be_true
+        expect(RailsAdmin.config(FieldTest).fields.find{ |f| f.name == :paperclip_asset }.children_fields.include?(:paperclip_asset_file_name)).to be_true
       end
 
       it 'should be hidden, not filterable' do
         f = RailsAdmin.config(FieldTest).fields.find{ |f| f.name == :paperclip_asset_file_name }
-        f.hidden?.should be_true
-        f.filterable?.should be_false
+        expect(f.hidden?).to be_true
+        expect(f.filterable?).to be_false
       end
     end
 
     context 'of a Dragonfly installation' do
       it 'should be a _name field and _uid field' do
-        RailsAdmin.config(FieldTest).fields.find{ |f| f.name == :dragonfly_asset }.children_fields.should == [:dragonfly_asset_name, :dragonfly_asset_uid]
+        expect(RailsAdmin.config(FieldTest).fields.find{ |f| f.name == :dragonfly_asset }.children_fields).to eq([:dragonfly_asset_name, :dragonfly_asset_uid])
       end
     end
 
     context 'of a Carrierwave installation' do
       it 'should be the parent field itself' do
-        RailsAdmin.config(FieldTest).fields.find{ |f| f.name == :carrierwave_asset }.children_fields.should == [:carrierwave_asset]
-        RailsAdmin.config(FieldTest).fields.find{ |f| f.name == :carrierwave_asset }.hidden?.should be_false
+        expect(RailsAdmin.config(FieldTest).fields.find{ |f| f.name == :carrierwave_asset }.children_fields).to eq([:carrierwave_asset])
+        expect(RailsAdmin.config(FieldTest).fields.find{ |f| f.name == :carrierwave_asset }.hidden?).to be_false
       end
     end
   end
@@ -88,18 +87,18 @@ describe RailsAdmin::Config::Fields::Base do
         end
       end
       @team = Team.new
-      RailsAdmin.config('Team').list.fields.find{|f| f.name == :name}.with(:object => @team).html_default_value.should == 'default value'
+      expect(RailsAdmin.config('Team').list.fields.find{|f| f.name == :name}.with(:object => @team).html_default_value).to eq('default value')
       @team.name = 'set value'
-      RailsAdmin.config('Team').list.fields.find{|f| f.name == :name}.with(:object => @team).html_default_value.should be_nil
+      expect(RailsAdmin.config('Team').list.fields.find{|f| f.name == :name}.with(:object => @team).html_default_value).to be_nil
       @team = FactoryGirl.create :team
       @team.name = nil
-      RailsAdmin.config('Team').list.fields.find{|f| f.name == :name}.with(:object => @team).html_default_value.should be_nil
+      expect(RailsAdmin.config('Team').list.fields.find{|f| f.name == :name}.with(:object => @team).html_default_value).to be_nil
     end
   end
 
   describe "#default_value" do
     it 'should be nil by default' do
-      RailsAdmin.config('Team').list.fields.find{|f| f.name == :name}.default_value.should be_nil
+      expect(RailsAdmin.config('Team').list.fields.find{|f| f.name == :name}.default_value).to be_nil
     end
   end
 
@@ -113,8 +112,8 @@ describe RailsAdmin::Config::Fields::Base do
           field :name
         end
       end
-      RailsAdmin.config('Team').list.fields.find{|f| f.name == :division}.hint.should == "Great Division" # custom
-      RailsAdmin.config('Team').list.fields.find{|f| f.name == :name}.hint.should == "" # default
+      expect(RailsAdmin.config('Team').list.fields.find{|f| f.name == :division}.hint).to eq("Great Division") # custom
+      expect(RailsAdmin.config('Team').list.fields.find{|f| f.name == :name}.hint).to eq("") # default
     end
   end
 
@@ -128,29 +127,29 @@ describe RailsAdmin::Config::Fields::Base do
           field :name
         end
       end
-      RailsAdmin.config('Team').list.fields.find{|f| f.name == :division}.css_class.should == "custom" # custom
-      RailsAdmin.config('Team').list.fields.find{|f| f.name == :division}.type_css_class.should == "belongs_to_association_type" # type css class, non-customizable
-      RailsAdmin.config('Team').list.fields.find{|f| f.name == :name}.css_class.should == "name_field" # default
+      expect(RailsAdmin.config('Team').list.fields.find{|f| f.name == :division}.css_class).to eq("custom") # custom
+      expect(RailsAdmin.config('Team').list.fields.find{|f| f.name == :division}.type_css_class).to eq("belongs_to_association_type") # type css class, non-customizable
+      expect(RailsAdmin.config('Team').list.fields.find{|f| f.name == :name}.css_class).to eq("name_field") # default
     end
   end
 
   describe "#associated_collection_cache_all" do
     it "should default to true if associated collection count < 100" do
-      RailsAdmin.config(Team).edit.fields.find{|f| f.name == :players}.associated_collection_cache_all.should == true
+      expect(RailsAdmin.config(Team).edit.fields.find{|f| f.name == :players}.associated_collection_cache_all).to be_true
     end
 
     it "should default to false if associated collection count >= 100" do
       @players = 100.times.map do
         FactoryGirl.create :player
       end
-      RailsAdmin.config(Team).edit.fields.find{|f| f.name == :players}.associated_collection_cache_all.should == false
+      expect(RailsAdmin.config(Team).edit.fields.find{|f| f.name == :players}.associated_collection_cache_all).to be_false
     end
   end
 
   describe '#searchable_columns' do
     describe 'for belongs_to fields' do
       it "should find label method on the opposite side for belongs_to associations by default" do
-        RailsAdmin.config(Team).fields.find{|f| f.name == :division}.searchable_columns.map{|c| c[:column]}.should == ["divisions.name", "teams.division_id"]
+        expect(RailsAdmin.config(Team).fields.find{|f| f.name == :division}.searchable_columns.map{|c| c[:column]}).to eq(["divisions.name", "teams.division_id"])
       end
 
       it "should search on opposite table for belongs_to" do
@@ -159,7 +158,7 @@ describe RailsAdmin::Config::Fields::Base do
             searchable :custom_id
           end
         end
-        RailsAdmin.config(Team).fields.find{|f| f.name == :division}.searchable_columns.map{|c| c[:column]}.should == ["divisions.custom_id"]
+        expect(RailsAdmin.config(Team).fields.find{|f| f.name == :division}.searchable_columns.map{|c| c[:column]}).to eq(["divisions.custom_id"])
       end
 
       it "should search on asked table with model name" do
@@ -168,7 +167,7 @@ describe RailsAdmin::Config::Fields::Base do
             searchable League => :name
           end
         end
-        RailsAdmin.config(Team).fields.find{|f| f.name == :division}.searchable_columns.should == [{:column=>"leagues.name", :type=>:string}]
+        expect(RailsAdmin.config(Team).fields.find{|f| f.name == :division}.searchable_columns).to eq([{:column=>"leagues.name", :type=>:string}])
       end
 
       it "should search on asked table with table name" do
@@ -177,15 +176,15 @@ describe RailsAdmin::Config::Fields::Base do
             searchable :leagues => :name
           end
         end
-        RailsAdmin.config(Team).fields.find{|f| f.name == :division}.searchable_columns.should == [{:column=>"leagues.name", :type=>:string}]
+        expect(RailsAdmin.config(Team).fields.find{|f| f.name == :division}.searchable_columns).to eq([{:column=>"leagues.name", :type=>:string}])
       end
     end
 
     describe 'for basic type fields' do
 
       it 'should use base table and find correct column type' do
-        RailsAdmin.config(FieldTest).fields.find{|f| f.name == :text_field}.searchable_columns.should == [{:column=>"field_tests.text_field", :type=>:text}]
-        RailsAdmin.config(FieldTest).fields.find{|f| f.name == :integer_field}.searchable_columns.should == [{:column=>"field_tests.integer_field", :type=>:integer}]
+        expect(RailsAdmin.config(FieldTest).fields.find{|f| f.name == :text_field}.searchable_columns).to eq([{:column=>"field_tests.text_field", :type=>:text}])
+        expect(RailsAdmin.config(FieldTest).fields.find{|f| f.name == :integer_field}.searchable_columns).to eq([{:column=>"field_tests.integer_field", :type=>:integer}])
       end
 
       it 'should be customizable to another field on the same table' do
@@ -194,7 +193,7 @@ describe RailsAdmin::Config::Fields::Base do
             searchable :date_field
           end
         end
-        RailsAdmin.config(FieldTest).fields.find{|f| f.name == :time_field}.searchable_columns.should == [{:column=>"field_tests.date_field", :type=>:date}]
+        expect(RailsAdmin.config(FieldTest).fields.find{|f| f.name == :time_field}.searchable_columns).to eq([{:column=>"field_tests.date_field", :type=>:date}])
       end
 
       it 'should be customizable to another field on another table with :table_name' do
@@ -203,7 +202,7 @@ describe RailsAdmin::Config::Fields::Base do
             searchable :nested_field_tests => :title
           end
         end
-        RailsAdmin.config(FieldTest).fields.find{|f| f.name == :string_field}.searchable_columns.should == [{:column=>"nested_field_tests.title", :type=>:string}]
+        expect(RailsAdmin.config(FieldTest).fields.find{|f| f.name == :string_field}.searchable_columns).to eq([{:column=>"nested_field_tests.title", :type=>:string}])
       end
 
       it 'should be customizable to another field on another model with ModelClass' do
@@ -212,21 +211,21 @@ describe RailsAdmin::Config::Fields::Base do
             searchable NestedFieldTest => :title
           end
         end
-        RailsAdmin.config(FieldTest).fields.find{|f| f.name == :string_field}.searchable_columns.should == [{:column=>"nested_field_tests.title", :type=>:string}]
+        expect(RailsAdmin.config(FieldTest).fields.find{|f| f.name == :string_field}.searchable_columns).to eq([{:column=>"nested_field_tests.title", :type=>:string}])
       end
     end
 
     describe 'for mapped fields' do
       it 'of paperclip should find the underlying column on the base table' do
-        RailsAdmin.config(FieldTest).fields.find{|f| f.name == :paperclip_asset}.searchable_columns.map{|c| c[:column]}.should == ["field_tests.paperclip_asset_file_name"]
+        expect(RailsAdmin.config(FieldTest).fields.find{|f| f.name == :paperclip_asset}.searchable_columns.map{|c| c[:column]}).to eq(["field_tests.paperclip_asset_file_name"])
       end
 
       it 'of dragonfly should find the underlying column on the base table' do
-        RailsAdmin.config(FieldTest).fields.find{|f| f.name == :dragonfly_asset}.searchable_columns.map{|c| c[:column]}.should == ["field_tests.dragonfly_asset_name"]
+        expect(RailsAdmin.config(FieldTest).fields.find{|f| f.name == :dragonfly_asset}.searchable_columns.map{|c| c[:column]}).to eq(["field_tests.dragonfly_asset_name"])
       end
 
       it 'of carrierwave should find the underlying column on the base table' do
-        RailsAdmin.config(FieldTest).fields.find{|f| f.name == :carrierwave_asset}.searchable_columns.map{|c| c[:column]}.should == ["field_tests.carrierwave_asset"]
+        expect(RailsAdmin.config(FieldTest).fields.find{|f| f.name == :carrierwave_asset}.searchable_columns.map{|c| c[:column]}).to eq(["field_tests.carrierwave_asset"])
       end
     end
   end
@@ -239,26 +238,26 @@ describe RailsAdmin::Config::Fields::Base do
         field :name
       end
       @league = FactoryGirl.create :league
-      RailsAdmin.config('League').export.fields.find{ |f| f.name == :virtual_column }.sortable.should == false
-      RailsAdmin.config('League').export.fields.find{ |f| f.name == :virtual_column }.searchable.should == false
-      RailsAdmin.config('League').export.fields.find{ |f| f.name == :name }.sortable.should == true
-      RailsAdmin.config('League').export.fields.find{ |f| f.name == :name }.searchable.should == true
+      expect(RailsAdmin.config('League').export.fields.find{ |f| f.name == :virtual_column }.sortable).to be_false
+      expect(RailsAdmin.config('League').export.fields.find{ |f| f.name == :virtual_column }.searchable).to be_false
+      expect(RailsAdmin.config('League').export.fields.find{ |f| f.name == :name }.sortable).to be_true
+      expect(RailsAdmin.config('League').export.fields.find{ |f| f.name == :name }.searchable).to be_true
     end
 
     context 'of a virtual field with children fields' do
       it 'of paperclip should target the first children field' do
-        RailsAdmin.config(FieldTest).fields.find{ |f| f.name == :paperclip_asset }.searchable.should == :paperclip_asset_file_name
-        RailsAdmin.config(FieldTest).fields.find{ |f| f.name == :paperclip_asset }.sortable.should == :paperclip_asset_file_name
+        expect(RailsAdmin.config(FieldTest).fields.find{ |f| f.name == :paperclip_asset }.searchable).to eq(:paperclip_asset_file_name)
+        expect(RailsAdmin.config(FieldTest).fields.find{ |f| f.name == :paperclip_asset }.sortable).to eq(:paperclip_asset_file_name)
       end
 
       it 'of dragonfly should target the first children field' do
-        RailsAdmin.config(FieldTest).fields.find{ |f| f.name == :dragonfly_asset }.searchable.should == :dragonfly_asset_name
-        RailsAdmin.config(FieldTest).fields.find{ |f| f.name == :dragonfly_asset }.sortable.should == :dragonfly_asset_name
+        expect(RailsAdmin.config(FieldTest).fields.find{ |f| f.name == :dragonfly_asset }.searchable).to eq(:dragonfly_asset_name)
+        expect(RailsAdmin.config(FieldTest).fields.find{ |f| f.name == :dragonfly_asset }.sortable).to eq(:dragonfly_asset_name)
       end
 
       it 'of carrierwave should target the first children field' do
-        RailsAdmin.config(FieldTest).fields.find{ |f| f.name == :carrierwave_asset }.searchable.should == :carrierwave_asset
-        RailsAdmin.config(FieldTest).fields.find{ |f| f.name == :carrierwave_asset }.sortable.should == :carrierwave_asset
+        expect(RailsAdmin.config(FieldTest).fields.find{ |f| f.name == :carrierwave_asset }.searchable).to eq(:carrierwave_asset)
+        expect(RailsAdmin.config(FieldTest).fields.find{ |f| f.name == :carrierwave_asset }.sortable).to eq(:carrierwave_asset)
       end
     end
   end
@@ -270,8 +269,8 @@ describe RailsAdmin::Config::Fields::Base do
         field :name
       end
       @league = FactoryGirl.create :league
-      RailsAdmin.config('League').export.fields.find{ |f| f.name == :virtual_column }.virtual?.should == true
-      RailsAdmin.config('League').export.fields.find{ |f| f.name == :name }.virtual?.should == false
+      expect(RailsAdmin.config('League').export.fields.find{ |f| f.name == :virtual_column }.virtual?).to be_true
+      expect(RailsAdmin.config('League').export.fields.find{ |f| f.name == :name }.virtual?).to be_false
     end
   end
 
@@ -282,16 +281,16 @@ describe RailsAdmin::Config::Fields::Base do
 
     context "when no search operator is specified for the field" do
       it "uses 'default' search operator" do
-        queryable_fields.should have_at_least(1).field
-        queryable_fields.first.search_operator.should == RailsAdmin::Config.default_search_operator
+        expect(queryable_fields).to have_at_least(1).field
+        expect(queryable_fields.first.search_operator).to eq(RailsAdmin::Config.default_search_operator)
       end
 
       it "uses config.default_search_operator if set" do
         RailsAdmin.config do |config|
           config.default_search_operator = 'starts_with'
         end
-        queryable_fields.should have_at_least(1).field
-        queryable_fields.first.search_operator.should == RailsAdmin::Config.default_search_operator
+        expect(queryable_fields).to have_at_least(1).field
+        expect(queryable_fields.first.search_operator).to eq(RailsAdmin::Config.default_search_operator)
       end
     end
 
@@ -304,8 +303,8 @@ describe RailsAdmin::Config::Fields::Base do
             end
           end
         end
-        queryable_fields.should have_at_least(1).field
-        queryable_fields.first.search_operator.should == "starts_with"
+        expect(queryable_fields).to have_at_least(1).field
+        expect(queryable_fields.first.search_operator).to eq("starts_with")
       end
 
       it "uses specified search operator even if config.default_search_operator set" do
@@ -320,8 +319,8 @@ describe RailsAdmin::Config::Fields::Base do
             end
           end
         end
-        queryable_fields.should have_at_least(1).field
-        queryable_fields.first.search_operator.should == "ends_with"
+        expect(queryable_fields).to have_at_least(1).field
+        expect(queryable_fields.first.search_operator).to eq("ends_with")
       end
     end
   end
@@ -335,19 +334,19 @@ describe RailsAdmin::Config::Fields::Base do
           end
         end
       end
-      RailsAdmin.config(Team).field(:name).render.should == 'rendered'
+      expect(RailsAdmin.config(Team).field(:name).render).to eq('rendered')
     end
   end
 
   describe '#active' do
     it 'is false by default' do
-      RailsAdmin.config(Team).field(:division).active?.should be_false
+      expect(RailsAdmin.config(Team).field(:division).active?).to be_false
     end
   end
-  
+
   describe '#associated_collection' do
     it 'returns [] when type is blank?' do
-      RailsAdmin.config(Comment).fields.find{|f|f.name == :commentable}.associated_collection('').should be_empty
+      expect(RailsAdmin.config(Comment).fields.find{|f|f.name == :commentable}.associated_collection('')).to be_empty
     end
   end
 
@@ -365,13 +364,13 @@ describe RailsAdmin::Config::Fields::Base do
         column :updated_on, :datetime
         column :deleted_on, :datetime
       end
-      RailsAdmin.config(FieldVisibilityTest).base.fields.select{|f| f.visible? }.map(&:name).should =~ [:_id, :created_at, :created_on, :deleted_at, :deleted_on, :id, :name, :updated_at, :updated_on]
-      RailsAdmin.config(FieldVisibilityTest).list.fields.select{|f| f.visible? }.map(&:name).should =~ [:_id, :created_at, :created_on, :deleted_at, :deleted_on, :id, :name, :updated_at, :updated_on]
-      RailsAdmin.config(FieldVisibilityTest).edit.fields.select{|f| f.visible? }.map(&:name).should =~ [:name]
-      RailsAdmin.config(FieldVisibilityTest).show.fields.select{|f| f.visible? }.map(&:name).should =~ [:name]
+      expect(RailsAdmin.config(FieldVisibilityTest).base.fields.select{|f| f.visible? }.map(&:name)).to match_array [:_id, :created_at, :created_on, :deleted_at, :deleted_on, :id, :name, :updated_at, :updated_on]
+      expect(RailsAdmin.config(FieldVisibilityTest).list.fields.select{|f| f.visible? }.map(&:name)).to match_array [:_id, :created_at, :created_on, :deleted_at, :deleted_on, :id, :name, :updated_at, :updated_on]
+      expect(RailsAdmin.config(FieldVisibilityTest).edit.fields.select{|f| f.visible? }.map(&:name)).to match_array [:name]
+      expect(RailsAdmin.config(FieldVisibilityTest).show.fields.select{|f| f.visible? }.map(&:name)).to match_array [:name]
     end
   end
-  
+
   describe '#editable?' do
     before do
       Moped.logger.stub!(:debug) if defined?(Moped)
@@ -386,9 +385,9 @@ describe RailsAdmin::Config::Fields::Base do
       end
       Rails.logger.should_receive(:debug).with {|msg| msg =~ /Please add 'attr_accessible :protected_field'/ }
       editable = RailsAdmin.config(FieldTest).field(:protected_field).with(:object => FactoryGirl.create(:field_test), :view => double(:controller => double(:_attr_accessible_role => :default))).editable?
-      editable.should == false
+      expect(editable).to be_false
     end
-    
+
     it 'should not yell for non attr_accessible fields if config.yell_for_non_accessible_fields is false' do
       RailsAdmin.config do |config|
         config.yell_for_non_accessible_fields = false
@@ -398,7 +397,7 @@ describe RailsAdmin::Config::Fields::Base do
       end
       Rails.logger.should_not_receive(:debug).with {|msg| msg =~ /Please add 'attr_accessible :protected_field'/ }
       editable = RailsAdmin.config(FieldTest).field(:protected_field).with(:object => FactoryGirl.create(:field_test), :view => double(:controller => double(:_attr_accessible_role => :default))).editable?
-      editable.should == false
+      expect(editable).to be_false
     end
   end
 end