activeadmin 0.6.6 → 1.0.0.pre1

data/spec/unit/comments_spec.rb

@@ -1,71 +1,132 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe "Comments" do
-  let(:application){ ActiveAdmin::Application.new }
+  let(:application) { ActiveAdmin::Application.new }
 
   describe ActiveAdmin::Comment do
-    subject { ActiveAdmin::Comment.new }
-
-    describe "Associations and Validations" do
-      it { should belong_to :resource }
-      it { should belong_to :author }
-      it { should validate_presence_of :resource }
-      it { should validate_presence_of :body }
-      it { should validate_presence_of :namespace }
+    subject(:comment){ ActiveAdmin::Comment.new }
+
+    it "has valid Associations and Validations" do
+      expect(comment).to belong_to :resource
+      expect(comment).to belong_to :author
+      expect(comment).to validate_presence_of :resource
+      expect(comment).to validate_presence_of :body
+      expect(comment).to validate_presence_of :namespace
     end
 
     describe ".find_for_resource_in_namespace" do
-      let(:post){ Post.create!(:title => "Hello World") }
-      let(:namespace_name){ "admin" }
+      let(:post) { Post.create!(title: "Hello World") }
+      let(:namespace_name) { "admin" }
 
       before do
-        @comment = ActiveAdmin::Comment.create! :resource => post,
-                                                :body => "A Comment",
-                                                :namespace => namespace_name
+        @comment = ActiveAdmin::Comment.create! resource: post,
+                                                body: "A Comment",
+                                                namespace: namespace_name
       end
 
       it "should return a comment for the resource in the same namespace" do
-        ActiveAdmin::Comment.find_for_resource_in_namespace(post, namespace_name).should == [@comment]
+        expect(ActiveAdmin::Comment.find_for_resource_in_namespace(post, namespace_name)).to eq [@comment]
       end
 
       it "should not return a comment for the same resource in a different namespace" do
-        ActiveAdmin::Comment.find_for_resource_in_namespace(post, 'public').should == []
+        expect(ActiveAdmin::Comment.find_for_resource_in_namespace(post, 'public')).to eq []
       end
 
       it "should not return a comment for a different resource" do
-        another_post = Post.create! :title => "Another Hello World"
-        ActiveAdmin::Comment.find_for_resource_in_namespace(another_post, namespace_name).should == []
+        another_post = Post.create! title: "Another Hello World"
+        expect(ActiveAdmin::Comment.find_for_resource_in_namespace(another_post, namespace_name)).to eq []
+      end
+
+      it "should return the most recent comment first" do
+        ActiveAdmin::Comment.class_eval { attr_accessible :created_at } if Rails::VERSION::MAJOR == 3
+        another_comment = ActiveAdmin::Comment.create! resource: post, 
+                                                       body: "Another Comment", 
+                                                       namespace: namespace_name,
+                                                       created_at: @comment.created_at + 20.minutes
+
+        yet_another_comment = ActiveAdmin::Comment.create! resource: post,
+                                                           body: "Yet Another Comment",
+                                                           namespace: namespace_name,
+                                                           created_at: @comment.created_at + 10.minutes
+
+        comments = ActiveAdmin::Comment.find_for_resource_in_namespace(post, namespace_name)
+        expect(comments.size).to eq 3
+        expect(comments.first).to eq(@comment)
+        expect(comments.second).to eq(yet_another_comment)
+        expect(comments.last).to eq(another_comment)
       end
     end
 
     describe ".resource_id_cast" do
-      let(:post) { Post.create!(:title => "Testing.") }
+      let(:post) { Post.create!(title: "Testing.") }
       let(:namespace_name) { "admin" }
 
       it "should cast resource_id as string" do
