activeadmin 0.1.1 → 0.2.0

data/spec/unit/event_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+require 'active_admin/event'
+
+describe ActiveAdmin::EventDispatcher do
+
+  let(:test_event){ 'active_admin.test_event' }
+  let(:dispatcher){ ActiveAdmin::EventDispatcher.new }
+
+  it "should add a subscriber for an event" do
+    dispatcher.subscribers(test_event).size.should == 0
+    dispatcher.subscribe(test_event){ true }
+    dispatcher.subscribers(test_event).size.should == 1
+  end
+
+  it "should call the dispatch block with no arguments" do
+    dispatcher.subscribe(test_event){ raise StandardError, "From Event Handler" }
+    lambda {
+      dispatcher.dispatch(test_event)
+    }.should raise_error(StandardError, "From Event Handler")
+  end
+
+  it "should call the dispatch block with one argument" do
+    arg = nil
+    dispatcher.subscribe(test_event){|passed_in| arg = passed_in }
+    dispatcher.dispatch(test_event, "My Arg")
+    arg.should == "My Arg"
+  end
+
+  it "should clear all subscribers" do
+    dispatcher.subscribe(test_event){ false }
+    dispatcher.subscribe(test_event + "_2"){ false }
+    dispatcher.clear_all_subscribers!
+    dispatcher.subscribers(test_event).size.should == 0
+    dispatcher.subscribers(test_event + "_2").size.should == 0
+  end
+
+  it "should have a dispatcher available from ActiveAdmin::Event" do
+    ActiveAdmin::Event.should be_an_instance_of(ActiveAdmin::EventDispatcher)
+  end
+
+end

data/spec/unit/filter_form_builder_spec.rb

@@ -1,157 +1,179 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper') 
 
 
-describe_with_render ActiveAdmin::FormBuilder do
+describe ActiveAdmin::ViewHelpers::FilterFormHelper 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.collection_path
+      "/posts"
+    end
 
-  def reset!
-    Admin::PostsController.reset_filters!
-  end
+    def view.protect_against_forgery?
+      false
+    end
 
-  def filter(*args)
-    Admin::PostsController.filter *args
+    view
   end
 
-  before do
-    @john = User.create :first_name => "John", :last_name => "Doe", :username => "john_doe"
-    @jane = User.create :first_name => "Jane", :last_name => "Doe", :username => "jane_doe"
-    reset!
-    filter :title
-    filter :body
-    filter :created_at
-    filter :id
-    filter :author
-    get :index
+  def filter(name, options = {})
+    search = Post.search
+    active_admin_filters_form_for(search, [options.merge(:attribute => name)])
   end
 
-  after(:each) do
-    reset!
-  end
+  describe "the form in general" do
+    let(:body) { filter :title }
 
-  it "should generate a form which submits via get" do
-    response.should have_tag("form", :attributes => { :method => 'get' })
-  end
+    it "should generate a form which submits via get" do
+      body.should have_tag("form", :attributes => { :method => 'get' })
+    end
 
