actionpack 2.2.3 → 2.3.2

data/test/controller/session/mem_cache_store_test.rb

@@ -1,181 +1,127 @@
 require 'abstract_unit'
-require 'action_controller/cgi_process'
-require 'action_controller/cgi_ext'
 
+# You need to start a memcached server inorder to run these tests
+class MemCacheStoreTest < ActionController::IntegrationTest
+  class TestController < ActionController::Base
+    def no_session_access
+      head :ok
+    end
 
-class CGI::Session
-  def cache
-    dbman.instance_variable_get(:@cache)
-  end
-end
+    def set_session_value
+      session[:foo] = "bar"
+      head :ok
+    end
 
+    def get_session_value
+      render :text => "foo: #{session[:foo].inspect}"
+    end
 
-uses_mocha 'MemCacheStore tests' do
-if defined? MemCache::MemCacheError
-
-class MemCacheStoreTest < Test::Unit::TestCase
-  SESSION_KEY_RE = /^session:[0-9a-z]+/
-  CONN_TEST_KEY = 'connection_test'
-  MULTI_TEST_KEY = '0123456789'
-  TEST_DATA = 'Hello test'
-
-  def self.get_mem_cache_if_available
-    begin
-      require 'memcache'
-      cache = MemCache.new('127.0.0.1')
-      # Test availability of the connection
-      cache.set(CONN_TEST_KEY, 1)
-      unless cache.get(CONN_TEST_KEY) == 1
-        puts 'Warning: memcache server available but corrupted.'
-        return nil
-      end
-    rescue LoadError, MemCache::MemCacheError
-      return nil
+    def get_session_id
+      session[:foo]
+      render :text => "#{request.session_options[:id]}"
+    end
+
+    def call_reset_session
+      session[:bar]
+      reset_session
+      session[:bar] = "baz"
+      head :ok
     end
-    return cache
+
+    def rescue_action(e) raise end
   end
 
-  CACHE = get_mem_cache_if_available
+  begin
+    DispatcherApp = ActionController::Dispatcher.new
+    MemCacheStoreApp = ActionController::Session::MemCacheStore.new(
+                         DispatcherApp, :key => '_session_id')
 
 
-  def test_initialization
-    assert_raise(ArgumentError) { new_session('session_id' => '!invalid_id') }
-    new_session do |s|
-      assert_equal Hash.new, s.cache.get('session:' + s.session_id)
+    def setup
+      @integration_session = open_session(MemCacheStoreApp)
     end
-  end
 
+    def test_setting_and_getting_session_value
+      with_test_route_set do
+        get '/set_session_value'
+        assert_response :success
+        assert cookies['_session_id']
 
-  def test_storage
-    d = rand(0xffff)
-    new_session do |s|
-      session_key = 'session:' + s.session_id
-      unless CACHE
-        s.cache.expects(:get).with(session_key) \
-                             .returns(:test => d)
-        s.cache.expects(:set).with(session_key,
-                                   has_entry(:test, d),
-                                   0)
+        get '/get_session_value'
+        assert_response :success
+        assert_equal 'foo: "bar"', response.body
       end
-      s[:test] = d
-      s.close
-      assert_equal d, s.cache.get(session_key)[:test]
-      assert_equal d, s[:test]
     end
-  end         
-  
-  def test_deletion
-    new_session do |s|
-      session_key = 'session:' + s.session_id
-      unless CACHE
-        s.cache.expects(:delete)
-        s.cache.expects(:get).with(session_key) \
-                             .returns(nil)
+
+    def test_getting_nil_session_value
+      with_test_route_set do
+        get '/get_session_value'
+        assert_response :success
+        assert_equal 'foo: nil', response.body
       end
-      s[:test] = rand(0xffff)
-      s.delete
-      assert_nil s.cache.get(session_key)
     end
-  end
 
+    def test_setting_session_value_after_session_reset
+      with_test_route_set do
+        get '/set_session_value'
+        assert_response :success
+        assert cookies['_session_id']
+        session_id = cookies['_session_id']
 
