activeadmin 0.6.6 → 1.0.0.pre1

data/spec/unit/resource_spec.rb

@@ -1,11 +1,10 @@
-require 'spec_helper'
+require 'rails_helper'
 require File.expand_path('config_shared_examples', File.dirname(__FILE__))
 
 module ActiveAdmin
   describe Resource do
 
-    it_should_behave_like "ActiveAdmin::Config"
-
+    it_should_behave_like "ActiveAdmin::Resource"
     before { load_defaults! }
 
     let(:application){ ActiveAdmin::Application.new }
@@ -19,33 +18,33 @@ module ActiveAdmin
 
     describe "#resource_table_name" do
       it "should return the resource's table name" do
-        config.resource_table_name.should == '"categories"'
+        expect(config.resource_table_name).to eq '"categories"'
       end
       context "when the :as option is given" do
         it "should return the resource's table name" do
-          config(:as => "My Category").resource_table_name.should == '"categories"'
+          expect(config(as: "My Category").resource_table_name).to eq '"categories"'
         end
       end
     end
 
     describe "#resource_column_names" do
       it "should return the resource's column names" do
-        config.resource_column_names.should == Category.column_names
+        expect(config.resource_column_names).to eq Category.column_names
       end
     end
 
     describe '#decorator_class' do
       it 'returns nil by default' do
-        config.decorator_class.should be_nil
+        expect(config.decorator_class).to be_nil
       end
       context 'when a decorator is defined' do
         let(:resource) { namespace.register(Post) { decorate_with PostDecorator } }
         specify '#decorator_class_name should return PostDecorator' do
-          resource.decorator_class_name.should == '::PostDecorator'
+          expect(resource.decorator_class_name).to eq '::PostDecorator'
         end
 
         it 'returns the decorator class' do
-          resource.decorator_class.should == PostDecorator
+          expect(resource.decorator_class).to eq PostDecorator
         end
       end
     end
@@ -53,12 +52,12 @@ module ActiveAdmin
 
     describe "controller name" do
       it "should return a namespaced controller name" do
-        config.controller_name.should == "Admin::CategoriesController"
+        expect(config.controller_name).to eq "Admin::CategoriesController"
       end
       context "when non namespaced controller" do
         let(:namespace){ ActiveAdmin::Namespace.new(application, :root) }
         it "should return a non namespaced controller name" do
-          config.controller_name.should == "CategoriesController"
+          expect(config.controller_name).to eq "CategoriesController"
         end
       end
     end
@@ -69,27 +68,27 @@ module ActiveAdmin
 
       context "when regular resource" do
         let(:resource){ namespace.register(Post) }
-        it { should be_include_in_menu }
+        it { is_expected.to be_include_in_menu }
       end
 
       context "when menu set to false" do
         let(:resource){ namespace.register(Post){ menu false } }
-        it { should_not be_include_in_menu }
+        it { is_expected.not_to be_include_in_menu }
       end
     end
 
     describe "#belongs_to" do
 
       it "should build a belongs to configuration" do
-        config.belongs_to_config.should be_nil
+        expect(config.belongs_to_config).to be_nil
         config.belongs_to :posts
-        config.belongs_to_config.should_not be_nil
+        expect(config.belongs_to_config).to_not be_nil
       end
 
       it "should set the target menu to the belongs to target" do
-        config.navigation_menu_name.should == ActiveAdmin::DEFAULT_MENU
+        expect(config.navigation_menu_name).to eq ActiveAdmin::DEFAULT_MENU
         config.belongs_to :posts
-        config.navigation_menu_name.should == :posts
+        expect(config.navigation_menu_name).to eq :posts
       end
 
     end
@@ -105,7 +104,7 @@ module ActiveAdmin
         end
         it "should call the proc for the begin of association chain" do
           begin_of_association_chain = @resource.controller.new.send(:begin_of_association_chain)
-          begin_of_association_chain.should == "scoped"
+          expect(begin_of_association_chain).to eq "scoped"
         end
       end
 
@@ -117,9 +116,9 @@ module ActiveAdmin
         end
         it "should call the method for the begin of association chain" do
           controller = @resource.controller.new
-          controller.should_receive(:current_user).and_return(true)
+          expect(controller).to receive(:current_user).and_return(true)
           begin_of_association_chain = controller.send(:begin_of_association_chain)
