yousty-activeadmin 1.0.4.pre → 1.0.5.pre

data/spec/unit/dsl_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 
 
 module MockModuleToInclude
@@ -8,16 +8,15 @@ end
 
 describe ActiveAdmin::DSL do
 
-  let(:config){ double }
   let(:application) { ActiveAdmin::Application.new }
   let(:namespace) { ActiveAdmin::Namespace.new application, :admin }
   let(:resource_config) { ActiveAdmin::Resource.new namespace, Post }
-  let(:dsl){ ActiveAdmin::DSL.new(config) }
+  let(:dsl){ ActiveAdmin::DSL.new(resource_config) }
 
   describe "#include" do
 
     it "should call the included class method on the module that is included" do
-      MockModuleToInclude.should_receive(:included).with(dsl)
+      expect(MockModuleToInclude).to receive(:included).with(dsl)
       dsl.run_registration_block do
         include MockModuleToInclude
       end
@@ -25,12 +24,45 @@ describe ActiveAdmin::DSL do
 
   end
 
+
+  describe '#action_item' do
+    before do
+      @default_items_count = resource_config.action_items.size
+
+      dsl.run_registration_block do
+        action_item :awesome, only: :show do
+          "Awesome ActionItem"
+        end
+      end
+    end
+
+    it "adds action_item to the action_items of config" do
+      expect(resource_config.action_items.size).to eq(@default_items_count + 1)
+    end
+
+    context 'DEPRECATED: when used without a name' do
+      it "is configured for only the show action" do
+        expect(ActiveAdmin::Deprecation).to receive(:warn).with(instance_of(String))
+
+        dsl.run_registration_block do
+          action_item only: :edit do
+            "Awesome ActionItem"
+          end
+        end
+
+        item = resource_config.action_items.last
+        expect(item.display_on?(:edit)).to be true
+        expect(item.display_on?(:index)).to be false
+      end
+    end
+  end
+
   describe "#menu" do
 
     it "should set the menu_item_options on the configuration" do
-      config.should_receive(:menu_item_options=).with({:parent => "Admin"})
+      expect(resource_config).to receive(:menu_item_options=).with({parent: "Admin"})
       dsl.run_registration_block do
-        menu :parent => "Admin"
+        menu parent: "Admin"
       end
     end
 
@@ -39,23 +71,52 @@ describe ActiveAdmin::DSL do
   describe "#navigation_menu" do
 
     it "should set the navigation_menu_name on the configuration" do
-      config.should_receive(:navigation_menu_name=).with(:admin)
+      expect(resource_config).to receive(:navigation_menu_name=).with(:admin)
       dsl.run_registration_block do
         navigation_menu :admin
       end
     end
 
     it "should accept a block" do
-
       dsl = ActiveAdmin::DSL.new(resource_config)
       dsl.run_registration_block do
         navigation_menu { :dynamic_menu }
       end
+      expect(resource_config.navigation_menu_name).to eq :dynamic_menu
+    end
+
+  end
+
+  describe "#sidebar" do
 
-      resource_config.navigation_menu_name.should == :dynamic_menu
+    before do
+      dsl.config.sidebar_sections << ActiveAdmin::SidebarSection.new(:email)
+    end
 
+    it "add sidebar_section to the sidebar_sections of config" do
+      dsl.run_registration_block do
+        sidebar :help
+      end
+      expect(dsl.config.sidebar_sections.map(&:name)).to match_array([:filters, :email, :help])
     end
 
   end
 
+  describe "#batch_action" do
+    it "should add a batch action by symbol" do
+      dsl.run_registration_block do
+        config.batch_actions = true
+        batch_action :foo
+      end
+      expect(resource_config.batch_actions.map(&:sym)).to eq [:foo, :destroy]
+    end
+
+    it "should add a batch action by title" do
+      dsl.run_registration_block do
+        config.batch_actions = true
+        batch_action "foo bar"
+      end
+      expect(resource_config.batch_actions.map(&:sym)).to eq [:foo_bar, :destroy]
+    end
+  end
 end

