activeadmin 1.1.0 → 2.4.0

data/spec/unit/generators/install_spec.rb

@@ -1,31 +0,0 @@
-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.coffee" do
-      path = Rails.root + "app/assets/javascripts/active_admin.js.coffee"
-
-      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

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

@@ -1,35 +0,0 @@
-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/helpers/settings_spec.rb

@@ -1,30 +0,0 @@
-require 'rails_helper'
-require 'active_admin/helpers/settings'
-
-RSpec.describe ActiveAdmin::Settings do
-
-  # A Class with settings module included
-  let(:klass) do
-    Class.new do
-      include ActiveAdmin::Settings
-    end
-  end
-
-  it "should add a new setting with a default" do
-    klass.setting :my_setting, "Hello World"
-    expect(klass.default_settings[:my_setting]).to eq "Hello World"
-  end
-
-  it "should initialize the defaults" do
-    klass.setting :my_setting, "Hello World"
-    expect(klass.new.my_setting).to eq "Hello World"
-  end
-
-  it "should support settings of nil" do
-    klass.setting :my_setting, :some_val
-    inst = klass.new
-    inst.my_setting = nil
-    expect(inst.my_setting).to eq nil
-  end
-
-end

data/spec/unit/i18n_spec.rb

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

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

@@ -1,62 +0,0 @@
-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
-
-  describe "#on_build" do
-
-    it "runs a callback when fetching a menu" do
-      menus.on_build do |m|
-        m.add :default, label: "Hello World"
-      end
-
-      expect(menus.fetch(:default)["Hello World"]).to_not eq nil
-    end
-
-    it "re-runs the callbacks when the menu is cleared" do
-      menus.on_build do |m|
-        m.add :default, label: "Hello World"
-      end
-
-      expect(menus.fetch(:default)["Hello World"]).to_not eq nil
-      menus.clear!
-      expect(menus.fetch(:default)["Hello World"]).to_not eq nil
-    end
-
-  end
-
-end

data/spec/unit/menu_item_spec.rb

@@ -1,141 +0,0 @@
-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
-
-    context "conditional display" do
-      it "should store a Proc internally and evaluate it when requested" do
-        item = MenuItem.new
-        expect(item.instance_variable_get(:@should_display)).to be_a Proc
-        expect(item.display?).to_not be_a Proc
-      end
-
-      it "should show the item by default" do
-        expect(MenuItem.new.display?).to eq true
-      end
-
-      it "should hide the item" do
-        expect(MenuItem.new(if: proc{false}).display?).to eq false
-      end
-    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 "should sort items based on priority and name" do
-        expect(item.items[0].label).to eq 'Users'
-        expect(item.items[1].label).to eq 'Settings'
-        expect(item.items[2].label).to eq 'Blog'
-        expect(item.items[3].label).to eq 'Cars'
-        expect(item.items[4].label).to eq 'Analytics'
-      end
-
-      it "children should hold a reference to their parent" do
-        expect(item["Blog"].parent).to eq item
-      end
-    end
-
-    describe "accessing ancestory" do
-      let(:item){ MenuItem.new label: "Blog" }
-
-      context "with no parent" do
-        it "should return an empty array" do
-          expect(item.ancestors).to eq []
-        end
-      end
-
-      context "with one parent" do
-        let(:sub_item) do
-          item.add label: "Create New"
-          item["Create New"]
-        end
-        it "should return an array with the parent" do
-          expect(sub_item.ancestors).to eq [item]
-        end
-      end
-
-      context "with many parents" do
-        before(:each) do
-          c1 = {label: "C1"}
-          c2 = {label: "C2"}
-          c3 = {label: "C3"}
-
-          item.add(c1).add(c2).add(c3)
-
-          item
-        end
-        let(:sub_item){ item["C1"]["C2"]["C3"] }
-        it "should return an array with the parents in reverse order" do
-          expect(sub_item.ancestors).to eq [item["C1"]["C2"], item["C1"], item]
-        end
-      end
-    end # accessing ancestory
-
-    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

@@ -1,71 +0,0 @@
-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
-
-  describe "sorting items" do
-    it "should sort children by the result of their label proc" do
-      menu = Menu.new
-      menu.add label: proc{ "G" }, id: "not related 1"
-      menu.add label: proc{ "B" }, id: "not related 2"
-      menu.add label: proc{ "A" }, id: "not related 3"
-
-      expect(menu.items.map(&:label)).to eq %w[A B G]
-    end
-  end
-end

data/spec/unit/namespace/authorization_spec.rb

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

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