-        comment = ActiveAdmin::Comment.create! :resource => post,
-                                                :body => "Another Comment",
-                                                :namespace => namespace_name
-        ActiveAdmin::Comment.resource_id_cast(comment).class.should eql String
+        comment = ActiveAdmin::Comment.create! resource: post,
+                                                body: "Another Comment",
+                                                namespace: namespace_name
+        expect(ActiveAdmin::Comment.resource_id_cast(comment).class).to eql String
+      end
+    end
+
+    describe ".resource_type" do
+      let(:post) { Post.create!(title: "Testing.") }
+      let(:post_decorator) { double 'PostDecorator' }
+
+      before do
+        allow(post_decorator).to receive(:model).and_return(post)
+        allow(post_decorator).to receive(:decorated?).and_return(true)
+      end
+
+      context "when a decorated object is passed" do
+        let(:resource) { post_decorator }
+
+        it "returns undeorated object class string" do
+          expect(ActiveAdmin::Comment.resource_type resource).to eql 'Post'
+        end
+      end
+
+      context "when an undecorated object is passed" do
+        let(:resource) { post }
+
+        it "returns object class string" do
+          expect(ActiveAdmin::Comment.resource_type resource).to eql 'Post'
+        end
       end
     end
 
     describe ".resource_id_type" do
       it "should be :string" do
-        ActiveAdmin::Comment.resource_id_type.should eql :string
+        expect(ActiveAdmin::Comment.resource_id_type).to eql :string
       end
     end
 
     describe "Commenting on resource with string id" do
-      let(:tag){ Tag.create!(:name => "cooltags") }
-      let(:namespace_name){ "admin" }
+      let(:tag) { Tag.create!(name: "cooltags") }
+      let(:namespace_name) { "admin" }
 
       it "should allow commenting" do
-        comment = ActiveAdmin::Comment.create! :resource => tag,
-                                                :body => "Another Comment",
-                                                :namespace => namespace_name
+        comment = ActiveAdmin::Comment.create!(
+          resource: tag,
+          body: "Another Comment",
+          namespace: namespace_name)
 
-        ActiveAdmin::Comment.find_for_resource_in_namespace(tag, namespace_name).should == [comment]
+        expect(ActiveAdmin::Comment.find_for_resource_in_namespace(tag, namespace_name)).to eq [comment]
+      end
+    end
+
+    describe "commenting on child of STI resource" do
+      let(:publisher) { Publisher.create!(username: "tenderlove") }
+      let(:namespace_name) { "admin" }
+
+      it "should assign child class as commented resource" do
+        comment = ActiveAdmin::Comment.create!(
+          resource: publisher,
+          body: "Lorem Ipsum",
+          namespace: namespace_name)
+
+        expect(ActiveAdmin::Comment.find_for_resource_in_namespace(publisher, namespace_name).last.resource_type).
+          to eq("User")
       end
     end
   end
@@ -75,16 +136,15 @@ describe "Comments" do
 
       it "should have comments when the namespace allows comments" do
         ns = ActiveAdmin::Namespace.new(application, :admin)
-        ns.allow_comments = true
-        ns.comments?.should be_true
+        ns.comments = true
+        expect(ns.comments?).to be_truthy
       end
 
       it "should not have comments when the namespace does not allow comments" do
         ns = ActiveAdmin::Namespace.new(application, :admin)
-        ns.allow_comments = false
-        ns.comments?.should be_false
+        ns.comments = false
+        expect(ns.comments?).to be_falsey
       end
-
     end
   end
 
@@ -92,15 +152,15 @@ describe "Comments" do
     it "should add an attr_accessor :comments to ActiveAdmin::Resource" do
       ns = ActiveAdmin::Namespace.new(application, :admin)
       resource = ActiveAdmin::Resource.new(ns, Post)
-      resource.comments.should be_nil
+      expect(resource.comments).to be_nil
       resource.comments = true
-      resource.comments.should be_true
+      expect(resource.comments).to be_truthy
     end
     it "should disable comments if set to false" do
       ns = ActiveAdmin::Namespace.new(application, :admin)
       resource = ActiveAdmin::Resource.new(ns, Post)
       resource.comments = false
-      resource.comments?.should be_false
+      expect(resource.comments?).to be_falsey
     end
   end
 end

data/spec/unit/component_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 
 class MockComponentClass < ActiveAdmin::Component; end
 
@@ -8,11 +8,11 @@ describe ActiveAdmin::Component do
   let(:component){ component_class.new }
 
   it "should be a subclass of an html div" do
-    ActiveAdmin::Component.ancestors.should include(Arbre::HTML::Div)
+    expect(ActiveAdmin::Component.ancestors).to include(Arbre::HTML::Div)
   end
 
   it "should render to a div, even as a subclass" do
