rails_admin-lbgraham 0.4.2

data/spec/integration/history/rails_admin_history_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe "RailsAdmin History", :active_record => true do
+  describe "model history fetch" do
+    before :each do
+      RailsAdmin::History.delete_all
+      @model = RailsAdmin::AbstractModel.new("Player")
+      player = FactoryGirl.create :player
+      30.times do |i|
+        player.number = i
+        RailsAdmin::History.create_history_item "change #{i}", player, @model, nil
+      end
+    end
+
+    it "fetches on page of history" do
+      histories = RailsAdmin::History.history_for_model @model, nil, false, false, false, nil, 20
+      expect(histories.total_count).to eq(30)
+      expect(histories.count).to eq(20)
+    end
+
+    it "respects RailsAdmin::Config.default_items_per_page" do
+      RailsAdmin.config.default_items_per_page = 15
+      histories = RailsAdmin::History.history_for_model @model, nil, false, false, false, nil
+      expect(histories.total_count).to eq(30)
+      expect(histories.count).to eq(15)
+    end
+
+    context "with Kaminari" do
+      before do
+        Kaminari.config.page_method_name = :per_page_kaminari
+        @paged = RailsAdmin::History.page(1)
+      end
+
+      after do
+        Kaminari.config.page_method_name = :page
+      end
+
+      it "supports pagination when Kaminari's page_method_name is customized" do
+        RailsAdmin::History.should_receive(:per_page_kaminari).twice.and_return(@paged)
+        RailsAdmin::History.history_for_model @model, nil, false, false, false, nil
+        RailsAdmin::History.history_for_object @model, Player.first, nil, false, false, false, nil
+      end
+    end
+
+    context "GET admin/history/@model" do
+      before :each do
+        RailsAdmin.config do |c|
+          c.audit_with :history
+        end
+
+        visit history_index_path(@model)
+      end
+
+      # https://github.com/sferik/rails_admin/issues/362
+      # test that no link uses the "wildcard route" with the history
+      # controller and for_model method
+      it "does not use the 'wildcard route'" do
+        expect(page).to have_selector("a[href*='all=true']") # make sure we're fully testing pagination
+        expect(page).to have_no_selector("a[href^='/rails_admin/history/for_model']")
+      end
+
+      context "with a lot of histories" do
+        before :each do
+          player = Player.create(:team_id => -1, :number => -1, :name => "Player 1")
+          101.times do |i|
+            player.number = i
+            RailsAdmin::History.create_history_item "change #{i}", player, @model, nil
+          end
+        end
+
+        it "gets latest ones" do
+          expect(RailsAdmin::History.latest.count).to eq(100)
+        end
+
+        it "gets latest ones orderly" do
+          latest = RailsAdmin::History.latest
+          expect(latest.first.message).to eq("change 100")
+          expect(latest.last.message).to eq("change 1")
+        end
+
+        it "renders a XHR request successfully" do
+          xhr :get, history_index_path(@model, :page => 2)
+        end
+      end
+    end
+  end
+
+end

