josevalim-inherited_resources 0.8.5 → 0.9.0

data/lib/inherited_resources/polymorphic_helpers.rb

@@ -136,10 +136,9 @@ module InheritedResources
             end
 
             if key.nil?
-              raise ScriptError, "Could not find param for polymorphic association.
-                                  The request params keys are #{params.keys.inspect}
-                                  and the polymorphic associations are
-                                  #{polymorphic_symbols.inspect}." unless polymorphic_config[:optional]
+              raise ScriptError, "Could not find param for polymorphic association. The request" <<
+                                 "parameters are #{params.keys.inspect} and the polymorphic " <<
+                                 "associations are #{polymorphic_config[:symbols].inspect}." unless polymorphic_config[:optional]
 
               nil
             else

data/test/aliases_test.rb

@@ -4,8 +4,13 @@ class Student;
   def self.human_name; 'Student'; end
 end
 
+class ApplicationController < ActionController::Base
+  include InheritedResources::DSL
+end
+
 class StudentsController < ApplicationController
   inherit_resources
+  respond_to :html, :xml
 
   def edit
     edit! do |format|
@@ -18,26 +23,19 @@ class StudentsController < ApplicationController
     new!
   end
 
-  def create
-    create! do |success, failure|
-      success.html { render :text => "I won't redirect!" }
-      failure.xml { render :text => "I shouldn't be rendered" }
-    end
+  create!(:location => "http://test.host/") do |success, failure|
+    success.html { render :text => "I won't redirect!" }
+    failure.xml { render :text => "I shouldn't be rendered" }
   end
 
-  def update
-    update! do |success, failure|
-      success.html { redirect_to(resource_url) }
-      failure.html { render :text => "I won't render!" }
-    end
+  update! do |success, failure|
+    success.html { redirect_to(resource_url) }
+    failure.html { render :text => "I won't render!" }
   end
 
-  def destroy
-    destroy! do |format|
-      format.html { render :text => "Destroyed!" }
-    end
+  destroy! do |format|
+    format.html { render :text => "Destroyed!" }
   end
-
 end
 
 class AliasesTest < ActionController::TestCase
@@ -89,7 +87,7 @@ class AliasesTest < ActionController::TestCase
 
   def test_dumb_responder_quietly_receives_everything_on_failure
     @request.accept = 'text/html'
-    Student.stubs(:new).returns(mock_student(:save => false, :errors => []))
+    Student.stubs(:new).returns(mock_student(:save => false, :errors => {:some => :error}))
     @controller.stubs(:resource_url).returns('http://test.host/')
     post :create
     assert_response :success
@@ -98,7 +96,7 @@ class AliasesTest < ActionController::TestCase
 
   def test_html_is_the_default_when_only_xml_is_overwriten
     @request.accept = '*/*'
-    Student.stubs(:new).returns(mock_student(:save => false, :errors => []))
+    Student.stubs(:new).returns(mock_student(:save => false, :errors => {:some => :error}))
     @controller.stubs(:resource_url).returns('http://test.host/')
     post :create
     assert_response :success
@@ -106,7 +104,7 @@ class AliasesTest < ActionController::TestCase
   end
 
   def test_wont_render_edit_template_on_update_with_failure_if_failure_block_is_given
-    Student.stubs(:find).returns(mock_student(:update_attributes => false, :errors => []))
+    Student.stubs(:find).returns(mock_student(:update_attributes => false))
     put :update
     assert_response :success
     assert_equal "I won't render!", @response.body
@@ -126,6 +124,13 @@ class AliasesTest < ActionController::TestCase
     assert_equal "Destroyed!", @response.body
   end
 
+  def test_options_are_used_in_respond_with
+    @request.accept = "application/xml"
+    Student.stubs(:new).returns(mock_student(:save => true, :to_xml => "XML"))
+    post :create
+    assert_equal "http://test.host/", @response.location
+  end
+
   protected
     def mock_student(stubs={})
       @mock_student ||= mock(stubs)

data/test/base_helpers_test.rb

@@ -61,6 +61,13 @@ class AssociationChainBaseHelpersTest < ActionController::TestCase
     assert_equal 'new pet', assigns(:pet)
   end
 