-    component.tag_name.should == 'div'
+    expect(component.tag_name).to eq 'div'
   end
 
 end

data/spec/unit/config_shared_examples.rb

@@ -1,13 +1,13 @@
-shared_examples_for "ActiveAdmin::Config" do
+shared_examples_for "ActiveAdmin::Resource" do
   describe "namespace" do
     it "should return the namespace" do
-      config.namespace.should == namespace
+      expect(config.namespace).to eq(namespace)
     end
   end
 
   describe "page_presenters" do
     it "should return an empty hash by default" do
-      config.page_presenters.should == {}
+      expect(config.page_presenters).to eq({})
     end
   end
 
@@ -22,11 +22,11 @@ shared_examples_for "ActiveAdmin::Config" do
 
   describe "Naming" do
     it "implements #resource_label" do
-      expect { config.resource_label }.should_not raise_error
+      expect { config.resource_label }.to_not raise_error
     end
 
     it "implements #plural_resource_label" do
-      expect { config.plural_resource_label }.should_not raise_error
+      expect { config.plural_resource_label }.to_not raise_error
     end
   end
 
@@ -34,24 +34,24 @@ shared_examples_for "ActiveAdmin::Config" do
     describe "#menu_item_options" do
 
       it "initializes a new menu item with defaults" do
-          config.menu_item_options[:label].call.should == config.plural_resource_label
+          expect(config.menu_item_options[:label].call).to eq(config.plural_resource_label)
       end
 
       it "initialize a new menu item with custom options" do
-        config.menu_item_options = { :label => "Hello" }
-        config.menu_item_options[:label].should == "Hello"
+        config.menu_item_options = { label: "Hello" }
+        expect(config.menu_item_options[:label]).to eq("Hello")
       end
 
     end
 
     describe "#include_in_menu?" do
       it "should be included in menu by default" do
-        config.include_in_menu?.should == true
+        expect(config.include_in_menu?).to eq(true)
       end
 
       it "should not be included in menu when menu set to false" do
         config.menu_item_options = false
-        config.include_in_menu?.should == false
+        expect(config.include_in_menu?).to eq(false)
       end
     end
 

data/spec/unit/controller_filters_spec.rb

@@ -1,37 +1,44 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe ActiveAdmin::Application do
   let(:application){ ActiveAdmin::Application.new }
-  let(:controllers){ [ActiveAdmin::BaseController,            ActiveAdmin::Devise::SessionsController,
-                      ActiveAdmin::Devise::UnlocksController, ActiveAdmin::Devise::PasswordsController] }
+  let(:controllers){ application.controllers_for_filters }
+
+  it 'controllers_for_filters' do
+    expect(application.controllers_for_filters).to eq [
+      ActiveAdmin::BaseController, ActiveAdmin::Devise::SessionsController,
+      ActiveAdmin::Devise::PasswordsController, ActiveAdmin::Devise::UnlocksController,
+      ActiveAdmin::Devise::RegistrationsController, ActiveAdmin::Devise::ConfirmationsController
+    ]
+  end
 
   it 'before_filter' do
-    controllers.each{ |c| c.should_receive(:before_filter).and_return(true) }
-    application.before_filter :my_filter, :only => :show
+    controllers.each{ |c| expect(c).to receive(:before_filter).and_return(true) }
+    application.before_filter :my_filter, only: :show
   end
 
   it 'skip_before_filter' do
-    controllers.each{ |c| c.should_receive(:skip_before_filter).and_return(true) }
-    application.skip_before_filter :my_filter, :only => :show
+    controllers.each{ |c| expect(c).to receive(:skip_before_filter).and_return(true) }
+    application.skip_before_filter :my_filter, only: :show
   end
 
   it 'after_filter' do
-    controllers.each{ |c| c.should_receive(:after_filter).and_return(true) }
-    application.after_filter :my_filter, :only => :show
+    controllers.each{ |c| expect(c).to receive(:after_filter).and_return(true) }
+    application.after_filter :my_filter, only: :show
   end
 
   it 'skip after_filter' do
