activeadmin 1.1.0 → 2.14.0

data/spec/unit/namespace/register_resource_spec.rb

@@ -1,162 +0,0 @@
-require 'rails_helper'
-
-# TODO: refactor this file so it doesn't depend on the Admin namespace in such a broken way.
-#       Specifically, the dashboard is already defined.
-
-RSpec.describe ActiveAdmin::Namespace, "registering a resource" do
-  let(:application){ ActiveAdmin::Application.new }
-  let(:namespace){ ActiveAdmin::Namespace.new(application, :admin) }
-  let(:menu){ namespace.fetch_menu(:default) }
-
-  after { namespace.unload! }
-
-  context "with no configuration" do
-    before do
-      namespace.register Category
-    end
-
-    it "should store the namespaced registered configuration" do
-      expect(namespace.resources.keys).to include('Category')
-    end
-
-    it "should create a new controller in the default namespace" do
-      expect(defined?(Admin::CategoriesController)).to eq 'constant'
-    end
-
-    skip "should not create the dashboard controller" do
-      defined?(Admin::DashboardController).to_not eq 'constant'
-    end
-
-    it "should create a menu item" do
-      expect(menu["Categories"]).to be_a ActiveAdmin::MenuItem
-      expect(menu["Categories"].instance_variable_get(:@url)).to be_a Proc
-    end
-  end
-
-  context "with a block configuration" do
-    it "should be evaluated in the dsl" do
-      expect{ |block|
-        namespace.register Category, &block
-      }.to yield_control
-    end
-  end
-
-  context "with a resource that's namespaced" do
-    before do
-      module ::Mock; class Resource; def self.has_many(arg1, arg2); end; end; end
-      namespace.register Mock::Resource
-    end
-
-    it "should store the namespaced registered configuration" do
-      expect(namespace.resources.keys).to include('Mock::Resource')
-    end
-    it "should create a new controller in the default namespace" do
-      expect(defined?(Admin::MockResourcesController)).to eq 'constant'
-    end
-    it "should create a menu item" do
-      expect(menu["Mock Resources"]).to be_an_instance_of(ActiveAdmin::MenuItem)
-    end
-
-    it "should use the resource as the model in the controller" do
-      expect(Admin::MockResourcesController.resource_class).to eq Mock::Resource
-    end
-  end # context "with a resource that's namespaced"
-
-  describe "finding resource instances" do
-    it "should return the resource when its been registered" do
-      post = namespace.register Post
-      expect(namespace.resource_for(Post)).to eq post
-    end
-
-    it 'should return nil when the resource has not been registered' do
-      expect(namespace.resource_for(Post)).to eq nil
-    end
-
-    it "should return the parent when the parent class has been registered and the child has not" do
-      user = namespace.register User
-      expect(namespace.resource_for(Publisher)).to eq user
-    end
-
-    it "should return the resource if it and it's parent were registered" do
-      user = namespace.register User
-      publisher = namespace.register Publisher
-      expect(namespace.resource_for(Publisher)).to eq publisher
-    end
-  end # describe "finding resource instances"
-
-  describe "adding to the menu" do
-    describe "adding as a top level item" do
-      before do
-        namespace.register Category
-      end
-      it "should add a new menu item" do
-        expect(menu['Categories']).to_not eq nil
-      end
-    end # describe "adding as a top level item"
-
-    describe "adding as a child" do
-      before do
-        namespace.register Category do
-          menu parent: 'Blog'
-        end
-      end
-      it "should generate the parent menu item" do
-        expect(menu['Blog']).to_not eq nil
-      end
-      it "should generate its own child item" do
-        expect(menu['Blog']['Categories']).to_not eq nil
-      end
-    end # describe "adding as a child"
-
-    describe "disabling the menu" do
-      before do
-        namespace.register Category do
-          menu false
-        end
-      end
-      it "should not create a menu item" do
-        expect(menu["Categories"]).to eq nil
-      end
-    end # describe "disabling the menu"
-
-    describe "adding as a belongs to" do
-      context "when not optional" do
-        before do
-          namespace.register Post do
-            belongs_to :author
-          end
-        end
-        it "should not show up in the menu" do
-          expect(menu["Posts"]).to eq nil
-        end
-      end
-      context "when optional" do
-        before do
-          namespace.register Post do
-            belongs_to :author, optional: true
-          end
-        end
-        it "should show up in the menu" do
-          expect(menu["Posts"]).to_not eq nil
-        end
-      end
-    end
-  end # describe "adding to the menu"
-
-  describe "dashboard controller name" do
-    context "when namespaced" do
-      it "should be namespaced" do
-        namespace = ActiveAdmin::Namespace.new(application, :one)
-        namespace.register Category
-        expect(defined?(One::CategoriesController)).to eq 'constant'
-      end
-    end
-    context "when not namespaced" do
-      it "should not be namespaced" do
-        namespace = ActiveAdmin::Namespace.new(application, :two)
-        namespace.register Category
-        expect(defined?(Two::CategoriesController)).to eq 'constant'
-      end
-    end
-  end # describe "dashboard controller name"
-end # describe "registering a resource"