-  def test_other_session_retrieval
-    new_session do |sa|
-      unless CACHE
-        sa.cache.expects(:set).with('session:' + sa.session_id,
-                                    has_entry(:test, TEST_DATA),
-                                    0)
-      end
-      sa[:test] = TEST_DATA
-      sa.close
-      new_session('session_id' => sa.session_id) do |sb|
-        unless CACHE
-          sb.cache.expects(:[]).with('session:' + sb.session_id) \
-                               .returns(:test => TEST_DATA)
-        end
-        assert_equal(TEST_DATA, sb[:test])
+        get '/call_reset_session'
+        assert_response :success
+        assert_not_equal [], headers['Set-Cookie']
+
+        get '/get_session_value'
+        assert_response :success
+        assert_equal 'foo: nil', response.body
+
+        get '/get_session_id'
+        assert_response :success
+        assert_not_equal session_id, response.body
       end
     end
-  end
 
+    def test_getting_session_id
+      with_test_route_set do
+        get '/set_session_value'
+        assert_response :success
+        assert cookies['_session_id']
+        session_id = cookies['_session_id']
 
-  def test_multiple_sessions
-    s_slots = Array.new(10)
-    operation = :write
-    last_data = nil
-    reads = writes = 0
-    50.times do
-      current = rand(10)
-      s_slots[current] ||= new_session('session_id' => MULTI_TEST_KEY,
-                                       'new_session' => true)
-      s = s_slots[current]
-      case operation
-      when :write
-        last_data = rand(0xffff)
-        unless CACHE
-          s.cache.expects(:set).with('session:' + MULTI_TEST_KEY,
-                                     { :test => last_data },
-                                     0)
-        end
-        s[:test] = last_data
-        s.close
-        writes += 1
-      when :read
-        # Make CGI::Session#[] think there was no data retrieval yet.
-        # Normally, the session caches the data during its lifetime.
-        s.instance_variable_set(:@data, nil)
-        unless CACHE
-          s.cache.expects(:[]).with('session:' + MULTI_TEST_KEY) \
-                              .returns(:test => last_data)
-        end
-        d = s[:test]
-        assert_equal(last_data, d, "OK reads: #{reads}, OK writes: #{writes}")
-        reads += 1
+        get '/get_session_id'
+        assert_response :success
+        assert_equal session_id, response.body
       end
-      operation = rand(5) == 0 ? :write : :read
     end
-  end
 
+    def test_prevents_session_fixation
+      with_test_route_set do
+        get '/get_session_value'
+        assert_response :success
+        assert_equal 'foo: nil', response.body
+        session_id = cookies['_session_id']
 
+        reset!
 
-  private
-  def obtain_session_options
-    options = { 'database_manager' => CGI::Session::MemCacheStore,
-                'session_key' => '_test_app_session'
-              }
-    # if don't have running memcache server we use mock instead
-    unless CACHE
-      options['cache'] = c = mock
-      c.stubs(:[]).with(regexp_matches(SESSION_KEY_RE))
-      c.stubs(:get).with(regexp_matches(SESSION_KEY_RE)) \
-                   .returns(Hash.new)
-      c.stubs(:add).with(regexp_matches(SESSION_KEY_RE),
-                         instance_of(Hash),
-                         0)
+        get '/set_session_value', :_session_id => session_id
+        assert_response :success
+        assert_equal nil, cookies['_session_id']
+      end
     end
-    options
+  rescue LoadError, RuntimeError
+    $stderr.puts "Skipping MemCacheStoreTest tests. Start memcached and try again."
   end
 
-
-  def new_session(options = {})
-    with_cgi do |cgi|
-      @options = obtain_session_options.merge(options)
-      session = CGI::Session.new(cgi, @options)
-      yield session if block_given?
-      return session
+  private
+    def with_test_route_set
+      with_routing do |set|
+        set.draw do |map|
+          map.with_options :controller => "mem_cache_store_test/test" do |c|
+            c.connect "/:action"
+          end
+        end
+        yield
+      end
     end
-  end
-
-  def with_cgi
-    ENV['REQUEST_METHOD'] = 'GET'
-    ENV['HTTP_HOST'] = 'example.com'
-    ENV['QUERY_STRING'] = ''
-
-    cgi = CGI.new('query', StringIO.new(''))
-    yield cgi if block_given?
-    cgi
-  end
 end
-
-end # defined? MemCache
-end # uses_mocha

data/test/controller/session/test_session_test.rb

