activeadmin 1.0.0.pre4 → 2.4.0

data/spec/unit/resource_controller/data_access_spec.rb

@@ -1,140 +0,0 @@
-require 'rails_helper'
-
-describe ActiveAdmin::ResourceController::DataAccess do
-  let(:params) do
-    {}
-  end
-
-  let(:controller) do
-    rc = Admin::PostsController.new
-    allow(rc).to receive(:params) do
-      params
-    end
-    rc
-  end
-
-  describe "searching" do
-    let(:params) {{ q: {} }}
-    it "should call the search method" do
-      chain = double "ChainObj"
-      expect(chain).to receive(:ransack).with(params[:q]).once.and_return(Post.ransack)
-      controller.send :apply_filtering, chain
-    end
-  end
-
-  describe "sorting" do
-
-    context "valid clause" do
-      let(:params) {{ order: "id_asc" }}
-
-      it "reorders chain" do
-        chain = double "ChainObj"
-        expect(chain).to receive(:reorder).with('"posts"."id" asc').once.and_return(Post.search)
-        controller.send :apply_sorting, chain
-      end
-    end
-
-    context "invalid clause" do
-      let(:params) {{ order: "_asc" }}
-
-      it "returns chain untouched" do
-        chain = double "ChainObj"
-        expect(chain).not_to receive(:reorder)
-        expect(controller.send(:apply_sorting, chain)).to eq chain
-      end
-    end
-
-  end
-
-  describe "scoping" do
-
-    context "when no current scope" do
-      it "should set collection_before_scope to the chain and return the chain" do
-        chain = double "ChainObj"
-        expect(controller.send(:apply_scoping, chain)).to eq chain
-        expect(controller.send(:collection_before_scope)).to eq chain
-      end
-    end
-
-    context "when current scope" do
-      it "should set collection_before_scope to the chain and return the scoped chain" do
-        chain = double "ChainObj"
-        scoped_chain = double "ScopedChain"
-        current_scope = double "CurrentScope"
-        allow(controller).to receive(:current_scope) { current_scope }
-
-        expect(controller).to receive(:scope_chain).with(current_scope, chain) { scoped_chain }
-        expect(controller.send(:apply_scoping, chain)).to eq scoped_chain
-        expect(controller.send(:collection_before_scope)).to eq chain
-      end
-    end
-  end
-
-  describe "includes" do
-    context "with no includes" do
-      it "should return the chain" do
-        chain = double "ChainObj"
-        expect(controller.send(:apply_includes, chain)).to eq chain
-      end
-    end
-
-    context "with includes" do
-      it "should return the chain with the includes" do
-        chain = double "ChainObj"
-        chain_with_includes = double "ChainObjWithIncludes"
-        expect(chain).to receive(:includes).with(:taggings, :author).and_return(chain_with_includes)
-        expect(controller.send(:active_admin_config)).to receive(:includes).twice.and_return([:taggings, :author])
-        expect(controller.send(:apply_includes, chain)).to eq chain_with_includes
-      end
-    end
-  end
-
-  describe "find_collection" do
-    let(:appliers) do
-      ActiveAdmin::ResourceController::DataAccess::COLLECTION_APPLIES
-    end
-    let(:scoped_collection) do
-      double "ScopedCollectionChain"
-    end
-    before do
-      allow(controller).to receive(:scoped_collection).
-        and_return(scoped_collection)
-    end
-
-    it "should return chain with all appliers " do
-      appliers.each do |applier|
-        expect(controller).to receive("apply_#{applier}").
-          with(scoped_collection).
-          once.
-          and_return(scoped_collection)
-      end
-      expect(controller).to receive(:collection_applies).
-        with({}).and_call_original.once
-      controller.send :find_collection
-    end
-
-    describe "collection_applies" do
-      context "excepting appliers" do
-        let(:options) do
-          { except:
-              [:authorization_scope, :filtering, :scoping, :collection_decorator]
-          }
-        end
-
-        it "should except appliers" do
-          expect(controller.send :collection_applies, options).
-            to eq([:sorting, :includes, :pagination])
-        end
-      end
-
-      context "specifying only needed appliers" do
-        let(:options) do
-          { only: [:filtering, :scoping] }
-        end
-        it "should except appliers" do
-          expect(controller.send :collection_applies, options).to eq(options[:only])
-        end
-      end
-    end
-  end
-end

data/spec/unit/resource_controller/decorators_spec.rb

