emmanuel-inherited_resources 0.9.1

data/test/customized_belongs_to_test.rb

@@ -0,0 +1,76 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class GreatSchool
+end
+
+class Professor
+  def self.human_name; 'Professor'; end
+end
+
+class ProfessorsController < InheritedResources::Base
+  belongs_to :school, :parent_class => GreatSchool, :instance_name => :great_school,
+                      :finder => :find_by_title!, :param => :school_title
+end
+
+class CustomizedBelongsToTest < ActionController::TestCase
+  tests ProfessorsController
+
+  def setup
+    GreatSchool.expects(:find_by_title!).with('nice').returns(mock_school(:professors => Professor))
+    @controller.stubs(:resource_url).returns('/')
+    @controller.stubs(:collection_url).returns('/')
+  end
+
+  def test_expose_the_resquested_school_with_chosen_instance_variable_on_index
+    Professor.stubs(:find).returns([mock_professor])
+    get :index, :school_title => 'nice'
+    assert_equal mock_school, assigns(:great_school)
+  end
+
+  def test_expose_the_resquested_school_with_chosen_instance_variable_on_show
+    Professor.stubs(:find).returns(mock_professor)
+    get :show, :school_title => 'nice'
+    assert_equal mock_school, assigns(:great_school)
+  end
+
+  def test_expose_the_resquested_school_with_chosen_instance_variable_on_new
+    Professor.stubs(:build).returns(mock_professor)
+    get :new, :school_title => 'nice'
+    assert_equal mock_school, assigns(:great_school)
+  end
+
+  def test_expose_the_resquested_school_with_chosen_instance_variable_on_edit
+    Professor.stubs(:find).returns(mock_professor)
+    get :edit, :school_title => 'nice'
+    assert_equal mock_school, assigns(:great_school)
+  end
+
+  def test_expose_the_resquested_school_with_chosen_instance_variable_on_create
+    Professor.stubs(:build).returns(mock_professor(:save => true))
+    post :create, :school_title => 'nice'
+    assert_equal mock_school, assigns(:great_school)
+  end
+
+  def test_expose_the_resquested_school_with_chosen_instance_variable_on_update
+    Professor.stubs(:find).returns(mock_professor(:update_attributes => true))
+    put :update, :school_title => 'nice'
+    assert_equal mock_school, assigns(:great_school)
+  end
+
+  def test_expose_the_resquested_school_with_chosen_instance_variable_on_destroy
+    Professor.stubs(:find).returns(mock_professor(:destroy => true))
+    delete :destroy, :school_title => 'nice'
+    assert_equal mock_school, assigns(:great_school)
+  end
+
+  protected
+
+    def mock_school(stubs={})
+      @mock_school ||= mock(stubs)
+    end
+
+    def mock_professor(stubs={})
+      @mock_professor ||= mock(stubs)
+    end
+end
+

data/test/defaults_test.rb

@@ -0,0 +1,70 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class Malarz
+  def self.human_name; 'Painter'; end
+end
+
+class PaintersController < InheritedResources::Base
+  defaults :instance_name => 'malarz', :collection_name => 'malarze',
+           :resource_class => Malarz, :route_prefix => nil
+end
+
+class DefaultsTest < ActionController::TestCase
+  tests PaintersController
+
+  def setup
+    @controller.stubs(:resource_url).returns('/')
+    @controller.stubs(:collection_url).returns('/')
+  end
+
+  def test_expose_all_painters_as_instance_variable
+    Malarz.expects(:find).with(:all).returns([mock_painter])
+    get :index
+    assert_equal [mock_painter], assigns(:malarze)
+  end
+
+  def test_expose_the_resquested_painter_on_show
+    Malarz.expects(:find).with('42').returns(mock_painter)
+    get :show, :id => '42'
+    assert_equal mock_painter, assigns(:malarz)
+  end
+
+  def test_expose_a_new_painter
+    Malarz.expects(:new).returns(mock_painter)
+    get :new
+    assert_equal mock_painter, assigns(:malarz)
+  end
+
+  def test_expose_the_resquested_painter_on_edit
+    Malarz.expects(:find).with('42').returns(mock_painter)
+    get :edit, :id => '42'
+    assert_response :success
+    assert_equal mock_painter, assigns(:malarz)
+  end
+
+  def test_expose_a_newly_create_painter_when_saved_with_success
+    Malarz.expects(:new).with({'these' => 'params'}).returns(mock_painter(:save => true))
+    post :create, :malarz => {:these => 'params'}
+    assert_equal mock_painter, assigns(:malarz)
+  end
+
+  def test_update_the_requested_object
+    Malarz.expects(:find).with('42').returns(mock_painter)
+    mock_painter.expects(:update_attributes).with({'these' => 'params'}).returns(true)
+    put :update, :id => '42', :malarz => {:these => 'params'}
+    assert_equal mock_painter, assigns(:malarz)
+  end
+
+  def test_the_resquested_painter_is_destroyed
+    Malarz.expects(:find).with('42').returns(mock_painter)
+    mock_painter.expects(:destroy)
+    delete :destroy, :id => '42'
+    assert_equal mock_painter, assigns(:malarz)
+  end
+
+  protected
+    def mock_painter(stubs={})
+      @mock_painter ||= mock(stubs)
+    end
+end
+

