activeadmin 0.6.6 → 1.0.0.pre1

data/spec/unit/page_controller_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe ActiveAdmin::PageController do
   let(:controller) { ActiveAdmin::PageController.new }

data/spec/unit/page_spec.rb

@@ -1,12 +1,12 @@
 # encoding: utf-8
 
-require 'spec_helper'
+require 'rails_helper'
 require File.expand_path('config_shared_examples', File.dirname(__FILE__))
 
 module ActiveAdmin
   describe Page do
 
-    it_should_behave_like "ActiveAdmin::Config"
+    it_should_behave_like "ActiveAdmin::Resource"
     before { load_defaults! }
 
     let(:application){ ActiveAdmin::Application.new }
@@ -18,54 +18,60 @@ module ActiveAdmin
 
     describe "controller name" do
       it "should return a namespaced controller name" do
-        config.controller_name.should == "Admin::ChocolateILoveYouController"
+        expect(config.controller_name).to eq "Admin::ChocolateILoveYouController"
       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 == "ChocolateILoveYouController"
+          expect(config.controller_name).to eq "ChocolateILoveYouController"
         end
       end
     end
 
     describe "#resource_name" do
       it "returns the name" do
-        config.resource_name.should == "Chocolate I lØve You!"
+        expect(config.resource_name).to eq "Chocolate I lØve You!"
       end
 
       it "returns the singular, lowercase name" do
-        config.resource_name.singular.should == "chocolate i lØve you!"
+        expect(config.resource_name.singular).to eq "chocolate i lØve you!"
       end
     end
 
     describe "#plural_resource_label" do
       it "returns the singular name" do
-        config.plural_resource_label.should == "Chocolate I lØve You!"
+        expect(config.plural_resource_label).to eq "Chocolate I lØve You!"
       end
     end
 
     describe "#underscored_resource_name" do
       it "returns the resource name underscored" do
-        config.underscored_resource_name.should == "chocolate_i_love_you"
+        expect(config.underscored_resource_name).to eq "chocolate_i_love_you"
       end
     end
 
     describe "#camelized_resource_name" do
       it "returns the resource name camel case" do
-        config.camelized_resource_name.should == "ChocolateILoveYou"
+        expect(config.camelized_resource_name).to eq "ChocolateILoveYou"
+      end
+    end
+
+    describe "#namespace_name" do
+      it "returns the name of the namespace" do
+        expect(config.namespace_name).to eq "admin"
       end
     end
 
     it "should not belong_to anything" do
-      config.belongs_to?.should == false
+      expect(config.belongs_to?).to eq false
     end
 
     it "should not have any action_items" do
-      config.action_items?.should == false
+      expect(config.action_items?).to eq false
     end
 
     it "should not have any sidebar_sections" do
-      config.sidebar_sections?.should == false
+      expect(config.sidebar_sections?).to eq false
     end
 
   end

data/spec/unit/pretty_format_spec.rb

@@ -1,35 +1,63 @@
-require 'spec_helper'
+require 'rails_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"
+  def method_missing(*args, &block)
+    mock_action_view.send *args, &block
+  end
+
+  {String: 'hello', Fixnum: 23, Float: 5.67, Bignum: 10**30,
+    'Arbre::Element' => Arbre::Element.new.br(:foo)
+  }.each do |klass, obj|
+    it "should call `to_s` on #{klass}s" do
+      expect(obj).to be_a klass.to_s.constantize # safeguard for Bignum
+      expect(pretty_format(obj)).to eq obj.to_s
     end
   end
 
