cancan 1.3.4 → 1.4.1

data/spec/cancan/active_record_additions_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe CanCan::ActiveRecordAdditions do
   before(:each) do
-    @model_class = Class.new(Person)
+    @model_class = Class.new(Project)
     stub(@model_class).scoped { :scoped_stub }
     @model_class.send(:include, CanCan::ActiveRecordAdditions)
     @ability = Object.new
@@ -10,12 +10,14 @@ describe CanCan::ActiveRecordAdditions do
   end
 
   it "should call where('true=false') when no ability is defined so no records are found" do
+    stub(@model_class).joins { true } # just so it responds to .joins as well
     stub(@model_class).where('true=false').stub!.joins(nil) { :no_match }
     @model_class.accessible_by(@ability, :read).should == :no_match
   end
 
   it "should call where with matching ability conditions" do
     @ability.can :read, @model_class, :foo => {:bar => 1}
+    stub(@model_class).joins { true } # just so it responds to .joins as well
     stub(@model_class).where(:foos => { :bar => 1 }).stub!.joins([:foo]) { :found_records }
     @model_class.accessible_by(@ability, :read).should == :found_records
   end
@@ -48,4 +50,26 @@ describe CanCan::ActiveRecordAdditions do
     # @ability.associations_hash(:read, @model_class).should == [{:too => [:far]}, :foo]
     @model_class.accessible_by(@ability).should == :found_records
   end
+
+  it "should allow to define sql conditions by not hash" do
+    @ability.can :read, @model_class, :foo => 1
+    @ability.can :read, @model_class, ['bar = ?', 1]
+    stub(@model_class).scoped( :conditions => '(bar = 1) OR (foo=1)', :joins => nil ) { :found_records }
+    stub(@model_class).scoped{|*args| args.inspect}
+    @model_class.accessible_by(@ability).should == :found_records
+  end
+
+  it "should not allow to fetch records when ability with just block present" do
+    @ability.can :read, @model_class do false end
+    lambda {
+      @model_class.accessible_by(@ability)
+    }.should raise_error(CanCan::Error)
+  end
+
+  it "should not allow to check ability on object when nonhash sql ability definition without block present" do
+    @ability.can :read, @model_class, ['bar = ?', 1]
+    lambda {
+      @ability.can? :read, @model_class.new
+    }.should raise_error(CanCan::Error)
+  end
 end

data/spec/cancan/can_definition_spec.rb

@@ -1,5 +1,6 @@
 require "spec_helper"
 
+# Most of CanDefinition functionality is tested in Ability specs
 describe CanCan::CanDefinition do
   before(:each) do
     @conditions = {}

data/spec/cancan/controller_additions_spec.rb

@@ -14,32 +14,10 @@ describe CanCan::ControllerAdditions do
     lambda { @controller.unauthorized! }.should raise_error(CanCan::ImplementationRemoved)
   end
 
-  it "should raise access denied exception if ability us unauthorized to perform a certain action" do
-    begin
-      @controller.authorize! :read, :foo, 1, 2, 3, :message => "Access denied!"
-    rescue CanCan::AccessDenied => e
-      e.message.should == "Access denied!"
-      e.action.should == :read
-      e.subject.should == :foo
-    else
-      fail "Expected CanCan::AccessDenied exception to be raised"
-    end
-  end
-
-  it "should not raise access denied exception if ability is authorized to perform an action" do
-    @controller.current_ability.can :read, :foo
-    lambda { @controller.authorize!(:read, :foo) }.should_not raise_error
-  end
-
-  it "should raise access denied exception with default message if not specified" do
-    begin
-      @controller.authorize! :read, :foo
-    rescue CanCan::AccessDenied => e
-      e.default_message = "Access denied!"
-      e.message.should == "Access denied!"
-    else
-      fail "Expected CanCan::AccessDenied exception to be raised"
-    end
+  it "authorize! should assign @_authorized instance variable and 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
@@ -75,4 +53,34 @@ describe CanCan::ControllerAdditions do
     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(:some_options) { |options, block| block.call(@controller) }
