saulolso-activeadmin 0.2.2

data/spec/unit/components/table_for_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+describe ActiveAdmin::Views::TableFor do
+  describe "creating with the dsl" do
+    include Arbre::HTML
+
+    let(:assigns){ {} }
+    let(:helpers){ mock_action_view }
+
+    let(:collection) do
+      [Post.new(:title => "First Post"), Post.new(:title => "Second Post"), Post.new(:title => "Third Post")]
+    end
+
+    context "when creating a column with a symbol" do
+      let(:table) do
+        table_for(collection) do
+          column :title
+        end
+      end
+
+      it "should create a table header based on the symbol" do
+        table.find_by_tag("th").first.content.should == "Title"
+      end
+
+      it "should create a table row for each element in the collection" do
+        table.find_by_tag("tr").size.should == 4 # 1 for head, 3 for rows
+      end
+
+      ["First Post", "Second Post", "Third Post"].each_with_index do |content, index|
+        it "should create a cell with #{content}" do
+          table.find_by_tag("td")[index].content.should == content
+        end
+      end
+    end
+
+    context "when creating many columns with symbols" do
+      let(:table) do
+        table_for(collection) do
+          column :title
+          column :created_at
+        end
+      end
+
+      it "should create a table header based on the symbol" do
+        table.find_by_tag("th").first.content.should == "Title"
+        table.find_by_tag("th").last.content.should == "Created At"
+      end
+
+      it "should create a table row for each element in the collection" do
+        table.find_by_tag("tr").size.should == 4 # 1 for head, 3 for rows
+      end
+
+      it "should create a cell for each column" do
+        table.find_by_tag("td").size.should == 6
+      end
+    end
+
+    context "when creating a column with block content" do
+      let(:table) do
+        table_for(collection) do
+          column :title do |post|
+            span(post.title)
+          end
+        end
+      end
+
+      [ "<span>First Post</span>", 
+        "<span>Second Post</span>", 
+        "<span>Third Post</span>" ].each_with_index do |content, index|
+        it "should create a cell with #{content}" do
+          table.find_by_tag("td")[index].content.strip.should == content
+        end
+      end
+    end
+
+    context "when creating a column with multiple block content" do
+      let(:table) do
+        table_for(collection) do
+          column :title do |post|
+            span(post.title)
+            span(post.title)
+          end
+        end
+      end
+
+      3.times do |index|
+        it "should create a cell with multiple elements in row #{index}" do
+          table.find_by_tag("td")[index].find_by_tag("span").size.should == 2
+        end
+      end
+    end
+  end
+
+  describe "column sorting" do
+
+    def build_column(*args, &block)
+      ActiveAdmin::Views::TableFor::Column.new(*args, &block)
+    end
+
+    subject { table_column }
+
+    context "when default" do
+      let(:table_column){ build_column(:username) }
+      it { should be_sortable }
+      its(:sort_key){ should == "username" }
+    end
+
+    context "when a block given with no sort key" do
+      let(:table_column){ build_column("Username"){ } }
+      it { should_not be_sortable }
+    end
+
+    context "when a block given with a sort key" do
+      let(:table_column){ build_column("Username", :sortable => :username){ } }
+      it { should be_sortable }
+      its(:sort_key){ should == "username" }
+    end
+
+    context "when :sortable => false with a symbol" do
+      let(:table_column){ build_column(:username, :sortable => false) }
+      it { should_not be_sortable }
+    end
+
+    context "when :sortable => false with a symbol and string" do
+      let(:table_column){ build_column("Username", :username, :sortable => false) }
+      it { should_not be_sortable }
+    end
+
+  end
+end

data/spec/unit/controller_filters_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper' 
+
+describe ActiveAdmin, "filters" do
+  let(:application){ ActiveAdmin::Application.new }
+
+  describe "before filters" do
+    it "should add a new before filter to ActiveAdmin::ResourceController" do
+      ActiveAdmin::ResourceController.should_receive(:before_filter).and_return(true)
+      application.before_filter :my_filter, :only => :show
+    end
+  end
+
+  describe "after filters" do
+    it "should add a new after filter to ActiveAdmin::ResourceController" do
+      ActiveAdmin::ResourceController.should_receive(:after_filter).and_return(true)
+      application.after_filter :my_filter, :only => :show
+    end
+  end
+
+  describe "around filters" do
+    it "should add a new around filter to ActiveAdmin::ResourceController" do
+      ActiveAdmin::ResourceController.should_receive(:around_filter).and_return(true)
+      application.around_filter :my_filter, :only => :show
+    end
+  end
+
+end