data/test/flash_test.rb

@@ -0,0 +1,88 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class Address
+  def self.human_name; 'Address'; end
+end
+
+class AddressesController < InheritedResources::Base
+  respond_to :xml
+  protected
+    def interpolation_options
+      { :reference => 'Ocean Avenue' }
+    end
+end
+
+module Admin; end
+class Admin::AddressesController < InheritedResources::Base
+  respond_to :xml
+  protected
+    def interpolation_options
+      { :reference => 'Ocean Avenue' }
+    end
+end
+
+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))
+    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))
+    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))
+    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
+    assert_equal 'Nice! Address was updated with success!', flash[:notice]
+  end
+
+  def test_success_flash_message_on_update
+    Address.stubs(:find).returns(mock_address(:update_attributes => true))
+    put :update
+    assert_response :success
+    assert_equal 'Nice! Address was updated with success!', flash[:notice]
+  end
+
+  def test_failure_flash_message_on_update
+    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
+
+  def test_success_flash_message_on_destroy
+    Address.stubs(:find).returns(mock_address(:destroy => true))
+    delete :destroy
+    assert_equal 'Address was successfully destroyed.', flash[:notice]
+  end
+
+  protected
+    def mock_address(stubs={})
+      @mock_address ||= stub(stubs.merge(:to_xml => "xml"))
+    end
+end

data/test/has_scope_test.rb

