activeadmin 1.1.0 → 2.14.0

data/spec/unit/routing_spec.rb

@@ -1,211 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin, "Routing", type: :routing do
-
-  before do
-    load_defaults!
-    reload_routes!
-  end
-
-  after :all do
-    load_defaults!
-    reload_routes!
-  end
-
-  let(:namespaces) { ActiveAdmin.application.namespaces }
-
-  it "should only have the namespaces necessary for route testing" do
-    expect(namespaces.names).to eq [:admin]
-  end
-
-  it "should route to the admin dashboard" do
-    expect(get('/admin')).to route_to 'admin/dashboard#index'
-  end
-
-  describe "root path helper" do
-    context "when in admin namespace" do
-      it "should be admin_root_path" do
-        expect(admin_root_path).to eq "/admin"
-      end
-    end
-  end
-
-  describe "route_options" do
-    context "with a custom path set in route_options" do
-      before do
-        namespaces[:admin].route_options = { path: '/custom-path' }
-        reload_routes!
-      end
-
-      after do
-        namespaces[:admin].route_options = {}
-        reload_routes!
-      end
-
-      it "should route using the custom path" do
-        expect(admin_posts_path).to eq "/custom-path/posts"
-      end
-    end
-  end
-
-  describe "standard resources" do
-    context "when in admin namespace" do
-      it "should route the index path" do
-        expect(admin_posts_path).to eq "/admin/posts"
-      end
-
-      it "should route the show path" do
-        expect(admin_post_path(1)).to eq "/admin/posts/1"
-      end
-
-      it "should route the new path" do
-        expect(new_admin_post_path).to eq "/admin/posts/new"
-      end
-
-      it "should route the edit path" do
-        expect(edit_admin_post_path(1)).to eq "/admin/posts/1/edit"
-      end
-    end
-
-    context "when in root namespace" do
-      before(:each) do
-        load_resources { ActiveAdmin.register(Post, namespace: false) }
-      end
-
-      after(:each) do
-        namespaces.instance_variable_get(:@namespaces).delete(:root)
-      end
-
-      it "should route the index path" do
-        expect(posts_path).to eq "/posts"
-      end
-
-      it "should route the show path" do
-        expect(post_path(1)).to eq "/posts/1"
-      end
-
-      it "should route the new path" do
-        expect(new_post_path).to eq "/posts/new"
-      end
-
-      it "should route the edit path" do
-        expect(edit_post_path(1)).to eq "/posts/1/edit"
-      end
-    end
-
-    context "with member action" do
-      context "without an http verb" do
-        before do
-          load_resources do
-            ActiveAdmin.register(Post){ member_action "do_something" }
-          end
-        end
-
-        it "should default to GET" do
-          expect({get: "/admin/posts/1/do_something"}).to      be_routable
-          expect({post: "/admin/posts/1/do_something"}).to_not be_routable
-        end
-      end
-
-      context "with one http verb" do
-        before do
-          load_resources do
-            ActiveAdmin.register(Post){ member_action "do_something", method: :post }
-          end
-        end
-
-        it "should properly route" do
-          expect({post: "/admin/posts/1/do_something"}).to be_routable
-        end
-      end
-
-      context "with two http verbs" do
-        before do
-          load_resources do
-            ActiveAdmin.register(Post){ member_action "do_something", method: [:put, :delete] }
-          end
-        end
-
-        it "should properly route the first verb" do
-          expect({put: "/admin/posts/1/do_something"}).to be_routable
-        end
-
-        it "should properly route the second verb" do
-          expect({delete: "/admin/posts/1/do_something"}).to be_routable
-        end
-      end
-    end
-  end
-
-  describe "belongs to resource" do
-    it "should route the nested index path" do
-      expect(admin_user_posts_path(1)).to eq "/admin/users/1/posts"
-    end
-
-    it "should route the nested show path" do
-      expect(admin_user_post_path(1, 2)).to eq "/admin/users/1/posts/2"
-    end
-
-    it "should route the nested new path" do
-      expect(new_admin_user_post_path(1)).to eq "/admin/users/1/posts/new"
-    end
-
-    it "should route the nested edit path" do
-      expect(edit_admin_user_post_path(1, 2)).to eq "/admin/users/1/posts/2/edit"
-    end
-
-    context "with collection action" do
-      before do
-        load_resources do
-          ActiveAdmin.register(Post) do
-            belongs_to :user, optional: true
-          end
-          ActiveAdmin.register(User) do
-            collection_action "do_something"
-          end
-        end
-      end
-
-      it "should properly route the collection action" do
-        expect({ get: "/admin/users/do_something" }).to \
-          route_to({ controller: 'admin/users', action: 'do_something'})
-      end
-    end
-  end
-
-  describe "page" do
-    context "when default namespace" do
-      before(:each) do
-        load_resources { ActiveAdmin.register_page("Chocolate I lØve You!") }
-      end
-
-      it "should route to the page under /admin" do
-        expect(admin_chocolate_i_love_you_path).to eq "/admin/chocolate_i_love_you"
-      end
-    end
-
-    context "when in the root namespace" do
-      before(:each) do
-        load_resources { ActiveAdmin.register_page("Chocolate I lØve You!", namespace: false) }
-      end
-
-      after(:each) do
-        namespaces.instance_variable_get(:@namespaces).delete(:root)
-      end
-
-      it "should route to page under /" do
-        expect(chocolate_i_love_you_path).to eq "/chocolate_i_love_you"
-      end
-    end
-
-    context "when singular page name" do
-      before(:each) do
-        load_resources { ActiveAdmin.register_page("Log") }
-      end
-
-      it "should not inject _index_ into the route name" do
-        expect(admin_log_path).to eq "/admin/log"
-      end
-    end
-  end
-end

