saulolso-activeadmin 0.2.2

data/spec/unit/registration_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper' 
+
+describe "Registering an object to administer" do
+  let(:application){ ActiveAdmin::Application.new }
+
+  context "with no configuration" do
+    let(:namespace) { ActiveAdmin::Namespace.new(application, :admin) }
+    it "should call register on the namespace" do
+      application.namespaces[namespace.name] = namespace
+      namespace.should_receive(:register)
+
+      application.register Category
+    end
+
+    it "should dispatch a Resource::RegisterEvent" do
+      ActiveAdmin::Event.should_receive(:dispatch).with(ActiveAdmin::Resource::RegisterEvent, an_instance_of(ActiveAdmin::Resource))
+      application.register Category
+    end
+  end
+
+  context "with a different namespace" do
+    it "should call register on the namespace" do
+      namespace = ActiveAdmin::Namespace.new(application, :hello_world)
+      application.namespaces[namespace.name] = namespace
+      namespace.should_receive(:register)
+
+      application.register Category, :namespace => :hello_world
+    end
+    it "should generate a menu item for the dashboard" do
+      application.register Category, :namespace => :hello_world
+      application.namespaces[:hello_world].load_menu!
+      application.namespaces[:hello_world].menu['Dashboard'].instance_variable_get("@url").should == :hello_world_dashboard_path
+    end
+    it "should generate a Namespace::RegisterEvent and a Resource::RegisterEvent" do
+      ActiveAdmin::Event.should_receive(:dispatch).with(ActiveAdmin::Namespace::RegisterEvent, an_instance_of(ActiveAdmin::Namespace))
+      ActiveAdmin::Event.should_receive(:dispatch).with(ActiveAdmin::Resource::RegisterEvent, an_instance_of(ActiveAdmin::Resource))
+      application.register Category, :namespace => :not_yet_created
+    end
+  end
+
+  context "with no namespace" do
+    it "should call register on the root namespace" do
+      namespace = ActiveAdmin::Namespace.new(application, :root)
+      application.namespaces[namespace.name] = namespace
+      namespace.should_receive(:register)
+
+      application.register Category, :namespace => false
+    end
+
+    it "should generate a menu item for the dashboard" do
+      application.register Category, :namespace => false  
+      application.namespaces[:root].load_menu!
+      application.namespaces[:root].menu['Dashboard'].instance_variable_get("@url").should == :dashboard_path
+    end
+
+  end
+
+  context "when being registered multiple times" do
+    it "should run the dsl in the same config object" do
+      config_1 = ActiveAdmin.register(Category) { filter :name }
+      config_2 = ActiveAdmin.register(Category) { filter :id }
+      config_1.should == config_2
+      config_1.controller.filters_config.size.should == 2
+    end
+
+    context "with different resource classes" do
+      it "should raise an ActiveAdmin::ResourceMismatch" do
+        lambda {
+          ActiveAdmin.register Category
+          ActiveAdmin.register Post, :as => "Category"
+        }.should raise_error(ActiveAdmin::ResourceMismatchError)
+      end
+    end
+  end
+
+end

