activeadmin-rails 1.7.0

data/spec/unit/routing_spec.rb

@@ -0,0 +1,211 @@
+require 'rails_helper'
+
+RSpec.describe "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

@@ -0,0 +1,225 @@
+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
+
+  describe "group" do
+    it "should default to nil" do
+      scope = ActiveAdmin::Scope.new(:default)
+      expect(scope.group).to eq nil
+    end
+
+    it "should accept a symbol to assign a group to the scope" do
+      scope = ActiveAdmin::Scope.new(:default, nil, group: :test)
+      expect(scope.group).to eq :test
+    end
+
+    it "should accept a string to assign a group to the scope" do
+      scope = ActiveAdmin::Scope.new(:default, nil, group: "test")
+      expect(scope.group).to eq :test
+    end
+  end
+end

data/spec/unit/settings_node_spec.rb

@@ -0,0 +1,26 @@
+require 'rails_helper'
+
+RSpec.describe ActiveAdmin::SettingsNode do
+  subject { ActiveAdmin::SettingsNode.build }
+  let!(:child) { ActiveAdmin::SettingsNode.build(subject) }
+
+  context 'parent setting includes foo' do
+    before { subject.register :foo, true }
+
+    it 'returns parent settings' do
+      expect(child.foo).to eq true
+    end
+
+    it 'fails if setting undefined' do
+      expect do
+        child.bar
+      end.to raise_error(NoMethodError)
+    end
+
+    context 'child overrides foo' do
+      before { child.foo = false }
+
+      it { expect(child.foo).to eq false }
+    end
+  end
+end

data/spec/unit/view_factory_spec.rb

@@ -0,0 +1,13 @@
+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 :site_title,           ActiveAdmin::Views::SiteTitle
+
+end