activeadmin 1.3.0 → 2.13.1

data/spec/unit/pundit_adapter_spec.rb

@@ -1,98 +0,0 @@
-require 'rails_helper'
-
-class DefaultPolicy < ApplicationPolicy
-  def respond_to_missing?(method, include_private = false)
-    method.to_s[0...3] == "foo" || super
-  end
-
-  def method_missing(method, *args, &block)
-    if method.to_s[0...3] == "foo"
-      method.to_s[4...7] == "yes"
-    else
-      super
-    end
-  end
-
-  class Scope
-
-    attr_reader :user, :scope
-
-    def initialize(user, scope)
-      @user = user
-      @scope = scope
-    end
-
-    def resolve
-      scope
-    end
-  end
-end
-
-RSpec.describe ActiveAdmin::PunditAdapter do
-
-  describe "full integration" do
-
-    let(:application) { ActiveAdmin::Application.new }
-    let(:namespace) { ActiveAdmin::Namespace.new(application, "Admin") }
-    let(:resource) { namespace.register(Post) }
-    let(:auth) { namespace.authorization_adapter.new(resource, double) }
-    let(:default_policy_klass) { DefaultPolicy }
-    let(:default_policy_klass_name) { "DefaultPolicy" }
-
-    before do
-      namespace.authorization_adapter = ActiveAdmin::PunditAdapter
-    end
-
-    it "should initialize the ability stored in the namespace configuration" do
-      expect(auth.authorized?(:read, Post)).to eq true
-      expect(auth.authorized?(:update, Post)).to eq false
-    end
-
-    it "should scope the collection" do
-      class RSpec::Mocks::DoublePolicy < ApplicationPolicy
-        class Scope < Struct.new(:user, :scope)
-          def resolve
-            scope
-          end
-        end
-      end
-
-      collection = double
-      auth.scope_collection(collection, :read)
-      expect(collection).to eq collection
-    end
-
-    it "works well with method_missing" do
-      allow(auth).to receive(:retrieve_policy).and_return(DefaultPolicy.new(double, double))
-      expect(auth.authorized?(:foo_no)).to eq false
-      expect(auth.authorized?(:foo_yes)).to eq true
-      expect(auth.authorized?(:bar_yes)).to eq false
-    end
-
-    context 'when Pundit is unable to find policy scope' do
-      let(:collection) { double("collection", to_sym: :collection) }
-      subject(:scope) { auth.scope_collection(collection, :read) }
-
-      before do
-        allow(ActiveAdmin.application).to receive(:pundit_default_policy).and_return default_policy_klass_name
-        allow(Pundit).to receive(:policy_scope!) { raise Pundit::NotDefinedError.new }
-      end
-
-      it("should return default policy's scope if defined") { is_expected.to eq(collection) }
-    end
-
-    context "when Pundit is unable to find policy" do
-      let(:record) { double }
-
-      subject(:policy) { auth.retrieve_policy(record) }
-
-      before do
-        allow(ActiveAdmin.application).to receive(:pundit_default_policy).and_return default_policy_klass_name
-        allow(Pundit).to receive(:policy!) { raise Pundit::NotDefinedError.new }
-      end
-
-      it("should return default policy instance") { is_expected.to be_instance_of(default_policy_klass) }
-    end
-  end
-
-end

data/spec/unit/resource/action_items_spec.rb

@@ -1,69 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::Resource::ActionItems do
-
-  let(:resource) do
-    namespace = ActiveAdmin::Namespace.new(ActiveAdmin::Application.new, :admin)
-    namespace.register(Post)
-  end
-
-  describe "adding a new action item" do
-
-    before do
-      resource.clear_action_items!
-      resource.add_action_item :empty, class: :test do
-        # Empty ...
-      end
-    end
-
-    it "should add an action item" do
-      expect(resource.action_items.size).to eq 1
-    end
-
-    it "should store an instance of ActionItem" do
-      expect(resource.action_items.first).to be_an_instance_of(ActiveAdmin::ActionItem)
-    end
-
-    it "should store the block in the action item" do
-      expect(resource.action_items.first.block).to_not eq nil
-    end
-
-    it "should include class from options" do
-      expect(resource.action_items.first.html_class).to eq("action_item test")
-    end
-
-  end
-
-  describe "setting an action item to only display on specific controller actions" do
-
-    before do
-      resource.clear_action_items!
-      resource.add_action_item :new, only: :index do
-        raise StandardError
-      end
-      resource.add_action_item :edit, only: :show do
-        # Empty ...
-      end
-    end
-
-    it "should return only relevant action items" do
-      expect(resource.action_items_for(:index).size).to eq 1
-      expect {
-        resource.action_items_for(:index).first.call
-      }.to raise_exception(StandardError)
-    end
-
-  end
-
-  describe "default action items" do
-    it "should have 3 action items" do
-      expect(resource.action_items.size).to eq 3
-    end
-
-    it 'can be removed by name' do
-      resource.remove_action_item :new
-      expect(resource.action_items.size).to eq 2
-    end
-  end
-
-end