-    controllers.each{ |c| c.should_receive(:skip_after_filter).and_return(true) }
-    application.skip_after_filter :my_filter, :only => :show
+    controllers.each{ |c| expect(c).to receive(:skip_after_filter).and_return(true) }
+    application.skip_after_filter :my_filter, only: :show
   end
 
   it 'around_filter' do
-    controllers.each{ |c| c.should_receive(:around_filter).and_return(true) }
-    application.around_filter :my_filter, :only => :show
+    controllers.each{ |c| expect(c).to receive(:around_filter).and_return(true) }
+    application.around_filter :my_filter, only: :show
   end
-  
+
   it 'skip_filter' do
-    controllers.each{ |c| c.should_receive(:skip_filter).and_return(true) }
-    application.skip_filter :my_filter, :only => :show
+    controllers.each{ |c| expect(c).to receive(:skip_filter).and_return(true) }
+    application.skip_filter :my_filter, only: :show
   end
 end

data/spec/unit/csv_builder_spec.rb

@@ -1,32 +1,46 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe ActiveAdmin::CSVBuilder do
 
   describe '.default_for_resource using Post' do
-    let(:csv_builder) { ActiveAdmin::CSVBuilder.default_for_resource(Post) }
+    let(:csv_builder) { ActiveAdmin::CSVBuilder.default_for_resource(Post).tap(&:exec_columns) }
 
-    it "should return a default csv_builder for Post" do
-      csv_builder.should be_a(ActiveAdmin::CSVBuilder)
+    it 'returns a default csv_builder for Post' do
+      expect(csv_builder).to 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
+    it 'defines Id as the first column' do
+      expect(csv_builder.columns.first.name).to eq 'Id'
+      expect(csv_builder.columns.first.data).to eq :id
     end
 
-    specify "the following columns should be content_column" do
+    it "has Post's content_columns" 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
+        expect(column.name).to eq Post.content_columns[index].name.humanize
+        expect(column.data).to eq Post.content_columns[index].name.to_sym
+      end
+    end
+
+    context 'when column has a localized name' do
+      let(:localized_name) { 'Titulo' }
+
+      before do
+        allow(Post).to receive(:human_attribute_name).and_call_original
+        allow(Post).to receive(:human_attribute_name).with(:title){ localized_name }
+      end
+
+      it 'gets name from I18n' do
+        title_index = Post.content_columns.map(&:name).index('title') + 1 # First col is always id
+        expect(csv_builder.columns[title_index].name).to eq localized_name
       end
     end
   end
 
   context 'when empty' do
-    let(:builder){ ActiveAdmin::CSVBuilder.new }
+    let(:builder){ ActiveAdmin::CSVBuilder.new.tap(&:exec_columns) }
 
     it "should have no columns" do
-      builder.columns.should == []
+      expect(builder.columns).to eq []
     end
   end
 
@@ -34,22 +48,22 @@ describe ActiveAdmin::CSVBuilder do
     let(:builder) do
       ActiveAdmin::CSVBuilder.new do
         column :title
-      end
+      end.tap(&:exec_columns)
     end
 
     it "should have one column" do
-      builder.columns.size.should == 1
+      expect(builder.columns.size).to eq 1
     end
 
     describe "the column" do
       let(:column){ builder.columns.first }
 
       it "should have a name of 'Title'" do
-        column.name.should == "Title"
+        expect(column.name).to eq "Title"
       end
 
       it "should have the data :title" do
-        column.data.should == :title
+        expect(column.data).to eq :title
       end
     end
   end
@@ -60,44 +74,171 @@ describe ActiveAdmin::CSVBuilder do
         column "My title" do
           # nothing
         end
-      end
+      end.tap(&:exec_columns)
     end
 
     it "should have one column" do
-      builder.columns.size.should == 1
+      expect(builder.columns.size).to eq 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"
+        expect(column.name).to eq "My title"
       end
 
       it "should have the data :title" do
