rc_rails 2.1.0

data/spec/lib/bug_0001_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module Bug0001Spec
+  class Thing < ActiveRecord::Base
+  end
+  
+  class MyController < ActionController::Base
+    def respond_to_with_cruft?(method)
+      respond_to_without_cruft?(method)
+    end
+    alias_method_chain :respond_to?, :cruft
+    
+    resources_controller_for :things, :class => Thing
+  end
+  
+  describe "Calling respond_to? when it has an old signature buried in there [#1]" do
+    it "should work just fine" do
+      c = MyController.new
+      c.respond_to?(:foo).should == false
+    end
+  end
+end

data/spec/lib/include_actions_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+module IncludeActionsSpec
+  module Actions
+    def foo; end
+    def bar; end
+    def faz; end
+  end
+
+  class ActionsController < ActionController::Base
+    include_actions Actions
+  end
+  
+  class OnlyFooController < ActionController::Base
+    include_actions Actions, :only => :foo
+  end
+  
+  class ExceptFooBarController < ActionController::Base
+    include_actions Actions, :except => [:foo, :bar]
+  end
+
+  describe "Include actions use case" do
+    it "ActionController should have actions from actions module" do
+      ActionsController.action_methods.should == ['foo', 'bar', 'faz'].to_set
+    end
+    
+    it "OnlyFooController should have only :foo from actions module" do
+      OnlyFooController.action_methods.should == ['foo'].to_set
+    end
+    
+    it "ExceptFooBarController should not have :foo, :bar from actions module" do
+      ExceptFooBarController.action_methods.should == ['faz'].to_set
+    end
+  end
+end

data/spec/lib/load_enclosing_resources_spec.rb

