activeadmin 0.2.2 → 0.3.0

data/spec/unit/rails_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe ActiveAdmin do
+
+  describe "use_asset_pipeline?" do
+
+    before(:each) do
+      @orig_rails_version = Rails::VERSION::MINOR
+    end
+
+    after(:each) do
+      silence_warnings { Rails::VERSION::MINOR = @orig_rails_version }
+    end
+
+    it "should be false when using rails 3.0.x" do
+      silence_warnings { Rails::VERSION::MINOR = 0 }
+      ActiveAdmin.use_asset_pipeline?.should be_false
+    end
+
+    context "when rails 3.1.x" do
+      before(:each) do
+        @orig_rails_app = Rails.application.dup
+        silence_warnings { Rails::VERSION::MINOR = 1 }
+      end
+
+      after(:each) do
+        Rails.application = @orig_rails_app
+      end
+
+      it "should be false without asset pipeline enabled" do
+        assets = mock(:enabled => false)
+        Rails.application.config.stub!(:assets => assets)
+        ActiveAdmin.use_asset_pipeline?.should be_false
+      end
+
+      it "should be true with asset pipeline enabled" do
+        assets = mock(:enabled => true)
+        Rails.application.config.stub!(:assets => assets)
+        ActiveAdmin.use_asset_pipeline?.should be_true
+      end
+    end
+  end
+end

data/spec/unit/registration_spec.rb

@@ -1,67 +1,58 @@
 require 'spec_helper' 
 
 describe "Registering an object to administer" do
+  let(:application){ ActiveAdmin::Application.new }
 
   context "with no configuration" do
-    let(:namespace) { ActiveAdmin::Namespace.new(:admin) }
+    let(:namespace) { ActiveAdmin::Namespace.new(application, :admin) }
     it "should call register on the namespace" do
-      ActiveAdmin.namespaces[namespace.name] = namespace
+      application.namespaces[namespace.name] = namespace
       namespace.should_receive(:register)
 
-      ActiveAdmin.register Category
+      application.register Category
     end
 
     it "should dispatch a Resource::RegisterEvent" do
       ActiveAdmin::Event.should_receive(:dispatch).with(ActiveAdmin::Resource::RegisterEvent, an_instance_of(ActiveAdmin::Resource))
-      ActiveAdmin.register Category
+      application.register Category
     end
   end
 
   context "with a different namespace" do
     it "should call register on the namespace" do
-      namespace = ActiveAdmin::Namespace.new(:hello_world)
-      ActiveAdmin.namespaces[namespace.name] = namespace
+      namespace = ActiveAdmin::Namespace.new(application, :hello_world)
+      application.namespaces[namespace.name] = namespace
       namespace.should_receive(:register)
 
-      ActiveAdmin.register Category, :namespace => :hello_world
-    end
-    it "should generate a path to the dashboard" do
-      ActiveAdmin.register Category, :namespace => :hello_world
-      reload_routes!
-      Rails.application.routes.url_helpers.methods.collect(&:to_s).should include("hello_world_dashboard_path")
+      application.register Category, :namespace => :hello_world
     end
     it "should generate a menu item for the dashboard" do
-      ActiveAdmin.register Category, :namespace => :hello_world
-      ActiveAdmin.namespaces[:hello_world].load_menu!
-      ActiveAdmin.namespaces[:hello_world].menu['Dashboard'].instance_variable_get("@url").should == :hello_world_dashboard_path
+      application.register Category, :namespace => :hello_world
+      application.namespaces[:hello_world].load_menu!
+      application.namespaces[:hello_world].menu['Dashboard'].instance_variable_get("@url").should == :hello_world_dashboard_path
     end
     it "should generate a Namespace::RegisterEvent and a Resource::RegisterEvent" do
       ActiveAdmin::Event.should_receive(:dispatch).with(ActiveAdmin::Namespace::RegisterEvent, an_instance_of(ActiveAdmin::Namespace))
       ActiveAdmin::Event.should_receive(:dispatch).with(ActiveAdmin::Resource::RegisterEvent, an_instance_of(ActiveAdmin::Resource))
-      ActiveAdmin.register Category, :namespace => :not_yet_created
+      application.register Category, :namespace => :not_yet_created
     end
   end
 
   context "with no namespace" do
     it "should call register on the root namespace" do
-      namespace = ActiveAdmin::Namespace.new(:root)
-      ActiveAdmin.namespaces[namespace.name] = namespace
+      namespace = ActiveAdmin::Namespace.new(application, :root)
+      application.namespaces[namespace.name] = namespace
       namespace.should_receive(:register)
 
-      ActiveAdmin.register Category, :namespace => false
+      application.register Category, :namespace => false
     end
 
     it "should generate a menu item for the dashboard" do