data/spec/unit/renderer_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+include ActiveAdmin
+
+describe ActiveAdmin::Renderer do
+
+  context "when initiailizing from a view" do
+    it "should have a view" do
+      view = action_view
+      renderer = Renderer.new(view)
+      renderer.view.should == view
+    end
+
+    it "should assign all local variables from the view" do
+      Renderer.new(action_view(:foo => "bar")).send(:instance_variable_get, "@foo").should == "bar"
+    end
+    
+    it "should assing an instance variable to the view" do
+      view = action_view
+      renderer = Renderer.new(view)
+      renderer.send :set_ivar_on_view, "@my_ivar", 'Hello World'
+      view.instance_variable_get("@my_ivar").should == 'Hello World'
+    end
+  end
+
+  context "when initializing from another renderer" do
+    it "should have the view" do
+      view = action_view
+      renderer = Renderer.new(Renderer.new(view))
+      renderer.view.should == view
+    end
+
+    it "should assign local variables from the renderer" do
+      view = action_view(:foo => 'bar')
+      renderer = Renderer.new(Renderer.new(view))
+      renderer.send(:instance_variable_get, "@foo").should == 'bar'
+    end
+
+    it "should assing an instance variable to the view" do
+      view = action_view
+      renderer = Renderer.new(Renderer.new(view))
+      renderer.send :set_ivar_on_view, "@my_ivar", 'Hello World'
+      view.instance_variable_get("@my_ivar").should == 'Hello World'
+    end    
+  end
+
+  context "when initializing from some other object" do
+    it "should initialize successfully" do
+      lambda {
+        Renderer.new "Hello World"
+      }.should_not raise_exception
+    end
+  end
+
+  describe "rendering HAML" do
+    before do
+      @haml_renderer = Class.new(Renderer)
+      @haml_renderer.class_eval do
+        def hello_world
+          "Hello World"
+        end
+      end
+    end
+    it "should render haml within the context of the renderer" do
+      @haml_renderer.class_eval do
+        def to_html
+          haml <<-HAML
+%p
+  =hello_world
+          HAML
+        end
+      end
+      @renderer = @haml_renderer.new(action_view)
+      @renderer.to_html.should == "<p>\n  Hello World\n</p>\n"
+    end
+
+    it "should allow for indentation at the start of the template" do
+      @haml_renderer.class_eval do
+        def to_html
+          haml <<-HAML
+            %p
+              =hello_world
+          HAML
+        end
+      end
+      @renderer = @haml_renderer.new(action_view)
+      @renderer.to_html.should == "<p>\n  Hello World\n</p>\n"      
+    end
+  end
+
+  describe "#call_method_or_proc_on" do
+    let(:renderer){ Renderer.new(action_view) }
+    let(:obj){ "Hello World" }
+    it "should return nil if no symbol or proc given" do
+      renderer.send(:call_method_or_proc_on, obj, 1).should == nil
+    end
+    it "should call the method if a symbol is given" do
+      renderer.send(:call_method_or_proc_on, obj, :size).should == obj.size
+    end
+    it "should call the method if a string is given" do
+      renderer.send(:call_method_or_proc_on, obj, "size").should == obj.size
+    end
+    it "should call the proc with the object if a proc is given" do
+      p = Proc.new{|string| string.size }
+      renderer.send(:call_method_or_proc_on, obj, p).should == obj.size
+    end
+  end
+end

data/spec/unit/resource_controller/collection_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe ActiveAdmin::ResourceController::Collection do
+  let(:params) do
+    {}
+  end
+
+  let(:controller) do
+    rc = Admin::PostsController.new
+    rc.stub!(:params) do
+      params
+    end
+    rc
+  end
+
+  describe ActiveAdmin::ResourceController::Collection::Search do
+    let(:params){ {:q => {} }}
+    it "should call the metasearch method" do
+      chain = mock("ChainObj")
+      chain.should_receive(:metasearch).with(params[:q]).once.and_return(Post.search)
+      controller.send :search, chain
+    end
+  end
+
+  describe ActiveAdmin::ResourceController::Collection::Sorting do
+    let(:params){ {:order => "id_asc" }}
+    it "should prepend the table name" do
+      chain = mock("ChainObj")
+      chain.should_receive(:order).with("posts.id asc").once.and_return(Post.search)
+      controller.send :sort_order, chain
+    end
+  end
+
+end

