activeadmin 0.3.4 → 0.4.0

data/spec/unit/namespace_spec.rb

@@ -16,199 +16,27 @@ describe ActiveAdmin::Namespace do
     end
 
     it "should have no resources" do
-      namespace.resources.should == {}
+      namespace.resources.resources.should be_empty
     end
 
     it "should have an empty menu" do
       namespace.menu.items.should be_empty
     end
-  end
-
-  describe "registering a resource" do
+  end # context "when new"
 
+  describe "settings" do
     let(:namespace){ ActiveAdmin::Namespace.new(application, :admin) }
 
-    context "with no configuration" do
-      before do
-        namespace.register Category
-      end
-      it "should store the namespaced registered configuration" do
-        namespace.resources.keys.should include('Category')
-      end
-      it "should create a new controller in the default namespace" do
-        defined?(Admin::CategoriesController).should be_true
-      end
-      it "should create the dashboard controller" do
-        defined?(Admin::DashboardController).should be_true
-      end
-      it "should create a menu item" do
-        namespace.load_menu!
-        namespace.menu["Categories"].should be_an_instance_of(ActiveAdmin::MenuItem)
-        namespace.menu["Categories"].url.should == "/admin/categories"
-      end
-    end
-
-    context "with a block configuration" do
-      it "should be evaluated in the dsl" do
-        lambda {
-          namespace.register Category do
-            raise "Hello World"
-          end
-        }.should raise_error
-      end
+    it "should inherit the site title from the application" do
+      ActiveAdmin::Namespace.setting :site_title, "Not the Same"
+      namespace.site_title.should == application.site_title
     end
 
-    context "with a resource that's namespaced" do
-
-      before do
-        module ::Mock; class Resource; def self.has_many(arg1, arg2); end; end; end
-        namespace.register Mock::Resource
-      end
-
-      it "should store the namespaced registered configuration" do
-        namespace.resources.keys.should include('MockResource')
-      end
-      it "should create a new controller in the default namespace" do
-        defined?(Admin::MockResourcesController).should be_true
-      end
-      it "should create a menu item" do
-        namespace.load_menu!
-        namespace.menu["Mock Resources"].should be_an_instance_of(ActiveAdmin::MenuItem)
-      end
-      it "should use the resource as the model in the controller" do
-        Admin::MockResourcesController.resource_class.should == Mock::Resource
-      end
-
+    it "should be able to override the site title" do
+      namespace.site_title.should == application.site_title
+      namespace.site_title = "My Site Title"
+      namespace.site_title.should_not == application.site_title
     end
-
-    describe "finding resource instances" do
-
-      let(:namespace){ ActiveAdmin::Namespace.new(application, :admin) }
-
-      it "should return the resource when its been registered" do
-        post = namespace.register Post
-        namespace.resource_for(Post).should == post
-      end
-
-      it 'should return nil when the resource has not been registered' do
-        namespace.resource_for(Post).should == nil
-      end
-
-      it "should return the parent when the parent class has been registered and the child has not" do
-        user = namespace.register User
-        namespace.resource_for(Publisher).should == user
-      end
-
-      it "should return the resource if it and it's parent were registered" do
-        user = namespace.register User
-        publisher = namespace.register Publisher
-        namespace.resource_for(Publisher).should == publisher
-      end
-
-    end
-
-    describe "adding to the menu" do
-
-      describe "adding as a top level item" do
-        before do
-          namespace.register Category
-          namespace.load_menu!
-        end
-        it "should add a new menu item" do
-          namespace.menu['Categories'].should_not be_nil
-        end
-      end
-
-      describe "adding as a child" do
-        before do
-          namespace.register Category do
-            menu :parent => 'Blog'
-          end
-          namespace.load_menu!
-        end
-        it "should generate the parent menu item" do
-          namespace.menu['Blog'].should_not be_nil
-        end
-        it "should generate its own child item" do
-          namespace.menu['Blog']['Categories'].should_not be_nil
-        end
-      end
-
-      describe "disabling the menu" do
-        before do
-          namespace.register Category do
-            menu false
-          end
-          namespace.load_menu!
-        end
-        it "should not create a menu item" do
-          namespace.menu["Categories"].should be_nil
-        end
-      end
-      
-      describe "setting menu priority" do
-        before do
-          namespace.register Category do
-            menu :priority => 2
-          end
-          namespace.load_menu!
-        end
-        it "should have a custom priority of 2" do
-          namespace.menu["Categories"].priority.should == 2
-        end
-      end
-      
-      describe "setting a condition for displaying" do
-        before do
-          namespace.register Category do
-            menu :if => proc { false }
-          end
-          namespace.load_menu!
-        end
-        it "should have a proc returning false" do
-          namespace.menu["Categories"].display_if_block.should be_instance_of(Proc)
-          namespace.menu["Categories"].display_if_block.call.should == false
-        end
-      end
-
-      describe "adding as a belongs to" do
-        context "when not optional" do
-          before do
-            namespace.register Post do
-              belongs_to :author
-            end
-          end
-          it "should not show up in the menu" do
-            namespace.menu["Posts"].should be_nil
-          end
-        end
-        context "when optional" do
-          before do
-            namespace.register Post do
-              belongs_to :author, :optional => true
-            end
-          end
-          it "should show up in the menu" do
-            namespace.menu["Posts"].should_not be_nil
-          end
-        end
-      end
-    end
-
-    describe "dashboard controller name" do
-      context "when namespaced" do
-        it "should be namespaced" do
-          namespace = ActiveAdmin::Namespace.new(application, :admin)
-          namespace.dashboard_controller_name.should == "Admin::DashboardController"
-        end
-      end
-      context "when not namespaced" do
-        it "should not be namespaced" do
-          namespace = ActiveAdmin::Namespace.new(application, :root)
-          namespace.dashboard_controller_name.should == "DashboardController"
-        end
-      end
-    end
-
   end
