activeadmin-rails 1.7.0

data/spec/unit/generators/install_spec.rb

@@ -0,0 +1,31 @@
+require 'rails_helper'
+
+RSpec.describe "AA installation" do
+  context "should create" do
+
+    it "active_admin.scss" do
+      path = Rails.root + "app/assets/stylesheets/active_admin.scss"
+
+      expect(File.exist?(path)).to eq true
+    end
+
+    it "active_admin.js" do
+      path = Rails.root + "app/assets/javascripts/active_admin.js"
+
+      expect(File.exist?(path)).to eq true
+    end
+
+    it "the dashboard" do
+      path = Rails.root + "app/admin/dashboard.rb"
+
+      expect(File.exist?(path)).to eq true
+    end
+
+    it "the initializer" do
+      path = Rails.root + "config/initializers/active_admin.rb"
+
+      expect(File.exist?(path)).to eq true
+    end
+
+  end
+end

data/spec/unit/helpers/collection_spec.rb

@@ -0,0 +1,68 @@
+require 'rails_helper'
+
+RSpec.describe ActiveAdmin::Helpers::Collection do
+
+  include ActiveAdmin::Helpers::Collection
+
+  before do
+    Post.create!(title: "A post")
+    Post.create!(title: "A post")
+    Post.create!(title: "An other post")
+  end
+
+  describe "#collection_size" do
+    it "should return the collection size for an ActiveRecord class" do
+      expect(collection_size(Post.where(nil))).to eq 3
+    end
+
+    it "should return the collection size for an ActiveRecord::Relation" do
+      expect(collection_size(Post.where(title: "A post"))).to eq 2
+    end
+
+    it "should return the collection size for a collection with group by" do
+      expect(collection_size(Post.group(:title))).to eq 2
+    end
+
+    it "should return the collection size for a collection with group by, select and custom order" do
+      expect(collection_size(Post.select("title, count(*) as nb_posts").group(:title).order("nb_posts"))).to eq 2
+    end
+
+    it "should return the collection size for an Array" do
+      expect(collection_size(Post.where(title: "A post").to_a)).to eq 2
+    end
+
+    it "should take the defined collection by default" do
+      def collection; Post.where(nil); end
+
+      expect(collection_size).to eq 3
+
+      def collection; Post.where(title: "An other post"); end
+
+      expect(collection_size).to eq 1
+
+      def collection; Post.where(title: "A post").to_a end
+
+      expect(collection_size).to eq 2
+    end
+  end
+
+  describe "#collection_is_empty?" do
+    it "should return true when the collection is empty" do
+      expect(collection_is_empty?(Post.where(title: "Non existing post"))).to eq true
+    end
+
+    it "should return false when the collection is not empty" do
+      expect(collection_is_empty?(Post.where(title: "A post"))).to eq false
+    end
+
+    it "should take the defined collection by default" do
+      def collection; Post.where(nil); end
+
+      expect(collection_is_empty?).to eq false
+
+      def collection; Post.where(title: "Non existing post"); end
+
+      expect(collection_is_empty?).to eq true
+    end
+  end
+end

data/spec/unit/helpers/scope_chain_spec.rb

@@ -0,0 +1,35 @@
+require 'rails_helper'
+
+RSpec.describe ActiveAdmin::ScopeChain do
+
+  include ActiveAdmin::ScopeChain
+
+  describe "#scope_chain" do
+    let(:relation) { double }
+
+    context "when Scope has a scope method" do
+      let(:scope) { ActiveAdmin::Scope.new :published }
+
+      it "should call the method on the relation and return it" do
+        expect(relation).to receive(:published).and_return(:scoped_relation)
+        expect(scope_chain(scope, relation)).to eq :scoped_relation
+      end
+    end
+
+    context "when Scope has the scope method method ':all'" do
+      let(:scope) { ActiveAdmin::Scope.new :all }
+
+      it "should return the relation" do
+        expect(scope_chain(scope, relation)).to eq relation
+      end
+    end
+
+    context "when Scope has a name and a scope block" do
+      let(:scope) { ActiveAdmin::Scope.new("My Scope"){|s| :scoped_relation } }
+
+      it "should instance_exec the block and return it" do
+        expect(scope_chain(scope, relation)).to eq :scoped_relation
+      end
+    end
+  end
+end