-  context "when a Date or a Time is passed in" do
+  context "given a Date or a Time" 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!"
+      expect(self).to receive(:localize).with(t, {format: :long}) { "Just Now!" }
+      expect(pretty_format(t)).to eq "Just Now!"
+    end
+
+    context "actually do the formatting" do
+      it "should actually do the formatting" do
+        t = Time.utc(1985,"feb",28,20,15,1)
+        expect(pretty_format(t)).to eq "February 28, 1985 20:15"
+      end
+
+      context "with non-English locale" do
+        before(:all) do
+          @previous_locale = I18n.locale.to_s
+          I18n.locale = "es"
+        end
+        after(:all) do
+          I18n.locale = @previous_locale
+        end
+        it "should return a localized Date or Time with long format for non-english locale" do
+          t = Time.utc(1985,"feb",28,20,15,1)
+          expect(pretty_format(t)).to eq "28 de febrero de 1985 20:15"
+        end
+      end
     end
   end
 
-  context "when an ActiveRecord object is passed in" do
+  context "given an ActiveRecord object" 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"
+      expect(self).to receive(:auto_link).with(post) { "model name" }
+      expect(pretty_format(post)).to eq "model name"
     end
   end
 
-  context "when something else is passed in" do
-    it "should delegate to display_name" do
+  context "given an arbitrary object" 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"
+      expect(self).to receive(:display_name).with(something) { "I'm not famous" }
+      expect(pretty_format(something)).to eq "I'm not famous"
     end
   end
 end

data/spec/unit/pundit_adapter_spec.rb

@@ -0,0 +1,98 @@
+require 'rails_helper'
+
+class DefaultPolicy < ApplicationPolicy
+  def respond_to_missing?(method, include_private = false)
+    method.to_s[0...3] == "foo" || super
+  end
+
+  def method_missing(method, *args, &block)
+    if method.to_s[0...3] == "foo"
+      method.to_s[4...7] == "yes"
+    else
+      super
+    end
+  end
+
+  class Scope
+
+    attr_reader :user, :scope
+
+    def initialize(user, scope)
+      @user = user
+      @scope = scope
+    end
+
+    def resolve
+      scope
+    end
+  end
+end
+
+describe ActiveAdmin::PunditAdapter do
+
+  describe "full integration" do
+
+    let(:application) { ActiveAdmin::Application.new }
+    let(:namespace) { ActiveAdmin::Namespace.new(application, "Admin") }
+    let(:resource) { namespace.register(Post) }
+    let(:auth) { namespace.authorization_adapter.new(resource, double) }
+    let(:default_policy_klass) { DefaultPolicy }
+    let(:default_policy_klass_name) { "DefaultPolicy" }
+
+    before do
+      namespace.authorization_adapter = ActiveAdmin::PunditAdapter
+    end
+
+    it "should initialize the ability stored in the namespace configuration" do
+      expect(auth.authorized?(:read, Post)).to eq true
+      expect(auth.authorized?(:update, Post)).to eq false
+    end
+
+    it "should scope the collection" do
+      class RSpec::Mocks::DoublePolicy < ApplicationPolicy
+        class Scope < Struct.new(:user, :scope)
+          def resolve
+            scope
+          end
+        end
+      end
+
+      collection = double
+      auth.scope_collection(collection, :read)
+      expect(collection).to eq collection
+    end
+
+    it "works well with method_missing" do
+      allow(auth).to receive(:retrieve_policy).and_return(DefaultPolicy.new(double, double))
+      expect(auth.authorized?(:foo_no)).to be_falsey
+      expect(auth.authorized?(:foo_yes)).to be_truthy
+      expect(auth.authorized?(:bar_yes)).to be_falsey
+    end
+
+    context 'when Pundit is unable to find policy scope' do
+      let(:collection) { double("collection", to_sym: :collection) }
+      subject(:scope) { auth.scope_collection(collection, :read) }
+
+      before do
+        allow(ActiveAdmin.application).to receive(:pundit_default_policy).and_return default_policy_klass_name
+        allow(Pundit).to receive(:policy_scope!) { raise Pundit::NotDefinedError.new }
+      end
+
+      it("should return default policy's scope if defined") { is_expected.to eq(collection) }
+    end
+
+    context "when Pundit is unable to find policy" do
+      let(:record) { double }
+
+      subject(:policy) { auth.retrieve_policy(record) }
+
+      before do
+        allow(ActiveAdmin.application).to receive(:pundit_default_policy).and_return default_policy_klass_name
+        allow(Pundit).to receive(:policy!) { raise Pundit::NotDefinedError.new }
+      end
+
+      it("should return default policy instance") { is_expected.to be_instance_of(default_policy_klass) }
+    end
+  end
+
+end

