activeadministration 0.0.1

data/spec/unit/routing_spec.rb

@@ -0,0 +1,172 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe ActiveAdmin, "Routing", type: :routing do
+
+  before do
+    load_defaults!
+    reload_routes!
+  end
+
+  it "should only have the namespaces necessary for route testing" do
+    ActiveAdmin.application.namespaces.keys.should eq [:admin, :root]
+  end
+
+  it "should route to the admin dashboard" do
+    expect(get('/admin')).to route_to 'admin/dashboard#index'
+  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
+
+      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
+
+      context "when in the root namespace" do
+        before(:each) do
+          load_resources { ActiveAdmin.register_page("Chocolate I lØve You!", namespace: false) }
+        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
+end

data/spec/unit/scope_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+describe ActiveAdmin::Scope do
+
+  describe "creating a scope" do
+    subject{ scope }
+
+    context "when just a scope method" do
+      let(:scope)        { ActiveAdmin::Scope.new :published }
+      its(:name)         { should == "Published"}
+      its(:id)           { should == "published"}
+      its(:scope_method) { should == :published }
+    end
+
+    context "when scope method is :all" do
+      let(:scope)        { ActiveAdmin::Scope.new :all }
+      its(:name)         { should == "All"}
+      its(:id)           { should == "all"}
+      # :all does not return a chain but an array of active record
+      # instances. We set the scope_method to nil then.
+      its(:scope_method) { should == nil }
+      its(:scope_block)  { should == nil }
+    end
+
+    context 'when a name and scope method is :all' do
+      let(:scope)        { ActiveAdmin::Scope.new 'Tous', :all }
+      its(:name)         { should eq 'Tous' }
+      its(:scope_method) { should be_nil }
+      its(:scope_block)  { should be_nil }
+    end
+
+    context "when a name and scope method" do
+      let(:scope)        { ActiveAdmin::Scope.new "With API Access", :with_api_access }
+      its(:name)         { should == "With API Access"}
+      its(:id)           { should == "with_api_access"}
+      its(:scope_method) { should == :with_api_access }
+    end
+
+    context "when a name and scope block" do
+      let(:scope)        { ActiveAdmin::Scope.new("My Scope"){|s| s } }
+      its(:name)         { should == "My Scope"}
+      its(:id)           { should == "my_scope"}
+      its(:scope_method) { should == nil }
+      its(:scope_block)  { should be_a(Proc)}
+    end
+
+    context "when a name has a space and lowercase" do
+      let(:scope)        { ActiveAdmin::Scope.new("my scope") }
+      its(:name)         { should == "my scope"}
+      its(:id)           { should == "my_scope"}
+    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
+      end
+
+      it "should properly render the proc" do
+        scope = ActiveAdmin::Scope.new proc{ Date.today.strftime '%A' }, :foobar
+        expect(scope.name).to eq Date.today.strftime '%A'
+      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

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe ActiveAdmin::Settings do
+
+  subject{ Class.new{ include ActiveAdmin::Settings } }
+
+  it{ should respond_to :setting }
+  it{ should respond_to :deprecated_setting }
+  it{ should 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
+
+
+describe ActiveAdmin::Settings::Inheritance do
+
+  subject do
+    Class.new do
+      include ActiveAdmin::Settings
+      include ActiveAdmin::Settings::Inheritance
+    end
+  end
+
+  it{ should respond_to :settings_inherited_by }
+  it{ should respond_to :inheritable_setting }
+  it{ should 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
+    before{ subject.inheritable_setting :left, :right }
+    it "should work" do
+      expect(heir.new.left).to eq :right
+    end
+  end
+
+end

data/spec/unit/view_factory_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_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
+
+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 :action_list_popover,  ActiveAdmin::Views::ActionListPopover
+
+  it_should_have_view :layout,               ActiveAdmin::Views::Pages::Layout
+
+end

data/spec/unit/view_helpers/breadcrumbs_spec.rb

@@ -0,0 +1,180 @@
+require 'spec_helper'
+
+describe "Breadcrumbs" do
+
+  include ActiveAdmin::ViewHelpers
+
+  describe "generating a trail from paths" do
+
+    def params; {}; end
+    def link_to(name, url); {name: name, path: url}; end
+
+    let(:user)        { double  display_name: 'Jane Doe' }
+    let(:user_config) { double  find_resource: user,
+                                resource_name: double(route_key: 'users') }
+    let(:post)        { double  display_name: 'Hello World' }
+    let(:post_config) { double  find_resource: post,
+                                belongs_to_config: double(target: user_config),
+                                resource_name: double(route_key: 'posts') }
+
+    let :active_admin_config do
+      post_config
+    end
+
+    let(:trail) { breadcrumb_links(path) }
+
+    context "when request '/admin'" do
+      let(:path) { "/admin" }
+
+      it "should not have any items" do
+        expect(trail.size).to eq 0
+      end
+    end
+
+    context "when path '/admin/users'" do
+      let(:path) { "/admin/users" }
+
+      it "should have one item" do
+        expect(trail.size).to eq 1
+      end
+      it "should have a link to /admin" do
+        expect(trail[0][:name]).to eq "Admin"
+        expect(trail[0][:path]).to eq "/admin"
+      end
+    end
+
+    context "when path '/admin/users/1'" do
+      let(:path) { "/admin/users/1" }
+
+      it "should have 2 items" do
+        expect(trail.size).to eq 2
+      end
+      it "should have a link to /admin" do
+        expect(trail[0][:name]).to eq "Admin"
+        expect(trail[0][:path]).to eq "/admin"
+      end
+      it "should have a link to /admin/users" do
+        expect(trail[1][:name]).to eq "Users"
+        expect(trail[1][:path]).to eq "/admin/users"
+      end
+    end
+
+    context "when path '/admin/users/1/posts'" do
+      let(:path) { "/admin/users/1/posts" }
+
+      it "should have 3 items" do
+        expect(trail.size).to eq 3
+      end
+      it "should have a link to /admin" do
+        expect(trail[0][:name]).to eq "Admin"
+        expect(trail[0][:path]).to eq "/admin"
+      end
+      it "should have a link to /admin/users" do
+        expect(trail[1][:name]).to eq "Users"
+        expect(trail[1][:path]).to eq "/admin/users"
+      end
+
+      context "when User.find(1) doesn't exist" do
+        before { user_config.stub(find_resource: nil) }
+        it "should have a link to /admin/users/1" do
+          expect(trail[2][:name]).to eq "1"
+          expect(trail[2][:path]).to eq "/admin/users/1"
+        end
+      end
+
+      context "when User.find(1) does exist" do
+        it "should have a link to /admin/users/1 using display name" do
+          expect(trail[2][:name]).to eq "Jane Doe"
+          expect(trail[2][:path]).to eq "/admin/users/1"
+        end
+      end
+    end
+
+    context "when path '/admin/users/4e24d6249ccf967313000000/posts'" do
+      let(:path) { "/admin/users/4e24d6249ccf967313000000/posts" }
+
+      it "should have 3 items" do
+        expect(trail.size).to eq 3
+      end
+      it "should have a link to /admin" do
+        expect(trail[0][:name]).to eq "Admin"
+        expect(trail[0][:path]).to eq "/admin"
+      end
+      it "should have a link to /admin/users" do
+        expect(trail[1][:name]).to eq "Users"
+        expect(trail[1][:path]).to eq "/admin/users"
+      end
+
+      context "when User.find(4e24d6249ccf967313000000) doesn't exist" do
+        before { user_config.stub(find_resource: nil) }
+        it "should have a link to /admin/users/4e24d6249ccf967313000000" do
+          expect(trail[2][:name]).to eq "4e24d6249ccf967313000000"
+          expect(trail[2][:path]).to eq "/admin/users/4e24d6249ccf967313000000"
+        end
+      end
+
+      context "when User.find(4e24d6249ccf967313000000) does exist" do
+        before do
+          user_config.stub find_resource: double(display_name: 'Hello :)')
+        end
+        it "should have a link to /admin/users/4e24d6249ccf967313000000 using display name" do
+          expect(trail[2][:name]).to eq "Hello :)"
+          expect(trail[2][:path]).to eq "/admin/users/4e24d6249ccf967313000000"
+        end
+      end
+    end
+
+    context "when path '/admin/users/1/coments/1'" do
+      let(:path) { "/admin/users/1/posts/1" }
+
+      it "should have 4 items" do
+        expect(trail.size).to eq 4
+      end
+      it "should have a link to /admin" do
+        expect(trail[0][:name]).to eq "Admin"
+        expect(trail[0][:path]).to eq "/admin"
+      end
+      it "should have a link to /admin/users" do
+        expect(trail[1][:name]).to eq "Users"
+        expect(trail[1][:path]).to eq "/admin/users"
+      end
+      it "should have a link to /admin/users/1" do
+        expect(trail[2][:name]).to eq "Jane Doe"
+        expect(trail[2][:path]).to eq "/admin/users/1"
+      end
+      it "should have a link to /admin/users/1/posts" do
+        expect(trail[3][:name]).to eq "Posts"
+        expect(trail[3][:path]).to eq "/admin/users/1/posts"
+      end
+    end
+
+    context "when path '/admin/users/1/coments/1/edit'" do
+      let(:path) { "/admin/users/1/posts/1/edit" }
+
+      it "should have 5 items" do
+        expect(trail.size).to eq 5
+      end
+      it "should have a link to /admin" do
+        expect(trail[0][:name]).to eq "Admin"
+        expect(trail[0][:path]).to eq "/admin"
+      end
+      it "should have a link to /admin/users" do
+        expect(trail[1][:name]).to eq "Users"
+        expect(trail[1][:path]).to eq "/admin/users"
+      end
+      it "should have a link to /admin/users/1" do
+        expect(trail[2][:name]).to eq "Jane Doe"
+        expect(trail[2][:path]).to eq "/admin/users/1"
+      end
+      it "should have a link to /admin/users/1/posts" do
+        expect(trail[3][:name]).to eq "Posts"
+        expect(trail[3][:path]).to eq "/admin/users/1/posts"
+      end
+      it "should have a link to /admin/users/1/posts/1" do
+        expect(trail[4][:name]).to eq "Hello World"
+        expect(trail[4][:path]).to eq "/admin/users/1/posts/1"
+      end
+    end
+
+  end
+end