data/spec/unit/i18n_spec.rb

@@ -0,0 +1,29 @@
+require 'rails_helper'
+require 'i18n/tasks'
+
+Dir.glob('config/locales/*.yml') do |locale_file|
+  RSpec.describe locale_file do
+    it { is_expected.to be_parseable }
+    it { is_expected.to have_one_top_level_namespace }
+    it { is_expected.to be_named_like_top_level_namespace }
+    it { is_expected.to_not have_legacy_interpolations }
+    it { is_expected.to have_a_valid_locale }
+    it { is_expected.to be_a_subset_of 'config/locales/en.yml' }
+  end
+end
+
+RSpec.describe 'I18n' do
+  let(:i18n) { I18n::Tasks::BaseTask.new }
+  let(:unused_keys) { i18n.unused_keys }
+
+  let(:failure_msg) do
+    <<-MSG.squish
+      #{unused_keys.leaves.count} unused i18n keys, run `i18n-tasks unused' to
+      show them
+    MSG
+  end
+
+  it 'does not have unused keys' do
+    expect(unused_keys).to be_empty, failure_msg
+  end
+end

data/spec/unit/localizers/resource_localizer_spec.rb

@@ -0,0 +1,36 @@
+require 'rails_helper'
+
+RSpec.shared_examples_for "ActiveAdmin::Localizers::ResourceLocalizer" do
+  it "should use proper translation" do
+    string = ActiveAdmin::Localizers::ResourceLocalizer.t(action, model: model, model_name: model_name)
+    expect(string).to eq translation
+  end
+
+  it "should accessible via ActiveAdmin::Localizers" do
+    resource = double(resource_label: model, resource_name: double(i18n_key: model_name))
+    localizer = ActiveAdmin::Localizers.resource(resource)
+    expect(localizer.t(action)).to eq translation
+  end
+end
+
+RSpec.describe ActiveAdmin::Localizers::ResourceLocalizer do
+  let(:action) { 'new_model' }
+  let(:model) { 'Comment' }
+  let(:model_name) { 'comment' }
+
+  it_behaves_like "ActiveAdmin::Localizers::ResourceLocalizer" do
+    let(:translation) { 'New Comment' }
+  end
+
+  describe "model action specified" do
+    around do |example|
+      with_translation active_admin: {resources: {comment: {new_model: 'Write comment'}}} do
+        example.call
+      end
+    end
+
+    it_behaves_like "ActiveAdmin::Localizers::ResourceLocalizer" do
+      let(:translation) { 'Write comment' }
+    end
+  end
+end

data/spec/unit/menu_collection_spec.rb

@@ -0,0 +1,40 @@
+require 'rails_helper'
+
+RSpec.describe ActiveAdmin::MenuCollection do
+
+  let(:menus) { ActiveAdmin::MenuCollection.new }
+
+  describe "#add" do
+
+    it "should initialize a new menu when first item" do
+      menus.add :default, label: "Hello World"
+
+      expect(menus.fetch(:default).items.size).to eq 1
+      expect(menus.fetch(:default)["Hello World"]).to be_an_instance_of(ActiveAdmin::MenuItem)
+    end
+
+    it "should add items to an existing menu" do
+      menus.add :default, label: "Hello World"
+      menus.add :default, label: "Hello World Again"
+
+      expect(menus.fetch(:default).items.size).to eq 2
+    end
+
+  end
+
+  describe "#clear!" do
+
+    it "should remove all menus" do
+      menus.add :default, label: "Hello World"
+
+      menus.clear!
+
+      expect {
+        menus.fetch(:non_default_menu)
+      }.to raise_error(ActiveAdmin::NoMenuError)
+
+    end
+
+  end
+
+end

