actionpack 1.8.1 → 1.9.0

data/test/controller/active_record_store_test.rb

@@ -0,0 +1,111 @@
+# Unfurl the safety net.
+path_to_ar = File.dirname(__FILE__) + '/../../../activerecord'
+if Object.const_defined?(:ActiveRecord) or File.exist?(path_to_ar)
+  begin
+
+# These tests exercise CGI::Session::ActiveRecordStore, so you're going to
+# need AR in a sibling directory to AP and have SQLite installed.
+
+unless Object.const_defined?(:ActiveRecord)
+  require File.join(path_to_ar, 'lib', 'active_record')
+end
+
+require File.dirname(__FILE__) + '/../abstract_unit'
+require 'action_controller/session/active_record_store'
+
+#ActiveRecord::Base.logger = Logger.new($stdout)
+begin
+  CGI::Session::ActiveRecordStore::Session.establish_connection(:adapter => 'sqlite3', :dbfile => ':memory:')
+  CGI::Session::ActiveRecordStore::Session.connection
+rescue Object
+  $stderr.puts 'SQLite 3 unavailable; falling to SQLite 2.'
+  CGI::Session::ActiveRecordStore::Session.establish_connection(:adapter => 'sqlite', :dbfile => ':memory:')
+end
+
+
+module CommonActiveRecordStoreTests
+  def test_basics
+    s = session_class.new(:session_id => '1234', :data => { 'foo' => 'bar' })
+    assert_equal 'bar', s.data['foo']
+    assert s.save!
+    assert_equal 'bar', s.data['foo']
+
+    assert_not_nil t = session_class.find_by_session_id('1234')
+    assert_not_nil t.data
+    assert_equal 'bar', t.data['foo']
+  end
+
+  def test_reload_same_session
+    @new_session.update
+    reloaded = CGI::Session.new(CGI.new, 'session_id' => @new_session.session_id, 'database_manager' => CGI::Session::ActiveRecordStore)
+    assert_equal 'bar', reloaded['foo']
+  end
+
+  def test_tolerates_close_close
+    assert_nothing_raised do
+      @new_session.close
+      @new_session.close
+    end
+  end
+end
+
+class ActiveRecordStoreTest < Test::Unit::TestCase
+  include CommonActiveRecordStoreTests
+
+  def session_class
+    CGI::Session::ActiveRecordStore::Session
+  end
+
+  def setup
+    session_class.create_table!
+
+    ENV['REQUEST_METHOD'] = 'GET'
+    CGI::Session::ActiveRecordStore.session_class = session_class
+
+    @new_session = CGI::Session.new(CGI.new, 'database_manager' => CGI::Session::ActiveRecordStore, 'new_session' => true)
+    @new_session['foo'] = 'bar'
+  end
+
+  def teardown
+    session_class.drop_table!
+  end
+end
+
+
+class DeprecatedActiveRecordStoreTest < ActiveRecordStoreTest
+  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'
+    session_class.send :setup_sessid_compatibility!
+
+    ENV['REQUEST_METHOD'] = 'GET'
+    CGI::Session::ActiveRecordStore.session_class = session_class
+
+    @new_session = CGI::Session.new(CGI.new, 'database_manager' => CGI::Session::ActiveRecordStore, 'new_session' => true)
+    @new_session['foo'] = 'bar'
+  end
+
+  def teardown
+    session_class.connection.execute 'drop table old_sessions'
+    session_class.table_name = 'sessions'
+    session_class.send :setup_sessid_compatibility!
+  end
+end
+
+class SqlBypassActiveRecordStoreTest < ActiveRecordStoreTest
+  def session_class
+    unless @session_class
+      @session_class = CGI::Session::ActiveRecordStore::SqlBypass
+      @session_class.connection = CGI::Session::ActiveRecordStore::Session.connection
+    end
+    @session_class
+  end
+end
+
+
+# End of safety net.
+  rescue Object => e
+    $stderr.puts "Skipping CGI::Session::ActiveRecordStore tests: #{e}"    
+    #$stderr.puts "  #{e.backtrace.join("\n  ")}"
+  end
+end