data/spec/unit/csv_builder_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe ActiveAdmin::CSVBuilder do
+
+  describe '.default_for_resource using Post' do
+    let(:csv_builder) { ActiveAdmin::CSVBuilder.default_for_resource(Post) }
+
+    it "should return a default csv_builder for Post" do
+      csv_builder.should be_a(ActiveAdmin::CSVBuilder)
+    end
+
+    specify "the first column should be Id" do
+      csv_builder.columns.first.name.should == 'Id'
+      csv_builder.columns.first.data.should == :id
+    end
+
+    specify "the following columns should be content_column" do
+      csv_builder.columns[1..-1].each_with_index do |column, index|
+        column.name.should == Post.content_columns[index].name.titleize
+        column.data.should == Post.content_columns[index].name.to_sym
+      end
+    end
+  end
+
+  context 'when empty' do
+    let(:builder){ ActiveAdmin::CSVBuilder.new }
+
+    it "should have no columns" do
+      builder.columns.should == []
+    end
+  end
+
+  context "with a symbol column (:title)" do
+    let(:builder) do
+      ActiveAdmin::CSVBuilder.new do
+        column :title
+      end
+    end
+
+    it "should have one colum" do
+      builder.columns.size.should == 1
+    end
+
+    describe "the column" do
+      let(:column){ builder.columns.first }
+
+      it "should have a name of 'Title'" do
+        column.name.should == "Title"
+      end
+
+      it "should have the data :title" do
+        column.data.should == :title
+      end
+    end
+  end
+
+  context "with a block and title" do
+    let(:builder) do
+      ActiveAdmin::CSVBuilder.new do
+        column "My title" do
+          # nothing
+        end
+      end
+    end
+
+    it "should have one colum" do
+      builder.columns.size.should == 1
+    end
+
+    describe "the column" do
+      let(:column){ builder.columns.first }
+
+      it "should have a name of 'My title'" do
+        column.name.should == "My title"
+      end
+
+      it "should have the data :title" do
+        column.data.should be_an_instance_of(Proc)
+      end
+    end
+  end
+
+end

data/spec/unit/dashboard_controller_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper' 
+
+
+module Admin
+  class DashboardController < ActiveAdmin::Dashboards::DashboardController
+  end
+end
+class DashboardController < ActiveAdmin::Dashboards::DashboardController; end
+
+describe ActiveAdmin::Dashboards::DashboardController do
+
+  describe "getting the namespace name" do
+    subject{ controller.send :namespace }
+
+    context "when admin namespace" do
+      let(:controller){ Admin::DashboardController.new }
+      it { should == :admin }
+    end
+
+    context "when root namespace" do
+      let(:controller){ DashboardController.new }
+      it { should == :root }
+    end
+  end
+
+end

data/spec/unit/dashboard_section_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper' 
+
+describe ActiveAdmin::Dashboards::Section do
+
+  def section(options = {})
+    name = options.delete(:name) || "Recent Posts"
+    ActiveAdmin::Dashboards::Section.new(:admin, name, options){ }
+  end
+
+  describe "accessors" do
+    it "should have a namespace" do
+      section.namespace.should == :admin
+    end
+
+    it "should have a block" do
+      section.block.class.should == Proc
+    end
+
+    it "should have a name" do
+      section.name.should == 'Recent Posts'
+    end
+  end
+
+  describe "priority" do
+    context "when not set" do
+      subject{ section.priority }
+      it { should == ActiveAdmin::Dashboards::Section::DEFAULT_PRIORITY }
+    end
+
+    context "when set" do
+      subject{ section(:priority => 1).priority }
+      it { should == 1 }
+    end
+  end
+
+  describe "icon" do
+    it "should set the icon" do
+      s = section(:icon => :my_icon)
+      s.icon.should == :my_icon
+    end
+    it "should be nil by default" do
+      section.icon.should be_nil
+    end
+  end
+
+  describe "sorting sections" do
+    it "should sort by priority then alpha" do
+      s1 = section :name => "Woot"
+      s2 = section :name => :Alpha
+      s3 = section :name => "Zulu", :priority => 1
+      s4 = section :name => "Beta", :priority => 100
+      [s1,s2,s3,s4].sort.should == [s3, s2, s1, s4]
+    end
+  end
+
+end

