actionpack 2.2.3 → 2.3.2

data/test/controller/http_authentication_test.rb

@@ -1,54 +0,0 @@
-require 'abstract_unit'
-
-class HttpBasicAuthenticationTest < Test::Unit::TestCase
-  include ActionController::HttpAuthentication::Basic
-  
-  class DummyController
-    attr_accessor :headers, :renders, :request
-    
-    def initialize
-      @headers, @renders = {}, []
-      @request = ActionController::TestRequest.new
-    end
-    
-    def render(options)
-      self.renders << options
-    end
-  end
-
-  def setup
-    @controller  = DummyController.new
-    @credentials = ActionController::HttpAuthentication::Basic.encode_credentials("dhh", "secret")
-  end
-
-  def test_successful_authentication
-    login = Proc.new { |user_name, password| user_name == "dhh" && password == "secret" }
-    set_headers
-    assert authenticate(@controller, &login)
-
-    set_headers ''
-    assert_nothing_raised do
-      assert !authenticate(@controller, &login)
-    end
-
-    set_headers nil
-    set_headers @credentials, 'REDIRECT_X_HTTP_AUTHORIZATION'
-    assert authenticate(@controller, &login)
-  end
-
-  def test_failing_authentication
-    set_headers
-    assert !authenticate(@controller) { |user_name, password| user_name == "dhh" && password == "incorrect" }
-  end
-  
-  def test_authentication_request
-    authentication_request(@controller, "Megaglobalapp")
-    assert_equal 'Basic realm="Megaglobalapp"', @controller.headers["WWW-Authenticate"]
-    assert_equal :unauthorized, @controller.renders.first[:status]
-  end
-
-  private
-    def set_headers(value = @credentials, name = 'HTTP_AUTHORIZATION')
-      @controller.request.env[name] = value
-    end
-end

data/test/controller/integration_upload_test.rb

@@ -1,43 +0,0 @@
-require 'abstract_unit'
-require 'action_controller/integration'
-require 'action_controller/routing'
-
-unless defined? ApplicationController
-  class ApplicationController < ActionController::Base
-  end
-end
-
-class UploadTestController < ActionController::Base
-  session :off
-
-  def update
-    SessionUploadTest.last_request_type = ActionController::Base.param_parsers[request.content_type]
-    render :text => "got here"
-  end
-end
-
-class SessionUploadTest < ActionController::IntegrationTest
-  FILES_DIR = File.dirname(__FILE__) + '/../fixtures/multipart'
-
-  class << self
-    attr_accessor :last_request_type
-  end
-
-  # def setup
-  #   @session = ActionController::Integration::Session.new
-  # end
-  def test_post_with_upload
-    uses_mocha "test_post_with_upload" do
-      ActiveSupport::Dependencies.stubs(:load?).returns(false)
-      with_routing do |set|
-        set.draw do |map|
-          map.update 'update', :controller => "upload_test", :action => "update", :method => :post
-        end
-
-        params = { :uploaded_data => fixture_file_upload(FILES_DIR + "/mona_lisa.jpg", "image/jpg") }
-        post '/update', params, :location => 'blah'
-        assert_equal(:multipart_form, SessionUploadTest.last_request_type)
-      end
-    end
-   end
-end

data/test/controller/session_fixation_test.rb

@@ -1,89 +0,0 @@
-require 'abstract_unit'
-
-
-class SessionFixationTest < Test::Unit::TestCase
-  class MockCGI < CGI #:nodoc:
-    attr_accessor :stdoutput, :env_table
-
-    def initialize(env, data = '')
-      self.env_table = env
-      self.stdoutput = StringIO.new
-      super(nil, StringIO.new(data))
-    end
-  end
-
-  class TestController < ActionController::Base
-    session :session_key => '_myapp_session_id', :secret => CGI::Session.generate_unique_id, :except => :default_session_key
-    session :cookie_only => false, :only => :allow_session_fixation
-
-    def default_session_key
-      render :text => "default_session_key"
-    end
-
-    def custom_session_key
-      render :text => "custom_session_key: #{params[:id]}"
-    end
-
-    def allow_session_fixation
-      render :text => "allow_session_fixation"
-    end
-
-    def rescue_action(e) raise end
-  end
-
-  def setup
-    @controller = TestController.new
-  end
-
-  def test_should_be_able_to_make_a_successful_request
-    cgi = mock_cgi_for_request_to(:custom_session_key, :id => 1)
-
-    assert_nothing_raised do
-      @controller.send(:process, ActionController::CgiRequest.new(cgi, {}), ActionController::CgiResponse.new(cgi))
-    end
-    assert_equal 'custom_session_key: 1', @controller.response.body
-    assert_not_nil @controller.session
-  end
-
-  def test_should_catch_session_fixation_attempt
-    cgi = mock_cgi_for_request_to(:custom_session_key, :_myapp_session_id => 42)
-
-    assert_raises ActionController::CgiRequest::SessionFixationAttempt do
-      @controller.send(:process, ActionController::CgiRequest.new(cgi, {}), ActionController::CgiResponse.new(cgi))
-    end
-    assert_nil @controller.session
-  end
-
-  def test_should_not_catch_session_fixation_attempt_when_cookie_only_setting_is_disabled
-    cgi = mock_cgi_for_request_to(:allow_session_fixation, :_myapp_session_id => 42)
-
-    assert_nothing_raised do
-      @controller.send(:process, ActionController::CgiRequest.new(cgi, {}), ActionController::CgiResponse.new(cgi))
-    end
-    assert ! @controller.response.body.blank?
-    assert_not_nil @controller.session
-  end
-
-  def test_should_catch_session_fixation_attempt_with_default_session_key
-    ActionController::Base.session_store = :p_store # using the default session_key is not possible with cookie store
-    cgi = mock_cgi_for_request_to(:default_session_key, :_session_id => 42)
-
-    assert_raises ActionController::CgiRequest::SessionFixationAttempt do
-      @controller.send(:process, ActionController::CgiRequest.new(cgi, {}), ActionController::CgiResponse.new(cgi))
-    end
-    assert @controller.response.body.blank?
-    assert_nil @controller.session
-  end
-
-private
-
-  def mock_cgi_for_request_to(action, params = {})
-    MockCGI.new({
-      "REQUEST_METHOD" => "GET",
-      "QUERY_STRING"   => "action=#{action}&#{params.to_query}",
-      "REQUEST_URI"    => "/",
-      "SERVER_PORT"    => "80",
-      "HTTP_HOST"      => "testdomain.com" }, '')
-  end
-
-end