data/test/controller/addresses_render_test.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/../abstract_unit'
+
+class Address
+
+  def Address.count(conditions = nil, join = nil)
+    nil
+  end
+  
+  def Address.find_all(arg1, arg2, arg3, arg4)
+    []
+  end
+end
+
+class AddressesTestController < ActionController::Base
+
+  scaffold :address
+
+  def self.controller_name; "addresses"; end
+  def self.controller_path; "addresses"; end
+
+end
+
+AddressesTestController.template_root = File.dirname(__FILE__) + "/../fixtures/"
+
+class AddressesTest < Test::Unit::TestCase
+  def setup
+    @controller = AddressesTestController.new
+
+    # enable a logger so that (e.g.) the benchmarking stuff runs, so we can get
+    # a more accurate simulation of what happens in "real life".
+    @controller.logger = Logger.new(nil)
+
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+
+    @request.host = "www.nextangle.com"
+  end
+
+  def test_list
+    get :list
+    assert_equal "We only need to get this far!", @response.body.chomp
+  end
+
+
+end

data/test/controller/caching_filestore.rb

@@ -0,0 +1,92 @@
+require 'fileutils'
+require File.dirname(__FILE__) + '/../abstract_unit'
+
+#generate the greatest logging class that ever lived
+class TestLogDevice < Logger::LogDevice
+  attr :last_message, true
+  
+  def initialize
+      @last_message=String.new
+  end
+  
+  def write(message)
+      @last_message << message
+  end
+
+  def clear
+    @last_message = String.new
+  end
+end
+
+#setup our really sophisticated logger
+TestLog = TestLogDevice.new
+RAILS_DEFAULT_LOGGER = Logger.new(TestLog)
+ActionController::Base.logger = RAILS_DEFAULT_LOGGER
+
+#generate a random key to ensure the cache is always in a different location
+RANDOM_KEY = rand(99999999).to_s
+FILE_STORE_PATH = File.dirname(__FILE__) + '/../temp/' + RANDOM_KEY
+ActionController::Base.perform_caching = true
+ActionController::Base.fragment_cache_store = ActionController::Caching::Fragments::FileStore.new(FILE_STORE_PATH)
+
+#setup the routing information...not sure if this does anything
+ActionController::Routing::Routes.connect "test", :controller => 'test', :action => 'render_to_cache'
+
+class TestController < ActionController::Base
+  caches_action :render_to_cache, :index
+ 
+  def render_to_cache
+    render_text "Render Cached"
+  end
+  alias :index :render_to_cache
+end
+
+class FileStoreTest < Test::Unit::TestCase
+  def setup
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+    @request.host = "hostname.com"
+  end
+
+  #To prime the cache with hostname.com/test
+  def test_render_to_cache_prime_a
+    @request.path_parameters = {:controller => "test"}
+    assert_fragment_cached do process_request end
+  end
+
+  #To prime the cache with hostname.com/test/render_to_cache
+  def test_render_to_cache_prime_b
+    @request.path_parameters = {:action => "render_to_cache", :controller => "test"}
+    assert_fragment_cached do process_request end
+  end
+
+  #To hit the cache with hostname.com/test 
+  def test_render_to_cache_zhit_a
+    @request.path_parameters = {:controller => "test"}
+    assert_fragment_hit do process_request end
+  end
+
+  #To hit the cache with hostname.com/test/render_to_cache
+  def test_render_to_cache_zhit_b
+    @request.path_parameters = {:action => "render_to_cache", :controller => "test"}
+    assert_fragment_hit do process_request end
+  end
+
+  private
+    def process_request
+      TestController.process(@request, @response)
+    end
+    
+    def assert_fragment_cached(&proc)
+      proc.call
+      assert(TestLog.last_message.include?("Cached fragment:"), "--ERROR-- FileStore write failed ----")
+      assert(!TestLog.last_message.include?("Couldn't create cache directory:"), "--ERROR-- FileStore create directory failed ----")
+      TestLog.clear
+    end
+    
+    def assert_fragment_hit(&proc)
+      proc.call
+      assert(TestLog.last_message.include?( "Fragment hit:"), "--ERROR-- Fragment not found in FileStore ----")
+      TestLog.clear
+    end
+end