data/spec/unit/event_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 require 'active_admin/event'
 
 describe ActiveAdmin::EventDispatcher do
@@ -7,15 +7,15 @@ describe ActiveAdmin::EventDispatcher do
   let(:dispatcher){ ActiveAdmin::EventDispatcher.new }
 
   it "should add a subscriber for an event" do
-    dispatcher.subscribers(test_event).size.should == 0
+    expect(dispatcher.subscribers(test_event).size).to eq 0
     dispatcher.subscribe(test_event){ true }
-    dispatcher.subscribers(test_event).size.should == 1
+    expect(dispatcher.subscribers(test_event).size).to eq 1
   end
 
   it "should add a subscriber for multiple events" do
     dispatcher.subscribe(test_event, test_event + "1"){ true }
-    dispatcher.subscribers(test_event).size.should == 1
-    dispatcher.subscribers(test_event + "1").size.should == 1
+    expect(dispatcher.subscribers(test_event).size).to eq 1
+    expect(dispatcher.subscribers(test_event + "1").size).to eq 1
   end
 
   it "should call the dispatch block with no arguments" do
@@ -29,19 +29,19 @@ describe ActiveAdmin::EventDispatcher do
     arg = nil
     dispatcher.subscribe(test_event){|passed_in| arg = passed_in }
     dispatcher.dispatch(test_event, "My Arg")
-    arg.should == "My Arg"
+    expect(arg).to eq "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
+    expect(dispatcher.subscribers(test_event).size).to eq 0
+    expect(dispatcher.subscribers(test_event + "_2").size).to eq 0
   end
 
   it "should have a dispatcher available from ActiveAdmin::Event" do
-    ActiveAdmin::Event.should be_an_instance_of(ActiveAdmin::EventDispatcher)
+    expect(ActiveAdmin::Event).to be_an_instance_of(ActiveAdmin::EventDispatcher)
   end
 
 end

data/spec/unit/filters/filter_form_builder_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 
 class Post
   ransacker :custom_searcher do
@@ -30,7 +30,7 @@ describe ActiveAdmin::Filters::ViewHelper do
   def render_filter(search, filters)
     render_arbre_component({filter_args: [search, filters]}, helpers) do
       text_node active_admin_filters_form_for *assigns[:filter_args]
-    end
+    end.to_s
   end
 
   def filter(name, options = {})
@@ -40,125 +40,111 @@ describe ActiveAdmin::Filters::ViewHelper do
   let(:scope) { Post.search }
 
   describe "the form in general" do
-    let(:body) { filter :title }
+    let(:body) { Capybara.string(filter :title) }
 
     it "should generate a form which submits via get" do
-      body.should have_tag("form", :attributes => { :method => 'get', :class => 'filter_form' })
+      expect(body).to have_selector("form.filter_form[method=get]")
     end
 
     it "should generate a filter button" do
-      body.should have_tag("input", :attributes => { :type => "submit",
-                                                        :value => "Filter" })
+      expect(body).to have_selector("input[type=submit][value=Filter]")
     end
 
     it "should only generate the form once" do
-      body.to_s.scan(/q\[title_contains\]/).size.should == 1
+      expect(body).to have_selector("form", count: 1)
     end
 
     it "should generate a clear filters link" do
-      body.should have_tag("a", "Clear Filters", :attributes => { :class => "clear_filters_btn" })
+      expect(body).to have_selector("a.clear_filters_btn", text: "Clear Filters")
+    end
+
+    describe "label as proc" do
+      let(:body) { Capybara.string(filter :title, label: proc { 'Title from proc' }) }
+
+      it "should render proper label" do
+        expect(body).to have_selector("label", text: "Title from proc")
+      end
     end
   end
 
   describe "string attribute" do
-    let(:body) { filter :title }
+    let(:body) { Capybara.string(filter :title) }
 
     it "should generate a select option for starts with" do