+
 end

data/spec/unit/page_controller_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require File.expand_path('base_controller_shared_examples', File.dirname(__FILE__))
+
+describe ActiveAdmin::PageController do
+  let(:controller) { ActiveAdmin::PageController.new }
+
+  it_should_behave_like "BaseController"
+end

data/spec/unit/page_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper' 
+require File.expand_path('config_shared_examples', File.dirname(__FILE__))
+
+module ActiveAdmin
+  describe Page do
+
+    it_should_behave_like "ActiveAdmin::Config"
+    before { load_defaults! }
+
+    let(:application){ ActiveAdmin::Application.new }
+    let(:namespace){ Namespace.new(application, :admin) }
+
+    def config(options = {})
+      @config ||= Page.new(namespace, "Status", options)
+    end
+
+    describe "controller name" do
+      it "should return a namespaced controller name" do
+        config.controller_name.should == "Admin::StatusController"
+      end
+      context "when non namespaced controller" do
+        let(:namespace){ ActiveAdmin::Namespace.new(application, :root) }
+        it "should return a non namespaced controller name" do
+          config.controller_name.should == "StatusController"
+        end
+      end
+    end
+
+    describe "#resource_name" do
+      it "returns the name" do
+        config.resource_name.should == "Status"
+      end
+    end
+
+    describe "#plural_resource_name" do
+      it "returns the singular name" do
+        config.plural_resource_name.should == "Status"
+      end
+    end
+
+    describe "#underscored_resource_name" do
+      it "returns the underscored name" do
+        config.underscored_resource_name.should == "status"
+      end
+    end
+
+    it "should not belong_to anything" do
+      config.belongs_to?.should == false
+    end
+
+    it "should not have any action_items" do
+      config.action_items?.should == false
+    end
+
+    it "should not have any sidebar_sections" do
+      config.sidebar_sections?.should == false
+    end
+
+  end
+end

data/spec/unit/reloader_spec.rb

@@ -13,68 +13,112 @@ rescue
   module ActionDispatch; module Callbacks; def self.to_prepare; end; end; end
 end
 
+major_rails_version = Rails.version[0..2]
+
 
 describe ActiveAdmin::Reloader do
 
   let(:rails_app){ mock(:reload_routes! => true)}
   let(:mock_app){ mock(:load_paths => ["app/admin"], :unload! => true)}
-  let(:reloader){ ActiveAdmin::Reloader.new(rails_app, mock_app, "3.1.0")}
+  let(:reloader){ ActiveAdmin::Reloader.build(rails_app, mock_app, rails_version) }
 
-  it "should initialize a new file update checker" do
-    ActiveSupport::FileUpdateChecker.should_receive(:new).with(mock_app.load_paths).and_return(mock(:execute_if_updated => true))
-    ActiveAdmin::Reloader.new(rails_app, mock_app, '3.1.0').attach!
-  end
+  context "when Rails version < 3.2" do
+    let(:rails_version){ "3.1.0" }
 