data/spec/unit/menu_item_spec.rb

@@ -0,0 +1,82 @@
+require 'rails_helper'
+require 'active_admin/menu'
+require 'active_admin/menu_item'
+
+module ActiveAdmin
+  RSpec.describe MenuItem do
+
+    it "should have a label" do
+      item = MenuItem.new(label: "Dashboard")
+      expect(item.label).to eq "Dashboard"
+    end
+
+    it "should have a url" do
+      item = MenuItem.new(url: "/admin")
+      expect(item.url).to eq "/admin"
+    end
+
+    it "should have a priority of 10 by default" do
+      item = MenuItem.new
+      expect(item.priority).to eq 10
+    end
+
+    it "should default to an empty hash for html_options" do
+      item = MenuItem.new
+      expect(item.html_options).to be_empty
+    end
+
+    it "should accept an options hash for link_to" do
+      item = MenuItem.new html_options: { target: :blank }
+      expect(item.html_options).to include(target: :blank)
+    end
+
+    context "with no items" do
+      it "should be empty" do
+        item = MenuItem.new
+        expect(item.items).to be_empty
+      end
+
+      it "should accept new children" do
+        item = MenuItem.new label: "Dashboard"
+        item.add            label: "My Child Dashboard"
+        expect(item.items.first).to be_a MenuItem
+        expect(item.items.first.label).to eq "My Child Dashboard"
+      end
+    end
+
+    context "with many children" do
+      let(:item) do
+        i = MenuItem.new(label: "Dashboard")
+        i.add label: "Blog"
+        i.add label: "Cars"
+        i.add label: "Users", priority: 1
+        i.add label: "Settings", priority: 2
+        i.add label: "Analytics", priority: 44
+        i
+      end
+
+      it "should contain 5 submenu items" do
+        expect(item.items.count).to eq 5
+      end
+
+      it "should give access to the menu item as an array" do
+        expect(item['Blog'].label).to eq 'Blog'
+      end
+
+      it "children should hold a reference to their parent" do
+        expect(item["Blog"].parent).to eq item
+      end
+    end
+
+    describe "#id" do
+      it "should be normalized" do
+        expect(MenuItem.new(id: "Foo Bar").id).to eq "foo_bar"
+      end
+
+      it "should not accept Procs" do
+        expect{ MenuItem.new(id: proc{"Dynamic"}).id }.to raise_error TypeError
+      end
+    end
+
+  end
+end

data/spec/unit/menu_spec.rb

@@ -0,0 +1,60 @@
+require 'rails_helper'
+require 'active_admin/menu'
+require 'active_admin/menu_item'
+
+include ActiveAdmin
+
+RSpec.describe ActiveAdmin::Menu do
+
+  context "with no items" do
+    it "should have an empty item collection" do
+      menu = Menu.new
+      expect(menu.items).to be_empty
+    end
+
+    it "should accept new items" do
+      menu = Menu.new
+      menu.add label: "Dashboard"
+      expect(menu.items.first.label).to eq "Dashboard"
+    end
+  end
+
+  context "with many items" do
+    let(:menu) do
+      Menu.new do |m|
+        m.add label: "Dashboard"
+        m.add label: "Blog"
+      end
+    end
+
+    it "should give access to the menu item as an array" do
+      expect(menu['Dashboard'].label).to eq 'Dashboard'
+    end
+  end
+
+  describe "adding items with children" do
+    it "should add an empty item if the parent does not exist" do
+      menu = Menu.new
+      menu.add parent: "Admin", label: "Users"
+
+      expect(menu["Admin"]["Users"]).to be_an_instance_of(ActiveAdmin::MenuItem)
+    end
+
+    it "should add a child to a parent if it exists" do
+      menu = Menu.new
+      menu.add parent: "Admin", label: "Users"
+      menu.add parent: "Admin", label: "Projects"
+
+      expect(menu["Admin"]["Projects"]).to be_an_instance_of(ActiveAdmin::MenuItem)
+    end
+
+    it "should assign children regardless of resource file load order" do
+      menu = Menu.new
+      menu.add parent: "Users", label: "Posts"
+      menu.add label: "Users", url: "/some/url"
+
+      expect(menu["Users"].url).to eq "/some/url"
+      expect(menu["Users"]["Posts"]).to be_a ActiveAdmin::MenuItem
+    end
+  end
+end

