activeadmin 0.6.6 → 1.0.0.pre1

data/spec/unit/abstract_view_factory_spec.rb

@@ -1,67 +1,67 @@
-require 'spec_helper'
+require 'rails_helper'
 
 require 'active_admin/abstract_view_factory'
 
 describe ActiveAdmin::AbstractViewFactory do
 
   let(:view_factory){ ActiveAdmin::AbstractViewFactory.new }
-  let(:mock_view){ Class.new }
+  let(:view){ Class.new }
 
   describe "registering a new view key" do
     before do
-      view_factory.register :my_new_view_class => mock_view
+      view_factory.register my_new_view_class: view
     end
 
     it "should respond to :my_new_view_class" do
-      view_factory.respond_to?(:my_new_view_class)
+      expect(view_factory.respond_to? :my_new_view_class).to be true
     end
 
     it "should respond to :my_new_view_class=" do
-      view_factory.respond_to?(:my_new_view_class=)
+      expect(view_factory.respond_to? :my_new_view_class=).to be true
     end
 
     it "should generate a getter method" do
-      view_factory.my_new_view_class.should == mock_view
+      expect(view_factory.my_new_view_class).to eq view
     end
 
     it "should be settable view a setter method" do
       view_factory.my_new_view_class = "Some Obj"
-      view_factory.my_new_view_class.should == "Some Obj"
+      expect(view_factory.my_new_view_class).to eq "Some Obj"
     end
   end
 
   describe "array syntax access" do
     before do
-      view_factory.register :my_new_view_class => mock_view
+      view_factory.register my_new_view_class: view
     end
 
     it "should be available through array syntax" do
-      view_factory[:my_new_view_class].should == mock_view
+      expect(view_factory[:my_new_view_class]).to eq view
     end
 
     it "should be settable through array syntax" do
       view_factory[:my_new_view_class] = "My New View Class"
-      view_factory[:my_new_view_class].should == "My New View Class"
+      expect(view_factory[:my_new_view_class]).to eq "My New View Class"
     end
   end
 
   describe "registering default views" do
     before do
-      ActiveAdmin::AbstractViewFactory.register :my_default_view_class => mock_view
+      ActiveAdmin::AbstractViewFactory.register my_default_view_class: view
     end
     it "should generate a getter method" do
-      view_factory.my_default_view_class.should == mock_view
+      expect(view_factory.my_default_view_class).to eq view
     end
     it "should be settable view a setter method and not change default" do
       view_factory.my_default_view_class = "Some Obj"
-      view_factory.my_default_view_class.should == "Some Obj"
-      view_factory.default_for(:my_default_view_class).should == mock_view
+      expect(view_factory.my_default_view_class).to eq "Some Obj"
+      expect(view_factory.default_for(:my_default_view_class)).to eq view
     end
   end
 
   describe "subclassing the ViewFactory" do
     let(:subclass) do
-      ActiveAdmin::AbstractViewFactory.register :my_subclassed_view => "From Parent"
+      ActiveAdmin::AbstractViewFactory.register my_subclassed_view: "From Parent"
       Class.new(ActiveAdmin::AbstractViewFactory) do
         def my_subclassed_view
           "From Subclass"
@@ -71,7 +71,7 @@ describe ActiveAdmin::AbstractViewFactory do
 
     it "should use the subclass implementation" do
       factory = subclass.new
-      factory.my_subclassed_view.should == "From Subclass"
+      expect(factory.my_subclassed_view).to eq "From Subclass"
     end
   end
 

data/spec/unit/action_builder_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe 'defining new actions from registration blocks' do
 
@@ -24,13 +24,13 @@ describe 'defining new actions from registration blocks' do
       end
 
       it "should create a new public instance method" do
-        controller.public_instance_methods.collect(&:to_s).should include("comment")
+        expect(controller.public_instance_methods.collect(&:to_s)).to include("comment")
       end
       it "should add itself to the member actions config" do
-        controller.active_admin_config.member_actions.size.should == 1
+        expect(controller.active_admin_config.member_actions.size).to eq 1
       end
       it "should create a new named route" do
-        Rails.application.routes.url_helpers.methods.collect(&:to_s).should include("comment_admin_post_path")
+        expect(Rails.application.routes.url_helpers.methods.collect(&:to_s)).to include("comment_admin_post_path")
       end
     end
 
