activeadmin-rb 1.4.0

data/spec/unit/resource/sidebars_spec.rb

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,175 @@
+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

@@ -0,0 +1,234 @@
+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