@@ -0,0 +1,112 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class Tree
+  def self.human_name; 'Tree'; end
+end
+
+class TreesController < InheritedResources::Base
+  has_scope :color
+  has_scope :only_tall, :boolean => true, :only => :index
+  has_scope :shadown_range, :default => 10, :except => [ :index, :show, :destroy, :new ]
+  has_scope :root_type, :as => :root
+  has_scope :calculate_height, :default => proc {|c| c.session[:height] || 20 }, :only => :new
+end
+
+class HasScopeTest < ActionController::TestCase
+  tests TreesController
+
+  def setup
+    @controller.stubs(:resource_url).returns('/')
+    @controller.stubs(:collection_url).returns('/')
+  end
+
+  def test_boolean_scope_is_called_when_boolean_param_is_true
+    Tree.expects(:only_tall).with().returns(Tree).in_sequence
+    Tree.expects(:find).with(:all).returns([mock_tree]).in_sequence
+    get :index, :only_tall => 'true'
+    assert_equal([mock_tree], assigns(:trees))
+    assert_equal({ :only_tall => 'true' }, assigns(:current_scopes))
+  end
+
+  def test_boolean_scope_is_called_when_boolean_param_is_false
+    Tree.expects(:only_tall).never
+    Tree.expects(:find).with(:all).returns([mock_tree])
+    get :index, :only_tall => 'false'
+    assert_equal([mock_tree], assigns(:trees))
+    assert_equal({ :only_tall => 'false' }, assigns(:current_scopes))
+  end
+
+  def test_scope_is_called_only_on_index
+    Tree.expects(:only_tall).never
+    Tree.expects(:find).with('42').returns(mock_tree)
+    get :show, :only_tall => 'true', :id => '42'
+    assert_equal(mock_tree, assigns(:tree))
+    assert_equal({ }, assigns(:current_scopes))
+  end
+
+  def test_scope_is_called_except_on_index
+    Tree.expects(:shadown_range).with().never
+    Tree.expects(:find).with(:all).returns([mock_tree])
+    get :index, :shadown_range => 20
+    assert_equal([mock_tree], assigns(:trees))
+    assert_equal({ }, assigns(:current_scopes))
+  end
+
+  def test_scope_is_called_with_arguments
+    Tree.expects(:color).with('blue').returns(Tree).in_sequence
+    Tree.expects(:find).with(:all).returns([mock_tree]).in_sequence
+    get :index, :color => 'blue'
+    assert_equal([mock_tree], assigns(:trees))
+    assert_equal({ :color => 'blue' }, assigns(:current_scopes))
+  end
+
+  def test_multiple_scopes_are_called
+    Tree.expects(:only_tall).with().returns(Tree)
+    Tree.expects(:color).with('blue').returns(Tree)
+    Tree.expects(:find).with(:all).returns([mock_tree])
+    get :index, :color => 'blue', :only_tall => 'true'
+    assert_equal([mock_tree], assigns(:trees))
+    assert_equal({ :color => 'blue', :only_tall => 'true' }, assigns(:current_scopes))
+  end
+
+  def test_scope_is_called_with_default_value
+    Tree.expects(:shadown_range).with(10).returns(Tree).in_sequence
+    Tree.expects(:find).with('42').returns(mock_tree).in_sequence
+    get :edit, :id => '42'
+    assert_equal(mock_tree, assigns(:tree))
+    assert_equal({ :shadown_range => 10 }, assigns(:current_scopes))
+  end
+
+  def test_default_scope_value_can_be_overwritten
+    Tree.expects(:shadown_range).with('20').returns(Tree).in_sequence
+    Tree.expects(:find).with('42').returns(mock_tree).in_sequence
+    get :edit, :id => '42', :shadown_range => '20'
+    assert_equal(mock_tree, assigns(:tree))
+    assert_equal({ :shadown_range => '20' }, assigns(:current_scopes))
+  end
+
+  def test_scope_with_different_key
+    Tree.expects(:root_type).with('outside').returns(Tree).in_sequence
+    Tree.expects(:find).with('42').returns(mock_tree).in_sequence
+    get :show, :id => '42', :root => 'outside'
+    assert_equal(mock_tree, assigns(:tree))
+    assert_equal({ :root => 'outside' }, assigns(:current_scopes))
+  end
+
+  def test_scope_with_default_value_as_proc
+    session[:height] = 100
+    Tree.expects(:calculate_height).with(100).returns(Tree).in_sequence
+    Tree.expects(:new).returns(mock_tree).in_sequence
+    get :new
+    assert_equal(mock_tree, assigns(:tree))
+    assert_equal({ :calculate_height => 100 }, assigns(:current_scopes))
+   end
+
+  protected
+
+    def mock_tree(stubs={})
+      @mock_tree ||= mock(stubs)
+    end
+
+end
+

data/test/nested_belongs_to_test.rb

