activeadmin 1.0.0 → 2.13.1

data/spec/unit/batch_actions/resource_spec.rb

@@ -1,84 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::BatchActions::ResourceExtension do
-
-  let(:resource) do
-    namespace = ActiveAdmin::Namespace.new(ActiveAdmin::Application.new, :admin)
-    namespace.batch_actions = true
-    namespace.register(Post)
-  end
-
-  describe "default action" do
-
-    it "should have the default action by default" do
-      expect(resource.batch_actions.size).to eq 1
-      expect(resource.batch_actions.first.sym == :destroy).to eq true
-    end
-
-  end
-
-  describe "adding a new batch action" do
-
-    before do
-      resource.clear_batch_actions!
-      resource.add_batch_action :flag, "Flag" do
-        # Empty
-      end
-    end
-
-    it "should add an batch action" do
-      expect(resource.batch_actions.size).to eq 1
-    end
-
-    it "should store an instance of BatchAction" do
-      expect(resource.batch_actions.first).to be_an_instance_of(ActiveAdmin::BatchAction)
-    end
-
-    it "should store the block in the batch action" do
-      expect(resource.batch_actions.first.block).to_not eq nil
-    end
-
-  end
-
-  describe "removing batch action" do
-
-    before do
-      resource.remove_batch_action :destroy
-    end
-
-    it "should allow for batch action removal" do
-      expect(resource.batch_actions.size).to eq 0
-    end
-
-  end
-
-  describe "#display_if_block" do
-
-    it "should return true by default" do
-      action = ActiveAdmin::BatchAction.new :default, "Default"
-      expect(action.display_if_block.call).to eq true
-    end
-
-    it "should return the :if block if set" do
-      action = ActiveAdmin::BatchAction.new :with_block, "With Block", if: proc { false }
-      expect(action.display_if_block.call).to eq false
-    end
-
-  end
-
-  describe "batch action priority" do
-
-    it "should have a default priority" do
-      action = ActiveAdmin::BatchAction.new :default, "Default"
-      expect(action.priority).to eq 10
-    end
-
-    it "should correctly order two actions" do
-      priority_one = ActiveAdmin::BatchAction.new :one, "One", priority: 1
-      priority_ten = ActiveAdmin::BatchAction.new :ten, "Ten", priority: 10
-      expect(priority_one).to be < priority_ten
-    end
-
-  end
-
-end

data/spec/unit/batch_actions/settings_spec.rb

@@ -1,61 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe "Batch Actions Settings" do
-  let(:app) { ActiveAdmin::Application.new }
-  let(:ns) { ActiveAdmin::Namespace.new(app, "Admin") }
-  let(:post_resource) { ns.register Post }
-
-  it "should be disabled globally by default" do
-    # Note: the default initializer would set it to true
-
-    expect(app.batch_actions).to eq false
-    expect(ns.batch_actions).to eq false
-    expect(post_resource.batch_actions_enabled?).to eq false
-  end
-
-  it "should be settable to true" do
-    app.batch_actions = true
-    expect(app.batch_actions).to eq true
-  end
-
-  it "should be an inheritable_setting" do
-    app.batch_actions = true
-    expect(ns.batch_actions).to eq true
-  end
-
-  it "should be settable at the namespace level" do
-    app.batch_actions = true
-    ns.batch_actions = false
-
-    expect(app.batch_actions).to eq true
-    expect(ns.batch_actions).to eq false
-  end
-
-  it "should be settable at the resource level" do
-    expect(post_resource.batch_actions_enabled?).to eq false
-    post_resource.batch_actions = true
-    expect(post_resource.batch_actions_enabled?).to eq true
-  end
-
-  it "should inherit the setting on the resource from the namespace" do
-    ns.batch_actions = false
-    expect(post_resource.batch_actions_enabled?).to eq false
-    expect(post_resource.batch_actions).to be_empty
-
-    post_resource.batch_actions = true
-    expect(post_resource.batch_actions_enabled?).to eq true
-    expect(post_resource.batch_actions).to_not be_empty
-  end
-
-  it "should inherit the setting from the namespace when set to nil" do
-    ns.batch_actions = true
-
-    post_resource.batch_actions = true
-    expect(post_resource.batch_actions_enabled?).to eq true
-    expect(post_resource.batch_actions).to_not be_empty
-
-    post_resource.batch_actions = nil
-    expect(post_resource.batch_actions_enabled?).to eq true # inherited from namespace
-    expect(post_resource.batch_actions).to_not be_empty
-  end
-end

data/spec/unit/belongs_to_spec.rb

