yousty-activeadmin 1.0.4.pre → 1.0.5.pre

data/spec/unit/resource_controller/decorators_spec.rb

@@ -0,0 +1,83 @@
+require 'rails_helper'
+
+describe ActiveAdmin::ResourceController::Decorators do
+  let(:controller_class) do
+    Class.new do
+      def self.name
+        "Test Controller using Decorators"
+      end
+
+      include ActiveAdmin::ResourceController::Decorators
+
+      public :apply_decorator, :apply_collection_decorator
+    end
+  end
+
+  let(:controller) { controller_class.new }
+  let(:active_admin_config) { double(decorator_class: decorator_class) }
+  before do
+    allow(controller).to receive(:active_admin_config).and_return(active_admin_config)
+    allow(controller).to receive(:action_name).and_return(action)
+  end
+
+  describe '#apply_decorator' do
+    let(:action) { 'show' }
+    let(:resource) { Post.new }
+    subject(:applied) { controller.apply_decorator(resource) }
+
+    context 'with a decorator configured' do
+      let(:decorator_class) { PostDecorator }
+      it { is_expected.to be_kind_of(PostDecorator) }
+    end
+
+    context 'with no decorator configured' do
+      let(:decorator_class) { nil }
+      it { is_expected.to be_kind_of(Post) }
+    end
+  end
+
+  describe '#apply_collection_decorator' do
+    before { Post.create! }
+    let(:action) { 'index' }
+    let(:collection) { Post.where nil }
+    subject(:applied) { controller.apply_collection_decorator(collection) }
+
+    context 'when a decorator is configured' do
+      context 'and it is using a recent version of draper' do
+        let(:decorator_class) { PostDecorator }
+
+        it 'calling certain scope collections work' do
+          # This is an example of one of the methods that was consistently
+          # failing before this feature existed
+          expect(applied.reorder('').count).to eq applied.count
+        end
+
+        it 'has a good description for the generated class' do
+          expect(applied.class.name).to eq "Draper::CollectionDecorator of PostDecorator + ActiveAdmin"
+        end
+
+      end
+    end
+  end
+
+  describe 'form actions' do
+    let(:action) { 'edit' }
+    let(:resource) { Post.new }
+    let(:form_presenter) { double options: { decorate: decorate_form } }
+    let(:decorator_class) { PostDecorator }
+    before { allow(active_admin_config).to receive(:get_page_presenter).with(:form).and_return form_presenter }
+
+    subject(:applied) { controller.apply_decorator(resource) }
+
+    context 'when the form is not configured to decorate' do
+      let(:decorate_form) { false }
+      it { is_expected.to be_kind_of(Post) }
+    end
+
+    context 'when the form is configured to decorate' do
+      let(:decorate_form) { true }
+      it { is_expected.to be_kind_of(PostDecorator) }
+    end
+
+  end
+end

data/spec/unit/resource_controller/sidebars_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe ActiveAdmin::ResourceController::Sidebars do
   let(:controller){ Admin::PostsController }
@@ -10,7 +10,7 @@ describe ActiveAdmin::ResourceController::Sidebars do
 
     subject { find_before_filter controller, :skip_sidebar! }
 
-    it { should set_skip_sidebar_to nil }
+    it { is_expected.to set_skip_sidebar_to nil, for: controller }
   end
 
   describe '#skip_sidebar!' do
@@ -22,7 +22,7 @@ describe ActiveAdmin::ResourceController::Sidebars do
 
     subject { find_before_filter controller, :skip_sidebar! }
 
-    it { should set_skip_sidebar_to true }
+    it { is_expected.to set_skip_sidebar_to true, for: controller }
   end
 
   def find_before_filter(controller, filter)
@@ -30,16 +30,15 @@ describe ActiveAdmin::ResourceController::Sidebars do
     controller._process_action_callbacks.detect { |f| f.raw_filter == filter.to_sym }
   end
 
-  RSpec::Matchers.define :set_skip_sidebar_to do |expected|
+  RSpec::Matchers.define :set_skip_sidebar_to do |expected, options|
     match do |filter|
-      klass = filter && filter.klass || controller
-      object = klass.new
+      object = options[:for].new
       object.send filter.raw_filter if filter
       @actual = object.instance_variable_get(:@skip_sidebar)
-      @actual == expected
+      expect(@actual).to eq expected
     end
 
-    failure_message_for_should do |filter|
+    failure_message do |filter|
       message = "expected before_filter to set @skip_sidebar to '#{expected}', but was '#{@actual}'"
     end
   end

data/spec/unit/resource_controller_spec.rb

