activeadmin 0.1.0

data/spec/unit/resource_spec.rb

@@ -0,0 +1,197 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper') 
+
+module ActiveAdmin
+  describe Resource do
+
+    let(:namespace){ Namespace.new(:admin) }
+
+    def config(options = {})
+      @config ||= Resource.new(namespace, Category, options)
+    end
+
+    describe "underscored resource name" do
+      context "when class" do
+        it "should be the underscored singular resource name" do
+          config.underscored_resource_name.should == "category"
+        end
+      end
+      context "when a class in a module" do
+        it "should underscore the module and the class" do
+          module ::Mock; class Resource; end; end
+          Resource.new(namespace, Mock::Resource).underscored_resource_name.should == "mock_resource"
+        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"
+        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"
+      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 give" do
+        it "should return the custom name" do
+          config(:as => "My Category").resource_name.should == "My Category"
+        end
+      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"
+      end
+      context "when non namespaced controller" do
+        let(:namespace){ ActiveAdmin::Namespace.new(:root) }
+        it "should return a non namespaced controller name" do
+          config.controller_name.should == "CategoriesController"
+        end
+      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 "route names" do
+      let(:config){ ActiveAdmin.register Category }
+      it "should return the route prefix" do
+        config.route_prefix.should == "admin"
+      end
+      it "should return the route collection path" do
+        config.route_collection_path.should == :admin_categories_path
+      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
+      let(:controller){ Admin::CategoriesController.new }
+      let(:begin_of_association_chain){ controller.send(:begin_of_association_chain) }
+
+      context "when using a block" do
+        before do
+          ActiveAdmin.register Category do
+            scope_to do
+              "scoped"
+            end
+          end
+        end
+        it "should call the proc for the begin of association chain" do
+          begin_of_association_chain.should == "scoped"
+        end
+      end
+
+      context "when using a symbol" do
+        before do
+          ActiveAdmin.register Category do
+            scope_to :current_user
+          end
+        end
+        it "should call the method for the begin of association chain" do
+          controller.should_receive(:current_user).and_return(true)
+          begin_of_association_chain.should == true
+        end
+      end
+
+      context "when not using a block or symbol" do
+        before do
+          ActiveAdmin.register Category do
+            scope_to "Some string"
+          end
+        end
+        it "should raise and exception" do
+          lambda {
+            begin_of_association_chain
+          }.should raise_error(ArgumentError)
+        end
+      end
+
+      describe "getting the method for the association chain" do
+        context "when a simple registration" do
+          before do
+            ActiveAdmin.register Category do
+              scope_to :current_user
+            end
+          end
+          it "should return the pluralized collection name" do
+            controller.send(:method_for_association_chain).should == :categories
+          end
+        end
+        context "when passing in the method as an option" do
+          before do
+            ActiveAdmin.register Category do
+              scope_to :current_user, :association_method => :blog_categories
+            end
+          end
+          it "should return the method from the option" do
+            controller.send(:method_for_association_chain).should == :blog_categories
+          end
+        end
+      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 }
+
+      context "by default" do
+        let(:resource_config) { config }
+
+        it { should == ActiveAdmin.default_sort_order }
+      end
+
+      context "when default_sort_order is set" do
+        let(:sort_order)      { "name_desc"                      }
+        let(:resource_config) { config :sort_order => sort_order }
+
+        it { should == sort_order }
+      end
+    end
+  end
+end

data/spec/unit/routing_spec.rb

@@ -0,0 +1,12 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe ActiveAdmin, "Routing" do
+  
+  subject { Admin::PostsController.new }
+
+  it { should respond_to(:admin_posts_path) }
+  it { should respond_to(:admin_post_path) }
+  it { should respond_to(:new_admin_post_path) }
+  it { should respond_to(:edit_admin_post_path) }
+
+end

data/spec/unit/sidebar_spec.rb

@@ -0,0 +1,96 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper') 
+
+describe_with_render ActiveAdmin::Sidebar do
+
+  before :all do
+    load_defaults!
+    reload_routes!
+  end
+
+  # Store the config and set it back after each spec so that we
+  # dont mess with other specs
+  before do
+    @config_before = Admin::PostsController.sidebar_sections
+    Admin::PostsController.clear_sidebar_sections!
+  end
+
+  after(:each) do
+    Admin::PostsController.sidebar_sections = @config_before
+  end
+
+  # Helper method to define a sidebar
+  def sidebar(name, options = {}, &block)
+    Admin::PostsController.class_eval do
+      sidebar(name, options, &block)
+    end    
+  end
+
+  context "when setting with a block" do
+    before do
+      sidebar :my_filters do
+        link_to "My Filters", '#'
+      end
+      get :index
+    end
+    it "should add a new sidebar to @sidebar_sections" do
+      Admin::PostsController.sidebar_sections.size.should == 1
+    end
+    it "should render content in the context of the view" do
+      response.should have_tag("a", "My Filters")
+    end
+    it "should put a title for the section" do
+      response.should have_tag("h3", "My Filters")
+    end
+  end
+
+  context "when only adding to the index action" do
+    before do
+      sidebar(:filters, :only => :index){ }
+    end
+    it "should be available on index" do
+      Admin::PostsController.sidebar_sections_for(:index).size.should == 1
+    end
+    it "should not be available on edit" do
+      Admin::PostsController.sidebar_sections_for(:edit).size.should == 0
+    end
+  end
+
+  context "when adding to all except index action" do
+    before do
+      sidebar(:filters, :except => :index){ }
+    end
+    it "should not be availbale on index" do
+      Admin::PostsController.sidebar_sections_for(:index).size.should == 0
+    end
+    it "should be available on edit" do
+      Admin::PostsController.sidebar_sections_for(:edit).size.should == 1
+    end
+  end
+
+  context "when setting with a class"
+
+  describe "rendering partials" do
+    let(:sections){ [section] }
+    let(:renderer){ ActiveAdmin::Sidebar::Renderer.new(action_view) }
+    let(:render!){ renderer.to_html(sections) }
+
+    context "when a partial name is set" do
+      let(:section){ ActiveAdmin::Sidebar::Section.new(:filters, :partial => 'custom_partial') }
+
+      it "should render the partial" do
+        renderer.should_receive(:render).with('custom_partial').and_return("woot")
+        render!.should include("woot")
+      end
+    end
+
+    context "when no partial name is set" do
+      let(:section){ ActiveAdmin::Sidebar::Section.new(:filters) }
+
+      it "should render the partial based on the name of the sidebar section" do
+        renderer.should_receive(:render).with('filters_sidebar').and_return("woot")
+        render!.should include("woot")
+      end
+    end
+  end
+
+end