-        column.data.should be_an_instance_of(Proc)
+        expect(column.data).to be_an_instance_of(Proc)
+      end
+    end
+  end
+
+  context "with a humanize_name column option" do
+    context "with symbol column name" do
+      let(:builder) do
+        ActiveAdmin::CSVBuilder.new do
+          column :my_title, humanize_name: false
+        end.tap(&:exec_columns)
+      end
+
+      describe "the column" do
+        let(:column){ builder.columns.first }
+
+        it "should have a name of 'my_title'" do
+          expect(column.name).to eq "my_title"
+        end
+      end
+    end
+
+    context "with string column name" do
+      let(:builder) do
+        ActiveAdmin::CSVBuilder.new do
+          column "my_title", humanize_name: false
+        end.tap(&:exec_columns)
+      end
+
+      describe "the column" do
+        let(:column){ builder.columns.first }
+
+        it "should have a name of 'my_title'" do
+          expect(column.name).to eq "my_title"
+        end
       end
     end
   end
 
   context "with a separator" do
     let(:builder) do
-      ActiveAdmin::CSVBuilder.new :col_sep => ";"
+      ActiveAdmin::CSVBuilder.new(col_sep: ";").tap(&:exec_columns)
     end
 
     it "should have proper separator" do
-      builder.options.should == {:col_sep => ";"}
+      expect(builder.options).to eq({col_sep: ";"})
+    end
+  end
+
+  context "with humanize_name option" do
+    let(:builder) do
+      ActiveAdmin::CSVBuilder.new(humanize_name: false) do
+        column :my_title
+      end.tap(&:exec_columns)
+    end
+
+    describe "the column" do
+      let(:column){ builder.columns.first }
+
+      it "should have humanize_name option set" do
+        expect(column.options).to eq humanize_name: false
+      end
+
+      it "should have a name of 'my_title'" do
+        expect(column.name).to eq "my_title"
+      end
     end
   end
 
   context "with csv_options" do
     let(:builder) do
-      ActiveAdmin::CSVBuilder.new :force_quotes => true
+      ActiveAdmin::CSVBuilder.new(force_quotes: true).tap(&:exec_columns)
     end
 
     it "should have proper separator" do
-      builder.options.should == {:force_quotes => true}
+      expect(builder.options).to eq({force_quotes: true})
     end
   end
 
+  context "with access to the controller" do
+    let(:dummy_view_context) { double(controller: dummy_controller) }
+    let(:dummy_controller) { double(names: %w(title summary updated_at created_at))}
+    let(:builder) do
+      ActiveAdmin::CSVBuilder.new do
+        column "id"
+        controller.names.each do |name|
+          column(name)
+        end
+      end.tap{ |b| b.exec_columns(dummy_view_context) }
+    end
+
+    it "should build columns provided by the controller" do
+      expect(builder.columns.map(&:data)).to match_array([:id, :title, :summary, :updated_at, :created_at])
+    end
+  end
+
+  context "build csv using the supplied order" do
+    before do
+      @post1 = Post.create!(title: "Hello1", published_at: Date.today - 2.day )
+      @post2 = Post.create!(title: "Hello2", published_at: Date.today - 1.day )
+    end
+    let(:dummy_controller) {
+      class DummyController
+        def find_collection(*)
+          collection
+        end
+
+        def collection
+          Post.order('published_at DESC')
+        end
+
+        def apply_decorator(resource)
+          resource
+        end
+
+        def view_context
+        end
+      end
+      DummyController.new
+    }
+    let(:builder) do
+      ActiveAdmin::CSVBuilder.new do
+        column "id"
+        column "title"
+        column "published_at"
+      end
+    end
+
+    it "should generate data with the supplied order" do
+      expect(builder).to receive(:build_row).and_return([]).once.ordered { |post| expect(post.id).to eq @post2.id }
+      expect(builder).to receive(:build_row).and_return([]).once.ordered { |post| expect(post.id).to eq @post1.id }
+      builder.build dummy_controller, []
+    end
+
+    it "should generate data ignoring pagination" do
+      expect(dummy_controller).to receive(:find_collection).
+        with(except: :pagination).once.
+        and_call_original
+      expect(builder).to receive(:build_row).and_return([]).twice
+      builder.build dummy_controller, []
+    end
+
+  end
+
+  skip '#exec_columns'
+
+  skip '#build_row' do
+    it 'renders non-strings'
+    it 'encodes values correctly'
+    it 'passes custom encoding options to String#encode!'
+  end
+
 end