@@ -0,0 +1,108 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class Country
+end
+
+class State
+end
+
+class City
+  def self.human_name; 'City'; end
+end
+
+class CitiesController < InheritedResources::Base
+  belongs_to :country, :state
+end
+
+class NestedBelongsToTest < ActionController::TestCase
+  tests CitiesController
+
+  def setup
+    Country.expects(:find).with('13').returns(mock_country)
+    mock_country.expects(:states).returns(State)
+    State.expects(:find).with('37').returns(mock_state)
+    mock_state.expects(:cities).returns(City)
+
+    @controller.stubs(:resource_url).returns('/')
+    @controller.stubs(:collection_url).returns('/')
+  end
+
+  def test_assigns_country_and_state_and_city_on_create
+    City.expects(:find).with(:all).returns([mock_city])
+    get :index, :state_id => '37', :country_id => '13'
+
+    assert_equal mock_country, assigns(:country)
+    assert_equal mock_state, assigns(:state)
+    assert_equal [mock_city], assigns(:cities)
+  end
+
+  def test_assigns_country_and_state_and_city_on_show
+    City.expects(:find).with('42').returns(mock_city)
+    get :show, :id => '42', :state_id => '37', :country_id => '13'
+
+    assert_equal mock_country, assigns(:country)
+    assert_equal mock_state, assigns(:state)
+    assert_equal mock_city, assigns(:city)
+  end
+
+  def test_assigns_country_and_state_and_city_on_new
+    City.expects(:build).returns(mock_city)
+    get :new, :state_id => '37', :country_id => '13'
+
+    assert_equal mock_country, assigns(:country)
+    assert_equal mock_state, assigns(:state)
+    assert_equal mock_city, assigns(:city)
+  end
+
+  def test_assigns_country_and_state_and_city_on_edit
+    City.expects(:find).with('42').returns(mock_city)
+    get :edit, :id => '42', :state_id => '37', :country_id => '13'
+
+    assert_equal mock_country, assigns(:country)
+    assert_equal mock_state, assigns(:state)
+    assert_equal mock_city, assigns(:city)
+  end
+
+  def test_assigns_country_and_state_and_city_on_create
+    City.expects(:build).with({'these' => 'params'}).returns(mock_city)
+    mock_city.expects(:save).returns(true)
+    post :create, :state_id => '37', :country_id => '13', :city => {:these => 'params'}
+
+    assert_equal mock_country, assigns(:country)
+    assert_equal mock_state, assigns(:state)
+    assert_equal mock_city, assigns(:city)
+  end
+
+  def test_assigns_country_and_state_and_city_on_update
+    City.expects(:find).with('42').returns(mock_city)
+    mock_city.expects(:update_attributes).returns(true)
+    put :update, :id => '42', :state_id => '37', :country_id => '13', :city => {:these => 'params'}
+
+    assert_equal mock_country, assigns(:country)
+    assert_equal mock_state, assigns(:state)
+    assert_equal mock_city, assigns(:city)
+  end
+  
+  def test_assigns_country_and_state_and_city_on_destroy
+    City.expects(:find).with('42').returns(mock_city)
+    mock_city.expects(:destroy)
+    delete :destroy, :id => '42', :state_id => '37', :country_id => '13'
+
+    assert_equal mock_country, assigns(:country)
+    assert_equal mock_state, assigns(:state)
+    assert_equal mock_city, assigns(:city)
+  end
+
+  protected
+    def mock_country(stubs={})
+      @mock_country ||= mock(stubs)
+    end
+
+    def mock_state(stubs={})
+      @mock_state ||= mock(stubs)
+    end
+
+    def mock_city(stubs={})
+      @mock_city ||= mock(stubs)
+    end
+end

data/test/optional_belongs_to_test.rb