@@ -1,77 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::Resource::BelongsTo do
-  before do
-    load_resources do
-      ActiveAdmin.register User
-      ActiveAdmin.register Post do belongs_to :user end
-    end
-  end
-
-  let(:namespace) { ActiveAdmin.application.namespace(:admin) }
-  let(:user_config){ ActiveAdmin.register User }
-  let(:post_config){ ActiveAdmin.register Post do belongs_to :user end }
-  let(:belongs_to){ post_config.belongs_to_config }
-
-
-  it "should have an owner" do
-    expect(belongs_to.owner).to eq post_config
-  end
-
-  describe "finding the target" do
-    context "when the resource has been registered" do
-      it "should return the target resource" do
-        expect(belongs_to.target).to eq user_config
-      end
-    end
-
-    context "when the resource has not been registered" do
-      let(:belongs_to){ ActiveAdmin::Resource::BelongsTo.new post_config, :missing }
-
-      it "should raise a ActiveAdmin::BelongsTo::TargetNotFound" do
-        expect {
-          belongs_to.target
-        }.to raise_error(ActiveAdmin::Resource::BelongsTo::TargetNotFound)
-      end
-    end
-
-    context "when the resource is on a namespace" do
-      let(:blog_post_config){ ActiveAdmin.register Blog::Post do; end }
-      let(:belongs_to) { ActiveAdmin::Resource::BelongsTo.new blog_post_config, :blog_author, class_name: "Blog::Author" }
-      before do
-        class Blog::Author
-          include ActiveModel::Naming
-        end
-        @blog_author_config = ActiveAdmin.register Blog::Author do; end
-      end
-      it "should return the target resource" do
-        expect(belongs_to.target).to eq @blog_author_config
-      end
-    end
-  end
-
-  it "should be optional" do
-    belongs_to = ActiveAdmin::Resource::BelongsTo.new post_config, :user, optional: true
-    expect(belongs_to).to be_optional
-  end
-
-  describe "controller" do
-    let(:controller) { post_config.controller.new }
-    let(:http_params) { {user_id: user.id}  }
-    let(:user) { User.create! }
-
-    before do
-      request = double 'Request', format: 'application/json'
-      allow(controller).to receive(:params) { ActionController::Parameters.new(http_params) }
-      allow(controller).to receive(:request){ request }
-    end
-
-    it 'should be able to access the collection' do
-      expect(controller.send :collection).to be_a ActiveRecord::Relation
-
-    end
-    it 'should be able to build a new resource' do
-      expect(controller.send :build_resource).to be_a Post
-    end
-  end
-end

data/spec/unit/cancan_adapter_spec.rb

@@ -1,43 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::CanCanAdapter do
-
-  describe "full integration" do
-
-    let(:application){ ActiveAdmin::Application.new }
-    let(:namespace){ ActiveAdmin::Namespace.new(application, "Admin") }
-    let(:resource){ namespace.register(Post) }
-
-    let :ability_class do
-      Class.new do
-        include CanCan::Ability
-
-        def initialize(user)
-          can :read, Post
-          cannot :update, Post
-        end
-
-      end
-    end
-
-    let(:auth) { namespace.authorization_adapter.new(resource, double) }
-
-    before do
-      namespace.authorization_adapter = ActiveAdmin::CanCanAdapter
-      namespace.cancan_ability_class = ability_class
-    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 with accessible_by" do
-      collection = double
-      expect(collection).to receive(:accessible_by).with(auth.cancan_ability, :edit)
-      auth.scope_collection(collection, :edit)
-    end
-
-  end
-
-end

data/spec/unit/comments_spec.rb

