rails_admin 0.6.2 → 0.6.3

data/spec/integration/relation_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe 'table relations' do
+describe 'table relations', type: :request do
 
   before do
     class RelTest < Tableless
@@ -17,19 +17,19 @@ describe 'table relations' do
 
   describe 'column with nullable fk and no model validations' do
     it 'is optional' do
-      expect(@fields.detect { |f| f.name == :league }.required?).to be_false
+      expect(@fields.detect { |f| f.name == :league }.required?).to be_falsey
     end
   end
 
   describe 'column with non-nullable fk and no model validations' do
     it 'is not required' do
-      expect(@fields.detect { |f| f.name == :division }.required?).to be_false
+      expect(@fields.detect { |f| f.name == :division }.required?).to be_falsey
     end
   end
 
   describe 'column with nullable fk and a numericality model validation' do
     it 'is required' do
-      expect(@fields.detect { |f| f.name == :player }.required?).to be_true
+      expect(@fields.detect { |f| f.name == :player }.required?).to be_truthy
     end
   end
 end

data/spec/orm/active_record.rb

@@ -31,7 +31,7 @@ class Tableless < ActiveRecord::Base
     end
 
     def column_defaults
-      @column_defaults ||= columns.collect { |column| [column.name, nil] }.inject({}) do |a, e|
+      @column_defaults ||= columns.collect { |column| [column.name, nil] }.each_with_object({}) do |e, a|
         a[e[0]] = e[1]
         a
       end

data/spec/orm/mongoid.rb

@@ -6,7 +6,7 @@ class Tableless
   include Mongoid::Document
 
   class <<self
-    def column(name, sql_type = 'string', default = nil, null = true)
+    def column(name, sql_type = 'string', default = nil, _null = true)
       # ignore length
       sql_type = sql_type.to_s.sub(/\(.*\)/, '').to_sym
       field(name, type: {integer: Integer, string: String, text: String, date: Date, datetime: DateTime}[sql_type], default: default)

data/spec/rails_admin/abstract_model_spec.rb

@@ -23,7 +23,7 @@ describe RailsAdmin::AbstractModel do
       it 'lists elements within outbound limits' do
         date_format = I18n.t('admin.misc.filter_date_format', default: I18n.t('admin.misc.filter_date_format', locale: :en)).gsub('dd', '%d').gsub('mm', '%m').gsub('yy', '%Y')
 
-        %w[01/01/2012 01/02/2012 01/03/2012 01/04/2012].each do |date|
+        %w(01/01/2012 01/02/2012 01/03/2012 01/04/2012).each do |date|
           FactoryGirl.create(:field_test, date_field: Date.strptime(date, date_format))
         end
         expect(@abstract_model.all(filters: {'date_field' => {'1' => {v: ['', '01/02/2012', '01/03/2012'], o: 'between'}}}).count).to eq(2)

data/spec/rails_admin/adapters/active_record/abstract_object_spec.rb

@@ -25,13 +25,13 @@ describe 'RailsAdmin::Adapters::ActiveRecord::AbstractObject', active_record: tr
       end
 
       it 'creates a Player with given attributes' do
-        expect(object.save).to be_true
+        expect(object.save).to be_truthy
 
         player.reload
         expect(player.name).to eq(name)
         expect(player.number).to eq(number)
         expect(player.position).to eq(position)
-        expect(player.suspended).to be_true
+        expect(player.suspended).to be_truthy
         expect(player.draft).to be_nil
         expect(player.team).to be_nil
       end
@@ -46,13 +46,13 @@ describe 'RailsAdmin::Adapters::ActiveRecord::AbstractObject', active_record: tr
       end
 
       it 'creates a Player with given attributes' do
-        expect(object.save).to be_true
+        expect(object.save).to be_truthy
 
         player.reload
         expect(player.name).to eq(name)
         expect(player.number).to eq(number)
         expect(player.position).to eq(position)
-        expect(player.suspended).to be_true
+        expect(player.suspended).to be_truthy
         expect(player.draft).to eq(draft.reload)
         expect(player.team).to be_nil
       end
@@ -70,7 +70,7 @@ describe 'RailsAdmin::Adapters::ActiveRecord::AbstractObject', active_record: tr
       end
 
       it 'creates a League with given attributes and associations' do
-        expect(object.save).to be_true
+        expect(object.save).to be_truthy
         league.reload
         expect(league.name).to eq(name)
         expect(league.divisions).to eq(divisions)
