activeadmin 0.4.4 → 0.5.0.pre

data/spec/unit/filters/resource_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe ActiveAdmin::Filters::ResourceExtension do
+
+  let(:resource) do
+    namespace = ActiveAdmin::Namespace.new(ActiveAdmin::Application.new, :admin)
+    namespace.register(Post)
+  end
+
+  it "should return the defaults if no filters are set" do
+    resource.filters.map{|f| f[:attribute].to_s }.sort.should == %w{
+      author body category created_at published_at title updated_at
+    }
+  end
+
+  it "should not have defaults when filters are disabled on the resource" do
+    resource.filters = false
+    resource.filters.should be_empty
+  end
+
+  it "should not have defaults when the filters are disabled on the namespace" do
+    resource.namespace.filters = false
+    resource.filters.should be_empty
+  end
+
+  it "should not have defaults when the filters are disabled on the application" do
+    resource.namespace.application.filters = false
+    resource.filters.should be_empty
+  end
+
+  it "should add a filter" do
+    resource.add_filter :title
+    resource.filters.should == [{:attribute => :title}]
+  end
+
+  it "should add a filter with options" do
+    resource.add_filter :title, :as => :string
+    resource.filters.should == [{:attribute => :title, :as => :string}]
+  end
+
+  it "should raise an exception if trying to add a filter when they are disabled" do
+    resource.filters = false
+    expect {
+      resource.add_filter :title
+    }.should raise_error(RuntimeError)
+  end
+
+  it "should reset filters" do
+    resource.add_filter :title
+    resource.filters.size.should == 1
+    resource.reset_filters!
+    resource.filters.size.should > 1
+  end
+
+  it "should add a sidebar section for the filters" do
+    resource.sidebar_sections.first.name.should == :filters
+  end
+
+
+end

data/spec/unit/form_builder_spec.rb

@@ -1,12 +1,10 @@
-require 'spec_helper' 
+require 'spec_helper'
 
 describe ActiveAdmin::FormBuilder do
 
-  setup_arbre_context!
-
   # Setup an ActionView::Base object which can be used for
   # generating the form for.
-  let(:helpers) do 
+  let(:helpers) do
     view = action_view
     def view.posts_path
       "/posts"
@@ -31,21 +29,56 @@ describe ActiveAdmin::FormBuilder do
     view
   end
 
-  def build_form(options = {}, &block)
-    options.merge!({:url => posts_path})
-    active_admin_form_for Post.new, options, &block
+  def build_form(options = {}, form_object = Post.new, &block)
+    options = {:url => helpers.posts_path}.merge(options)
+
+    render_arbre_component({:form_object => form_object, :form_options => options, :form_block => block}, helpers)do
+      text_node active_admin_form_for(assigns[:form_object], assigns[:form_options], &assigns[:form_block])
+    end.to_s
   end
 
-  context "in general" do
+  context "in general with actions" do
     let :body do
       build_form do |f|
         f.inputs do
           f.input :title
           f.input :body
         end
-        f.buttons do
-          f.commit_button "Submit Me"
-          f.commit_button "Another Button"
+        f.actions do
+          f.action :submit, :label => "Submit Me"
+          f.action :submit, :label => "Another Button"
+        end
+      end
+    end
+
+   it "should generate a text input" do
+      body.should have_tag("input", :attributes => { :type => "text",
+                                                     :name => "post[title]" })
+    end
+    it "should generate a textarea" do
+      body.should have_tag("textarea", :attributes => { :name => "post[body]" })
+    end
+    it "should only generate the form once" do
+      body.scan(/Title/).size.should == 1
+    end
+    it "should generate actions" do
+      body.should have_tag("input", :attributes => {  :type => "submit",
+                                                          :value => "Submit Me" })
+      body.should have_tag("input", :attributes => {  :type => "submit",
+                                                          :value => "Another Button" })
+    end
+  end
+
+  context "in general with actions" do
+    let :body do
+      build_form do |f|
+        f.inputs do
+          f.input :title
+          f.input :body
+        end
+        f.actions do
+          f.action :submit, :button_html => { :value => "Submit Me" }
+          f.action :submit, :button_html => { :value => "Another Button" }
         end
       end
     end