data/spec/unit/resource/attributes_spec.rb

@@ -1,49 +0,0 @@
-require 'rails_helper'
-
-module ActiveAdmin
-  RSpec.describe Resource, "Attributes" do
-    let(:application) { ActiveAdmin::Application.new }
-    let(:namespace) { ActiveAdmin::Namespace.new application, :admin }
-    let(:resource_config) { ActiveAdmin::Resource.new namespace, Post }
-
-    describe "#resource_attributes" do
-      subject do
-        resource_config.resource_attributes
-      end
-
-      it 'should return attributes hash' do
-        expect(subject).to eq(author_id: :author,
-                               body: :body,
-                               created_at: :created_at,
-                               custom_category_id: :category,
-                               foo_id: :foo_id,
-                               position: :position,
-                               published_date: :published_date,
-                               starred: :starred,
-                               title: :title,
-                               updated_at: :updated_at)
-      end
-    end
-
-    describe "#association_columns" do
-      subject do
-        resource_config.association_columns
-      end
-
-      it 'should return associations' do
-        expect(subject).to eq([:author, :category])
-      end
-    end
-
-    describe "#content_columns" do
-      subject do
-        resource_config.content_columns
-      end
-
-      it 'should return columns without associations' do
-        expect(subject).to eq([:title, :body, :published_date, :position, :starred, :foo_id, :created_at, :updated_at])
-      end
-    end
-
-  end
-end

data/spec/unit/resource/includes_spec.rb

@@ -1,21 +0,0 @@
-require 'rails_helper'
-
-module ActiveAdmin
-  RSpec.describe Resource, "Includes" do
-    describe "#includes" do
-
-      let(:application) { ActiveAdmin::Application.new }
-      let(:namespace) { ActiveAdmin::Namespace.new application, :admin }
-      let(:resource_config) { ActiveAdmin::Resource.new namespace, Post }
-      let(:dsl){ ActiveAdmin::ResourceDSL.new(resource_config) }
-
-      it "should register the includes in the config" do
-        dsl.run_registration_block do
-          includes :taggings, :author
-        end
-        expect(resource_config.includes.size).to eq(2)
-      end
-
-    end
-  end
-end

data/spec/unit/resource/menu_spec.rb

@@ -1,18 +0,0 @@
-require 'rails_helper'
-
-module ActiveAdmin
-  RSpec.describe Resource, "Menu" 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
-
-    # TODO...
-
-  end
-end

data/spec/unit/resource/naming_spec.rb