@@ -0,0 +1,164 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class Brands; end
+class Category; end
+
+class Product
+  def self.human_name; 'Product'; end
+end
+
+class ProductsController < InheritedResources::Base
+  belongs_to :brand, :category, :polymorphic => true, :optional => true
+end
+
+class OptionalTest < ActionController::TestCase
+  tests ProductsController
+
+  def setup
+    @controller.stubs(:resource_url).returns('/')
+    @controller.stubs(:collection_url).returns('/')
+  end
+
+  def test_expose_all_products_as_instance_variable_with_category
+    Category.expects(:find).with('37').returns(mock_category)
+    mock_category.expects(:products).returns(Product)
+    Product.expects(:find).with(:all).returns([mock_product])
+    get :index, :category_id => '37'
+    assert_equal mock_category, assigns(:category)
+    assert_equal [mock_product], assigns(:products)
+  end
+
+  def test_expose_all_products_as_instance_variable_without_category
+    Product.expects(:find).with(:all).returns([mock_product])
+    get :index
+    assert_equal nil, assigns(:category)
+    assert_equal [mock_product], assigns(:products)
+  end
+
+  def test_expose_the_resquested_product_with_category
+    Category.expects(:find).with('37').returns(mock_category)
+    mock_category.expects(:products).returns(Product)
+    Product.expects(:find).with('42').returns(mock_product)
+    get :show, :id => '42', :category_id => '37'
+    assert_equal mock_category, assigns(:category)
+    assert_equal mock_product, assigns(:product)
+  end
+
+  def test_expose_the_resquested_product_without_category
+    Product.expects(:find).with('42').returns(mock_product)
+    get :show, :id => '42'
+    assert_equal nil, assigns(:category)
+    assert_equal mock_product, assigns(:product)
+  end
+
+  def test_expose_a_new_product_with_category
+    Category.expects(:find).with('37').returns(mock_category)
+    mock_category.expects(:products).returns(Product)
+    Product.expects(:build).returns(mock_product)
+    get :new, :category_id => '37'
+    assert_equal mock_category, assigns(:category)
+    assert_equal mock_product, assigns(:product)
+  end
+
+  def test_expose_a_new_product_without_category
+    Product.expects(:new).returns(mock_product)
+    get :new
+    assert_equal nil, assigns(:category)
+    assert_equal mock_product, assigns(:product)
+  end
+
+  def test_expose_the_resquested_product_for_edition_with_category
+    Category.expects(:find).with('37').returns(mock_category)
+    mock_category.expects(:products).returns(Product)
+    Product.expects(:find).with('42').returns(mock_product)
+    get :edit, :id => '42', :category_id => '37'
+    assert_equal mock_category, assigns(:category)
+    assert_equal mock_product, assigns(:product)
+  end
+
+  def test_expose_the_resquested_product_for_edition_without_category
+    Product.expects(:find).with('42').returns(mock_product)
+    get :edit, :id => '42'
+    assert_equal nil, assigns(:category)
+    assert_equal mock_product, assigns(:product)
+  end
+
+  def test_expose_a_newly_create_product_with_category
+    Category.expects(:find).with('37').returns(mock_category)
+    mock_category.expects(:products).returns(Product)
+    Product.expects(:build).with({'these' => 'params'}).returns(mock_product(:save => true))
+    post :create, :category_id => '37', :product => {:these => 'params'}
+    assert_equal mock_category, assigns(:category)
+    assert_equal mock_product, assigns(:product)
+  end
+
+  def test_expose_a_newly_create_product_without_category
+    Product.expects(:new).with({'these' => 'params'}).returns(mock_product(:save => true))
+    post :create, :product => {:these => 'params'}
+    assert_equal nil, assigns(:category)
+    assert_equal mock_product, assigns(:product)
+  end
+
+  def test_update_the_requested_object_with_category
+    Category.expects(:find).with('37').returns(mock_category)
+    mock_category.expects(:products).returns(Product)
+    Product.expects(:find).with('42').returns(mock_product)
+    mock_product.expects(:update_attributes).with({'these' => 'params'}).returns(true)
+
+    put :update, :id => '42', :category_id => '37', :product => {:these => 'params'}
+    assert_equal mock_category, assigns(:category)
+    assert_equal mock_product, assigns(:product)
+  end
+
+  def test_update_the_requested_object_without_category
+    Product.expects(:find).with('42').returns(mock_product)
+    mock_product.expects(:update_attributes).with({'these' => 'params'}).returns(true)
+
+    put :update, :id => '42', :product => {:these => 'params'}
+    assert_equal nil, assigns(:category)
+    assert_equal mock_product, assigns(:product)
+  end
+
+  def test_the_resquested_product_is_destroyed_with_category
+    Category.expects(:find).with('37').returns(mock_category)
+    mock_category.expects(:products).returns(Product)
+    Product.expects(:find).with('42').returns(mock_product)
+    mock_product.expects(:destroy)
+    @controller.expects(:collection_url).returns('/')
+
+    delete :destroy, :id => '42', :category_id => '37'
+    assert_equal mock_category, assigns(:category)
+    assert_equal mock_product, assigns(:product)
+  end
+
+  def test_the_resquested_product_is_destroyed_without_category
+    Product.expects(:find).with('42').returns(mock_product)
+    mock_product.expects(:destroy)
+    @controller.expects(:collection_url).returns('/')
+
+    delete :destroy, :id => '42'
+    assert_equal nil, assigns(:category)
+    assert_equal mock_product, assigns(:product)
+  end
+
+  def test_polymorphic_helpers
+    Product.expects(:find).with(:all).returns([mock_product])
+    get :index
+
+    assert !@controller.send(:parent?)
+    assert_equal nil, assigns(:parent_type)
+    assert_equal nil, @controller.send(:parent_type)
+    assert_equal nil, @controller.send(:parent_class)
+    assert_equal nil, assigns(:category)
+    assert_equal nil, @controller.send(:parent)
+  end
+
+  protected
+    def mock_category(stubs={})
+      @mock_category ||= mock(stubs)
+    end
+
+    def mock_product(stubs={})
+      @mock_product ||= mock(stubs)
+    end
+end