@@ -60,7 +93,7 @@ describe ActiveAdmin::FormBuilder do
     it "should only generate the form once" do
       body.scan(/Title/).size.should == 1
     end
-    it "should generate buttons" do
+    it "should generate actions" do
       body.should have_tag("input", :attributes => {  :type => "submit",
                                                           :value => "Submit Me" })
       body.should have_tag("input", :attributes => {  :type => "submit",
@@ -72,18 +105,18 @@ describe ActiveAdmin::FormBuilder do
     it "should raise error" do
       lambda {
         comment = ActiveAdmin::Comment.new
-        active_admin_form_for comment, :url => "admins/comments" do |f|
+        build_form({:url => "admins/comments"}, comment) do |f|
           f.inputs :resource
         end
       }.should raise_error(Formtastic::PolymorphicInputWithoutCollectionError)
     end
   end
 
-  describe "passing in options" do
+  describe "passing in options with actions" do
     let :body do
       build_form :html => { :multipart => true } do |f|
         f.inputs :title
-        f.buttons
+        f.actions
       end
     end
     it "should pass the options on to the form" do
@@ -91,28 +124,41 @@ describe ActiveAdmin::FormBuilder do
     end
   end
 
-  context "with buttons" do
+  describe "passing in options with actions" do
+    let :body do
+      build_form :html => { :multipart => true } do |f|
+        f.inputs :title
+        f.actions
+      end
+    end
+    it "should pass the options on to the form" do
+      body.should have_tag("form", :attributes => { :enctype => "multipart/form-data" })
+    end
+  end
+
+
+  context "with actions" do
     it "should generate the form once" do
       body = build_form do |f|
         f.inputs do
           f.input :title
         end
-        f.buttons
+        f.actions
       end
       body.scan(/id=\"post_title\"/).size.should == 1
     end
     it "should generate one button and a cancel link" do
       body = build_form do |f|
-        f.buttons
+        f.actions
       end
       body.scan(/type=\"submit\"/).size.should == 1
       body.scan(/class=\"cancel\"/).size.should == 1
     end
-    it "should generate multiple buttons" do
+    it "should generate multiple actions" do
       body = build_form do |f|
-        f.buttons do
-          f.commit_button "Create & Continue"
-          f.commit_button "Create & Edit"
+        f.actions do
+          f.action :submit, :label => "Create & Continue"
+          f.action :submit, :label => "Create & Edit"
         end
       end
       body.scan(/type=\"submit\"/).size.should == 2
@@ -121,6 +167,35 @@ describe ActiveAdmin::FormBuilder do
 
   end
 
+  context "with actons" do
+    it "should generate the form once" do
+      body = build_form do |f|
+        f.inputs do
+          f.input :title
+        end
+        f.actions
+      end
+      body.scan(/id=\"post_title\"/).size.should == 1
+    end
+    it "should generate one button and a cancel link" do
+      body = build_form do |f|
+        f.actions
+      end
+      body.scan(/type=\"submit\"/).size.should == 1
+      body.scan(/class=\"cancel\"/).size.should == 1
+    end
+    it "should generate multiple actions" do
+      body = build_form do |f|
+        f.actions do
+          f.action :submit, :label => "Create & Continue"
+          f.action :submit, :label => "Create & Edit"
+        end
+      end
+      body.scan(/type=\"submit\"/).size.should == 2
+      body.scan(/class=\"cancel\"/).size.should == 0
+    end
+  end
+
   context "without passing a block to inputs" do
     let :body do
       build_form do |f|
@@ -218,13 +293,90 @@ describe ActiveAdmin::FormBuilder do
     end
   end
 
+  context "with has many inputs" do
+    describe "with simple block" do
+      let :body do
+        build_form({:url => '/categories'}, Category.new) do |f|
+          f.object.posts.build
+          f.has_many :posts do |p|
+            p.input :title
+          end
+        end
+      end
+
+      it "should translate the association name in header" do
+        begin
+          I18n.backend.store_translations(:en, :activerecord => { :models => { :post => { :one => "Blog Post", :other => "Blog Posts" } } })
+          body.should have_tag('h3', 'Blog Posts')
+        ensure
+          I18n.backend.reload!
+        end
+      end
+
+      it "should use model name when there is no translation for given model in header" do
+        body.should have_tag('h3', 'Post')
+      end
+
+      it "should translate the association name in has many new button" do
+        begin
+          I18n.backend.store_translations(:en, :activerecord => { :models => { :post => { :one => "Blog Post", :other => "Blog Posts" } } })
+          body.should have_tag('a', 'Add New Blog Post')
+        ensure
+          I18n.backend.reload!
+        end
+      end
+
+      it "should use model name when there is no translation for given model in has many new button" do
+        body.should have_tag('a', 'Add New Post')
+      end
+
+      it "should render the nested form" do
+        body.should have_tag("input", :attributes => {:name => "category[posts_attributes][0][title]"})
+      end
+
+      it "should add a link to remove new nested records" do
+        Capybara.string(body).should have_css(".has_many > fieldset > ol > li > a", :class => "button", :href => "#", :content => "Delete")
+      end
+
+      it "should add a link to add new nested records" do
+        Capybara.string(body).should have_css(".has_many > fieldset > ol > li > a", :class => "button", :href => "#", :content => "Add New Post")
+      end
+    end
+
+    describe "with complex block" do
+      let :body do
+        build_form({:url => '/categories'}, Category.new) do |f|
+          f.object.posts.build
+          f.has_many :posts do |p,i|
+            p.input :title, :label => "Title #{i}"
+          end
+        end
+      end
+
+      it "should accept a block with a second argument" do
+        body.should have_tag("label", "Title 1")
+      end
+    end
+
+    pending "should render the block if it returns nil" do
+      body = build_form({:url => '/categories'}, Category.new) do |f|
+        f.object.posts.build
+        f.has_many :posts do |p|
+          p.input :title
+          nil
+        end
+      end
+
+      body.should have_tag("input", :attributes => {:name => "category[posts_attributes][0][title]"})
+    end
+  end
 
-  { 
-    "input :title, :as => :string"        => /id\=\"post_title\"/,
-    "input :title, :as => :text"          => /id\=\"post_title\"/,
-    "input :created_at, :as => :time"     => /id\=\"post_created_at_2i\"/,
-    "input :created_at, :as => :datetime" => /id\=\"post_created_at_2i\"/,
-    "input :created_at, :as => :date"     => /id\=\"post_created_at_2i\"/,
+  {
+    "input :title, :as => :string"               => /id\=\"post_title\"/,
+    "input :title, :as => :text"                 => /id\=\"post_title\"/,
+    "input :created_at, :as => :time_select"     => /id\=\"post_created_at_2i\"/,
+    "input :created_at, :as => :datetime_select" => /id\=\"post_created_at_2i\"/,
+    "input :created_at, :as => :date_select"     => /id\=\"post_created_at_2i\"/,
   }.each do |source, regex|
    it "should properly buffer #{source}" do
      body = build_form do |f|

data/spec/unit/helpers/collection_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe ActiveAdmin::Helpers::Collection do
+
+  include ActiveAdmin::Helpers::Collection
+
+  before(:all) do
+    Post.delete_all
+    Post.create!(:title => "A post")
+    Post.create!(:title => "A post")
+    Post.create!(:title => "An other post")
+  end
+
+  after(:all) do
+    Post.delete_all
+  end
+
+  describe "#collection_size" do
+    it "should return the collection size for an ActiveRecord class" do
+      collection_size(Post).should == 3
+    end
+
+    it "should return the collection size for an ActiveRecord::Relation" do
+      collection_size(Post.where(:title => "A post")).should == 2
+    end
+
+    it "should return the collection size for a collection with group by" do
+      collection_size(Post.group(:title)).should == 2
+    end
+
+    it "should return the collection size for a collection with group by, select and custom order" do
+      collection_size(Post.select("title, count(*) as nb_posts").group(:title).order("nb_posts")).should == 2
+    end
+
+    it "should take the defined collection by default" do
+      def collection; Post; end
+
+      collection_size.should == 3
+
+      def collection; Post.where(:title => "An other post"); end
+
+      collection_size.should == 1
+    end
+  end
+
+  describe "#collection_is_empty?" do
+    it "should return true when the collection is empty" do
+      collection_is_empty?(Post.where(:title => "Non existing post")).should be_true
+    end
+
+    it "should return false when the collection is not empty" do
+      collection_is_empty?(Post.where(:title => "A post")).should be_false
+    end
+
+    it "should take the defined collection by default" do
+      def collection; Post; end
+
+      collection_is_empty?.should be_false
+
+      def collection; Post.where(:title => "Non existing post"); end
+
+      collection_is_empty?.should be_true
+    end
+  end
+end

data/spec/unit/menu_item_spec.rb

@@ -1,75 +1,72 @@
 require 'spec_helper_without_rails'
+require 'active_admin/menu'
 require 'active_admin/menu_item'
 
 module ActiveAdmin
   describe MenuItem do
 
-    it "should have a name" do
-      item = MenuItem.new("Dashboard", "/admin")
-      item.name.should == "Dashboard"
+    it "should have a label" do
+      item = MenuItem.new(:label => "Dashboard")
+      item.label.should == "Dashboard"
     end
 
     it "should have a url" do
-      item = MenuItem.new("Dashboard", "/admin")
+      item = MenuItem.new(:url => "/admin")
       item.url.should == "/admin"
     end
 
     it "should have a priority of 10 by default" do
-      item = MenuItem.new("Dashboard", "/admin")
+      item = MenuItem.new
       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 = MenuItem.new(:if => block )
       item.display_if_block.should == block
     end
 
     it "should have a default display if block always returning true" do
-      item = MenuItem.new("Dashboard", "/admin")
+      item = MenuItem.new
       item.display_if_block.should be_instance_of(Proc)
       item.display_if_block.call(self).should == true
     end
 
     context "with no children" do
       it "should be empty" do
-        item = MenuItem.new("Blog", "/admin/blog")
+        item = MenuItem.new
         item.children.should == []
       end
 
       it "should accept new children" do
-        item = MenuItem.new("Blog", "/admin/blog")
-        item.add "Dashboard", "/admin"
+        item = MenuItem.new
+        item.add MenuItem.new(:label => "Dashboard")
         item.children.first.should be_an_instance_of(MenuItem)
-        item.children.first.name.should == "Dashboard"
+        item.children.first.label.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 = MenuItem.new(:label => "Dashboard")
+        i.add MenuItem.new(:label => "Blog")
+        i.add MenuItem.new(:label => "Cars")
+        i.add MenuItem.new(:label => "Users", :priority => 1)
+        i.add MenuItem.new(:label => "Settings", :priority => 2)
+        i.add MenuItem.new(:label => "Analytics", :priority => 44)
         i
       end
 
       it "should give access to the menu item as an array" do
-        item['Blog'].name.should == 'Blog'
+        item['Blog'].label.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'
+        item.children[0].label.should == 'Users'
+        item.children[1].label.should == 'Settings'
+        item.children[2].label.should == 'Blog'
+        item.children[3].label.should == 'Cars'
+        item.children[4].label.should == 'Analytics'
       end
 
       it "children should hold a reference to their parent" do
@@ -77,27 +74,8 @@ module ActiveAdmin
       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" }
+      let(:item){ MenuItem.new :label => "Blog" }
 
       context "with no parent" do
         it "should return an empty array" do
@@ -107,7 +85,7 @@ module ActiveAdmin
 
       context "with one parent" do
         let(:sub_item) do 
-          item.add "Create New", "/blog/new"
+          item.add MenuItem.new(:label => "Create New")
           item["Create New"]
         end
         it "should return an array with the parent" do
@@ -117,11 +95,15 @@ module ActiveAdmin
 
       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
+          c1 = MenuItem.new(:label => "C1")
+          c2 = MenuItem.new(:label => "C2")
+          c3 = MenuItem.new(:label => "C3")
+
+          item.add(c1)
+          c1.add c2
+          c2.add c3
+
+          item
         end
         let(:sub_item){ item["C1"]["C2"]["C3"] }
         it "should return an array with the parents in reverse order" do
@@ -130,5 +112,18 @@ module ActiveAdmin
       end
     end # accessing ancestory
 
+
+    describe ".generate_item_id" do
+
+      it "downcases the id" do
+        MenuItem.generate_item_id("Identifier").should == "identifier"
+      end
+
+      it "should set underscore any spaces" do
+        MenuItem.generate_item_id("An Id").should == "an_id"
+      end
+
+    end
+
   end
 end