activeadmin 1.0.0.pre4 → 2.4.0

data/spec/unit/action_builder_spec.rb

@@ -1,134 +0,0 @@
-require 'rails_helper'
-
-describe 'defining actions from registration blocks', type: :controller do
-  let(:klass){ Admin::PostsController }
-  render_views # https://github.com/rspec/rspec-rails/issues/860
-
-  before do
-    @controller = klass.new
-  end
-
-  describe 'creates a member action' do
-    before do
-      action!
-      reload_routes!
-    end
-
-    after(:each) do
-      klass.clear_member_actions!
-    end
-
-    context 'with a block' do
-      let(:action!) do
-        ActiveAdmin.register Post do
-          member_action :comment do
-            # Do nothing
-          end
-        end
-      end
-
-      it 'should create a new public instance method' do
-        expect(klass.public_instance_methods.collect(&:to_s)).to include('comment')
-      end
-
-      it 'should add itself to the member actions config' do
-        expect(klass.active_admin_config.member_actions.size).to eq 1
-      end
-
-      it 'should create a new named route' do
-        expect(Rails.application.routes.url_helpers.methods.collect(&:to_s)).to include('comment_admin_post_path')
-      end
-    end
-
-    context 'without a block' do
-      let(:action!) do
-        ActiveAdmin.register Post do
-          member_action :comment
-        end
-      end
-
-      it 'should still generate a new empty action' do
-        expect(klass.public_instance_methods.collect(&:to_s)).to include('comment')
-      end
-    end
-
-    context 'with :title' do
-      let(:action!) do
-        ActiveAdmin.register Post do
-          member_action :comment, title: 'My Awesome Comment' do
-            render json: {a: 2}
-          end
-        end
-      end
-
-      it 'sets the page title' do
-        params = {id: 1}
-        params = {params: params} if ActiveAdmin::Dependency.rails5?
-        get :comment, params
-
-        expect(controller.instance_variable_get(:@page_title)).to eq 'My Awesome Comment'
-      end
-    end
-  end
-
-  describe 'creates a collection action' do
-    before do
-      action!
-      reload_routes!
-    end
-
-    after(:each) do
-      klass.clear_collection_actions!
-    end
-
-    context 'with a block' do
-      let(:action!) do
-        ActiveAdmin.register Post do
-          collection_action :comments do
-            # Do nothing
-          end
-        end
-      end
-
-      it 'should create a public instance method' do
-        expect(klass.public_instance_methods.collect(&:to_s)).to include('comments')
-      end
-
-      it 'should add itself to the member actions config' do
-        expect(klass.active_admin_config.collection_actions.size).to eq 1
-      end
-
-      it 'should create a named route' do
-        expect(Rails.application.routes.url_helpers.methods.collect(&:to_s)).to include('comments_admin_posts_path')
-      end
-    end
-
-    context 'without a block' do
-      let(:action!) do
-        ActiveAdmin.register Post do
-          collection_action :comments
-        end
-      end
-
-      it 'should still generate a new empty action' do
-        expect(klass.public_instance_methods.collect(&:to_s)).to include('comments')
-      end
-    end
-
-    context 'with :title' do
-      let(:action!) do
-        ActiveAdmin.register Post do
-          collection_action :comments, title: 'My Awesome Comments' do
-            render json: {a: 2}
-          end
-        end
-      end
-
-      it 'sets the page title' do
-        get :comments
-
-        expect(controller.instance_variable_get(:@page_title)).to eq 'My Awesome Comments'
-      end
-    end
-  end
-end

data/spec/unit/active_admin_spec.rb

@@ -1,11 +0,0 @@
-require 'rails_helper'
-
-describe ActiveAdmin do
-  %w(register register_page unload! load! routes).each do |method|
-    it "delegates ##{method} to application" do
-      expect(ActiveAdmin.application).to receive(method)
-
-      ActiveAdmin.send(method)
-    end
-  end
-end

data/spec/unit/application_spec.rb

