activeadmin 1.3.1 → 1.4.0

data/spec/unit/resource/scopes_spec.rb

@@ -1,50 +0,0 @@
-require 'rails_helper'
-
-module ActiveAdmin
-  RSpec.describe Resource, "Scopes" do
-
-    before { load_defaults! }
-
-    let(:application){ ActiveAdmin::Application.new }
-    let(:namespace){ Namespace.new(application, :admin) }
-
-    def config(options = {})
-      @config ||= Resource.new(namespace, Category, options)
-    end
-
-    describe "adding a scope" do
-
-      it "should add a scope" do
-        config.scope :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
-        expect(config.get_scope_by_id(:published).name).to eq "Published"
-      end
-
-      it "should retrieve a string scope with spaces by its id without conflicts" do
-        aspace_1 = config.scope "a space"
-        aspace_2 = config.scope "as pace"
-        expect(config.get_scope_by_id(aspace_1.id).name).to eq "a space"
-        expect(config.get_scope_by_id(aspace_2.id).name).to eq "as pace"
-      end
-
-      it "should not add a scope with the same name twice" do
-        config.scope :published
-        config.scope :published
-        expect(config.scopes.size).to eq 1
-      end
-
-      it "should update a scope with the same id" do
-        config.scope :published
-        expect(config.scopes.first.scope_block).to eq nil
-        config.scope(:published){ }
-        expect(config.scopes.first.scope_block).to_not eq nil
-      end
-
-    end
-  end
-end

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