@@ -1,122 +0,0 @@
-# -*- coding: UTF-8 -*-
-
-require 'rails_helper'
-
-module ActiveAdmin
-  RSpec.describe Resource, "Naming" 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
-
-    module ::Mock class Resource < ActiveRecord::Base; end; end
-    module NoActiveModel class Resource; end; end
-
-    describe "singular resource name" do
-      context "when class" do
-        it "should be the underscored singular resource name" do
-          expect(config.resource_name.singular).to eq "category"
-        end
-      end
-      context "when a class in a module" do
-        it "should underscore the module and the class" do
-          expect(Resource.new(namespace, Mock::Resource).resource_name.singular).to eq "mock_resource"
-        end
-      end
-      context "when you pass the 'as' option" do
-        it "should underscore the passed through string" do
-          expect(config(as: "Blog Category").resource_name.singular).to eq "blog_category"
-        end
-      end
-    end
-
-    describe "resource label" do
-      it "should return a pretty name" do
-        expect(config.resource_label).to eq "Category"
-      end
-
-      it "should return the plural version" do
-        expect(config.plural_resource_label).to eq "Categories"
-      end
-
-      context "when the :as option is given" do
-        it "should return the custom name" do
-          expect(config(as: "My Category").resource_label).to eq "My Category"
-        end
-      end
-
-      context "when a class in a module" do
-        it "should include the module and the class" do
-          expect(Resource.new(namespace, Mock::Resource).resource_label).to eq "Mock Resource"
-        end
-
-        it "should include the module and the pluralized class" do
-          expect(Resource.new(namespace, Mock::Resource).plural_resource_label).to eq "Mock Resources"
-        end
-      end
-
-      describe "I18n integration" do
-        describe "singular label" do
-          it "should return the titleized model_name.human" do
-            expect(config.resource_name).to receive(:translate).and_return "Da category"
-
-            expect(config.resource_label).to eq "Da category"
-          end
-        end
-
-        describe "plural label" do
-          it "should return the titleized plural version defined by i18n if available" do
-            expect(config.resource_name).to receive(:translate).at_least(:once).and_return "Da categories"
-            expect(config.plural_resource_label).to eq "Da categories"
-          end
-        end
-
-        describe "plural label with not default locale" do
-          it "should return the titleized plural version defined by i18n with custom :count if available" do
-            expect(config.resource_name).to receive(:translate).at_least(:once).and_return "Категории"
-            expect(config.plural_resource_label(count: 3)).to eq "Категории"
-          end
-        end
-
-        context "when the :as option is given" do
-          describe "singular label" do
-            it "should translate the custom name" do
-              config = config(as: 'My Category')
-              expect(config.resource_name).to receive(:translate).and_return "Translated category"
-              expect(config.resource_label).to eq "Translated category"
-            end
-          end
-
-          describe "plural label" do
-            it "should translate the custom name" do
-              config = config(as: 'My Category')
-              expect(config.resource_name).to receive(:translate).at_least(:once).and_return "Translated categories"
-              expect(config.plural_resource_label).to eq "Translated categories"
-            end
-          end
-        end
-
-      end
-    end
-
-    describe "duplicate resource names" do
-      let(:resource_name) { config.resource_name }
-      let(:duplicate_resource_name) { Resource.new(namespace, Category).resource_name }
-
-      [:==, :===, :eql?].each do |method|
-        it "are equivalent when compared with #{method}" do
-          expect(resource_name.public_send(method, duplicate_resource_name)).to eq true
-        end
-      end
-
-      it "have identical hash values" do
-        expect(resource_name.hash).to eq duplicate_resource_name.hash
-      end
-    end
-  end
-end

data/spec/unit/resource/ordering_spec.rb

@@ -1,35 +0,0 @@
-require 'rails_helper'
-
-module ActiveAdmin
-  RSpec.describe Resource, "Ordering" do
-    describe "#order_by" do
-
-      let(:application) { ActiveAdmin::Application.new }
-      let(:namespace) { ActiveAdmin::Namespace.new application, :admin }
-      let(:resource_config) { ActiveAdmin::Resource.new namespace, Post }
-      let(:dsl){ ActiveAdmin::ResourceDSL.new(resource_config) }
-
-      it "should register the ordering in the config" do
-        dsl.run_registration_block do
-          order_by(:age) do |order_clause|
-            if order_clause.order == 'desc'
-              [order_clause.to_sql, 'NULLS LAST'].join(' ')
-            end
-          end
-        end
-        expect(resource_config.ordering.size).to eq(1)
-      end
-
-      it "should allow to setup custom ordering class" do
-        MyOrderClause = Class.new(ActiveAdmin::OrderClause)
-        dsl.run_registration_block do
-          config.order_clause = MyOrderClause
-        end
-        expect(resource_config.order_clause).to eq(MyOrderClause)
-        expect(application.order_clause).to eq(ActiveAdmin::OrderClause)
-
-      end
-
-    end
-  end
-end

data/spec/unit/resource/page_presenters_spec.rb

@@ -1,44 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::Resource::PagePresenters do
-
-  let(:namespace){ ActiveAdmin::Namespace.new(ActiveAdmin::Application.new, :admin) }
-  let(:resource){ namespace.register(Post) }
-
-  it "should have an empty set of configs on initialize" do
-    expect(resource.page_presenters).to eq ({})
-  end
-
-  it "should add a show page presenter" do
-    page_presenter = ActiveAdmin::PagePresenter.new
-    resource.set_page_presenter(:show, page_presenter)
-    expect(resource.page_presenters[:show]).to eq page_presenter
-  end
-
-  it "should add an index page presenter" do
-    page_presenter = ActiveAdmin::PagePresenter.new({as: :table})
-    resource.set_page_presenter(:index, page_presenter)
-    expect(resource.page_presenters[:index].default).to eq page_presenter
-  end
-
-  describe "#get_page_presenter" do
-
-    it "should return a page config when set" do
-      page_presenter = ActiveAdmin::PagePresenter.new
-      resource.set_page_presenter(:index, page_presenter)
-      expect(resource.get_page_presenter(:index)).to eq page_presenter
-    end
-
-    it "should return a specific index page config when set" do
-      page_presenter = ActiveAdmin::PagePresenter.new
-      resource.set_page_presenter(:index, page_presenter)
-      expect(resource.get_page_presenter(:index, "table")).to eq page_presenter
-    end
-
-    it "should return nil when no page config set" do
-      expect(resource.get_page_presenter(:index)).to eq nil
-    end
-
-  end
-
-end

