activeadmin 0.1.1 → 0.2.0

data/spec/unit/namespace_spec.rb

@@ -36,13 +36,14 @@ describe ActiveAdmin::Namespace 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 controller" do
+      it "should be evaluated in the dsl" do
         lambda {
           namespace.register Category do
             raise "Hello World"
@@ -53,7 +54,7 @@ describe ActiveAdmin::Namespace do
 
     context "with a resource that's namespaced" do
       before do
-        module ::Mock; class Resource; end; end
+        module ::Mock; class Resource; def self.has_many(arg1, arg2); end; end; end
         namespace.register Mock::Resource
       end
       
@@ -64,6 +65,7 @@ describe ActiveAdmin::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
@@ -71,11 +73,29 @@ describe ActiveAdmin::Namespace do
       end
     end
 
+    describe "finding resource instances" do
+      let(:namespace){ ActiveAdmin::Namespace.new(:admin) }
+      context "when registered" do
+        before do
+          @post_resource = namespace.register Post
+        end
+        it "should return the resource instance" do
+          namespace.resource_for(Post).should == @post_resource
+        end
+      end
+      context "when not registered" do
+        it "should be nil" do
+          namespace.resource_for(Post).should == nil
+        end
+      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
@@ -87,6 +107,7 @@ describe ActiveAdmin::Namespace 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
@@ -100,8 +121,45 @@ describe ActiveAdmin::Namespace do
         # TODO
         it "should not create a menu item"
       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
 
-  end  
+    describe "dashboard controller name" do
+      context "when namespaced" do
+        it "should be namespaced" do
+          namespace = ActiveAdmin::Namespace.new(: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(:root)
+          namespace.dashboard_controller_name.should == "DashboardController"
+        end
+      end
+    end
 
+  end
 end

data/spec/unit/pretty_format_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe "#pretty_format" do
+  include ActiveAdmin::ViewHelpers::DisplayHelper
+
+  context "when a String is passed in" do
+    it "should return the String passed in" do
+      pretty_format("hello").should == "hello"
+    end
+  end
+
+  context "when a Date or a Time is passed in" do
+    it "should return a localized Date or Time with long format" do
+      t = Time.now
+      self.should_receive(:localize).with(t, {:format => :long}) { "Just Now!" }
+      pretty_format(t).should == "Just Now!"
+    end
+  end
+
+  context "when an ActiveRecord object is passed in" do
+    it "should delegate to auto_link" do
+      post = Post.new
+      self.should_receive(:auto_link).with(post) { "model name" }
+      pretty_format(post).should == "model name"
+    end
+  end
+
+  context "when something else is passed in" do
+    it "should delegate to display_name" do
+      something = Class.new.new
+      self.should_receive(:display_name).with(something) { "I'm not famous" }
+      pretty_format(something).should == "I'm not famous"
+    end
+  end
+end

data/spec/unit/registration_spec.rb

@@ -3,13 +3,18 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 describe "Registering an object to administer" do
 
   context "with no configuration" do
+    let(:namespace) { ActiveAdmin::Namespace.new(:admin) }
     it "should call register on the namespace" do
-      namespace = ActiveAdmin::Namespace.new(:admin)
       ActiveAdmin.namespaces[namespace.name] = namespace
       namespace.should_receive(:register)
 
       ActiveAdmin.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
+    end
   end
 
   context "with a different namespace" do
@@ -25,6 +30,16 @@ describe "Registering an object to administer" do
       reload_routes!
       Rails.application.routes.url_helpers.methods.collect(&:to_s).should include("hello_world_dashboard_path")
     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
+    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
+    end
   end
 
   context "with no namespace" do
@@ -36,6 +51,12 @@ describe "Registering an object to administer" do
       ActiveAdmin.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
+    end
+
     it "should generate a path to the dashboard" do
       ActiveAdmin.register Category, :namespace => false
       reload_routes!
@@ -43,4 +64,22 @@ describe "Registering an object to administer" do
     end
   end
 
+  context "when being registered multiple times" do
+    it "should run the dsl in the same config object" do
+      config_1 = ActiveAdmin.register(Category) { filter :name }
+      config_2 = ActiveAdmin.register(Category) { filter :id }
+      config_1.should == config_2
+      config_1.controller.filters_config.size.should == 2
+    end
+
+    context "with different resource classes" do
+      it "should raise an ActiveAdmin::ResourceMismatch" do
+        lambda {
+          ActiveAdmin.register Category
+          ActiveAdmin.register Post, :as => "Category"
+        }.should raise_error(ActiveAdmin::ResourceMismatchError)
+      end
+    end
+  end
+
 end

data/spec/unit/renderer_spec.rb

@@ -44,6 +44,14 @@ describe ActiveAdmin::Renderer do
     end    
   end
 
+  context "when initializing from some other object" do
+    it "should initialize successfully" do
+      lambda {
+        Renderer.new "Hello World"
+      }.should_not raise_exception
+    end
+  end
+
   describe "rendering HAML" do
     before do
       @haml_renderer = Class.new(Renderer)

data/spec/unit/resource_controller_spec.rb

@@ -9,13 +9,13 @@ describe ActiveAdmin::ResourceController do
       end
 
       it "should be set" do
-        Admin::PostsController.send(page)
+        Admin::PostsController.send(:set_page_config, page, {})
         Admin::PostsController.send(:"#{page}_config").should be_an_instance_of(ActiveAdmin::PageConfig)
       end
 
       it "should store the block" do
         block = Proc.new {}
-        Admin::PostsController.send(:"#{page}", &block)
+        Admin::PostsController.send(:set_page_config, page, {}, &block)
         Admin::PostsController.send(:"#{page}_config").block.should == block
       end
 
@@ -29,19 +29,118 @@ describe ActiveAdmin::ResourceController do
   describe "setting the current tab" do
     let(:controller) { ActiveAdmin::ResourceController.new }
     before do 
-      controller.stub!(:active_admin_config => resource)
+      controller.stub!(:active_admin_config => resource, :parent? => true)
       controller.send :set_current_tab # Run the before filter
     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) }
