andrewroth_activeadmin 0.3.4 → 0.3.4.1

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

data/spec/unit/resource/naming_spec.rb

@@ -26,48 +26,53 @@ module ActiveAdmin
         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"
+        it "should underscore the passed through string" do
+          config(:as => "Blog Category").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"
+        config(:as => "Blog category").camelized_resource_name.should == "BlogCategory"
       end
     end
     
-    describe "plural underscored resource name" do
-      before(:all) do
-        class ::CandyCane; end
-        @config = Resource.new(namespace, CandyCane, {})
-      end
-      
-      it "should return an underscored and pluralized resource name" do
-        config.plural_underscored_resource_name.should == "candy_canes"
-      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' }
+
+      describe "I18n integration" do
+        describe "singular name" do
+          it "should return the titleized model_name.human" do
+            Category.model_name.should_receive(:human).and_return "Da category"
+
+            config.resource_name.should == "Da Category"
+          end
         end
-        it "should return the plural version defined in the i18n if available" do
-          config.plural_resource_name.should == "Categorie"
+
+        describe "plural name" do
+          it "should return the titleized plural version defined by i18n if available" do
+            Category.model_name.should_receive(:underscore).and_return "category"
+            Category.model_name.should_not_receive(:i18n_key) # Not implemented in Rails 3.0.0
+            I18n.should_receive(:translate!).
+              with("activerecord.models.category.other").
+              and_return("Da categories")
+            config.plural_resource_name.should == "Da Categories"
+          end
         end
+
       end
     end
 

data/spec/unit/resource/page_presenters_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe ActiveAdmin::Resource::PagePresenters do
+
+  let(:namespace){ ActiveAdmin::Namespace.new(ActiveAdmin::Application.new, :admin) }
+  let(:resource){ namespace.register(Post) }
+
+  it "should have an empty set of configs on initialize" do
+    resource.page_presenters.should == {}
+  end
+
+  it "should add a page presenter" do
+    page_presenter = ActiveAdmin::PagePresenter.new
+    resource.set_page_presenter(:index, page_presenter)
+    resource.page_presenters[:index].should == page_presenter
+  end
+
+  describe "#get_page_presenter" do
+
+    it "should return a page config when set" do
+      page_presenter = ActiveAdmin::PagePresenter.new
+      resource.set_page_presenter(:index, page_presenter)
+      resource.get_page_presenter(:index).should == page_presenter
+    end
+
+    it "should return nil when no page config set" do
+      resource.get_page_presenter(:index).should == nil
+    end
+
+  end
+
+end

data/spec/unit/resource/scopes_spec.rb

@@ -25,6 +25,19 @@ module ActiveAdmin
         config.get_scope_by_id(:published).name.should == "Published"
       end
 
+      it "should not add a scope with the same name twice" do
+        config.scope :published
+        config.scope :published
+        config.scopes.size.should == 1
+      end
+
+      it "should update a scope with the same id" do
+        config.scope :published
+        config.scopes.first.scope_block.should be_nil
+        config.scope(:published){  }
+        config.scopes.first.scope_block.should_not be_nil
+      end
+
     end
   end
 end