+  def test_model_is_not_initialized_with_nil
+    @controller.current_user.expects(:pets).returns(Pet)
+    Pet.expects(:build).with({}).returns(mock_pet)
+    get :new
+    assert mock_pet, assigns(:pet)
+  end
+
   protected
     def mock_pet(stubs={})
       @mock_pet ||= mock(stubs)

data/test/base_test.rb

@@ -131,7 +131,7 @@ class CreateActionBaseTest < ActionController::TestCase
 
   def test_redirect_to_the_created_user
     User.stubs(:new).returns(mock_user(:save => true))
-    @controller.expects(:resource_url).returns('http://test.host/').times(2)
+    @controller.expects(:resource_url).returns('http://test.host/')
     post :create
     assert_redirected_to 'http://test.host/'
   end
@@ -143,14 +143,14 @@ class CreateActionBaseTest < ActionController::TestCase
   end
 
   def test_render_new_template_when_user_cannot_be_saved
-    User.stubs(:new).returns(mock_user(:save => false, :errors => []))
+    User.stubs(:new).returns(mock_user(:save => false, :errors => {:some => :error}))
     post :create
     assert_response :success
     assert_template :new
   end
 
   def test_dont_show_flash_message_when_user_cannot_be_saved
-    User.stubs(:new).returns(mock_user(:save => false, :errors => []))
+    User.stubs(:new).returns(mock_user(:save => false, :errors => {:some => :error}))
     post :create
     assert flash.empty?
   end
@@ -180,14 +180,14 @@ class UpdateActionBaseTest < ActionController::TestCase
   end
 
   def test_render_edit_template_when_user_cannot_be_saved
-    User.stubs(:find).returns(mock_user(:update_attributes => false, :errors => []))
+    User.stubs(:find).returns(mock_user(:update_attributes => false, :errors => {:some => :error}))
     put :update
     assert_response :success
     assert_template :edit
   end
 
   def test_dont_show_flash_message_when_user_cannot_be_saved
-    User.stubs(:find).returns(mock_user(:update_attributes => false, :errors => []))
+    User.stubs(:find).returns(mock_user(:update_attributes => false, :errors => {:some => :error}))
     put :update
     assert flash.empty?
   end

data/test/flash_test.rb

@@ -5,6 +5,7 @@ class Address
 end
 
 class AddressesController < InheritedResources::Base
+  respond_to :xml
   protected
     def interpolation_options
       { :reference => 'Ocean Avenue' }
@@ -13,6 +14,7 @@ end
 
 module Admin; end
 class Admin::AddressesController < InheritedResources::Base
+  respond_to :xml
   protected
     def interpolation_options
       { :reference => 'Ocean Avenue' }
@@ -23,34 +25,37 @@ class FlashBaseHelpersTest < ActionController::TestCase
   tests AddressesController
 
   def setup
+    super
     @request.accept = 'application/xml'
+    @controller.stubs(:resource_url).returns("http://test.host/")
+    @controller.stubs(:collection_url).returns("http://test.host/")
   end
 
   def test_success_flash_message_on_create_with_yml
     Address.stubs(:new).returns(mock_address(:save => true))
-    @controller.stubs(:address_url)
     post :create
     assert_equal 'You created a new address close to <b>Ocean Avenue</b>.', flash[:notice]
   end
 
   def test_success_flash_message_on_create_with_namespaced_controller
     @controller = Admin::AddressesController.new
+    @controller.stubs(:resource_url).returns("http://test.host/")
     Address.stubs(:new).returns(mock_address(:save => true))
-    @controller.stubs(:address_url)
     post :create
     assert_equal 'Admin, you created a new address close to <b>Ocean Avenue</b>.', flash[:notice]
   end
 
   def test_failure_flash_message_on_create_with_namespaced_controller_actions
     @controller = Admin::AddressesController.new
+    @controller.stubs(:resource_url).returns("http://test.host/")
     Address.stubs(:new).returns(mock_address(:save => false))
-    @controller.stubs(:address_url)
     post :create
     assert_equal 'Admin error message.', flash[:error]
   end
 
   def test_inherited_success_flash_message_on_update_on_namespaced_controllers
     @controller = Admin::AddressesController.new
+    @controller.stubs(:resource_url).returns("http://test.host/")
     Address.stubs(:find).returns(mock_address(:update_attributes => true))
     put :update
     assert_response :success