data/spec/unit/resource/action_items_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe ActiveAdmin::Resource::ActionItems do
 
@@ -11,21 +11,21 @@ describe ActiveAdmin::Resource::ActionItems do
 
     before do
       resource.clear_action_items!
-      resource.add_action_item do
+      resource.add_action_item :empty do
         # Empty ...
       end
     end
 
     it "should add an action item" do
-      resource.action_items.size.should == 1
+      expect(resource.action_items.size).to eq 1
     end
 
     it "should store an instance of ActionItem" do
-      resource.action_items.first.should be_an_instance_of(ActiveAdmin::ActionItem)
+      expect(resource.action_items.first).to 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
+      expect(resource.action_items.first.block).to_not be_nil
     end
 
   end
@@ -34,29 +34,32 @@ describe ActiveAdmin::Resource::ActionItems do
 
     before do
       resource.clear_action_items!
-      resource.add_action_item :only => :index do
+      resource.add_action_item :new, only: :index do
         raise StandardError
       end
-      resource.add_action_item :only => :show do
+      resource.add_action_item :edit, only: :show do
         # Empty ...
       end
     end
 
     it "should return only relevant action items" do
-      resource.action_items_for(:index).size.should == 1
-      lambda {
+      expect(resource.action_items_for(:index).size).to eq 1
+      expect {
         resource.action_items_for(:index).first.call
-      }.should raise_exception(StandardError)
+      }.to raise_exception(StandardError)
     end
 
   end
 
   describe "default action items" do
-
     it "should have 3 action items" do
-      resource.action_items.size.should == 3
+      expect(resource.action_items.size).to eq 3
     end
 
+    it 'can be removed by name' do
+      resource.remove_action_item :new
+      expect(resource.action_items.size).to eq 2
+    end
   end
 
 end

data/spec/unit/resource/includes_spec.rb

@@ -0,0 +1,21 @@
+require 'rails_helper'
+
+module ActiveAdmin
+  describe Resource, "Includes" do
+    describe "#includes" do
+
+      let(:application) { ActiveAdmin::Application.new }
+      let(:namespace) { ActiveAdmin::Namespace.new application, :admin }
+      let(:resource_config) { ActiveAdmin::Resource.new namespace, Post }
+      let(:dsl){ ActiveAdmin::ResourceDSL.new(resource_config, Post) }
+
+      it "should register the includes in the config" do
+        dsl.run_registration_block do
+          includes :taggings, :author
+        end
+        expect(resource_config.includes.size).to eq(2)
+      end
+
+    end
+  end
+end

data/spec/unit/resource/menu_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 
 module ActiveAdmin
   describe Resource, "Menu" do

data/spec/unit/resource/naming_spec.rb

@@ -1,6 +1,6 @@
 # -*- coding: UTF-8 -*-
 
-require 'spec_helper'
+require 'rails_helper'
 
 module ActiveAdmin
   describe Resource, "Naming" do
@@ -20,83 +20,83 @@ module ActiveAdmin
     describe "singular resource name" do
       context "when class" do
         it "should be the underscored singular resource name" do
-          config.resource_name.singular.should == "category"
+          expect(config.resource_name.singular).to eq "category"
         end
       end
       context "when a class in a module" do
         it "should underscore the module and the class" do
-          Resource.new(namespace, Mock::Resource).resource_name.singular.should == "mock_resource"
+          expect(Resource.new(namespace, Mock::Resource).resource_name.singular).to eq "mock_resource"
         end
       end
       context "when you pass the 'as' option" do
         it "should underscore the passed through string" do
