aa-rails4 0.6.0

data/spec/unit/dsl_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+
+module MockModuleToInclude
+  def self.included(dsl)
+  end
+end
+
+describe ActiveAdmin::DSL do
+
+  let(:config){ mock }
+  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) }
+
+  describe "#include" do
+
+    it "should call the included class method on the module that is included" do
+      MockModuleToInclude.should_receive(:included).with(dsl)
+      dsl.run_registration_block do
+        include MockModuleToInclude
+      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"})
+      dsl.run_registration_block do
+        menu :parent => "Admin"
+      end
+    end
+
+  end
+
+  describe "#navigation_menu" do
+
+    it "should set the navigation_menu_name on the configuration" do
+      config.should_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
+
+      resource_config.navigation_menu_name.should == :dynamic_menu
+
+    end
+
+  end
+
+end

data/spec/unit/event_spec.rb

@@ -0,0 +1,47 @@
+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 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
+  end
+
+  it "should call the dispatch block with no arguments" do
+    dispatcher.subscribe(test_event){ raise StandardError, "From Event Handler" }
+    expect {
+      dispatcher.dispatch(test_event)
+    }.to 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/filters/filter_form_builder_spec.rb

@@ -0,0 +1,338 @@
+require 'spec_helper'
+
+describe ActiveAdmin::Filters::ViewHelper do
+
+  # 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 view.protect_against_forgery?
+      false
+    end
+
+    def view.a_helper_method
+      "A Helper Method"
+    end
+
+    view
+  end
+
+  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
+
+  def filter(name, options = {})
+    render_filter scope, @filters.push(options.merge(:attribute => name))
+  end
+
+  let(:scope) { Post.search }
+
+  before(:each) { @filters = [] }
+
+
+  describe "the form in general" do
+    let(:body) { filter :title }
+
+    it "should generate a form which submits via get" do
+      body.should have_tag("form", :attributes => { :method => 'get', :class => 'filter_form' })
+    end
+
+    it "should generate a filter button" do
+      body.should have_tag("input", :attributes => { :type => "submit",
+                                                        :value => "Filter" })
+    end
+
+    it "should only generate the form once" do
+      body.to_s.scan(/q\[title_contains\]/).size.should == 1
+    end
+
+    it "should generate a clear filters link" do
+      body.should have_tag("a", "Clear Filters", :attributes => { :class => "clear_filters_btn" })
+    end
+  end
+
+  describe "string attribute" do
+    let(:body) { filter :title }
+
+    it "should generate a select option for starts with" do
+      body.should have_tag("option", "Starts with", :attributes => { :value => 'title_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' })
+    end
+
+    it "should generate a select option for contains" do
+      body.should have_tag("option", "Contains", :attributes => { :value => 'title_contains' })
+    end
+
+    it "should generate a text field for input" do
+      body.should have_tag("input", :attributes => { :name => 'q[title_contains]' })
+    end
+    
+    it "should have a proper label" do
+      body.should have_tag('label', '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!
+      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')
+    end
+
+    it "should NOT generate a select option for contains" do
+      body.should_not have_tag("option", "Contains", :attributes => { :value => 'title_contains' })
+    end
+
+    context "using starts_with and as" do
+      let(:body) { filter :title_starts_with }
+
+      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]" })
+      end
+    end
+  end
+  
+  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 have a proper label" do
+      body.should have_tag('label', 'Body')
+    end
+  end
+
+  describe "text attribute, as a select" do
+    let(:body) { filter :title, as: :select }
+    let(:builder) { ActiveAdmin::Inputs::FilterSelectInput }
+
+    context "when loading collection from DB" do
+      it "should use pluck for efficiency" do
+        builder.any_instance.should_receive(:pluck_column) { [] }
+        body
+      end
+
+      it "should remove original ordering to prevent PostgreSQL error" do
+        scope.object.klass.should_receive(:reorder).with('title asc') {
+          m = mock uniq: mock(pluck: ['A Title'])
+          m.uniq.should_receive(:pluck).with :title
+          m
+        }
+        body
+      end
+    end
+  end unless Rails::VERSION::MAJOR == 3 && Rails::VERSION::MINOR < 2
+
+  describe "datetime attribute" do
+    let(:body) { filter :created_at }
+
+    it "should generate a date greater than" do
+      body.should have_tag("input", :attributes => { :name => "q[created_at_gteq]", :class => "datepicker"})
+    end
+    it "should generate a seperator" do
+      body.should have_tag("span", :attributes => { :class => "seperator"})
+    end
+    it "should generate a date less than" do
+      body.should have_tag("input", :attributes => { :name => "q[created_at_lteq]", :class => "datepicker"})
+    end
+  end
+
+  describe "integer attribute" do
+    let(:body) { filter :id }
+
+    it "should generate a select option for equal to" do
+      body.should have_tag("option", "Equals", :attributes => { :value => 'id_equals' })
+    end
+    it "should generate a select option for greater than" do
+      body.should have_tag("option", "Greater than")
+    end
+    it "should generate a select option for less than" do
+      body.should have_tag("option", "Less than")
+    end
+    it "should generate a text field for input" do
+      body.should have_tag("input", :attributes => { :name => 'q[id_equals]' })
+    end
+    it "should select the option which is currently being filtered"
+  end
+
+  describe "boolean attribute" do
+    context "boolean datatypes" do
+      let(:body) { filter :starred }
+
+      it "should create a check box for equals to" do
+        body.should have_tag("input", :attributes => {
+                                            :name => "q[starred_eq]",
+                                            :type => "checkbox" })
+      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!
+        end
+      end
+    end
+
+    context "non-boolean data types" do
+      let(:body) { 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" })
+      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"
+    end
+
+    context "when given as the _id attribute name" do
+      let(:body) { 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]'}
+      end
+    end
+
+    context "when given as the name of the relationship" do
+      let(:body) { filter :author }
+
+      it "should generate a select" do
+        body.should have_tag "select",             :attributes => { :name => "q[author_id_eq]" }
+      end
+      it "should set the default text to 'Any'" do
+        body.should have_tag "option", "Any",      :attributes => { :value => "" }
+      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 }
+      end
+
+      context "with a proc" do
+        let :body do
+          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")
+        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")
+        end
+      end
+    end
+
+    context "as check boxes" do
+      let(:body) { 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 })
+      end
+    end
+
+    context "when polymorphic relationship" do
+      it "should raise an error if a collection isn't provided" do
+        expect {
+          search = ActiveAdmin::Comment.search
+          render_filter(search, [{:attribute => :resource}])
+        }.to raise_error Formtastic::PolymorphicInputWithoutCollectionError
+      end
+    end
+  end # belongs to
+
+  describe "has_and_belongs_to_many" do
+    pending "add HABTM models so this can be mocked out"
+  end
+
+  describe "conditional display" do
+
+    context "with :if block" do
+      let(:body) do
+        filter :body,   :if => proc{true}
+        filter :author, :if => proc{false}
+      end
+
+      it "should be displayed if true" do
+        body.should have_tag("input", :attributes => { :name => "q[body_contains]"})
+      end
+
+      it "should NOT be displayed if false" do
+        body.should_not have_tag("input", :attributes => { :name => "q[author_id_eq]"})
+      end
+    end
+
+    context "with :unless block" do
+      let(:body) do
+        filter :created_at, :unless => proc{false}
+        filter :updated_at, :unless => proc{true}
+      end
+
+      it "should be displayed if false" do
+        body.should have_tag("input", :attributes => { :name => "q[created_at_gteq]"})
+      end
+
+      it "should NOT be displayed if true" do
+        body.should_not have_tag("input", :attributes => { :name => "q[updated_at_gteq]"})
+      end
+    end
+  end
+
+end