data/spec/unit/table_builder_spec.rb

@@ -0,0 +1,162 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+include ActiveAdmin
+
+describe ActiveAdmin::TableBuilder do
+  
+  describe "when creating a simple column" do
+    before(:each) do
+      @builder = TableBuilder.new do |t|
+        t.column :first_name
+      end
+    end
+    
+    it "should set the column title" do
+      @builder.columns.first.title.should == 'First Name'
+    end
+    
+    it "should set the column data" do
+      @builder.columns.first.data.should == :first_name
+    end
+  end
+  
+  it "should generate multiple columns" do
+    builder = TableBuilder.new do |t|
+      t.column :username
+      t.column :last_name
+    end
+    builder.columns.size.should == 2
+  end
+  
+  describe 'when creating a column with a title' do
+    before(:each) do
+      @builder = TableBuilder.new do |t|
+        t.column 'My Great Username', :username
+      end
+    end
+    
+    it "should set the column title" do
+      @builder.columns.first.title.should == 'My Great Username'
+    end
+    
+    it "should set the column data" do
+      @builder.columns.first.data.should == :username
+    end
+  end
+  
+  describe 'when creating a column with a title and a block as the data' do
+    before(:each) do
+      @builder = TableBuilder.new do |t|
+        t.column('Username'){ |u| u.username }
+      end
+    end
+    
+    it "should set the column title" do
+      @builder.columns.first.title.should == 'Username'
+    end
+    
+    it "should set the column data" do
+      @builder.columns.first.data.should be_a(Proc)
+    end
+  end
+
+  describe "column sorting" do
+    before(:each) do
+      @builder = TableBuilder.new
+    end
+
+    it "should default to true" do
+      @builder.column :username
+      @builder.columns.first.should be_sortable
+    end
+
+    it "should be set with a symbol" do
+      @builder.column :username, :sortable => false
+      @builder.columns.first.should_not be_sortable
+    end
+
+    it "should be set with a string and a symbol" do
+      @builder.column "Username", :username, :sortable => false
+      @builder.columns.first.should_not be_sortable
+    end
+
+    it "should set the default sort key to the column symbol data" do
+      @builder.column :username
+      @builder.columns.first.sort_key.should == "username"
+    end
+
+    it "should not be sortable if a block given and no sort key" do
+      @builder.column('Username'){ @user.username }
+      @builder.columns.first.should_not be_sortable
+    end
+
+    it "should be sortable if a block given and a string to sortable" do
+      @builder.column('Username', :sortable => 'username'){ @user.pretty_username }
+      @builder.columns.first.should be_sortable
+      @builder.columns.first.sort_key.should == 'username'
+    end
+    
+    it "should be sortable if a block given and a symbol to sortable" do
+      @builder.column('Username', :sortable => :username){ @user.pretty_username }
+      @builder.columns.first.should be_sortable
+      @builder.columns.first.sort_key.should == 'username'
+    end
+  end
+
+  describe "column conditionals" do
+    before(:each) do
+      @builder = TableBuilder.new
+    end
+    it "should default to true" do
+      @builder.column :username
+      @builder.columns.first.conditional_block.call.should be_true
+    end
+    it "should accept a lamdba" do
+      @builder.column :username, :if => proc{ false }
+      @builder.columns.first.conditional_block.call.should be_false
+    end
+  end
+
+
+  it "should generate many columns" do
+    builder = TableBuilder.new do |t|
+      t.columns :first, :second, :third
+    end
+    builder.columns.size.should == 3
+    builder.columns.first.data.should == :first
+  end
+
+  include ActiveAdminIntegrationSpecHelper
+
+  describe "rendering" do
+
+    let(:collection) { [ "Hello World", "Ruby Rocks", "Foo Bar" ] }
+    let(:table_builder) do
+      TableBuilder.new do |t|
+        t.column :to_s
+        t.column :size
+        t.column("Underscored"){|string| string.underscore }
+      end
+    end
+    let(:table) { TableBuilder::Renderer.new(action_view).to_html(table_builder,collection) }
+
+    context "when a table of objects" do
+      it "should have 3 rows and 1 header row" do
+        table.scan('<tr').size.should == 3
+      end
+    end
+
+    context "when unescaped html" do
+      let(:table_builder) do
+        TableBuilder.new do |t|
+          t.column(''){ "<h2>scary html</h2>" }
+        end
+      end
+      it "should escape the html" do
+        table.should_not include("<h2>scary html</h2>")
+      end
+    end
+
+  end
+    
+end