@@ -0,0 +1,245 @@
+require 'spec_helper'
+
+module LoadEnclosingResourcesSpecHelper
+  def setup_tags_controller(options = {})
+    @klass = Class.new(ActionController::Base)
+    @klass.stub!(:anonymous?).and_return(false)
+    @klass.resources_controller_for :tags, options
+    @klass.stub!(:name).and_return 'ATestController'
+    setup_common
+  end
+
+  def setup_common
+    @controller = @klass.new
+    @controller.stub!(:request_path).and_return('')
+    # stub :load_enclosing_resource_from_specification, increase enclosing_resources by one, and return a mock resource
+    @controller.stub!(:load_enclosing_resource_from_specification).and_return do |name, _|
+      mock("resource: #{name}").tap do |resource|
+        @controller.enclosing_resources << resource
+      end
+    end
+  end
+end
+
+describe "#load_enclosing_resources for resources_controller_for :tags (when nesting_segments is [{:segment => 'users', :singleton => false}])" do
+  include LoadEnclosingResourcesSpecHelper
+
+  before do
+    setup_tags_controller
+    @controller.stub!(:nesting_segments).and_return [{:segment => 'users', :singleton => false}]
+  end
+    
+  it "should call load_wildcard once" do
+    @controller.should_receive(:load_wildcard).once
+    @controller.send(:load_enclosing_resources)
+  end
+  
+  it "should call Specification.new('user', :singleton => false, :as => nil)" do
+    ResourcesController::Specification.should_receive(:new).with('user', :singleton => false, :as => nil)
+    @controller.send(:load_enclosing_resources)
+  end
+end
+
+describe "#load_enclosing_resources for resources_controller_for :tags, with :account mapping (when nesting_segments is [{:segment => 'account', :singleton => true}])" do
+  include LoadEnclosingResourcesSpecHelper
+
+  before do
+    setup_tags_controller
+    @klass.map_resource :account, :singleton => true, :class => User
+    @account_spec = @controller.resource_specification_map['account']
+    @controller.stub!(:nesting_segments).and_return [{:segment => 'account', :singleton => true}]
+  end
+    
+  it "should call load_wildcard once" do
+    @controller.should_receive(:load_wildcard).once
+    @controller.send(:load_enclosing_resources)
+  end
+  
+  it "should call load_enclosing_resource_from_specification with account specification" do
+    @controller.should_receive(:load_enclosing_resource_from_specification).with(@account_spec)
+    @controller.send(:load_enclosing_resources)
+  end
+  
+  it "should not call Specification.new" do
+    ResourcesController::Specification.should_not_receive(:new)
+    @controller.send(:load_enclosing_resources)
+  end
+end
+
+describe "#load_enclosing_resources for resources_controller_for :tags (when nesting_segments is [{:segment =>'users', :singleton => false}, {:segment =>'forums', :singleton => false}])" do
+  include LoadEnclosingResourcesSpecHelper
+
+  before do
+    setup_tags_controller
+    @controller.stub!(:nesting_segments).and_return [{:segment =>'users', :singleton => false}, {:segment => 'forums', :singleton => false}]
+  end
+    
+  it "should call load_wildcard twice" do
+    @controller.should_receive(:load_wildcard).twice
+    @controller.send(:load_enclosing_resources)
+  end
+  
+  it "should call Specification.new with ('user', :singleton => false, :as => nil), then ('forum', :singleton => false, :as => nil)" do
+    ResourcesController::Specification.should_receive(:new).with('user', :singleton => false, :as => nil).ordered
+    ResourcesController::Specification.should_receive(:new).with('forum', :singleton => false, :as => nil).ordered
+    @controller.send(:load_enclosing_resources)
+  end
+end
+
+describe "#load_enclosing_resources for resources_controller_for :tags, :in => ['*', :comment] (when nesting_segments is [{:segment => 'comments', :singleton => false}])" do
+  include LoadEnclosingResourcesSpecHelper
+
+  before do
+    setup_tags_controller :in => ['*', :comment]
+    @controller.stub!(:nesting_segments).and_return [{:segment => 'comments', :singleton => false}]
+  end
+  
+  it "should not call load_wildcard" do
+    @controller.should_not_receive(:load_wildcard)
+    @controller.send(:load_enclosing_resources)
+  end
+  
+  it "should not call Specification.new" do
+    ResourcesController::Specification.should_not_receive(:new)
+    @controller.send(:load_enclosing_resources)
+  end
+end
+
+describe "#load_enclosing_resources for resources_controller_for :tags, :in => ['*', :comment] (when nesting_segments is [{:segment => 'users', :singleton => false}, {:segment => 'forums', :singleton => false}, {:segment =>'comments', :singleton => false}])" do
+  include LoadEnclosingResourcesSpecHelper
+
+  before do
+    setup_tags_controller :in => ['*', :comment]
+    @controller.stub!(:nesting_segments).and_return [{:segment => 'users', :singleton => false}, {:segment => 'forums', :singleton => false}, {:segment =>'comments', :singleton => false}]
+  end
+  
+  it "should call load_wildcard twice" do
+    @controller.should_receive(:load_wildcard).twice
+    @controller.send(:load_enclosing_resources)
+  end
+  
+  it "should call Specification.new with ('user', :singleton => false, :as => nil), then ('forum', :singleton => false, :as => nil)" do
+    ResourcesController::Specification.should_receive(:new).with('user', :singleton => false, :as => nil).ordered
+    ResourcesController::Specification.should_receive(:new).with('forum', :singleton => false, :as => nil).ordered
+    @controller.send(:load_enclosing_resources)
+  end
+end
+
+describe "#load_enclosing_resources for resources_controller_for :tags, :in => ['*', '?commentable', :comment] (when nesting_segments is [{:segment => 'users', :singleton => false}, {:segment => 'comments', :singleton => false}])" do
+  include LoadEnclosingResourcesSpecHelper
+
+  before do
+    setup_tags_controller :in => ['*', '?commentable', :comment]
+    @controller.stub!(:nesting_segments).and_return [{:segment => 'users', :singleton => false}, {:segment => 'comments', :singleton => false}]
+  end
+  
+  it "should call load_wildcard once with 'commentable'" do
+    @controller.should_receive(:load_wildcard).with('commentable').once
+    @controller.send(:load_enclosing_resources)
+  end
+  
+  it "should call Specification.new with ('user', :singleton => false, :as => 'commentable')" do
+    ResourcesController::Specification.should_receive(:new).with('user', :singleton => false, :as => 'commentable').ordered
+    @controller.send(:load_enclosing_resources)
+  end
+end
+
+describe "#load_enclosing_resources for resources_controller_for :tags, :in => ['*', '?commentable', :comment] (when nesting_segments is [{:segment => 'users', :singleton => false}, {:segment => 'forums', :singleton => false}, {:segment => 'comments', :singleton => false}])" do
+  include LoadEnclosingResourcesSpecHelper
+
+  before do
+    setup_tags_controller :in => ['*', '?commentable', :comment]
+    @controller.stub!(:nesting_segments).and_return [{:segment => 'users', :singleton => false}, {:segment => 'forums', :singleton => false}, {:segment => 'comments', :singleton => false}]
+  end
+  
+  it "should call load_wildcard twice" do
+    @controller.should_receive(:load_wildcard).with().once.ordered
+    @controller.should_receive(:load_wildcard).with('commentable').once.ordered
+    @controller.send(:load_enclosing_resources)
+  end
+  
+  it "should call Specification.new with ('user', :singleton => false, :as => nil), ('forum', :singleton => false, :as => 'commentable')" do
+    ResourcesController::Specification.should_receive(:new).with('user', :singleton => false, :as => nil).once.ordered
+    ResourcesController::Specification.should_receive(:new).with('forum', :singleton => false, :as => 'commentable').once.ordered
+    @controller.send(:load_enclosing_resources)
+  end
+end
+
+describe "#load_enclosing_resources for resources_controller_for :tags, :in => ['*', '?commentable', :comment] (when nesting_segments is [{:segment => 'users', :singleton => false}, {:segment => 'forums', :singleton => false}, {:segment => 'posts', :singleton => false}, {:segment => 'comments', :singleton => false}])" do
+  include LoadEnclosingResourcesSpecHelper
+
+  before do
+    setup_tags_controller :in => ['*', '?commentable', :comment]
+    @controller.stub!(:nesting_segments).and_return [{:segment => 'users', :singleton => false}, {:segment => 'forums', :singleton => false}, {:segment => 'posts', :singleton => false}, {:segment => 'comments', :singleton => false}]
+  end
+  
+  it "should call load_wildcard twice, then once with 'commentable'" do
+    @controller.should_receive(:load_wildcard).with().twice.ordered
+    @controller.should_receive(:load_wildcard).with('commentable').once.ordered
+    @controller.send(:load_enclosing_resources)
+  end
+  
+  it "should call Specification.new with ('user', :singleton => false, :as => nil), ('forum', :singleton => false, :as => nil), then ('post', :singleton => false, :as => 'commentable')" do
+    ResourcesController::Specification.should_receive(:new).with('user', :singleton => false, :as => nil).once.ordered
+    ResourcesController::Specification.should_receive(:new).with('forum', :singleton => false, :as => nil).once.ordered
+    ResourcesController::Specification.should_receive(:new).with('post', :singleton => false, :as => 'commentable').once.ordered
+    @controller.send(:load_enclosing_resources)
+  end
+end
+
+describe "#load_enclosing_resources for resources_controller_for :tags, :in => ['user', '*', '?taggable'] (when nesting_segments is [{:segment => 'users', :singleton => false}, {:segment => 'comments', :singleton => false}])" do
+  include LoadEnclosingResourcesSpecHelper
+
+  before do
+    setup_tags_controller :in => ['user', '*', '?taggable']
+    @user_spec = @controller.send(:specifications)[1]
+    @controller.stub!(:nesting_segments).and_return [{:segment => 'users', :singleton => false}, {:segment => 'comments', :singleton => false}]
+  end
+  
+  it "should call load_enclosing_resource_from_specification with user spec, then load_wildcard once with 'taggable'" do
+    @controller.should_receive(:load_enclosing_resource_from_specification).with(@user_spec).once.ordered do
+      mock('user').tap {|r| @controller.enclosing_resources << r }
+    end
+    @controller.should_receive(:load_wildcard).with('taggable').once.ordered
+    @controller.send(:load_enclosing_resources)
+  end
+  
+  it "should call Specification.new with ('comment', :singleton => false, :as => 'taggable')" do
+    ResourcesController::Specification.should_receive(:new).with('comment', :singleton => false, :as => 'taggable')
+    @controller.send(:load_enclosing_resources)
+  end
+end
+
+# specing some branching BC code
+# find_filter dissapeared from edge, but we want to support it for 2.0-stable
+describe "ResourcesController.load_enclosing_resources_filter_exists?" do
+  before do
+    @klass = Class.new(ActionController::Base)
+  end
+  
+  describe "when :find_filter defined" do
+    before do
+      class<<@klass
+        def find_filter; end
+      end
+    end
+    
+    it "should call :find_filter with :load_enclosing_resources" do
+      @klass.should_receive(:find_filter).with(:load_enclosing_resources)
+      @klass.send(:load_enclosing_resources_filter_exists?)
+    end
+  end
+  
+  describe "when :find_filter not defined" do
+    before do
+      class<<@klass
+        undef_method(:find_filter) rescue nil
+      end
+    end
+        
+    it "should call :_process_action_callbacks" do
+      @klass.should_receive(:_process_action_callbacks).and_return([])
+      @klass.send(:load_enclosing_resources_filter_exists?)
+    end
+  end
+end