data/spec/unit/resource_collection_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+require 'active_admin/resource_collection'
+
+include ActiveAdmin
+
+describe ActiveAdmin::ResourceCollection do
+
+  let(:collection){ ResourceCollection.new }
+
+  it "should have no resources when new" do
+    collection.resources.should == []
+  end
+
+  it "should be enumerable" do
+    resource = mock(:resource_key => "MyResource")
+    collection.add(resource)
+    collection.each{|r| r.should == resource }
+  end
+
+  it "should return the available keys" do
+    resource = mock(:resource_key => "MyResource")
+    collection.add resource
+    collection.keys.should == [resource.resource_key]
+  end
+
+  describe "adding a new resource" do
+    let(:resource){ mock(:resource_key => "MyResource") }
+
+    it "should return the resource" do
+      collection.add(resource).should == resource
+    end
+
+    it "should add a new resource" do
+      collection.add(resource)
+      collection.resources.should == [resource]
+    end
+
+    it "should be available by name" do
+      collection.add(resource)
+      collection.find_by_key(resource.resource_key).should == resource
+    end
+  end
+
+  describe "adding a new resource when the key already exists" do
+    let(:stored_resource){ mock(:resource_key => "MyResource") }
+    let(:resource){ mock(:resource_key => "MyResource") }
+
+    before do
+      collection.add(stored_resource)
+    end
+
+    it "should return the original resource" do
+      collection.add(resource).should == stored_resource
+    end
+
+    it "should not add a new resource" do
+      collection.add(resource)
+      collection.resources.should == [stored_resource]
+    end
+  end
+
+  describe "adding an existing resource key with a different resource class" do
+    let(:stored_resource){ mock(:resource_key => "MyResource", :resource_class => mock) }
+    let(:resource){ mock(:resource_key => "MyResource", :resource_class => mock) }
+
+    it "should raise a ActiveAdmin::ResourceMismatchError" do
+      collection.add(stored_resource)
+      lambda {
+        collection.add(resource)
+      }.should raise_error(ActiveAdmin::ResourceMismatchError)
+    end
+
+  end
+
+  describe "#find_by_resource_class" do
+
+    let(:base_class){ mock(:to_s => "BaseClass")}
+    let(:resource_from_base_class){ mock(:resource_key => "MyBaseClassResource", :resource_class => base_class )}
+    let(:resource_class){ mock(:base_class => base_class, :to_s => "ResourceClass") }
+    let(:resource){ mock(:resource_key => "MyResource", :resource_class => resource_class) }
+
+    it "should find a resource when it's in the collection" do
+      collection.add resource
+      collection.find_by_resource_class(resource_class).should == resource
+    end
+
+    it "should return nil when the resource class is not in the collection" do
+      collection.find_by_resource_class(resource_class).should == nil
+    end
+
+    it "should return the resource when it and it's base class is in the collection" do
+      collection.add resource_from_base_class
+      collection.find_by_resource_class(resource_class).should == resource_from_base_class
+    end
+
+    it "should return nil the resource_class does not repond to base_class and it's not in the collection" do
+      collection.find_by_resource_class(mock).should == nil
+    end
+  end
+
+end

data/spec/unit/resource_controller_spec.rb

@@ -1,47 +1,55 @@
 require 'spec_helper'
+require File.expand_path('base_controller_shared_examples', File.dirname(__FILE__))
 
 describe ActiveAdmin::ResourceController do
-  
-  [:index, :show].each do |page|
-    describe "#{page} config" do
-      before do
-        Admin::PostsController.send(:"reset_#{page}_config!")
-      end
 
-      it "should be set" do
-        Admin::PostsController.send(:set_page_config, page, {})
-        Admin::PostsController.send(:"#{page}_config").should be_an_instance_of(ActiveAdmin::PageConfig)
-      end
+  let(:controller) { ActiveAdmin::ResourceController.new }
 
-      it "should store the block" do
-        block = Proc.new {}
-        Admin::PostsController.send(:set_page_config, page, {}, &block)
-        Admin::PostsController.send(:"#{page}_config").block.should == block
-      end
+  it_should_behave_like "BaseController"
 
-      it "should be reset" do
-        Admin::PostsController.send(:"reset_#{page}_config!")
-        Admin::PostsController.send(:"#{page}_config").should == nil
-      end
+  describe "authenticating the user" do
+    let(:controller){ Admin::PostsController.new }
+
+    it "should do nothing when no authentication_method set" do
+      namespace = controller.class.active_admin_config.namespace
+      namespace.should_receive(:authentication_method).once.and_return(nil)
+
+      controller.send(:authenticate_active_admin_user)
     end
-  end
 