data/spec/unit/namespace_spec.rb

@@ -1,124 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::Namespace do
-
-  let(:application){ ActiveAdmin::Application.new }
-
-  context "when new" do
-    let(:namespace){ ActiveAdmin::Namespace.new(application, :admin) }
-
-    it "should have an application instance" do
-      expect(namespace.application).to eq application
-    end
-
-    it "should have a name" do
-      expect(namespace.name).to eq :admin
-    end
-
-    it "should have no resources" do
-      expect(namespace.resources).to be_empty
-    end
-
-    it "should not have any menu item" do
-      expect(namespace.fetch_menu(:default).children).to be_empty
-    end
-  end # context "when new"
-
-  describe "#unload!" do
-    context "when controller is only defined without a namespace" do
-      before do
-        # To ensure Admin::PostsController is defined
-        ActiveAdmin.register Post
-
-        # To ensure ::PostsController is defined
-        ActiveAdmin.register Post, namespace: false
-
-        # To prevent unload! from unregistering ::PostsController
-        ActiveAdmin.application.namespaces.instance_variable_get(:@namespaces).delete(:root)
-
-        # To force Admin::PostsController to not be there
-        Admin.send(:remove_const, 'PostsController')
-      end
-
-      it "should not crash" do
-        expect { ActiveAdmin.unload! }.not_to raise_error
-      end
-    end
-  end
-
-  describe "settings" do
-    let(:namespace){ ActiveAdmin::Namespace.new(application, :admin) }
-
-    it "should inherit the site title from the application" do
-      ActiveAdmin::Namespace.setting :site_title, "Not the Same"
-      expect(namespace.site_title).to eq application.site_title
-    end
-
-    it "should be able to override the site title" do
-      expect(namespace.site_title).to eq application.site_title
-      namespace.site_title = "My Site Title"
-      expect(namespace.site_title).to_not eq application.site_title
-    end
-  end
-
-  describe "#fetch_menu" do
-    let(:namespace){ ActiveAdmin::Namespace.new(application, :admin) }
-
-    it "returns the menu" do
-      expect(namespace.fetch_menu(:default)).to be_an_instance_of(ActiveAdmin::Menu)
-    end
-
-    it "should have utility nav menu" do
-      expect(namespace.fetch_menu(:utility_navigation)).to be_an_instance_of(ActiveAdmin::Menu)
-    end
-
-    it "should raise an exception if the menu doesn't exist" do
-      expect {
-        namespace.fetch_menu(:not_a_menu_that_exists)
-      }.to raise_error(KeyError)
-    end
-  end
-
-  describe "#build_menu" do
-    let(:namespace){ ActiveAdmin::Namespace.new(application, :admin) }
-
-    it "should set the block as a menu build callback" do
-      namespace.build_menu do |menu|
-        menu.add label: "menu item"
-      end
-
-      expect(namespace.fetch_menu(:default)["menu item"]).to_not eq nil
-    end
-
-    it "should set a block on a custom menu" do
-      namespace.build_menu :test do |menu|
-        menu.add label: "menu item"
-      end
-
-      expect(namespace.fetch_menu(:test)["menu item"]).to_not eq nil
-    end
-  end
-
-  describe "utility navigation" do
-    let(:namespace){ ActiveAdmin::Namespace.new(application, :admin) }
-    let(:menu) do
-      namespace.build_menu :utility_navigation do |menu|
-        menu.add label: "ActiveAdmin.info", url: "http://www.activeadmin.info", html_options: { target: :blank }
-        namespace.add_logout_button_to_menu menu, 1, class: "matt"
-      end
-      namespace.fetch_menu(:utility_navigation)
-    end
-
-    it "should have a logout button to the far left" do
-      expect(menu["Logout"]).to_not eq nil
-      expect(menu["Logout"].priority).to eq 1
-    end
-
-    it "should have a static link with a target of :blank" do
-      expect(menu["ActiveAdmin.info"]).to_not eq nil
-      expect(menu["ActiveAdmin.info"].html_options).to include(target: :blank)
-    end
-
-  end
-
-end

data/spec/unit/order_clause_spec.rb