data/spec/unit/resource/pagination_spec.rb

@@ -1,38 +0,0 @@
-require 'rails_helper'
-
-module ActiveAdmin
-  RSpec.describe Resource, "Pagination" 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 "#paginate" do
-      it "should default to true" do
-        expect(config.paginate).to eq true
-      end
-
-      it "should be settable to false" do
-        config.paginate = false
-        expect(config.paginate).to eq false
-      end
-    end
-
-    describe "#per_page" do
-      it "should default to namespace.default_per_page" do
-        expect(namespace).to receive(:default_per_page).and_return(5)
-        expect(config.per_page).to eq 5
-      end
-
-      it "should be settable" do
-        config.per_page = 5
-        expect(config.per_page).to eq 5
-      end
-    end
-  end
-end

data/spec/unit/resource/routes_spec.rb

@@ -1,125 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::Resource::Routes do
-
-  after do
-    load_defaults!
-    reload_routes!
-  end
-
-  let(:application) { ActiveAdmin.application }
-  let(:namespace) { application.namespace(:admin) }
-
-  context "when in the admin namespace" do
-    let(:config) { namespace.resource_for('Category') }
-
-    before do
-      load_resources { ActiveAdmin.register Category }
-    end
-
-    let(:category) { Category.new { |c| c.id = 123 } }
-
-    it "should return the route prefix" do
-      expect(config.route_prefix).to eq 'admin'
-    end
-
-    it "should return the route collection path" do
-      expect(config.route_collection_path).to eq '/admin/categories'
-    end
-
-    it "should return the route instance path" do
-      expect(config.route_instance_path(category)).to eq '/admin/categories/123'
-    end
-  end
-
-  context "when in the root namespace" do
-    let!(:config) { ActiveAdmin.register Category, namespace: false }
-
-    after(:each) do
-      application.namespace(:root).unload!
-      application.namespaces.instance_variable_get(:@namespaces).delete(:root)
-    end
-
-    it "should have a nil route_prefix" do
-      expect(config.route_prefix).to eq nil
-    end
-
-    it "should generate a correct route" do
-      reload_routes!
-      expect(config.route_collection_path).to eq "/categories"
-    end
-  end
-
-  context "when registering a plural resource" do
-    class ::News; def self.has_many(*); end end
-    let!(:config) { ActiveAdmin.register News }
-    before{ reload_routes! }
-
-    it "should return the plural route with _index" do
-      expect(config.route_collection_path).to eq "/admin/news"
-    end
-  end
-
-  context "when the resource belongs to another resource" do
-    let(:config) { namespace.resource_for('Post') }
-
-    let :post do
-      Post.new do |p|
-        p.id = 3
-        p.category = Category.new{ |c| c.id = 1 }
-      end
-    end
-
-    before do
-      load_resources do
-        ActiveAdmin.register Category
-        ActiveAdmin.register(Post) { belongs_to :category }
-      end
-    end
-
-    it "should nest the collection path" do
-      expect(config.route_collection_path(category_id: 1)).to eq "/admin/categories/1/posts"
-    end
-
-    it "should nest the instance path" do
-      expect(config.route_instance_path(post)).to eq "/admin/categories/1/posts/3"
-    end
-  end
-
-  context "for batch_action handler" do
-    before do
-      load_resources { config.batch_actions = true }
-    end
-
-    context "when register a singular resource" do
-
-      let :config do
-        ActiveAdmin.register Category
-        ActiveAdmin.register Post do
-          belongs_to :category
-        end
-      end
-
-      it "should include :scope and :q params" do
-        params = ActionController::Parameters.new(category_id: 1, q: { name_equals: "Any" }, scope: :all)
-        additional_params = { locale: 'en' }
-        batch_action_path = "/admin/categories/1/posts/batch_action?locale=en&q%5Bname_equals%5D=Any&scope=all"
-
-        expect(config.route_batch_action_path(params, additional_params)).to eq batch_action_path
-      end
-    end
-
-    context "when registering a plural resource" do
-
-      class ::News; def self.has_many(*); end end
-      let(:config) { ActiveAdmin.register News }
-
-      it "should return the plural batch action route with _index and given params" do
-        params = ActionController::Parameters.new(q: { name_equals: "Any" }, scope: :all)
-        additional_params = { locale: 'en' }
-        batch_action_path = "/admin/news/batch_action?locale=en&q%5Bname_equals%5D=Any&scope=all"
-        expect(config.route_batch_action_path(params, additional_params)).to eq batch_action_path
-      end
-    end
-  end
-end

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