andrewroth_activeadmin 0.3.4 → 0.3.4.1

data/spec/unit/base_controller_spec.rb

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

data/spec/unit/belongs_to_spec.rb

@@ -1,45 +1,42 @@
 require 'spec_helper' 
 
-module ActiveAdmin
-  class Resource
-    describe BelongsTo do
+describe ActiveAdmin::Resource::BelongsTo do
 
-      let(:application){ ActiveAdmin::Application.new }
-      let(:namespace){ Namespace.new(application, :admin) }
-      let(:post){ namespace.register(Post) }
-      let(:belongs_to){ BelongsTo.new(post, :user) }
 
-      it "should have an owner" do
-        belongs_to.owner.should == post
-      end
+  let(:application){ ActiveAdmin::Application.new }
+  let(:namespace){ Namespace.new(application, :admin) }
+  let(:post){ namespace.register(Post) }
+  let(:belongs_to){ ActiveAdmin::Resource::BelongsTo.new(post, :user) }
 
-      it "should have a namespace" do
-        belongs_to.namespace.should == namespace
-      end
+  it "should have an owner" do
+    belongs_to.owner.should == post
+  end
+
+  it "should have a namespace" do
+    belongs_to.namespace.should == namespace
+  end
 
-      describe "finding the target" do
-        context "when the resource has been registered" do
-          let(:user){ namespace.register(User) }
-          before { user } # Ensure user is registered
-
-          it "should return the target resource" do
-            belongs_to.target.should == user
-          end
-        end
-
-        context "when the resource has not been registered" do
-          it "should raise a ActiveAdmin::BelongsTo::TargetNotFound" do
-            lambda {
-              belongs_to.target
-            }.should raise_error(ActiveAdmin::Resource::BelongsTo::TargetNotFound)
-          end
-        end
+  describe "finding the target" do
+    context "when the resource has been registered" do
+      let(:user){ namespace.register(User) }
+      before { user } # Ensure user is registered
+
+      it "should return the target resource" do
+        belongs_to.target.should == user
       end
+    end
 
-      it "should be optional" do
-        belongs_to = BelongsTo.new post, :user, :optional => true
-        belongs_to.should be_optional
+    context "when the resource has not been registered" do
+      it "should raise a ActiveAdmin::BelongsTo::TargetNotFound" do
+        lambda {
+          belongs_to.target
+        }.should raise_error(ActiveAdmin::Resource::BelongsTo::TargetNotFound)
       end
     end
   end
+
+  it "should be optional" do
+    belongs_to = ActiveAdmin::Resource::BelongsTo.new post, :user, :optional => true
+    belongs_to.should be_optional
+  end
 end

data/spec/unit/comments_spec.rb

@@ -3,38 +3,68 @@ require 'spec_helper'
 describe "Comments" do
   let(:application){ ActiveAdmin::Application.new }
 
-  describe "Configuration" do
-    it "should have an array of namespaces which allow comments" do
-      application.allow_comments_in.should be_an_instance_of(Array)
-    end
-
-    it "should allow comments in the default namespace by default" do
-      application.allow_comments_in.should include(application.default_namespace)
-    end
-  end
-
   describe ActiveAdmin::Comment do
     describe "Associations and Validations" do
       it { should belong_to :resource }
       it { should belong_to :author }
 
-      it { should validate_presence_of :resource_id }
-      it { should validate_presence_of :resource_type }
+      it { should validate_presence_of :resource }
       it { should validate_presence_of :body }
       it { should validate_presence_of :namespace }
     end
+
+    describe ".find_for_resource_in_namespace" do
+      let(:post){ Post.create!(:title => "Hello World") }
+      let(:namespace_name){ "admin" }
+
+      before do
+        @comment = ActiveAdmin::Comment.create! :resource => post,
+                                                :body => "A Comment",
+                                                :namespace => namespace_name
+      end
+
+      it "should return a comment for the resource in the same namespace" do
+        ActiveAdmin::Comment.find_for_resource_in_namespace(post, namespace_name).should == [@comment]
+      end
+
+      it "should not return a comment for the same resource in a different namespace" do
+        ActiveAdmin::Comment.find_for_resource_in_namespace(post, 'public').should == []
+      end
+
+      it "should not return a comment for a different resource" do
+        another_post = Post.create! :title => "Another Hello World"
+        ActiveAdmin::Comment.find_for_resource_in_namespace(another_post, namespace_name).should == []
+      end
+    end
   end
 
   describe ActiveAdmin::Comments::NamespaceHelper do
     describe "#comments?" do
-      it "should have comments if the namespace is in the settings" do
+
+      it "should have comments when the namespace allows comments" do
         ns = ActiveAdmin::Namespace.new(application, :admin)
+        ns.allow_comments = true
         ns.comments?.should be_true
       end
