From b37f2d083ef447696ed960b061f9b202f3222311 Mon Sep 17 00:00:00 2001 From: Ryan Bates Date: Sun, 22 Apr 2012 14:59:32 -0700 Subject: [PATCH] switching to Rspec stubbing/mocking - no more RR --- cancan.gemspec | 5 +- spec/cancan/ability_spec.rb | 7 ++- spec/cancan/controller_additions_spec.rb | 57 ++++++++++--------- spec/cancan/controller_resource_spec.rb | 70 ++++++++++++------------ spec/cancan/inherited_resource_spec.rb | 16 +++--- spec/cancan/matchers_spec.rb | 8 +-- spec/spec_helper.rb | 1 - 7 files changed, 83 insertions(+), 81 deletions(-) diff --git a/cancan.gemspec b/cancan.gemspec index c085d18..4fc7631 100644 --- a/cancan.gemspec +++ b/cancan.gemspec @@ -10,10 +10,9 @@ Gem::Specification.new do |s| s.files = Dir["{lib,spec}/**/*", "[A-Z]*", "init.rb"] - ["Gemfile.lock"] s.require_path = "lib" - s.add_development_dependency 'rspec', '~> 2.6.0' + s.add_development_dependency 'rspec', '~> 2.9.0' s.add_development_dependency 'rails', '~> 3.0.9' - s.add_development_dependency 'rr', '~> 0.10.11' # 1.0.0 has respond_to? issues: http://github.com/btakita/rr/issues/issue/43 - s.add_development_dependency 'supermodel', '~> 0.1.4' + s.add_development_dependency 'supermodel', '~> 0.1.6' s.rubyforge_project = s.name s.required_rubygems_version = ">= 1.3.4" diff --git a/spec/cancan/ability_spec.rb b/spec/cancan/ability_spec.rb index a8b8b4f..0bccd2c 100644 --- a/spec/cancan/ability_spec.rb +++ b/spec/cancan/ability_spec.rb @@ -291,7 +291,8 @@ describe CanCan::Ability do end it "should not match subjects return nil for methods that must match nested a nested conditions hash" do - mock(object_with_foo = Object.new).foo { :bar } + object_with_foo = Object.new + object_with_foo.should_receive(:foo) { :bar } @ability.can :read, :arrays, :first => { :foo => :bar } @ability.can?(:read, [object_with_foo]).should be_true @ability.can?(:read, []).should be_false @@ -457,8 +458,8 @@ describe CanCan::Ability do it "determines model adapter class by asking AbstractAdapter" do model_class = Object.new adapter_class = Object.new - stub(CanCan::ModelAdapters::AbstractAdapter).adapter_class(model_class) { adapter_class } - stub(adapter_class).new(model_class, []) { :adapter_instance } + CanCan::ModelAdapters::AbstractAdapter.stub(:adapter_class).with(model_class) { adapter_class } + adapter_class.stub(:new).with(model_class, []) { :adapter_instance } @ability.model_adapter(model_class, :read).should == :adapter_instance end diff --git a/spec/cancan/controller_additions_spec.rb b/spec/cancan/controller_additions_spec.rb index fe7a0c0..a8a2fca 100644 --- a/spec/cancan/controller_additions_spec.rb +++ b/spec/cancan/controller_additions_spec.rb @@ -5,9 +5,9 @@ describe CanCan::ControllerAdditions do @params = HashWithIndifferentAccess.new @controller_class = Class.new @controller = @controller_class.new - stub(@controller).params { @params } - stub(@controller).current_user { :current_user } - mock(@controller_class).helper_method(:can?, :cannot?, :current_ability) + @controller.stub(:params) { @params } + @controller.stub(:current_user) { :current_user } + @controller_class.should_receive(:helper_method).with(:can?, :cannot?, :current_ability) @controller_class.send(:include, CanCan::ControllerAdditions) end @@ -22,7 +22,7 @@ describe CanCan::ControllerAdditions do end it "authorize! should pass args to current ability" do - mock(@controller.current_ability).authorize!(:foo, :bar) + @controller.current_ability.should_receive(:authorize!).with(:foo, :bar) @controller.authorize!(:foo, :bar) end @@ -33,19 +33,23 @@ describe CanCan::ControllerAdditions do end it "load_and_authorize_resource should setup a before filter which passes call to ControllerResource" do - stub(CanCan::ControllerResource).new(@controller, nil, :load => true, :authorize => true, :foo => :bar).mock!.process - mock(@controller_class).before_filter({}) { |options, block| block.call(@controller) } + controller_resource = double("controller_resource") + controller_resource.should_receive(:process) + CanCan::ControllerResource.stub(:new).with(@controller, nil, :load => true, :authorize => true, :foo => :bar) { controller_resource } + @controller_class.should_receive(:before_filter).with({}).and_yield(@controller) @controller_class.load_and_authorize_resource :foo => :bar end it "load_and_authorize_resource should properly pass first argument as the resource name" do - stub(CanCan::ControllerResource).new(@controller, :project, :load => true, :authorize => true, :foo => :bar).mock!.process - mock(@controller_class).before_filter({}) { |options, block| block.call(@controller) } + controller_resource = double("controller_resource") + controller_resource.should_receive(:process) + CanCan::ControllerResource.stub(:new).with(@controller, :project, :load => true, :authorize => true, :foo => :bar) { controller_resource } + @controller_class.should_receive(:before_filter).with({}).and_yield(@controller) @controller_class.load_and_authorize_resource :project, :foo => :bar end it "load_and_authorize_resource with :prepend should prepend the before filter" do - mock(@controller_class).prepend_before_filter({}) + @controller_class.should_receive(:prepend_before_filter).with({}) @controller_class.load_and_authorize_resource :foo => :bar, :prepend => true end @@ -54,23 +58,22 @@ describe CanCan::ControllerAdditions do end it "cancan_resource_class should be InheritedResource when class includes InheritedResources::Actions" do - stub(@controller.class).ancestors { ["InheritedResources::Actions"] } + @controller.class.stub(:ancestors) { ["InheritedResources::Actions"] } @controller.class.cancan_resource_class.should == CanCan::InheritedResource end it "enable_authorization should call authorize! with controller and action name" do @params.merge!(:controller => "projects", :action => "create") - mock(@controller).authorize!("create", "projects") - stub(@controller_class).before_filter(:only => :foo, :except => :bar) { |options, block| block.call(@controller) } - stub(@controller_class).after_filter(:only => :foo, :except => :bar) + @controller.should_receive(:authorize!).with("create", "projects") + @controller_class.stub(:before_filter).with(:only => :foo, :except => :bar).and_yield(@controller) + @controller_class.stub(:after_filter).with(:only => :foo, :except => :bar) @controller_class.enable_authorization(:only => :foo, :except => :bar) end it "enable_authorization should raise InsufficientAuthorizationCheck when not fully authoried" do @params.merge!(:controller => "projects", :action => "create") - stub(@ability).fully_authorized? { false } - stub(@controller_class).before_filter(:only => :foo, :except => :bar) - stub(@controller_class).after_filter(:only => :foo, :except => :bar) { |options, block| block.call(@controller) } + @controller_class.stub(:before_filter).with(:only => :foo, :except => :bar) + @controller_class.stub(:after_filter).with(:only => :foo, :except => :bar).and_yield(@controller) lambda { @controller_class.enable_authorization(:only => :foo, :except => :bar) }.should raise_error(CanCan::InsufficientAuthorizationCheck) @@ -78,29 +81,29 @@ describe CanCan::ControllerAdditions do it "enable_authorization should not call authorize! when :if is false" do @authorize_called = false - stub(@controller).authorize? { false } - stub(@controller).authorize! { @authorize_called = true } - mock(@controller_class).before_filter({}) { |options, block| block.call(@controller) } - mock(@controller_class).after_filter({}) { |options, block| block.call(@controller) } + @controller.stub(:authorize?) { false } + @controller.stub(:authorize!) { @authorize_called = true } + @controller_class.should_receive(:before_filter).with({}).and_yield(@controller) + @controller_class.should_receive(:after_filter).with({}).and_yield(@controller) @controller_class.enable_authorization(:if => :authorize?) @authorize_called.should be_false end it "enable_authorization should not call authorize! when :unless is true" do @authorize_called = false - stub(@controller).engine_controller? { true } - stub(@controller).authorize! { @authorize_called = true } - mock(@controller_class).before_filter({}) { |options, block| block.call(@controller) } - mock(@controller_class).after_filter({}) { |options, block| block.call(@controller) } + @controller.stub(:engine_controller?) { true } + @controller.stub(:authorize!) { @authorize_called = true } + @controller_class.should_receive(:before_filter).with({}).and_yield(@controller) + @controller_class.should_receive(:after_filter).with({}).and_yield(@controller) @controller_class.enable_authorization(:unless => :engine_controller?) @authorize_called.should be_false end it "enable_authorization should pass block to rescue_from CanCan::Unauthorized call" do @block_called = false - mock(@controller_class).before_filter({}) - mock(@controller_class).after_filter({}) - mock(@controller_class).rescue_from(CanCan::Unauthorized) { |options, block| block.call(:exception) } + @controller_class.should_receive(:before_filter).with({}) + @controller_class.should_receive(:after_filter).with({}) + @controller_class.should_receive(:rescue_from).with(CanCan::Unauthorized).and_yield(:exception) @controller_class.enable_authorization { |e| @block_called = (e == :exception) } @block_called.should be_true end diff --git a/spec/cancan/controller_resource_spec.rb b/spec/cancan/controller_resource_spec.rb index 8e4a407..e1cf572 100644 --- a/spec/cancan/controller_resource_spec.rb +++ b/spec/cancan/controller_resource_spec.rb @@ -6,10 +6,10 @@ describe CanCan::ControllerResource do @controller_class = Class.new @controller = @controller_class.new @ability = Ability.new(nil) - stub(@controller).params { @params } - stub(@controller).current_ability { @ability } - stub(@controller).authorize! { |*args| @ability.authorize!(*args) } - # stub(@controller_class).cancan_skipper { {:authorize => {}, :load => {}} } + @controller.stub(:params) { @params } + @controller.stub(:current_ability) { @ability } + @controller.stub(:authorize!) { |*args| @ability.authorize!(*args) } + # @controller_class.stub(:cancan_skipper) { {:authorize => {}, :load => {}} } end it "should load the resource into an instance variable if params[:id] is specified" do @@ -61,7 +61,7 @@ describe CanCan::ControllerResource do end it "should build a collection when on index action when class responds to accessible_by and mark ability as fully authorized" do - stub(Project).accessible_by(@ability, :index) { :found_projects } + Project.stub(:accessible_by).with(@ability, :index) { :found_projects } @params[:action] = "index" CanCan::ControllerResource.new(@controller, :project, :load => true).process @controller.instance_variable_get(:@project).should be_nil @@ -78,7 +78,7 @@ describe CanCan::ControllerResource do end it "should not use accessible_by when defining abilities through a block" do - stub(Project).accessible_by(@ability) { :found_projects } + Project.stub(:accessible_by).with(@ability) { :found_projects } @params[:action] = "index" @ability.can(:read, :projects) { |p| false } CanCan::ControllerResource.new(@controller, :load => true).process @@ -89,7 +89,7 @@ describe CanCan::ControllerResource do it "should not authorize resource in collection action" do @params[:action] = "index" @controller.instance_variable_set(:@project, :some_project) - stub(@controller).authorize!(:index, :projects) { raise CanCan::Unauthorized } + @controller.stub(:authorize!).with(:index, :projects) { raise CanCan::Unauthorized } resource = CanCan::ControllerResource.new(@controller, :authorize => true) lambda { resource.process }.should_not raise_error(CanCan::Unauthorized) end @@ -97,7 +97,7 @@ describe CanCan::ControllerResource do it "should authorize parent resource in collection action" do @params[:action] = "index" @controller.instance_variable_set(:@category, :some_category) - stub(@controller).authorize!(:show, :some_category) { raise CanCan::Unauthorized } + @controller.stub(:authorize!).with(:show, :some_category) { raise CanCan::Unauthorized } resource = CanCan::ControllerResource.new(@controller, :category, :parent => true, :authorize => true) lambda { resource.process }.should raise_error(CanCan::Unauthorized) end @@ -105,14 +105,14 @@ describe CanCan::ControllerResource do it "should perform authorization using controller action and loaded model" do @params.merge!(:action => "show", :id => 123) @controller.instance_variable_set(:@project, :some_project) - stub(@controller).authorize!(:show, :some_project) { raise CanCan::Unauthorized } + @controller.stub(:authorize!).with(:show, :some_project) { raise CanCan::Unauthorized } resource = CanCan::ControllerResource.new(@controller, :authorize => true) lambda { resource.process }.should raise_error(CanCan::Unauthorized) end it "should not perform authorization using controller action when no loaded model" do @params.merge!(:action => "show", :id => 123) - stub(@controller).authorize!(:show, :projects) { raise CanCan::Unauthorized } + @controller.stub(:authorize!).with(:show, :projects) { raise CanCan::Unauthorized } resource = CanCan::ControllerResource.new(@controller, :authorize => true) lambda { resource.process }.should_not raise_error(CanCan::Unauthorized) end @@ -124,7 +124,7 @@ describe CanCan::ControllerResource do end it "should load a collection resource when on custom action with no id param" do - stub(Project).accessible_by(@ability, :sort) { :found_projects } + Project.stub(:accessible_by).with(@ability, :sort) { :found_projects } @params[:action] = "sort" CanCan::ControllerResource.new(@controller, :load => true).process @controller.instance_variable_get(:@project).should be_nil @@ -133,7 +133,7 @@ describe CanCan::ControllerResource do it "should build a resource when on custom new action even when params[:id] exists" do @params.merge!(:action => "build", :id => 123) - stub(Project).new { :some_project } + Project.stub(:new) { :some_project } CanCan::ControllerResource.new(@controller, :load => true, :new => :build).process @controller.instance_variable_get(:@project).should == :some_project end @@ -173,27 +173,27 @@ describe CanCan::ControllerResource do it "should load resource through the association of another parent resource using instance variable" do @params.merge!(:action => "show", :id => 123) - category = Object.new + category = double("category", :projects => double("projects")) + category.projects.stub(:find).with(123) { :some_project } @controller.instance_variable_set(:@category, category) - stub(category).projects.stub!.find(123) { :some_project } CanCan::ControllerResource.new(@controller, :load => true, :through => :category).process @controller.instance_variable_get(:@project).should == :some_project end it "should load resource through the custom association name" do @params.merge!(:action => "show", :id => 123) - category = Object.new + category = double("category", :custom_projects => double("custom_projects")) + category.custom_projects.stub(:find).with(123) { :some_project } @controller.instance_variable_set(:@category, category) - stub(category).custom_projects.stub!.find(123) { :some_project } CanCan::ControllerResource.new(@controller, :load => true, :through => :category, :through_association => :custom_projects).process @controller.instance_variable_get(:@project).should == :some_project end it "should load resource through the association of another parent resource using method" do @params.merge!(:action => "show", :id => 123) - category = Object.new - stub(@controller).category { category } - stub(category).projects.stub!.find(123) { :some_project } + category = double("category", :projects => double("projects")) + @controller.stub(:category) { category } + category.projects.stub(:find).with(123) { :some_project } CanCan::ControllerResource.new(@controller, :load => true, :through => :category).process @controller.instance_variable_get(:@project).should == :some_project end @@ -223,16 +223,16 @@ describe CanCan::ControllerResource do @params.merge!(:action => "index") category = Object.new @controller.instance_variable_set(:@category, category) - stub(@controller).authorize!(:index, category => :projects) { raise CanCan::Unauthorized } + @controller.stub(:authorize!).with(:index, category => :projects) { raise CanCan::Unauthorized } resource = CanCan::ControllerResource.new(@controller, :authorize => true, :through => :category) lambda { resource.process }.should raise_error(CanCan::Unauthorized) end it "should load through first matching if multiple are given" do @params.merge!(:action => "show", :id => 123) - category = Object.new + category = double("category", :projects => double("projects")) + category.projects.stub(:find).with(123) { :some_project } @controller.instance_variable_set(:@category, category) - stub(category).projects.stub!.find(123) { :some_project } CanCan::ControllerResource.new(@controller, :load => true, :through => [:category, :user]).process @controller.instance_variable_get(:@project).should == :some_project end @@ -241,7 +241,7 @@ describe CanCan::ControllerResource do @params.merge!(:action => "show", :id => nil) category = Object.new @controller.instance_variable_set(:@category, category) - stub(category).project { :some_project } + category.stub(:project) { :some_project } CanCan::ControllerResource.new(@controller, :load => true, :through => :category, :singleton => true).process @controller.instance_variable_get(:@project).should == :some_project end @@ -271,7 +271,7 @@ describe CanCan::ControllerResource do it "should only authorize :show action on parent resource" do project = Project.create! @params.merge!(:action => "new", :project_id => project.id) - stub(@controller).authorize!(:show, project) { raise CanCan::Unauthorized } + @controller.stub(:authorize!).with(:show, project) { raise CanCan::Unauthorized } resource = CanCan::ControllerResource.new(@controller, :project, :load => true, :authorize => true, :parent => true) lambda { resource.process }.should raise_error(CanCan::Unauthorized) end @@ -301,7 +301,7 @@ describe CanCan::ControllerResource do it "should not authorize based on resource name if class is false because we don't do class level authorization anymore" do @params.merge!(:action => "show", :id => 123) - stub(@controller).authorize!(:show, :projects) { raise CanCan::Unauthorized } + @controller.stub(:authorize!).with(:show, :projects) { raise CanCan::Unauthorized } resource = CanCan::ControllerResource.new(@controller, :authorize => true, :class => false) lambda { resource.process }.should_not raise_error(CanCan::Unauthorized) end @@ -309,7 +309,7 @@ describe CanCan::ControllerResource do it "should load and authorize using custom instance name" do project = Project.create! @params.merge!(:action => "show", :id => project.id) - stub(@controller).authorize!(:show, project) { raise CanCan::Unauthorized } + @controller.stub(:authorize!).with(:show, project) { raise CanCan::Unauthorized } resource = CanCan::ControllerResource.new(@controller, :load => true, :authorize => true, :instance_name => :custom_project) lambda { resource.process }.should raise_error(CanCan::Unauthorized) @controller.instance_variable_get(:@custom_project).should == project @@ -333,7 +333,7 @@ describe CanCan::ControllerResource do it "should authorize each new attribute in the create action" do @params.merge!(:action => "create", :project => {:name => "foo"}) @controller.instance_variable_set(:@project, :some_project) - mock(@controller).authorize!(:create, :some_project, :name) + @ability.should_receive(:authorize!).with(:create, :some_project, :name) CanCan::ControllerResource.new(@controller, :authorize => true).process end @@ -347,14 +347,14 @@ describe CanCan::ControllerResource do it "should authorize each new attribute in the update action" do @params.merge!(:action => "update", :id => 123, :project => {:name => "foo"}) @controller.instance_variable_set(:@project, :some_project) - mock(@controller).authorize!(:update, :some_project, :name) + @ability.should_receive(:authorize!).with(:update, :some_project, :name) CanCan::ControllerResource.new(@controller, :authorize => true).process end it "should fetch member through method when instance variable is not provided" do - stub(@controller).project { :some_project } + @controller.stub(:project) { :some_project } @params.merge!(:action => "show", :id => 123) - stub(@controller).authorize!(:show, :some_project) { raise CanCan::Unauthorized } + @controller.stub(:authorize!).with(:show, :some_project) { raise CanCan::Unauthorized } resource = CanCan::ControllerResource.new(@controller, :authorize => true) lambda { resource.process }.should raise_error(CanCan::Unauthorized) end @@ -398,7 +398,7 @@ describe CanCan::ControllerResource do # end # it "should skip resource behavior for :only actions in array" do - # stub(@controller_class).cancan_skipper { {:load => {nil => {:only => [:index, :show]}}} } + # @controller_class.stub(:cancan_skipper) { {:load => {nil => {:only => [:index, :show]}}} } # @params.merge!(:action => "index") # CanCan::ControllerResource.new(@controller).skip?(:load).should be_true # CanCan::ControllerResource.new(@controller, :some_resource).skip?(:load).should be_false @@ -409,7 +409,7 @@ describe CanCan::ControllerResource do # end # # it "should skip resource behavior for :only one action on resource" do - # stub(@controller_class).cancan_skipper { {:authorize => {:project => {:only => :index}}} } + # @controller_class.stub(:cancan_skipper) { {:authorize => {:project => {:only => :index}}} } # @params.merge!(:action => "index") # CanCan::ControllerResource.new(@controller).skip?(:authorize).should be_false # CanCan::ControllerResource.new(@controller, :project).skip?(:authorize).should be_true @@ -418,7 +418,7 @@ describe CanCan::ControllerResource do # end # # it "should skip resource behavior :except actions in array" do - # stub(@controller_class).cancan_skipper { {:load => {nil => {:except => [:index, :show]}}} } + # @controller_class.stub(:cancan_skipper) { {:load => {nil => {:except => [:index, :show]}}} } # @params.merge!(:action => "index") # CanCan::ControllerResource.new(@controller).skip?(:load).should be_false # @params.merge!(:action => "show") @@ -429,7 +429,7 @@ describe CanCan::ControllerResource do # end # # it "should skip resource behavior :except one action on resource" do - # stub(@controller_class).cancan_skipper { {:authorize => {:project => {:except => :index}}} } + # @controller_class.stub(:cancan_skipper) { {:authorize => {:project => {:except => :index}}} } # @params.merge!(:action => "index") # CanCan::ControllerResource.new(@controller, :project).skip?(:authorize).should be_false # @params.merge!(:action => "other_action") @@ -438,7 +438,7 @@ describe CanCan::ControllerResource do # end # # it "should skip loading and authorization" do - # stub(@controller_class).cancan_skipper { {:authorize => {nil => {}}, :load => {nil => {}}} } + # @controller_class.stub(:cancan_skipper) { {:authorize => {nil => {}}, :load => {nil => {}}} } # @params.merge!(:action => "new") # resource = CanCan::ControllerResource.new(@controller) # lambda { resource.load_and_authorize_resource }.should_not raise_error diff --git a/spec/cancan/inherited_resource_spec.rb b/spec/cancan/inherited_resource_spec.rb index 0a03549..ea69c9c 100644 --- a/spec/cancan/inherited_resource_spec.rb +++ b/spec/cancan/inherited_resource_spec.rb @@ -6,36 +6,36 @@ describe CanCan::InheritedResource do @controller_class = Class.new @controller = @controller_class.new @ability = Ability.new(nil) - stub(@controller).params { @params } - stub(@controller).current_ability { @ability } - # stub(@controller_class).cancan_skipper { {:authorize => {}, :load => {}} } + @controller.stub(:params) { @params } + @controller.stub(:current_ability) { @ability } + # @controller_class.stub(:cancan_skipper) { {:authorize => {}, :load => {}} } end it "show should load resource through @controller.resource" do @params.merge!(:action => "show", :id => 123) - stub(@controller).resource { :project_resource } + @controller.stub(:resource) { :project_resource } CanCan::InheritedResource.new(@controller, :load => true).process @controller.instance_variable_get(:@project).should == :project_resource end it "new should load through @controller.build_resource" do @params[:action] = "new" - stub(@controller).build_resource { :project_resource } + @controller.stub(:build_resource) { :project_resource } CanCan::InheritedResource.new(@controller, :load => true).process @controller.instance_variable_get(:@project).should == :project_resource end it "index should load through @controller.association_chain when parent" do @params[:action] = "index" - stub(@controller).association_chain { @controller.instance_variable_set(:@project, :project_resource) } + @controller.stub(:association_chain) { @controller.instance_variable_set(:@project, :project_resource) } CanCan::InheritedResource.new(@controller, :load => true, :parent => true).process @controller.instance_variable_get(:@project).should == :project_resource end it "index should load through @controller.end_of_association_chain" do @params[:action] = "index" - stub(Project).accessible_by(@ability, :index) { :projects } - stub(@controller).end_of_association_chain { Project } + Project.stub(:accessible_by).with(@ability, :index) { :projects } + @controller.stub(:end_of_association_chain) { Project } CanCan::InheritedResource.new(@controller, :load => true).process @controller.instance_variable_get(:@projects).should == :projects end diff --git a/spec/cancan/matchers_spec.rb b/spec/cancan/matchers_spec.rb index de6a439..9e4eefe 100644 --- a/spec/cancan/matchers_spec.rb +++ b/spec/cancan/matchers_spec.rb @@ -3,13 +3,13 @@ require "spec_helper" describe "be_able_to" do it "delegates to can?" do object = Object.new - mock(object).can?(:read, 123) { true } + object.should_receive(:can?).with(:read, 123) { true } object.should be_able_to(:read, 123) end it "reports a nice failure message for should" do object = Object.new - mock(object).can?(:read, 123) { false } + object.should_receive(:can?).with(:read, 123) { false } expect do object.should be_able_to(:read, 123) end.should raise_error('expected to be able to :read 123') @@ -17,7 +17,7 @@ describe "be_able_to" do it "reports a nice failure message for should not" do object = Object.new - mock(object).can?(:read, 123) { true } + object.should_receive(:can?).with(:read, 123) { true } expect do object.should_not be_able_to(:read, 123) end.should raise_error('expected not to be able to :read 123') @@ -25,7 +25,7 @@ describe "be_able_to" do it "delegates additional arguments to can? and reports in failure message" do object = Object.new - mock(object).can?(:read, 123, 456) { false } + object.should_receive(:can?).with(:read, 123, 456) { false } expect do object.should be_able_to(:read, 123, 456) end.should raise_error('expected to be able to :read 123 456') diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb index 30489e2..834b127 100644 --- a/spec/spec_helper.rb +++ b/spec/spec_helper.rb @@ -13,7 +13,6 @@ RSpec.configure do |config| config.filter_run :focus => true config.run_all_when_everything_filtered = true - config.mock_with :rr config.before(:each) do Project.delete_all Category.delete_all