data/spec/unit/resource_controller_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+
+describe ActiveAdmin::ResourceController do
+  
+  [:index, :show].each do |page|
+    describe "#{page} config" do
+      before do
+        Admin::PostsController.send(:"reset_#{page}_config!")
+      end
+
+      it "should be set" do
+        Admin::PostsController.send(:set_page_config, page, {})
+        Admin::PostsController.send(:"#{page}_config").should be_an_instance_of(ActiveAdmin::PageConfig)
+      end
+
+      it "should store the block" do
+        block = Proc.new {}
+        Admin::PostsController.send(:set_page_config, page, {}, &block)
+        Admin::PostsController.send(:"#{page}_config").block.should == block
+      end
+
+      it "should be reset" do
+        Admin::PostsController.send(:"reset_#{page}_config!")
+        Admin::PostsController.send(:"#{page}_config").should == nil
+      end
+    end
+  end
+
+  describe "setting the current tab" do
+    let(:controller) { ActiveAdmin::ResourceController.new }
+    before do 
+      controller.stub!(:active_admin_config => resource, :parent? => true)
+      controller.send :set_current_tab # Run the before filter
+    end
+    subject{ controller.instance_variable_get(:@current_tab) }
+
+    context "when menu item name is 'Resources' without a parent menu item" do
+      let(:resource){ mock(:menu_item_name => "Resources", :parent_menu_item_name => nil, :belongs_to? => false) }
+      it { should == "Resources" }
+    end
+
+    context "when there is a parent menu item of 'Admin'" do
+      let(:resource){ mock(:parent_menu_item_name => "Admin", :menu_item_name => "Resources", :belongs_to? => false) }
+      it { should == "Admin/Resources" }
+    end
+  end
+
+  ActiveAdmin.register Post do
+    after_build :call_after_build
+    before_save :call_before_save
+    after_save :call_after_save
+    before_create :call_before_create
+    after_create :call_after_create
+    before_update :call_before_update
+    after_update :call_after_update
+    before_destroy :call_before_destroy
+    after_destroy :call_after_destroy
+  end
+
+  class Admin::PostsController < ActiveAdmin::ResourceController
+    def call_after_build(obj); end
+    def call_before_save(obj); end
+    def call_after_save(obj); end
+    def call_before_create(obj); end
+    def call_after_create(obj); end
+    def call_before_update(obj); end
+    def call_after_update(obj); end
+    def call_before_destroy(obj); end
+    def call_after_destroy(obj); end
+  end
+
+  describe "callbacks" do
+    describe "performing create" do
+      let(:controller){ Admin::PostsController.new }
+      let(:resource){ mock("Resource", :save => true) }
+
+      before do
+        resource.should_receive(:save)
+      end
+
+      it "should call the before create callback" do
+        controller.should_receive(:call_before_create).with(resource)
+        controller.send :create_resource, resource
+      end
+      it "should call the before save callback" do
+        controller.should_receive(:call_before_save).with(resource)
+        controller.send :create_resource, resource
+      end
+      it "should call the after save callback" do
+        controller.should_receive(:call_after_save).with(resource)
+        controller.send :create_resource, resource
+      end
+      it "should call the after create callback" do
+        controller.should_receive(:call_after_create).with(resource)
+        controller.send :create_resource, resource
+      end
+    end
+
+    describe "performing update" do
+      let(:controller){ Admin::PostsController.new }
+      let(:resource){ mock("Resource", :attributes= => true, :save => true) }
+      let(:attributes){ {} }
+
+      before do
+        resource.should_receive(:attributes=).with(attributes)
+        resource.should_receive(:save)
+      end
+
+      it "should call the before update callback" do
+        controller.should_receive(:call_before_update).with(resource)
+        controller.send :update_resource, resource, attributes
+      end
+      it "should call the before save callback" do
+        controller.should_receive(:call_before_save).with(resource)
+        controller.send :update_resource, resource, attributes
+      end
+      it "should call the after save callback" do
+        controller.should_receive(:call_after_save).with(resource)
+        controller.send :update_resource, resource, attributes
+      end
+      it "should call the after create callback" do
+        controller.should_receive(:call_after_update).with(resource)
+        controller.send :update_resource, resource, attributes
+      end
+    end
+
+    describe "performing destroy" do
+      let(:controller){ Admin::PostsController.new }
+      let(:resource){ mock("Resource", :destroy => true) }
+
+      before do
+        resource.should_receive(:destroy)
+      end
+
+      it "should call the before destroy callback" do
+        controller.should_receive(:call_before_destroy).with(resource)
+        controller.send :destroy_resource, resource
+      end
+
+      it "should call the after destroy callback" do
+        controller.should_receive(:call_after_destroy).with(resource)
+        controller.send :destroy_resource, resource
+      end
+    end
+  end
+
+end

data/spec/unit/resource_spec.rb