@@ -0,0 +1,58 @@
+require 'abstract_unit'
+require 'stringio'
+
+class ActionController::TestSessionTest < ActiveSupport::TestCase
+  
+  def test_calling_delete_without_parameters_raises_deprecation_warning_and_calls_to_clear_test_session
+    assert_deprecated(/use clear instead/){ ActionController::TestSession.new.delete }
+  end
+  
+  def test_calling_update_without_parameters_raises_deprecation_warning_and_calls_to_clear_test_session
+    assert_deprecated(/use replace instead/){ ActionController::TestSession.new.update }
+  end
+  
+  def test_calling_close_raises_deprecation_warning
+    assert_deprecated(/sessions should no longer be closed/){ ActionController::TestSession.new.close }
+  end
+  
+  def test_defaults
+    session = ActionController::TestSession.new
+    assert_equal({}, session.data)
+    assert_equal('', session.session_id)
+  end
+  
+  def test_ctor_allows_setting
+    session = ActionController::TestSession.new({:one => 'one', :two => 'two'})
+    assert_equal('one', session[:one])
+    assert_equal('two', session[:two])
+  end
+  
+  def test_setting_session_item_sets_item
+    session = ActionController::TestSession.new
+    session[:key] = 'value'
+    assert_equal('value', session[:key])
+  end
+  
+  def test_calling_delete_removes_item
+    session = ActionController::TestSession.new
+    session[:key] = 'value'
+    assert_equal('value', session[:key])
+    session.delete(:key)
+    assert_nil(session[:key])
+  end
+  
+  def test_calling_update_with_params_passes_to_attributes
+    session = ActionController::TestSession.new()
+    session.update('key' => 'value')
+    assert_equal('value', session[:key])
+  end
+  
+  def test_clear_emptys_session
+    params = {:one => 'one', :two => 'two'}
+    session = ActionController::TestSession.new({:one => 'one', :two => 'two'})
+    session.clear
+    assert_nil(session[:one])
+    assert_nil(session[:two])
+  end
+  
+end

data/test/controller/test_test.rb

@@ -1,7 +1,7 @@
 require 'abstract_unit'
 require 'controller/fake_controllers'
 
-class TestTest < Test::Unit::TestCase
+class TestTest < ActionController::TestCase
   class TestController < ActionController::Base
     def no_op
       render :text => 'dummy'
@@ -23,8 +23,13 @@ class TestTest < Test::Unit::TestCase
       render :text => 'Success'
     end
 
+    def reset_the_session
+      reset_session
+      render :text => 'ignore me'
+    end
+
     def render_raw_post
-      raise Test::Unit::AssertionFailedError, "#raw_post is blank" if request.raw_post.blank?
+      raise ActiveSupport::TestCase::Assertion, "#raw_post is blank" if request.raw_post.blank?
       render :text => request.raw_post
     end
 
@@ -171,6 +176,24 @@ XML
     assert_equal 'value2', session[:symbol]
   end
 
+  def test_session_is_cleared_from_controller_after_reset_session
+    process :set_session
+    process :reset_the_session
+    assert_equal Hash.new, @controller.session.to_hash
+  end
+
+  def test_session_is_cleared_from_response_after_reset_session
+    process :set_session
+    process :reset_the_session
+    assert_equal Hash.new, @response.session.to_hash
+  end
+
+  def test_session_is_cleared_from_request_after_reset_session
+    process :set_session
+    process :reset_the_session
+    assert_equal Hash.new, @request.session.to_hash
+  end
+
   def test_process_with_request_uri_with_no_params
     process :test_uri
     assert_equal "/test_test/test/test_uri", @response.body
@@ -580,7 +603,7 @@ XML
     assert_equal @response.redirect_url, redirect_to_url
 
     # Must be a :redirect response.
-    assert_raise(Test::Unit::AssertionFailedError) do
+    assert_raise(ActiveSupport::TestCase::Assertion) do
       assert_redirected_to 'created resource'
     end
   end
@@ -602,9 +625,9 @@ XML
     end
 end
 
-class CleanBacktraceTest < Test::Unit::TestCase
+class CleanBacktraceTest < ActionController::TestCase
   def test_should_reraise_the_same_object
-    exception = Test::Unit::AssertionFailedError.new('message')
+    exception = ActiveSupport::TestCase::Assertion.new('message')
     clean_backtrace { raise exception }
   rescue Exception => caught
     assert_equal exception.object_id, caught.object_id
@@ -613,7 +636,7 @@ class CleanBacktraceTest < Test::Unit::TestCase
 
   def test_should_clean_assertion_lines_from_backtrace
     path = File.expand_path("#{File.dirname(__FILE__)}/../../lib/action_controller")