-          begin_of_association_chain.should == true
+          expect(begin_of_association_chain).to eq true
         end
       end
 
@@ -131,17 +130,17 @@ module ActiveAdmin
             end
           end
           it "should return the pluralized collection name" do
-            @resource.controller.new.send(:method_for_association_chain).should == :categories
+            expect(@resource.controller.new.send(:method_for_association_chain)).to eq :categories
           end
         end
         context "when passing in the method as an option" do
           before do
             @resource = application.register Category do
-              scope_to :current_user, :association_method => :blog_categories
+              scope_to :current_user, association_method: :blog_categories
             end
           end
           it "should return the method from the option" do
-            @resource.controller.new.send(:method_for_association_chain).should == :blog_categories
+            expect(@resource.controller.new.send(:method_for_association_chain)).to eq :blog_categories
           end
         end
       end
@@ -152,22 +151,22 @@ module ActiveAdmin
 
       context "when resource class responds to primary_key" do
         it "should sort by primary key desc by default" do
-          MockResource.should_receive(:primary_key).and_return("pk")
+          expect(MockResource).to receive(:primary_key).and_return("pk")
           config = Resource.new(namespace, MockResource)
-          config.sort_order.should == "pk_desc"
+          expect(config.sort_order).to eq "pk_desc"
         end
       end
 
       context "when resource class does not respond to primary_key" do
         it "should default to id" do
           config = Resource.new(namespace, MockResource)
-          config.sort_order.should == "id_desc"
+          expect(config.sort_order).to eq "id_desc"
         end
       end
 
       it "should be set-able" do
         config.sort_order = "task_id_desc"
-        config.sort_order.should == "task_id_desc"
+        expect(config.sort_order).to eq "task_id_desc"
       end
 
     end
@@ -176,19 +175,19 @@ module ActiveAdmin
 
       it "should add a scope" do
         config.scope :published
-        config.scopes.first.should be_a(ActiveAdmin::Scope)
-        config.scopes.first.name.should == "Published"
+        expect(config.scopes.first).to be_a(ActiveAdmin::Scope)
+        expect(config.scopes.first.name).to eq "Published"
       end
 
       it "should retrive a scope by its id" do
         config.scope :published
-        config.get_scope_by_id(:published).name.should == "Published"
+        expect(config.get_scope_by_id(:published).name).to eq "Published"
       end
 
       it "should retrieve the default scope by proc" do
-        config.scope :published, :default => proc{ true }
+        config.scope :published, default: proc{ true }
         config.scope :all
-        config.default_scope.name.should == "Published"
+        expect(config.default_scope.name).to eq "Published"
       end
 
     end
@@ -196,7 +195,7 @@ module ActiveAdmin
     describe "#csv_builder" do
       context "when no csv builder set" do
         it "should return a default column builder with id and content columns" do
-          config.csv_builder.columns.size.should == Category.content_columns.size + 1
+          expect(config.csv_builder.exec_columns.size).to eq Category.content_columns.size + 1
         end
       end
 
@@ -204,38 +203,74 @@ module ActiveAdmin
         it "shuld return the csv_builder we set" do
           csv_builder = CSVBuilder.new
           config.csv_builder = csv_builder
-          config.csv_builder.should == csv_builder
+          expect(config.csv_builder).to eq csv_builder
+        end
+      end
+    end
+
+    describe "#breadcrumb" do
+      subject { config.breadcrumb }
+
+      context "when no breadcrumb is set" do
+        it { is_expected.to eq(namespace.breadcrumb) }
+      end
+
+      context "when breadcrumb is set" do
+        context "when set to true" do
+          before { config.breadcrumb = true }
+          it { is_expected.to be_truthy }
+        end
+
+        context "when set to false" do
+          before { config.breadcrumb = false }
+          it { is_expected.to be_falsey }
         end
       end
     end
 
     describe '#find_resource' do
       let(:resource) { namespace.register(Post) }
-      let(:post) { stub }
+      let(:post) { double }
       before do
-        Post.stub(:where).with('id' => '12345').and_return { [post] }
+        allow(Post).to receive(:find_by_id).with('12345') { post }
       end
 
       it 'can find the resource' do