@@ -65,7 +70,7 @@ class FlashBaseHelpersTest < ActionController::TestCase
   end
 
   def test_failure_flash_message_on_update
-    Address.stubs(:find).returns(mock_address(:update_attributes => false, :errors => []))
+    Address.stubs(:find).returns(mock_address(:update_attributes => false, :errors => {:some => :error}))
     put :update
     assert_equal 'Oh no! We could not update your address!', flash[:error]
   end
@@ -78,6 +83,6 @@ class FlashBaseHelpersTest < ActionController::TestCase
 
   protected
     def mock_address(stubs={})
-      @mock_address ||= mock(stubs)
+      @mock_address ||= stub(stubs.merge(:to_xml => "xml"))
     end
 end

data/test/redirect_to_test.rb

@@ -28,21 +28,18 @@ class RedirectToWithBlockTest < ActionController::TestCase
 
   def test_redirect_to_the_given_url_on_create
     Machine.stubs(:new).returns(mock_machine(:save => true))
-    @controller.expects(:resource_url).times(0)
     post :create
     assert_redirected_to 'http://test.host/create'
   end
 
   def test_redirect_to_the_given_url_on_update
     Machine.stubs(:find).returns(mock_machine(:update_attributes => true))
-    @controller.expects(:resource_url).times(0)
     put :update
     assert_redirected_to 'http://test.host/update'
   end
 
   def test_redirect_to_the_given_url_on_destroy
     Machine.stubs(:find).returns(mock_machine(:destroy => true))
-    @controller.expects(:collection_url).times(0)
     delete :destroy
     assert_redirected_to 'http://test.host/destroy'
   end
@@ -52,26 +49,3 @@ class RedirectToWithBlockTest < ActionController::TestCase
       @mock_machine ||= mock(stubs)
     end
 end
-
-
-# Use this to test blocks with multiple arity in the future.
-class SuperMachinesController < InheritedResources::Base
-  defaults :resource_class => Machine
-
-  def create
-    create! do |arg1, arg2, arg3|
-      # nothing
-    end
-  end
-end
-
-class RedirectToArityTest < ActionController::TestCase
-  tests SuperMachinesController
-
-  def test_redirect_to_the_given_url_on_create
-    Machine.stubs(:new).returns(:anything)
-    assert_raise ScriptError, /arity/ do
-      post :create
-    end
-  end
-end

data/test/respond_to_test.rb

@@ -15,12 +15,10 @@ class Project
 end
 
 class ProjectsController < ActionController::Base
-  # Inherited respond_to definition is:
-  # respond_to :html
   respond_to :html
-  respond_to :xml, :except => :edit
-  respond_to :rjs => :edit
-  respond_to :rss,  :only => 'index'
+  respond_to :xml,  :except => :edit
+  respond_to :rjs,  :only => :edit
+  respond_to :rss,  :only => :index
   respond_to :json, :except => :index
   respond_to :csv,  :except => :index
 
@@ -28,21 +26,16 @@ class ProjectsController < ActionController::Base
     respond_with(Project.new)
   end
 
-  def respond_with_options
-    respond_with(Project.new, :to => [:xml, :json], :location => 'http://test.host/')
-  end
-
-  def skip_not_acceptable
-    respond_with(Project.new, :skip_not_acceptable => true)
-    render :text => 'Will not raise double render error.'
+  def respond_with_resource
+    respond_with(Project.new)
   end
 
-  def respond_to_with_resource
-    respond_to(:with => Project.new)
+  def respond_with_resource_and_options
+    respond_with(Project.new, :location => 'http://test.host/')
   end
 
-  def respond_to_with_resource_and_blocks
-    respond_to(:with => Project.new) do |format|
+  def respond_with_resource_and_blocks
+    respond_with(Project.new) do |format|
       format.json { render :text => 'Render JSON' }
       format.rss  { render :text => 'Render RSS' }
     end
@@ -53,7 +46,7 @@ class ProjectsController < ActionController::Base
   # block. This tests exactly this case.
   #
   def respond_to_skip_default_template
-    respond_to(:with => Project.new) do |format|
+    respond_with(Project.new) do |format|
       format.html { render :text => 'Render HTML' }
     end
   end
