drewda_rails_admin 0.0.1

data/spec/integration/relation_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe 'table relations' do
+
+  before(:each) do
+    @fields = RailsAdmin.config(RelTest).create.fields
+  end
+
+  describe 'column with nullable fk and no model validations' do
+    it 'should be optional' do
+      @fields.find{ |f| f.name == :league }.required?.should == false
+    end
+  end
+
+  describe 'column with non-nullable fk and no model validations' do
+    it 'should not be required' do
+      @fields.find{ |f| f.name == :division }.required?.should == false
+    end
+  end
+
+  describe 'column with nullable fk and a numericality model validation' do
+    it 'should be required' do
+      @fields.find{ |f| f.name == :player }.required?.should == true
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,86 @@
+# Configure Rails Envinronment
+ENV["RAILS_ENV"] = "test"
+ENV['SKIP_RAILS_ADMIN_INITIALIZER'] = 'true'
+
+if ENV['INVOKE_SIMPLECOV']
+  require 'simplecov'
+  SimpleCov.start 'rails'
+end
+
+require File.expand_path('../dummy_app/config/environment', __FILE__)
+
+require 'rspec/rails'
+require 'factory_girl'
+require 'factories'
+require 'database_helpers'
+require 'support/tableless'
+
+ActionMailer::Base.delivery_method = :test
+ActionMailer::Base.perform_deliveries = true
+ActionMailer::Base.default_url_options[:host] = "example.com"
+
+Rails.backtrace_cleaner.remove_silencers!
+
+include DatabaseHelpers
+drop_all_tables
+migrate_database
+ENV['SKIP_RAILS_ADMIN_INITIALIZER'] = 'false'
+
+# Don't need passwords in test DB to be secure, but we would like 'em to be
+# fast -- and the stretches mechanism is intended to make passwords
+# computationally expensive.
+module Devise
+  module Models
+    module DatabaseAuthenticatable
+      protected
+
+      def password_digest(password)
+        password
+      end
+    end
+  end
+end
+
+Devise.setup do |config|
+  config.stretches = 0
+end
+
+RSpec.configure do |config|
+  require 'rspec/expectations'
+
+  config.include RSpec::Matchers
+  config.include DatabaseHelpers
+  config.include RailsAdmin::Engine.routes.url_helpers
+
+  config.include Warden::Test::Helpers
+
+  config.before(:each) do
+    RailsAdmin::Config.reset
+    RailsAdmin::AbstractModel.reset
+    RailsAdmin::Config.excluded_models = [RelTest, FieldTest, Category]
+    RailsAdmin::Config.audit_with :history
+    Category.delete_all
+    Division.delete_all
+    Draft.delete_all
+    Fan.delete_all
+    League.delete_all
+    Player.delete_all
+    Team.delete_all
+    User.delete_all
+    FieldTest.delete_all
+    Author.delete_all
+    Article.delete_all
+    MongoidFieldTest.delete_all
+    Tag.delete_all
+    login_as User.create(
+      :email => "username@example.com",
+      :password => "password"
+    )
+  end
+
+  config.after(:each) do
+    Warden.test_reset!
+  end
+
+  config.seed = ENV['SEED'] if ENV['SEED']
+end

data/spec/support/tableless.rb

