activeadmin 1.3.0 → 2.13.1

data/spec/unit/resource/sidebars_spec.rb

@@ -1,43 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::Resource::Sidebars do
-
-  let(:resource) do
-    namespace = ActiveAdmin::Namespace.new(ActiveAdmin::Application.new, :admin)
-    namespace.register(Post)
-  end
-
-  let(:sidebar) { ActiveAdmin::SidebarSection.new(:help) }
-
-  describe "adding a new sidebar section" do
-
-    before do
-      resource.clear_sidebar_sections!
-      resource.sidebar_sections << sidebar
-    end
-
-    it "should add a sidebar section" do
-      expect(resource.sidebar_sections.size).to eq(1)
-    end
-
-  end
-
-  describe "retrieving sections for a controller action" do
-
-    let(:only_index){ ActiveAdmin::SidebarSection.new(:help, only: :index) }
-    let(:only_show){ ActiveAdmin::SidebarSection.new(:help, only: :show) }
-
-    before do
-      resource.clear_sidebar_sections!
-      resource.sidebar_sections << only_index
-      resource.sidebar_sections << only_show
-    end
-
-    it "should only return the relevant action items" do
-      expect(resource.sidebar_sections.size).to eq(2)
-      expect(resource.sidebar_sections_for("index")).to eq [only_index]
-    end
-
-  end
-
-end

data/spec/unit/resource_collection_spec.rb

@@ -1,175 +0,0 @@
-require 'rails_helper'
-require 'active_admin/resource_collection'
-
-RSpec.describe ActiveAdmin::ResourceCollection do
-  let(:application) { ActiveAdmin::Application.new }
-  let(:namespace)   { ActiveAdmin::Namespace.new application, :admin }
-  let(:collection)  { ActiveAdmin::ResourceCollection.new }
-  let(:resource)    { double resource_name: "MyResource" }
-
-  it { is_expected.to respond_to :[]       }
-  it { is_expected.to respond_to :add      }
-  it { is_expected.to respond_to :each     }
-  it { is_expected.to respond_to :has_key? }
-  it { is_expected.to respond_to :keys     }
-  it { is_expected.to respond_to :values   }
-  it { is_expected.to respond_to :size     }
-  it { is_expected.to respond_to :to_a     }
-
-  it "should have no resources when new" do
-    expect(collection).to be_empty
-  end
-
-  it "should be enumerable" do
-    collection.add(resource)
-    collection.each{ |r| expect(r).to eq resource }
-  end
-
-  it "should return the available keys" do
-    collection.add resource
-    expect(collection.keys).to eq [resource.resource_name]
-  end
-
-  describe "#add" do
-    it "should return the resource" do
-      expect(collection.add(resource)).to eq resource
-    end
-
-    it "should add a new resource" do
-      collection.add(resource)
-      expect(collection.values).to eq [resource]
-    end
-
-    it "should be available by name" do
-      collection.add(resource)
-      expect(collection[resource.resource_name]).to eq resource
-    end
-
-    it "shouldn't happen twice" do
-      collection.add(resource); collection.add(resource)
-      expect(collection.values).to eq [resource]
-    end
-
-    it "shouldn't allow a resource name mismatch to occur" do
-      expect {
-        ActiveAdmin.register Category
-        ActiveAdmin.register Post, as: "Category"
-      }.to raise_error ActiveAdmin::ResourceCollection::ConfigMismatch
-    end
-
-    it "shouldn't allow a Page/Resource mismatch to occur" do
-      expect {
-        ActiveAdmin.register User
-        ActiveAdmin.register_page 'User'
-      }.to raise_error ActiveAdmin::ResourceCollection::IncorrectClass
-    end
-
-    describe "should store both renamed and non-renamed resources" do
-      let(:resource) { ActiveAdmin::Resource.new namespace, Category }
-      let(:renamed)  { ActiveAdmin::Resource.new namespace, Category, as: "Subcategory" }
-
-      it "when the renamed version is added first" do
-        collection.add renamed
-        collection.add resource
-        expect(collection.values).to include(resource, renamed)
-      end
-
-      it "when the renamed version is added last" do
-        collection.add resource
-        collection.add renamed
-        expect(collection.values).to include(resource, renamed)
-      end
-    end
-  end
-
-  describe "#[]" do
-    let(:resource)              { ActiveAdmin::Resource.new namespace, resource_class }
-    let(:inherited_resource)    { ActiveAdmin::Resource.new namespace, inherited_resource_class }
-
-    let(:resource_class)           { User }
-    let(:inherited_resource_class) { Publisher }
-    let(:unregistered_class)       { Category }
-
-    context "with resources" do
-      before do
-        collection.add resource
-        collection.add inherited_resource
-      end
-
-      it "should find resource by class" do
-        expect(collection[resource_class]).to eq resource
-      end
-
-      it "should find resource by class string" do
-        expect(collection[resource_class.to_s]).to eq resource
-      end
-
-      it "should find inherited resource by class" do
-        expect(collection[inherited_resource_class]).to eq inherited_resource
-      end
-
-      it "should find inherited resource by class string" do
-        expect(collection[inherited_resource_class.to_s]).to eq inherited_resource
-      end
-
-      it "should return nil when the resource_class does not respond to base_class and it is not in the collection" do
-        expect(collection[double]).to eq nil
-      end
-
-      it "should return nil when a resource class is NOT in the collection" do
-        expect(collection[unregistered_class]).to eq nil
-      end
-    end
-
-    context "without inherited resources" do
-      before do
-        collection.add resource
-      end
-
-      it "should find resource by inherited class" do
-        expect(collection[inherited_resource_class]).to eq resource
-      end
-    end
-
-    context "with a renamed resource" do
-      let(:renamed_resource) { ActiveAdmin::Resource.new namespace, resource_class, as: name }
-      let(:name)             { "Administrators" }
-
-      before do
-        collection.add renamed_resource
-      end
-
-      it "should find resource by class" do
-        expect(collection[resource_class]).to eq renamed_resource
-      end
-
-      it "should find resource by class string" do
-        expect(collection[resource_class.to_s]).to eq renamed_resource
-      end
-
-      it "should find resource by name" do
-        expect(collection[name]).to eq renamed_resource
-      end
-    end
-
-    context "with a resource and a renamed resource added in disorder" do
-      let(:resource) { ActiveAdmin::Resource.new namespace, resource_class }
-      let(:renamed_resource) do
-        ActiveAdmin::Resource.new namespace, resource_class, as: name
-      end
-      let(:name) { "Administrators" }
-
-      before do
-        collection.add renamed_resource
-        collection.add resource
-      end
-
-      it "should find a resource by class when there are two resources with that class" do
-        expect(collection[resource_class]).to eq resource
-      end
-    end
-  end
-
-  skip "specs for subclasses of Page and Resource"
-
-end