-          config(:as => "Blog Category").resource_name.singular.should == "blog_category"
+          expect(config(as: "Blog Category").resource_name.singular).to eq "blog_category"
         end
       end
     end
 
     describe "resource label" do
       it "should return a pretty name" do
-        config.resource_label.should == "Category"
+        expect(config.resource_label).to eq "Category"
       end
 
       it "should return the plural version" do
-        config.plural_resource_label.should == "Categories"
+        expect(config.plural_resource_label).to eq "Categories"
       end
 
       context "when the :as option is given" do
         it "should return the custom name" do
-          config(:as => "My Category").resource_label.should == "My Category"
+          expect(config(as: "My Category").resource_label).to eq "My Category"
         end
       end
 
       context "when a class in a module" do
         it "should include the module and the class" do
-          Resource.new(namespace, Mock::Resource).resource_label.should == "Mock Resource"
+          expect(Resource.new(namespace, Mock::Resource).resource_label).to eq "Mock Resource"
         end
 
         it "should include the module and the pluralized class" do
-          Resource.new(namespace, Mock::Resource).plural_resource_label.should == "Mock Resources"
+          expect(Resource.new(namespace, Mock::Resource).plural_resource_label).to eq "Mock Resources"
         end
       end
 
       describe "I18n integration" do
         describe "singular label" do
           it "should return the titleized model_name.human" do
-            config.resource_name.should_receive(:translate).and_return "Da category"
+            expect(config.resource_name).to receive(:translate).and_return "Da category"
 
-            config.resource_label.should == "Da category"
+            expect(config.resource_label).to eq "Da category"
           end
         end
 
         describe "plural label" do
           it "should return the titleized plural version defined by i18n if available" do
-            config.resource_name.should_receive(:translate).at_least(:once).and_return "Da categories"
-            config.plural_resource_label.should == "Da categories"
+            expect(config.resource_name).to receive(:translate).at_least(:once).and_return "Da categories"
+            expect(config.plural_resource_label).to eq "Da categories"
           end
         end
 
         describe "plural label with not default locale" do
           it "should return the titleized plural version defined by i18n with custom :count if available" do
-            config.resource_name.should_receive(:translate).at_least(:once).and_return "Категории"
-            config.plural_resource_label(:count => 3).should == "Категории"
+            expect(config.resource_name).to receive(:translate).at_least(:once).and_return "Категории"
+            expect(config.plural_resource_label(count: 3)).to eq "Категории"
           end
         end
 
         context "when the :as option is given" do
           describe "singular label" do
             it "should translate the custom name" do
-              config = config(:as => 'My Category')
-              config.resource_name.should_receive(:translate).and_return "Translated category"
-              config.resource_label.should == "Translated category"
+              config = config(as: 'My Category')
+              expect(config.resource_name).to receive(:translate).and_return "Translated category"
+              expect(config.resource_label).to eq "Translated category"
             end
           end
 
           describe "plural label" do
             it "should translate the custom name" do
-              config = config(:as => 'My Category')
-              config.resource_name.should_receive(:translate).at_least(:once).and_return "Translated categories"
-              config.plural_resource_label.should == "Translated categories"
+              config = config(as: 'My Category')
+              expect(config.resource_name).to receive(:translate).at_least(:once).and_return "Translated categories"
+              expect(config.plural_resource_label).to eq "Translated categories"
             end
           end
         end
@@ -104,5 +104,19 @@ module ActiveAdmin
       end
     end
 
+    describe "duplicate resource names" do
+      let(:resource_name) { config.resource_name }
+      let(:duplicate_resource_name) { Resource.new(namespace, Category).resource_name }
+
+      [:==, :===, :eql?].each do |method|
+        it "are equivalent when compared with #{method}" do
+          expect(resource_name.public_send(method, duplicate_resource_name)).to be_truthy
+        end
+      end
+
+      it "have identical hash values" do
+        expect(resource_name.hash).to eq duplicate_resource_name.hash
+      end
+    end
   end
 end