data/test/controller/capture_test.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/../abstract_unit'
+
+class CaptureController < ActionController::Base
+  def self.controller_name; "test"; end
+  def self.controller_path; "test"; end
+
+  def rescue_action(e) raise end
+end
+
+CaptureController.template_root = File.dirname(__FILE__) + "/../fixtures/"
+
+class CaptureTest < Test::Unit::TestCase
+  def setup
+    @controller = CaptureController.new
+
+    # enable a logger so that (e.g.) the benchmarking stuff runs, so we can get
+    # a more accurate simulation of what happens in "real life".
+    @controller.logger = Logger.new(nil)
+
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+
+    @request.host = "www.nextangle.com"
+  end
+
+  def test_simple_capture
+    get :capturing
+    assert_equal "Dreamy days", @response.body.strip
+  end
+
+  def test_update_element_with_capture
+    get :update_element_with_capture
+    assert_equal(
+      "<script type=\"text/javascript\">$('products').innerHTML = '\\n  <p>Product 1</p>\\n  <p>Product 2</p>\\n';\n</script>" +
+        "\n\n$('status').innerHTML = '\\n  <b>You bought something!</b>\\n';", 
+      @response.body.strip
+    )
+  end
+end

data/test/controller/cgi_test.rb

@@ -1,3 +1,4 @@
+$:.unshift File.dirname(__FILE__) + "/../../lib"
 
 require 'test/unit'
 require 'action_controller/cgi_ext/cgi_methods'
@@ -21,6 +22,8 @@ class CGITest < Test::Unit::TestCase
     @query_string_with_amps  = "action=create_customer&name=Don%27t+%26+Does"
     @query_string_with_multiple_of_same_name = 
       "action=update_order&full_name=Lau%20Taarnskov&products=4&products=2&products=3"
+    @query_string_with_many_equal = "action=create_customer&full_name=abc=def=ghi"
+    @query_string_without_equal = "action"
   end
 
   def test_query_string
@@ -29,7 +32,16 @@ class CGITest < Test::Unit::TestCase
       CGIMethods.parse_query_parameters(@query_string)
     )
   end
-
+  
+  def test_deep_query_string
+    assert_equal({'x' => {'y' => {'z' => '10'}}}, CGIMethods.parse_query_parameters('x[y][z]=10'))
+  end
+  
+  def test_deep_query_string_with_array
+    assert_equal({'x' => {'y' => {'z' => ['10']}}}, CGIMethods.parse_query_parameters('x[y][z][]=10'))
+    assert_equal({'x' => {'y' => {'z' => ['10', '5']}}}, CGIMethods.parse_query_parameters('x[y][z][]=10&x[y][z][]=5'))
+  end
+  
   def test_query_string_with_nil
     assert_equal(
       { "action" => "create_customer", "full_name" => nil},
@@ -38,10 +50,10 @@ class CGITest < Test::Unit::TestCase
   end
 
   def test_query_string_with_array
-      assert_equal(
+    assert_equal(
       { "action" => "create_customer", "selected" => ["1", "2", "3"]},
       CGIMethods.parse_query_parameters(@query_string_with_array)
-      )
+    )
   end
 
   def test_query_string_with_amps
@@ -51,6 +63,20 @@ class CGITest < Test::Unit::TestCase
     )    
   end
   