@@ -1,176 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe "Comments" do
-  let(:application) { ActiveAdmin::Application.new }
-
-  describe ActiveAdmin::Comment do
-    subject(:comment){ ActiveAdmin::Comment.new }
-
-    it "has valid Associations and Validations" do
-      expect(comment).to belong_to :resource
-      expect(comment).to belong_to :author
-      expect(comment).to validate_presence_of :resource
-      expect(comment).to validate_presence_of :body
-      expect(comment).to validate_presence_of :namespace
-    end
-
-    describe ".find_for_resource_in_namespace" do
-      let(:post) { Post.create!(title: "Hello World") }
-      let(:namespace_name) { "admin" }
-
-      before do
-        @comment = ActiveAdmin::Comment.create! resource: post,
-                                                body: "A Comment",
-                                                namespace: namespace_name
-      end
-
-      it "should return a comment for the resource in the same namespace" do
-        expect(ActiveAdmin::Comment.find_for_resource_in_namespace(post, namespace_name)).to eq [@comment]
-      end
-
-      it "should not return a comment for the same resource in a different namespace" do
-        ActiveAdmin.application.namespaces[:public] = ActiveAdmin.application.namespaces[:admin]
-        expect(ActiveAdmin::Comment.find_for_resource_in_namespace(post, 'public')).to eq []
-        ActiveAdmin.application.namespaces.instance_variable_get(:@namespaces).delete(:public)
-      end
-
-      it "should not return a comment for a different resource" do
-        another_post = Post.create! title: "Another Hello World"
-        expect(ActiveAdmin::Comment.find_for_resource_in_namespace(another_post, namespace_name)).to eq []
-      end
-
-      it "should return the most recent comment first by default" do
-        another_comment = ActiveAdmin::Comment.create! resource: post,
-                                                       body: "Another Comment",
-                                                       namespace: namespace_name,
-                                                       created_at: @comment.created_at + 20.minutes
-
-        yet_another_comment = ActiveAdmin::Comment.create! resource: post,
-                                                           body: "Yet Another Comment",
-                                                           namespace: namespace_name,
-                                                           created_at: @comment.created_at + 10.minutes
-
-        comments = ActiveAdmin::Comment.find_for_resource_in_namespace(post, namespace_name)
-        expect(comments.size).to eq 3
-        expect(comments.first).to eq(@comment)
-        expect(comments.second).to eq(yet_another_comment)
-        expect(comments.last).to eq(another_comment)
-      end
-
-      context "when custom ordering configured" do
-        around do |example|
-          previous_order = ActiveAdmin.application.comments_order
-          ActiveAdmin.application.comments_order = "created_at DESC"
-
-          example.call
-
-          ActiveAdmin.application.comments_order = previous_order
-        end
-
-        it "should return the correctly ordered comments" do
-          another_comment = ActiveAdmin::Comment.create!(
-            resource: post,
-            body: "Another Comment",
-            namespace: namespace_name,
-            created_at: @comment.created_at + 20.minutes
-          )
-
-          comments = ActiveAdmin::Comment.find_for_resource_in_namespace(
-            post, namespace_name
-          )
-          expect(comments.size).to eq 2
-          expect(comments.first).to eq(another_comment)
-          expect(comments.last).to eq(@comment)
-        end
-      end
-    end
-
-    describe ".resource_type" do
-      let(:post) { Post.create!(title: "Testing.") }
-      let(:post_decorator) { double 'PostDecorator' }
-
-      before do
-        allow(post_decorator).to receive(:model).and_return(post)
-        allow(post_decorator).to receive(:decorated?).and_return(true)
-      end
-
-      context "when a decorated object is passed" do
-        let(:resource) { post_decorator }
-
-        it "returns undeorated object class string" do
-          expect(ActiveAdmin::Comment.resource_type resource).to eql 'Post'
-        end
-      end
-
-      context "when an undecorated object is passed" do
-        let(:resource) { post }
-
-        it "returns object class string" do
-          expect(ActiveAdmin::Comment.resource_type resource).to eql 'Post'
-        end
-      end
-    end
-
-    describe "Commenting on resource with string id" do
-      let(:tag) { Tag.create!(name: "cooltags") }
-      let(:namespace_name) { "admin" }
-
-      it "should allow commenting" do
-        comment = ActiveAdmin::Comment.create!(
-          resource: tag,
-          body: "Another Comment",
-          namespace: namespace_name)
-
-        expect(ActiveAdmin::Comment.find_for_resource_in_namespace(tag, namespace_name)).to eq [comment]
-      end
-    end
-
-    describe "commenting on child of STI resource" do
-      let(:publisher) { Publisher.create!(username: "tenderlove") }
-      let(:namespace_name) { "admin" }
-
-      it "should assign child class as commented resource" do
-        comment = ActiveAdmin::Comment.create!(
-          resource: publisher,
-          body: "Lorem Ipsum",
-          namespace: namespace_name)
-
-        expect(ActiveAdmin::Comment.find_for_resource_in_namespace(publisher, namespace_name).last.resource_type).
-          to eq("User")
-      end
-    end
-  end
-
-  describe ActiveAdmin::Comments::NamespaceHelper do
-    describe "#comments?" do
-
-      it "should have comments when the namespace allows comments" do
-        ns = ActiveAdmin::Namespace.new(application, :admin)
-        ns.comments = true
-        expect(ns.comments?).to eq true
-      end
-
-      it "should not have comments when the namespace does not allow comments" do
-        ns = ActiveAdmin::Namespace.new(application, :admin)
-        ns.comments = false
-        expect(ns.comments?).to eq false
-      end
-    end
-  end
-
-  describe ActiveAdmin::Comments::ResourceHelper do
-    it "should add an attr_accessor :comments to ActiveAdmin::Resource" do
-      ns = ActiveAdmin::Namespace.new(application, :admin)
-      resource = ActiveAdmin::Resource.new(ns, Post)
-      expect(resource.comments).to eq nil
-      resource.comments = true
-      expect(resource.comments).to eq true
-    end
-    it "should disable comments if set to false" do
-      ns = ActiveAdmin::Namespace.new(application, :admin)
-      resource = ActiveAdmin::Resource.new(ns, Post)
-      resource.comments = false
-      expect(resource.comments?).to eq false
-    end
-  end
-end

