rails_admin 0.6.1 → 0.6.2

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

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'timecop'
+
+describe 'RailsAdmin::Adapters::ActiveRecord::Property', active_record: true do
+  describe 'string field' do
+    subject { RailsAdmin::AbstractModel.new('Player').properties.detect { |f| f.name == :name } }
+
+    it 'returns correct values' 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
+    end
+  end
+
+  describe 'serialized field' do
+    subject { RailsAdmin::AbstractModel.new('User').properties.detect { |f| f.name == :roles } }
+
+    it 'returns correct values' 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
+    end
+  end
+end

data/spec/rails_admin/adapters/active_record_spec.rb

@@ -7,171 +7,20 @@ describe 'RailsAdmin::Adapters::ActiveRecord', active_record: true do
   end
 
   describe '#associations' do
-    before :all do
-      RailsAdmin::AbstractModel.reset_polymorphic_parents
-
-      class ARBlog < ActiveRecord::Base
-        has_many :a_r_posts
-        has_many :a_r_comments, as: :commentable
-        belongs_to :librarian, polymorphic: true
-      end
-
-      class ARPost < ActiveRecord::Base
-        belongs_to :a_r_blog
-        has_and_belongs_to_many :a_r_categories
-        has_many :a_r_comments, as: :commentable
-      end
-
-      class ARCategory < ActiveRecord::Base
-        has_and_belongs_to_many :a_r_posts
-        belongs_to :librarian, polymorphic: true
-      end
-
-      class ARUser < ActiveRecord::Base
-        has_one :a_r_profile
-        has_many :a_r_categories, as: :librarian
-      end
-
-      class ARProfile < ActiveRecord::Base
-        belongs_to :a_r_user
-        has_many :a_r_blogs, as: :librarian
-      end
-
-      class ARComment < ActiveRecord::Base
-        belongs_to :commentable, polymorphic: true
-      end
-
-      @blog = RailsAdmin::AbstractModel.new(ARBlog)
-      @post = RailsAdmin::AbstractModel.new(ARPost)
-      @category = RailsAdmin::AbstractModel.new(ARCategory)
-      @user = RailsAdmin::AbstractModel.new(ARUser)
-      @profile = RailsAdmin::AbstractModel.new(ARProfile)
-      @comment = RailsAdmin::AbstractModel.new(ARComment)
-    end
-
-    after :all do
-      RailsAdmin::AbstractModel.reset_polymorphic_parents
-    end
-
-    it 'lists associations' do
-      expect(@post.associations.collect { |a|a[:name].to_s }).to match_array %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
-      expect((@post.associations + @blog.associations + @user.associations).collect { |a|a[:type] }.uniq.collect(&:to_s)).to match_array %w(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
-      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
-      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
-      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
-      allow(RailsAdmin::Config).to receive(:models_pool).and_return(%w(ARBlog ARPost ARCategory ARUser ARProfile ARComment))
-      param = @comment.associations.select { |a| a[:name] == :commentable }.first
-      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
-      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
-
-    it 'has correct opposite model lookup for polymorphic associations' do
-      allow(RailsAdmin::Config).to receive(:models_pool).and_return(%w(ARBlog ARPost ARCategory ARUser ARProfile ARComment))
-      expect(@category.associations.detect { |a| a[:name] == :librarian }[:model_proc].call).to eq [ARUser]
-      expect(@blog.associations.detect { |a| a[:name] == :librarian }[:model_proc].call).to eq [ARProfile]
+    it 'returns Association class' do
+      expect(RailsAdmin::AbstractModel.new(Player).associations.first).
+        to be_a_kind_of RailsAdmin::Adapters::ActiveRecord::Association
     end
   end
 
   describe '#properties' do
-    it 'returns parameters of string-type field' do
-      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
-      expect(RailsAdmin::AbstractModel.new('User').properties.detect { |f| f[:name] == :roles }).to eq(:name => :roles, :pretty_name => 'Roles', :length => 255, :nullable? => true, :serial? => false, :type => :serialized)
+    it 'returns Property class' do
+      expect(RailsAdmin::AbstractModel.new(Player).properties.first).
+        to be_a_kind_of RailsAdmin::Adapters::ActiveRecord::Property
     end
   end
 
-  describe 'data access method' do
+  describe 'data access methods' do
     before do
       @players = FactoryGirl.create_list(:player, 3)
       @abstract_model = RailsAdmin::AbstractModel.new('Player')
@@ -252,6 +101,20 @@ describe 'RailsAdmin::Adapters::ActiveRecord', active_record: true do
     it 'makes correct query' do
       expect(@abstract_model.all(query: 'foo')).to match_array @teams[1..2]
     end
+
+    context "when field's searchable_columns is empty" do
+      before do
+        RailsAdmin.config do |c|
+          c.model Team do
+            field :players
+          end
+        end
+      end
+
+      it 'does not break' do
+        expect { @abstract_model.all(query: 'foo') }.not_to raise_error
+      end
+    end
   end
 
   describe '#filter_conditions' do
@@ -262,7 +125,21 @@ describe 'RailsAdmin::Adapters::ActiveRecord', active_record: true do
         collect { |h| FactoryGirl.create :team, h }
     end
 
-    it 'makes conrrect query' do
+    context 'without configuration' do
+      before do
+        Rails.configuration.stub(:database_configuration) { nil }
+      end
+
+      after do
+        Rails.configuration.unstub(:database_configuration)
+      end
+
+      it 'does not raise error' do
+        expect { @abstract_model.all(filters: {'name' => {'0000' => {o: 'like', v: 'foo'}}}) }.to_not raise_error
+      end
+    end
+
+    it 'makes correct query' do
       expect(@abstract_model.all(filters: {'name' => {'0000' => {o: 'like', v: 'foo'}}, 'division' => {'0001' => {o: 'like', v: 'bar'}}}, include: :division)).to eq([@teams[2]])
     end
   end
@@ -315,10 +192,10 @@ 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
@@ -334,7 +211,7 @@ describe 'RailsAdmin::Adapters::ActiveRecord', active_record: true do
       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, %w[9 10 20], 'default')).to eq(['(field = ?)', 9])
     end
 
     it 'supports integer type range query' do