-        resource.find_resource('12345').should == post
+        expect(resource.find_resource('12345')).to eq post
       end
 
       context 'with a decorator' do
         let(:resource) { namespace.register(Post) { decorate_with PostDecorator } }
         it 'decorates the resource' do
-          resource.find_resource('12345').should == PostDecorator.new(post)
+          expect(resource.find_resource('12345')).to eq PostDecorator.new(post)
         end
       end
 
       context 'when using a nonstandard primary key' do
-        let(:different_post) { stub }
+        let(:different_post) { double }
         before do
-          Post.stub(:primary_key).and_return 'something_else'
-          Post.stub(:where).with('something_else' => '55555').and_return { [different_post] }
+          allow(Post).to receive(:primary_key).and_return 'something_else'
+          allow(Post).to receive(:find_by_something_else).with('55555') { different_post }
         end
 
         it 'can find the post by the custom primary key' do
-          resource.find_resource('55555').should == different_post
+          expect(resource.find_resource('55555')).to eq different_post
+        end
+      end
+
+      context 'when using controller finder' do
+        let(:resource) do
+          namespace.register(Post) do
+            controller do
+              defaults finder: :find_by_title!
+            end
+          end
+        end
+
+        it 'can find the post by controller finder' do
+          allow(Post).to receive(:find_by_title!).with('title-name').and_return(post)
+
+          expect(resource.find_resource('title-name')).to eq post
         end
       end
     end

data/spec/unit/routing_spec.rb

@@ -1,8 +1,8 @@
 # encoding: utf-8
 
-require 'spec_helper'
+require 'rails_helper'
 
-describe ActiveAdmin, "Routing", :type => :routing do
+describe ActiveAdmin, "Routing", type: :routing do
 
   before do
     load_defaults!
@@ -10,51 +10,59 @@ describe ActiveAdmin, "Routing", :type => :routing do
   end
 
   it "should only have the namespaces necessary for route testing" do
-    ActiveAdmin.application.namespaces.keys.should eq [:admin, :root]
+    expect(ActiveAdmin.application.namespaces.names).to eq [:admin, :root]
   end
 
   it "should route to the admin dashboard" do
-    get('/admin').should route_to 'admin/dashboard#index'
+    expect(get('/admin')).to route_to 'admin/dashboard#index'
+  end
+
+  describe "root path helper" do
+    context "when in admin namespace" do
+      it "should be admin_root_path" do
+        expect(admin_root_path).to eq "/admin"
+      end
+    end
   end
 
   describe "standard resources" do
     context "when in admin namespace" do
       it "should route the index path" do
-        admin_posts_path.should == "/admin/posts"
+        expect(admin_posts_path).to eq "/admin/posts"
       end
 
       it "should route the show path" do
-        admin_post_path(1).should == "/admin/posts/1"
+        expect(admin_post_path(1)).to eq "/admin/posts/1"
       end
 
       it "should route the new path" do
-        new_admin_post_path.should == "/admin/posts/new"
+        expect(new_admin_post_path).to eq "/admin/posts/new"
       end
 
       it "should route the edit path" do
-        edit_admin_post_path(1).should == "/admin/posts/1/edit"
+        expect(edit_admin_post_path(1)).to eq "/admin/posts/1/edit"
       end
     end
 
     context "when in root namespace" do
       before(:each) do
-        load_resources { ActiveAdmin.register(Post, :namespace => false) }
+        load_resources { ActiveAdmin.register(Post, namespace: false) }
       end
 
       it "should route the index path" do
-        posts_path.should == "/posts"
+        expect(posts_path).to eq "/posts"
       end
 
       it "should route the show path" do
-        post_path(1).should == "/posts/1"
+        expect(post_path(1)).to eq "/posts/1"
       end
 
       it "should route the new path" do
-        new_post_path.should == "/posts/new"
+        expect(new_post_path).to eq "/posts/new"
       end
 
       it "should route the edit path" do
-        edit_post_path(1).should == "/posts/1/edit"
+        expect(edit_post_path(1)).to eq "/posts/1/edit"
       end
     end
 
@@ -67,36 +75,36 @@ describe ActiveAdmin, "Routing", :type => :routing do
         end
 
         it "should default to GET" do