+    lambda {
+      @controller_class.check_authorization(:some_options)
+    }.should 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(:some_options) { |options, block| block.call(@controller) }
+    lambda {
+      @controller_class.check_authorization(:some_options)
+    }.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
+
+  it "cancan_resource_class should be InheritedResource when class includes InheritedResources::Actions" do
+    stub(@controller.class).ancestors { ["InheritedResources::Actions"] }
+    @controller.class.cancan_resource_class.should == CanCan::InheritedResource
+  end
 end

data/spec/cancan/controller_resource_spec.rb

@@ -2,77 +2,106 @@ require "spec_helper"
 
 describe CanCan::ControllerResource do
   before(:each) do
-    @params = HashWithIndifferentAccess.new(:controller => "abilities")
+    @params = HashWithIndifferentAccess.new(:controller => "projects")
     @controller = Object.new # simple stub for now
+    @ability = Ability.new(nil)
     stub(@controller).params { @params }
+    stub(@controller).current_ability { @ability }
   end
 
   it "should load the resource into an instance variable if params[:id] is specified" do
-    @params.merge!(:action => "show", :id => 123)
-    stub(Ability).find(123) { :some_resource }
+    project = Project.create!
+    @params.merge!(:action => "show", :id => project.id)
     resource = CanCan::ControllerResource.new(@controller)
     resource.load_resource
-    @controller.instance_variable_get(:@ability).should == :some_resource
+    @controller.instance_variable_get(:@project).should == project
   end
 
   it "should not load resource into an instance variable if already set" do
     @params.merge!(:action => "show", :id => 123)
-    @controller.instance_variable_set(:@ability, :some_ability)
+    @controller.instance_variable_set(:@project, :some_project)
     resource = CanCan::ControllerResource.new(@controller)
     resource.load_resource
-    @controller.instance_variable_get(:@ability).should == :some_ability
+    @controller.instance_variable_get(:@project).should == :some_project
   end
 
   it "should properly load resource for namespaced controller" do
-    @params.merge!(:controller => "admin/abilities", :action => "show", :id => 123)
-    stub(Ability).find(123) { :some_resource }
+    project = Project.create!
+    @params.merge!(:controller => "admin/projects", :action => "show", :id => project.id)
     resource = CanCan::ControllerResource.new(@controller)
     resource.load_resource
-    @controller.instance_variable_get(:@ability).should == :some_resource
+    @controller.instance_variable_get(:@project).should == project
   end
 
   it "should properly load resource for namespaced controller when using '::' for namespace" do
-    @params.merge!(:controller => "Admin::AbilitiesController", :action => "show", :id => 123)
-    stub(Ability).find(123) { :some_resource }
+    project = Project.create!
+    @params.merge!(:controller => "Admin::ProjectsController", :action => "show", :id => project.id)
     resource = CanCan::ControllerResource.new(@controller)
     resource.load_resource
-    @controller.instance_variable_get(:@ability).should == :some_resource
+    @controller.instance_variable_get(:@project).should == project
   end
 
   it "should build a new resource with hash if params[:id] is not specified" do
-    @params.merge!(:action => "create", :ability => {:foo => "bar"})
-    stub(Ability).new("foo" => "bar") { :some_resource }
+    @params.merge!(:action => "create", :project => {:name => "foobar"})
+    resource = CanCan::ControllerResource.new(@controller)
+    resource.load_resource
+    @controller.instance_variable_get(:@project).name.should == "foobar"
+  end
+
+  it "should build a new resource with attributes from current ability" do
+    @params.merge!(:action => "new")
+    @ability.can(:create, Project, :name => "from conditions")
     resource = CanCan::ControllerResource.new(@controller)
     resource.load_resource
-    @controller.instance_variable_get(:@ability).should == :some_resource
+    @controller.instance_variable_get(:@project).name.should == "from conditions"
   end
 
-  it "should build a new resource with no arguments if attribute hash isn't specified" do
-    @params[:action] = "new"
-    mock(Ability).new { :some_resource }
+  it "should override initial attributes with params" do
+    @params.merge!(:action => "new", :project => {:name => "from params"})
+    @ability.can(:create, Project, :name => "from conditions")
     resource = CanCan::ControllerResource.new(@controller)
     resource.load_resource
