upstream-rails_admin 1.0.2

data/spec/integration/relation_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe 'table relations' do
+
+  before(:each) do
+    class RelTest < Tableless
+      column :league_id, :integer
+      column :division_id, :integer, nil, false
+      column :player_id, :integer
+      belongs_to :league
+      belongs_to :division
+      belongs_to :player
+      validates_numericality_of(:player_id, :only_integer => true)
+    end
+    @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/orm/active_record.rb

@@ -0,0 +1,42 @@
+require 'rails_admin/extensions/history/history'
+require 'rails_admin/adapters/active_record'
+
+DatabaseCleaner.strategy = :transaction
+
+ActiveRecord::Base.connection.tables.each do |table|
+  ActiveRecord::Base.connection.drop_table(table)
+end
+
+silence_stream(STDOUT) do
+  ActiveRecord::Migrator.migrate File.expand_path('../../dummy_app/db/migrate/', __FILE__)
+end
+
+class Tableless < ActiveRecord::Base
+  class <<self
+    def columns
+      @columns ||= [];
+    end
+
+    def 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 columns_hash
+      @columns_hash ||= Hash[columns.map { |column| [column.name, column] }]
+    end
+
+    def column_names
+      @column_names ||= columns.map { |column| column.name }
+    end
+
+    def column_defaults
+      @column_defaults ||= columns.map { |column| [column.name, nil] }.inject({}) { |m, e| m[e[0]] = e[1]; m }
+    end
+  end
+
+  # Override the save method to prevent exceptions.
+  def save(validate = true)
+    validate ? valid? : true
+  end
+end

data/spec/orm/mongoid.rb

@@ -0,0 +1,19 @@
+require 'rails_admin/adapters/mongoid'
+
+class Tableless
+  include Mongoid::Document
+
+  class <<self
+    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
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,79 @@
+# Configure Rails Envinronment
+ENV["RAILS_ENV"] = "test"
+ENV['SKIP_RAILS_ADMIN_INITIALIZER'] = 'true'
+CI_ORM = (ENV['CI_ORM'] || :active_record).to_sym
+CI_TARGET_ORMS = [:active_record, :mongoid]
+PK_COLUMN = {:active_record=>:id, :mongoid=>:_id}[CI_ORM]
+
+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_cleaner'
+require "orm/#{CI_ORM}"
+
+ActionMailer::Base.delivery_method = :test
+ActionMailer::Base.perform_deliveries = true
+ActionMailer::Base.default_url_options[:host] = "example.com"
+
+Rails.backtrace_cleaner.remove_silencers!
+
+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 RailsAdmin::Engine.routes.url_helpers
+
+  config.include Warden::Test::Helpers
+
+  config.before(:each) do
+    DatabaseCleaner.start
+    RailsAdmin::Config.reset
+    RailsAdmin::AbstractModel.reset
+    RailsAdmin::Config.audit_with(:history) if CI_ORM == :active_record
+    login_as User.create(
+      :email => "username@example.com",
+      :password => "password"
+    )
+  end
+
+  config.after(:each) do
+    Warden.test_reset!
+    DatabaseCleaner.clean
+  end
+
+  CI_TARGET_ORMS.each do |orm|
+    if orm == CI_ORM
+      config.filter_run_excluding "skip_#{orm}".to_sym => true
+    else
+      config.filter_run_excluding orm => true
+    end
+  end
+end