@@ -0,0 +1,290 @@
+require 'spec_helper' 
+
+module ActiveAdmin
+  describe Resource do
+
+    before { load_defaults! }
+
+    let(:application){ ActiveAdmin::Application.new }
+    let(:namespace){ Namespace.new(application, :admin) }
+
+    def config(options = {})
+      @config ||= Resource.new(namespace, Category, options)
+    end
+
+    describe "underscored resource name" do
+      context "when class" do
+        it "should be the underscored singular resource name" do
+          config.underscored_resource_name.should == "category"
+        end
+      end
+      context "when a class in a module" do
+        it "should underscore the module and the class" do
+          module ::Mock; class Resource; end; end
+          Resource.new(namespace, Mock::Resource).underscored_resource_name.should == "mock_resource"
+        end
+      end
+      context "when you pass the 'as' option" do
+        it "should underscore the passed through string and singulralize" do
+          config(:as => "Blog Categories").underscored_resource_name.should == "blog_category"
+        end
+      end
+    end
+
+    describe "camelized resource name" do
+      it "should return a camelized version of the underscored resource name" do
+        config(:as => "Blog Categories").camelized_resource_name.should == "BlogCategory"
+      end
+    end
+
+    describe "resource name" do
+      it "should return a pretty name" do
+        config.resource_name.should == "Category"
+      end
+      it "should return the plural version" do
+        config.plural_resource_name.should == "Categories"
+      end
+      context "when the :as option is given" do
+        it "should return the custom name" do
+          config(:as => "My Category").resource_name.should == "My Category"
+        end
+      end
+    end
+
+    describe "#resource_table_name" do
+      it "should return the resource's table name" do
+        config.resource_table_name.should == 'categories'
+      end
+      context "when the :as option is given" do
+        it "should return the resource's table name" do
+          config(:as => "My Category").resource_table_name.should == 'categories'
+        end
+      end
+    end
+
+    describe "namespace" do
+      it "should return the namespace" do
+        config.namespace.should == namespace
+      end
+    end
+
+    describe "controller name" do
+      it "should return a namespaced controller name" do
+        config.controller_name.should == "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
+          config.controller_name.should == "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 { should be_include_in_menu }
+      end
+      context "when belongs to" do
+        let(:resource){ namespace.register(Post){ belongs_to :author } }
+        it { should_not be_include_in_menu }
+      end
+      context "when belongs to optional" do
+        let(:resource){ namespace.register(Post){ belongs_to :author, :optional => true} }
+        it { should be_include_in_menu }
+      end
+      context "when menu set to false" do
+        let(:resource){ namespace.register(Post){ menu false } }
+        it { should_not be_include_in_menu }
+      end
+    end
+
+    describe "menu item name" do
+      it "should be the resource name when not set" do
+        config.menu_item_name.should == "Categories"
+      end
+      it "should be settable" do
+        config.menu :label => "My Label"
+        config.menu_item_name.should == "My Label"
+      end
+    end
+
+    describe "parent menu item name" do
+      it "should be nil when not set" do
+        config.parent_menu_item_name.should == nil
+      end
+      it "should return the name if set" do
+        config.tap do |c|
+          c.menu :parent => "Blog"
+        end.parent_menu_item_name.should == "Blog"
+      end
+    end
+    
+    describe "menu item priority" do
+      it "should be 10 when not set" do
+        config.menu_item_priority.should == 10
+      end
+      it "should be settable" do
+        config.menu :priority => 2
+        config.menu_item_priority.should == 2
+      end
+    end
+    
+    describe "menu item display if" do
+      it "should be a proc always returning true if not set" do
+        config.menu_item_display_if.should be_instance_of(Proc)
+        config.menu_item_display_if.call.should == true
+      end
+      it "should be settable" do
+        config.menu :if => proc { false }
+        config.menu_item_display_if.call.should == false
+      end
+    end
+
+    describe "route names" do
+      let(:config){ application.register Category }
+      it "should return the route prefix" do
+        config.route_prefix.should == "admin"
+      end
+      it "should return the route collection path" do
+        config.route_collection_path.should == :admin_categories_path
+      end
+
+      context "when in the root namespace" do
+        let(:config){ application.register Category, :namespace => false}
+        it "should have a nil route_prefix" do
+          config.route_prefix.should == nil
+        end
+      end
+    end
+
+    describe "page configs" do
+      context "when initialized" do
+        it "should be empty" do
+          config.page_configs.should == {}
+        end
+      end
+      it "should be set-able" do
+        config.page_configs[:index] = "hello world"
+        config.page_configs[:index].should == "hello world"
+      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)
+          begin_of_association_chain.should == "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
+          controller.should_receive(:current_user).and_return(true)
+          begin_of_association_chain = controller.send(:begin_of_association_chain)
+          begin_of_association_chain.should == true
+        end
+      end
+
+      context "when not using a block or symbol" do
+        before do
+          @resource = application.register Category do
+            scope_to "Some string"
+          end
+        end
+        it "should raise and exception" do
+          lambda {
+            @resource.controller.new.send(:begin_of_association_chain)
+          }.should raise_error(ArgumentError)
+        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
+            @resource.controller.new.send(:method_for_association_chain).should == :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
+            @resource.controller.new.send(:method_for_association_chain).should == :blog_categories
+          end
+        end
+      end
+    end
+
+
+    describe "sort order" do
+      subject { resource_config.sort_order }
+
+      context "by default" do
+        let(:resource_config) { config }
+
+        it { should == application.default_sort_order }
+      end
+
+      context "when default_sort_order is set" do
+        let(:sort_order)      { "name_desc"                      }
+        let(:resource_config) { config :sort_order => sort_order }
+
+        it { should == sort_order }
+      end
+    end
+
+    describe "adding a scope" do
+
+      it "should add a scope" do
+        config.scope :published
+        config.scopes.first.should be_a(ActiveAdmin::Scope)
+        config.scopes.first.name.should == "Published"
+      end
+
+      it "should retrive a scope by its id" do
+        config.scope :published
+        config.get_scope_by_id(:published).name.should == "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
+          config.csv_builder.columns.size.should == 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
+          config.csv_builder.should == csv_builder
+        end
+      end
+    end
+  end
+end