-          {:get  => "/admin/posts/1/do_something"}.should     be_routable
-          {:post => "/admin/posts/1/do_something"}.should_not be_routable
+          expect({get: "/admin/posts/1/do_something"}).to      be_routable
+          expect({post: "/admin/posts/1/do_something"}).to_not be_routable
         end
       end
 
       context "with one http verb" do
         before do
           load_resources do
-            ActiveAdmin.register(Post){ member_action "do_something", :method => :post }
+            ActiveAdmin.register(Post){ member_action "do_something", method: :post }
           end
         end
 
         it "should properly route" do
-          {:post => "/admin/posts/1/do_something"}.should be_routable
+          expect({post: "/admin/posts/1/do_something"}).to be_routable
         end
       end
 
       context "with two http verbs" do
         before do
           load_resources do
-            ActiveAdmin.register(Post){ member_action "do_something", :method => [:put, :delete] }
+            ActiveAdmin.register(Post){ member_action "do_something", method: [:put, :delete] }
           end
         end
 
         it "should properly route the first verb" do
-          {:put => "/admin/posts/1/do_something"}.should be_routable
+          expect({put: "/admin/posts/1/do_something"}).to be_routable
         end
 
         it "should properly route the second verb" do
-          {:delete => "/admin/posts/1/do_something"}.should be_routable
+          expect({delete: "/admin/posts/1/do_something"}).to be_routable
         end
       end
     end
@@ -104,26 +112,26 @@ describe ActiveAdmin, "Routing", :type => :routing do
 
   describe "belongs to resource" do
     it "should route the nested index path" do
-      admin_user_posts_path(1).should == "/admin/users/1/posts"
+      expect(admin_user_posts_path(1)).to eq "/admin/users/1/posts"
     end
 
     it "should route the nested show path" do
-      admin_user_post_path(1,2).should == "/admin/users/1/posts/2"
+      expect(admin_user_post_path(1,2)).to eq "/admin/users/1/posts/2"
     end
 
     it "should route the nested new path" do
-      new_admin_user_post_path(1).should == "/admin/users/1/posts/new"
+      expect(new_admin_user_post_path(1)).to eq "/admin/users/1/posts/new"
     end
 
     it "should route the nested edit path" do
-      edit_admin_user_post_path(1,2).should == "/admin/users/1/posts/2/edit"
+      expect(edit_admin_user_post_path(1,2)).to eq "/admin/users/1/posts/2/edit"
     end
 
     context "with collection action" do
       before do
         load_resources do
           ActiveAdmin.register(Post) do
-            belongs_to :user, :optional => true
+            belongs_to :user, optional: true
           end
           ActiveAdmin.register(User) do
             collection_action "do_something"
@@ -132,8 +140,8 @@ describe ActiveAdmin, "Routing", :type => :routing do
       end
 
       it "should properly route the collection action" do
-        { :get => "/admin/users/do_something" }.
-          should route_to({ :controller => 'admin/users',:action => 'do_something'})
+        expect({ get: "/admin/users/do_something" }).to \
+          route_to({ controller: 'admin/users', action: 'do_something'})
       end
     end
   end
@@ -145,16 +153,16 @@ describe ActiveAdmin, "Routing", :type => :routing do
       end
 
       it "should route to the page under /admin" do
-        admin_chocolate_i_love_you_path.should == "/admin/chocolate_i_love_you"
+        expect(admin_chocolate_i_love_you_path).to eq "/admin/chocolate_i_love_you"
       end
 
       context "when in the root namespace" do
         before(:each) do
-          load_resources { ActiveAdmin.register_page("Chocolate I lØve You!", :namespace => false) }
+          load_resources { ActiveAdmin.register_page("Chocolate I lØve You!", namespace: false) }
         end
 
         it "should route to page under /" do
-          chocolate_i_love_you_path.should == "/chocolate_i_love_you"
+          expect(chocolate_i_love_you_path).to eq "/chocolate_i_love_you"
         end
       end
 
@@ -164,7 +172,7 @@ describe ActiveAdmin, "Routing", :type => :routing do
         end
 
         it "should not inject _index_ into the route name" do
-          admin_log_path.should == "/admin/log"
+          expect(admin_log_path).to eq "/admin/log"
         end
       end
     end