-    @controller.instance_variable_get(:@ability).should == :some_resource
+    @controller.instance_variable_get(:@project).name.should == "from params"
+  end
+
+  it "should build a collection when on index action when class responds to accessible_by" do
+    stub(Project).accessible_by(@ability) { :found_projects }
+    @params[:action] = "index"
+    resource = CanCan::ControllerResource.new(@controller, :project)
+    resource.load_resource
+    @controller.instance_variable_get(:@project).should be_nil
+    @controller.instance_variable_get(:@projects).should == :found_projects
   end
 
-  it "should not build a resource when on index action" do
+  it "should not build a collection when on index action when class does not respond to accessible_by" do
     @params[:action] = "index"
     resource = CanCan::ControllerResource.new(@controller)
     resource.load_resource
-    @controller.instance_variable_get(:@ability).should be_nil
+    @controller.instance_variable_get(:@project).should be_nil
+    @controller.instance_variable_defined?(:@projects).should be_false
+  end
+
+  it "should not use accessible_by when defining abilities through a block" do
+    stub(Project).accessible_by(@ability) { :found_projects }
+    @params[:action] = "index"
+    @ability.can(:read, Project) { |p| false }
+    resource = CanCan::ControllerResource.new(@controller)
+    resource.load_resource
+    @controller.instance_variable_get(:@project).should be_nil
+    @controller.instance_variable_defined?(:@projects).should be_false
   end
 
   it "should perform authorization using controller action and loaded model" do
     @params[:action] = "show"
-    @controller.instance_variable_set(:@ability, :some_resource)
-    stub(@controller).authorize!(:show, :some_resource) { raise CanCan::AccessDenied }
+    @controller.instance_variable_set(:@project, :some_project)
+    stub(@controller).authorize!(:show, :some_project) { raise CanCan::AccessDenied }
     resource = CanCan::ControllerResource.new(@controller)
     lambda { resource.authorize_resource }.should raise_error(CanCan::AccessDenied)
   end
 
   it "should perform authorization using controller action and non loaded model" do
     @params[:action] = "show"
-    stub(@controller).authorize!(:show, Ability) { raise CanCan::AccessDenied }
+    stub(@controller).authorize!(:show, Project) { raise CanCan::AccessDenied }
     resource = CanCan::ControllerResource.new(@controller)
     lambda { resource.authorize_resource }.should raise_error(CanCan::AccessDenied)
   end
@@ -89,146 +118,192 @@ describe CanCan::ControllerResource do
     @params[:action] = "sort"
     resource = CanCan::ControllerResource.new(@controller, :collection => [:sort, :list])
     resource.load_resource
-    @controller.instance_variable_get(:@ability).should be_nil
+    @controller.instance_variable_get(:@project).should be_nil
   end
 
   it "should build a resource when on custom new action even when params[:id] exists" do
     @params.merge!(:action => "build", :id => 123)
-    stub(Ability).new { :some_resource }
+    stub(Project).new { :some_project }
     resource = CanCan::ControllerResource.new(@controller, :new => :build)
     resource.load_resource
-    @controller.instance_variable_get(:@ability).should == :some_resource
+    @controller.instance_variable_get(:@project).should == :some_project
   end
 
   it "should not try to load resource for other action if params[:id] is undefined" do
     @params[:action] = "list"
     resource = CanCan::ControllerResource.new(@controller)
     resource.load_resource
-    @controller.instance_variable_get(:@ability).should be_nil
+    @controller.instance_variable_get(:@project).should be_nil
   end
 
   it "should be a parent resource when name is provided which doesn't match controller" do
-    resource = CanCan::ControllerResource.new(@controller, :person)
+    resource = CanCan::ControllerResource.new(@controller, :category)
     resource.should be_parent
   end
 
   it "should not be a parent resource when name is provided which matches controller" do
-    resource = CanCan::ControllerResource.new(@controller, :ability)
+    resource = CanCan::ControllerResource.new(@controller, :project)
     resource.should_not be_parent
   end
 
   it "should be parent if specified in options" do