@@ -1,94 +0,0 @@
-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) }
-
-      context 'with form' do
-        let(:action) { 'update' }
-
-        it "does not decorate when :decorate is set to false" do 
-          form = double
-          allow(form).to receive(:options).and_return(:decorate => false)
-          allow(active_admin_config).to receive(:get_page_presenter).and_return(form)
-          is_expected.not_to be_kind_of(PostDecorator) 
-        end
-      end
-    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,38 +0,0 @@
-require 'rails_helper'
-
-describe ActiveAdmin::ResourceController::Sidebars, type: :controller do
-  let(:klass){ Admin::PostsController }
-  render_views # https://github.com/rspec/rspec-rails/issues/860
-
-  before do
-    @controller = klass.new
-  end
-
-  context 'without before_filter' do
-    before do
-      ActiveAdmin.register Post
-      reload_routes!
-    end
-
-    it 'does not set @skip_sidebar' do
-      get :index
-
-      expect(controller.instance_variable_get(:@skip_sidebar)).to eq nil
-    end
-  end
-
-  describe '#skip_sidebar!' do
-    before do
-      ActiveAdmin.register Post do
-        before_filter :skip_sidebar!
-      end
-      reload_routes!
-    end
-
-    it 'works' do
-      get :index
-
-      expect(controller.instance_variable_get(:@skip_sidebar)).to eq true
-    end
-  end
-end unless ActiveAdmin::Dependency.rails < 4

data/spec/unit/resource_controller_spec.rb