@@ -41,20 +41,20 @@ describe 'defining new actions from registration blocks' do
         end
       end
       it "should still generate a new empty action" do
-        controller.public_instance_methods.collect(&:to_s).should include("comment")
+        expect(controller.public_instance_methods.collect(&:to_s)).to include("comment")
       end
     end
 
     context "with :title" do
       let(:action!) do
         ActiveAdmin.register Post do
-          member_action :comment, :title => "My Awesome Comment"
+          member_action :comment, title: "My Awesome Comment"
         end
       end
 
       subject { find_before_filter controller, :comment }
 
-      it { should set_page_title_to "My Awesome Comment" }
+      it { is_expected.to set_page_title_to "My Awesome Comment", for: controller }
     end
   end
 
@@ -76,13 +76,13 @@ describe 'defining new actions from registration blocks' do
         end
       end
       it "should create a new public instance method" do
-        controller.public_instance_methods.collect(&:to_s).should include("comments")
+        expect(controller.public_instance_methods.collect(&:to_s)).to include("comments")
       end
       it "should add itself to the member actions config" do
-        controller.active_admin_config.collection_actions.size.should == 1
+        expect(controller.active_admin_config.collection_actions.size).to eq 1
       end
       it "should create a new named route" do
-        Rails.application.routes.url_helpers.methods.collect(&:to_s).should include("comments_admin_posts_path")
+        expect(Rails.application.routes.url_helpers.methods.collect(&:to_s)).to include("comments_admin_posts_path")
       end
     end
     context "without a block" do
@@ -92,34 +92,40 @@ describe 'defining new actions from registration blocks' do
         end
       end
       it "should still generate a new empty action" do
-        controller.public_instance_methods.collect(&:to_s).should include("comments")
+        expect(controller.public_instance_methods.collect(&:to_s)).to include("comments")
       end
     end
     context "with :title" do
       let(:action!) do
         ActiveAdmin.register Post do
-          collection_action :comments, :title => "My Awesome Comments"
+          collection_action :comments, title: "My Awesome Comments"
         end
       end
 
       subject { find_before_filter controller, :comments }
 
-      it { should set_page_title_to "My Awesome Comments" }
+      it { is_expected.to set_page_title_to "My Awesome Comments", for: controller }
     end
   end
 
   def find_before_filter(controller, action)
-    controller._process_action_callbacks.detect { |f| f.kind == :before && f.options[:only] == [action] }
+    finder = if ActiveAdmin::Dependency.rails? '>= 4.1.0'
+      ->c { c.kind == :before && c.instance_variable_get(:@if) == ["action_name == '#{action}'"] }
+    else
+      ->c { c.kind == :before && c.options[:only] == [action] }
+    end
+
+    controller._process_action_callbacks.detect &finder
   end
 
-  RSpec::Matchers.define :set_page_title_to do |expected|
+  RSpec::Matchers.define :set_page_title_to do |expected, options|
     match do |filter|
       filter.raw_filter.call
-      @actual = filter.klass.instance_variable_get(:@page_title)
-      @actual == expected
+      @actual = options[:for].instance_variable_get(:@page_title)
+      expect(@actual).to eq expected
     end
 
-    failure_message_for_should do |filter|
+    failure_message do |filter|
       message = "expected before_filter to set the @page_title to '#{expected}', but was '#{@actual}'"
     end
   end

data/spec/unit/active_admin_spec.rb

@@ -1,9 +1,9 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe ActiveAdmin do
   %w(register register_page unload! load! routes).each do |method|
     it "delegates ##{method} to application" do
-      ActiveAdmin.application.should_receive(method)
+      expect(ActiveAdmin.application).to receive(method)
 
       ActiveAdmin.send(method)
     end

data/spec/unit/application_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 require 'fileutils'
 
 describe ActiveAdmin::Application do
@@ -11,90 +11,90 @@ describe ActiveAdmin::Application do
   end
 
   it "should have a default load path of ['app/admin']" do
-    application.load_paths.should == [File.expand_path('app/admin', Rails.root)]
+    expect(application.load_paths).to eq [File.expand_path('app/admin', Rails.root)]
   end
 
-  it "should remove app/admin from the autoload path to remove the possibility of conflicts" do
-    ActiveSupport::Dependencies.autoload_paths.should_not include(File.join(Rails.root, "app/admin"))
+  it "should remove app/admin from the autoload paths (Active Admin deals with loading)" do
+    expect(ActiveSupport::Dependencies.autoload_paths).to_not include(File.join(Rails.root, "app/admin"))
   end
 