+      let(:resource){ mock(:menu_item_name => "Resources", :parent_menu_item_name => nil, :belongs_to? => false) }
       it { should == "Resources" }
     end
 
     context "when there is a parent menu item of 'Admin'" do
-      let(:resource){ mock(:parent_menu_item_name => "Admin") }
-      it { should == "Admin" }
+      let(:resource){ mock(:parent_menu_item_name => "Admin", :menu_item_name => "Resources", :belongs_to? => false) }
+      it { should == "Admin/Resources" }
+    end
+  end
+
+  ActiveAdmin.register Post do
+    after_build :call_after_build
+    before_save :call_before_save
+    after_save :call_after_save
+    before_create :call_before_create
+    after_create :call_after_create
+    before_update :call_before_update
+    after_update :call_after_update
+    before_destroy :call_before_destroy
+    after_destroy :call_after_destroy
+  end
+
+  class Admin::PostsController < ActiveAdmin::ResourceController
+    def call_after_build(obj); end
+    def call_before_save(obj); end
+    def call_after_save(obj); end
+    def call_before_create(obj); end
+    def call_after_create(obj); end
+    def call_before_update(obj); end
+    def call_after_update(obj); end
+    def call_before_destroy(obj); end
+    def call_after_destroy(obj); end
+  end
+
+  describe "callbacks" do
+    describe "performing create" do
+      let(:controller){ Admin::PostsController.new }
+      let(:resource){ mock("Resource", :save => true) }
+
+      before do
+        resource.should_receive(:save)
+      end
+
+      it "should call the before create callback" do
+        controller.should_receive(:call_before_create).with(resource)
+        controller.send :create_resource, resource
+      end
+      it "should call the before save callback" do
+        controller.should_receive(:call_before_save).with(resource)
+        controller.send :create_resource, resource
+      end
+      it "should call the after save callback" do
+        controller.should_receive(:call_after_save).with(resource)
+        controller.send :create_resource, resource
+      end
+      it "should call the after create callback" do
+        controller.should_receive(:call_after_create).with(resource)
+        controller.send :create_resource, resource
+      end
+    end
+
+    describe "performing update" do
+      let(:controller){ Admin::PostsController.new }
+      let(:resource){ mock("Resource", :attributes= => true, :save => true) }
+      let(:attributes){ {} }
+
+      before do
+        resource.should_receive(:attributes=).with(attributes)
+        resource.should_receive(:save)
+      end
+
+      it "should call the before update callback" do
+        controller.should_receive(:call_before_update).with(resource)
+        controller.send :update_resource, resource, attributes
+      end
+      it "should call the before save callback" do
+        controller.should_receive(:call_before_save).with(resource)
+        controller.send :update_resource, resource, attributes
+      end
+      it "should call the after save callback" do
+        controller.should_receive(:call_after_save).with(resource)
+        controller.send :update_resource, resource, attributes
+      end
+      it "should call the after create callback" do
+        controller.should_receive(:call_after_update).with(resource)
+        controller.send :update_resource, resource, attributes
+      end
+    end
+
+    describe "performing destroy" do
+      let(:controller){ Admin::PostsController.new }
+      let(:resource){ mock("Resource", :destroy => true) }
+
+      before do
+        resource.should_receive(:destroy)
+      end
+
+      it "should call the before destroy callback" do
+        controller.should_receive(:call_before_destroy).with(resource)
+        controller.send :destroy_resource, resource
+      end
+
+      it "should call the after destroy callback" do
+        controller.should_receive(:call_after_destroy).with(resource)
+        controller.send :destroy_resource, resource
+      end
     end
   end
 