data/spec/unit/namespace/authorization_spec.rb

@@ -0,0 +1,27 @@
+require 'rails_helper'
+
+RSpec.describe ActiveAdmin::Resource, "authorization" do
+
+  let(:app){ ActiveAdmin::Application.new }
+  let(:namespace){ ActiveAdmin::Namespace.new(app, :admin) }
+  let(:auth){ double }
+
+  describe "authorization_adapter" do
+
+    it "should return AuthorizationAdapter by default" do
+      expect(app.authorization_adapter).to       eq ActiveAdmin::AuthorizationAdapter
+      expect(namespace.authorization_adapter).to eq ActiveAdmin::AuthorizationAdapter
+    end
+
+    it "should be settable on the namespace" do
+      namespace.authorization_adapter = auth
+      expect(namespace.authorization_adapter).to eq auth
+    end
+
+    it "should be settable on the application" do
+      app.authorization_adapter = auth
+      expect(app.authorization_adapter).to eq auth
+    end
+
+  end
+end

data/spec/unit/namespace/register_page_spec.rb

@@ -0,0 +1,99 @@
+require 'rails_helper'
+
+RSpec.describe ActiveAdmin::Namespace, "registering a page" do
+  let(:application){ ActiveAdmin::Application.new }
+  let(:namespace){ ActiveAdmin::Namespace.new(application, :admin) }
+  let(:menu){ namespace.fetch_menu(:default) }
+
+  context "with no configuration" do
+    before do
+      namespace.register_page "Status"
+    end
+
+    it "should store the namespaced registered configuration" do
+      expect(namespace.resources.keys).to include('Status')
+    end
+
+    it "should create a new controller in the default namespace" do
+      expect(defined?(Admin::StatusController)).to eq 'constant'
+    end
+
+    it "should create a menu item" do
+      expect(menu["Status"]).to be_an_instance_of(ActiveAdmin::MenuItem)
+    end
+  end
+
+  context "with a block configuration" do
+    it "should be evaluated in the dsl" do
+      expect{ |block|
+        namespace.register_page "Status", &block
+      }.to yield_control
+    end
+  end
+
+  describe "adding to the menu" do
+    describe "adding as a top level item" do
+      before do
+        namespace.register_page "Status"
+      end
+
+      it "should add a new menu item" do
+        expect(menu['Status']).to_not eq nil
+      end
+    end
+
+    describe "adding as a child" do
+      before do
+        namespace.register_page "Status" do
+          menu parent: 'Extra'
+        end
+      end
+
+      it "should generate the parent menu item" do
+        expect(menu['Extra']).to_not eq nil
+      end
+
+      it "should generate its own child item" do
+        expect(menu['Extra']['Status']).to_not eq nil
+      end
+    end
+
+    describe "disabling the menu" do
+      before do
+        namespace.register_page "Status" do
+          menu false
+        end
+      end
+
+      it "should not create a menu item" do
+        expect(menu["Status"]).to eq nil
+      end
+    end # describe "disabling the menu"
+  end # describe "adding to the menu"
+
+  describe "adding as a belongs to" do
+    context "when not optional" do
+      before do
+        namespace.register_page "Reports" do
+          belongs_to :author
+        end
+      end
+
+      it "should be excluded from the menu" do
+        expect(menu["Reports"]).to be_nil
+      end
+    end
+
+    context "when optional" do
+      before do
+        namespace.register_page "Reports" do
+          belongs_to :author, optional: true
+        end
+      end
+
+      it "should be in the menu" do
+        expect(menu["Reports"]).to_not be_nil
+      end
+    end
+  end # describe "adding as a belongs to"
+end

data/spec/unit/namespace/register_resource_spec.rb

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