will/cancan
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

adding enable_authorization method and deprecating some other controller methods

Browse Source
This commit is contained in:
Ryan Bates
2011-03-24 11:22:32 -07:00
parent 3a825ed0d1
commit 7ee942c334
2 changed files with 57 additions and 117 deletions
Download Patch File Download Diff File Expand all files Collapse all files
spec/cancan/controller_additions_spec.rb
+30 -82
View File
@@ -2,26 +2,28 @@ require "spec_helper"
describe CanCan::ControllerAdditions do
before(:each) do
@params = HashWithIndifferentAccess.new
@controller_class = Class.new
@controller = @controller_class.new
stub(@controller).params { {} }
stub(@controller).params { @params }
stub(@controller).current_user { :current_user }
mock(@controller_class).helper_method(:can?, :cannot?)
@controller_class.send(:include, CanCan::ControllerAdditions)
end
it "should raise ImplementationRemoved when attempting to call 'unauthorized!' on a controller" do
lambda { @controller.unauthorized! }.should raise_error(CanCan::ImplementationRemoved)
it "should raise ImplementationRemoved when attempting to call load/authorize/skip/check calls on a controller" do
lambda { @controller_class.load_resource }.should raise_error(CanCan::ImplementationRemoved)
lambda { @controller_class.authorize_resource }.should raise_error(CanCan::ImplementationRemoved)
lambda { @controller_class.skip_load_resource }.should raise_error(CanCan::ImplementationRemoved)
lambda { @controller_class.skip_authorize_resource }.should raise_error(CanCan::ImplementationRemoved)
lambda { @controller_class.check_authorization }.should raise_error(CanCan::ImplementationRemoved)
lambda { @controller_class.skip_authorization_check }.should raise_error(CanCan::ImplementationRemoved)
lambda { @controller_class.cancan_skipper }.should raise_error(CanCan::ImplementationRemoved)
end
it "authorize! should assign @_authorized instance variable and pass args to current ability" do
it "authorize! should pass args to current ability" do
mock(@controller.current_ability).authorize!(:foo, :bar)
@controller.authorize!(:foo, :bar)
@controller.instance_variable_get(:@_authorized).should be_true
end
it "should have a current_ability method which generates an ability for the current user" do
@controller.current_ability.should be_kind_of(Ability)
end
it "should provide a can? and cannot? methods which go through the current ability" do
@@ -47,55 +49,6 @@ describe CanCan::ControllerAdditions do
@controller_class.load_and_authorize_resource :foo => :bar, :prepend => true
end
it "authorize_resource should setup a before filter which passes call to ControllerResource" do
stub(CanCan::ControllerResource).new(@controller, nil, :foo => :bar).mock!.authorize_resource
mock(@controller_class).before_filter(:except => :show) { |options, block| block.call(@controller) }
@controller_class.authorize_resource :foo => :bar, :except => :show
end
it "load_resource should setup a before filter which passes call to ControllerResource" do
stub(CanCan::ControllerResource).new(@controller, nil, :foo => :bar).mock!.load_resource
mock(@controller_class).before_filter(:only => [:show, :index]) { |options, block| block.call(@controller) }
@controller_class.load_resource :foo => :bar, :only => [:show, :index]
end
it "skip_authorization_check should set up a before filter which sets @_authorized to true" do
mock(@controller_class).before_filter(:filter_options) { |options, block| block.call(@controller) }
@controller_class.skip_authorization_check(:filter_options)
@controller.instance_variable_get(:@_authorized).should be_true
end
it "check_authorization should trigger AuthorizationNotPerformed in after filter" do
mock(@controller_class).after_filter(:only => [:test]) { |options, block| block.call(@controller) }
lambda {
@controller_class.check_authorization(:only => [:test])
}.should raise_error(CanCan::AuthorizationNotPerformed)
end
it "check_authorization should not trigger AuthorizationNotPerformed when :if is false" do
stub(@controller).check_auth? { false }
mock(@controller_class).after_filter({}) { |options, block| block.call(@controller) }
lambda {
@controller_class.check_authorization(:if => :check_auth?)
}.should_not raise_error(CanCan::AuthorizationNotPerformed)
end
it "check_authorization should not trigger AuthorizationNotPerformed when :unless is true" do
stub(@controller).engine_controller? { true }
mock(@controller_class).after_filter({}) { |options, block| block.call(@controller) }
lambda {
@controller_class.check_authorization(:unless => :engine_controller?)
}.should_not raise_error(CanCan::AuthorizationNotPerformed)
end
it "check_authorization should not raise error when @_authorized is set" do
@controller.instance_variable_set(:@_authorized, true)
mock(@controller_class).after_filter(:only => [:test]) { |options, block| block.call(@controller) }
lambda {
@controller_class.check_authorization(:only => [:test])
}.should_not raise_error(CanCan::AuthorizationNotPerformed)
end
it "cancan_resource_class should be ControllerResource by default" do
@controller.class.cancan_resource_class.should == CanCan::ControllerResource
end
@@ -105,33 +58,28 @@ describe CanCan::ControllerAdditions do
@controller.class.cancan_resource_class.should == CanCan::InheritedResource
end
it "cancan_skipper should be an empty hash with :authorize and :load options and remember changes" do
@controller_class.cancan_skipper.should == {:authorize => {}, :load => {}}
@controller_class.cancan_skipper[:load] = true
@controller_class.cancan_skipper[:load].should == true
it "enable_authorization should call authorize! with controller and action name" do
@params.merge!(:controller => "projects", :action => "create")
mock(@controller_class).authorize!("create", "projects")
stub(@controller_class).before_filter(:only => :foo, :except => :bar) { |options, block| block.call(@controller) }
@controller_class.enable_authorization(:only => :foo, :except => :bar)
end
it "skip_authorize_resource should add itself to the cancan skipper with given model name and options" do
@controller_class.skip_authorize_resource(:project, :only => [:index, :show])
@controller_class.cancan_skipper[:authorize][:project].should == {:only => [:index, :show]}
@controller_class.skip_authorize_resource(:only => [:index, :show])
@controller_class.cancan_skipper[:authorize][nil].should == {:only => [:index, :show]}
@controller_class.skip_authorize_resource(:article)
@controller_class.cancan_skipper[:authorize][:article].should == {}
it "enable_authorization should not not call authorize! when :if is false" do
@authorize_called = false
stub(@controller).authorize? { false }
stub(@controller_class).authorize! { @authorize_called = true }
mock(@controller_class).before_filter({}) { |options, block| block.call(@controller) }
@controller_class.enable_authorization(:if => :authorize?)
@authorize_called.should be_false
end
it "skip_load_resource should add itself to the cancan skipper with given model name and options" do
@controller_class.skip_load_resource(:project, :only => [:index, :show])
@controller_class.cancan_skipper[:load][:project].should == {:only => [:index, :show]}
@controller_class.skip_load_resource(:only => [:index, :show])
@controller_class.cancan_skipper[:load][nil].should == {:only => [:index, :show]}
@controller_class.skip_load_resource(:article)
@controller_class.cancan_skipper[:load][:article].should == {}
end
it "skip_load_and_authore_resource should add itself to the cancan skipper with given model name and options" do
@controller_class.skip_load_and_authorize_resource(:project, :only => [:index, :show])
@controller_class.cancan_skipper[:load][:project].should == {:only => [:index, :show]}
@controller_class.cancan_skipper[:authorize][:project].should == {:only => [:index, :show]}
it "enable_authorization should not trigger AuthorizationNotPerformed when :unless is true" do
@authorize_called = false
stub(@controller).engine_controller? { true }
stub(@controller_class).authorize! { @authorize_called = true }
mock(@controller_class).before_filter({}) { |options, block| block.call(@controller) }
@controller_class.enable_authorization(:unless => :engine_controller?)
@authorize_called.should be_false
end
end