data/spec/unit/resource_spec.rb

@@ -3,6 +3,8 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 module ActiveAdmin
   describe Resource do
 
+    before { load_defaults! }
+
     let(:namespace){ Namespace.new(:admin) }
 
     def config(options = {})
@@ -66,6 +68,28 @@ module ActiveAdmin
       end
     end
 
+    describe "#include_in_menu?" do
+      let(:namespace){ ActiveAdmin::Namespace.new(: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 "parent menu item name" do
       it "should be nil when not set" do
         config.parent_menu_item_name.should == nil
@@ -85,6 +109,13 @@ module ActiveAdmin
       it "should return the route collection path" do
         config.route_collection_path.should == :admin_categories_path
       end
+
+      context "when in the root namespace" do
+        let(:config){ ActiveAdmin.register Category, :namespace => false}
+        it "should have a nil route_prefix" do
+          config.route_prefix.should == nil
+        end
+      end
     end
 
     describe "page configs" do
@@ -165,17 +196,6 @@ module ActiveAdmin
       end
     end
 
-    describe "dashboard controller name" do
-      context "when namespaced" do
-        subject{ config.dashboard_controller_name }
-        it { should == "Admin::DashboardController" }
-      end
-      context "when not namespaced" do
-        let(:namespace){ ActiveAdmin::Namespace.new(:root) }
-        subject{ config.dashboard_controller_name }
-        it { should == "DashboardController" }
-      end
-    end
 
     describe "sort order" do
       subject { resource_config.sort_order }
@@ -193,5 +213,52 @@ module ActiveAdmin
         it { should == sort_order }
       end
     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
+    
+    describe "admin notes" do
+      context "when not set" do
+        context "when global is true" do
+          before(:each) do
+            ActiveAdmin.admin_notes = true
+          end
+          it "should default to true" do
+            config.admin_notes?.should be_true
+          end
+        end
+        context "when global is false" do
+          before(:each) do
+            ActiveAdmin.admin_notes = false
+          end
+          it "should default to false" do
+            config.admin_notes?.should be_false
+          end
+        end
+      end
+      context "when set" do
+        it "should be set to the local value true" do
+          ActiveAdmin.admin_notes = false
+          config.admin_notes = true
+          config.admin_notes?.should be_true
+        end
+        it "should be set to the local value false" do
+          ActiveAdmin.admin_notes = true
+          config.admin_notes = false
+          config.admin_notes?.should be_false
+        end
+      end
+    end
   end
 end