@@ -343,7 +220,7 @@ describe 'RailsAdmin::Adapters::ActiveRecord', active_record: true do
       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, %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, ['', 'word3', 'word4'], 'between')).to be_nil

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

@@ -0,0 +1,278 @@
+require 'spec_helper'
+
+describe 'RailsAdmin::Adapters::Mongoid::Association', mongoid: true do
+  before :all do
+    RailsAdmin::AbstractModel.reset_polymorphic_parents
+
+    class MongoBlog
+      include Mongoid::Document
+      has_many :mongo_posts
+      has_many :mongo_comments, as: :commentable
+      belongs_to :librarian, polymorphic: true
+      field :mongo_blog_id
+    end
+
+    class MongoPost
+      include Mongoid::Document
+      belongs_to :mongo_blog
+      has_and_belongs_to_many :mongo_categories
+      has_many :mongo_comments, as: :commentable
+      embeds_one :mongo_note
+      accepts_nested_attributes_for :mongo_note
+    end
+
+    class MongoCategory
+      include Mongoid::Document
+      has_and_belongs_to_many :mongo_posts
+      belongs_to :librarian, polymorphic: true
+    end
+
+    class MongoUser
+      include Mongoid::Document
+      has_one :mongo_profile
+      has_many :mongo_categories, as: :librarian
+
+      embeds_many :mongo_notes
+      accepts_nested_attributes_for :mongo_notes
+      field :name, type: String
+      field :message, type: String
+      field :short_text, type: String
+
+      validates :short_text, length: {maximum: 255}
+    end
+
+    class MongoProfile
+      include Mongoid::Document
+      belongs_to :mongo_user
+      has_many :mongo_blogs, as: :librarian
+    end
+
+    class MongoComment
+      include Mongoid::Document
+      belongs_to :commentable, polymorphic: true
+    end
+
+    class MongoNote
+      include Mongoid::Document
+      embedded_in :mongo_post
+      embedded_in :mongo_user
+    end
+
+    @blog     = RailsAdmin::AbstractModel.new MongoBlog
+    @post     = RailsAdmin::AbstractModel.new MongoPost
+    @category = RailsAdmin::AbstractModel.new MongoCategory
+    @user     = RailsAdmin::AbstractModel.new MongoUser
+    @profile  = RailsAdmin::AbstractModel.new MongoProfile
+    @comment  = RailsAdmin::AbstractModel.new MongoComment
+  end
+
+  after :all do
+    RailsAdmin::AbstractModel.reset_polymorphic_parents
+  end
+
+  it 'lists associations' do
+    expect(@post.associations.collect { |a| a.name.to_sym }).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
+    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
+    subject { @post.associations.select { |a| a.name == :mongo_blog }.first }
+
+    it 'returns correct values' do
+      expect(subject.pretty_name).to eq 'Mongo blog'
+      expect(subject.type).to eq :belongs_to
+      expect(subject.klass).to eq MongoBlog
+      expect(subject.primary_key).to eq :_id
+      expect(subject.foreign_key).to eq :mongo_blog_id
+      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.inverse_of).to be_nil
+      expect(subject.read_only?).to be_false
+      expect(subject.nested_options).to be_nil
+    end
+
+    it 'distinguishes foreign_key column' do
+      expect(@post.properties.detect { |f| f.name == :mongo_blog_id }.type).to eq(:bson_object_id)
+      expect(@blog.properties.detect { |f| f.name == :mongo_blog_id }.type).to eq(:string)
+    end
+  end
+
+  describe 'has_many association' do
+    subject { @blog.associations.select { |a| a.name == :mongo_posts }.first }
+
+    it 'returns correct values' do
+      expect(subject.pretty_name).to eq 'Mongo posts'
+      expect(subject.type).to eq :has_many
+      expect(subject.klass).to eq MongoPost
+      expect(subject.primary_key).to eq :_id
+      expect(subject.foreign_key).to eq :mongo_blog_id
+      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.inverse_of).to be_nil
+      expect(subject.read_only?).to be_false
+      expect(subject.nested_options).to be_nil
+    end
+  end
+
+  describe 'has_and_belongs_to_many association' do
+    subject { @post.associations.select { |a| a.name == :mongo_categories }.first }
+
+    it 'returns correct values' do
+      expect(subject.pretty_name).to eq 'Mongo categories'
+      expect(subject.type).to eq :has_and_belongs_to_many
+      expect(subject.klass).to eq MongoCategory
+      expect(subject.primary_key).to eq :_id
+      expect(subject.foreign_key).to eq :mongo_category_ids
+      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.inverse_of).to be_nil
+      expect(subject.read_only?).to be_false
+      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]) }
+    subject { @comment.associations.select { |a| a.name == :commentable }.first }
+
+    it 'returns correct values' do
+      expect(subject.pretty_name).to eq 'Commentable'
+      expect(subject.type).to eq :belongs_to
+      expect(subject.klass).to eq [MongoBlog, MongoPost]
+      expect(subject.primary_key).to eq :_id
+      expect(subject.foreign_key).to eq :commentable_id
+      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.inverse_of).to be_nil
+      expect(subject.read_only?).to be_false
+      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]) }
+    subject { @blog.associations.select { |a| a.name == :mongo_comments }.first }
+
+    it 'returns correct values' do
+      expect(subject.pretty_name).to eq 'Mongo comments'
+      expect(subject.type).to eq :has_many
+      expect(subject.klass).to eq MongoComment
+      expect(subject.primary_key).to eq :_id
+      expect(subject.foreign_key).to eq :commentable_id
+      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.inverse_of).to be_nil
+      expect(subject.read_only?).to be_false
+      expect(subject.nested_options).to be_nil
+    end
+
+    it 'looks up correct inverse model' do
+      expect(@category.associations.detect { |a| a.name == :librarian }.klass).to eq [MongoUser]
+      expect(@blog.associations.detect { |a| a.name == :librarian }.klass).to eq [MongoProfile]
+    end
+  end
+
+  describe 'embeds_one association' do
+    subject { @post.associations.select { |a| a.name == :mongo_note }.first }
+
+    it 'returns correct values' do
+      expect(subject.pretty_name).to eq 'Mongo note'
+      expect(subject.type).to eq :has_one
+      expect(subject.klass).to eq MongoNote
+      expect(subject.primary_key).to eq :_id
+      expect(subject.foreign_key).to be_nil
+      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.inverse_of).to be_nil
+      expect(subject.read_only?).to be_false
+      expect(subject.nested_options).to eq(allow_destroy: false, update_only: false)
+    end
+  end
+
+  describe 'embeds_many association' do
+    subject { @user.associations.select { |a| a.name == :mongo_notes }.first }
+
+    it 'returns correct values' do
+      expect(subject.pretty_name).to eq 'Mongo notes'
+      expect(subject.type).to eq :has_many
+      expect(subject.klass).to eq MongoNote
+      expect(subject.primary_key).to eq :_id
+      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.inverse_of).to be_nil
+      expect(subject.read_only?).to be_false
+      expect(subject.nested_options).to eq(allow_destroy: false, update_only: false)
+    end
+
+    it 'raises error when embeds_* is used without accepts_nested_attributes_for' do
+      class MongoEmbedsOne
+        include Mongoid::Document
+        embeds_one :mongo_embedded
+      end
+
+      class MongoEmbedsMany
+        include Mongoid::Document
+        embeds_many :mongo_embeddeds
+      end
+
+      class MongoEmbedded
+        include Mongoid::Document
+        embedded_in :mongo_embeds_one
+        embedded_in :mongo_embeds_many
+      end
+
+      class MongoRecursivelyEmbedsOne
+        include Mongoid::Document
+        recursively_embeds_one
+      end
+
+      class MongoRecursivelyEmbedsMany
+        include Mongoid::Document
+        recursively_embeds_many
+      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"
+      )
+      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"
+      )
+      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
+    end
+
+    it 'works with inherited embeds_many model' do
+      class MongoEmbedsParent
+        include Mongoid::Document
+        embeds_many :mongo_embeddeds
+        accepts_nested_attributes_for :mongo_embeddeds
+      end
+
+      class MongoEmbedded
+        include Mongoid::Document
+        embedded_in :mongo_embeds_many
+      end
+
+      class MongoEmbedsChild < MongoEmbedsParent; end
+
+      expect(lambda { RailsAdmin::AbstractModel.new(MongoEmbedsChild).associations }).not_to raise_error
+    end
+  end
+end