@@ -1,9 +1,7 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe ActiveAdmin::ResourceController do
 
-  before(:all) { load_defaults! }
-
   let(:controller) { ActiveAdmin::ResourceController.new }
 
   describe "authenticating the user" do
@@ -11,7 +9,7 @@ describe ActiveAdmin::ResourceController do
 
     it "should do nothing when no authentication_method set" do
       namespace = controller.class.active_admin_config.namespace
-      namespace.should_receive(:authentication_method).once.and_return(nil)
+      expect(namespace).to receive(:authentication_method).once.and_return(nil)
 
       controller.send(:authenticate_active_admin_user)
     end
@@ -19,10 +17,10 @@ describe ActiveAdmin::ResourceController do
     it "should call the authentication_method when set" do
       namespace = controller.class.active_admin_config.namespace
 
-      namespace.should_receive(:authentication_method).twice.
+      expect(namespace).to receive(:authentication_method).twice.
         and_return(:authenticate_admin_user!)
 
-      controller.should_receive(:authenticate_admin_user!).and_return(true)
+      expect(controller).to receive(:authenticate_admin_user!).and_return(true)
 
       controller.send(:authenticate_active_admin_user)
     end
@@ -34,21 +32,21 @@ describe ActiveAdmin::ResourceController do
 
     it "should return nil when no current_user_method set" do
       namespace = controller.class.active_admin_config.namespace
-      namespace.should_receive(:current_user_method).once.and_return(nil)
+      expect(namespace).to receive(:current_user_method).once.and_return(nil)
 
-      controller.send(:current_active_admin_user).should == nil
+      expect(controller.send(:current_active_admin_user)).to eq nil
     end
 
     it "should call the current_user_method when set" do
       user = double
       namespace = controller.class.active_admin_config.namespace
 
-      namespace.should_receive(:current_user_method).twice.
+      expect(namespace).to receive(:current_user_method).twice.
         and_return(:current_admin_user)
 
-      controller.should_receive(:current_admin_user).and_return(user)
+      expect(controller).to receive(:current_admin_user).and_return(user)
 
-      controller.send(:current_active_admin_user).should == user
+      expect(controller.send(:current_active_admin_user)).to eq user
     end
   end
 
@@ -84,141 +82,141 @@ describe ActiveAdmin::ResourceController do
 
     describe "performing create" do
       let(:controller){ Admin::PostsController.new }
-      let(:resource){ double("Resource", :save => true) }
+      let(:resource){ double("Resource", save: true) }
 
       before do
-        resource.should_receive(:save)
+        expect(resource).to receive(:save)
       end
 
       it "should call the before create callback" do
-        controller.should_receive(:call_before_create).with(resource)
+        expect(controller).to receive(:call_before_create).with(resource)
         controller.send :create_resource, resource
       end
       it "should call the before save callback" do
-        controller.should_receive(:call_before_save).with(resource)
+        expect(controller).to receive(:call_before_save).with(resource)
         controller.send :create_resource, resource
       end
       it "should call the after save callback" do
-        controller.should_receive(:call_after_save).with(resource)
+        expect(controller).to receive(:call_after_save).with(resource)
         controller.send :create_resource, resource
       end
       it "should call the after create callback" do
-        controller.should_receive(:call_after_create).with(resource)
+        expect(controller).to receive(:call_after_create).with(resource)
         controller.send :create_resource, resource
       end
     end
 
     describe "performing update" do
       let(:controller){ Admin::PostsController.new }
-      let(:resource){ double("Resource", :attributes= => true, :save => true) }
+      let(:resource){ double("Resource", :attributes= => true, save: true) }
       let(:attributes){ [{}] }
 
       before do
-        resource.should_receive(:attributes=).with(attributes[0])
-        resource.should_receive(:save)
+        expect(resource).to receive(:attributes=).with(attributes[0])
+        expect(resource).to receive(:save)
       end
 
       it "should call the before update callback" do
-        controller.should_receive(:call_before_update).with(resource)
+        expect(controller).to receive(:call_before_update).with(resource)
         controller.send :update_resource, resource, attributes
       end
       it "should call the before save callback" do
-        controller.should_receive(:call_before_save).with(resource)
+        expect(controller).to receive(:call_before_save).with(resource)
         controller.send :update_resource, resource, attributes
       end
       it "should call the after save callback" do
-        controller.should_receive(:call_after_save).with(resource)
+        expect(controller).to receive(:call_after_save).with(resource)
         controller.send :update_resource, resource, attributes
       end
       it "should call the after create callback" do