data/spec/unit/scope_spec.rb

@@ -1,209 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::Scope do
-
-  describe "creating a scope" do
-    subject{ scope }
-
-    context "when just a scope method" do
-      let(:scope) { ActiveAdmin::Scope.new :published }
-
-      describe '#name' do
-        subject { super().name }
-        it      { is_expected.to eq("Published")}
-      end
-
-      describe '#id' do
-        subject { super().id }
-        it      { is_expected.to eq("published")}
-      end
-
-      describe '#scope_method' do
-        subject { super().scope_method }
-        it      { is_expected.to eq(:published) }
-      end
-    end
-
-    context "when scope method is :all" do
-      let(:scope) { ActiveAdmin::Scope.new :all }
-
-      describe '#name' do
-        subject { super().name }
-        it      { is_expected.to eq("All")}
-      end
-
-      describe '#id' do
-        subject { super().id }
-        it      { is_expected.to eq("all")}
-      end
-      # :all does not return a chain but an array of active record
-      # instances. We set the scope_method to nil then.
-
-      describe '#scope_method' do
-        subject { super().scope_method }
-        it      { is_expected.to eq(nil) }
-      end
-
-      describe '#scope_block' do
-        subject { super().scope_block }
-        it      { is_expected.to eq(nil) }
-      end
-    end
-
-    context 'when a name and scope method is :all' do
-      let(:scope) { ActiveAdmin::Scope.new 'Tous', :all }
-
-      describe '#name' do
-        subject { super().name }
-        it      { is_expected.to eq 'Tous' }
-      end
-
-      describe '#scope_method' do
-        subject { super().scope_method }
-        it      { is_expected.to eq nil }
-      end
-
-      describe '#scope_block' do
-        subject { super().scope_block }
-        it      { is_expected.to eq nil }
-      end
-    end
-
-    context "when a name and scope method" do
-      let(:scope) { ActiveAdmin::Scope.new "With API Access", :with_api_access }
-
-      describe '#name' do
-        subject { super().name }
-        it      { is_expected.to eq("With API Access")}
-      end
-
-      describe '#id' do
-        subject { super().id }
-        it      { is_expected.to eq("with_api_access")}
-      end
-
-      describe '#scope_method' do
-        subject { super().scope_method }
-        it      { is_expected.to eq(:with_api_access) }
-      end
-    end
-
-    context "when a name and scope block" do
-      let(:scope) { ActiveAdmin::Scope.new("My Scope"){|s| s } }
-
-      describe '#name' do
-        subject { super().name }
-        it      { is_expected.to eq("My Scope")}
-      end
-
-      describe '#id' do
-        subject { super().id }
-        it      { is_expected.to eq("my_scope")}
-      end
-
-      describe '#scope_method' do
-        subject { super().scope_method }
-        it      { is_expected.to eq(nil) }
-      end
-
-      describe '#scope_block' do
-        subject { super().scope_block }
-        it      { is_expected.to be_a(Proc)}
-      end
-    end
-
-    context "when a name has a space and lowercase" do
-      let(:scope) { ActiveAdmin::Scope.new("my scope") }
-
-      describe '#name' do
-        subject { super().name }
-        it      { is_expected.to eq("my scope")}
-      end
-
-      describe '#id' do
-        subject { super().id }
-        it      { is_expected.to eq("my_scope")}
-      end
-    end
-
-    context "with a proc as the label" do
-      it "should raise an exception if a second argument isn't provided" do
-        expect{
-          ActiveAdmin::Scope.new proc{ Date.today.strftime '%A' }
-        }.to raise_error 'A string/symbol is required as the second argument if your label is a proc.'
-      end
-
-      it "should properly render the proc" do
-        scope = ActiveAdmin::Scope.new proc{ Date.today.strftime '%A' }, :foobar
-        expect(scope.name.call).to eq Date.today.strftime '%A'
-      end
-    end
-
-    context "with scope method and localizer" do
-      let(:localizer) do
-        loc = double(:localizer)
-        allow(loc).to receive(:t).with(:published, scope: 'scopes').and_return("All published")
-        loc
-      end
-      let(:scope) { ActiveAdmin::Scope.new :published, :published, localizer: localizer }
-
-      describe '#name' do
-        subject { super().name }
-        it { is_expected.to eq("All published")}
-      end
-
-      describe '#id' do
-        subject { super().id }
-        it { is_expected.to eq("published")}
-      end
-
-      describe '#scope_method' do
-        subject { super().scope_method }
-        it { is_expected.to eq(:published) }
-      end
-    end
-
-  end # describe "creating a scope"
-
-  describe "#display_if_block" do
-    it "should return true by default" do
-      scope = ActiveAdmin::Scope.new(:default)
-      expect(scope.display_if_block.call).to eq true
-    end
-
-    it "should return the :if block if set" do
-      scope = ActiveAdmin::Scope.new(:with_block, nil, if: proc{ false })
-      expect(scope.display_if_block.call).to eq false
-    end
-  end
-
-  describe "#default" do
-    it "should accept a boolean" do
-      scope = ActiveAdmin::Scope.new(:method, nil, default: true)
-      expect(scope.default_block).to eq true
-    end
-
-    it "should default to a false #default_block" do
-      scope = ActiveAdmin::Scope.new(:method, nil)
-      expect(scope.default_block.call).to eq false
-    end
-
-    it "should store the :default proc" do
-      scope = ActiveAdmin::Scope.new(:with_block, nil, default: proc{ true })
-      expect(scope.default_block.call).to eq true
-    end
-  end
-
-  describe "show_count" do
-    it "should allow setting of show_count to prevent showing counts" do
-      scope = ActiveAdmin::Scope.new(:default, nil, show_count: false)
-      expect(scope.show_count).to eq false
-    end
-
-    it "should set show_count to true if not passed in" do
-      scope = ActiveAdmin::Scope.new(:default)
-      expect(scope.show_count).to eq true
-    end
-  end
-
-end