-  describe "#reloader_class" do
-    it "should use ActionDispatch::Reloader if rails 3.1" do
-      reloader = ActiveAdmin::Reloader.new rails_app, mock_app, '3.1.0'
-      reloader.reloader_class.should == ActionDispatch::Reloader
-    end
+    describe "initialization" do
+
+      it "should initialize a new file update checker" do
+        ActiveSupport::FileUpdateChecker.should_receive(:new).with(mock_app.load_paths).and_return(mock(:execute_if_updated => true))
+        ActiveAdmin::Reloader.build(rails_app, mock_app, '3.1.0')
+      end
+
+      it "should build a RailsLessThan31Reloader" do
+        reloader.class.should == ActiveAdmin::Reloader::RailsLessThan31Reloader
+      end
 
-    it "should use ActionDispatch::Callbacks if rails 3.0" do
-      reloader = ActiveAdmin::Reloader.new rails_app, mock_app, '3.0.0'
-      reloader.reloader_class.should == ActionDispatch::Callbacks
     end
-  end
 
-  describe "#reload!" do
+    describe "#reloader_class" do
+
+      it "should use ActionDispatch::Reloader if rails 3.1" do
+        reloader = ActiveAdmin::Reloader.build rails_app, mock_app, '3.1.0'
+        reloader.reloader_class.should == ActionDispatch::Reloader
+      end
+
+      it "should use ActionDispatch::Callbacks if rails 3.0" do
+        reloader = ActiveAdmin::Reloader.build rails_app, mock_app, '3.0.0'
+        reloader.reloader_class.should == ActionDispatch::Callbacks
+      end
 
-    it "should unload the active admin app" do
-      mock_app.should_receive(:unload!)
-      reloader.reload!
     end
 
-    it "should reload the rails app routes" do
-      rails_app.should_receive(:reload_routes!)
-      reloader.reload!
+    describe "#reload!" do
+
+      it "should unload the active admin app" do
+        mock_app.should_receive(:unload!)
+        reloader.reload!
+      end
+
+      it "should reload the rails app routes" do
+        rails_app.should_receive(:reload_routes!)
+        reloader.reload!
+      end
+
+      it 'should reset the files within the file_update_checker' do
+        reloader.file_update_checker.paths.should_receive(:clear)
+        reloader.file_update_checker.paths.should_receive(:<<).with("app/admin")
+        reloader.reload!
+      end
+
     end
 
-    it 'should reset the files within the file_update_checker' do
-      reloader.file_update_checker.paths.should_receive(:clear)
-      reloader.file_update_checker.paths.should_receive(:<<).with("app/admin")
-      reloader.reload!
+    describe "#watched_paths" do
+      let(:mock_app){ ActiveAdmin::Application.new }
+      let(:admin_path){ File.join(Rails.root, "app", "admin") }
+
+      before do
+        mock_app.load_paths = [admin_path]
+      end
+
+      it "should return the load path directories" do
+        reloader.watched_paths.should include(admin_path)
+      end
+
+      it "should include all files in the directory" do
+        root = Rails.root + "/app/admin"
+        reloader.watched_paths.should include(*Dir["#{admin_path}/**/*.rb"])
+      end
+
     end
 
   end
 
-  describe "#watched_paths" do
-    let(:mock_app){ ActiveAdmin::Application.new }
-    let(:admin_path){ File.join(Rails.root, "app", "admin") }
+  context "when Rails >= 3.2" do
+    let(:rails_version){ "3.2.0" }
 
-    before do
-      mock_app.load_paths = [admin_path]
-    end
+    describe "initialization" do
 
-    it "should return the load path directories" do
-      reloader.watched_paths.should include(admin_path)
-    end
+      it "should build a Rails32Reloader" do
+        reloader.class.should == ActiveAdmin::Reloader::Rails32Reloader
+      end
 
-    it "should include all files in the directory" do
-      root = Rails.root + "/app/admin"
-      reloader.watched_paths.should include(*Dir["#{admin_path}/**/*.rb"])
     end
 
-  end
+    describe "attach!" do
+      before do
+        mock_app.load_paths << "app/active_admin"
+        ActionDispatch::Reloader.stub!(:to_prepare => true)
+      end
+
+      it "should the load paths to the watchable_dirs" do
+        config = mock(:watchable_dirs => {})
+        rails_app.should_receive(:config).twice.and_return(config)
+        reloader.attach!
 
+        config.watchable_dirs["app/admin"].should == [:rb]
+        config.watchable_dirs["app/active_admin"].should == [:rb]
+      end
+    end
+  end
 
 end

data/spec/unit/resource/menu_spec.rb

@@ -16,65 +16,15 @@ module ActiveAdmin
       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