data/spec/unit/dashboards_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper' 
+
+describe ActiveAdmin::Dashboards do
+
+  after(:each) do
+    ActiveAdmin::Dashboards.clear_all_sections!
+  end
+
+  describe "adding sections" do
+    before do
+      ActiveAdmin::Dashboards.clear_all_sections!
+      ActiveAdmin::Dashboards.add_section('Recent Posts')
+    end
+    it "should add a new section namespaced" do
+      ActiveAdmin::Dashboards.sections[:admin].first.should be_an_instance_of(ActiveAdmin::Dashboards::Section)
+    end
+  end
+
+  describe "adding sections using the build syntax" do
+    before do
+      ActiveAdmin::Dashboards.clear_all_sections!
+      ActiveAdmin::Dashboards.build do
+        section "Recent Posts" do
+        end
+      end
+    end
+
+    it "should add a new section" do
+      ActiveAdmin::Dashboards.sections[:admin].first.should be_an_instance_of(ActiveAdmin::Dashboards::Section)
+    end
+  end
+
+  describe "clearing all sections" do
+    before do
+      ActiveAdmin::Dashboards.add_section('Recent Posts')
+    end
+    it "should clear all sections" do
+      ActiveAdmin::Dashboards.clear_all_sections!
+      ActiveAdmin::Dashboards.sections.keys.should be_empty
+    end
+  end
+
+  describe "finding namespaced sections" do
+    context "when the namespace exists" do
+      before do
+        ActiveAdmin::Dashboards.add_section('Recent Posts')
+      end
+      it "should return an array of sections" do
+        ActiveAdmin::Dashboards.sections_for_namespace(:admin).should_not be_empty
+      end
+    end
+
+    context "when the namespace does not exists" do
+      it "should return an empty array" do
+        ActiveAdmin::Dashboards.sections_for_namespace(:not_a_namespace).should be_empty
+      end
+    end
+  end
+end

data/spec/unit/display_name_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe "display names" do
+
+  include ActiveAdmin::ViewHelpers
+
+  [:display_name, :full_name, :name, :username, :login, :title, :email, :to_s].each do |m|
+    it "should return #{m} if defined" do
+      r = Class.new do
+        define_method m do
+          m.to_s
+        end
+      end.new
+      display_name(r).should == m.to_s
+    end
+  end
+
+  it "should memeoize the result for the class" do
+    c = Class.new do
+      def name
+        "My Name"
+      end
+    end
+    display_name(c.new).should == "My Name"
+    ActiveAdmin.application.should_not_receive(:display_name_methods)
+    display_name(c.new).should == "My Name"
+  end
+
+end

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

@@ -0,0 +1,179 @@
+require 'spec_helper' 
+
+
+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 view.protect_against_forgery?
+      false
+    end
+
+    view
+  end
+
+  def filter(name, options = {})
+    search = Post.search
+    active_admin_filters_form_for(search, [options.merge(:attribute => name)])
+  end
+
+  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' })
+    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.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 search field for a string attribute" do
+      body.should have_tag("input", :attributes => { :name => "q[title_contains]"})
+    end
+
+    it "should label a text field with search" do
+      body.should have_tag('label', 'Search Title')
+    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 label a text field with search" do
+      body.should have_tag('label', 'Search Body')
+    end
+  end
+
+  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_gte]", :class => "datepicker"})
+    end
+    it "should generate a date less than" do
+      body.should have_tag("input", :attributes => { :name => "q[created_at_lte]", :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", "Equal To", :attributes => { :value => 'id_eq' })
+    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_eq|id_equals)\]/ })
+    end
+    it "should select the option which is currently being filtered"
+  end
+
+  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
+      let(:body) { filter :author_id }
+
+      it "should not render as an integer" do
+        body.should_not have_tag("input", :attributes => {
+                                                :name => "q[author_id_eq]"})
+      end
+      it "should render as belongs to select" do
+        body.should have_tag("select", :attributes => {
+                                            :name => "q[author_id_eq]"})
+        body.should have_tag("option", "jane_doe", :attributes => {
+                                                          :value => @jane.id })
+      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
+      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
+      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 # belongs to
+end