@@ -99,7 +99,7 @@ describe 'RailsAdmin::Adapters::ActiveRecord::AbstractObject', active_record: tr
         expect(object.number).to eq(new_number)
         expect(object.name).to eq(name)
         expect(object.draft).to be_nil
-        expect(object.suspended).to be_false
+        expect(object.suspended).to be_falsey
         expect(object.team).to eq(new_team)
       end
     end
@@ -114,7 +114,7 @@ describe 'RailsAdmin::Adapters::ActiveRecord::AbstractObject', active_record: tr
     end
 
     it 'deletes the record' do
-      expect(Player.exists?(player.id)).to be_false
+      expect(Player.exists?(player.id)).to be_falsey
     end
   end
 

data/spec/rails_admin/adapters/active_record/association_spec.rb

@@ -49,12 +49,12 @@ describe 'RailsAdmin::Adapters::ActiveRecord::Association', active_record: true
   end
 
   it 'lists associations' do
-    expect(@post.associations.collect { |a|a.name.to_s }).to include(*%w[a_r_blog a_r_categories a_r_comments])
+    expect(@post.associations.collect { |a|a.name.to_s }).to include(*%w(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
     # ActiveRecord 4.1 converts has_and_belongs_to_many association to has_many
-    expect((@post.associations + @blog.associations + @user.associations).collect { |a| a.type }.uniq.collect(&:to_s)).to include(*%w[belongs_to has_many has_one])
+    expect((@post.associations + @blog.associations + @user.associations).collect { |a| a.type }.uniq.collect(&:to_s)).to include(*%w(belongs_to has_many has_one))
   end
 
   describe 'belongs_to association' do
@@ -68,9 +68,9 @@ describe 'RailsAdmin::Adapters::ActiveRecord::Association', active_record: true
       expect(subject.foreign_key).to eq :a_r_blog_id
       expect(subject.foreign_type).to be_nil
       expect(subject.as).to be_nil
-      expect(subject.polymorphic?).to be_false
+      expect(subject.polymorphic?).to be_falsey
       expect(subject.inverse_of).to be_nil
-      expect(subject.read_only?).to be_false
+      expect(subject.read_only?).to be_falsey
       expect(subject.nested_options).to be_nil
     end
   end
@@ -86,13 +86,47 @@ describe 'RailsAdmin::Adapters::ActiveRecord::Association', active_record: true
       expect(subject.foreign_key).to eq :ar_blog_id
       expect(subject.foreign_type).to be_nil
       expect(subject.as).to be_nil
-      expect(subject.polymorphic?).to be_false
+      expect(subject.polymorphic?).to be_falsey
       expect(subject.inverse_of).to be_nil
-      expect(subject.read_only?).to be_false
+      expect(subject.read_only?).to be_falsey
       expect(subject.nested_options).to be_nil
     end
   end
 
+  describe 'has_many association' do
+    let(:league) { RailsAdmin::AbstractModel.new(League) }
+
+    context 'for direct has many' do
+      let(:association) { league.associations.detect { |a| a.name == :divisions } }
+
+      it 'returns correct values' do
+        expect(association.type).to eq :has_many
+        expect(association.klass).to eq Division
+        expect(association.read_only?).to be_falsey
+      end
+    end
+
+    context 'for has many through marked as readonly' do
+      let(:association) { league.associations.detect { |a| a.name == :teams } }
+
+      it 'returns correct values' do
+        expect(association.type).to eq :has_many
+        expect(association.klass).to eq Team
+        expect(association.read_only?).to be_truthy
+      end
+    end
+
+    context 'for has many through multiple associations' do
+      let(:association) { league.associations.detect { |a| a.name == :players } }
+
+      it 'returns correct values' do
+        expect(association.type).to eq :has_many
+        expect(association.klass).to eq Player
+        expect(association.read_only?).to be_truthy
+      end
+    end
+  end
+
   describe 'has_and_belongs_to_many association' do
     subject { @post.associations.select { |a| a.name == :a_r_categories }.first }
 
@@ -102,15 +136,15 @@ describe 'RailsAdmin::Adapters::ActiveRecord::Association', active_record: true
       expect(subject.primary_key).to eq :id
       expect(subject.foreign_type).to be_nil
       expect(subject.as).to be_nil
-      expect(subject.polymorphic?).to be_false
+      expect(subject.polymorphic?).to be_falsey
       expect(subject.inverse_of).to be_nil
-      expect(subject.read_only?).to be_false
+      expect(subject.read_only?).to be_falsey
       expect(subject.nested_options).to be_nil
     end
   end
 
   describe 'polymorphic belongs_to association' do
-    before { allow(RailsAdmin::Config).to receive(:models_pool).and_return(%w[ARBlog ARPost ARCategory ARUser ARProfile ARComment]) }
+    before { allow(RailsAdmin::Config).to receive(:models_pool).and_return(%w(ARBlog ARPost ARCategory ARUser ARProfile ARComment)) }
     subject { @comment.associations.select { |a| a.name == :commentable }.first }
 
     it 'returns correct values' do
@@ -121,9 +155,9 @@ describe 'RailsAdmin::Adapters::ActiveRecord::Association', active_record: true
       expect(subject.foreign_key).to eq :commentable_id
       expect(subject.foreign_type).to eq :commentable_type
       expect(subject.as).to be_nil
-      expect(subject.polymorphic?).to be_true
+      expect(subject.polymorphic?).to be_truthy
       expect(subject.inverse_of).to be_nil
-      expect(subject.read_only?).to be_false
+      expect(subject.read_only?).to be_falsey
       expect(subject.nested_options).to be_nil
     end
 
@@ -144,9 +178,9 @@ describe 'RailsAdmin::Adapters::ActiveRecord::Association', active_record: true
       expect(subject.foreign_key).to eq :commentable_id
       expect(subject.foreign_type).to be_nil
       expect(subject.as).to eq :commentable
-      expect(subject.polymorphic?).to be_false
+      expect(subject.polymorphic?).to be_falsey
       expect(subject.inverse_of).to be_nil
-      expect(subject.read_only?).to be_false
+      expect(subject.read_only?).to be_falsey
       expect(subject.nested_options).to be_nil
     end
   end

data/spec/rails_admin/adapters/active_record/property_spec.rb

@@ -9,8 +9,8 @@ describe 'RailsAdmin::Adapters::ActiveRecord::Property', active_record: true do
       expect(subject.pretty_name).to eq 'Name'
       expect(subject.type).to eq :string
       expect(subject.length).to eq 100
-      expect(subject.nullable?).to be_false
-      expect(subject.serial?).to be_false
+      expect(subject.nullable?).to be_falsey
+      expect(subject.serial?).to be_falsey
     end
   end
 
@@ -21,8 +21,8 @@ describe 'RailsAdmin::Adapters::ActiveRecord::Property', active_record: true do
       expect(subject.pretty_name).to eq 'Roles'
       expect(subject.type).to eq :serialized
       expect(subject.length).to eq 255
-      expect(subject.nullable?).to be_true
-      expect(subject.serial?).to be_false
+      expect(subject.nullable?).to be_truthy
+      expect(subject.serial?).to be_falsey
     end
   end
 end

data/spec/rails_admin/adapters/active_record_spec.rb

@@ -65,7 +65,7 @@ describe 'RailsAdmin::Adapters::ActiveRecord', active_record: true do
       end
 
       it 'supports limiting' do
-        expect(@abstract_model.all(limit: 2)).to have(2).items
+        expect(@abstract_model.all(limit: 2).size).to eq(2)
       end
 
       it 'supports retrieval by bulk_ids' do
@@ -127,11 +127,11 @@ describe 'RailsAdmin::Adapters::ActiveRecord', active_record: true do
 
     context 'without configuration' do
       before do
-        Rails.configuration.stub(:database_configuration) { nil }
+        allow(Rails.configuration).to receive(:database_configuration) { nil }
       end
 
       after do
-        Rails.configuration.unstub(:database_configuration)
+        allow(Rails.configuration).to receive(:database_configuration).and_call_original
       end
 
       it 'does not raise error' do
@@ -192,26 +192,26 @@ describe 'RailsAdmin::Adapters::ActiveRecord', active_record: true do
     end
 
     it 'supports boolean type query' do
-      %w[false f 0].each do |value|
+      %w(false f 0).each do |value|
         expect(@abstract_model.send(:build_statement, :field, :boolean, value, nil)).to eq(['(field IS NULL OR field = ?)', false])
       end
-      %w[true t 1].each do |value|
+      %w(true t 1).each do |value|
         expect(@abstract_model.send(:build_statement, :field, :boolean, value, nil)).to eq(['(field = ?)', true])
       end
       expect(@abstract_model.send(:build_statement, :field, :boolean, 'word', nil)).to be_nil
     end
 
     it 'supports integer type query' do
-      expect(@abstract_model.send(:build_statement, :field, :integer, '1'   , nil)).to eq(['(field = ?)', 1])
+      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
-      expect(@abstract_model.send(:build_statement, :field, :integer, '1'   , 'default')).to eq(['(field = ?)', 1])
+      expect(@abstract_model.send(:build_statement, :field, :integer, '1', 'default')).to eq(['(field = ?)', 1])
       expect(@abstract_model.send(:build_statement, :field, :integer, 'word', 'default')).to be_nil
-      expect(@abstract_model.send(:build_statement, :field, :integer, '1'   , 'between')).to eq(['(field = ?)', 1])
+      expect(@abstract_model.send(:build_statement, :field, :integer, '1', 'between')).to eq(['(field = ?)', 1])
       expect(@abstract_model.send(:build_statement, :field, :integer, 'word', 'between')).to be_nil
-      expect(@abstract_model.send(:build_statement, :field, :integer, ['6', ''  , ''], 'default')).to eq(['(field = ?)', 6])
+      expect(@abstract_model.send(:build_statement, :field, :integer, ['6', '', ''], 'default')).to eq(['(field = ?)', 6])
       expect(@abstract_model.send(:build_statement, :field, :integer, ['7', '10', ''], 'default')).to eq(['(field = ?)', 7])
-      expect(@abstract_model.send(:build_statement, :field, :integer, ['8', ''  , '20'], 'default')).to eq(['(field = ?)', 8])
-      expect(@abstract_model.send(:build_statement, :field, :integer, %w[9 10 20], 'default')).to eq(['(field = ?)', 9])
+      expect(@abstract_model.send(:build_statement, :field, :integer, ['8', '', '20'], 'default')).to eq(['(field = ?)', 8])
+      expect(@abstract_model.send(:build_statement, :field, :integer, %w(9 10 20), 'default')).to eq(['(field = ?)', 9])
     end
 
     it 'supports integer type range query' do
@@ -219,52 +219,52 @@ describe 'RailsAdmin::Adapters::ActiveRecord', active_record: true do
       expect(@abstract_model.send(:build_statement, :field, :integer, ['2', '', ''], 'between')).to be_nil
       expect(@abstract_model.send(:build_statement, :field, :integer, ['', '3', ''], 'between')).to eq(['(field >= ?)', 3])
       expect(@abstract_model.send(:build_statement, :field, :integer, ['', '', '5'], 'between')).to eq(['(field <= ?)', 5])
-      expect(@abstract_model.send(:build_statement, :field, :integer, [''  , '10', '20'], 'between')).to eq(['(field BETWEEN ? AND ?)', 10, 20])
-      expect(@abstract_model.send(:build_statement, :field, :integer, %w[15 10 20], 'between')).to eq(['(field BETWEEN ? AND ?)', 10, 20])
+      expect(@abstract_model.send(:build_statement, :field, :integer, ['', '10', '20'], 'between')).to eq(['(field BETWEEN ? AND ?)', 10, 20])
+      expect(@abstract_model.send(:build_statement, :field, :integer, %w(15 10 20), 'between')).to eq(['(field BETWEEN ? AND ?)', 10, 20])
       expect(@abstract_model.send(:build_statement, :field, :integer, ['', 'word1', ''], 'between')).to be_nil
-      expect(@abstract_model.send(:build_statement, :field, :integer, ['', ''     , 'word2'], 'between')).to be_nil
+      expect(@abstract_model.send(:build_statement, :field, :integer, ['', '', 'word2'], 'between')).to be_nil
       expect(@abstract_model.send(:build_statement, :field, :integer, ['', 'word3', 'word4'], 'between')).to be_nil
     end
 
     it 'supports both decimal and float type queries' do
       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
-      expect(@abstract_model.send(:build_statement, :field, :decimal, '1.1'   , 'default')).to eq(['(field = ?)', 1.1])
+      expect(@abstract_model.send(:build_statement, :field, :decimal, '1.1', 'default')).to eq(['(field = ?)', 1.1])
       expect(@abstract_model.send(:build_statement, :field, :decimal, 'word', 'default')).to be_nil
-      expect(@abstract_model.send(:build_statement, :field, :decimal, '1.1'   , 'between')).to eq(['(field = ?)', 1.1])
+      expect(@abstract_model.send(:build_statement, :field, :decimal, '1.1', 'between')).to eq(['(field = ?)', 1.1])
       expect(@abstract_model.send(:build_statement, :field, :decimal, 'word', 'between')).to be_nil
-      expect(@abstract_model.send(:build_statement, :field, :decimal, ['6.1', ''  , ''], 'default')).to eq(['(field = ?)', 6.1])
+      expect(@abstract_model.send(:build_statement, :field, :decimal, ['6.1', '', ''], 'default')).to eq(['(field = ?)', 6.1])
       expect(@abstract_model.send(:build_statement, :field, :decimal, ['7.1', '10.1', ''], 'default')).to eq(['(field = ?)', 7.1])
-      expect(@abstract_model.send(:build_statement, :field, :decimal, ['8.1', ''  , '20.1'], 'default')).to eq(['(field = ?)', 8.1])
+      expect(@abstract_model.send(:build_statement, :field, :decimal, ['8.1', '', '20.1'], 'default')).to eq(['(field = ?)', 8.1])
       expect(@abstract_model.send(:build_statement, :field, :decimal, ['9.1', '10.1', '20.1'], 'default')).to eq(['(field = ?)', 9.1])
       expect(@abstract_model.send(:build_statement, :field, :decimal, ['', '', ''], 'between')).to be_nil
       expect(@abstract_model.send(:build_statement, :field, :decimal, ['2.1', '', ''], 'between')).to be_nil
       expect(@abstract_model.send(:build_statement, :field, :decimal, ['', '3.1', ''], 'between')).to eq(['(field >= ?)', 3.1])
       expect(@abstract_model.send(:build_statement, :field, :decimal, ['', '', '5.1'], 'between')).to eq(['(field <= ?)', 5.1])
-      expect(@abstract_model.send(:build_statement, :field, :decimal, [''  , '10.1', '20.1'], 'between')).to eq(['(field BETWEEN ? AND ?)', 10.1, 20.1])
+      expect(@abstract_model.send(:build_statement, :field, :decimal, ['', '10.1', '20.1'], 'between')).to eq(['(field BETWEEN ? AND ?)', 10.1, 20.1])
       expect(@abstract_model.send(:build_statement, :field, :decimal, ['15.1', '10.1', '20.1'], 'between')).to eq(['(field BETWEEN ? AND ?)', 10.1, 20.1])
       expect(@abstract_model.send(:build_statement, :field, :decimal, ['', 'word1', ''], 'between')).to be_nil
-      expect(@abstract_model.send(:build_statement, :field, :decimal, ['', ''     , 'word2'], 'between')).to be_nil
+      expect(@abstract_model.send(:build_statement, :field, :decimal, ['', '', 'word2'], 'between')).to be_nil
       expect(@abstract_model.send(:build_statement, :field, :decimal, ['', 'word3', 'word4'], 'between')).to be_nil
 
       expect(@abstract_model.send(:build_statement, :field, :float, '1.1', nil)).to eq(['(field = ?)', 1.1])
       expect(@abstract_model.send(:build_statement, :field, :float, 'word', nil)).to be_nil
-      expect(@abstract_model.send(:build_statement, :field, :float, '1.1'   , 'default')).to eq(['(field = ?)', 1.1])
+      expect(@abstract_model.send(:build_statement, :field, :float, '1.1', 'default')).to eq(['(field = ?)', 1.1])
       expect(@abstract_model.send(:build_statement, :field, :float, 'word', 'default')).to be_nil
-      expect(@abstract_model.send(:build_statement, :field, :float, '1.1'   , 'between')).to eq(['(field = ?)', 1.1])
+      expect(@abstract_model.send(:build_statement, :field, :float, '1.1', 'between')).to eq(['(field = ?)', 1.1])
       expect(@abstract_model.send(:build_statement, :field, :float, 'word', 'between')).to be_nil
-      expect(@abstract_model.send(:build_statement, :field, :float, ['6.1', ''  , ''], 'default')).to eq(['(field = ?)', 6.1])
+      expect(@abstract_model.send(:build_statement, :field, :float, ['6.1', '', ''], 'default')).to eq(['(field = ?)', 6.1])
       expect(@abstract_model.send(:build_statement, :field, :float, ['7.1', '10.1', ''], 'default')).to eq(['(field = ?)', 7.1])
-      expect(@abstract_model.send(:build_statement, :field, :float, ['8.1', ''  , '20.1'], 'default')).to eq(['(field = ?)', 8.1])
+      expect(@abstract_model.send(:build_statement, :field, :float, ['8.1', '', '20.1'], 'default')).to eq(['(field = ?)', 8.1])
       expect(@abstract_model.send(:build_statement, :field, :float, ['9.1', '10.1', '20.1'], 'default')).to eq(['(field = ?)', 9.1])
       expect(@abstract_model.send(:build_statement, :field, :float, ['', '', ''], 'between')).to be_nil
       expect(@abstract_model.send(:build_statement, :field, :float, ['2.1', '', ''], 'between')).to be_nil
       expect(@abstract_model.send(:build_statement, :field, :float, ['', '3.1', ''], 'between')).to eq(['(field >= ?)', 3.1])
       expect(@abstract_model.send(:build_statement, :field, :float, ['', '', '5.1'], 'between')).to eq(['(field <= ?)', 5.1])
-      expect(@abstract_model.send(:build_statement, :field, :float, [''  , '10.1', '20.1'], 'between')).to eq(['(field BETWEEN ? AND ?)', 10.1, 20.1])
+      expect(@abstract_model.send(:build_statement, :field, :float, ['', '10.1', '20.1'], 'between')).to eq(['(field BETWEEN ? AND ?)', 10.1, 20.1])
       expect(@abstract_model.send(:build_statement, :field, :float, ['15.1', '10.1', '20.1'], 'between')).to eq(['(field BETWEEN ? AND ?)', 10.1, 20.1])
       expect(@abstract_model.send(:build_statement, :field, :float, ['', 'word1', ''], 'between')).to be_nil
-      expect(@abstract_model.send(:build_statement, :field, :float, ['', ''     , 'word2'], 'between')).to be_nil
+      expect(@abstract_model.send(:build_statement, :field, :float, ['', '', 'word2'], 'between')).to be_nil
       expect(@abstract_model.send(:build_statement, :field, :float, ['', 'word3', 'word4'], 'between')).to be_nil
     end
 

data/spec/rails_admin/adapters/mongoid/association_spec.rb

@@ -75,7 +75,7 @@ describe 'RailsAdmin::Adapters::Mongoid::Association', mongoid: true do
   end
 
   it 'reads correct and know types in [:belongs_to, :has_and_belongs_to_many, :has_many, :has_one]' do
-    expect((@post.associations + @blog.associations + @user.associations).collect { |a| a.type.to_s }.uniq).to match_array %w[belongs_to has_and_belongs_to_many has_many has_one]
+    expect((@post.associations + @blog.associations + @user.associations).collect { |a| a.type.to_s }.uniq).to match_array %w(belongs_to has_and_belongs_to_many has_many has_one)
   end
 
   describe 'belongs_to association' do
@@ -90,9 +90,9 @@ describe 'RailsAdmin::Adapters::Mongoid::Association', mongoid: true do
       expect(subject.foreign_type).to be_nil
       expect(subject.foreign_inverse_of).to be_nil
       expect(subject.as).to be_nil
-      expect(subject.polymorphic?).to be_false
+      expect(subject.polymorphic?).to be_falsey
       expect(subject.inverse_of).to be_nil
-      expect(subject.read_only?).to be_false
+      expect(subject.read_only?).to be_falsey
       expect(subject.nested_options).to be_nil
     end
 
@@ -114,9 +114,9 @@ describe 'RailsAdmin::Adapters::Mongoid::Association', mongoid: true do
       expect(subject.foreign_type).to be_nil
       expect(subject.foreign_inverse_of).to be_nil
       expect(subject.as).to be_nil
-      expect(subject.polymorphic?).to be_false
+      expect(subject.polymorphic?).to be_falsey
       expect(subject.inverse_of).to be_nil
-      expect(subject.read_only?).to be_false
+      expect(subject.read_only?).to be_falsey
       expect(subject.nested_options).to be_nil
     end
   end
@@ -133,15 +133,15 @@ describe 'RailsAdmin::Adapters::Mongoid::Association', mongoid: true do
       expect(subject.foreign_type).to be_nil
       expect(subject.foreign_inverse_of).to be_nil
       expect(subject.as).to be_nil
-      expect(subject.polymorphic?).to be_false
+      expect(subject.polymorphic?).to be_falsey
       expect(subject.inverse_of).to be_nil
-      expect(subject.read_only?).to be_false
+      expect(subject.read_only?).to be_falsey
       expect(subject.nested_options).to be_nil
     end
   end
 
   describe 'polymorphic belongs_to association' do
-    before { allow(RailsAdmin::Config).to receive(:models_pool).and_return(%w[MongoBlog MongoPost MongoCategory MongoUser MongoProfile MongoComment]) }
+    before { allow(RailsAdmin::Config).to receive(:models_pool).and_return(%w(MongoBlog MongoPost MongoCategory MongoUser MongoProfile MongoComment)) }
     subject { @comment.associations.select { |a| a.name == :commentable }.first }
 
     it 'returns correct values' do
@@ -153,15 +153,15 @@ describe 'RailsAdmin::Adapters::Mongoid::Association', mongoid: true do
       expect(subject.foreign_type).to eq :commentable_type
       expect(subject.foreign_inverse_of).to be_nil
       expect(subject.as).to be_nil
-      expect(subject.polymorphic?).to be_true
+      expect(subject.polymorphic?).to be_truthy
       expect(subject.inverse_of).to be_nil
-      expect(subject.read_only?).to be_false
+      expect(subject.read_only?).to be_falsey
       expect(subject.nested_options).to be_nil
     end
   end
 
   describe 'polymorphic inverse has_many association' do
-    before { allow(RailsAdmin::Config).to receive(:models_pool).and_return(%w[MongoBlog MongoPost MongoCategory MongoUser MongoProfile MongoComment]) }
+    before { allow(RailsAdmin::Config).to receive(:models_pool).and_return(%w(MongoBlog MongoPost MongoCategory MongoUser MongoProfile MongoComment)) }
     subject { @blog.associations.select { |a| a.name == :mongo_comments }.first }
 
     it 'returns correct values' do
@@ -173,9 +173,9 @@ describe 'RailsAdmin::Adapters::Mongoid::Association', mongoid: true do
       expect(subject.foreign_type).to be_nil
       expect(subject.foreign_inverse_of).to be_nil
       expect(subject.as).to eq :commentable
-      expect(subject.polymorphic?).to be_false
+      expect(subject.polymorphic?).to be_falsey
       expect(subject.inverse_of).to be_nil
-      expect(subject.read_only?).to be_false
+      expect(subject.read_only?).to be_falsey
       expect(subject.nested_options).to be_nil
     end
 
@@ -197,9 +197,9 @@ describe 'RailsAdmin::Adapters::Mongoid::Association', mongoid: true do
       expect(subject.foreign_type).to be_nil
       expect(subject.foreign_inverse_of).to be_nil
       expect(subject.as).to be_nil
-      expect(subject.polymorphic?).to be_false
+      expect(subject.polymorphic?).to be_falsey
       expect(subject.inverse_of).to be_nil
-      expect(subject.read_only?).to be_false
+      expect(subject.read_only?).to be_falsey
       expect(subject.nested_options).to eq(allow_destroy: false, update_only: false)
     end
   end
@@ -215,9 +215,9 @@ describe 'RailsAdmin::Adapters::Mongoid::Association', mongoid: true do
       expect(subject.foreign_key).to be_nil
       expect(subject.foreign_type).to be_nil
       expect(subject.as).to be_nil
-      expect(subject.polymorphic?).to be_false
+      expect(subject.polymorphic?).to be_falsey
       expect(subject.inverse_of).to be_nil
-      expect(subject.read_only?).to be_false
+      expect(subject.read_only?).to be_falsey
       expect(subject.nested_options).to eq(allow_destroy: false, update_only: false)
     end
 
@@ -249,10 +249,10 @@ describe 'RailsAdmin::Adapters::Mongoid::Association', mongoid: true do
       end
 
       expect(lambda { RailsAdmin::AbstractModel.new(MongoEmbedsOne).associations.first.nested_options }).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"
+                                                                                                                        "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",
       )
       expect(lambda { RailsAdmin::AbstractModel.new(MongoEmbedsMany).associations.first.nested_options }).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"
+                                                                                                                         "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",
       )
       expect(lambda { RailsAdmin::AbstractModel.new(MongoRecursivelyEmbedsOne).associations.first.nested_options }).not_to raise_error
       expect(lambda { RailsAdmin::AbstractModel.new(MongoRecursivelyEmbedsMany).associations.first.nested_options }).not_to raise_error