actionpack 1.11.2 → 1.12.0

data/test/{controller → activerecord}/active_record_assertions_test.rb

@@ -1,45 +1,6 @@
-require "#{File.dirname(__FILE__)}/../abstract_unit"
-
-# Unfurl the safety net.
-path_to_ar = File.dirname(__FILE__) + '/../../../activerecord'
-if Object.const_defined?(:ActiveRecord) || File.exist?(path_to_ar)
-  begin
-
-# These tests require Active Record, so you're going to need AR in a
-# sibling directory to AP and have SQLite installed.
-
-unless Object.const_defined?(:ActiveRecord)
-  require "#{path_to_ar}/lib/active_record"
-end
-
-begin
-  ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :dbfile => ':memory:')
-  ActiveRecord::Base.connection
-rescue Object
-  $stderr.puts 'SQLite 3 unavailable; falling to SQLite 2.'
-  ActiveRecord::Base.establish_connection(:adapter => 'sqlite', :dbfile => ':memory:')
-  ActiveRecord::Base.connection
-end
-
-# Set up company fixtures.
-$LOAD_PATH << "#{path_to_ar}/test"
-QUOTED_TYPE = ActiveRecord::Base.connection.quote_column_name('type') unless Object.const_defined?(:QUOTED_TYPE)
+require "#{File.dirname(__FILE__)}/../active_record_unit"
 require 'fixtures/company'
-File.read("#{path_to_ar}/test/fixtures/db_definitions/sqlite.sql").split(';').each do |sql|
-  ActiveRecord::Base.connection.execute(sql) unless sql.blank?
-end
-
-# Add some validation rules to trip up the assertions.
-class Company
-  protected
-    def validate
-      errors.add_on_empty('name')
-      errors.add('rating', 'rating should not be 2') if rating == 2
-      errors.add_to_base('oh oh') if rating == 3
-    end  
-end
 
-# A controller to host the assertions.
 class ActiveRecordAssertionsController < ActionController::Base
   self.template_root = "#{File.dirname(__FILE__)}/../fixtures/"
 
@@ -76,12 +37,15 @@ class ActiveRecordAssertionsController < ActionController::Base
   # the safety dance......
   def rescue_action(e) raise; end
 end
-                    
-class ActiveRecordAssertionsControllerTest < Test::Unit::TestCase
+                  
+class ActiveRecordAssertionsControllerTest < ActiveRecordTestCase
+  fixtures :companies
+  
   def setup
     @request = ActionController::TestRequest.new
     @response = ActionController::TestResponse.new
     @controller = ActiveRecordAssertionsController.new
+    super
   end
 
   # test for 1 bad apple column
@@ -117,11 +81,4 @@ class ActiveRecordAssertionsControllerTest < Test::Unit::TestCase
     assert_success
     assert_invalid_record 'company'
   end
-end 
-
-# End of safety net.
-  rescue Object => e
-    $stderr.puts "Skipping Active Record assertion tests: #{e}"
-    #$stderr.puts "  #{e.backtrace.join("\n  ")}"
-  end
-end
+end

data/test/{controller → activerecord}/active_record_store_test.rb

@@ -62,6 +62,10 @@ class ActiveRecordStoreTest < Test::Unit::TestCase
     CGI::Session::ActiveRecordStore::Session
   end
 
+  def session_id_column
+    "session_id"
+  end
+
   def setup
     session_class.create_table!
 
@@ -73,16 +77,31 @@ class ActiveRecordStoreTest < Test::Unit::TestCase
     @new_session['foo'] = 'bar'
   end
 
-  def test_another_instance
-    @another = CGI::Session.new(@cgi, 'session_id' => @new_session.session_id, 'database_manager' => CGI::Session::ActiveRecordStore)
-    assert_equal @new_session.session_id, @another.session_id
-  end
+# this test only applies for eager sesssion saving
+#  def test_another_instance
+#    @another = CGI::Session.new(@cgi, 'session_id' => @new_session.session_id, 'database_manager' => CGI::Session::ActiveRecordStore)
+#    assert_equal @new_session.session_id, @another.session_id
+#  end
 
   def test_model_attribute
     assert_kind_of CGI::Session::ActiveRecordStore::Session, @new_session.model
     assert_equal({ 'foo' => 'bar' }, @new_session.model.data)
   end
 