data/spec/lib/request_path_introspection_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+module RequestPathIntrospectionSpec
+  class Forum < ActiveRecord::Base; end
+  
+  class User < ActiveRecord::Base; end
+  
+  describe "RequestPathIntrospection" do
+    before do
+      @klass = Class.new(ActionController::Base)
+      @controller = @klass.new
+      @controller.stub!(:controller_name).and_return('forums')
+      @controller.stub!(:controller_path).and_return('forums')
+      @controller.stub!(:params).and_return({})
+      @controller.stub!(:request).and_return(mock('request', :path => '/forums'))
+    end
+    
+    describe "#request_path" do
+      it "should default to request.path" do
+        @controller.send(:request_path).should == '/forums'
+      end
+      
+      it " should be params[:resource_path], when set" do
+        @controller.params[:resource_path] = '/foo'
+        @controller.send(:request_path).should == '/foo'
+      end
+    end
+    
+    describe "#nesting_request_path" do
+      it "should remove the controller_name segment" do
+        @controller.stub!(:request_path).and_return('/users/1/forums/2')
+        @controller.send(:nesting_request_path).should == '/users/1'
+      end
+      
+      it "when resource_specification present, whould remove taht segment" do
+        @controller.stub!(:resource_specification).and_return(ResourcesController::Specification.new(:forum, :class => RequestPathIntrospectionSpec::Forum, :segment => 'foromas'))
+        @controller.stub!(:request_path).and_return('/users/1/foromas/2')
+        @controller.send(:nesting_request_path).should == '/users/1'
+      end
+      
+      it "should remove only the controller_name segment, when nesting is same name" do
+        @controller.stub!(:request_path).and_return('/forums/1/forums/2')
+        @controller.send(:nesting_request_path).should == '/forums/1'
+      end
+
+      it "should remove the controller_name segment, even when id matches controller name" do
+        @controller.stub!(:request_path).and_return('/forums/1/forums/forums.atom')
+        @controller.send(:nesting_request_path).should == '/forums/1'
+      end
+
+      it "should remove only the controller_name segment even when nesting is same name" do
+        @controller.stub!(:resource_specification).and_return(ResourcesController::Specification.new(:forum, :class => RequestPathIntrospectionSpec::Forum, :singleton => true))
+        @controller.stub!(:request_path).and_return('/users/1/forum/forum.atom')
+        @controller.send(:nesting_request_path).should == '/users/1/forum'
+      end
+      
+      it "should remove any controller namespace" do
+        @controller.stub!(:controller_path).and_return('some/name/space/forums')
+        @controller.stub!(:request_path).and_return('/some/name/space/users/1/secret/forums')
+        @controller.send(:nesting_request_path).should == '/users/1/secret'
+      end
+    end
+    
+    it "#namespace_segments should return [] segments if NOT present in request_path" do
+      @controller.stub!(:controller_path).and_return('some/name/space/forums')
+      @controller.stub!(:request_path).and_return('/SAM/name/space/users/1/secret/forums')
+      @controller.send(:namespace_segments).should == []
+    end
+    
+    it "#namespace_segments should return namespace segments if present in request_path" do
+      @controller.stub!(:controller_path).and_return('some/name/space/forums')
+      @controller.stub!(:request_path).and_return('/some/name/space/users/1/secret/forums')
+      @controller.send(:namespace_segments).should == ['some', 'name', 'space']
+    end
+    
+    describe "#nesting_segments" do
+      describe "when params include :user_id" do
+        before do
+          @controller.params[:user_id] = '1'
+        end
+        
+        it "and request path is '/users/1/forums', should return [{:segment => 'users', :singleton => false}]" do
+          @controller.request.stub!(:path).and_return('/users/1/forums')
+          @controller.send(:nesting_segments).should == [{:segment => 'users', :singleton => false}]
+        end
+        
+        it "and request path is '/account/users/1/forums', should return [{:segment => 'account', :singleton => true}, {:segment => 'users', :singleton => false}]" do
+          @controller.request.stub!(:path).and_return('/account/users/1/forums')
+          @controller.send(:nesting_segments).should == [{:segment => 'account', :singleton => true}, {:segment => 'users', :singleton => false}]
+        end
+        
+        describe "when controller has nesting for :user => 'muchachos'" do
+          before do
+            @klass.resources_controller_for :forums, :class => RequestPathIntrospectionSpec::Forum
+            @klass.nested_in :user, :segment => "muchachos", :class => RequestPathIntrospectionSpec::User
+          end
+          
+          it "and request path is '/muchachos/1/forums', should return [{:segment => 'muchachos', :singleton => false}]" do
+            @controller.request.stub!(:path).and_return('/muchachos/1/forums')
+            @controller.send(:nesting_segments).should == [{:segment => 'muchachos', :singleton => false}]
+          end
+        end
+        
+        describe "when enclosing resource has mapping for :user => 'muchachos'" do
+          before do
+            @klass.map_enclosing_resource :user, :segment => "muchachos", :class => RequestPathIntrospectionSpec::User
+          end
+          
+          it "and request path is '/muchachos/1/forums', should return [{:segment => 'muchachos', :singleton => false}]" do
+            @controller.request.stub!(:path).and_return('/muchachos/1/forums')
+            @controller.send(:nesting_segments).should == [{:segment => 'muchachos', :singleton => false}]
+          end
+        end
+      end
+    end
+  
+    describe "#segment_for_key" do
+      describe "when controller has map {:user, :singelton => true}" do
+        before do
+          @klass.resources_controller_for :forums, :class => RequestPathIntrospectionSpec::Forum
+          @klass.map_enclosing_resource :user, :singleton => true, :class => RequestPathIntrospectionSpec::User
+        end
+        
+        it "('user_id') should return 'users'" do
+          @controller.send(:segment_for_key, 'user_id').should == 'users'
+        end
+      end
+    end
+  end
+end