-    resource = CanCan::ControllerResource.new(@controller, :ability, {:parent => true})
+    resource = CanCan::ControllerResource.new(@controller, :project, {:parent => true})
     resource.should be_parent
   end
 
   it "should not be parent if specified in options" do
-    resource = CanCan::ControllerResource.new(@controller, :person, {:parent => false})
+    resource = CanCan::ControllerResource.new(@controller, :category, {:parent => false})
     resource.should_not be_parent
   end
 
-  it "should load parent resource through proper id parameter when supplying a resource with a different name" do
-    @params.merge!(:action => "index", :person_id => 123)
-    stub(Person).find(123) { :some_person }
-    resource = CanCan::ControllerResource.new(@controller, :person)
+  it "should load parent resource through proper id parameter" do
+    project = Project.create!
+    @params.merge!(:action => "index", :project_id => project.id)
+    resource = CanCan::ControllerResource.new(@controller, :project, :parent => true)
     resource.load_resource
-    @controller.instance_variable_get(:@person).should == :some_person
+    @controller.instance_variable_get(:@project).should == project
   end
 
-  it "should load parent resource for collection action" do
-    @params.merge!(:action => "index", :person_id => 456)
-    stub(Person).find(456) { :some_person }
-    resource = CanCan::ControllerResource.new(@controller, :person)
+  it "should load resource through the association of another parent resource using instance variable" do
+    @params.merge!(:action => "show", :id => 123)
+    category = Object.new
+    @controller.instance_variable_set(:@category, category)
+    stub(category).projects.stub!.find(123) { :some_project }
+    resource = CanCan::ControllerResource.new(@controller, :through => :category)
     resource.load_resource
-    @controller.instance_variable_get(:@person).should == :some_person
+    @controller.instance_variable_get(:@project).should == :some_project
   end
 
-  it "should load resource through the association of another parent resource" do
+  it "should load resource through the custom association name" do
     @params.merge!(:action => "show", :id => 123)
-    person = Object.new
-    @controller.instance_variable_set(:@person, person)
-    stub(person).abilities.stub!.find(123) { :some_ability }
-    resource = CanCan::ControllerResource.new(@controller, :through => :person)
+    category = Object.new
+    @controller.instance_variable_set(:@category, category)
+    stub(category).custom_projects.stub!.find(123) { :some_project }
+    resource = CanCan::ControllerResource.new(@controller, :through => :category, :through_association => :custom_projects)
     resource.load_resource
-    @controller.instance_variable_get(:@ability).should == :some_ability
+    @controller.instance_variable_get(:@project).should == :some_project
   end
 
-  it "should not load through parent resource if instance isn't loaded" do
+  it "should load resource through the association of another parent resource using method" do
     @params.merge!(:action => "show", :id => 123)
-    stub(Ability).find(123) { :some_ability }
-    resource = CanCan::ControllerResource.new(@controller, :through => :person)
+    category = Object.new
+    stub(@controller).category { category }
+    stub(category).projects.stub!.find(123) { :some_project }
+    resource = CanCan::ControllerResource.new(@controller, :through => :category)
     resource.load_resource
-    @controller.instance_variable_get(:@ability).should == :some_ability
+    @controller.instance_variable_get(:@project).should == :some_project
+  end
+
+  it "should not load through parent resource if instance isn't loaded when shallow" do
+    project = Project.create!
+    @params.merge!(:action => "show", :id => project.id)
+    resource = CanCan::ControllerResource.new(@controller, :through => :category, :shallow => true)
+    resource.load_resource
+    @controller.instance_variable_get(:@project).should == project
+  end
+
+  it "should raise AccessDenied when attempting to load resource through nil" do
+    project = Project.create!
+    @params.merge!(:action => "show", :id => project.id)
+    resource = CanCan::ControllerResource.new(@controller, :through => :category)
+    lambda {
+      resource.load_resource
+    }.should raise_error(CanCan::AccessDenied)
+    @controller.instance_variable_get(:@project).should be_nil
+  end
+
+  it "should authorize nested resource through parent association on index action" do
+    @params.merge!(:action => "index")
+    category = Object.new
+    @controller.instance_variable_set(:@category, category)
+    stub(@controller).authorize!(:index, category => Project) { raise CanCan::AccessDenied }
+    resource = CanCan::ControllerResource.new(@controller, :through => :category)
+    lambda { resource.authorize_resource }.should raise_error(CanCan::AccessDenied)
   end
 
   it "should load through first matching if multiple are given" do
     @params.merge!(:action => "show", :id => 123)