@@ -0,0 +1,27 @@
+class Tableless < ActiveRecord::Base
+  def self.columns
+    @columns ||= [];
+  end
+
+  def self.column(name, sql_type = nil, default = nil, null = true)
+    columns << ActiveRecord::ConnectionAdapters::Column.new(name.to_s, default,
+      sql_type.to_s, null)
+  end
+
+  def self.columns_hash
+    @columns_hash ||= Hash[columns.map { |column| [column.name, column] }]
+  end
+
+  def self.column_names
+    @column_names ||= columns.map { |column| column.name }
+  end
+
+  def self.column_defaults
+    @column_defaults ||= columns.map { |column| [column.name, nil] }.inject({}) { |m, e| m[e[0]] = e[1]; m }
+  end
+
+  # Override the save method to prevent exceptions.
+  def save(validate = true)
+    validate ? valid? : true
+  end
+end

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

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+describe "AbstractObject" do
+  describe "proxy" do
+    let(:object) { mock("object") }
+    let(:abstract_object) { RailsAdmin::Adapters::ActiveRecord::AbstractObject.new(object) }
+
+    it "should act like a proxy" do
+      object.should_receive(:method_call)
+      abstract_object.method_call
+    end
+  end
+
+  describe "create" do
+    let(:player) { Player.new }
+    let(:object) { RailsAdmin::Adapters::ActiveRecord::AbstractObject.new player }
+    let(:name) { "Stefan Kiszonka" }
+    let(:number) { 87 }
+    let(:position) { "Fifth baseman" }
+    let(:suspended) { true }
+
+    describe "a record without associations" do
+      before do
+        object.set_attributes({ :name => name, :number => number, :position => position, :suspended => suspended, :team_id => nil })
+      end
+
+      it "should create a Player with given attributes" do
+        object.save.should be_true
+
+        player.reload
+        player.name.should == name
+        player.number.should == number
+        player.position.should == position
+        player.suspended.should == false # protected
+        player.draft.should == nil
+        player.team.should == nil
+      end
+    end
+
+    describe "a record with protected attributes and has_one association" do
+      let(:draft) { Factory :draft }
+
+      before do
+        object.set_attributes({ :name => name, :number => number, :position => position, :suspended => suspended, :team_id => nil, :draft_id => draft.id })
+      end
+
+      it "should create a Player with given attributes" do
+        object.save.should be_true
+
+        player.reload
+        player.name.should == name
+        player.number.should == number
+        player.position.should == position
+        player.suspended.should == false # protected
+        player.draft.should == draft.reload
+        player.team.should == nil
+      end
+    end
+
+    describe "a record with has_many associations" do
+      let(:league) { League.new }
+      let(:object) { RailsAdmin::Adapters::ActiveRecord::AbstractObject.new league }
+      let(:name) { "Awesome League" }
+      let(:teams) { [Factory(:team)] }
+      let(:divisions) { [Division.create!(:name => 'div 1', :league => League.create!(:name => 'north')), Division.create!(:name => 'div 2', :league => League.create!(:name => 'south'))] }
+
+      before do
+        object.set_attributes({ :name  => name, :division_ids => divisions.map(&:id) })
+      end
+
+      it "should create a League with given attributes and associations" do
+        object.save.should be_true
+        league.reload
+        league.name.should == name
+        league.divisions.should == divisions
+      end
+    end
+  end
+
+  describe "update" do
+    describe "a record with protected attributes and has_one association" do
+      let(:name) { "Stefan Koza" }
+      let(:suspended) { true }
+      let(:player) { Factory :player, :suspended => true, :name => name, :draft => Factory(:draft) }
+      let(:object) { RailsAdmin::Adapters::ActiveRecord::AbstractObject.new player }
+      let(:new_team) { Factory :team }
+      let(:new_suspended) { false }
+      let(:new_draft) { nil }
+      let(:new_number) { player.number + 29 }
+
+      before do
+        object.set_attributes({ :number => new_number, :team_id => new_team.id, :suspended => new_suspended, :draft_id => new_draft })
+        object.save
+      end
+
+      it "should update a record and associations" do
+        object.reload
+        object.number.should == new_number
+        object.name.should == name
+        object.draft.should == nil
+        object.suspended.should == true # protected
+        object.team.should == new_team
+      end
+    end
+  end
+
+  describe "destroy" do
+    let(:player) { Factory :player }
+    let(:object) { RailsAdmin::Adapters::ActiveRecord::AbstractObject.new player }
+
+    before do
+      object.destroy
+    end
+
+    it "should delete the record" do
+      Player.exists?(player.id).should == false
+    end
+  end
+
+  describe "object_label_method" do
+    it 'should be configurable' do
+      RailsAdmin.config League do
+        object_label_method { :custom_name }
+      end
+
+      @league = FactoryGirl.create :league
+
+      RailsAdmin.config('League').with(:object => @league).object_label.should == "League '#{@league.name}'"
+    end
+  end
+end

data/spec/unit/adapters/active_record_spec.rb