@@ -1,269 +0,0 @@
-require 'rails_helper'
-
-describe ActiveAdmin::ResourceController do
-
-  let(:controller) { ActiveAdmin::ResourceController.new }
-
-  describe "authenticating the user" do
-    let(:controller){ Admin::PostsController.new }
-
-    it "should do nothing when no authentication_method set" do
-      namespace = controller.class.active_admin_config.namespace
-      expect(namespace).to receive(:authentication_method).once.and_return(nil)
-
-      controller.send(:authenticate_active_admin_user)
-    end
-
-    it "should call the authentication_method when set" do
-      namespace = controller.class.active_admin_config.namespace
-
-      expect(namespace).to receive(:authentication_method).twice.
-        and_return(:authenticate_admin_user!)
-
-      expect(controller).to receive(:authenticate_admin_user!).and_return(true)
-
-      controller.send(:authenticate_active_admin_user)
-    end
-
-  end
-
-  describe "retrieving the current user" do
-    let(:controller){ Admin::PostsController.new }
-
-    it "should return nil when no current_user_method set" do
-      namespace = controller.class.active_admin_config.namespace
-      expect(namespace).to receive(:current_user_method).once.and_return(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
-
-      expect(namespace).to receive(:current_user_method).twice.
-        and_return(:current_admin_user)
-
-      expect(controller).to receive(:current_admin_user).and_return(user)
-
-      expect(controller.send(:current_active_admin_user)).to eq user
-    end
-  end
-
-
-  describe "callbacks" do
-    before :all do
-      application = ::ActiveAdmin::Application.new
-      namespace = ActiveAdmin::Namespace.new(application, :admin)
-      namespace.register Post do
-        after_build :call_after_build
-        before_save :call_before_save
-        after_save :call_after_save
-        before_create :call_before_create
-        after_create :call_after_create
-        before_update :call_before_update
-        after_update :call_after_update
-        before_destroy :call_before_destroy
-        after_destroy :call_after_destroy
-
-        controller do
-          def call_after_build(obj); end
-          def call_before_save(obj); end
-          def call_after_save(obj); end
-          def call_before_create(obj); end
-          def call_after_create(obj); end
-          def call_before_update(obj); end
-          def call_after_update(obj); end
-          def call_before_destroy(obj); end
-          def call_after_destroy(obj); end
-        end
-      end
-    end
-
-    describe "performing create" do
-      let(:controller){ Admin::PostsController.new }
-      let(:resource){ double("Resource", save: true) }
-
-      before do
-        expect(resource).to receive(:save)
-      end
-
-      it "should call the before create callback" do
-        expect(controller).to receive(:call_before_create).with(resource)
-        controller.send :create_resource, resource
-      end
-      it "should call the before save callback" do
-        expect(controller).to receive(:call_before_save).with(resource)
-        controller.send :create_resource, resource
-      end
-      it "should call the after save callback" do
-        expect(controller).to receive(:call_after_save).with(resource)
-        controller.send :create_resource, resource
-      end
-      it "should call the after create callback" do
-        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(:attributes){ [{}] }
-
-      before do
-        expect(resource).to receive(:attributes=).with(attributes[0])
-        expect(resource).to receive(:save)
-      end
-
-      it "should call the before update callback" do
-        expect(controller).to receive(:call_before_update).with(resource)
-        controller.send :update_resource, resource, attributes
-      end
-      it "should call the before save callback" do
-        expect(controller).to receive(:call_before_save).with(resource)
-        controller.send :update_resource, resource, attributes
-      end
-      it "should call the after save callback" do
-        expect(controller).to receive(:call_after_save).with(resource)
-        controller.send :update_resource, resource, attributes
-      end
-      it "should call the after create callback" do
-        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) }
-
-      before do
-        expect(resource).to receive(:destroy)
-      end
-
-      it "should call the before destroy callback" do
-        expect(controller).to receive(:call_before_destroy).with(resource)
-        controller.send :destroy_resource, resource
-      end
-
-      it "should call the after destroy callback" do
-        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 'retrieving the resource' do
-    let(:controller){ Admin::PostsController.new }
-    let(:post) { Post.new title: "An incledibly unique Post Title" }
-
-    before do
-      allow(Post).to receive(:find).and_return(post)
-      controller.class_eval { public :resource }
-      allow(controller).to receive(:params).and_return({ id: '1' })
-    end
-
-    subject { controller.resource }
-
-    it "returns a Post" do
-      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
-        expect(subject).to be_kind_of(PostDecorator)
-      end
-
-      it 'returns a PostDecorator that wraps the post' do
-        expect(subject.title).to eq post.title
-      end
-    end
-  end
-
-  describe 'retrieving 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
-      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.send :collection }
-
-    it {
-      is_expected.to be_a ActiveRecord::Relation
-    }
-
-    it "returns a collection of posts" do
-      expect(subject.first).to be_kind_of(Post)
-    end
-
-    context 'with a decorator' do
-      before { config.decorator_class_name = 'PostDecorator' }
-
-      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 collection decorator that wraps the post' do
-        expect(subject.first.title).to eq Post.first.title
-      end
-    end
-  end
-
-
-  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
-      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
-        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
-        allow(controller).to receive(:params) { { batch_action: "derp", collection_selection: ["1"] } }
-        expect {
-          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
-        allow(controller).to receive(:params) { { collection_selection: ["1"] } }
-        expect {
-          controller.batch_action
-        }.to raise_error("Couldn't find batch action \"\"")
-      end
-    end
-
-  end
-
-end

data/spec/unit/resource_registration_spec.rb

@@ -1,56 +0,0 @@
-require 'rails_helper'
-
-describe "Registering an object to administer" do
-  application = ActiveAdmin::Application.new
-
-  context "with no configuration" do
-    namespace = ActiveAdmin::Namespace.new(application, :admin)
-    it "should call register on the namespace" do
-      application.namespaces[namespace.name] = namespace
-      expect(namespace).to receive(:register)
-
-      application.register Category
-    end
-
-    it "should dispatch a Resource::RegisterEvent" do
-      expect(ActiveSupport::Notifications).to receive(:publish).with(ActiveAdmin::Resource::RegisterEvent, an_instance_of(ActiveAdmin::Resource))
-      application.register Category
-    end
-  end
-
-  context "with a different namespace" do
-    it "should call register on the namespace" do
-      namespace = ActiveAdmin::Namespace.new(application, :hello_world)
-      application.namespaces[namespace.name] = namespace
-      expect(namespace).to receive(:register)
-
-      application.register Category, namespace: :hello_world
-    end
-
-    it "should generate a Namespace::RegisterEvent and a Resource::RegisterEvent" do
-      expect(ActiveSupport::Notifications).to receive(:publish).with(ActiveAdmin::Namespace::RegisterEvent, an_instance_of(ActiveAdmin::Namespace))
-      expect(ActiveSupport::Notifications).to receive(:publish).with(ActiveAdmin::Resource::RegisterEvent, an_instance_of(ActiveAdmin::Resource))
-      application.register Category, namespace: :not_yet_created
-    end
-  end
-
-  context "with no namespace" do
-    it "should call register on the root namespace" do
-      namespace = ActiveAdmin::Namespace.new(application, :root)
-      application.namespaces[namespace.name] = namespace
-      expect(namespace).to receive(:register)
-
-      application.register Category, namespace: false
-    end
-  end
-
-  context "when being registered multiple times" 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 }
-      expect(config_1).to eq config_2
-      expect(config_1.filters.size).to eq 2
-    end
-  end
-
-end