@@ -1,81 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::OrderClause do
-  subject { described_class.new(config, clause) }
-
-  let(:application) { ActiveAdmin::Application.new }
-  let(:namespace) { ActiveAdmin::Namespace.new application, :admin }
-  let(:config) { ActiveAdmin::Resource.new namespace, Post }
-
-  describe 'id_asc (existing column)' do
-    let(:clause) { 'id_asc' }
-
-    it { is_expected.to be_valid }
-
-    describe '#field' do
-      subject { super().field }
-      it { is_expected.to eq('id') }
-    end
-
-    describe '#order' do
-      subject { super().order }
-      it { is_expected.to eq('asc') }
-    end
-
-    specify '#to_sql prepends table name' do
-      expect(subject.to_sql).to eq '"posts"."id" asc'
-    end
-  end
-
-  describe 'virtual_column_asc' do
-    let(:clause) { 'virtual_column_asc' }
-
-    it { is_expected.to be_valid }
-
-    describe '#field' do
-      subject { super().field }
-      it { is_expected.to eq('virtual_column') }
-    end
-
-    describe '#order' do
-      subject { super().order }
-      it { is_expected.to eq('asc') }
-    end
-
-    specify '#to_sql' do
-      expect(subject.to_sql).to eq '"virtual_column" asc'
-    end
-  end
-
-  describe "hstore_col->'field'_desc" do
-    let(:clause) { "hstore_col->'field'_desc" }
-
-    it { is_expected.to be_valid }
-
-    describe '#field' do
-      subject { super().field }
-      it { is_expected.to eq("hstore_col->'field'") }
-    end
-
-    describe '#order' do
-      subject { super().order }
-      it { is_expected.to eq('desc') }
-    end
-
-    it 'converts to sql' do
-      expect(subject.to_sql).to eq %Q("hstore_col"->'field' desc)
-    end
-  end
-
-  describe '_asc' do
-    let(:clause) { '_asc' }
-
-    it { is_expected.not_to be_valid }
-  end
-
-  describe 'nil' do
-    let(:clause) { nil }
-
-    it { is_expected.not_to be_valid }
-  end
-end

data/spec/unit/page_controller_spec.rb

@@ -1,5 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::PageController do
-  let(:controller) { ActiveAdmin::PageController.new }
-end

data/spec/unit/page_spec.rb

@@ -1,128 +0,0 @@
-require 'rails_helper'
-require File.expand_path('config_shared_examples', File.dirname(__FILE__))
-
-module ActiveAdmin
-  RSpec.describe Page do
-
-    it_should_behave_like "ActiveAdmin::Resource"
-    before { load_defaults! }
-
-    let(:application){ ActiveAdmin::Application.new }
-    let(:namespace){ Namespace.new(application, :admin) }
-    let(:page_name) { "Chocolate I lØve You!" }
-
-    def config(options = {})
-      @config ||= namespace.register_page("Chocolate I lØve You!", options)
-    end
-
-    describe "controller name" do
-      it "should return a namespaced controller name" do
-        expect(config.controller_name).to eq "Admin::ChocolateILoveYouController"
-      end
-      context "when non namespaced controller" do
-        let(:namespace){ ActiveAdmin::Namespace.new(application, :root) }
-        it "should return a non namespaced controller name" do
-          expect(config.controller_name).to eq "ChocolateILoveYouController"
-        end
-      end
-    end
-
-    describe "#resource_name" do
-      it "returns the name" do
-        expect(config.resource_name).to eq "Chocolate I lØve You!"
-      end
-
-      it "returns the singular, lowercase name" do
-        if RUBY_VERSION >= '2.4.0'
-          expect(config.resource_name.singular).to eq "chocolate i løve you!"
-        else
-          expect(config.resource_name.singular).to eq "chocolate i lØve you!"
-        end
-      end
-    end
-
-    describe "#plural_resource_label" do
-      it "returns the singular name" do
-        expect(config.plural_resource_label).to eq "Chocolate I lØve You!"
-      end
-    end
-
-    describe "#underscored_resource_name" do
-      it "returns the resource name underscored" do
-        expect(config.underscored_resource_name).to eq "chocolate_i_love_you"
-      end
-    end
-
-    describe "#camelized_resource_name" do
-      it "returns the resource name camel case" do
-        expect(config.camelized_resource_name).to eq "ChocolateILoveYou"
-      end
-    end
-
-    describe "#namespace_name" do
-      it "returns the name of the namespace" do
-        expect(config.namespace_name).to eq "admin"
-      end
-    end
-
-    it "should not belong_to anything" do
-      expect(config.belongs_to?).to eq false
-    end
-
-    it "should not have any action_items" do
-      expect(config.action_items?).to eq false
-    end
-
-    it "should not have any sidebar_sections" do
-      expect(config.sidebar_sections?).to eq false
-    end
-
-    context "with belongs to config" do
-      let!(:post_config) { namespace.register Post }
-      let!(:page_config) {
-        namespace.register_page page_name do
-          belongs_to :post
-        end
-      }
-
-      it "configures page with belongs_to" do
-        expect(page_config.belongs_to?).to be true
-      end
-
-      it "sets navigation menu to parent" do
-        expect(page_config.navigation_menu_name).to eq :post
-      end
-
-      it "builds a belongs_to relationship" do
-        belongs_to = page_config.belongs_to_config
-
-        expect(belongs_to.target).to eq(post_config)
-        expect(belongs_to.owner).to eq(page_config)
-        expect(belongs_to.optional?).to be_falsy
-      end
-
-      it "forwards belongs_to call to controller" do
-        options = { optional: true }
-        expect(page_config.controller).to receive(:belongs_to).with(:post, options)
-        page_config.belongs_to :post, options
-      end
-    end # context "with belongs to config" do
-
-    context "with optional belongs to config" do
-      let!(:post_config) { namespace.register Post }
-      let!(:page_config) {
-        namespace.register_page page_name do
-          belongs_to :post, optional: true
-        end
-      }
-
-      it "does not override default navigation menu" do
-        expect(page_config.navigation_menu_name).to eq(:default)
-      end
-    end # context "with optional belongs to config" do
-
-    it "has no belongs_to by default" do
-      expect(config.belongs_to?).to be_falsy
-    end
-  end
-end