+  def test_save_unloaded_session
+    c = session_class.connection
+    bogus_class = c.quote(Base64.encode64("\004\010o:\vBlammo\000"))
+    c.insert("INSERT INTO #{session_class.table_name} ('#{session_id_column}', 'data') VALUES ('abcdefghijklmnop', #{bogus_class})")
+
+    sess = session_class.find_by_session_id('abcdefghijklmnop')
+    assert_not_nil sess
+    assert !sess.loaded?
+
+    # because the session is not loaded, the save should be a no-op. If it
+    # isn't, this'll try and unmarshall the bogus class, and should get an error.
+    assert_nothing_raised { sess.save }
+  end
+
   def teardown
     session_class.drop_table!
   end
@@ -109,6 +128,10 @@ class ColumnLimitTest < Test::Unit::TestCase
 end
 
 class DeprecatedActiveRecordStoreTest < ActiveRecordStoreTest
+  def session_id_column
+    "sessid"
+  end
+
   def setup
     session_class.connection.execute 'create table old_sessions (id integer primary key, sessid text unique, data text)'
     session_class.table_name = 'old_sessions'

data/test/activerecord/pagination_test.rb

@@ -0,0 +1,161 @@
+require File.dirname(__FILE__) + '/../active_record_unit'
+
+require 'fixtures/topic'
+require 'fixtures/reply'
+require 'fixtures/developer'
+require 'fixtures/project'
+
+class PaginationTest < ActiveRecordTestCase
+  fixtures :topics, :replies, :developers, :projects, :developers_projects
+
+  class PaginationController < ActionController::Base
+    self.template_root = "#{File.dirname(__FILE__)}/../fixtures/"
+    
+    def simple_paginate
+      @topic_pages, @topics = paginate(:topics)
+      render :nothing => true
+    end
+    
+    def paginate_with_per_page
+      @topic_pages, @topics = paginate(:topics, :per_page => 1)
+      render :nothing => true
+    end
+    
+    def paginate_with_order
+      @topic_pages, @topics = paginate(:topics, :order => 'created_at asc')
+      render :nothing => true
+    end
+    
+    def paginate_with_order_by
+      @topic_pages, @topics = paginate(:topics, :order_by => 'created_at asc')
+      render :nothing => true
+    end
+    
+    def paginate_with_include_and_order
+      @topic_pages, @topics = paginate(:topics, :include => :replies, :order => 'replies.created_at asc, topics.created_at asc')
+      render :nothing => true
+    end
+    
+    def paginate_with_conditions
+      @topic_pages, @topics = paginate(:topics, :conditions => ["created_at > ?", 30.minutes.ago])
+      render :nothing => true
+    end
+    
+    def paginate_with_class_name
+      @developer_pages, @developers = paginate(:developers, :class_name => "DeVeLoPeR")
+      render :nothing => true
+    end
+    
+    def paginate_with_singular_name
+      @developer_pages, @developers = paginate()
+      render :nothing => true
+    end
+    
+    def paginate_with_joins
+      @developer_pages, @developers = paginate(:developers, 
+                                             :joins => 'LEFT JOIN developers_projects ON developers.id = developers_projects.developer_id',
+                                             :conditions => 'project_id=1')        
+      render :nothing => true
+    end
+    
+    def paginate_with_join
+      @developer_pages, @developers = paginate(:developers, 
+                                             :join => 'LEFT JOIN developers_projects ON developers.id = developers_projects.developer_id',
+                                             :conditions => 'project_id=1')        
+      render :nothing => true
+    end
+     
+    def paginate_with_join_and_count
+      @developer_pages, @developers = paginate(:developers, 
+                                             :join => 'd LEFT JOIN developers_projects ON d.id = developers_projects.developer_id',
+                                             :conditions => 'project_id=1',
+                                             :count => "d.id")        
+      render :nothing => true
+    end
+    
+    def rescue_errors(e) raise e end
+
+    def rescue_action(e) raise end
+    
+  end
+  
+  def setup
+    @controller = PaginationController.new
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+    super
+  end
+
+  # Single Action Pagination Tests
+
+  def test_simple_paginate
+    get :simple_paginate
+    assert_equal 1, assigns(:topic_pages).page_count
+    assert_equal 3, assigns(:topics).size
+  end
+  
+  def test_paginate_with_per_page
+    get :paginate_with_per_page
+    assert_equal 1, assigns(:topics).size
+    assert_equal 3, assigns(:topic_pages).page_count
+  end
+  
+  def test_paginate_with_order
+    get :paginate_with_order
+    expected = [topics(:futurama),
+               topics(:harvey_birdman),
+               topics(:rails)]
+    assert_equal expected, assigns(:topics)
+    assert_equal 1, assigns(:topic_pages).page_count
+  end
+  
+  def test_paginate_with_order_by
+    get :paginate_with_order
+    expected = assigns(:topics)
+    get :paginate_with_order_by
+    assert_equal expected, assigns(:topics)  
+    assert_equal 1, assigns(:topic_pages).page_count    
+  end
+  
+  def test_paginate_with_conditions
+    get :paginate_with_conditions
+    expected = [topics(:rails)]
+    assert_equal expected, assigns(:topics)
+    assert_equal 1, assigns(:topic_pages).page_count
+  end
+  
+  def test_paginate_with_class_name
+    get :paginate_with_class_name
+    
+    assert assigns(:developers).size > 0
+    assert_equal DeVeLoPeR, assigns(:developers).first.class
+  end
+      
+  def test_paginate_with_joins
+    get :paginate_with_joins
+    assert_equal 2, assigns(:developers).size
+    developer_names = assigns(:developers).map { |d| d.name }
+    assert developer_names.include?('David')
+    assert developer_names.include?('Jamis')
+  end
+  
+  def test_paginate_with_join_and_conditions
+    get :paginate_with_joins
+    expected = assigns(:developers)
+    get :paginate_with_join
+    assert_equal expected, assigns(:developers)
+  end
+  
+  def test_paginate_with_join_and_count
+    get :paginate_with_joins
+    expected = assigns(:developers)
+    get :paginate_with_join_and_count
+    assert_equal expected, assigns(:developers)
+  end
+  
+  def test_paginate_with_include_and_order
+    get :paginate_with_include_and_order
+    expected = Topic.find(:all, :include => 'replies', :order => 'replies.created_at asc, topics.created_at asc', :limit => 10)
+    assert_equal expected, assigns(:topics)
+  end
+end