-        controller.should_receive(:call_after_update).with(resource)
+        expect(controller).to receive(:call_after_update).with(resource)
         controller.send :update_resource, resource, attributes
       end
     end
 
     describe "performing destroy" do
       let(:controller){ Admin::PostsController.new }
-      let(:resource){ double("Resource", :destroy => true) }
+      let(:resource){ double("Resource", destroy: true) }
 
       before do
-        resource.should_receive(:destroy)
+        expect(resource).to receive(:destroy)
       end
 
       it "should call the before destroy callback" do
-        controller.should_receive(:call_before_destroy).with(resource)
+        expect(controller).to receive(:call_before_destroy).with(resource)
         controller.send :destroy_resource, resource
       end
 
       it "should call the after destroy callback" do
-        controller.should_receive(:call_after_destroy).with(resource)
+        expect(controller).to receive(:call_after_destroy).with(resource)
         controller.send :destroy_resource, resource
       end
     end
   end
 end
 
-describe Admin::PostsController, :type => "controller" do
+describe Admin::PostsController, type: "controller" do
 
   describe 'retreiving the resource' do
     let(:controller){ Admin::PostsController.new }
-    let(:post) { Post.new :title => "An incledibly unique Post Title" }
+    let(:post) { Post.new title: "An incledibly unique Post Title" }
 
     before do
-      Post.stub(:find).and_return(post)
+      allow(Post).to receive(:find).and_return(post)
       controller.class_eval { public :resource }
-      controller.stub(:params).and_return({ :id => '1' })
+      allow(controller).to receive(:params).and_return({ id: '1' })
     end
 
     subject { controller.resource }
 
     it "returns a Post" do
-      subject.should be_kind_of(Post)
+      expect(subject).to be_kind_of(Post)
     end
 
     context 'with a decorator' do
       let(:config) { controller.class.active_admin_config }
       before { config.decorator_class_name = '::PostDecorator' }
       it 'returns a PostDecorator' do
-        subject.should be_kind_of(PostDecorator)
+        expect(subject).to be_kind_of(PostDecorator)
       end
 
       it 'returns a PostDecorator that wraps the post' do
-        subject.title.should == post.title
+        expect(subject.title).to eq post.title
       end
     end
   end
 
   describe 'retreiving the resource collection' do
     let(:controller){ Admin::PostsController.new }
+    let(:config) { controller.class.active_admin_config }
     before do
-      Post.create!(:title => "An incledibly unique Post Title") if Post.count == 0
-      controller.class_eval { public :collection }
+      Post.create!(title: "An incledibly unique Post Title") if Post.count == 0
+      config.decorator_class_name = nil
+      request = double 'Request', format: 'application/json'
+      allow(controller).to receive(:params) { {} }
+      allow(controller).to receive(:request){ request }
     end
 
-    subject { controller.collection }
+    subject { controller.send :collection }
 
     it {
-      pending # doesn't pass when running whole spec suite (WTF)
-      should be_kind_of(ActiveRecord::Relation)
+      is_expected.to be_a ActiveRecord::Relation
     }
 
     it "returns a collection of posts" do
-      pending # doesn't pass when running whole spec suite (WTF)
-      subject.first.should be_kind_of(Post)
+      expect(subject.first).to be_kind_of(Post)
     end
 
     context 'with a decorator' do
-      let(:config) { controller.class.active_admin_config }
-      before { config.decorator_class_name = '::PostDecorator' }
+      before { config.decorator_class_name = 'PostDecorator' }
 
-      it 'returns a PostDecorator' do
-        pending # doesn't pass when running whole spec suite (WTF)
-        subject.should be_kind_of(PostDecorator::DecoratedEnumerableProxy)
+      it 'returns a collection decorator using PostDecorator' do
+        expect(subject).to be_a Draper::CollectionDecorator
+        expect(subject.decorator_class).to eq PostDecorator
       end
 
-      it 'returns a PostDecorator that wraps the post' do
-        pending # doesn't pass when running whole spec suite (WTF)
-        subject.first.title.should == Post.first.title
+      it 'returns a collection decorator that wraps the post' do
+        expect(subject.first.title).to eq Post.first.title
       end
     end
   end
@@ -226,36 +224,42 @@ describe Admin::PostsController, :type => "controller" do
 
   describe "performing batch_action" do
     let(:controller){ Admin::PostsController.new }
+    let(:batch_action) { ActiveAdmin::BatchAction.new :flag, "Flag", &batch_action_block }
+    let(:batch_action_block) { proc { } }
     before do