data/spec/unit/resource_controller/data_access_spec.rb

@@ -1,234 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::ResourceController::DataAccess do
-  before do
-    load_resources { config }
-  end
-
-  let(:config) do
-    ActiveAdmin.register Post do
-    end
-  end
-
-  let(:http_params) do
-    {}
-  end
-
-  let(:params) do
-    ActionController::Parameters.new(http_params)
-  end
-
-  let(:controller) do
-    rc = Admin::PostsController.new
-    allow(rc).to receive(:params) do
-      params
-    end
-    rc
-  end
-
-  describe "searching" do
-    let(:http_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
-
-    context "params includes empty values" do
-      let(:http_params) do
-        { q: {id_eq: 1, position_eq: ""} }
-      end
-      it "should return relation without empty filters" do
-        expect(Post).to receive(:ransack).with(params[:q]).once.and_wrap_original do |original, *args|
-          chain = original.call(*args)
-          expect(chain.conditions.size).to eq(1)
-          chain
-        end
-        controller.send :apply_filtering, Post
-      end
-    end
-  end
-
-  describe "sorting" do
-
-    context "valid clause" do
-      let(:http_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(:http_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
-
-    context "custom strategy" do
-      before do
-        expect(controller.send(:active_admin_config)).to receive(:ordering).twice.and_return(
-          {
-            published_date: proc do |order_clause|
-              [order_clause.to_sql, 'NULLS LAST'].join(' ') if order_clause.order == 'desc'
-            end
-          }.with_indifferent_access
-        )
-      end
-
-      context "when params applicable" do
-        let(:http_params) {{ order: "published_date_desc" }}
-        it "reorders chain" do
-          chain = double "ChainObj"
-          expect(chain).to receive(:reorder).with('"posts"."published_date" desc NULLS LAST').once.and_return(Post.search)
-          controller.send :apply_sorting, chain
-        end
-      end
-      context "when params not applicable" do
-        let(:http_params) {{ order: "published_date_asc" }}
-        it "reorders chain" do
-          chain = double "ChainObj"
-          expect(chain).to receive(:reorder).with('"posts"."published_date" asc').once.and_return(Post.search)
-          controller.send :apply_sorting, chain
-        end
-      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
-
-  describe "build_resource" do
-
-    let(:config) do
-      ActiveAdmin.register User do
-        permit_params :type, posts_attributes: :custom_category_id
-      end
-    end
-
-    let!(:category) { Category.create! }
-
-    let(:params) do
-      ActionController::Parameters.new(user: { type: 'User::VIP', posts_attributes: [custom_category_id: category.id] })
-    end
-
-    subject do
-      controller.send :build_resource
-    end
-
-    let(:controller) do
-      rc = Admin::UsersController.new
-      allow(rc).to receive(:params) do
-        params
-      end
-      rc
-    end
-
-    it "should return post with assigned attributes" do
-      expect(subject).to be_a(User::VIP)
-    end
-
-    # see issue 4548
-    it "should assign nested attributes once" do
-      expect(subject.posts.size).to eq(1)
-    end
-
-  end
-
-end

data/spec/unit/resource_controller/decorators_spec.rb

@@ -1,94 +0,0 @@
-require 'rails_helper'
-
-RSpec.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,37 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::ResourceController::Sidebars, type: :controller do
-  let(:klass){ Admin::PostsController }
-
-  shared_context 'with post config' do
-    before do
-      load_resources { post_config }
-
-      @controller = klass.new
-
-      get :index
-    end
-  end
-
-  context 'without skip_sidebar! before filter' do
-    include_context 'with post config' do
-      let(:post_config) { ActiveAdmin.register Post }
-    end
-
-    it 'does not set @skip_sidebar' do
-      expect(controller.instance_variable_get(:@skip_sidebar)).to eq nil
-    end
-  end
-
-  context 'with skip_sidebar! before_action' do
-    include_context 'with post config' do
-      let(:post_config) do
-        ActiveAdmin.register(Post) { before_action :skip_sidebar! }
-      end
-    end
-
-    it 'works' do
-      expect(controller.instance_variable_get(:@skip_sidebar)).to eq true
-    end
-  end
-end