-      body.should have_tag("option", "Starts with", :attributes => { :value => 'title_starts_with' })
+      expect(body).to have_selector("option[value=title_starts_with]", text: "Starts with")
     end
 
     it "should generate a select option for ends with" do
-      body.should have_tag("option", "Ends with", :attributes => { :value => 'title_ends_with' })
+      expect(body).to have_selector("option[value=title_ends_with]", text: "Ends with")
     end
 
     it "should generate a select option for contains" do
-      body.should have_tag("option", "Contains", :attributes => { :value => 'title_contains' })
+      expect(body).to have_selector("option[value=title_contains]", text: "Contains")
     end
 
     it "should generate a text field for input" do
-      body.should have_tag("input", :attributes => { :name => 'q[title_contains]' })
+      expect(body).to have_selector("input[name='q[title_contains]']")
     end
-    
+
     it "should have a proper label" do
-      body.should have_tag('label', 'Title')
+      expect(body).to have_selector("label", text: "Title")
     end
 
     it "should translate the label for text field" do
-      begin
-        I18n.backend.store_translations(:en, :activerecord => { :attributes => { :post => { :title => "Name" } } })
-        body.should have_tag('label', 'Name')
-      ensure
-        I18n.backend.reload!
+      with_translation activerecord: {attributes: {post: {title: 'Name'}}} do
+        expect(body).to have_selector("label", text: "Name")
       end
     end
 
-    it "should select the option which is currently being filtered"
-
-  end
-
-  describe "string attribute with sub filters" do
-    let(:body) { filter :title_contains }
-    
-    it "should generate a search field for a string attribute with query contains" do
-      body.should have_tag("input", :attributes => { :name => "q[title_contains]"})
-      body.should have_tag('label', 'Title contains')
+    it "should select the option which is currently being filtered" do
+      scope = Post.search title_starts_with: "foo"
+      body = Capybara.string(render_filter scope, title: {})
+      expect(body).to have_selector("option[value=title_starts_with][selected=selected]", text: "Starts with")
     end
 
-    it "should NOT generate a select option for contains" do
-      body.should_not have_tag("option", "Contains", :attributes => { :value => 'title_contains' })
-    end
+    context "with predicate" do
+      %w[eq equals cont contains start starts_with end ends_with].each do |predicate|
+        describe "'#{predicate}'" do
+          let(:body) { Capybara.string(filter :"title_#{predicate}") }
 
-    context "using starts_with and as" do
-      let(:body) { filter :title_starts_with }
+          it "shouldn't include a select field" do
+            expect(body).not_to have_selector("select")
+          end
 
-      it "should generate a search field for a string attribute with query starts_with" do
-        body.should have_tag("input", :attributes => { :name => "q[title_starts_with]" })
-      end
-    end
-
-    context "using ends_with and as" do
-      let(:body) { filter :title_ends_with }
-
-      it "should generate a search field for a string attribute with query ends_with" do
-        body.should have_tag("input", :attributes => { :name => "q[title_ends_with]" })
-      end
-    end
-    
-    context "using contains and NO AS defined" do
-      let(:body) { filter :title_contains }
-
-      it "should generate a search field for a string attribute with query contains" do
-        body.should have_tag("input", :attributes => { :name => "q[title_contains]" })
+          it "should build correctly" do
+            expect(body).to have_selector("input[name='q[title_#{predicate}]']")
+          end
+        end
       end
     end
   end
-  
+
   describe "text attribute" do
-    let(:body) { filter :body }
+    let(:body) { Capybara.string(filter :body) }
 
     it "should generate a search field for a text attribute" do
-      body.should have_tag("input", :attributes => { :name => "q[body_contains]"})
+      expect(body).to have_selector("input[name='q[body_contains]']")
     end
 
     it "should have a proper label" do