-      ActiveAdmin.register Category, :namespace => false  
-      ActiveAdmin.namespaces[:root].load_menu!
-      ActiveAdmin.namespaces[:root].menu['Dashboard'].instance_variable_get("@url").should == :dashboard_path
+      application.register Category, :namespace => false  
+      application.namespaces[:root].load_menu!
+      application.namespaces[:root].menu['Dashboard'].instance_variable_get("@url").should == :dashboard_path
     end
 
-    it "should generate a path to the dashboard" do
-      ActiveAdmin.register Category, :namespace => false
-      reload_routes!
-      Rails.application.routes.url_helpers.methods.collect(&:to_s).should include("dashboard_path")
-    end
   end
 
   context "when being registered multiple times" do

data/spec/unit/reloader_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+# Ensure we have both constants to play with
+begin
+  ActionDispatch::Reloader
+rescue
+  module ActionDispatch; module Reloader; end; end
+end
+
+begin
+  ActionDispatch::Callbacks
+rescue
+  module ActionDispatch; module Callbacks; end; end
+end
+
+
+describe ActiveAdmin::Reloader do
+
+  it "should use ActionDispatch::Reloader if rails 3.1" do
+    reloader = ActiveAdmin::Reloader.new '3.1.0'
+    reloader.reloader_class.should == ActionDispatch::Reloader
+  end
+
+  it "should use ActionDispatch::Callbacks if rails 3.0" do
+    reloader = ActiveAdmin::Reloader.new '3.0.0'
+    reloader.reloader_class.should == ActionDispatch::Callbacks
+  end
+end

data/spec/unit/resource/action_items_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe ActiveAdmin::Resource::ActionItems do
+
+  let(:resource) do
+    namespace = ActiveAdmin::Namespace.new(ActiveAdmin::Application.new, :admin)
+    namespace.register(Post)
+  end
+
+  describe "adding a new action item" do
+
+    before do
+      resource.clear_action_items!
+      resource.add_action_item do
+        # Empty ...
+      end
+    end
+
+    it "should add an action item" do
+      resource.action_items.size.should == 1
+    end
+
+    it "should store an instance of ActionItem" do
+      resource.action_items.first.should be_an_instance_of(ActiveAdmin::ActionItem)
+    end
+
+    it "should store the block in the action item" do
+      resource.action_items.first.block.should_not be_nil
+    end
+
+  end
+
+  describe "setting an action item to only display on specific controller actions" do
+
+    before do
+      resource.clear_action_items!
+      resource.add_action_item :only => :index do
+        raise StandardError
+      end
+      resource.add_action_item :only => :show do
+        # Empty ...
+      end
+    end
+
+    it "should return only relevant action items" do
+      resource.action_items_for(:index).size.should == 1
+      lambda {
+        resource.action_items_for(:index).first.call
+      }.should raise_exception(StandardError)
+    end
+
+  end
+
+  describe "default action items" do
+
+    it "should have 3 action items" do
+      resource.action_items.size.should == 3
+    end
+
+  end
+
+end

data/spec/unit/resource/menu_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper' 
+
+module ActiveAdmin
+  describe Resource, "Menu" do
+
+    before { load_defaults! }
+
+    let(:application){ ActiveAdmin::Application.new }
+    let(:namespace){ Namespace.new(application, :admin) }
+
+    def config(options = {})
+      @config ||= Resource.new(namespace, Category, options)
+    end
+
+    describe "#include_in_menu?" do
+      let(:namespace){ ActiveAdmin::Namespace.new(application, :admin) }
+      subject{ resource }
+
+      context "when regular resource" do
+        let(:resource){ namespace.register(Post) }
+        it { should be_include_in_menu }
+      end
+      context "when belongs to" do
+        let(:resource){ namespace.register(Post){ belongs_to :author } }
+        it { should_not be_include_in_menu }
+      end
+      context "when belongs to optional" do
+        let(:resource){ namespace.register(Post){ belongs_to :author, :optional => true} }
+        it { should be_include_in_menu }
+      end
+      context "when menu set to false" do
+        let(:resource){ namespace.register(Post){ menu false } }
+        it { should_not be_include_in_menu }
+      end
+    end
+
+    describe "menu item name" do
+      it "should be the resource name when not set" do
+        config.menu_item_name.should == "Categories"
+      end
+      it "should be settable" do
+        config.menu :label => "My Label"
+        config.menu_item_name.should == "My Label"
+      end
+    end
+
+    describe "parent menu item name" do
+      it "should be nil when not set" do
+        config.parent_menu_item_name.should == nil
+      end
+      it "should return the name if set" do
+        config.tap do |c|
+          c.menu :parent => "Blog"
+        end.parent_menu_item_name.should == "Blog"
+      end
+    end
+
+    describe "menu item priority" do
+      it "should be 10 when not set" do
+        config.menu_item_priority.should == 10
+      end
+      it "should be settable" do
+        config.menu :priority => 2
+        config.menu_item_priority.should == 2
+      end
+    end
+
+    describe "menu item display if" do
+      it "should be a proc always returning true if not set" do
+        config.menu_item_display_if.should be_instance_of(Proc)
+        config.menu_item_display_if.call.should == true
+      end
+      it "should be settable" do
+        config.menu :if => proc { false }
+        config.menu_item_display_if.call.should == false
+      end
+    end
+
+  end
+end