-  it "should remove app/admin from the eager load paths (Active Admin deals with loading)" do
-    Rails.application.config.eager_load_paths.should_not include(File.join(Rails.root, "app/admin"))
+  it "should add app/admin to the Engine's watchable directories (loaded after the app itself)" do
+    expect(ActiveAdmin::Engine.config.watchable_dirs).to have_key File.join(Rails.root, "app/admin")
   end
 
   it "should store the site's title" do
-    application.site_title.should == ""
+    expect(application.site_title).to eq ""
   end
 
   it "should set the site title" do
     application.site_title = "New Title"
-    application.site_title.should == "New Title"
+    expect(application.site_title).to eq "New Title"
   end
 
   it "should store the site's title link" do
-    application.site_title_link.should == ""
+    expect(application.site_title_link).to eq ""
   end
 
   it "should set the site's title link" do
     application.site_title_link = "http://www.mygreatsite.com"
-    application.site_title_link.should == "http://www.mygreatsite.com"
+    expect(application.site_title_link).to eq "http://www.mygreatsite.com"
   end
 
   it "should store the site's title image" do
-    application.site_title_image.should == ""
+    expect(application.site_title_image).to eq ""
   end
 
   it "should set the site's title image" do
     application.site_title_image = "http://railscasts.com/assets/episodes/stills/284-active-admin.png?1316476106"
-    application.site_title_image.should == "http://railscasts.com/assets/episodes/stills/284-active-admin.png?1316476106"
+    expect(application.site_title_image).to eq "http://railscasts.com/assets/episodes/stills/284-active-admin.png?1316476106"
   end
-  
+
   it "should store the site's favicon" do
-    application.favicon.should == false
+    expect(application.favicon).to eq false
   end
 
   it "should set the site's favicon" do
     application.favicon = "/a/favicon.ico"
-    application.favicon.should == "/a/favicon.ico"
+    expect(application.favicon).to eq "/a/favicon.ico"
   end
 
   it "should have a view factory" do
-    application.view_factory.should be_an_instance_of(ActiveAdmin::ViewFactory)
+    expect(application.view_factory).to be_an_instance_of(ActiveAdmin::ViewFactory)
   end
 
   it "should allow comments by default" do
-    application.allow_comments.should == true
+    expect(application.comments).to eq true
   end
 
   describe "authentication settings" do
 
     it "should have no default current_user_method" do
-      application.current_user_method.should == false
+      expect(application.current_user_method).to eq false
     end
 
     it "should have no default authentication method" do
-      application.authentication_method.should == false
+      expect(application.authentication_method).to eq false
     end
 
     it "should have a logout link path (Devise's default)" do
-      application.logout_link_path.should == :destroy_admin_user_session_path
+      expect(application.logout_link_path).to eq :destroy_admin_user_session_path
     end
 
     it "should have a logout link method (Devise's default)" do
-      application.logout_link_method.should == :get
+      expect(application.logout_link_method).to eq :get
     end
   end
 
   describe "files in load path" do
     it "should load files in the first level directory" do
-      application.files.should include(File.expand_path("app/admin/dashboard.rb", Rails.root))
+      expect(application.files).to include(File.expand_path("app/admin/dashboard.rb", Rails.root))
     end
 
     it "should load files from subdirectories" do
       FileUtils.mkdir_p(File.expand_path("app/admin/public", Rails.root))
       test_file = File.expand_path("app/admin/public/posts.rb", Rails.root)
       FileUtils.touch(test_file)
-      application.files.should include(test_file)
+      expect(application.files).to include(test_file)
     end
   end
 
@@ -102,39 +102,38 @@ describe ActiveAdmin::Application do
 
     it "should yield a new namespace" do
       application.namespace :new_namespace do |ns|
-        ns.name.should == :new_namespace
+        expect(ns.name).to eq :new_namespace
       end
     end
 
     it "should return an instantiated namespace" do
       admin = application.namespace :admin
-      admin.should == application.namespaces[:admin]
+      expect(admin).to eq application.namespaces[:admin]
     end
 
     it "should yield an existing namespace" do
       expect {
         application.namespace :admin do |ns|
-          ns.should == application.namespaces[:admin]
+          expect(ns).to eq application.namespaces[:admin]
           raise "found"
         end
       }.to raise_error("found")
     end
 
     it "should not pollute the global app" do