data/spec/unit/pretty_format_spec.rb

@@ -1,82 +0,0 @@
-require 'rails_helper'
-require 'active_admin/view_helpers/display_helper'
-
-RSpec.describe "#pretty_format" do
-  include ActiveAdmin::ViewHelpers::DisplayHelper
-
-  def method_missing(*args, &block)
-    mock_action_view.send *args, &block
-  end
-
-  ['hello', 23, 5.67, 10**30, :foo, Arbre::Element.new.br(:foo)].each do |obj|
-    it "should call `to_s` on #{obj.class}s" do
-      expect(pretty_format(obj)).to eq obj.to_s
-    end
-  end
-
-  shared_examples_for 'a time-ish object' do |t|
-    it "formats it with the default long format" do
-      expect(pretty_format(t)).to eq "February 28, 1985 20:15"
-    end
-
-    it "formats it with a customized long format" do
-      with_translation time: { formats: { long: "%B %d, %Y, %l:%M%P" } } do
-        expect(pretty_format(t)).to eq "February 28, 1985,  8:15pm"
-      end
-    end
-
-    context "with a custom localize format" do
-      around do |example|
-        previous_localize_format = ActiveAdmin.application.localize_format
-        ActiveAdmin.application.localize_format = :short
-        example.call
-        ActiveAdmin.application.localize_format = previous_localize_format
-      end
-
-      it "formats it with the default custom format" do
-        expect(pretty_format(t)).to eq "28 Feb 20:15"
-      end
-
-      it "formats it with i18n custom format" do
-        with_translation time: { formats: { short: "%-m %d %Y" } } do
-          expect(pretty_format(t)).to eq "2 28 1985"
-        end
-      end
-    end
-
-    context "with non-English locale" do
-      around do |example|
-        I18n.with_locale(:es) { example.call }
-      end
-
-      it "formats it with the default long format" do
-        expect(pretty_format(t)).to eq "28 de febrero de 1985 20:15"
-      end
-
-      it "formats it with a customized long format" do
-        with_translation time: { formats: { long: "El %d de %B de %Y a las %H horas y %M minutos" } } do
-          expect(pretty_format(t)).to eq "El 28 de febrero de 1985 a las 20 horas y 15 minutos"
-        end
-      end
-    end
-  end
-
-  it_behaves_like 'a time-ish object', Time.utc(1985, "feb", 28, 20, 15, 1)
-  it_behaves_like 'a time-ish object', DateTime.new(1985, 2, 28, 20, 15, 1)
-
-  context "given an ActiveRecord object" do
-    it "should delegate to auto_link" do
-      post = Post.new
-      expect(self).to receive(:auto_link).with(post) { "model name" }
-      expect(pretty_format(post)).to eq "model name"
-    end
-  end
-
-  context "given an arbitrary object" do
-    it "should delegate to `display_name`" do
-      something = Class.new.new
-      expect(self).to receive(:display_name).with(something) { "I'm not famous" }
-      expect(pretty_format(something)).to eq "I'm not famous"
-    end
-  end
-end

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