@@ -62,139 +55,6 @@ end
 class SuperProjectsController < ProjectsController
 end
 
-class RespondToUnitTest < ActionController::TestCase
-  tests ProjectsController
-
-  def setup
-    @formats   = @controller.formats_for_respond_to
-    @responder = ActionController::MimeResponds::Responder.new(@controller)
-  end
-
-  def test_respond_to_class_method_without_options
-    assert_nil @formats[:html][:only]
-    assert_nil @formats[:html][:except]
-  end
-
-  def test_respond_to_class_method_inheritance
-    assert_nil   @formats[:xml][:only]
-    assert_equal [:edit], @formats[:xml][:except]
-  end
-
-  def test_respond_to_class_method_with_implicit_only
-    assert_equal [:edit], @formats[:rjs][:only]
-    assert_nil   @formats[:rjs][:except]
-  end
-
-  def test_respond_to_class_method_with_explicit_only
-    assert_equal [:index], @formats[:rss][:only]
-    assert_nil   @formats[:rss][:except]
-  end
-
-  def test_respond_to_class_method_with_explicit_except
-    assert_nil   @formats[:json][:only]
-    assert_equal [:index], @formats[:json][:except]
-  end
-
-  def test_action_respond_to_format
-    @controller.action_name = 'index'
-    assert @responder.action_respond_to_format?('html')  # defined
-    assert @responder.action_respond_to_format?('xml')   # inherited
-    assert @responder.action_respond_to_format?('rss')   # explicit only
-    assert !@responder.action_respond_to_format?('json') # exception
-
-    @controller.action_name = 'edit'
-    assert !@responder.action_respond_to_format?('xml')  # inherited
-    assert @responder.action_respond_to_format?('rjs')   # implicit only
-    assert @responder.action_respond_to_format?('json')  # exception
-  end
-
-  def test_action_respond_to_format_with_additional_mimes
-    assert @responder.action_respond_to_format?('html', [:xml, :html, :json])
-    assert !@responder.action_respond_to_format?('html', [:xml, :rss, :json])
-
-    @controller.action_name = 'index'
-    assert @responder.action_respond_to_format?('html', [])
-    assert !@responder.action_respond_to_format?('json', [])
-  end
-
-  def test_clear_respond_to
-    @controller = SuperProjectsController.new
-    @controller.request  = ActionController::TestRequest.new
-
-    @controller.action_name = 'index'
-    @responder = ActionController::MimeResponds::Responder.new(@controller)
-
-    # Those responses are inherited from ProjectsController
-    assert @responder.action_respond_to_format?('html')  # defined
-    assert @responder.action_respond_to_format?('xml')   # inherited
-    assert @responder.action_respond_to_format?('rss')   # explicit only
-
-    # Let's clear respond_to definitions
-    SuperProjectsController.send(:clear_respond_to!)
-
-    assert !@responder.action_respond_to_format?('html')
-    assert !@responder.action_respond_to_format?('xml')
-    assert !@responder.action_respond_to_format?('rss')
-  end
-
-  def test_respond_except_any_does_not_respond_to_mime_all
-    prepare_responder_to_respond!
-
-    @responder.respond_except_any
-    assert !@performed
-
-    @responder.respond
-    assert @performed
-  end
-
-  def test_respond_any_responds_to_mime_all
-    prepare_responder_to_respond!
-
-    @responder.respond_any
-    assert @performed
-  end
-
-  def test_respond_any_responds_only_to_all
-    prepare_responder_to_respond!('text/html')
-
-    @responder.respond_any
-    assert !@performed
-  end
-
-  def test_responder_prioritize
-    prepare_responder_to_respond!
-    assert_equal [Mime::HTML, Mime::XML], @responder.order
-
-    @responder.prioritize(:xml)
-    assert_equal [Mime::XML, Mime::HTML], @responder.order
-
-    @responder.prioritize(:js)
-    assert_equal [Mime::XML, Mime::HTML], @responder.order
-  end
- 
-  protected 
-    def prepare_responder_to_respond!(content_type='*/*')
-      @controller.request  = @request  = ActionController::TestRequest.new
-      @controller.response = @response = ActionController::TestResponse.new
-
-      @request.accept = content_type
-      @responder  = ActionController::MimeResponds::Responder.new(@controller)
-      @performed = false
-
-      # Mock template
-      template = mock()
-      @response.stubs(:template).returns(template)
-      template.stubs(:template_format=).returns(true)
-
-      respond_to_declaration = proc { |format|
-        format.html { @performed = true }
-        format.xml  { }
-      }
-
-      respond_to_declaration.call(@responder)
-    end
-end
-
 class RespondToFunctionalTest < ActionController::TestCase
   tests ProjectsController
 