data/test/controller/session_management_test.rb

@@ -1,178 +0,0 @@
-require 'abstract_unit'
-
-class SessionManagementTest < Test::Unit::TestCase
-  class SessionOffController < ActionController::Base
-    session :off
-
-    def show
-      render :text => "done"
-    end
-
-    def tell
-      render :text => "done"
-    end
-  end
-
-  class SessionOffOnController < ActionController::Base
-    session :off
-    session :on, :only => :tell
-
-    def show
-      render :text => "done"
-    end
-
-    def tell
-      render :text => "done"
-    end
-  end
-
-  class TestController < ActionController::Base
-    session :off, :only => :show
-    session :session_secure => true, :except => :show
-    session :off, :only => :conditional,
-            :if => Proc.new { |r| r.parameters[:ws] }
-
-    def show
-      render :text => "done"
-    end
-
-    def tell
-      render :text => "done"
-    end
-
-    def conditional
-      render :text => ">>>#{params[:ws]}<<<"
-    end
-  end
-
-  class SpecializedController < SessionOffController
-    session :disabled => false, :only => :something
-
-    def something
-      render :text => "done"
-    end
-
-    def another
-      render :text => "done"
-    end
-  end
-
-  class AssociationCachingTestController < ActionController::Base
-    class ObjectWithAssociationCache
-      def initialize
-        @cached_associations = false
-      end
-
-      def fetch_associations
-        @cached_associations = true
-      end
-
-      def clear_association_cache
-        @cached_associations = false
-      end
-
-      def has_cached_associations?
-        @cached_associations
-      end
-    end
-
-    def show
-      session[:object] = ObjectWithAssociationCache.new
-      session[:object].fetch_associations
-      if session[:object].has_cached_associations?
-        render :text => "has cached associations"
-      else
-        render :text => "does not have cached associations"
-      end
-    end
-
-    def tell
-      if session[:object]
-        if session[:object].has_cached_associations?
-          render :text => "has cached associations"
-        else
-          render :text => "does not have cached associations"
-        end
-      else
-        render :text => "there is no object"
-      end
-    end
-  end
-
-
-  def setup
-    @request, @response = ActionController::TestRequest.new,
-      ActionController::TestResponse.new
-  end
-
-  def test_session_off_globally
-    @controller = SessionOffController.new
-    get :show
-    assert_equal false, @request.session_options
-    get :tell
-    assert_equal false, @request.session_options
-  end
-
-  def test_session_off_then_on_globally
-    @controller = SessionOffOnController.new
-    get :show
-    assert_equal false, @request.session_options
-    get :tell
-    assert_instance_of Hash, @request.session_options
-    assert_equal false, @request.session_options[:disabled]
-  end
-  
-  def test_session_off_conditionally
-    @controller = TestController.new
-    get :show
-    assert_equal false, @request.session_options
-    get :tell
-    assert_instance_of Hash, @request.session_options
-    assert @request.session_options[:session_secure]
-  end
-
-  def test_controller_specialization_overrides_settings
-    @controller = SpecializedController.new
-    get :something
-    assert_instance_of Hash, @request.session_options
-    get :another
-    assert_equal false, @request.session_options
-  end
-
-  def test_session_off_with_if
-    @controller = TestController.new
-    get :conditional
-    assert_instance_of Hash, @request.session_options
-    get :conditional, :ws => "ws"
-    assert_equal false, @request.session_options
-  end
-  
-  def test_session_store_setting
-    ActionController::Base.session_store = :drb_store
-    assert_equal CGI::Session::DRbStore, ActionController::Base.session_store
-
-    if Object.const_defined?(:ActiveRecord)
-      ActionController::Base.session_store = :active_record_store
-      assert_equal CGI::Session::ActiveRecordStore, ActionController::Base.session_store
-    end
-  end
-  
-  def test_process_cleanup_with_session_management_support
-    @controller = AssociationCachingTestController.new
-    get :show
-    assert_equal "has cached associations", @response.body
-    get :tell
-    assert_equal "does not have cached associations", @response.body
-  end
-  
-  def test_session_is_enabled
-    @controller = TestController.new
-    get :show
-    assert_nothing_raised do
-      assert_equal false, @controller.session_enabled?
-    end
-    
-    get :tell
-    assert @controller.session_enabled?
-  end
-end

data/test/fixtures/test/hello_world.js

@@ -1 +0,0 @@
-var greeting = 'Hallo World!';