-    person = Object.new
-    @controller.instance_variable_set(:@person, person)
-    stub(person).abilities.stub!.find(123) { :some_ability }
-    resource = CanCan::ControllerResource.new(@controller, :through => [:thing, :person])
+    category = Object.new
+    @controller.instance_variable_set(:@category, category)
+    stub(category).projects.stub!.find(123) { :some_project }
+    resource = CanCan::ControllerResource.new(@controller, :through => [:category, :user])
     resource.load_resource
-    @controller.instance_variable_get(:@ability).should == :some_ability
+    @controller.instance_variable_get(:@project).should == :some_project
   end
 
   it "should find record through has_one association with :singleton option" do
     @params.merge!(:action => "show")
-    person = Object.new
-    @controller.instance_variable_set(:@person, person)
-    stub(person).ability { :some_ability }
-    resource = CanCan::ControllerResource.new(@controller, :through => :person, :singleton => true)
+    category = Object.new
+    @controller.instance_variable_set(:@category, category)
+    stub(category).project { :some_project }
+    resource = CanCan::ControllerResource.new(@controller, :through => :category, :singleton => true)
     resource.load_resource
-    @controller.instance_variable_get(:@ability).should == :some_ability
+    @controller.instance_variable_get(:@project).should == :some_project
   end
 
   it "should build record through has_one association with :singleton option" do
-    @params.merge!(:action => "create", :ability => :ability_attributes)
-    person = Object.new
-    @controller.instance_variable_set(:@person, person)
-    stub(person).build_ability(:ability_attributes) { :new_ability }
-    resource = CanCan::ControllerResource.new(@controller, :through => :person, :singleton => true)
+    @params.merge!(:action => "create", :project => {:name => "foobar"})
+    category = Object.new
+    @controller.instance_variable_set(:@category, category)
+    stub(category).build_project { Project.new }
+    resource = CanCan::ControllerResource.new(@controller, :through => :category, :singleton => true)
+    resource.load_resource
+    @controller.instance_variable_get(:@project).name.should == "foobar"
+  end
+
+  it "should find record through has_one association with :singleton and :shallow options" do
+    project = Project.create!
+    @params.merge!(:action => "show", :id => project.id)
+    resource = CanCan::ControllerResource.new(@controller, :through => :category, :singleton => true, :shallow => true)
+    resource.load_resource
+    @controller.instance_variable_get(:@project).should == project
+  end
+
+  it "should build record through has_one association with :singleton and :shallow options" do
+    @params.merge!(:action => "create", :project => {:name => "foobar"})
+    resource = CanCan::ControllerResource.new(@controller, :through => :category, :singleton => true, :shallow => true)
     resource.load_resource
-    @controller.instance_variable_get(:@ability).should == :new_ability
+    @controller.instance_variable_get(:@project).name.should == "foobar"
   end
 
   it "should only authorize :read action on parent resource" do
-    @params.merge!(:action => "new", :person_id => 123)
-    stub(Person).find(123) { :some_person }
-    stub(@controller).authorize!(:read, :some_person) { raise CanCan::AccessDenied }
-    resource = CanCan::ControllerResource.new(@controller, :person)
+    project = Project.create!
+    @params.merge!(:action => "new", :project_id => project.id)
+    stub(@controller).authorize!(:read, project) { raise CanCan::AccessDenied }
+    resource = CanCan::ControllerResource.new(@controller, :project, :parent => true)
     lambda { resource.load_and_authorize_resource }.should raise_error(CanCan::AccessDenied)
   end
 
   it "should load the model using a custom class" do
