activeadmin-rails 1.7.0

data/spec/unit/authorization/controller_authorization_spec.rb

@@ -0,0 +1,43 @@
+require 'rails_helper'
+
+RSpec.describe "Controller Authorization", type: :controller do
+
+  let(:authorization){ controller.send(:active_admin_authorization) }
+
+  before do
+    load_resources { ActiveAdmin.register Post }
+    @controller = Admin::PostsController.new
+    allow(authorization).to receive(:authorized?)
+  end
+
+  it "should authorize the index action" do
+    expect(authorization).to receive(:authorized?).with(auth::READ, Post).and_return true
+    get :index
+    expect(response).to be_successful
+  end
+
+  it "should authorize the new action" do
+    expect(authorization).to receive(:authorized?).with(auth::CREATE, an_instance_of(Post)).and_return true
+    get :new
+    expect(response).to be_successful
+  end
+
+  it "should authorize the create action with the new resource" do
+    expect(authorization).to receive(:authorized?).with(auth::CREATE, an_instance_of(Post)).and_return true
+    post :create
+    expect(response).to redirect_to action: 'show', id: Post.last.id
+  end
+
+  it "should redirect when the user isn't authorized" do
+    expect(authorization).to receive(:authorized?).with(auth::READ, Post).and_return false
+    get :index
+
+    expect(response).to redirect_to '/admin'
+  end
+
+  private
+
+  def auth
+    ActiveAdmin::Authorization
+  end
+end

data/spec/unit/authorization/index_overriding_spec.rb

@@ -0,0 +1,23 @@
+require 'rails_helper'
+
+RSpec.describe 'Index overriding', type: :controller do
+  before do
+    load_resources { ActiveAdmin.register Post }
+    @controller = Admin::PostsController.new
+
+    @controller.instance_eval do
+      def index
+        super do
+          render body: 'Rendered from passed block'
+          return
+        end
+      end
+    end
+  end
+
+  it 'should call block passed to overridden index' do
+    get :index
+    expect(response.body).to eq 'Rendered from passed block'
+  end
+
+end

data/spec/unit/auto_link_spec.rb

@@ -0,0 +1,103 @@
+require 'rails_helper'
+require 'active_admin/view_helpers/active_admin_application_helper'
+require 'active_admin/view_helpers/auto_link_helper'
+require 'active_admin/view_helpers/display_helper'
+require 'active_admin/view_helpers/method_or_proc_helper'
+
+RSpec.describe "#auto_link" do
+  let(:view_klass) do
+    Class.new(ActionView::Base) do
+      include ActiveAdmin::ViewHelpers::ActiveAdminApplicationHelper
+      include ActiveAdmin::ViewHelpers::AutoLinkHelper
+      include ActiveAdmin::ViewHelpers::DisplayHelper
+      include MethodOrProcHelper
+    end
+  end
+
+  let(:view) { mock_action_view(view_klass) }
+
+  let(:linked_post) { view.auto_link(post) }
+
+  let(:active_admin_namespace){ ActiveAdmin.application.namespace(:admin) }
+  let(:post){ Post.create! title: "Hello World" }
+
+  before do
+    allow(view).to receive(:authorized?).and_return(true)
+    allow(view).to receive(:active_admin_namespace).and_return(active_admin_namespace)
+    allow(view).to receive(:url_options).and_return({})
+  end
+
+  context "when the resource is not registered" do
+    before do
+      load_resources {}
+    end
+
+    it "should return the display name of the object" do
+      expect(linked_post).to eq "Hello World"
+    end
+  end
+
+  context "when the resource is registered" do
+    before do
+      load_resources do
+        active_admin_namespace.register Post
+      end
+    end
+
+    it "should return a link with the display name of the object" do
+      expect(linked_post).to \
+          match(%r{<a href="/admin/posts/\d+">Hello World</a>})
+    end
+
+    it "should keep locale in the url if present" do
+      expect(view).to receive(:url_options).and_return(locale: 'en')
+
+      expect(linked_post).to \
+          match(%r{<a href="/admin/posts/\d+\?locale=en">Hello World</a>})
+    end
+
+    context "but the user doesn't have access" do
+      before do
+        allow(view).to receive(:authorized?).and_return(false)
+      end
+
+      it "should return the display name of the object" do
+        expect(linked_post).to eq "Hello World"
+      end
+    end
+  end
+
+  context "when the resource is registered with the show action disabled" do
+    before do
+      load_resources do
+        active_admin_namespace.register(Post) { actions :all, except: :show }
+      end
+    end
+
+    it "should fallback to edit" do
+      expect(linked_post).to \
+        match(%r{<a href="/admin/posts/\d+/edit">Hello World</a>})
+    end
+
+    it "should keep locale in the url if present" do
+      expect(view).to receive(:url_options).and_return(locale: 'en')
+
+      expect(linked_post).to \
+        match(%r{<a href="/admin/posts/\d+/edit\?locale=en">Hello World</a>})
+    end
+  end
+
+  context "when the resource is registered with the show & edit actions disabled" do
+    before do
+      load_resources do
+        active_admin_namespace.register(Post) do
+          actions :all, except: [:show, :edit]
+        end
+      end
+
+      it "should return the display name of the object" do
+        expect(linked_post).to eq "Hello World"
+      end
+    end
+  end
+end

data/spec/unit/batch_actions/resource_spec.rb

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

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

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

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

@@ -0,0 +1,204 @@
+require 'rails_helper'
+
+RSpec.describe "Comments" do
+  let(:application) { ActiveAdmin::Application.new }
+
+  describe ActiveAdmin::Comment do
+    let(:comment){ ActiveAdmin::Comment.new }
+
+    let(:user) { User.create!(first_name: "John", last_name: "Doe") }
+
+    let(:post) { Post.create!(title: "Hello World") }
+
+    it "belongs to a resource" do
+      comment.assign_attributes(resource_type: "Post", resource_id: post.id)
+
+      expect(comment.resource).to eq(post)
+    end
+
+    it "belongs to an author" do
+      comment.assign_attributes(author_type: "User", author_id: user.id)
+
+      expect(comment.author).to eq(user)
+    end
+
+    it "needs a body" do
+      expect(comment).to_not be_valid
+      expect(comment.errors[:body]).to eq(["can't be blank"])
+    end
+
+    it "needs a namespace" do
+      expect(comment).to_not be_valid
+      expect(comment.errors[:namespace]).to eq(["can't be blank"])
+    end
+
+    it "needs a resource" do
+      expect(comment).to_not be_valid
+      expect(comment.errors[:resource]).to eq(["can't be blank"])
+    end
+
+    describe ".find_for_resource_in_namespace" do
+      let(:namespace_name) { "admin" }
+
+      before do
+        @comment = ActiveAdmin::Comment.create! author: user,
+                                                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! author: user,
+                                                       resource: post,
+                                                       body: "Another Comment",
+                                                       namespace: namespace_name,
+                                                       created_at: @comment.created_at + 20.minutes
+
+        yet_another_comment = ActiveAdmin::Comment.create! author: user,
+                                                           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!(
+            author: user,
+            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!(
+          author: user,
+          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!(
+          author: user,
+          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

@@ -0,0 +1,18 @@
+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(Arbo::HTML::Div)
+  end
+
+  it "should render to a div, even as a subclass" do
+    expect(component.tag_name).to eq 'div'
+  end
+
+end