data/spec/unit/filters/resource_spec.rb

@@ -0,0 +1,87 @@
+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 starred 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
+
+  context "filter removal" do
+    it "should work" do
+      resource.filters.should include :attribute => :author
+      resource.remove_filter :author
+      resource.filters.should_not include :attribute => :author
+    end
+
+    it "should be lazy" do
+      resource.should_not_receive :default_filters # this hits the DB
+      resource.remove_filter :author
+    end
+
+    it "should not prevent the default filters from being added" do
+      resource.remove_filter :author
+      resource.filters.should_not be_empty
+    end
+  end
+
+  context "adding a filter" do
+    it "should work" do
+      resource.add_filter :title
+      resource.filters.should == [{:attribute => :title}]
+    end
+
+    it "should work with specified options" do
+      resource.add_filter :title, :as => :string
+      resource.filters.should == [{:attribute => :title, :as => :string}]
+    end
+
+    it "should preserve default filters" do
+      resource.preserve_default_filters!
+      resource.add_filter :count, :as => :string
+      resource.filters.map { |f| f[:attribute].to_s }.sort.should == %w{
+      author body category count created_at published_at starred title updated_at
+    }
+    end
+
+    it "should raise an exception when filters are disabled" do
+      resource.filters = false
+      expect {
+        resource.add_filter :title
+      }.to raise_error(RuntimeError)
+    end
+  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