-  it "should generate a filter button" do
-    response.should have_tag("input", :attributes => { :type => "submit",
+    it "should generate a filter button" do
+      body.should have_tag("input", :attributes => { :type => "submit",
                                                         :value => "Filter" })
-  end
+    end
 
-  it "should generate a search field for a string attribute" do
-    response.should have_tag("input", :attributes => { :name => "q[title_contains]"})
-  end
+    it "should only generate the form once" do
+      body.scan(/q\[title_contains\]/).size.should == 1
+    end
 
-  it "should label a text field with search" do
-    response.should have_tag('label', 'Search Title')
+    it "should generate a clear filters link" do
+      body.should have_tag("a", "Clear Filters", :attributes => { :class => "clear_filters_btn" })
+    end
   end
 
-  it "should generate a search field for a text attribute" do
-    response.should have_tag("input", :attributes => { :name => "q[body_contains]"})
-  end
+  describe "string attribute" do
+    let(:body) { filter :title }
+
+    it "should generate a search field for a string attribute" do
+      body.should have_tag("input", :attributes => { :name => "q[title_contains]"})
+    end
 
-  it "should only generate the form once" do
-    response.body.scan(/q\[title_contains\]/).size.should == 1
+    it "should label a text field with search" do
+      body.should have_tag('label', 'Search Title')
+    end
   end
 
-  it "should generate a clear filters link" do
-    response.should have_tag("a", "Clear Filters", :attributes => { :class => "clear_filters_btn" })
+  describe "text attribute" do
+    let(:body) { filter :body }
+
+    it "should generate a search field for a text attribute" do
+      body.should have_tag("input", :attributes => { :name => "q[body_contains]"})
+    end
+
+    it "should label a text field with search" do
+      body.should have_tag('label', 'Search Body')
+    end
   end
 
-  context "when date" do
+  describe "datetime attribute" do
+    let(:body) { filter :created_at }
+
     it "should generate a date greater than" do
-      response.should have_tag("input", :attributes => { :name => "q[created_at_gte]", :class => "datepicker"})
+      body.should have_tag("input", :attributes => { :name => "q[created_at_gte]", :class => "datepicker"})
     end
     it "should generate a date less than" do
-      response.should have_tag("input", :attributes => { :name => "q[created_at_lte]", :class => "datepicker"})
+      body.should have_tag("input", :attributes => { :name => "q[created_at_lte]", :class => "datepicker"})
     end
   end
 
-  context "when integer" do
+  describe "integer attribute" do
+    let(:body) { filter :id }
+
     it "should generate a select option for equal to" do
-      response.should have_tag("option", "Equal To", :attributes => { :value => 'id_eq' })
+      body.should have_tag("option", "Equal To", :attributes => { :value => 'id_eq' })
     end
     it "should generate a select option for greater than" do
-      response.should have_tag("option", "Greater Than")
+      body.should have_tag("option", "Greater Than")
     end
     it "should generate a select option for less than" do
-      response.should have_tag("option", "Less Than")
+      body.should have_tag("option", "Less Than")
     end
     it "should generate a text field for input" do
-      response.should have_tag("input", :attributes => {
-                                          :name => "q[id_equals]" })
+      body.should have_tag("input", :attributes => {
+                                          :name => /q\[(id_eq|id_equals)\]/ })
     end
     it "should select the option which is currently being filtered"
   end
 
-  context "when belong to" do
+  describe "belong to" do
+    before do
+      @john = User.create :first_name => "John", :last_name => "Doe", :username => "john_doe"
+      @jane = User.create :first_name => "Jane", :last_name => "Doe", :username => "jane_doe"
+    end
 
     context "when given as the _id attribute name" do
-      before do
-        filter :author_id
-        get :index
-      end
+      let(:body) { filter :author_id }
+
       it "should not render as an integer" do
-        response.should_not have_tag("input", :attributes => {
+        body.should_not have_tag("input", :attributes => {
                                                 :name => "q[author_id_eq]"})
       end
       it "should render as belongs to select" do
-        response.should have_tag("select", :attributes => {
+        body.should have_tag("select", :attributes => {
                                             :name => "q[author_id_eq]"})
-        response.should have_tag("option", "jane_doe", :attributes => {
+        body.should have_tag("option", "jane_doe", :attributes => {
                                                           :value => @jane.id })
       end
     end
 
-    context "as select" do
+    context "when given as the name of the relationship" do
+      let(:body) { filter :author }
+
       it "should generate a select" do
-        response.should have_tag("select", :attributes => {
+        body.should have_tag("select", :attributes => {
                                             :name => "q[author_id_eq]"})
       end
       it "should set the default text to 'Any'" do
-        response.should have_tag("option", "Any", :attributes => {
+        body.should have_tag("option", "Any", :attributes => {
                                                     :value => "" })
       end
       it "should create an option for each related object" do
-        response.should have_tag("option", "john_doe", :attributes => {
+        body.should have_tag("option", "john_doe", :attributes => {
                                                           :value => @john.id })
-        response.should have_tag("option", "jane_doe", :attributes => {
+        body.should have_tag("option", "jane_doe", :attributes => {
                                                           :value => @jane.id })
       end
+
       context "with a proc" do
-        before do
-          reset!
+        let :body do
           filter :title, :as => :select, :collection => proc{ ['Title One', 'Title Two'] }
-          get :index
         end
+
         it "should use call the proc as the collection" do
-          response.should have_tag("option", "Title One")
-          response.should have_tag("option", "Title Two")
+          body.should have_tag("option", "Title One")
+          body.should have_tag("option", "Title Two")
         end
       end
     end
 
     context "as check boxes" do
-      before do
-        filter :author, :as => :check_boxes
-        get :index
-      end
+      let(:body) { filter :author, :as => :check_boxes }
+
       it "should create a check box for each related object" do
-        response.should have_tag("input", :attributes => {
+        body.should have_tag("input", :attributes => {
                                             :name => "q[author_id_in][]",
                                             :type => "checkbox",
                                             :value => @john.id })
-        response.should have_tag("input", :attributes => {
+        body.should have_tag("input", :attributes => {
                                             :name => "q[author_id_in][]",
                                             :type => "checkbox",          
                                             :value => @jane.id })
       end
     end
-  end # belongs to
 
-  describe "default filters" do
-    it "should order by association, then content columns" do
-      attributes = controller.class.default_filters_config.collect{|f| f[:attribute] }
-      attributes.should == [ :author, :title, :body, :published_at, :created_at, :updated_at ]
+    context "when polymorphic relationship" do
+      let(:body) do
+        search = ActiveAdmin::Comment.search
+        active_admin_filters_form_for(search, [{ :attribute => :resource}])
+      end
+      it "should not generate any field" do
+        body.should have_tag("form", :attributes => { :method => 'get' })
+      end
     end
-  end
-
+  end # belongs to
 end

data/spec/unit/form_builder_spec.rb

@@ -1,118 +1,127 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper') 
 
-describe_with_render ActiveAdmin::FormBuilder do
+describe ActiveAdmin::FormBuilder do
+  include Arbre::HTML
+  let(:assigns){ {} }
 
-  def build_form(&block)
-    Admin::PostsController.form(&block)
-    get :new
+  # 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
-    before do
+    let :body do
       build_form do |f|
         f.inputs do
           f.input :title
           f.input :body
         end
-        f.label :title, "My Super Title"
-        f.text_field :title
         f.buttons do
-          f.submit "My Submit Button"
           f.commit_button "Submit Me"
           f.commit_button "Another Button"
         end
       end
     end
+
     it "should generate a text input" do
-      response.should have_tag("input", :attributes => { :type => "text",
+      body.should have_tag("input", :attributes => { :type => "text",
                                                      :name => "post[title]" })
     end
-    it "should generate a label using the default form methods" do
-      response.should have_tag("label", "My Super Title")
-    end
     it "should generate a textarea" do
-      response.should have_tag("textarea", :attributes => { :name => "post[body]" })
+      body.should have_tag("textarea", :attributes => { :name => "post[body]" })
     end
     it "should only generate the form once" do
-      response.body.scan(/My Super Title/).size.should == 1
+      body.scan(/Title/).size.should == 1
     end
     it "should generate buttons" do
-      response.should have_tag("input", :attributes => {  :type => "submit",
+      body.should have_tag("input", :attributes => {  :type => "submit",
                                                           :value => "Submit Me" })
-      response.should have_tag("input", :attributes => {  :type => "submit",
+      body.should have_tag("input", :attributes => {  :type => "submit",
                                                           :value => "Another Button" })
     end
   end
 
   describe "passing in options" do
-    before do
-      Admin::PostsController.form :html => { :multipart => true } do |f|
+    let :body do
+      build_form :html => { :multipart => true } do |f|
         f.inputs :title
         f.buttons
       end
-      get :new
     end
     it "should pass the options on to the form" do
-      response.should have_tag("form", :attributes => { :enctype => "multipart/form-data" })
-    end
-  end
-
-  context "with default settings" do
-    before do
-      Admin::PostsController.reset_form_config!
-      get :new
-    end
-    it "should generate one post title field" do
-      response.body.scan('id="post_title"').size.should == 1
+      body.should have_tag("form", :attributes => { :enctype => "multipart/form-data" })
     end
   end
 
   context "with buttons" do
     it "should generate the form once" do
-      build_form do |f|
+      body = build_form do |f|
         f.inputs do
           f.input :title
         end
         f.buttons
       end
-      response.body.scan(/id=\"post_title\"/).size.should == 1
+      body.scan(/id=\"post_title\"/).size.should == 1
     end
-    it "should generate one button" do
-      build_form do |f|
+    it "should generate one button and a cancel link" do
+      body = build_form do |f|
         f.buttons
       end
-      response.body.scan(/type=\"submit\"/).size.should == 1
+      body.scan(/type=\"submit\"/).size.should == 1
+      body.scan(/class=\"cancel\"/).size.should == 1
     end
     it "should generate multiple buttons" do
-      build_form do |f|
+      body = build_form do |f|
         f.buttons do
-          f.submit "Create"
           f.commit_button "Create & Continue"
           f.commit_button "Create & Edit"
         end
       end
-      response.body.scan(/type=\"submit\"/).size.should == 3
+      body.scan(/type=\"submit\"/).size.should == 2
+      body.scan(/class=\"cancel\"/).size.should == 0
     end
 
   end
 
   context "without passing a block to inputs" do
-    before do
+    let :body do
       build_form do |f|
         f.inputs :title, :body
       end
     end
     it "should have a title input" do
-      response.should have_tag("input", :attributes => { :type => "text",
+      body.should have_tag("input", :attributes => { :type => "text",
                                                           :name => "post[title]" })
     end
     it "should have a body textarea" do
-      response.should have_tag("textarea", :attributes => { :name => "post[body]" })
+      body.should have_tag("textarea", :attributes => { :name => "post[body]" })
     end
   end
 
   context "with semantic fields for" do
-    before do
+    let :body do
       build_form do |f|
         f.inputs do
           f.input :title
@@ -127,7 +136,7 @@ describe_with_render ActiveAdmin::FormBuilder do
       end
     end
     it "should generate a nested text input once" do
-      response.body.scan("post_author_attributes_first_name_input").size.should == 1
+      body.scan("post_author_attributes_first_name_input").size.should == 1
     end
   end
 
@@ -138,30 +147,30 @@ describe_with_render ActiveAdmin::FormBuilder do
     end
 
     describe "as select" do
-      before do
+      let :body do
         build_form do |f|
           f.input :author
         end
       end
       it "should create 2 options" do
-        response.body.scan(/\<option/).size.should == 3
+        body.scan(/\<option/).size.should == 3
       end
     end
 
     describe "as radio buttons" do
-      before do
+      let :body do
         build_form do |f|
           f.input :author, :as => :radio
         end
       end
       it "should create 2 radio buttons" do
-        response.body.scan(/type=\"radio\"/).size.should == 2
+        body.scan(/type=\"radio\"/).size.should == 2
       end
     end
   end
 
   context "with inputs 'for'" do
-    before do
+    let :body do
       build_form do |f|
         f.inputs do
           f.input :title
@@ -176,52 +185,43 @@ describe_with_render ActiveAdmin::FormBuilder do
       end
     end
     it "should generate a nested text input once" do
-      response.body.scan("post_author_attributes_first_name_input").size.should == 1
+      body.scan("post_author_attributes_first_name_input").size.should == 1
     end
     it "should add an author first name field" do
-      response.body.should have_tag("input", :attributes => { :name => "post[author_attributes][first_name]"})
+      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
-      build_form do |f|
+      body = build_form do |f|
         f.input :title, :wrapper_html => { :class => "important" }
       end
-      response.should have_tag("li", :attributes => {:class => "string optional important"})
+      body.should have_tag("li", :attributes => {:class => "string optional important"})
     end
   end
 
 
-  # This checks that each input can be added via the standard
-  # rails method as well as using the form builder's #input method.
   { 
     "input :title, :as => :string"        => /id\=\"post_title\"/,
-    "text_field :title"                   => /id\=\"post_title\"/,
     "input :title, :as => :text"          => /id\=\"post_title\"/,
-    "text_area :title"                    => /id\=\"post_title\"/,
     "input :created_at, :as => :time"     => /id\=\"post_created_at_2i\"/,
-    "time_select :created_at"             => /id\=\"post_created_at_2i\"/,
     "input :created_at, :as => :datetime" => /id\=\"post_created_at_2i\"/,
-    "datetime_select :created_at"         => /id\=\"post_created_at_2i\"/,
     "input :created_at, :as => :date"     => /id\=\"post_created_at_2i\"/,
-    "date_select :created_at"             => /id\=\"post_created_at_2i\"/,
-    "radio_button :title, 'title'"        => /id\=\"post_title_title\"/,
-    "file_field :title"                   => /id\=\"post_title\"/,
-    "hidden_field :title"                 => /id\=\"post_title\"/,
-    "label :title"                        => /for\=\"post_title\"/,
   }.each do |source, regex|
    it "should properly buffer #{source}" do
-     build_form do |f|
-       f.instance_eval(source)
-       f.instance_eval(source)
+     body = build_form do |f|
+       f.inputs do
+         f.instance_eval(source)
+         f.instance_eval(source)
+       end
      end
-     response.body.scan(regex).size.should == 2
+     body.scan(regex).size.should == 2
    end
   end
 
   describe "datepicker input" do
-    before do
+    let :body do
       build_form do |f|
         f.inputs do
           f.input :created_at, :as => :datepicker
@@ -229,7 +229,7 @@ describe_with_render ActiveAdmin::FormBuilder do
       end
     end
     it "should generate a text input with the class of datepicker" do
-      response.should have_tag("input", :attributes => {  :type => "text",
+      body.should have_tag("input", :attributes => {  :type => "text",
                                                           :class => "datepicker",
                                                           :name => "post[created_at]" })
     end