@@ -222,10 +82,11 @@ class RespondToFunctionalTest < ActionController::TestCase
     assert_equal '406 Not Acceptable', @response.status
   end
 
-  def test_respond_with_renders_not_found_when_mime_type_is_valid_but_could_not_render
+  def test_respond_with_raises_error_if_could_not_respond
     @request.accept = 'application/rss+xml'
-    get :index
-    assert_equal '404 Not Found', @response.status
+    assert_raise ActionView::MissingTemplate do
+      get :index
+    end
   end
 
   def test_respond_to_all
@@ -234,13 +95,6 @@ class RespondToFunctionalTest < ActionController::TestCase
     assert_equal 'Index HTML', @response.body.strip
   end
 
-  def test_default_template_is_not_rendered_if_template_format_is_not_accepted
-    @controller.stubs(:default_template_format).returns(:json)
-    @request.accept = '*/*'
-    get :index
-    assert_equal '406 Not Acceptable', @response.status
-  end
-
   def test_respond_with_sets_content_type_properly
     @request.accept = 'text/html'
     get :index
@@ -253,57 +107,44 @@ class RespondToFunctionalTest < ActionController::TestCase
     assert_equal :xml, @response.template.template_format
   end
 
-  def test_respond_with_when_to_is_given_as_option
-    @request.accept = 'text/html'
-    get :respond_with_options
-    assert_equal '406 Not Acceptable', @response.status
-
-    @request.accept = 'application/xml'
-    get :respond_with_options
-    assert_equal 'Generated XML', @response.body.strip
-  end
-
   def test_respond_with_forwads_extra_options_to_render
     @request.accept = 'application/xml'
-    get :respond_with_options
+    get :respond_with_resource_and_options
     assert_equal 'Generated XML', @response.body.strip
     assert_equal 'http://test.host/', @response.headers['Location']
   end
 
-  def test_respond_with_skips_head_when_skip_not_acceptable_is_given
-    @request.accept = 'application/rss+xml'
-    get :skip_not_acceptable
-    assert_equal 'Will not raise double render error.', @response.body.strip
-  end
-
   def test_respond_to_when_a_resource_is_given_as_option
     @request.accept = 'text/html'
-    get :respond_to_with_resource
+    get :respond_with_resource
     assert_equal 'RespondTo HTML', @response.body.strip
 
     @request.accept = 'application/xml'
-    get :respond_to_with_resource
+    get :respond_with_resource
     assert_equal 'Generated XML', @response.body.strip
 
-    @request.accept = 'application/json'
-    get :respond_to_with_resource
-    assert_equal '404 Not Found', @response.status
-
     @request.accept = 'application/rss+xml'
-    get :respond_to_with_resource
+    get :respond_with_resource
     assert_equal '406 Not Acceptable', @response.status
+
+    @request.accept = 'application/json'
+    assert_raise ActionView::MissingTemplate do
+      get :respond_with_resource
+    end
   end
 
   def test_respond_to_overwrite_class_method_definition
     @request.accept = 'application/rss+xml'
-    get :respond_to_with_resource_and_blocks
+    get :respond_with_resource_and_blocks
     assert_equal 'Render RSS', @response.body.strip
   end
 
-  def test_respond_to_fallback_to_first_block_when_mime_type_is_all
+  def test_respond_to_first_configured_mime_in_respond_to_when_mime_type_is_all
     @request.accept = '*/*'
-    get :respond_to_with_resource_and_blocks
-    assert_equal 'Render JSON', @response.body.strip
+    assert_raise ActionView::MissingTemplate do
+      get :respond_with_resource_and_blocks
+    end
+    assert_equal 'text/html', @response.content_type
   end
 
   def test_respond_to_skip_default_template_when_it_is_in_block