data/spec/unit/resource/naming_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+module ActiveAdmin
+  describe Resource, "Naming" do
+
+    before { load_defaults! }
+
+    let(:application){ ActiveAdmin::Application.new }
+    let(:namespace){ Namespace.new(application, :admin) }
+
+    def config(options = {})
+      @config ||= Resource.new(namespace, Category, options)
+    end
+
+
+    describe "underscored resource name" do
+      context "when class" do
+        it "should be the underscored singular resource name" do
+          config.underscored_resource_name.should == "category"
+        end
+      end
+      context "when a class in a module" do
+        it "should underscore the module and the class" do
+          module ::Mock; class Resource; end; end
+          Resource.new(namespace, Mock::Resource).underscored_resource_name.should == "mock_resource"
+        end
+      end
+      context "when you pass the 'as' option" do
+        it "should underscore the passed through string and singulralize" do
+          config(:as => "Blog Categories").underscored_resource_name.should == "blog_category"
+        end
+      end
+    end
+
+    describe "camelized resource name" do
+      it "should return a camelized version of the underscored resource name" do
+        config(:as => "Blog Categories").camelized_resource_name.should == "BlogCategory"
+      end
+    end
+
+    describe "resource name" do
+      it "should return a pretty name" do
+        config.resource_name.should == "Category"
+      end
+      it "should return the plural version" do
+        config.plural_resource_name.should == "Categories"
+      end
+      context "when the :as option is given" do
+        it "should return the custom name" do
+          config(:as => "My Category").resource_name.should == "My Category"
+        end
+      end
+      context "I18n" do
+        before do
+          I18n.stub(:translate) { 'Categorie' }
+        end
+        it "should return the plural version defined in the i18n if available" do
+          config.plural_resource_name.should == "Categorie"
+        end
+      end
+    end
+
+  end
+end

data/spec/unit/resource/scopes_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper' 
+
+module ActiveAdmin
+  describe Resource, "Scopes" do
+
+    before { load_defaults! }
+
+    let(:application){ ActiveAdmin::Application.new }
+    let(:namespace){ Namespace.new(application, :admin) }
+
+    def config(options = {})
+      @config ||= Resource.new(namespace, Category, options)
+    end
+
+    describe "adding a scope" do
+
+      it "should add a scope" do
+        config.scope :published
+        config.scopes.first.should be_a(ActiveAdmin::Scope)
+        config.scopes.first.name.should == "Published"
+      end
+
+      it "should retrive a scope by its id" do
+        config.scope :published
+        config.get_scope_by_id(:published).name.should == "Published"
+      end
+
+    end
+  end
+end

data/spec/unit/resource/sidebars_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe ActiveAdmin::Resource::Sidebars do
+
+  let(:resource) do
+    namespace = ActiveAdmin::Namespace.new(ActiveAdmin::Application.new, :admin)
+    namespace.register(Post)
+  end
+
+  let(:sidebar) { ActiveAdmin::SidebarSection.new(:help) }
+
+  describe "adding a new sidebar section" do
+
+    before do
+      resource.clear_sidebar_sections!
+      resource.sidebar_sections << sidebar
+    end
+
+    it "should add a sidebar section" do
+      resource.should have(1).sidebar_sections
+    end
+
+  end
+
+  describe "retrieving sections for a controller action" do
+
+    let(:only_index){ ActiveAdmin::SidebarSection.new(:help, :only => :index) }
+    let(:only_show){ ActiveAdmin::SidebarSection.new(:help, :only => :show) }
+
+    before do
+      resource.clear_sidebar_sections!
+      resource.sidebar_sections << only_index
+      resource.sidebar_sections << only_show
+    end
+
+    it "should only return the relevant action items" do
+      resource.should have(2).sidebar_sections
+      resource.sidebar_sections_for("index").should == [only_index]
+    end
+
+  end
+
+  describe "default sidebar sections" do
+
+    it "should have a filters section by default" do
+      resource.sidebar_sections.first.name.should == :filters
+    end
+
+  end
+end