data/test/controller/action_pack_assertions_test.rb

@@ -87,7 +87,7 @@ class ActionPackAssertionsController < ActionController::Base
 
       def errors
         Class.new do 
-           def full_messages; '...stuff...'; end          
+           def full_messages; []; end          
         end.new
       end    
     
@@ -106,7 +106,7 @@ class ActionPackAssertionsController < ActionController::Base
       
       def errors
         Class.new do 
-           def full_messages; '...stuff...'; end          
+           def full_messages; ['...stuff...']; end          
         end.new
       end
     end.new                
@@ -174,17 +174,18 @@ class ActionPackAssertionsControllerTest < Test::Unit::TestCase
     assert_equal @response.body, 'request method: POST'
   end
   
-  # test the get/post switch within one test action
-  def test_get_post_switch
-    post :raise_on_get
-    assert_equal @response.body, 'request method: POST'
-    get :raise_on_post
-    assert_equal @response.body, 'request method: GET'
-    post :raise_on_get
-    assert_equal @response.body, 'request method: POST'
-    get :raise_on_post
-    assert_equal @response.body, 'request method: GET'
-  end
+#   the following test fails because the request_method is now cached on the request instance
+#   test the get/post switch within one test action
+#   def test_get_post_switch
+#     post :raise_on_get
+#     assert_equal @response.body, 'request method: POST'
+#     get :raise_on_post
+#     assert_equal @response.body, 'request method: GET'
+#     post :raise_on_get
+#     assert_equal @response.body, 'request method: POST'
+#     get :raise_on_post
+#     assert_equal @response.body, 'request method: GET'
+#   end
 
   # test the assertion of goodies in the template
   def test_assert_template_has
