activeadmin-orac 1.0.0.pre4

data/spec/unit/resource_spec.rb

@@ -0,0 +1,337 @@
+require 'rails_helper'
+require File.expand_path('config_shared_examples', File.dirname(__FILE__))
+
+module ActiveAdmin
+  describe Resource do
+
+    it_should_behave_like "ActiveAdmin::Resource"
+    before { load_defaults! }
+
+    let(:application){ ActiveAdmin::Application.new }
+    let(:namespace){ Namespace.new(application, :admin) }
+
+    def config(options = {})
+      @config ||= Resource.new(namespace, Category, options)
+    end
+
+    it { respond_to :resource_class }
+
+    describe "#resource_table_name" do
+      it "should return the resource's table name" do
+        expect(config.resource_table_name).to eq '"categories"'
+      end
+      context "when the :as option is given" do
+        it "should return the resource's table name" do
+          expect(config(as: "My Category").resource_table_name).to eq '"categories"'
+        end
+      end
+    end
+
+    describe "#resource_column_names" do
+      it "should return the resource's column names" do
+        expect(config.resource_column_names).to eq Category.column_names
+      end
+    end
+
+    describe '#decorator_class' do
+      it 'returns nil by default' do
+        expect(config.decorator_class).to eq nil
+      end
+      context 'when a decorator is defined' do
+        let(:resource) { namespace.register(Post) { decorate_with PostDecorator } }
+        specify '#decorator_class_name should return PostDecorator' do
+          expect(resource.decorator_class_name).to eq '::PostDecorator'
+        end
+
+        it 'returns the decorator class' do
+          expect(resource.decorator_class).to eq PostDecorator
+        end
+      end
+    end
+
+
+    describe "controller name" do
+      it "should return a namespaced controller name" do
+        expect(config.controller_name).to eq "Admin::CategoriesController"
+      end
+      context "when non namespaced controller" do
+        let(:namespace){ ActiveAdmin::Namespace.new(application, :root) }
+        it "should return a non namespaced controller name" do
+          expect(config.controller_name).to eq "CategoriesController"
+        end
+      end
+    end
+
+    describe "#include_in_menu?" do
+      let(:namespace){ ActiveAdmin::Namespace.new(application, :admin) }
+      subject{ resource }
+
+      context "when regular resource" do
+        let(:resource){ namespace.register(Post) }
+        it { is_expected.to be_include_in_menu }
+      end
+
+      context "when menu set to false" do
+        let(:resource){ namespace.register(Post){ menu false } }
+        it { is_expected.not_to be_include_in_menu }
+      end
+    end
+
+    describe "#belongs_to" do
+
+      it "should build a belongs to configuration" do
+        expect(config.belongs_to_config).to eq nil
+        config.belongs_to :posts
+        expect(config.belongs_to_config).to_not eq nil
+      end
+
+      it "should set the target menu to the belongs to target" do
+        expect(config.navigation_menu_name).to eq ActiveAdmin::DEFAULT_MENU
+        config.belongs_to :posts
+        expect(config.navigation_menu_name).to eq :posts
+      end
+
+    end
+
+    describe "scoping" do
+      context "when using a block" do
+        before do
+          @resource = application.register Category do
+            scope_to do
+              "scoped"
+            end
+          end
+        end
+        it "should call the proc for the begin of association chain" do
+          begin_of_association_chain = @resource.controller.new.send(:begin_of_association_chain)
+          expect(begin_of_association_chain).to eq "scoped"
+        end
+      end
+
+      context "when using a symbol" do
+        before do
+          @resource = application.register Category do
+            scope_to :current_user
+          end
+        end
+        it "should call the method for the begin of association chain" do
+          controller = @resource.controller.new
+          expect(controller).to receive(:current_user).and_return(true)
+          begin_of_association_chain = controller.send(:begin_of_association_chain)
+          expect(begin_of_association_chain).to eq true
+        end
+      end
+
+      describe "getting the method for the association chain" do
+        context "when a simple registration" do
+          before do
+            @resource = application.register Category do
+              scope_to :current_user
+            end
+          end
+          it "should return the pluralized collection name" do
+            expect(@resource.controller.new.send(:method_for_association_chain)).to eq :categories
+          end
+        end
+        context "when passing in the method as an option" do
+          before do
+            @resource = application.register Category do
+              scope_to :current_user, association_method: :blog_categories
+            end
+          end
+          it "should return the method from the option" do
+            expect(@resource.controller.new.send(:method_for_association_chain)).to eq :blog_categories
+          end
+        end
+      end
+    end
+
+
+    describe "sort order" do
+
+      context "when resource class responds to primary_key" do
+        it "should sort by primary key desc by default" do
+          expect(MockResource).to receive(:primary_key).and_return("pk")
+          config = Resource.new(namespace, MockResource)
+          expect(config.sort_order).to eq "pk_desc"
+        end
+      end
+
+      context "when resource class does not respond to primary_key" do
+        it "should default to id" do
+          config = Resource.new(namespace, MockResource)
+          expect(config.sort_order).to eq "id_desc"
+        end
+      end
+
+      it "should be set-able" do
+        config.sort_order = "task_id_desc"
+        expect(config.sort_order).to eq "task_id_desc"
+      end
+
+    end
+
+    describe "adding a scope" do
+
+      it "should add a scope" do
+        config.scope :published
+        expect(config.scopes.first).to be_a(ActiveAdmin::Scope)
+        expect(config.scopes.first.name).to eq "Published"
+      end
+
+      it "should retrive a scope by its id" do
+        config.scope :published
+        expect(config.get_scope_by_id(:published).name).to eq "Published"
+      end
+
+      it "should retrieve the default scope by proc" do
+        config.scope :published, default: proc{ true }
+        config.scope :all
+        expect(config.default_scope.name).to eq "Published"
+      end
+
+    end
+
+    describe "#csv_builder" do
+      context "when no csv builder set" do
+        it "should return a default column builder with id and content columns" do
+          expect(config.csv_builder.exec_columns.size).to eq Category.content_columns.size + 1
+        end
+      end
+
+      context "when csv builder set" do
+        it "shuld return the csv_builder we set" do
+          csv_builder = CSVBuilder.new
+          config.csv_builder = csv_builder
+          expect(config.csv_builder).to eq csv_builder
+        end
+      end
+    end
+
+    describe "#breadcrumb" do
+      subject { config.breadcrumb }
+
+      context "when no breadcrumb is set" do
+        it { is_expected.to eq(namespace.breadcrumb) }
+      end
+
+      context "when breadcrumb is set" do
+        context "when set to true" do
+          before { config.breadcrumb = true }
+          it { is_expected.to eq true }
+        end
+
+        context "when set to false" do
+          before { config.breadcrumb = false }
+          it { is_expected.to eq false }
+        end
+      end
+    end
+
+    describe '#find_resource' do
+      let(:resource) { namespace.register(Post) }
+      let(:post) { double }
+      before do
+        if Rails::VERSION::MAJOR >= 4
+          allow(Post).to receive(:find_by).with("id" => "12345") { post }
+          allow(Post).to receive(:find_by).with("id" => "54321") { nil }
+        else
+          allow(Post).to receive(:find_by_id).with("12345") { post }
+          allow(Post).to receive(:find_by_id).with("54321") { nil }
+        end
+      end
+
+      it 'can find the resource' do
+        expect(resource.find_resource('12345')).to eq post
+      end
+
+      context 'with a decorator' do
+        let(:resource) { namespace.register(Post) { decorate_with PostDecorator } }
+        it 'decorates the resource' do
+          expect(resource.find_resource('12345')).to eq PostDecorator.new(post)
+        end
+
+        it 'does not decorate a not found resource' do
+          expect(resource.find_resource('54321')).to equal nil
+        end
+      end
+
+      context 'when using a nonstandard primary key' do
+        let(:different_post) { double }
+        before do
+          allow(Post).to receive(:primary_key).and_return 'something_else'
+          if Rails::VERSION::MAJOR >= 4
+            allow(Post).to receive(:find_by).
+              with("something_else" => "55555") { different_post }
+          else
+            allow(Post).to receive(:find_by_something_else).
+              with("55555") { different_post }
+          end
+        end
+
+        it 'can find the post by the custom primary key' do
+          expect(resource.find_resource('55555')).to eq different_post
+        end
+      end
+
+      context 'when using controller finder' do
+        let(:resource) do
+          namespace.register(Post) do
+            controller do
+              defaults finder: :find_by_title!
+            end
+          end
+        end
+
+        it 'can find the post by controller finder' do
+          allow(Post).to receive(:find_by_title!).with('title-name').and_return(post)
+
+          expect(resource.find_resource('title-name')).to eq post
+        end
+      end
+    end
+
+    describe "delegation" do
+      let(:controller) {
+        Class.new do
+          def method_missing(name, *args, &block)
+            "called #{name}"
+          end
+        end.new
+      }
+      let(:resource) { ActiveAdmin::ResourceDSL.new(double, double) }
+
+      before do
+        expect(resource).to receive(:controller).and_return(controller)
+      end
+
+      context "filters" do
+        [
+          :before_filter, :skip_before_filter,
+          :after_filter, :skip_after_filter,
+          :around_filter, :skip_filter
+        ].each do |method|
+          it "delegates #{method}" do
+            expected = method.to_s.dup
+            expected.sub! 'filter', 'action' if ActiveAdmin::Dependency.rails >= 4
+            expect(resource.send(method)).to eq "called #{expected}"
+          end
+        end
+      end
+
+      if ActiveAdmin::Dependency.rails >= 4
+        context "actions" do
+          [
+            :before_action, :skip_before_action,
+            :after_action, :skip_after_action,
+            :around_action, :skip_action
+          ].each do |method|
+            it "delegates #{method}" do
+              expect(resource.send(method)).to eq "called #{method}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/routing_spec.rb

@@ -0,0 +1,185 @@
+# encoding: utf-8
+
+require 'rails_helper'
+
+describe ActiveAdmin, "Routing", type: :routing do
+
+  before do
+    load_defaults!
+    reload_routes!
+  end
+
+  after :all do
+    load_defaults!
+    reload_routes!
+  end
+
+  it "should only have the namespaces necessary for route testing" do
+    expect(ActiveAdmin.application.namespaces.names).to eq [:admin, :root]
+  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 "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
+    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