-      it "should not have comments if the namespace is not in the settings" do
-        ns = ActiveAdmin::Namespace.new(application, :not_in_comments)
+
+      it "should not have comments when the namespace does not allow comments" do
+        ns = ActiveAdmin::Namespace.new(application, :admin)
+        ns.allow_comments = false
         ns.comments?.should be_false
       end
+
+      it "should have comments when the application allows comments and no local namespace config" do
+        application.allow_comments = true
+        ns = ActiveAdmin::Namespace.new(application, :admin)
+        ns.comments?.should be_true
+      end
+
+      it "should not have comments when the application does not allow commands and no local namespace config" do
+        application.allow_comments = false
+        ns = ActiveAdmin::Namespace.new(application, :admin)
+        ns.comments?.should be_false
+      end
+
     end
   end
 

data/spec/unit/config_shared_examples.rb

@@ -0,0 +1,108 @@
+shared_examples_for "ActiveAdmin::Config" do
+  describe "namespace" do
+    it "should return the namespace" do
+      config.namespace.should == namespace
+    end
+  end
+
+  describe "page_presenters" do
+    it "should return an empty hash by default" do
+      config.page_presenters.should == {}
+    end
+  end
+
+  it { respond_to :controller_name }
+  it { respond_to :controller }
+  it { respond_to :route_prefix }
+  it { respond_to :route_collection_path }
+  it { respond_to :comments? }
+  it { respond_to :belongs_to? }
+  it { respond_to :action_items? }
+  it { respond_to :sidebar_sections? }
+
+  describe "Naming" do
+    it "implements #resource_name" do
+      expect { config.resource_name }.should_not raise_error
+    end
+
+    it "implements #plural_resource_name" do
+      expect { config.plural_resource_name }.should_not raise_error
+    end
+
+    describe "#camelized_resource_name" do
+      it "returns a camelized version of the resource_name" do
+        config.should_receive(:resource_name).and_return "My resource"
+        config.camelized_resource_name.should == "MyResource"
+      end
+    end
+
+    describe "#underscored_resource_name" do
+      it "returns the camelized_resource_name underscored" do
+        config.should_receive(:camelized_resource_name).and_return "MyResource"
+        config.underscored_resource_name.should == "my_resource"
+      end
+    end
+
+    describe "#plural_underscored_resource_name" do
+      it "returns the plural_camelized_resource_name underscored" do
+        config.should_receive(:plural_camelized_resource_name).and_return "MyResources"
+        config.plural_underscored_resource_name.should == "my_resources"
+      end
+    end
+  end
+
+  describe "Menu" do
+    describe "menu item name" do
+      it "should be the plural resource name when not set" do
+        config.menu_item_name.should == config.plural_resource_name
+      end
+      it "should be settable" do
+        config.menu :label => "My Label"
+        config.menu_item_name.should == "My Label"
+      end
+    end
+
+    describe "#include_in_menu?" do
+      it "should be included in menu by default" do
+        config.include_in_menu?.should == true
+      end
+
+      it "should not be included in menu when menu set to false" do
+        config.menu false
+        config.include_in_menu?.should == false
+      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/dashboard_controller_spec.rb

@@ -23,4 +23,48 @@ describe ActiveAdmin::Dashboards::DashboardController do
     end
   end
 
+  describe "conditionally displaying sections" do
+    before { ActiveAdmin::Dashboards.clear_all_sections! }
+    let(:controller){ Admin::DashboardController.new }
+    
+    context "when :if not specified" do
+      before do
+        @section = ActiveAdmin::Dashboards.add_section('Stats').last
+      end
+      
+      it "should include section" do
+        controller.send(:find_sections).should include(@section)
+      end
+    end
+    
+    context "when :if option specified as a method" do
+      before do
+        @section = ActiveAdmin::Dashboards.add_section('Secret Codes', :if => :i_am_awesome?).last
+      end
+      
+      it "should call the method of the same name" do
+        controller.should_receive(:i_am_awesome?).and_return(true)
+        controller.send(:find_sections).should include(@section)
+        
+        controller.should_receive(:i_am_awesome?).and_return(false)
+        controller.send(:find_sections).should_not include(@section)
+      end
+    end
+    
+    context "when :if option specified as block" do
+      before do
+        @proc    = Proc.new { true }
+        @section = ActiveAdmin::Dashboards.add_section('Secret Codes', :if => proc {}).last
+      end
+      
+      it "should evaluate the block" do
+        controller.should_receive(:instance_exec).with(&@proc).and_return(true)
+        controller.send(:find_sections).should include(@section)
+        
+        controller.should_receive(:instance_exec).with(&@proc).and_return(false)
+        controller.send(:find_sections).should_not include(@section)
+      end
+    end
+  end
+  
 end

data/spec/unit/event_spec.rb

@@ -12,6 +12,12 @@ describe ActiveAdmin::EventDispatcher do
     dispatcher.subscribers(test_event).size.should == 1
   end
 