data/spec/unit/abstract_model_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe RailsAdmin::AbstractModel do
+  describe 'filters' do
+    before do
+      @abstract_model = RailsAdmin::AbstractModel.new('FieldTest')
+    end
+
+    context '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')
+
+        FactoryGirl.create(:field_test, :date_field => Date.strptime("01/01/2012", date_format))
+        FactoryGirl.create(:field_test, :date_field => Date.strptime("01/02/2012", date_format))
+        FactoryGirl.create(:field_test, :date_field => Date.strptime("01/03/2012", date_format))
+        FactoryGirl.create(:field_test, :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
+
+    context 'on datetimes' do
+      it 'lists elements within outbound limits' do
+        FactoryGirl.create(:field_test, :datetime_field => Time.local(2012, 1, 1, 23, 59, 59))
+        FactoryGirl.create(:field_test, :datetime_field => Time.local(2012, 1, 2, 0, 0, 0))
+        FactoryGirl.create(:field_test, :datetime_field => Time.local(2012, 1, 3, 23, 59, 59))
+        if defined?(Mongoid) && Mongoid::VERSION >= '3.0.0'
+          # TODO: Mongoid 3.0.0 mysteriously expands the range of inclusion slightly...
+          FactoryGirl.create(:field_test, :datetime_field => Time.local(2012, 1, 4, 0, 0, 1))
+        else
+          FactoryGirl.create(:field_test, :datetime_field => Time.local(2012, 1, 4, 0, 0, 0))
+        end
+        @abstract_model.all(:filters => { "datetime_field" => { "1" => { :v => ["", "01/02/2012", "01/03/2012"], :o => 'between' } } } ).count.should == 2
+        @abstract_model.all(:filters => { "datetime_field" => { "1" => { :v => ["", "01/02/2012", "01/02/2012"], :o => 'between' } } } ).count.should == 1
+        @abstract_model.all(:filters => { "datetime_field" => { "1" => { :v => ["", "01/03/2012", ""], :o => 'between' } } } ).count.should == 2
+        @abstract_model.all(:filters => { "datetime_field" => { "1" => { :v => ["", "", "01/02/2012"], :o => 'between' } } } ).count.should == 2
+        @abstract_model.all(:filters => { "datetime_field" => { "1" => { :v => ["01/02/2012"], :o => 'default' } } } ).count.should == 1
+      end
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+describe "AbstractObject", :active_record => true 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) { FactoryGirl.create(:draft) }
+      let(:number) { draft.player.number + 1 } # to avoid collision
+
+      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) { [FactoryGirl.create(: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) { FactoryGirl.create(:player, :suspended => true, :name => name, :draft => FactoryGirl.create(:draft)) }
+      let(:object) { RailsAdmin::Adapters::ActiveRecord::AbstractObject.new player }
+      let(:new_team) { FactoryGirl.create(: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) { FactoryGirl.create(: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'
+
+describe 'RailsAdmin::Adapters::ActiveRecord', :active_record => true 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}.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).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
+
+    it "#where returns filtered results" do
+      @abstract_model.where(:name => @players.first.name).should == [@players.first]
+    end
+
+    describe "#all" do
+      it "works without options" do
+        @abstract_model.all.should =~ @players
+      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(&:id)).should =~ @players[0..1]
+      end
+
+      it "supports pagination" do
+        @abstract_model.all(:sort => "id", :page => 2, :per => 1).should == @players[1..1]
+        @abstract_model.all(:sort => "id", :page => 1, :per => 2).should == @players[1..2].reverse
+      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").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
+
+
+    it 'supports date type query' do
+      @abstract_model.send(:filter_conditions, { "date_field" => { "1" => { :v => ["", "01/02/2012", "01/03/2012"], :o => 'between' } } }).should == ["((field_tests.date_field BETWEEN ? AND ?))", Date.new(2012,1,2), Date.new(2012,1,3)]
+      @abstract_model.send(:filter_conditions, { "date_field" => { "1" => { :v => ["", "01/03/2012", ""], :o => 'between' } } } ).should == ["((field_tests.date_field >= ?))", Date.new(2012,1,3)]
+      @abstract_model.send(:filter_conditions, { "date_field" => { "1" => { :v => ["", "", "01/02/2012"], :o => 'between' } } } ).should == ["((field_tests.date_field <= ?))", Date.new(2012,1,2)]
+      @abstract_model.send(:filter_conditions, { "date_field" => { "1" => { :v => ["01/02/2012"], :o => 'default' } } } ).should == ["((field_tests.date_field BETWEEN ? AND ?))", Date.new(2012,1,2), Date.new(2012,1,2)]
+    end
+
+    it 'supports datetime type query' do
+      @abstract_model.send(:filter_conditions, { "datetime_field" => { "1" => { :v => ["", "01/02/2012", "01/03/2012"], :o => 'between' } } } ).should == ["((field_tests.datetime_field BETWEEN ? AND ?))", Time.local(2012,1,2), Time.local(2012,1,3).end_of_day]
+      @abstract_model.send(:filter_conditions, { "datetime_field" => { "1" => { :v => ["", "01/03/2012", ""], :o => 'between' } } } ).should == ["((field_tests.datetime_field >= ?))", Time.local(2012,1,3)]
+      @abstract_model.send(:filter_conditions, { "datetime_field" => { "1" => { :v => ["", "", "01/02/2012"], :o => 'between' } } } ).should == ["((field_tests.datetime_field <= ?))", Time.local(2012,1,2).end_of_day]
+      @abstract_model.send(:filter_conditions, { "datetime_field" => { "1" => { :v => ["01/02/2012"], :o => 'default' } } } ).should == ["((field_tests.datetime_field BETWEEN ? AND ?))", Time.local(2012,1,2), Time.local(2012,1,2).end_of_day]
+    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