data/spec/unit/component_spec.rb

@@ -1,18 +0,0 @@
-require 'rails_helper'
-
-class MockComponentClass < ActiveAdmin::Component; end
-
-RSpec.describe ActiveAdmin::Component do
-
-  let(:component_class){ MockComponentClass }
-  let(:component){ component_class.new }
-
-  it "should be a subclass of an html div" do
-    expect(ActiveAdmin::Component.ancestors).to include(Arbre::HTML::Div)
-  end
-
-  it "should render to a div, even as a subclass" do
-    expect(component.tag_name).to eq 'div'
-  end
-
-end

data/spec/unit/config_shared_examples.rb

@@ -1,59 +0,0 @@
-RSpec.shared_examples_for "ActiveAdmin::Resource" do
-  describe "namespace" do
-    it "should return the namespace" do
-      expect(config.namespace).to eq(namespace)
-    end
-  end
-
-  describe "page_presenters" do
-    it "should return an empty hash by default" do
-      expect(config.page_presenters).to eq({})
-    end
-  end
-
-  it { respond_to :controller_name }
-  it { respond_to :controller }
-  it { respond_to :route_prefix }
-  it { respond_to :route_collection_path }
-  it { respond_to :comments? }
-  it { respond_to :belongs_to? }
-  it { respond_to :action_items? }
-  it { respond_to :sidebar_sections? }
-
-  describe "Naming" do
-    it "implements #resource_label" do
-      expect { config.resource_label }.to_not raise_error
-    end
-
-    it "implements #plural_resource_label" do
-      expect { config.plural_resource_label }.to_not raise_error
-    end
-  end
-
-  describe "Menu" do
-    describe "#menu_item_options" do
-
-      it "initializes a new menu item with defaults" do
-          expect(config.menu_item_options[:label].call).to eq(config.plural_resource_label)
-      end
-
-      it "initialize a new menu item with custom options" do
-        config.menu_item_options = { label: "Hello" }
-        expect(config.menu_item_options[:label]).to eq("Hello")
-      end
-
-    end
-
-    describe "#include_in_menu?" do
-      it "should be included in menu by default" do
-        expect(config.include_in_menu?).to eq(true)
-      end
-
-      it "should not be included in menu when menu set to false" do
-        config.menu_item_options = false
-        expect(config.include_in_menu?).to eq(false)
-      end
-    end
-
-  end
-end

data/spec/unit/controller_filters_spec.rb

@@ -1,41 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::Application do
-  let(:application){ ActiveAdmin::Application.new }
-  let(:controllers){ application.controllers_for_filters }
-
-  it 'controllers_for_filters' do
-    expect(application.controllers_for_filters).to eq [
-      ActiveAdmin::BaseController, ActiveAdmin::Devise::SessionsController,
-      ActiveAdmin::Devise::PasswordsController, ActiveAdmin::Devise::UnlocksController,
-      ActiveAdmin::Devise::RegistrationsController, ActiveAdmin::Devise::ConfirmationsController
-    ]
-  end
-
-  expected_actions = (
-    prefixes = %w(skip append prepend) << nil
-    positions = %w(before around after)
-    suffixes = %w(action)
-    base = %w()
-    if ActiveAdmin::Dependency.rails? '< 5.1.x'
-      suffixes += %w(filter)
-      base += %w(skip_filter skip_action_callback)
-    end
-
-    prefixes.each_with_object(base) do |prefix, stack|
-      positions.each do |position|
-        suffixes.each do |suffix|
-          stack << [prefix, position, suffix].compact.join("_").to_sym
-        end
-      end
-    end
-  )
-
-  expected_actions.each do |action|
-    it action do
-      args = [:my_filter, { only: :show }]
-      controllers.each { |c| expect(c).to receive(action).with(args) }
-      application.public_send action, args
-    end
-  end
-end