activeadmin 1.0.0.pre1 → 2.9.0

data/spec/unit/resource_spec.rb

@@ -1,278 +0,0 @@
-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 be_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 be_nil
-        config.belongs_to :posts
-        expect(config.belongs_to_config).to_not be_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 be_truthy }
-        end
-
-        context "when set to false" do
-          before { config.breadcrumb = false }
-          it { is_expected.to be_falsey }
-        end
-      end
-    end
-
-    describe '#find_resource' do
-      let(:resource) { namespace.register(Post) }
-      let(:post) { double }
-      before do
-        allow(Post).to receive(:find_by_id).with('12345') { post }
-      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
-      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'
-          allow(Post).to receive(:find_by_something_else).with('55555') { different_post }
-        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
-  end
-end

data/spec/unit/routing_spec.rb

@@ -1,180 +0,0 @@
-# encoding: utf-8
-
-require 'rails_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
-    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
-
-      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

@@ -1,190 +0,0 @@
-require 'rails_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 }
-
-      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 be_nil }
-      end
-
-      describe '#scope_block' do
-        subject { super().scope_block }
-        it  { is_expected.to be_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
-      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