andrewroth_activeadmin 0.3.4

data/spec/unit/pretty_format_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe "#pretty_format" do
+  include ActiveAdmin::ViewHelpers::DisplayHelper
+
+  context "when a String is passed in" do
+    it "should return the String passed in" do
+      pretty_format("hello").should == "hello"
+    end
+  end
+
+  context "when a Date or a Time is passed in" do
+    it "should return a localized Date or Time with long format" do
+      t = Time.now
+      self.should_receive(:localize).with(t, {:format => :long}) { "Just Now!" }
+      pretty_format(t).should == "Just Now!"
+    end
+  end
+
+  context "when an ActiveRecord object is passed in" do
+    it "should delegate to auto_link" do
+      post = Post.new
+      self.should_receive(:auto_link).with(post) { "model name" }
+      pretty_format(post).should == "model name"
+    end
+  end
+
+  context "when something else is passed in" do
+    it "should delegate to display_name" do
+      something = Class.new.new
+      self.should_receive(:display_name).with(something) { "I'm not famous" }
+      pretty_format(something).should == "I'm not famous"
+    end
+  end
+end

data/spec/unit/rails_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe ActiveAdmin do
+
+  describe "use_asset_pipeline?" do
+
+    before(:each) do
+      @orig_rails_version = Rails::VERSION::MINOR
+    end
+
+    after(:each) do
+      silence_warnings { Rails::VERSION::MINOR = @orig_rails_version }
+    end
+
+    it "should be false when using rails 3.0.x" do
+      silence_warnings { Rails::VERSION::MINOR = 0 }
+      ActiveAdmin.use_asset_pipeline?.should be_false
+    end
+
+    context "when rails 3.1.x" do
+      before(:each) do
+        @orig_rails_app = Rails.application.dup
+        silence_warnings { Rails::VERSION::MINOR = 1 }
+      end
+
+      after(:each) do
+        Rails.application = @orig_rails_app
+      end
+
+      it "should be false without asset pipeline enabled" do
+        assets = mock(:enabled => false)
+        Rails.application.config.stub!(:assets => assets)
+        ActiveAdmin.use_asset_pipeline?.should be_false
+      end
+
+      it "should be true with asset pipeline enabled" do
+        assets = mock(:enabled => true)
+        Rails.application.config.stub!(:assets => assets)
+        ActiveAdmin.use_asset_pipeline?.should be_true
+      end
+    end
+  end
+end

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/reloader_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+# Ensure we have both constants to play with
+begin
+  ActionDispatch::Reloader
+rescue
+  module ActionDispatch; module Reloader; def self.to_prepare; end; end; end
+end
+
+begin
+  ActionDispatch::Callbacks
+rescue
+  module ActionDispatch; module Callbacks; def self.to_prepare; end; end; end
+end
+
+
+describe ActiveAdmin::Reloader do
+
+  let(:rails_app){ mock(:reload_routes! => true)}
+  let(:mock_app){ mock(:load_paths => ["app/admin"], :unload! => true)}
+  let(:reloader){ ActiveAdmin::Reloader.new(rails_app, mock_app, "3.1.0")}
+
+  it "should initialize a new file update checker" do
+    ActiveSupport::FileUpdateChecker.should_receive(:new).with(mock_app.load_paths).and_return(mock(:execute_if_updated => true))
+    ActiveAdmin::Reloader.new(rails_app, mock_app, '3.1.0').attach!
+  end
+
+  describe "#reloader_class" do
+    it "should use ActionDispatch::Reloader if rails 3.1" do
+      reloader = ActiveAdmin::Reloader.new rails_app, mock_app, '3.1.0'
+      reloader.reloader_class.should == ActionDispatch::Reloader
+    end
+
+    it "should use ActionDispatch::Callbacks if rails 3.0" do
+      reloader = ActiveAdmin::Reloader.new rails_app, mock_app, '3.0.0'
+      reloader.reloader_class.should == ActionDispatch::Callbacks
+    end
+  end
+
+  describe "#reload!" do
+
+    it "should unload the active admin app" do
+      mock_app.should_receive(:unload!)
+      reloader.reload!
+    end
+
+    it "should reload the rails app routes" do
+      rails_app.should_receive(:reload_routes!)
+      reloader.reload!
+    end
+
+    it 'should reset the files within the file_update_checker' do
+      reloader.file_update_checker.paths.should_receive(:clear)
+      reloader.file_update_checker.paths.should_receive(:<<).with("app/admin")
+      reloader.reload!
+    end
+
+  end
+
+  describe "#watched_paths" do
+    let(:mock_app){ ActiveAdmin::Application.new }
+    let(:admin_path){ File.join(Rails.root, "app", "admin") }
+
+    before do
+      mock_app.load_paths = [admin_path]
+    end
+
+    it "should return the load path directories" do
+      reloader.watched_paths.should include(admin_path)
+    end
+
+    it "should include all files in the directory" do
+      root = Rails.root + "/app/admin"
+      reloader.watched_paths.should include(*Dir["#{admin_path}/**/*.rb"])
+    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/action_items_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe ActiveAdmin::Resource::ActionItems do
+
+  let(:resource) do
+    namespace = ActiveAdmin::Namespace.new(ActiveAdmin::Application.new, :admin)
+    namespace.register(Post)
+  end
+
+  describe "adding a new action item" do
+
+    before do
+      resource.clear_action_items!
+      resource.add_action_item do
+        # Empty ...
+      end
+    end
+
+    it "should add an action item" do
+      resource.action_items.size.should == 1
+    end
+
+    it "should store an instance of ActionItem" do
+      resource.action_items.first.should be_an_instance_of(ActiveAdmin::ActionItem)
+    end
+
+    it "should store the block in the action item" do
+      resource.action_items.first.block.should_not be_nil
+    end
+
+  end
+
+  describe "setting an action item to only display on specific controller actions" do
+
+    before do
+      resource.clear_action_items!
+      resource.add_action_item :only => :index do
+        raise StandardError
+      end
+      resource.add_action_item :only => :show do
+        # Empty ...
+      end
+    end
+
+    it "should return only relevant action items" do
+      resource.action_items_for(:index).size.should == 1
+      lambda {
+        resource.action_items_for(:index).first.call
+      }.should raise_exception(StandardError)
+    end
+
+  end
+
+  describe "default action items" do
+
+    it "should have 3 action items" do
+      resource.action_items.size.should == 3
+    end
+
+  end
+
+end

data/spec/unit/resource/menu_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper' 
+
+module ActiveAdmin
+  describe Resource, "Menu" 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 "#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
+
+  end
+end