+  it "should add a subscriber for multiple events" do
+    dispatcher.subscribe(test_event, test_event + "1"){ true }
+    dispatcher.subscribers(test_event).size.should == 1
+    dispatcher.subscribers(test_event + "1").size.should == 1
+  end
+
   it "should call the dispatch block with no arguments" do
     dispatcher.subscribe(test_event){ raise StandardError, "From Event Handler" }
     lambda {

data/spec/unit/filter_form_builder_spec.rb

@@ -56,6 +56,15 @@ describe ActiveAdmin::ViewHelpers::FilterFormHelper do
     it "should label a text field with search" do
       body.should have_tag('label', 'Search Title')
     end
+
+    it "should translate the label for text field" do
+      begin
+        I18n.backend.store_translations(:en, :activerecord => { :attributes => { :post => { :title => "Name" } } })
+        body.should have_tag('label', 'Search Name')
+      ensure
+        I18n.backend.reload!
+      end
+    end
   end
 
   describe "text attribute" do

data/spec/unit/form_builder_spec.rb

@@ -65,19 +65,13 @@ describe ActiveAdmin::FormBuilder do
   end
 
   context "when polymorphic relationship" do
-    
-    let(:body) do
-      comment = ActiveAdmin::Comment.new
-      
-      active_admin_form_for comment, :url => "admins/comments" do |f|
-        f.inputs :resource
-      end
-      
-    end
-    
-    it "should not generate any field" do
-      body.should have_tag("form", :attributes => { :method => 'post' })
-      body.should_not have_tag("select")
+    it "should raise error" do
+      lambda {
+        comment = ActiveAdmin::Comment.new
+        active_admin_form_for comment, :url => "admins/comments" do |f|
+          f.inputs :resource
+        end
+      }.should raise_error(Formtastic::PolymorphicInputWithoutCollectionError)
     end
   end
 
@@ -215,7 +209,7 @@ describe ActiveAdmin::FormBuilder do
       body = build_form do |f|
         f.input :title, :wrapper_html => { :class => "important" }
       end
-      body.should have_tag("li", :attributes => {:class => "string optional important"})
+      body.should have_tag("li", :attributes => {:class => "important string input optional stringish"})
     end
   end
 

data/spec/unit/namespace/register_page_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper' 
+
+describe ActiveAdmin::Namespace, "registering a page" do
+
+  let(:application){ ActiveAdmin::Application.new }
+
+  let(:namespace){ ActiveAdmin::Namespace.new(application, :admin) }
+
+  context "with no configuration" do
+    before do
+      namespace.register_page "Status"
+    end
+
+    it "should store the namespaced registered configuration" do
+      namespace.resources.keys.should include('Status')
+    end
+
+    it "should create a new controller in the default namespace" do
+      defined?(Admin::StatusController).should be_true
+    end
+
+    it "should create a menu item" do
+      namespace.load_menu!
+      namespace.menu["Status"].should be_an_instance_of(ActiveAdmin::MenuItem)
+    end
+  end # context "with no configuration"
+
+  context "with a block configuration" do
+    it "should be evaluated in the dsl" do
+      lambda {
+        namespace.register_page "Status" do
+          raise "Hello World"
+        end
+      }.should raise_error
+    end
+  end # context "with a block configuration"
+
+  describe "adding to the menu" do
+    describe "adding as a top level item" do
+      before do
+        namespace.register_page "Status"
+        namespace.load_menu!
+      end
+
+      it "should add a new menu item" do
+        namespace.menu['Status'].should_not be_nil
+      end
+    end # describe "adding as a top level item"
+
+    describe "adding as a child" do
+      before do
+        namespace.register_page "Status" do
+          menu :parent => 'Extra'
+        end
+        namespace.load_menu!
+      end
+      it "should generate the parent menu item" do
+        namespace.menu['Extra'].should_not be_nil
+      end
+      it "should generate its own child item" do
+        namespace.menu['Extra']['Status'].should_not be_nil
+      end
+    end # describe "adding as a child"
+
+    describe "disabling the menu" do
+      before do
+        namespace.register_page "Status" do
+          menu false
+        end
+        namespace.load_menu!
+      end
+      it "should not create a menu item" do
+        namespace.menu["Status"].should be_nil
+      end
+    end # describe "disabling the menu"
+    
+    describe "setting menu priority" do
+      before do
+        namespace.register_page "Status" do
+          menu :priority => 2
+        end
+        namespace.load_menu!
+      end
+      it "should have a custom priority of 2" do
+        namespace.menu["Status"].priority.should == 2
+      end
+    end # describe "setting menu priority"
+    
+    describe "setting a condition for displaying" do
+      before do
+        namespace.register_page "Status" do
+          menu :if => proc { false }
+        end
+        namespace.load_menu!
+      end
+      it "should have a proc returning false" do
+        namespace.menu["Status"].display_if_block.should be_instance_of(Proc)
+        namespace.menu["Status"].display_if_block.call.should == false
+      end
+    end # describe "setting a condition for displaying"
+  end # describe "adding to the menu"
+end