data/spec/unit/settings_spec.rb

@@ -1,117 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::Settings do
-
-  subject{ Class.new{ include ActiveAdmin::Settings } }
-
-  it{ is_expected.to respond_to :setting }
-  it{ is_expected.to respond_to :deprecated_setting }
-  it{ is_expected.to respond_to :default_settings }
-
-  describe "class API" do
-    it "should create settings" do
-      subject.setting :foo, 'bar'
-      expect(subject.default_settings[:foo]).to eq 'bar'
-    end
-
-    it "should create deprecated settings" do
-      expect(ActiveAdmin::Deprecation).to receive(:deprecate).twice
-      subject.deprecated_setting :baz, 32
-      expect(subject.default_settings[:baz]).to eq 32
-    end
-  end
-
-  describe "instance API" do
-
-    before do
-      subject.setting :foo, 'bar'
-      subject.deprecated_setting :baz, 32
-    end
-    let(:instance) { subject.new }
-
-    it "should have access to a default value" do
-      expect(instance.foo).to eq 'bar'
-      instance.foo = 'qqq'
-      expect(instance.foo).to eq 'qqq'
-    end
-
-    it "should have access to a deprecated value" do
-      expect(ActiveAdmin::Deprecation).to receive(:warn).exactly(3).times
-      expect(instance.baz).to eq 32
-      instance.baz = [45]
-      expect(instance.baz).to eq [45]
-    end
-  end
-
-end
-
-RSpec.describe ActiveAdmin::Settings::Inheritance do
-
-  subject do
-    Class.new do
-      include ActiveAdmin::Settings
-      include ActiveAdmin::Settings::Inheritance
-    end
-  end
-
-  it{ is_expected.to respond_to :settings_inherited_by }
-  it{ is_expected.to respond_to :inheritable_setting }
-  it{ is_expected.to respond_to :deprecated_inheritable_setting }
-
-  let(:heir) { Class.new }
-
-  before do
-    subject.settings_inherited_by heir
-  end
-
-  describe "class API" do
-    it "should add setting to an heir" do
-      subject.inheritable_setting :one, 2
-      expect(heir.default_settings[:one]).to eq 2
-    end
-
-    it "should add deprecated setting to an heir" do
-      expect(ActiveAdmin::Deprecation).to receive(:deprecate).exactly(4).times
-      subject.deprecated_inheritable_setting :three, 4
-      expect(heir.default_settings[:three]).to eq 4
-    end
-  end
-
-  describe "instance API" do
-    describe "the setter `config.left =`" do
-      before{ subject.inheritable_setting :left, :right }
-      it "should work" do
-        config = heir.new
-        config.left = :none
-        expect(config.left).to eq :none
-      end
-    end
-
-    describe "the getter `config.left`" do
-      before{ subject.inheritable_setting :left, :right }
-      it "should work" do
-        expect(heir.new.left).to eq :right
-      end
-    end
-
-    describe "the getter with question-mark `config.left?`" do
-      {
-        "nil" => [nil, false],
-        "false" => [false, false],
-        "true" => [true, true],
-        "string" => ["string", true],
-        "empty string" => ["", false],
-        "array" => [[1, 2], true],
-        "empty array" => [[], false]
-      }.each do |context, (value, result)|
-        context "with a #{context} value" do
-          before{ subject.inheritable_setting :left, value }
-          it "should be #{result}" do
-            expect(heir.new.left?).to eq result
-          end
-        end
-      end
-    end
-  end
-
-end

data/spec/unit/view_factory_spec.rb

@@ -1,19 +0,0 @@
-require 'rails_helper'
-
-def it_should_have_view(key, value)
-  it "should have #{value} for view key '#{key}'" do
-    expect(subject.send(key)).to eq value
-  end
-end
-
-RSpec.describe ActiveAdmin::ViewFactory do
-
-  it_should_have_view :global_navigation,    ActiveAdmin::Views::TabbedNavigation
-  it_should_have_view :utility_navigation,   ActiveAdmin::Views::TabbedNavigation
-  it_should_have_view :site_title,           ActiveAdmin::Views::SiteTitle
-  it_should_have_view :action_items,         ActiveAdmin::Views::ActionItems
-  it_should_have_view :header,               ActiveAdmin::Views::Header
-  it_should_have_view :blank_slate,          ActiveAdmin::Views::BlankSlate
-  it_should_have_view :layout,               ActiveAdmin::Views::Pages::Layout
-
-end