@@ -0,0 +1,373 @@
+require 'spec_helper'
+require 'timecop'
+require 'rails_admin/adapters/active_record'
+
+
+describe RailsAdmin::Adapters::ActiveRecord do
+  before do
+    @like = ::ActiveRecord::Base.configurations[Rails.env]['adapter'] == "postgresql" ? 'ILIKE' : 'LIKE'
+  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
+      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
+      end
+
+      class ARUser < ActiveRecord::Base
+        has_one :a_r_profile
+      end
+
+      class ARProfile < ActiveRecord::Base
+        belongs_to :a_r_user
+      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
+      @post.associations.map{|a|a[:name].to_s}.sort.should == ['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).sort.should == ['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
+    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
+    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
+    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]
+    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
+    end
+  end
+  
+
+  describe "#properties" do
+    before do
+      @abstract_model = RailsAdmin::AbstractModel.new('Player')
+    end
+
+    it "returns parameters of string-type field" do
+      @abstract_model.properties.select{|f| f[:name] == :name}.should ==
+        [{:name => :name, :pretty_name => "Name", :type => :string, :length => 100, :nullable? => false, :serial? => false}]
+    end
+  end
+
+  describe "data access method" do
+    before do
+      @players = FactoryGirl.create_list(:player, 3)
+      @abstract_model = RailsAdmin::AbstractModel.new('Player')
+    end
+
+    it "#new returns instance of AbstractObject" do
+      @abstract_model.new.object.should be_instance_of(Player)
+    end
+
+    it "#get returns instance of AbstractObject" do
+      @abstract_model.get(@players.first.id).object.should == @players.first
+    end
+
+    it "#get returns nil when id does not exist" do
+      @abstract_model.get('abc').should be_nil
+    end
+
+    it "#first returns first item" do
+      @abstract_model.first.should == @players.first
+    end
+
+    it "#count returns count of items" do
+      @abstract_model.count.should == @players.count
+    end
+
+    it "#destroy destroys multiple items" do
+      @abstract_model.destroy(@players[0..1])
+      Player.all.should == @players[2..2]
+    end
+
+    describe "#all" do
+      it "works without options" do
+        @abstract_model.all.sort.should == @players.sort
+      end
+
+      it "supports eager loading" do
+        @abstract_model.all(:include => :team).includes_values.should == [:team]
+      end
+
+      it "supports limiting" do
+        @abstract_model.all(:limit => 2).count.should == 2
+      end
+
+      it "supports retrieval by bulk_ids" do
+        @abstract_model.all(:bulk_ids => @players[0..1].map{|player| player.id }).
+          sort.should == @players[0..1].sort
+      end
+
+      it "supports pagination" do
+        @abstract_model.all(:page => 2, :per => 1).should == @players[1..1]
+      end
+
+      it "supports ordering" do
+        @abstract_model.all(:sort => "id", :sort_reverse => true).should == @players.sort
+      end
+
+      it "supports querying" do
+        @abstract_model.all(:query => @players[1].name).should == @players[1..1]
+      end
+
+      it "supports filtering" do
+        @abstract_model.all(:filters => {"name" => {"0000" => {:o=>"is", :v=>@players[1].name}}}).should == @players[1..1]
+      end
+    end
+  end
+
+  describe "#query_conditions" do
+    before do
+      @abstract_model = RailsAdmin::AbstractModel.new('Team')
+      @teams = [{}, {:name=>'somewhere foos'}, {:manager=>'foo junior'}].
+        map{|h| FactoryGirl.create :team, h}
+    end
+
+    it "makes conrrect query" do
+      @abstract_model.all(:query => "foo").sort.should == @teams[1..2]
+    end
+  end
+
+  describe "#filter_conditions" 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'}].
+        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"}}},
+        :include => :division
+      ).should == [@teams[2]]
+    end
+  end
+
+  describe "#build_statement" do
+    before do
+      @abstract_model = RailsAdmin::AbstractModel.new('FieldTest')
+    end
+
+    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
+      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 = '')"]
+      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 != '')"]
+      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)"]
+      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)"]
+      end
+    end
+
+    it "supports '_empty' operator" do
+      [["_empty", ""], ["", "_empty"]].each do |value, operator|
+        @abstract_model.send(:build_statement, :name, :string, value, operator).should == ["(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 != '')"]
+      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]
+      end
+      ['true', 't', '1'].each do |value|
+        @abstract_model.send(:build_statement, :field, :boolean, value, nil).should == ["(field = ?)", true]
+      end
+      @abstract_model.send(:build_statement, :field, :boolean, 'word', nil).should 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
+    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"]
+    end
+
+    context 'filters on dates' 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')
+
+        FieldTest.create!(:date_field => Date.strptime("01/01/2012", date_format))
+        FieldTest.create!(:date_field => Date.strptime("01/02/2012", date_format))
+        FieldTest.create!(:date_field => Date.strptime("01/03/2012", date_format))
+        FieldTest.create!(:date_field => Date.strptime("01/04/2012", date_format))
+        @abstract_model.all(:filters => { "date_field" => { "1" => { :v => ["", "01/02/2012", "01/03/2012"], :o => 'between' } } } ).count.should == 2
+        @abstract_model.all(:filters => { "date_field" => { "1" => { :v => ["", "01/02/2012", "01/02/2012"], :o => 'between' } } } ).count.should == 1
+        @abstract_model.all(:filters => { "date_field" => { "1" => { :v => ["", "01/03/2012", ""], :o => 'between' } } } ).count.should == 2
+        @abstract_model.all(:filters => { "date_field" => { "1" => { :v => ["", "", "01/02/2012"], :o => 'between' } } } ).count.should == 2
+        @abstract_model.all(:filters => { "date_field" => { "1" => { :v => ["01/02/2012"], :o => 'default' } } } ).count.should == 1
+
+      end
+    end
+
+    it "supports enum type query" do
+      @abstract_model.send(:build_statement, :field, :enum, "1", nil).should == ["(field IN (?))", ["1"]]
+    end
+  end
+
+  describe "model attribute method" do
+    before do
+      @abstract_model = RailsAdmin::AbstractModel.new('Player')
+    end
+
+    it "#scoped returns relation object" do
+      @abstract_model.scoped.should be_instance_of(ActiveRecord::Relation)
+    end
+
+    it "#table_name works" do
+      @abstract_model.table_name.should == 'players'
+    end
+
+    it "#serialized_attributes works" do
+      RailsAdmin::AbstractModel.new('User').serialized_attributes.should == ["roles"]
+    end
+  end
+end