-      batch_action = ActiveAdmin::BatchAction.new :flag, "Flag" do
-        redirect_to collection_path
-      end
-
-      controller.class.active_admin_config.stub(:batch_actions).and_return([batch_action])
+      allow(controller.class.active_admin_config).to receive(:batch_actions).and_return([batch_action])
     end
 
     describe "when params batch_action matches existing BatchAction" do
+      before do
+        allow(controller).to receive(:params) { { batch_action: "flag", collection_selection: ["1"] } }
+      end
+
       it "should call the block with args" do
-        pending # dont know how to check if the block was called
+        expect(controller).to receive(:instance_exec).with(["1"], {})
+        controller.batch_action
+      end
+
+      it "should call the block in controller scope" do
+        expect(controller).to receive(:render_in_context).with(controller, nil).and_return({})
+        controller.batch_action
       end
     end
 
     describe "when params batch_action doesn't match a BatchAction" do
       it "should raise an error" do
-        pending # doesn't pass when running whole spec suite (WTF)
-
+        allow(controller).to receive(:params) { { batch_action: "derp", collection_selection: ["1"] } }
         expect {
-          post(:batch_action, :batch_action => "derp", :collection_selection => ["1"])
+          controller.batch_action
         }.to raise_error("Couldn't find batch action \"derp\"")
       end
     end
 
     describe "when params batch_action is blank" do
       it "should raise an error" do
-        pending # doesn't pass when running whole spec suite (WTF)
-
+        allow(controller).to receive(:params) { { collection_selection: ["1"] } }
         expect {
-          post(:batch_action, :collection_selection => ["1"])
+          controller.batch_action
         }.to raise_error("Couldn't find batch action \"\"")
       end
     end

data/spec/unit/resource_registration_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe "Registering an object to administer" do
   application = ActiveAdmin::Application.new
@@ -7,13 +7,13 @@ describe "Registering an object to administer" do
     namespace = ActiveAdmin::Namespace.new(application, :admin)
     it "should call register on the namespace" do
       application.namespaces[namespace.name] = namespace
-      namespace.should_receive(:register)
+      expect(namespace).to receive(:register)
 
       application.register Category
     end
 
     it "should dispatch a Resource::RegisterEvent" do
-      ActiveAdmin::Event.should_receive(:dispatch).with(ActiveAdmin::Resource::RegisterEvent, an_instance_of(ActiveAdmin::Resource))
+      expect(ActiveAdmin::Event).to receive(:dispatch).with(ActiveAdmin::Resource::RegisterEvent, an_instance_of(ActiveAdmin::Resource))
       application.register Category
     end
   end
@@ -22,15 +22,15 @@ describe "Registering an object to administer" do
     it "should call register on the namespace" do
       namespace = ActiveAdmin::Namespace.new(application, :hello_world)
       application.namespaces[namespace.name] = namespace
-      namespace.should_receive(:register)
+      expect(namespace).to receive(:register)
 
-      application.register Category, :namespace => :hello_world
+      application.register Category, namespace: :hello_world
     end
 
     it "should generate a Namespace::RegisterEvent and a Resource::RegisterEvent" do
-      ActiveAdmin::Event.should_receive(:dispatch).with(ActiveAdmin::Namespace::RegisterEvent, an_instance_of(ActiveAdmin::Namespace))
-      ActiveAdmin::Event.should_receive(:dispatch).with(ActiveAdmin::Resource::RegisterEvent, an_instance_of(ActiveAdmin::Resource))
-      application.register Category, :namespace => :not_yet_created
+      expect(ActiveAdmin::Event).to receive(:dispatch).with(ActiveAdmin::Namespace::RegisterEvent, an_instance_of(ActiveAdmin::Namespace))
+      expect(ActiveAdmin::Event).to receive(:dispatch).with(ActiveAdmin::Resource::RegisterEvent, an_instance_of(ActiveAdmin::Resource))
+      application.register Category, namespace: :not_yet_created
     end
   end
 
@@ -38,9 +38,9 @@ describe "Registering an object to administer" do
     it "should call register on the root namespace" do
       namespace = ActiveAdmin::Namespace.new(application, :root)
       application.namespaces[namespace.name] = namespace
-      namespace.should_receive(:register)
+      expect(namespace).to receive(:register)
 
-      application.register Category, :namespace => false
+      application.register Category, namespace: false
     end
   end
 
@@ -48,8 +48,8 @@ describe "Registering an object to administer" do
     it "should run the dsl in the same config object" do
       config_1 = ActiveAdmin.register(Category) { filter :name }
       config_2 = ActiveAdmin.register(Category) { filter :id }
-      config_1.should == config_2
-      config_1.filters.size.should == 2
+      expect(config_1).to eq config_2
+      expect(config_1.filters.size).to eq 2
     end
   end