@@ -478,13 +479,15 @@ class ActionPackHeaderTest < Test::Unit::TestCase
     @controller = ActionPackAssertionsController.new
     @request, @response = ActionController::TestRequest.new, ActionController::TestResponse.new
   end
+
   def test_rendering_xml_sets_content_type
     process :hello_xml_world
-    assert_equal('text/xml', @controller.headers['Content-Type'])
+    assert_equal('application/xml', @controller.headers['Content-Type'])
   end
+
   def test_rendering_xml_respects_content_type
     @response.headers['Content-Type'] = 'application/pdf'
     process :hello_xml_world
     assert_equal('application/pdf', @controller.headers['Content-Type'])
   end
-end
+end

data/test/controller/base_test.rb

@@ -2,68 +2,57 @@ require File.dirname(__FILE__) + '/../abstract_unit'
 require 'test/unit'
 require 'pp' # require 'pp' early to prevent hidden_methods from not picking up the pretty-print methods until too late
 
-# This file currently contains a few controller UTs
-# I couldn't find where the current base tests are, so I created this file.
-# If there aren't any base-specific UTs, then this file should grow as they
-# are written. If there are, or there is a better place for these, then I will
-# move them to the correct location.
-#
-# Nicholas Seckar aka. Ulysses
-
-# Provide a static version of the Controllers module instead of the auto-loading version.
-# We don't want these tests to fail when dependencies are to blame.
-module Controllers
-  module Submodule
-    class ContainedEmptyController < ActionController::Base
-    end
-    class ContainedNonEmptyController < ActionController::Base
-      def public_action
-      end
-      
-      hide_action :hidden_action
-      def hidden_action
-      end
-      
-      def another_hidden_action
-      end
-      hide_action :another_hidden_action
-    end
-    class SubclassedController < ContainedNonEmptyController
-      hide_action :public_action # Hiding it here should not affect the superclass.
-    end
-  end
-  class EmptyController < ActionController::Base
-    include ActionController::Caching
+# Provide some controller to run the tests on.
+module Submodule
+  class ContainedEmptyController < ActionController::Base
   end
-  class NonEmptyController < ActionController::Base
+  class ContainedNonEmptyController < ActionController::Base
     def public_action
     end
     
     hide_action :hidden_action
     def hidden_action
     end
+    
+    def another_hidden_action
+    end
+    hide_action :another_hidden_action
+  end
+  class SubclassedController < ContainedNonEmptyController
+    hide_action :public_action # Hiding it here should not affect the superclass.
+  end
+end
+class EmptyController < ActionController::Base
+  include ActionController::Caching
+end
+class NonEmptyController < ActionController::Base
+  def public_action
+  end
+  
+  hide_action :hidden_action
+  def hidden_action
   end
 end
 
 class ControllerClassTests < Test::Unit::TestCase
   def test_controller_path
-    assert_equal 'empty', Controllers::EmptyController.controller_path
-    assert_equal 'submodule/contained_empty', Controllers::Submodule::ContainedEmptyController.controller_path
+    assert_equal 'empty', EmptyController.controller_path
+    assert_equal 'submodule/contained_empty', Submodule::ContainedEmptyController.controller_path
   end
   def test_controller_name
-    assert_equal 'empty', Controllers::EmptyController.controller_name
-    assert_equal 'contained_empty', Controllers::Submodule::ContainedEmptyController.controller_name
+    assert_equal 'empty', EmptyController.controller_name
+    assert_equal 'contained_empty', Submodule::ContainedEmptyController.controller_name
  end
 end
 
 class ControllerInstanceTests < Test::Unit::TestCase
   def setup
-    @empty = Controllers::EmptyController.new
-    @contained = Controllers::Submodule::ContainedEmptyController.new
-    @empty_controllers = [@empty, @contained, Controllers::Submodule::SubclassedController.new]
+    @empty = EmptyController.new
+    @contained = Submodule::ContainedEmptyController.new
+    @empty_controllers = [@empty, @contained, Submodule::SubclassedController.new]
     
-    @non_empty_controllers = [Controllers::NonEmptyController.new,
-                              Controllers::Submodule::ContainedNonEmptyController.new]
+    @non_empty_controllers = [NonEmptyController.new,
+                              Submodule::ContainedNonEmptyController.new]
   end
 
   def test_action_methods