-      application.namespaces.keys.should be_empty
+      expect(application.namespaces).to be_empty
       application.namespace(:brand_new_ns)
-      application.namespaces.keys.should eq [:brand_new_ns]
-      ActiveAdmin.application.namespaces.keys.should eq [:admin]
+      expect(application.namespaces.names).to eq [:brand_new_ns]
+      expect(ActiveAdmin.application.namespaces.names).to eq [:admin]
     end
   end
 
   describe "#register_page" do
     it "finds or create the namespace and register the page to it" do
-      namespace = mock
-      application.should_receive(:namespace).with("public").and_return namespace
-      namespace.should_receive(:register_page).with("My Page", {:namespace => "public"})
-
-      application.register_page("My Page", :namespace => "public")
+      namespace = double
+      expect(application).to receive(:namespace).with("public").and_return namespace
+      expect(namespace).to receive(:register_page).with("My Page", {namespace: "public"})
+      application.register_page("My Page", namespace: "public")
     end
   end
 

data/spec/unit/asset_registration_spec.rb

@@ -1,56 +1,52 @@
-require 'spec_helper'
-
-module MockRegistration
-  extend ActiveAdmin::AssetRegistration
-end
+require 'rails_helper'
 
 describe ActiveAdmin::AssetRegistration do
+  include ActiveAdmin::AssetRegistration
 
   before do
-    MockRegistration.clear_stylesheets!
-    MockRegistration.clear_javascripts!
+    clear_stylesheets!
+    clear_javascripts!
   end
 
   it "should register a stylesheet file" do
-    MockRegistration.register_stylesheet "active_admin.css"
-    MockRegistration.stylesheets.length.should == 1
-    MockRegistration.stylesheets.keys.first.should == "active_admin.css"
+    register_stylesheet "active_admin.css"
+    expect(stylesheets.length).to eq 1
+    expect(stylesheets.keys.first).to eq "active_admin.css"
   end
 
   it "should clear all existing stylesheets" do
-    MockRegistration.register_stylesheet "active_admin.css"
-    MockRegistration.stylesheets.length.should == 1
-    MockRegistration.clear_stylesheets!
-    MockRegistration.stylesheets.should be_empty
+    register_stylesheet "active_admin.css"
+    expect(stylesheets.length).to eq 1
+    clear_stylesheets!
+    expect(stylesheets).to be_empty
   end
 
   it "should allow media option when registering stylesheet" do
-    MockRegistration.register_stylesheet "active_admin.css", :media => :print
-    MockRegistration.stylesheets.values.first[:media].should == :print
+    register_stylesheet "active_admin.css", media: :print
+    expect(stylesheets.values.first[:media]).to eq :print
   end
 
   it "shouldn't register a stylesheet twice" do
-    MockRegistration.register_stylesheet "active_admin.css"
-    MockRegistration.register_stylesheet "active_admin.css"
-    MockRegistration.stylesheets.length.should == 1
+    register_stylesheet "active_admin.css"
+    register_stylesheet "active_admin.css"
+    expect(stylesheets.length).to eq 1
   end
 
-
   it "should register a javascript file" do
-    MockRegistration.register_javascript "active_admin.js"
-    MockRegistration.javascripts.should == ["active_admin.js"].to_set
+    register_javascript "active_admin.js"
+    expect(javascripts).to eq ["active_admin.js"].to_set
   end
 
   it "should clear all existing javascripts" do
-    MockRegistration.register_javascript "active_admin.js"
-    MockRegistration.javascripts.should == ["active_admin.js"].to_set
-    MockRegistration.clear_javascripts!
-    MockRegistration.javascripts.should be_empty
+    register_javascript "active_admin.js"
+    expect(javascripts).to eq ["active_admin.js"].to_set
+    clear_javascripts!
+    expect(javascripts).to be_empty
   end
 
   it "shouldn't register a javascript twice" do
-    MockRegistration.register_javascript "active_admin.js"
-    MockRegistration.register_javascript "active_admin.js"
-    MockRegistration.javascripts.length.should == 1
+    register_javascript "active_admin.js"
+    register_javascript "active_admin.js"
+    expect(javascripts.length).to eq 1
   end
 end