-    @params.merge!(:action => "show", :id => 123)
-    stub(Person).find(123) { :some_resource }
-    resource = CanCan::ControllerResource.new(@controller, :class => Person)
+    project = Project.create!
+    @params.merge!(:action => "show", :id => project.id)
+    resource = CanCan::ControllerResource.new(@controller, :class => Project)
     resource.load_resource
-    @controller.instance_variable_get(:@ability).should == :some_resource
+    @controller.instance_variable_get(:@project).should == project
   end
 
   it "should authorize based on resource name if class is false" do
     @params.merge!(:action => "show", :id => 123)
-    stub(@controller).authorize!(:show, :ability) { raise CanCan::AccessDenied }
+    stub(@controller).authorize!(:show, :project) { raise CanCan::AccessDenied }
     resource = CanCan::ControllerResource.new(@controller, :class => false)
     lambda { resource.authorize_resource }.should raise_error(CanCan::AccessDenied)
   end
 
   it "should load and authorize using custom instance name" do
-    @params.merge!(:action => "show", :id => 123)
-    stub(Ability).find(123) { :some_ability }
-    stub(@controller).authorize!(:show, :some_ability) { raise CanCan::AccessDenied }
-    resource = CanCan::ControllerResource.new(@controller, :instance_name => :custom_ability)
+    project = Project.create!
+    @params.merge!(:action => "show", :id => project.id)
+    stub(@controller).authorize!(:show, project) { raise CanCan::AccessDenied }
+    resource = CanCan::ControllerResource.new(@controller, :instance_name => :custom_project)
     lambda { resource.load_and_authorize_resource }.should raise_error(CanCan::AccessDenied)
-    @controller.instance_variable_get(:@custom_ability).should == :some_ability
+    @controller.instance_variable_get(:@custom_project).should == project
   end
 
   it "should load resource using custom find_by attribute" do
-    @params.merge!(:action => "show", :id => 123)
-    stub(Ability).find_by_name!(123) { :some_resource }
+    project = Project.create!(:name => "foo")
+    @params.merge!(:action => "show", :id => "foo")
     resource = CanCan::ControllerResource.new(@controller, :find_by => :name)
     resource.load_resource
-    @controller.instance_variable_get(:@ability).should == :some_resource
+    @controller.instance_variable_get(:@project).should == project
   end
 
   it "should raise ImplementationRemoved when adding :name option" do
@@ -239,13 +314,13 @@ describe CanCan::ControllerResource do
 
   it "should raise ImplementationRemoved exception when specifying :resource option since it is no longer used" do
     lambda {
-      CanCan::ControllerResource.new(@controller, :resource => Person)
+      CanCan::ControllerResource.new(@controller, :resource => Project)
     }.should raise_error(CanCan::ImplementationRemoved)
   end
 
   it "should raise ImplementationRemoved exception when passing :nested option" do
     lambda {
-      CanCan::ControllerResource.new(@controller, :nested => :person)
+      CanCan::ControllerResource.new(@controller, :nested => :project)
     }.should raise_error(CanCan::ImplementationRemoved)
   end
 end

data/spec/cancan/inherited_resource_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+describe CanCan::InheritedResource do
+  before(:each) do
+    @params = HashWithIndifferentAccess.new(:controller => "projects")
+    @controller = Object.new # simple stub for now
+    @ability = Ability.new(nil)
+    stub(@controller).params { @params }
+    stub(@controller).current_ability { @ability }
+  end
+
+  it "show should load resource through @controller.resource" do
+    @params[:action] = "show"
+    stub(@controller).resource { :project_resource }
+    CanCan::InheritedResource.new(@controller).load_resource
+    @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 }
+    CanCan::InheritedResource.new(@controller).load_resource
+    @controller.instance_variable_get(:@project).should == :project_resource
+  end
+
+  it "index should load through @controller.parent when parent" do
+    @params[:action] = "index"
+    stub(@controller).parent { :project_resource }
+    CanCan::InheritedResource.new(@controller, :parent => true).load_resource
+    @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) { :projects }
+    stub(@controller).end_of_association_chain { Project }
+    CanCan::InheritedResource.new(@controller).load_resource
+    @controller.instance_variable_get(:@projects).should == :projects
+  end
+end