activeadmin 0.1.0

data/spec/unit/menu_item_spec.rb

@@ -0,0 +1,137 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper') 
+
+module ActiveAdmin
+  describe MenuItem do
+
+    it "should have a name" do
+      item = MenuItem.new("Dashboard", "/admin")
+      item.name.should == "Dashboard"
+    end
+    
+    it "should have a url" do
+      item = MenuItem.new("Dashboard", "/admin")
+      item.url.should == "/admin"
+    end
+    
+    it "should have a priority of 10 by default" do
+      item = MenuItem.new("Dashboard", "/admin")
+      item.priority.should == 10
+    end
+    
+    it "should accept an optional options hash" do
+      item = MenuItem.new("Dashboard", "/admin", 10, :if => lambda{ logged_in? } )
+    end
+    
+    it "should have a display if block" do
+      block = lambda{ logged_in? }
+      item = MenuItem.new("Dashboard", "/admin", 10, :if => block )
+      item.display_if_block.should == block
+    end
+
+    describe "url generation and caching" do
+      it "should generate a url if it is a symbol" do
+        MenuItem.new("Posts", :admin_posts_path).url.should == "/admin/posts"
+      end
+
+      it "should generate a url if it is a string" do
+        MenuItem.new("Posts", "/admin/posts").url.should == "/admin/posts"
+      end
+    end
+    
+    context "with no children" do
+      it "should be empty" do
+        item = MenuItem.new("Blog", "/admin/blog")
+        item.children.should == []
+      end
+      
+      it "should accept new children" do
+        item = MenuItem.new("Blog", "/admin/blog")
+        item.add "Dashboard", "/admin"
+        item.children.first.should be_an_instance_of(MenuItem)
+        item.children.first.name.should == "Dashboard"
+      end
+    end
+    
+    context "with many children" do
+      let(:item) do
+        i = MenuItem.new("Dashboard", "/admin")
+        i.add "Blog",     "/" 
+        i.add "Cars",     "/" 
+        i.add "Users",    "/",  1
+        i.add "Settings", "/",  2
+        i.add "Analytics", "/", 44
+        i
+      end
+      
+      it "should give access to the menu item as an array" do
+        item['Blog'].name.should == 'Blog'
+      end
+      
+      it "should sort items based on priority and name" do    
+        item.children[0].name.should == 'Users'
+        item.children[1].name.should == 'Settings'
+        item.children[2].name.should == 'Blog'
+        item.children[3].name.should == 'Cars'
+        item.children[4].name.should == 'Analytics'
+      end
+      
+      it "children should hold a reference to their parent" do
+        item["Blog"].parent.should == item
+      end
+    end
+    
+    describe "building children using block syntax" do
+      let(:item) do
+        MenuItem.new("Blog", "/") do |blog|
+          blog.add "Create New", "/blog/new"
+          blog.add("Comments", "/blog/comments") do |comments|
+            comments.add "Approved", "/blog/comments?status=approved"
+          end
+        end
+      end
+      
+      it "should have 2 children" do
+        item.children.size.should == 2
+      end
+      
+      it "should have sub-sub items" do
+        item["Comments"]["Approved"].name.should == 'Approved'
+      end
+    end
+    
+    describe "accessing ancestory" do
+      let(:item){ MenuItem.new "Blog", "/blog" }
+      
+      context "with no parent" do
+        it "should return an empty array" do
+         item.ancestors.should == [] 
+        end
+      end
+      
+      context "with one parent" do
+        let(:sub_item) do 
+          item.add "Create New", "/blog/new"
+          item["Create New"]
+        end
+        it "should return an array with the parent" do
+          sub_item.ancestors.should == [item]
+        end
+      end
+      
+      context "with many parents" do
+        before(:each) do
+          item.add "C1", "/c1" do |c1|
+            c1.add "C2", "/c2" do |c2|
+              c2.add "C3", "/c3"
+            end
+          end
+        end
+        let(:sub_item){ item["C1"]["C2"]["C3"] }
+        it "should return an array with the parents in reverse order" do
+          sub_item.ancestors.should == [item["C1"]["C2"], item["C1"], item]
+        end
+      end
+    end # accessing ancestory
+
+  end
+end

data/spec/unit/menu_spec.rb

@@ -0,0 +1,53 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper') 
+
+describe ActiveAdmin::Menu do
+
+  context "with no items" do
+    it "should be empty" do
+      ActiveAdmin::Menu.new.items.should == []
+    end
+    
+    it "should accept new items" do
+      menu = ActiveAdmin::Menu.new
+      menu.add "Dashboard", "/admin"
+      menu.items.first.should be_an_instance_of(ActiveAdmin::MenuItem)
+      menu.items.first.name.should == "Dashboard"
+    end
+    
+    it "should default new items to the priority of 10" do
+      menu = ActiveAdmin::Menu.new
+      menu.add "Dashboard", "/admin"
+      menu.items.first.priority.should == 10
+    end
+  end
+  
+  context "with many item" do
+    let(:menu) do
+      ActiveAdmin::Menu.new do |m|
+        m.add "Dashboard", "/admin"
+        m.add "Blog",      "/admin/blog"
+        m.add "Users",     "/admin/users"
+        m.add "Settings",  "/admin/settings" do |s|
+          s.add "Admin Settings", "/admin/settings/admin" do |as|
+            s.add "User Settings", "/admin/settings/users"
+          end
+        end
+      end
+    end
+
+    it "should give access to the menu item as an array" do
+      menu['Dashboard'].name.should == 'Dashboard'
+    end
+    
+    it "should find the item by a url on the top level" do
+      menu.find_by_url("/admin").name.should == "Dashboard"
+    end
+    
+    it "should find the item deep in the tree" do
+      menu.find_by_url("/admin/settings/users").name.should == "User Settings"
+    end
+    
+  end
+
+end
+