data/spec/lib/resource_methods_spec.rb

@@ -0,0 +1,204 @@
+require 'spec_helper'
+
+module ResourceMethodsSpec
+  class MyController < ActionController::Base
+    resources_controller_for :users
+  end
+  
+  if Rails.respond_to?(:version) && Rails.version >= "2.3"
+    describe "#new_resource" do
+      it "should accept block syntax" do
+        c = MyController.new
+        c.resource_service = User
+        c.stub!(:params).and_return({})
+        r = c.send(:new_resource) do |u|
+          u.login = "Fred"
+        end
+        r.should be_kind_of User
+        r.login.should == "Fred"
+      end
+    end
+  end
+  
+  describe "An rc for collection :users" do
+    before do
+      @controller = MyController.new
+      @controller.stub!(:params).and_return({})
+    end
+
+    describe "when no enclosing resource" do
+      it "#find_resource(<id>) should call User.find(<id>)" do
+        User.should_receive(:find).with("42")
+        @controller.send(:find_resource, "42")
+      end
+    
+      it "#find_resources should call User.find(:all)" do
+        User.should_receive(:all)
+        @controller.send(:find_resources)
+      end
+
+      it "#new_resource({}) should call User.new({})" do
+        User.should_receive(:new).with({})
+        @controller.send(:new_resource, {})
+      end
+
+      it "#destroy_resource(<id>) should call User.find(<id>).destroy" do
+        User.should_receive(:find).with("42").and_return(user = mock)
+        user.should_receive(:destroy).and_return(user)
+        @controller.send(:destroy_resource, "42").should == user
+      end
+    end
+      
+    describe "when an enclosing resource is added (a forum)" do
+      before do
+        @forum = Forum.create!
+        @controller.send :add_enclosing_resource, @forum
+      end
+  
+      it "#find_resource(<id>) should call forum.users.find(<id>)" do
+        @forum.users.should_receive(:find).with("42")
+        @controller.send(:find_resource, "42")
+      end
+  
+      it "#find_resources should call forum.users.find(:all)" do
+        @forum.users.should_receive(:all)
+        @controller.send(:find_resources)
+      end
+
+      it "#new_resource({}) should call forum.users.build({})" do
+        @forum.users.should_receive(:build).with({})
+        @controller.send :new_resource, {}
+      end
+
+      it "#destroy_resource(<id>) should call forum.users.find(<id>) and forum.users.destroy(<id>)" do
+        @forum.users.should_receive(:find).with("42").and_return(user = mock)
+        @forum.users.should_receive(:destroy).with("42").and_return(useless_array = mock)
+        @controller.send(:destroy_resource, "42").should == user
+      end
+    end
+  end
+  
+  class MySingletonController < ActionController::Base
+    resources_controller_for :info, :singleton => true
+  end
+  
+  describe "An rc for singleton :info" do
+    before do
+      @controller = MySingletonController.new
+      @controller.stub!(:params).and_return({})
+    end
+      
+    describe "with an enclosing resource (a user)" do
+      before do
+        @user = User.create!
+        @controller.send :add_enclosing_resource, @user
+      end
+  
+      it "#find_resource should call user.info" do
+        @user.should_receive(:info)
+        @controller.send(:find_resource)
+      end
+
+      it "#new_resource({}) should call user.build_info({})" do
+        @user.should_receive(:build_info).with({})
+        @controller.send :new_resource, {}
+      end
+
+      it "#destroy_resource should call user.info.destroy" do
+        @user.should_receive(:info).and_return(info = mock)
+        info.should_receive(:destroy)
+        @controller.send(:destroy_resource)
+      end
+    end
+  end
+  
+  module MyResourceMethods
+  protected
+    def new_resource(attrs = (params[resource_name] || {}), &block)
+      "my new_resource"
+    end
+    
+    def find_resource(id = params[:id])
+      "my find_resource"
+      
+    end
+    
+    def find_resources
+      "my find_resources"
+    end
+    
+    def destroy_resource(id = params[:id])
+      "my destroy_resource"
+    end
+  end
+
+  shared_examples_for "A controller with its own resource methods" do
+    it "#new_resource should call MyResourceMethods#new_resource" do
+      @controller.send(:new_resource, {}).should == 'my new_resource'
+    end
+
+    it "#find_resource should call MyResourceMethods#find_resource" do
+      @controller.send(:find_resource, 1).should == 'my find_resource'
+    end
+
+    it "#find_resources should call MyResourceMethods#new_resource" do
+      @controller.send(:find_resources).should == 'my find_resources'
+    end
+    
+    it "#destroy_resource should call MyResourceMethods#destroy_resource" do
+      @controller.send(:destroy_resource, 1).should == 'my destroy_resource'
+    end
+  end
+  
+  class MyControllerWithMyResourceMethodsMixedIn < ActionController::Base
+    resources_controller_for :users
+    include MyResourceMethods
+  end
+  
+  describe "A controller with resource methods mixed in after resources_controller_for" do
+    before do
+      @controller = MyControllerWithMyResourceMethodsMixedIn.new
+      @controller.resource_service = User
+      @controller.stub!(:params).and_return({})
+    end
+    
+    it_should_behave_like "A controller with its own resource methods"
+  end
+  
+  class MyAbstractControllerWithOwnResourceMethods < ActionController::Base
+    include MyResourceMethods
+  end
+  
+  class InhertedMyAbstractControllerWithOwnResourceMethods < MyAbstractControllerWithOwnResourceMethods
+    resources_controller_for :users, :resource_methods => false
+  end
+  
+  describe "A controller inheriting resource methods which declares :resource_methods => false" do
+    before do
+      @controller = InhertedMyAbstractControllerWithOwnResourceMethods.new
+      @controller.resource_service = User
+      @controller.stub!(:params).and_return({})
+    end
+    
+    it_should_behave_like "A controller with its own resource methods"
+  end
+  
+  class MyAbstractControllerWithResourceMethodsOverridden < ActionController::Base
+    include ResourcesController::ResourceMethods
+    include MyResourceMethods
+  end
+  
+  class InhertedMyAbstractControllerWithResourceMethodsOverridden < MyAbstractControllerWithResourceMethodsOverridden
+    resources_controller_for :users
+  end
+  
+  describe "A controller inheriting from a controller which mixes in ResourceMethods, and overrides them" do
+    before do
+      @controller = InhertedMyAbstractControllerWithResourceMethodsOverridden.new
+      @controller.resource_service = User
+      @controller.stub!(:params).and_return({})
+    end
+    
+    it_should_behave_like "A controller with its own resource methods"
+  end
+end