data/spec/integration/rails_admin_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+
+describe RailsAdmin do
+
+  subject { page }
+
+  describe "authentication" do
+    it "is disableable" do
+      logout
+      RailsAdmin.config do |config|
+        config.included_models = []
+        config.authenticate_with {}
+      end
+      visit dashboard_path
+    end
+  end
+
+  # A common mistake for translators is to forget to change the YAML file's
+  # root key from en to their own locale (as people tend to use the English
+  # file as template for a new translation).
+  describe "localization" do
+    it "defaults to English" do
+      RailsAdmin.config.included_models = []
+      visit dashboard_path
+
+      should have_content("Site administration")
+      should have_content("Dashboard")
+    end
+  end
+
+  describe "html head" do
+    before { visit dashboard_path }
+
+    # Note: the [href^="/asset... syntax matches the start of a value. The reason
+    # we just do that is to avoid being confused by rails' asset_ids.
+    it "loads stylesheets in header" do
+      should have_selector('head link[href^="/assets/rails_admin/rails_admin.css"]')
+    end
+
+    it "loads javascript files in body" do
+      should have_selector('head script[src^="/assets/rails_admin/rails_admin.js"]')
+    end
+  end
+
+  describe "hidden fields with default values" do
+
+    before (:each) do
+      RailsAdmin.config Player do
+        include_all_fields
+        edit do
+          field :name, :hidden do
+            default_value do
+              bindings[:view]._current_user.email
+            end
+          end
+        end
+      end
+    end
+
+    it "shows up with default value, hidden" do
+      visit new_path(:model_name => "player")
+      should have_selector("#player_name[type=hidden][value='username@example.com']")
+      should_not have_selector("#player_name[type=hidden][value='toto@example.com']")
+    end
+
+    it "does not show label" do
+      should_not have_selector("label", :text => "Name")
+    end
+
+    it "does not show help block" do
+      should_not have_xpath("id('player_name')/../p[@class='help-block']")
+    end
+  end
+
+  describe "_current_user" do # https://github.com/sferik/rails_admin/issues/549
+
+    it "is accessible from the list view" do
+      RailsAdmin.config Player do
+        list do
+          field :name do
+            visible do
+              bindings[:view]._current_user.email == 'username@example.com'
+            end
+          end
+
+          field :team do
+            visible do
+              bindings[:view]._current_user.email == 'foo@example.com'
+            end
+          end
+        end
+      end
+
+      visit index_path(:model_name => "player")
+      should have_selector(".header.name_field")
+      should_not have_selector(".header.team_field")
+    end
+  end
+
+  describe "polymorphic associations" do
+    before :each do
+      @team = FactoryGirl.create :team
+      @comment = FactoryGirl.create :comment, :commentable => @team
+    end
+
+    it "works like belongs to associations in the list view" do
+      visit index_path(:model_name => "comment")
+
+      should have_content(@team.name)
+    end
+
+    it "is editable" do
+      visit edit_path(:model_name => "comment", :id => @comment.id)
+
+      should have_selector("select#comment_commentable_type")
+      should have_selector("select#comment_commentable_id")
+    end
+
+    it "is visible in the owning end" do
+      visit edit_path(:model_name => "team", :id => @team.id)
+
+      should have_selector("select#team_comment_ids")
+    end
+  end
+
+  describe "secondary navigation" do
+    it "has Gravatar image" do
+      visit dashboard_path
+      should have_selector("ul.nav.pull-right li img")
+    end
+
+    it "does not show Gravatar when user doesn't have email method" do
+      User.any_instance.stub(:respond_to?).with(:email).and_return(false)
+      visit dashboard_path
+      should_not have_selector("ul.nav.pull-right li img")
+    end
+
+    it "does not cause error when email is nil" do
+      User.any_instance.stub(:email).and_return(nil)
+      visit dashboard_path
+      should have_selector("body.rails_admin")
+    end
+
+    it "shows a log out link" do
+      visit dashboard_path
+      click_link "Log out"
+      should have_content("Sign in")
+    end
+  end
+end

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 "is optional" do
+      expect(@fields.find{ |f| f.name == :league }.required?).to be_false
+    end
+  end
+
+  describe "column with non-nullable fk and no model validations" do
+    it "is not required" do
+      expect(@fields.find{ |f| f.name == :division }.required?).to be_false
+    end
+  end
+
+  describe "column with nullable fk and a numericality model validation" do
+    it "is required" do
+      expect(@fields.find{ |f| f.name == :player }.required?).to be_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,21 @@
+require 'rails_admin/adapters/mongoid'
+
+Paperclip.logger = Logger.new(nil)
+
+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/rails_admin/abstract_model_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe RailsAdmin::AbstractModel do
+
+  describe "#to_s" do
+    it 'returns model\'s name' do
+      expect(RailsAdmin::AbstractModel.new(Cms::BasicPage).to_s).to eq Cms::BasicPage.to_s
+    end
+  end
+
+  describe "filters" do
+    before do
+      @abstract_model = RailsAdmin::AbstractModel.new('FieldTest')
+    end
+
+    context "ActiveModel::ForbiddenAttributesProtection" do
+      it "is present" do
+        @abstract_model.model.ancestors.map(&:to_s).include?('ActiveModel::ForbiddenAttributesProtection')
+      end
+    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))
+        expect(@abstract_model.all(:filters => { "date_field" => { "1" => { :v => ["", "01/02/2012", "01/03/2012"], :o => 'between' } } } ).count).to eq(2)
+        expect(@abstract_model.all(:filters => { "date_field" => { "1" => { :v => ["", "01/02/2012", "01/02/2012"], :o => 'between' } } } ).count).to eq(1)
+        expect(@abstract_model.all(:filters => { "date_field" => { "1" => { :v => ["", "01/03/2012", ""], :o => 'between' } } } ).count).to eq(2)
+        expect(@abstract_model.all(:filters => { "date_field" => { "1" => { :v => ["", "", "01/02/2012"], :o => 'between' } } } ).count).to eq(2)
+        expect(@abstract_model.all(:filters => { "date_field" => { "1" => { :v => ["01/02/2012"], :o => 'default' } } } ).count).to eq(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
+        expect(@abstract_model.all(:filters => { "datetime_field" => { "1" => { :v => ["", "01/02/2012", "01/03/2012"], :o => 'between' } } } ).count).to eq(2)
+        expect(@abstract_model.all(:filters => { "datetime_field" => { "1" => { :v => ["", "01/02/2012", "01/02/2012"], :o => 'between' } } } ).count).to eq(1)
+        expect(@abstract_model.all(:filters => { "datetime_field" => { "1" => { :v => ["", "01/03/2012", ""], :o => 'between' } } } ).count).to eq(2)
+        expect(@abstract_model.all(:filters => { "datetime_field" => { "1" => { :v => ["", "", "01/02/2012"], :o => 'between' } } } ).count).to eq(2)
+        expect(@abstract_model.all(:filters => { "datetime_field" => { "1" => { :v => ["01/02/2012"], :o => 'default' } } } ).count).to eq(1)
+      end
+    end
+  end
+
+  context "with Kaminari" do
+    before do
+      Kaminari.config.page_method_name = :per_page_kaminari
+      @abstract_model = RailsAdmin::AbstractModel.new('Player')
+      @paged = Player.page(1)
+    end
+
+    after do
+      Kaminari.config.page_method_name = :page
+    end
+
+    it "supports pagination when Kaminari's page_method_name is customized" do
+      Player.should_receive(:per_page_kaminari).once.and_return(@paged)
+      @abstract_model.all(:sort => PK_COLUMN, :page => 1, :per => 2)
+    end
+  end
+end

data/spec/rails_admin/active_record_extension_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require File.expand_path('../../../config/initializers/active_record_extensions', __FILE__)
+
+describe "ActiveRecord::Base", :active_record => true do
+  describe "#safe_send" do
+    it "only calls #read_attribute once" do
+      @player = Player.new
+      @player.number = 23
+      original_method = @player.method(:read_attribute)
+      @player.should_receive(:read_attribute).exactly(1).times do |*args|
+        original_method.call(*args)
+      end
+      expect(@player.safe_send(:number)).to eq(23)
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+describe "RailsAdmin::Adapters::ActiveRecord::AbstractObject", :active_record => true do
+  describe "proxy" do
+    let(:object) { mock("object") }
+    let(:abstract_object) { RailsAdmin::Adapters::ActiveRecord::AbstractObject.new(object) }
+
+    it "acts 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 "creates a Player with given attributes" do
+        expect(object.save).to be_true
+
+        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_false
+        expect(player.draft).to be_nil
+        expect(player.team).to be_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 "creates a Player with given attributes" do
+        expect(object.save).to be_true
+
+        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_false
+        expect(player.draft).to eq(draft.reload)
+        expect(player.team).to be_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 "creates a League with given attributes and associations" do
+        expect(object.save).to be_true
+        league.reload
+        expect(league.name).to eq(name)
+        expect(league.divisions).to eq(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 "updates a record and associations" do
+        object.reload
+        expect(object.number).to eq(new_number)
+        expect(object.name).to eq(name)
+        expect(object.draft).to be_nil
+        expect(object.suspended).to be_true
+        expect(object.team).to eq(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 "deletes the record" do
+      expect(Player.exists?(player.id)).to be_false
+    end
+  end
+
+  describe "object_label_method" do
+    it "is configurable" do
+      RailsAdmin.config League do
+        object_label_method { :custom_name }
+      end
+
+      @league = FactoryGirl.create :league
+
+      expect(RailsAdmin.config('League').with(:object => @league).object_label).to eq("League '#{@league.name}'")
+    end
+  end
+end