-  describe "setting the current tab" do
-    let(:controller) { ActiveAdmin::ResourceController.new }
-    before do 
-      controller.stub!(:active_admin_config => resource, :parent? => true)
-      controller.send :set_current_tab # Run the before filter
+    it "should call the authentication_method when set" do
+      namespace = controller.class.active_admin_config.namespace
+
+      namespace.should_receive(:authentication_method).twice.
+        and_return(:authenticate_admin_user!)
+
+      controller.should_receive(:authenticate_admin_user!).and_return(true)
+
+      controller.send(:authenticate_active_admin_user)
     end
-    subject{ controller.instance_variable_get(:@current_tab) }
 
-    context "when menu item name is 'Resources' without a parent menu item" do
-      let(:resource){ mock(:menu_item_name => "Resources", :parent_menu_item_name => nil, :belongs_to? => false) }
-      it { should == "Resources" }
+  end
+
+  describe "retrieving the current user" do
+    let(:controller){ Admin::PostsController.new }
+
+    it "should return nil when no current_user_method set" do
+      namespace = controller.class.active_admin_config.namespace
+      namespace.should_receive(:current_user_method).once.and_return(nil)
+
+      controller.send(:current_active_admin_user).should == nil
     end
 
-    context "when there is a parent menu item of 'Admin'" do
-      let(:resource){ mock(:parent_menu_item_name => "Admin", :menu_item_name => "Resources", :belongs_to? => false) }
-      it { should == "Admin/Resources" }
+    it "should call the current_user_method when set" do
+      user = mock
+      namespace = controller.class.active_admin_config.namespace
+
+      namespace.should_receive(:current_user_method).twice.
+        and_return(:current_admin_user)
+
+      controller.should_receive(:current_admin_user).and_return(user)
+
+      controller.send(:current_active_admin_user).should == user
     end
   end
 

data/spec/unit/resource_spec.rb

@@ -1,8 +1,11 @@
 require 'spec_helper' 
+require File.expand_path('config_shared_examples', File.dirname(__FILE__))
 
 module ActiveAdmin
   describe Resource do
 
+    it_should_behave_like "ActiveAdmin::Config"
+
     before { load_defaults! }
 
     let(:application){ ActiveAdmin::Application.new }
@@ -12,6 +15,8 @@ module ActiveAdmin
       @config ||= Resource.new(namespace, Category, options)
     end
 
+    it { respond_to :resource_class }
+
     describe "#resource_table_name" do
       it "should return the resource's table name" do
         config.resource_table_name.should == '"categories"'
@@ -23,12 +28,6 @@ module ActiveAdmin
       end
     end
 
-    describe "namespace" do
-      it "should return the namespace" do
-        config.namespace.should == namespace
-      end
-    end
-
     describe "controller name" do
       it "should return a namespaced controller name" do
         config.controller_name.should == "Admin::CategoriesController"
@@ -106,7 +105,6 @@ module ActiveAdmin
     end
 
     describe "route names" do
-      let(:config){ application.register Category }
       it "should return the route prefix" do
         config.route_prefix.should == "admin"
       end
@@ -131,18 +129,6 @@ module ActiveAdmin
       end
     end
 
-    describe "page configs" do
-      context "when initialized" do
-        it "should be empty" do
-          config.page_configs.should == {}
-        end
-      end
-      it "should be set-able" do
-        config.page_configs[:index] = "hello world"
-        config.page_configs[:index].should == "hello world"
-      end
-    end
-
     describe "scoping" do
       context "when using a block" do
         before do
@@ -214,17 +200,15 @@ module ActiveAdmin
 
       context "when resource class responds to primary_key" do
         it "should sort by primary key desc by default" do
-          mock_resource = mock
-          mock_resource.should_receive(:primary_key).and_return("pk")
-          config = Resource.new(namespace, mock_resource)
+          MockResource.should_receive(:primary_key).and_return("pk")
+          config = Resource.new(namespace, MockResource)
           config.sort_order.should == "pk_desc"
         end
       end
 
       context "when resource class does not respond to primary_key" do
         it "should default to id" do
-          mock_resource = mock
-          config = Resource.new(namespace, mock_resource)
+          config = Resource.new(namespace, MockResource)
           config.sort_order.should == "id_desc"
         end
       end