-    exception = Test::Unit::AssertionFailedError.new('message')
+    exception = ActiveSupport::TestCase::Assertion.new('message')
     exception.set_backtrace ["#{path}/abc", "#{path}/assertions/def"]
     clean_backtrace { raise exception }
   rescue Exception => caught
@@ -629,21 +652,17 @@ class CleanBacktraceTest < Test::Unit::TestCase
   end
 end
 
-class InferringClassNameTest < Test::Unit::TestCase
+class InferringClassNameTest < ActionController::TestCase
   def test_determine_controller_class
     assert_equal ContentController, determine_class("ContentControllerTest")
   end
 
   def test_determine_controller_class_with_nonsense_name
-    assert_raises ActionController::NonInferrableControllerError do
-      determine_class("HelloGoodBye")
-    end
+    assert_nil determine_class("HelloGoodBye")
   end
 
   def test_determine_controller_class_with_sensible_name_where_no_controller_exists
-    assert_raises ActionController::NonInferrableControllerError do
-      determine_class("NoControllerWithThisNameTest")
-    end
+    assert_nil determine_class("NoControllerWithThisNameTest")
   end
 
   private

data/test/controller/url_rewriter_test.rb

@@ -2,7 +2,7 @@ require 'abstract_unit'
 
 ActionController::UrlRewriter
 
-class UrlRewriterTests < Test::Unit::TestCase
+class UrlRewriterTests < ActionController::TestCase
   def setup
     @request = ActionController::TestRequest.new
     @params = {}
@@ -85,8 +85,7 @@ class UrlRewriterTests < Test::Unit::TestCase
   end
 end
 
-class UrlWriterTests < Test::Unit::TestCase
-
+class UrlWriterTests < ActionController::TestCase
   class W
     include ActionController::UrlWriter
   end
@@ -100,7 +99,7 @@ class UrlWriterTests < Test::Unit::TestCase
   end
 
   def test_exception_is_thrown_without_host
-    assert_raises RuntimeError do
+    assert_raise RuntimeError do
       W.new.url_for :controller => 'c', :action => 'a', :id => 'i'
     end
   end
@@ -302,6 +301,57 @@ class UrlWriterTests < Test::Unit::TestCase
     assert_generates("/image", :controller=> :image)
   end
 
+  def test_named_routes_with_nil_keys
+    ActionController::Routing::Routes.clear!
+    ActionController::Routing::Routes.draw do |map|
+      map.main '', :controller => 'posts'
+      map.resources :posts
+      map.connect ':controller/:action/:id'
+    end
+    # We need to create a new class in order to install the new named route.
+    kls = Class.new { include ActionController::UrlWriter }
+    kls.default_url_options[:host] = 'www.basecamphq.com'
+
+    controller = kls.new
+    params = {:action => :index, :controller => :posts, :format => :xml}
+    assert_equal("http://www.basecamphq.com/posts.xml", controller.send(:url_for, params))    
+    params[:format] = nil
+    assert_equal("http://www.basecamphq.com/", controller.send(:url_for, params))    
+  ensure
+    ActionController::Routing::Routes.load!
+  end
+
+  def test_formatted_url_methods_are_deprecated
+    ActionController::Routing::Routes.draw do |map|
+      map.resources :posts
+    end
+    # We need to create a new class in order to install the new named route.
+    kls = Class.new { include ActionController::UrlWriter }
+    controller = kls.new
+    params = {:id => 1, :format => :xml}
+    assert_deprecated do
+      assert_equal("/posts/1.xml", controller.send(:formatted_post_path, params))    
+    end
+    assert_deprecated do
+      assert_equal("/posts/1.xml", controller.send(:formatted_post_path, 1, :xml))    
+    end
+  ensure
+    ActionController::Routing::Routes.load!
+  end
+
+  def test_multiple_includes_maintain_distinct_options
+    first_class = Class.new { include ActionController::UrlWriter }
+    second_class = Class.new { include ActionController::UrlWriter }
+
+    first_host, second_host = 'firsthost.com', 'secondhost.com'
+
+    first_class.default_url_options[:host] = first_host
+    second_class.default_url_options[:host] = second_host
+
+    assert_equal first_class.default_url_options[:host], first_host
+    assert_equal second_class.default_url_options[:host], second_host
+  end
+
   private
     def extract_params(url)
       url.split('?', 2).last.split('&')