activeadmin-orac 1.0.0.pre4

data/spec/unit/asset_registration_spec.rb

@@ -0,0 +1,52 @@
+require 'rails_helper'
+
+describe ActiveAdmin::AssetRegistration do
+  include ActiveAdmin::AssetRegistration
+
+  before do
+    clear_stylesheets!
+    clear_javascripts!
+  end
+
+  it "should register a stylesheet file" do
+    register_stylesheet "active_admin.css"
+    expect(stylesheets.length).to eq 1
+    expect(stylesheets.keys.first).to eq "active_admin.css"
+  end
+
+  it "should clear all existing stylesheets" do
+    register_stylesheet "active_admin.css"
+    expect(stylesheets.length).to eq 1
+    clear_stylesheets!
+    expect(stylesheets).to be_empty
+  end
+
+  it "should allow media option when registering stylesheet" do
+    register_stylesheet "active_admin.css", media: :print
+    expect(stylesheets.values.first[:media]).to eq :print
+  end
+
+  it "shouldn't register a stylesheet twice" do
+    register_stylesheet "active_admin.css"
+    register_stylesheet "active_admin.css"
+    expect(stylesheets.length).to eq 1
+  end
+
+  it "should register a javascript file" do
+    register_javascript "active_admin.js"
+    expect(javascripts).to eq ["active_admin.js"].to_set
+  end
+
+  it "should clear all existing javascripts" do
+    register_javascript "active_admin.js"
+    expect(javascripts).to eq ["active_admin.js"].to_set
+    clear_javascripts!
+    expect(javascripts).to be_empty
+  end
+
+  it "shouldn't register a javascript twice" do
+    register_javascript "active_admin.js"
+    register_javascript "active_admin.js"
+    expect(javascripts.length).to eq 1
+  end
+end

data/spec/unit/authorization/authorization_adapter_spec.rb

@@ -0,0 +1,61 @@
+require 'rails_helper'
+
+describe ActiveAdmin::AuthorizationAdapter do
+
+  let(:adapter) { ActiveAdmin::AuthorizationAdapter.new(double, double) }
+
+  describe "#authorized?" do
+
+    it "should always return true" do
+      expect(adapter.authorized?(:read, "Resource")).to eq true
+    end
+
+  end
+
+  describe "#scope_collection" do
+
+    it "should return the collection unscoped" do
+      collection = double
+      expect(adapter.scope_collection(collection, ActiveAdmin::Auth::READ)).to eq collection
+    end
+
+  end
+
+  describe "using #normalized in a subclass" do
+
+    let(:auth_class) do
+      Class.new(ActiveAdmin::AuthorizationAdapter) do
+
+        def authorized?(action, subject = nil)
+          case subject
+          when normalized(String)
+            true
+          else
+            false
+          end
+        end
+
+      end
+    end
+
+    let(:adapter) { auth_class.new(double, double) }
+
+    it "should match against a class" do
+      expect(adapter.authorized?(:read, String)).to eq true
+    end
+
+    it 'should match against an instance' do
+      expect(adapter.authorized?(:read, "String")).to eq true
+    end
+
+    it 'should not match a different class' do
+      expect(adapter.authorized?(:read, Hash)).to eq false
+    end
+
+    it 'should not match a different instance' do
+      expect(adapter.authorized?(:read, {})).to eq false
+    end
+
+  end
+
+end

data/spec/unit/authorization/controller_authorization_spec.rb

@@ -0,0 +1,39 @@
+require 'rails_helper'
+Auth = ActiveAdmin::Authorization
+
+describe Admin::PostsController, "Controller Authorization", type: :controller do
+
+  let(:authorization){ controller.send(:active_admin_authorization) }
+
+  before do
+    load_defaults!
+    # HACK: the AA config is missing, so we throw it in here
+    controller.class.active_admin_config = ActiveAdmin.application.namespace(:admin).resources['Post'].controller.active_admin_config
+  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_success
+  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_success
+  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.body).to eq '<html><body>You are being <a href="http://test.host/admin">redirected</a>.</body></html>'
+    expect(response).to redirect_to '/admin'
+  end
+
+end

data/spec/unit/authorization/index_overriding_spec.rb

@@ -0,0 +1,23 @@
+require 'rails_helper'
+
+describe Admin::PostsController, 'Index overriding', type: :controller do
+  before do
+    controller.instance_eval do
+      def index
+        super do
+          render Dependency.rails.render_key => 'Rendered from passed block'
+          return
+        end
+      end
+    end
+    load_defaults!
+    # HACK: the AA config is missing, so we throw it in here
+    controller.class.active_admin_config = ActiveAdmin.application.namespace(:admin).resources['Post'].controller.active_admin_config
+  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,69 @@
+require 'rails_helper'
+
+describe "auto linking resources" do
+  include ActiveAdmin::ViewHelpers::ActiveAdminApplicationHelper
+  include ActiveAdmin::ViewHelpers::AutoLinkHelper
+  include ActiveAdmin::ViewHelpers::DisplayHelper
+  include MethodOrProcHelper
+
+  let(:active_admin_config)   { double namespace: namespace }
+  let(:active_admin_namespace){ ActiveAdmin::Namespace.new(ActiveAdmin::Application.new, :admin) }
+  let(:post){ Post.create! title: "Hello World" }
+
+  def admin_post_path(post)
+    "/admin/posts/#{post.id}"
+  end
+
+  def authorized?(*)
+    true
+  end
+
+  context "when the resource is not registered" do
+    it "should return the display name of the object" do
+      expect(auto_link(post)).to eq "Hello World"
+    end
+  end
+
+  context "when the resource is registered" do
+    before do
+      active_admin_namespace.register Post
+    end
+    it "should return a link with the display name of the object" do
+      expect(self).to receive(:url_for) { |url| url }
+      expect(self).to receive(:link_to).with "Hello World", admin_post_path(post)
+      auto_link(post)
+    end
+
+    context "but the user doesn't have access" do
+      it "should return the display name of the object" do
+        expect(self).to receive(:authorized?).twice.and_return(false)
+        expect(auto_link(post)).to eq "Hello World"
+      end
+    end
+
+    context "but the show action is disabled" do
+      before do
+        active_admin_namespace.register(Post) { actions :all, except: :show }
+      end
+
+      it "should fallback to edit" do
+        url_path = "/admin/posts/#{post.id}/edit"
+        expect(self).to receive(:url_for) { |url| url }
+        expect(self).to receive(:link_to).with "Hello World", url_path
+        auto_link(post)
+      end
+    end
+
+    context "but the show and edit actions are disabled" do
+      before 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(auto_link(post)).to eq "Hello World"
+      end
+    end
+  end
+end

data/spec/unit/batch_actions/resource_spec.rb

@@ -0,0 +1,97 @@
+require 'rails_helper'
+
+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 "#batch_action_path" do
+
+    it "returns the path as a symbol" do
+      expect(resource.batch_action_path).to eq "/admin/posts/batch_action"
+    end
+
+    it "includes :scope and :q params" do
+      params = { q: { name_equals: "Any" }, scope: :all }
+      batch_action_path = "/admin/posts/batch_action?q%5Bname_equals%5D=Any&scope=all"
+      expect(resource.batch_action_path(params)).to eq(batch_action_path)
+    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'
+
+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,65 @@
+require 'rails_helper'
+
+describe ActiveAdmin::Resource::BelongsTo do
+
+  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 }
+    before do
+      user = User.create!
+      request = double 'Request', format: 'application/json'
+      allow(controller).to receive(:params) { {user_id: user.id} }
+      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