@@ -1,165 +0,0 @@
-require 'rails_helper'
-require 'fileutils'
-
-describe ActiveAdmin::Application do
-
-  let(:application) do
-    ActiveAdmin::Application.new.tap do |app|
-      # Manually override the load paths becuase RSpec messes these up
-      app.load_paths = [File.expand_path('app/admin', Rails.root)]
-    end
-  end
-
-  it "should have a default load path of ['app/admin']" do
-    expect(application.load_paths).to eq [File.expand_path('app/admin', Rails.root)]
-  end
-
-  it "should remove app/admin from the autoload paths (Active Admin deals with loading)" do
-    expect(ActiveSupport::Dependencies.autoload_paths).to_not include(File.join(Rails.root, "app/admin"))
-  end
-
-  it "should store the site's title" do
-    expect(application.site_title).to eq ""
-  end
-
-  it "should set the site title" do
-    application.site_title = "New Title"
-    expect(application.site_title).to eq "New Title"
-  end
-
-  it "should store the site's title link" do
-    expect(application.site_title_link).to eq ""
-  end
-
-  it "should set the site's title link" do
-    application.site_title_link = "http://www.mygreatsite.com"
-    expect(application.site_title_link).to eq "http://www.mygreatsite.com"
-  end
-
-  it "should store the site's title image" do
-    expect(application.site_title_image).to eq ""
-  end
-
-  it "should set the site's title image" do
-    application.site_title_image = "http://railscasts.com/assets/episodes/stills/284-active-admin.png?1316476106"
-    expect(application.site_title_image).to eq "http://railscasts.com/assets/episodes/stills/284-active-admin.png?1316476106"
-  end
-
-  it "should store the site's favicon" do
-    expect(application.favicon).to eq false
-  end
-
-  it "should return default localize format" do
-    expect(application.localize_format).to eq :long
-  end
-
-  it "should set localize format" do
-    application.localize_format = :default
-    expect(application.localize_format).to eq :default
-  end
-
-  it "should set the site's favicon" do
-    application.favicon = "/a/favicon.ico"
-    expect(application.favicon).to eq "/a/favicon.ico"
-  end
-
-  it "should store meta tags" do
-    expect(application.meta_tags).to eq({})
-  end
-
-  it "should set meta tags" do
-    application.meta_tags = { author: "My Company" }
-    expect(application.meta_tags).to eq(author: "My Company")
-  end
-
-  it "should contains robots meta tags by default" do
-    result = application.meta_tags_for_logged_out_pages
-    expect(result).to eq(robots: "noindex, nofollow")
-  end
-
-  it "should set meta tags for logged out pages" do
-    value = { author: "My Company" }
-    application.meta_tags_for_logged_out_pages = value
-    expect(application.meta_tags_for_logged_out_pages).to eq value
-  end
-
-  it "should have a view factory" do
-    expect(application.view_factory).to be_an_instance_of(ActiveAdmin::ViewFactory)
-  end
-
-  it "should allow comments by default" do
-    expect(application.comments).to eq true
-  end
-
-  describe "authentication settings" do
-
-    it "should have no default current_user_method" do
-      expect(application.current_user_method).to eq false
-    end
-
-    it "should have no default authentication method" do
-      expect(application.authentication_method).to eq false
-    end
-
-    it "should have a logout link path (Devise's default)" do
-      expect(application.logout_link_path).to eq :destroy_admin_user_session_path
-    end
-
-    it "should have a logout link method (Devise's default)" do
-      expect(application.logout_link_method).to eq :get
-    end
-  end
-
-  describe "files in load path" do
-    it "should load files in the first level directory" do
-      expect(application.files).to include(File.expand_path("app/admin/dashboard.rb", Rails.root))
-    end
-
-    it "should load files from subdirectories" do
-      FileUtils.mkdir_p(File.expand_path("app/admin/public", Rails.root))
-      test_file = File.expand_path("app/admin/public/posts.rb", Rails.root)
-      FileUtils.touch(test_file)
-      expect(application.files).to include(test_file)
-    end
-  end
-
-  describe "#namespace" do
-
-    it "should yield a new namespace" do
-      application.namespace :new_namespace do |ns|
-        expect(ns.name).to eq :new_namespace
-      end
-    end
-
-    it "should return an instantiated namespace" do
-      admin = application.namespace :admin
-      expect(admin).to eq application.namespaces[:admin]
-    end
-
-    it "should yield an existing namespace" do
-      expect {
-        application.namespace :admin do |ns|
-          expect(ns).to eq application.namespaces[:admin]
-          raise "found"
-        end
-      }.to raise_error("found")
-    end
-
-    it "should not pollute the global app" do
-      expect(application.namespaces).to be_empty
-      application.namespace(:brand_new_ns)
-      expect(application.namespaces.names).to eq [:brand_new_ns]
-      expect(ActiveAdmin.application.namespaces.names).to eq [:admin]
-    end
-  end
-
-  describe "#register_page" do
-    it "finds or create the namespace and register the page to it" do
-      namespace = double
-      expect(application).to receive(:namespace).with("public").and_return namespace
-      expect(namespace).to receive(:register_page).with("My Page", {namespace: "public"})
-      application.register_page("My Page", namespace: "public")
-    end
-  end
-
-end

data/spec/unit/asset_registration_spec.rb

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

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

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

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

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

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