data/spec/unit/namespace_spec.rb

@@ -0,0 +1,107 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper') 
+
+describe ActiveAdmin::Namespace do
+
+  context "when new" do
+    let(:namespace){ ActiveAdmin::Namespace.new(:admin) }
+
+    it "should have a name" do
+      namespace.name.should == :admin
+    end
+
+    it "should have no resources" do
+      namespace.resources.should == {}
+    end
+
+    it "should have an empty menu" do
+      namespace.menu.items.should be_empty
+    end
+  end
+
+  describe "registering a resource" do
+
+    let(:namespace){ ActiveAdmin::Namespace.new(: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.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
+        lambda {
+          namespace.register Category do
+            raise "Hello World"
+          end
+        }.should raise_error
+      end
+    end
+
+    context "with a resource that's namespaced" do
+      before do
+        module ::Mock; class Resource; 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.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
+    end
+
+    describe "adding to the menu" do
+
+      describe "adding as a top level item" do
+        before do
+          namespace.register Category
+        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
+        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
+        # TODO
+        it "should not create a menu item"
+      end
+    end
+
+  end  
+
+end

data/spec/unit/registration_spec.rb

@@ -0,0 +1,46 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper') 
+
+describe "Registering an object to administer" do
+
+  context "with no configuration" do
+    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
+  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.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.should include("hello_world_dashboard_path")
+    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.should_receive(:register)
+
+      ActiveAdmin.register Category, :namespace => false
+    end
+
+    it "should generate a path to the dashboard" do
+      ActiveAdmin.register Category, :namespace => false
+      reload_routes!
+      Rails.application.routes.url_helpers.methods.should include("dashboard_path")
+    end
+  end
+
+end

data/spec/unit/renderer_spec.rb

@@ -0,0 +1,100 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+include ActiveAdmin
+
+describe ActiveAdmin::Renderer do
+
+  context "when initiailizing from a view" do
+    it "should have a view" do
+      view = action_view
+      renderer = Renderer.new(view)
+      renderer.view.should == view
+    end
+
+    it "should assign all local variables from the view" do
+      Renderer.new(action_view(:foo => "bar")).send(:instance_variable_get, "@foo").should == "bar"
+    end
+    
+    it "should assing an instance variable to the view" do
+      view = action_view
+      renderer = Renderer.new(view)
+      renderer.send :set_ivar_on_view, "@my_ivar", 'Hello World'
+      view.instance_variable_get("@my_ivar").should == 'Hello World'
+    end
+  end
+
+  context "when initializing from another renderer" do
+    it "should have the view" do
+      view = action_view
+      renderer = Renderer.new(Renderer.new(view))
+      renderer.view.should == view
+    end
+
+    it "should assign local variables from the renderer" do
+      view = action_view(:foo => 'bar')
+      renderer = Renderer.new(Renderer.new(view))
+      renderer.send(:instance_variable_get, "@foo").should == 'bar'
+    end
+
+    it "should assing an instance variable to the view" do
+      view = action_view
+      renderer = Renderer.new(Renderer.new(view))
+      renderer.send :set_ivar_on_view, "@my_ivar", 'Hello World'
+      view.instance_variable_get("@my_ivar").should == 'Hello World'
+    end    
+  end
+
+  describe "rendering HAML" do
+    before do
+      @haml_renderer = Class.new(Renderer)
+      @haml_renderer.class_eval do
+        def hello_world
+          "Hello World"
+        end
+      end
+    end
+    it "should render haml within the context of the renderer" do
+      @haml_renderer.class_eval do
+        def to_html
+          haml <<-HAML
+%p
+  =hello_world
+          HAML
+        end
+      end
+      @renderer = @haml_renderer.new(action_view)
+      @renderer.to_html.should == "<p>\n  Hello World\n</p>\n"
+    end
+
+    it "should allow for indentation at the start of the template" do
+      @haml_renderer.class_eval do
+        def to_html
+          haml <<-HAML
+            %p
+              =hello_world
+          HAML
+        end
+      end
+      @renderer = @haml_renderer.new(action_view)
+      @renderer.to_html.should == "<p>\n  Hello World\n</p>\n"      
+    end
+  end
+
+  describe "#call_method_or_proc_on" do
+    let(:renderer){ Renderer.new(action_view) }
+    let(:obj){ "Hello World" }
+    it "should return nil if no symbol or proc given" do
+      renderer.send(:call_method_or_proc_on, obj, 1).should == nil
+    end
+    it "should call the method if a symbol is given" do
+      renderer.send(:call_method_or_proc_on, obj, :size).should == obj.size
+    end
+    it "should call the method if a string is given" do
+      renderer.send(:call_method_or_proc_on, obj, "size").should == obj.size
+    end
+    it "should call the proc with the object if a proc is given" do
+      p = Proc.new{|string| string.size }
+      renderer.send(:call_method_or_proc_on, obj, p).should == obj.size
+    end
+  end
+end

data/spec/unit/resource_controller_spec.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+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(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(:"#{page}_config").block.should == block
+      end
+
+      it "should be reset" do
+        Admin::PostsController.send(:"reset_#{page}_config!")
+        Admin::PostsController.send(:"#{page}_config").should == nil
+      end
+    end
+  end
+
+  describe "setting the current tab" do
+    let(:controller) { ActiveAdmin::ResourceController.new }
+    before do 
+      controller.stub!(:active_admin_config => resource)
+      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) }
+      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" }
+    end
+  end
+
+end