-      body.should have_tag('label', 'Body')
+      expect(body).to have_selector("label", text: "Body")
     end
   end
 
   describe "string attribute, as a select" do
     let(:body) { filter :title, as: :select }
-    let(:builder) { ActiveAdmin::Inputs::FilterSelectInput }
+    let(:builder) { ActiveAdmin::Inputs::Filters::SelectInput }
 
     context "when loading collection from DB" do
       it "should use pluck for efficiency" do
-        builder.any_instance.should_receive(:pluck_column) { [] }
+        expect_any_instance_of(builder).to receive(:pluck_column) { [] }
         body
       end
 
       it "should remove original ordering to prevent PostgreSQL error" do
-        scope.object.klass.should_receive(:reorder).with('title asc') {
+        expect(scope.object.klass).to receive(:reorder).with('title asc') {
           m = double uniq: double(pluck: ['A Title'])
-          m.uniq.should_receive(:pluck).with :title
+          expect(m.uniq).to receive(:pluck).with :title
           m
         }
         body
@@ -167,127 +153,132 @@ describe ActiveAdmin::Filters::ViewHelper do
   end
 
   describe "datetime attribute" do
-    let(:body) { filter :created_at }
+    let(:body) { Capybara.string(filter :created_at) }
 
     it "should generate a date greater than" do
-      body.should have_tag("input", :attributes => { :name => "q[created_at_gteq]", :class => "datepicker"})
+      expect(body).to have_selector("input.datepicker[name='q[created_at_gteq]']")
     end
     it "should generate a seperator" do
-      body.should have_tag("span", :attributes => { :class => "seperator"})
+      expect(body).to have_selector("span.seperator")
     end
     it "should generate a date less than" do
-      body.should have_tag("input", :attributes => { :name => "q[created_at_lteq]", :class => "datepicker"})
+      expect(body).to have_selector("input.datepicker[name='q[created_at_lteq]']")
     end
   end
 
   describe "integer attribute" do
-    let(:body) { filter :id }
+    let(:body) { Capybara.string(filter :id) }
 
     it "should generate a select option for equal to" do
-      body.should have_tag("option", "Equals", :attributes => { :value => 'id_equals' })
+      expect(body).to have_selector("option[value=id_equals]", text: "Equals")
     end
     it "should generate a select option for greater than" do
-      body.should have_tag("option", "Greater than")
+      expect(body).to have_selector("option", text: "Greater than")
     end
     it "should generate a select option for less than" do
-      body.should have_tag("option", "Less than")
+      expect(body).to have_selector("option", text: "Less than")
     end
     it "should generate a text field for input" do
-      body.should have_tag("input", :attributes => { :name => 'q[id_equals]' })
+      expect(body).to have_selector("input[name='q[id_equals]']")
+    end
+    it "should select the option which is currently being filtered" do
+      scope = Post.search id_greater_than: 1
+      body = Capybara.string(render_filter scope, id: {})
+      expect(body).to have_selector("option[value=id_greater_than][selected=selected]", text: "Greater than")
     end
-    it "should select the option which is currently being filtered"
   end
 
   describe "boolean attribute" do
     context "boolean datatypes" do
-      let(:body) { filter :starred }
+      let(:body) { Capybara.string(filter :starred) }
 
-      it "should create a check box for equals to" do
-        body.should have_tag("input", :attributes => {
-                                            :name => "q[starred_eq]",
-                                            :type => "checkbox" })
+      it "should generate a select" do
+        expect(body).to have_selector("select[name='q[starred_eq]']")
+      end
+      it "should set the default text to 'Any'" do
+        expect(body).to have_selector("option[value='']", text: "Any")
+      end
+      it "should create an option for true and false" do
+        expect(body).to have_selector("option[value=true]", text: "Yes")
+        expect(body).to have_selector("option[value=false]", text: "No")
       end
 
       it "should translate the label for boolean field" do
-        begin
-          I18n.backend.store_translations(:en, :activerecord => { :attributes => { :post => { :starred => "Faved" } } })
-          body.should have_tag('label', 'Faved')
-        ensure
-          I18n.backend.reload!
+        with_translation activerecord: {attributes: {post: {starred: 'Faved'}}} do
+          expect(body).to have_selector("label", text: "Faved")
         end
       end
     end
 
     context "non-boolean data types" do
-      let(:body) { filter :title_present, :as => :boolean }
+      let(:body) { Capybara.string(filter :title_present, as: :boolean) }
 
-      it "should create a check box for equals to" do
-        body.should have_tag("input", :attributes => {
-                                            :name => "q[title_present]",
-                                            :type => "checkbox" })
+      it "should generate a select" do
+        expect(body).to have_selector("select[name='q[title_present]']")
+      end
+      it "should set the default text to 'Any'" do
+        expect(body).to have_selector("option[value='']", text: "Any")
+      end
+      it "should create an option for true and false" do
+        expect(body).to have_selector("option[value=true]", text: "Yes")
+        expect(body).to have_selector("option[value=false]", text: "No")
       end
     end
   end
 
   describe "belongs_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"
+      @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
-      let(:body) { filter :author_id }
+      let(:body) { Capybara.string(filter :author_id) }
 
       it "should generate a numeric filter" do
-        body.should have_tag 'label', 'Author' # really this should be Author ID :/
-        body.should have_tag 'option', :attributes => { :value => 'author_id_less_than' }
-        body.should have_tag 'input',  :attributes => { :id => 'q_author_id', :name => 'q[author_id_equals]'}
+        expect(body).to have_selector("label", text: "Author") # really this should be Author ID :/)
+        expect(body).to have_selector("option[value=author_id_less_than]")
+        expect(body).to have_selector("input#q_author_id[name='q[author_id_equals]']")
       end
     end
 
     context "when given as the name of the relationship" do
-      let(:body) { filter :author }
+      let(:body) { Capybara.string(filter :author) }
 
       it "should generate a select" do
-        body.should have_tag "select",             :attributes => { :name => "q[author_id_eq]" }
+        expect(body).to have_selector("select[name='q[author_id_eq]']")
       end
       it "should set the default text to 'Any'" do
-        body.should have_tag "option", "Any",      :attributes => { :value => "" }
+        expect(body).to have_selector("option[value='']", text: "Any")
       end
       it "should create an option for each related object" do
-        body.should have_tag "option", "John Doe", :attributes => { :value => @john.id }
-        body.should have_tag "option", "Jane Doe", :attributes => { :value => @jane.id }
+        expect(body).to have_selector("option[value='#{@john.id}']", text: "John Doe")
+        expect(body).to have_selector("option[value='#{@jane.id}']", text: "Jane Doe")
       end
 
       context "with a proc" do
         let :body do
-          filter :title, :as => :select, :collection => proc{ ['Title One', 'Title Two'] }
+          Capybara.string(filter :title, as: :select, collection: proc{ ['Title One', 'Title Two'] })
         end
 
         it "should use call the proc as the collection" do
-          body.should have_tag("option", "Title One")
-          body.should have_tag("option", "Title Two")
+          expect(body).to have_selector("option", text: "Title One")
+          expect(body).to have_selector("option", text: "Title Two")
         end
 
         it "should render the collection in the context of the view" do
-          body = filter(:title, :as => :select, :collection => proc{[a_helper_method]})
-          body.should have_tag("option", "A Helper Method")
+          body = Capybara.string(filter(:title, as: :select, collection: proc{[a_helper_method]}))
+          expect(body).to have_selector("option", text: "A Helper Method")
         end
       end
     end
 
     context "as check boxes" do
-      let(:body) { filter :author, :as => :check_boxes }
+      let(:body) { Capybara.string(filter :author, as: :check_boxes) }
 
       it "should create a check box for each related object" do
-        body.should have_tag("input", :attributes => {
-                                            :name => "q[author_id_in][]",
-                                            :type => "checkbox",
-                                            :value => @john.id })
-        body.should have_tag("input", :attributes => {
-                                            :name => "q[author_id_in][]",
-                                            :type => "checkbox",
-                                            :value => @jane.id })
+        expect(body).to have_selector("input[type=checkbox][name='q[author_id_in][]'][value='#{@jane.id}']")
+        expect(body).to have_selector("input[type=checkbox][name='q[author_id_in][]'][value='#{@jane.id}']")
       end
     end
 
@@ -298,10 +289,19 @@ describe ActiveAdmin::Filters::ViewHelper do
           Formtastic::PolymorphicInputWithoutCollectionError
       end
     end
+
+    context "when using a custom foreign key" do
+      let(:scope) { Post.search }
+      let(:body)  { Capybara.string(filter :category) }
+      it "should ignore that foreign key and let Ransack handle it" do
+        expect(Post.reflect_on_association(:category).foreign_key).to eq :custom_category_id
+        expect(body).to have_selector("select[name='q[category_id_eq]']")
+      end
+    end
   end # belongs to
 
   describe "has_and_belongs_to_many" do
-    pending "add HABTM models so this can be tested"
+    skip "add HABTM models so this can be tested"
   end
 
   describe "has_many :through" do
@@ -325,64 +325,63 @@ describe ActiveAdmin::Filters::ViewHelper do
     end
     let(:scope) { Category.search }
 
-    let!(:john) { User.create :first_name => "John", :last_name => "Doe", :username => "john_doe" }
-    let!(:jane) { User.create :first_name => "Jane", :last_name => "Doe", :username => "jane_doe" }
+    let!(:john) { User.create first_name: "John", last_name: "Doe", username: "john_doe" }
+    let!(:jane) { User.create first_name: "Jane", last_name: "Doe", username: "jane_doe" }
 
     context "when given as the name of the relationship" do
-      let(:body) { filter :authors }
+      let(:body) { Capybara.string(filter :authors) }
 
       it "should generate a select" do
-        body.should have_tag 'select', :attributes => { :name => "q[posts_author_id_eq]" }
+        expect(body).to have_selector("select[name='q[posts_author_id_eq]']")
       end
 
       it "should set the default text to 'Any'" do
-        body.should have_tag "option", "Any", :attributes => { :value => "" }
+        expect(body).to have_selector("option[value='']", text: "Any")
       end
 
       it "should create an option for each related object" do
-        body.should have_tag "option", "John Doe", :attributes => { :value => john.id }
-        body.should have_tag "option", "Jane Doe", :attributes => { :value => jane.id }
+        expect(body).to have_selector("option[value='#{john.id}']", text: "John Doe")
+        expect(body).to have_selector("option[value='#{jane.id}']", text: "Jane Doe")
       end
     end
 
     context "as check boxes" do
-      let(:body) { filter :authors, :as => :check_boxes }
+      let(:body) { Capybara.string(filter :authors, as: :check_boxes) }
 
       it "should create a check box for each related object" do
-        body.should have_tag("input", :attributes => {
-                                            :name => "q[posts_author_id_in][]",
-                                            :type => "checkbox",
-                                            :value => john.id })
-        body.should have_tag("input", :attributes => {
-                                            :name => "q[posts_author_id_in][]",
-                                            :type => "checkbox",
-                                            :value => jane.id })
+        expect(body).to have_selector("input[name='q[posts_author_id_in][]'][type=checkbox][value='#{john.id}']")
+        expect(body).to have_selector("input[name='q[posts_author_id_in][]'][type=checkbox][value='#{jane.id}']")
       end
     end
   end
 
   describe "conditional display" do
-    context "with :if block" do
-      it "should be displayed if true" do
-        body = filter :body,   if: proc{true}
-        body.should     have_tag "input", attributes: {name: "q[body_contains]"}
-      end
-
-      it "should NOT be displayed if false" do
-        body = filter :author, if: proc{false}
-        body.should_not have_tag "input", attributes: {name: "q[author_id_eq]"}
-      end
-    end
-
-    context "with :unless block" do
-      it "should be displayed if false" do
-        body = filter :created_at, unless: proc{false}
-        body.should     have_tag "input", attributes: {name: "q[created_at_gteq]"}
-      end
-
-      it "should NOT be displayed if true" do
-        body = filter :updated_at, unless: proc{true}
-        body.should_not have_tag "input", attributes: {name: "q[updated_at_gteq]"}
+    [:if, :unless].each do |verb|
+      should   = verb == :if ? "should" : "shouldn't"
+      if_true  = verb == :if ? :to      : :to_not
+      if_false = verb == :if ? :to_not  : :to
+      context "with #{verb.inspect} proc" do
+        it "#{should} be displayed if true" do
+          body = Capybara.string(filter :body, verb => proc{ true })
+          expect(body).send if_true,  have_selector("input[name='q[body_contains]']")
+        end
+        it "#{should} be displayed if false" do
+          body = Capybara.string(filter :body, verb => proc{ false })
+          expect(body).send if_false, have_selector("input[name='q[body_contains]']")
+        end
+        it "should still be hidden on the second render" do
+          filters = {body: { verb => proc{ verb == :unless }}}
+          2.times do
+            body = Capybara.string(render_filter scope, filters)
+            expect(body).not_to have_selector("input[name='q[body_contains]']")
+          end
+        end
+        it "should successfully keep rendering other filters after one is hidden" do
+          filters = {body: { verb => proc{ verb == :unless }}, author: {}}
+          body    = Capybara.string(render_filter scope, filters)
+          expect(body).not_to have_selector("input[name='q[body_contains]']")
+          expect(body).to     have_selector("select[name='q[author_id_eq]']")
+        end
       end
     end
   end
@@ -390,32 +389,43 @@ describe ActiveAdmin::Filters::ViewHelper do
   describe "custom search methods" do
 
     it "should work as select" do
-      body = filter :custom_searcher, as: :select, collection: ['foo']
-      body.should have_tag "select", attributes: { name: "q[custom_searcher]" }
+      body = Capybara.string(filter :custom_searcher, as: :select, collection: ['foo'])
+      expect(body).to have_selector("select[name='q[custom_searcher]']")
     end
 
     it "should work as string" do
-      body = filter :custom_searcher, as: :string
-      body.should have_tag "input", attributes: { name: "q[custom_searcher]" }
+      body = Capybara.string(filter :custom_searcher, as: :string)
+      expect(body).to have_selector("input[name='q[custom_searcher]']")
+    end
+  end
+
+  describe "does not support some filter inputs" do
+    it "should fallback to use formtastic inputs" do
+      body = Capybara.string(filter :custom_searcher, as: :text)
+      expect(body).to have_selector("textarea[name='q[custom_searcher]']")
     end
   end
 
   describe "blank option" do
     context "for a select filter" do
       it "should be there by default" do
-        filter(:author).should have_tag "option", "Any"
+        body = Capybara.string(filter(:author))
+        expect(body).to have_selector("option", text: "Any")
       end
       it "should be able to be disabled" do
-        filter(:author, include_blank: false).should_not have_tag "option", "Any"
+        body = Capybara.string(filter(:author, include_blank: false))
+        expect(body).to_not have_selector("option", text: "Any")
       end
     end
 
     context "for a multi-select filter" do
       it "should not be there by default" do
-        filter(:author, multiple: true).should_not have_tag "option", "Any"
+        body = Capybara.string(filter(:author, multiple: true))
+        expect(body).to_not have_selector("option", text: "Any")
       end
       it "should be able to be enabled" do
-        filter(:author, multiple: true, include_blank: true).should have_tag "option", "Any"
+        body = Capybara.string(filter(:author, multiple: true, include_blank: true))
+        expect(body).to have_selector("option", text: "Any")
       end
     end
   end