+  def test_query_string_with_many_equal
+    assert_equal(
+      { "action" => "create_customer", "full_name" => "abc=def=ghi"},
+      CGIMethods.parse_query_parameters(@query_string_with_many_equal)
+    )    
+  end
+  
+  def test_query_string_without_equal
+    assert_equal(
+      { "action" => nil },
+      CGIMethods.parse_query_parameters(@query_string_without_equal)
+    )    
+  end
+  
   def test_parse_params
     input = {
       "customers[boston][first][name]" => [ "David" ],
@@ -94,12 +120,22 @@ class CGITest < Test::Unit::TestCase
   
     input = {
       "something" => [ StringIO.new("") ],
+      "array_of_stringios" => [[ StringIO.new("One"), StringIO.new("Two") ]],
+      "mixed_types_array" => [[ StringIO.new("Three"), "NotStringIO" ]],
+      "mixed_types_as_checkboxes[strings][nested]" => [[ mock_file, "String", StringIO.new("StringIO")]],
       "products[string]" => [ StringIO.new("Apple Computer") ],
       "products[file]" => [ mock_file ]
     }
     
     expected_output =  {
       "something" => "",
+      "array_of_stringios" => ["One", "Two"],
+      "mixed_types_array" => [ "Three", "NotStringIO" ],
+      "mixed_types_as_checkboxes" => {
+         "strings"=> {
+            "nested"=>[ mock_file, "String", "StringIO" ]
+         },
+      },
       "products"  => {
         "string"  => "Apple Computer",
         "file"    => mock_file
@@ -169,3 +205,4 @@ class CGITest < Test::Unit::TestCase
     assert_equal expected, CGIMethods.parse_request_parameters(input)
   end
 end
+

data/test/controller/helper_test.rb

@@ -9,7 +9,7 @@ end
 module Fun
   class GamesController < ActionController::Base
     def render_hello_world
-      render_template "hello: <%= stratego %>"
+      render :inline => "hello: <%= stratego %>"
     end
 
     def rescue_action(e) raise end
@@ -23,7 +23,6 @@ module LocalAbcHelper
 end
 
 class HelperTest < Test::Unit::TestCase
-
   def setup
     # Increment symbol counter.
     @symbol = (@@counter ||= 'A0').succ!.dup
@@ -50,7 +49,7 @@ class HelperTest < Test::Unit::TestCase
 
 
   def test_deprecated_helper
-    assert_equal helper_methods, missing_methods
+    assert_equal expected_helper_methods, missing_methods
     assert_nothing_raised { @controller_class.helper TestHelper }
     assert_equal [], missing_methods
   end
@@ -58,13 +57,13 @@ class HelperTest < Test::Unit::TestCase
   def test_declare_helper
     require 'abc_helper'
     self.test_helper = AbcHelper
-    assert_equal helper_methods, missing_methods
+    assert_equal expected_helper_methods, missing_methods
     assert_nothing_raised { @controller_class.helper :abc }
     assert_equal [], missing_methods
   end
 
   def test_declare_missing_helper
-    assert_equal helper_methods, missing_methods
+    assert_equal expected_helper_methods, missing_methods
     assert_raise(MissingSourceFile) { @controller_class.helper :missing }
   end
 
@@ -78,11 +77,11 @@ class HelperTest < Test::Unit::TestCase
     assert_nothing_raised {
       @controller_class.helper { def block_helper_method; end }
     }
-    assert template_methods.include?('block_helper_method')
+    assert master_helper_methods.include?('block_helper_method')
   end
 
   def test_helper_block_include
-    assert_equal helper_methods, missing_methods
+    assert_equal expected_helper_methods, missing_methods
     assert_nothing_raised {
       @controller_class.helper { include TestHelper }
     }
@@ -91,13 +90,13 @@ class HelperTest < Test::Unit::TestCase
 
   def test_helper_method
     assert_nothing_raised { @controller_class.helper_method :delegate_method }
-    assert template_methods.include?('delegate_method')
+    assert master_helper_methods.include?('delegate_method')
   end
 
   def test_helper_attr
     assert_nothing_raised { @controller_class.helper_attr :delegate_attr }
-    assert template_methods.include?('delegate_attr')
-    assert template_methods.include?('delegate_attr=')
+    assert master_helper_methods.include?('delegate_attr')
+    assert master_helper_methods.include?('delegate_attr=')
   end
 
   def test_helper_for_nested_controller
@@ -109,9 +108,17 @@ class HelperTest < Test::Unit::TestCase
   end
 
   private
-    def helper_methods;   TestHelper.instance_methods      end
-    def template_methods; @template_class.instance_methods  end
-    def missing_methods;  helper_methods - template_methods end
+    def expected_helper_methods
+      TestHelper.instance_methods
+    end
+
+    def master_helper_methods
+      @controller_class.master_helper_module.instance_methods
+    end
+
+    def missing_methods
+      expected_helper_methods - master_helper_methods
+    end
 
     def test_helper=(helper_module)
       old_verbose, $VERBOSE = $VERBOSE, nil
@@ -119,3 +126,48 @@ class HelperTest < Test::Unit::TestCase
       $VERBOSE = old_verbose
     end
 end
+
+
+class IsolatedHelpersTest < Test::Unit::TestCase
+  class A < ActionController::Base
+    def index
+      render :inline => '<%= shout %>'
+    end
+
+    def rescue_action(e) raise end
+  end
+
+  class B < A
+    helper { def shout; 'B' end }
+
+    def index
+      render :inline => '<%= shout %>'
+    end
+  end
+
+  class C < A
+    helper { def shout; 'C' end }
+
+    def index
+      render :inline => '<%= shout %>'
+    end
+  end
+
+  def setup
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+    @request.action = 'index'
+  end
+
+  def test_helper_in_a
+    assert_raise(NameError) { A.process(@request, @response) }
+  end
+
+  def test_helper_in_b
+    assert_equal 'B', B.process(@request, @response).body
+  end
+
+  def test_helper_in_c
+    assert_equal 'C', C.process(@request, @response).body
+  end
+end