saulolso-activeadmin 0.2.2

data/spec/unit/form_builder_spec.rb

@@ -0,0 +1,238 @@
+require 'spec_helper' 
+
+describe ActiveAdmin::FormBuilder do
+  include Arbre::HTML
+  let(:assigns){ {} }
+
+  # Setup an ActionView::Base object which can be used for
+  # generating the form for.
+  let(:helpers) do 
+    view = action_view
+    def view.posts_path
+      "/posts"
+    end
+
+    def view.protect_against_forgery?
+      false
+    end
+
+    def view.url_for(*args)
+      if args.first == {:action => "index"}
+        posts_path
+      else
+        super
+      end
+    end
+
+    view
+  end
+
+  def build_form(options = {}, &block)
+    active_admin_form_for Post.new, options, &block
+  end
+
+  context "in general" 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"
+        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 buttons" 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
+
+  describe "passing in options" do
+    let :body do
+      build_form :html => { :multipart => true } do |f|
+        f.inputs :title
+        f.buttons
+      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 buttons" do
+    it "should generate the form once" do
+      body = build_form do |f|
+        f.inputs do
+          f.input :title
+        end
+        f.buttons
+      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
+      end
+      body.scan(/type=\"submit\"/).size.should == 1
+      body.scan(/class=\"cancel\"/).size.should == 1
+    end
+    it "should generate multiple buttons" do
+      body = build_form do |f|
+        f.buttons do
+          f.commit_button "Create & Continue"
+          f.commit_button "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|
+        f.inputs :title, :body
+      end
+    end
+    it "should have a title input" do
+      body.should have_tag("input", :attributes => { :type => "text",
+                                                          :name => "post[title]" })
+    end
+    it "should have a body textarea" do
+      body.should have_tag("textarea", :attributes => { :name => "post[body]" })
+    end
+  end
+
+  context "with semantic fields for" do
+    let :body do
+      build_form do |f|
+        f.inputs do
+          f.input :title
+          f.input :body
+        end
+        f.instance_eval do
+          @object.author = User.new
+        end
+        f.semantic_fields_for :author do |author|
+          author.inputs :first_name, :last_name
+        end
+      end
+    end
+    it "should generate a nested text input once" do
+      body.scan("post_author_attributes_first_name_input").size.should == 1
+    end
+  end
+
+  context "with collection inputs" do
+    before do
+      User.create :first_name => "John", :last_name => "Doe"
+      User.create :first_name => "Jane", :last_name => "Doe"
+    end
+
+    describe "as select" do
+      let :body do
+        build_form do |f|
+          f.input :author
+        end
+      end
+      it "should create 2 options" do
+        body.scan(/\<option/).size.should == 3
+      end
+    end
+
+    describe "as radio buttons" do
+      let :body do
+        build_form do |f|
+          f.input :author, :as => :radio
+        end
+      end
+      it "should create 2 radio buttons" do
+        body.scan(/type=\"radio\"/).size.should == 2
+      end
+    end
+  end
+
+  context "with inputs 'for'" do
+    let :body do
+      build_form do |f|
+        f.inputs do
+          f.input :title
+          f.input :body
+        end
+        f.instance_eval do
+          @object.author = User.new
+        end
+        f.inputs :name => 'Author', :for => :author do |author|
+          author.inputs :first_name, :last_name
+        end
+      end
+    end
+    it "should generate a nested text input once" do
+      body.scan("post_author_attributes_first_name_input").size.should == 1
+    end
+    it "should add an author first name field" do
+      body.should have_tag("input", :attributes => { :name => "post[author_attributes][first_name]"})
+    end
+  end
+
+  context "with wrapper html" do
+    it "should set a class" do
+      body = build_form do |f|
+        f.input :title, :wrapper_html => { :class => "important" }
+      end
+      body.should have_tag("li", :attributes => {:class => "string optional important"})
+    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\"/,
+  }.each do |source, regex|
+   it "should properly buffer #{source}" do
+     body = build_form do |f|
+       f.inputs do
+         f.instance_eval(source)
+         f.instance_eval(source)
+       end
+     end
+     body.scan(regex).size.should == 2
+   end
+  end
+
+  describe "datepicker input" do
+    let :body do
+      build_form do |f|
+        f.inputs do
+          f.input :created_at, :as => :datepicker
+        end
+      end
+    end
+    it "should generate a text input with the class of datepicker" do
+      body.should have_tag("input", :attributes => {  :type => "text",
+                                                          :class => "datepicker",
+                                                          :name => "post[created_at]" })
+    end
+  end
+
+end

data/spec/unit/menu_item_spec.rb

@@ -0,0 +1,143 @@
+require '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
+    
+    it "should have a default display if block always returning true" do
+      item = MenuItem.new("Dashboard", "/admin")
+      item.display_if_block.should be_instance_of(Proc)
+      item.display_if_block.call(self).should == true
+    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 '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,203 @@
+require 'spec_helper' 
+
+describe ActiveAdmin::Namespace do
+
+  let(:application){ ActiveAdmin::Application.new }
+
+  context "when new" do
+    let(:namespace){ ActiveAdmin::Namespace.new(application, :admin) }
+
+    it "should have an application instance" do
+      namespace.application.should == application
+    end
+
+    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(application, :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.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 dsl" 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; def self.has_many(arg1, arg2); end; 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.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
+        Admin::MockResourcesController.resource_class.should == Mock::Resource
+      end
+    end
+
+    describe "finding resource instances" do
+      let(:namespace){ ActiveAdmin::Namespace.new(application, :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
+        end
+      end
+
+      describe "adding as a child" do
+        before 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
+        end
+        it "should generate its own child item" do
+          namespace.menu['Blog']['Categories'].should_not be_nil
+        end
+      end
+
+      describe "disabling the menu" do
+        before do
+          namespace.register Category do
+            menu false
+          end
+          namespace.load_menu!
+        end
+        it "should not create a menu item" do
+          namespace.menu["Categories"].should be_nil
+        end
+      end
+      
+      describe "setting menu priority" do
+        before do
+          namespace.register Category do
+            menu :priority => 2
+          end
+          namespace.load_menu!
+        end
+        it "should have a custom priority of 2" do
+          namespace.menu["Categories"].priority.should == 2
+        end
+      end
+      
+      describe "setting a condition for displaying" do
+        before do
+          namespace.register Category do
+            menu :if => proc { false }
+          end
+          namespace.load_menu!
+        end
+        it "should have a proc returning false" do
+          namespace.menu["Categories"].display_if_block.should be_instance_of(Proc)
+          namespace.menu["Categories"].display_if_block.call.should == false
+        end
+      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
+
+    describe "dashboard controller name" do
+      context "when namespaced" do
+        it "should be namespaced" do
+          namespace = ActiveAdmin::Namespace.new(application, :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(application, :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