actionpack 1.8.1 → 1.9.0

data/test/controller/multipart_progress_testx.rb

@@ -0,0 +1,365 @@
+require File.dirname(__FILE__) + '/../abstract_unit'
+require 'logger'
+require 'test/unit'
+require 'cgi'
+require 'stringio'
+
+DEBUG=false
+
+def test_logger
+  if DEBUG then ActionController::Base.logger = Logger.new(STDERR)
+  else ActionController::Base.logger = Logger.new(StringIO.new)
+  end
+end
+
+# 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
+  class EmptyController < ActionController::Base
+  end
+  class ApplicationController < ActionController::Base
+  end
+
+  class MockController < ActionController::Base
+    def initialize
+      super
+      @session = {:uploads => {}}
+      @params = {}
+    end
+  end
+  
+  class SingleUploadController < ActionController::Base
+    upload_status_for   :one
+    
+    def one; end
+  end
+
+  class DoubleUploadController < ActionController::Base
+    upload_status_for   :one, :two
+    
+    def one; end
+    def two; end
+  end
+  
+  class DoubleStatusUploadController < ActionController::Base
+    upload_status_for   :one, :two, :status => :custom_status
+    
+    def one; end
+    def two; end
+  end
+  
+  class DoubleSeperateController < ActionController::Base
+    upload_status_for :one
+    upload_status_for :two
+    
+    def one; end    
+    def two; end
+  end  
+  
+  class UploadController < ActionController::Base
+    upload_status_for   :norendered, :rendered, :redirected, :finish_param_dict, :finish_param_string, :finish_param_number
+    
+    def norendered 
+    end
+      
+    def rendered
+      render_text("rendered")
+    end
+    
+    def redirected
+      redirect_to "/redirected/"
+    end
+    
+    def finish_param_dict
+      finish_upload_status "{a: 'b'}"
+    end
+
+    def finish_param_string
+      finish_upload_status "'a string'"
+    end
+
+    def finish_param_number
+      finish_upload_status 123
+    end
+
+    def finish_param_number_redirect
+      redirect_to "/redirected/"
+      finish_upload_status 123
+    end
+  end
+end
+
+class MockIO < StringIO
+  def initialize(data='', &block)
+    test_logger.debug("MockIO inializing data: #{data[0..20]}")
+
+    @block = block
+    super(data)
+  end
+
+  def write(data)
+    test_logger.debug("MockIO write #{data.size} data: #{data[0..20]}")
+    super
+  end
+  def read(size)
+    test_logger.debug("MockIO getting data from super")
+    data = super
+
+    test_logger.debug("Calling read callback")
+    @block.call 
+
+    test_logger.debug("Returning data: #{data.size}")
+    data
+  end
+end
+
+class MockCGI < CGI
+  BOUNDARY = '----------0xKhTmLbOuNdArY'
+  FILENAME = 'dummy.nul'
+
+  attr_reader :upload_id, :session_options, :session_id
+
+  def initialize(size=1000, url='/test', &block)
+    @url = url
+    @env = {}
+    @sio = MockIO.new('') { block.call(self) if block_given? }
+
+    @upload_id = '1'
+
+    add_param('param1', 'value1')
+    add_data(size)
+    add_param('param1', 'value2')
+    add_end_boundary
+    init_env
+    @sio.rewind
+    super()
+  end
+
+  #def stdinput_without_progress
+  #  @sio
+  #end
+
+  def stdinput
+    @sio
+  end
+  
+  def env_table
+    @env
+  end
+
+  private
+  def init_env
+    @env['HTTP_HOST'] = 'localhost'
+    @env['SERVER_PORT'] = '80'
+    @env['REQUEST_METHOD'] = "POST"
+    @env['QUERY_STRING'] = @url.split('?')[1] || "upload_id=#{upload_id}&query_param=query_value"
+    @env['REQUEST_URI'] = @url
+    @env['SCRIPT_NAME'] = @url.split('?').first.split('/').last
+    @env['PATH_INFO'] = @url.split('?').first
+    @env['CONTENT_TYPE'] = "multipart/form-data; boundary=#{BOUNDARY}"
+    @env['CONTENT_LENGTH'] = @sio.tell - EOL.size
+
+    @session_options = ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS.inject({}) { |options, pair| 
+      options[pair.first.to_s] = pair.last; options 
+    }
+    session = CGI::Session.new({}, @session_options.merge({'new_session' => true}))
+    @session_id = session.session_id
+    @env['COOKIE'] = "_session_id=#{session.session_id}"
+    session.close
+  end
+
+  def add_param(name, value)
+    add_boundary
+    @sio << "Content-Disposition: form-data; name=\"#{name}\"" << EOL << EOL
+    @sio << value.to_s << EOL
+  end
+
+  def add_data(size)
+    add_boundary
+    @sio << "Content-Disposition: form-data; name=\"file\"; filename=\"#{FILENAME}\"" << EOL
+    @sio << "Content-Type: application/octet-stream" << EOL << EOL
+    @sio << "." * size
+    @sio << EOL
+  end
+
+  def add_boundary
+    @sio << "--" << BOUNDARY << EOL
+  end
+
+  def add_end_boundary
+    @sio << "--" << BOUNDARY << "--" << EOL
+  end
+end
+
+class MultipartProgressTest < Test::Unit::TestCase
+  
+  def test_domain_language_single
+    c = Controllers::SingleUploadController.new
+    assert_respond_to(c, :one)
+    assert_respond_to(c, :upload_status)
+    assert_respond_to(c, :finish_upload_status)
+  end
+  
+  def test_domain_language_double
+    c = Controllers::DoubleUploadController.new
+    assert_respond_to(c, :one)
+    assert_respond_to(c, :two)
+    assert_respond_to(c, :upload_status)
+    assert_respond_to(c, :finish_upload_status)
+  end
+    
+  def test_domain_language_double_status
+    c = Controllers::DoubleStatusUploadController.new
+    assert_respond_to(c, :one)
+    assert_respond_to(c, :two)
+    assert_respond_to(c, :custom_status)
+    assert_respond_to(c, :finish_upload_status)
+  end
+    
+  def test_domain_language_double_seperate
+    c = Controllers::DoubleSeperateController.new
+    assert_respond_to(c, :one)
+    assert_respond_to(c, :two)
+    assert_respond_to(c, :upload_status)
+    assert_respond_to(c, :finish_upload_status)
+  end
+
+  def test_finish_status_norendered
+    # Fails to render the upload finish script because there is no view associated with this action
+    test_logger.debug('test_finish_status_norendered')
+
+    res = process(:action => 'norendered', :upload_id => 1)
+    assert_match(/ActionView::ActionViewError/s, res.body)
+    
+    res = process(:action => :upload_status, :upload_id => 1)
+    assert_match(/Upload finished/s, res.body)
+
+    res = process(:action => :norendered)
+    assert_match(/ActionView::ActionViewError/s, res.body)
+  end
+
+  def test_finish_status_rendered
+    test_logger.debug('test_finish_status_rendered')
+
+    res = process(:action => :rendered, :upload_id => 1)
+    assert_match(/stop\(\)/s, res.body)
+    assert_no_match(/rendered/s, res.body)
+    
+    res = process(:action => :upload_status, :upload_id => 1)
+    assert_match(/Upload finished/s, res.body)
+    
+    res = process(:action => :rendered)
+    assert_no_match(/stop\(\)/s, res.body)
+    assert_match(/rendered/, res.body)
+  end 
+  
+  def test_finish_status_redirected
+    test_logger.debug('test_finish_status_redirected')
+
+    res = process(:action => :redirected, :upload_id => 1)
+    assert_match(/location\.replace/s, res.body)
+    
+    res = process(:action => :redirected)
+    assert_no_match(/location\.replace/s, res.body)
+    assert_match(/\/redirected\//s, res.headers['location'])
+    assert_match(/302 .*$/, res.headers['Status'])
+
+    res = process(:action => :upload_status, :upload_id => 1)
+    assert_match(/Upload finished/s, res.body)
+  end
+  
+  def test_finish_status_finish_param
+    test_logger.debug('test_finish_status_param')
+
+    res = process(:action => :finish_param_string, :upload_id => 1)
+    assert_match(/stop\('a string'\)/s, res.body)
+    assert_no_redirect res
+
+    res = process(:action => :finish_param_dict, :upload_id => 1)
+    assert_match(/stop\(\{a: 'b'\}\)/s, res.body)
+    assert_no_redirect res
+
+    res = process(:action => :finish_param_number, :upload_id => 1)
+    assert_match(/stop\(123\)/s, res.body)
+    assert_no_redirect res
+
+    res = process(:action => :finish_param_number_redirect, :upload_id => 1)
+    test_logger.debug('test_finish_status_param: ' + res.body)
+    assert_match(/stop\(123\)/s, res.body)
+    assert_match(/replace\('\http:\/\/localhost\/redirected\/'\).*?/s, res.body)
+    assert_no_redirect res
+  end
+  
+  def test_basic_setup
+    test_logger.debug('test_basic_setup')
+
+    cgi, request, response = new_request(100000)
+    assert_not_nil(request.session)
+    assert_not_nil(request.session[:uploads], "uploads collection not set")
+    assert_not_nil(request.session[:uploads][cgi.upload_id], "upload id not set")
+    progress = request.session[:uploads][cgi.upload_id]
+    assert_equal(true, progress.finished?)
+  end
+
+  def test_params
+    test_logger.debug('test_params')
+
+    cgi, request, response = new_request(1000)
+    assert(!request.params.empty?)
+    assert(!request.params['param1'].empty?)
+  end
+
+  def test_share_session
+    cgi, request, response = new_request(100000) do |cgi, req|
+      if cgi.stdinput.tell > 50000
+        # force a save
+        cgi.stdinput.save_progress rescue flunk('Something else is wrong, our wrapper isnt setup, is ActionController::Base.logger set?')
+
+        other_session = CGI::Session.new(cgi, cgi.session_options.merge({'session_id' => cgi.session_id}))
+        assert_not_nil(other_session[:uploads])
+        assert_not_nil(other_session[:uploads][cgi.upload_id])
+        assert_in_delta(cgi.stdinput.session[:uploads][cgi.upload_id].bitrate, other_session[:uploads][cgi.upload_id].bitrate, 1000.0, "Seperate session does not share data from original session")
+
+        other_session.close
+      end
+    end
+  end
+
+  def test_upload_ids
+    c = Controllers::MockController.new
+    (1..222).each do |id|
+      c.params = {}
+
+      assert_equal((id-1).to_s, c.last_upload_id, "last_upload_id is out of sync")
+      assert_equal(id.to_s, c.next_upload_id, "next_upload_id is out of sync")
+      assert_equal(id.to_s, c.current_upload_id, "current_upload_id is out of sync")
+
+      c.params = {:upload_id => (id-1).to_s}
+      assert_equal((id-1).to_s, c.current_upload_id, "current_upload_id is out of sync")
+
+      c.session[:uploads][id] = {}
+    end
+  end
+
+  private
+  def new_request(size=1000, url='/test', &block)
+    test_logger.debug('Creating MockCGI')
+    cgi = MockCGI.new(size, url) do |cgi|
+      block.call(cgi) if block_given?
+    end
+
+    assert(cgi.private_methods.include?("read_multipart_with_progress")) 
+    return [cgi, ActionController::CgiRequest.new(cgi), ActionController::CgiResponse.new(cgi)]
+  end
+
+  def process(options = {})
+    Controllers::UploadController.process(*(new_request(1000, '/upload?' + options.map {|k,v| "#{k}=#{v}"}.join('&'))[1..2]))
+  end
+
+  def assert_no_redirect(res)
+    assert_nil(res.redirected_to)
+    assert_nil(res.headers['location'])
+    assert_match(/200 .*$/, res.headers['Status'])
+  end
+
+end

data/test/controller/new_render_test.rb

@@ -0,0 +1,263 @@
+require File.dirname(__FILE__) + '/../abstract_unit'
+
+silence_warnings { Customer = Struct.new("Customer", :name) }
+
+module Fun
+  class GamesController < ActionController::Base
+    def hello_world
+    end
+  end
+end
+
+class NewRenderTestController < ActionController::Base
+  layout :determine_layout
+
+  def self.controller_name; "test"; end
+  def self.controller_path; "test"; end
+
+  def hello_world
+  end
+
+  def render_hello_world
+    render :template => "test/hello_world"
+  end
+
+  def render_hello_world_from_variable
+    @person = "david"
+    render :text => "hello #{@person}"
+  end
+
+  def render_action_hello_world
+    render :action => "hello_world"
+  end
+  
+  def render_text_hello_world
+    render :text => "hello world"
+  end
+
+  def render_custom_code
+    render :text => "hello world", :status => "404 Moved"
+  end
+  
+  def render_xml_hello
+    @name = "David"
+    render :template => "test/hello"
+  end
+
+  def greeting
+    # let's just rely on the template
+  end
+
+  def layout_test
+    render :action => "hello_world"
+  end
+
+  def layout_test_with_different_layout
+    render :action => "hello_world", :layout => "standard"
+  end
+  
+  def rendering_without_layout
+    render :action => "hello_world", :layout => false
+  end
+  
+  def rendering_nothing_on_layout
+    render :nothing => true
+  end
+  
+  def builder_layout_test
+    render :action => "hello"
+  end
+
+  def partials_list
+    @test_unchanged = 'hello'
+    @customers = [ Customer.new("david"), Customer.new("mary") ]
+    render :action => "list"
+  end
+
+  def partial_only
+    render :partial => true
+  end
+
+  def partial_only_with_layout
+    render :partial => "partial_only", :layout => true
+  end
+
+  def hello_in_a_string
+    @customers = [ Customer.new("david"), Customer.new("mary") ]
+    render :text =>  "How's there? #{render_to_string("test/list")}"
+  end
+  
+  def accessing_params_in_template
+    render :inline =>  "Hello: <%= params[:name] %>"
+  end
+
+  def accessing_params_in_template_with_layout
+    render :inline =>  "Hello: <%= params[:name] %>", :layout => nil
+  end
+
+  def render_with_explicit_template
+    render "test/hello_world"
+  end
+
+  def rescue_action(e) raise end
+    
+  private
+    def determine_layout
+      case action_name 
+        when "hello_world", "layout_test", "rendering_without_layout",
+             "rendering_nothing_on_layout", "render_text_hello_world",
+             "partial_only", "partial_only_with_layout",
+             "accessing_params_in_template",
+             "accessing_params_in_template_with_layout",
+             "render_with_explicit_template"
+          "layouts/standard"
+        when "builder_layout_test"
+          "layouts/builder"
+      end
+    end
+end
+
+NewRenderTestController.template_root = File.dirname(__FILE__) + "/../fixtures/"
+Fun::GamesController.template_root = File.dirname(__FILE__) + "/../fixtures/"
+
+class NewRenderTest < Test::Unit::TestCase
+  def setup
+    @controller = NewRenderTestController.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_show
+    get :hello_world
+    assert_response :success
+    assert_template "test/hello_world"
+    assert_equal "<html>Hello world!</html>", @response.body
+  end
+
+  def test_do_with_render
+    get :render_hello_world
+    assert_template "test/hello_world"
+  end
+
+  def test_do_with_render_from_variable
+    get :render_hello_world_from_variable
+    assert_equal "hello david", @response.body
+  end
+
+  def test_do_with_render_action
+    get :render_action_hello_world
+    assert_template "test/hello_world"
+  end
+
+  def test_do_with_render_text
+    get :render_text_hello_world
+    assert_equal "hello world", @response.body
+  end
+
+  def test_do_with_render_custom_code
+    get :render_custom_code
+    assert_response :missing
+  end
+
+  def test_attempt_to_access_object_method
+    assert_raises(ActionController::UnknownAction, "No action responded to [clone]") { get :clone }
+  end
+
+  def test_private_methods
+    assert_raises(ActionController::UnknownAction, "No action responded to [determine_layout]") { get :determine_layout }
+  end
+
+  def test_access_to_request_in_view
+    ActionController::Base.view_controller_internals = false
+
+    get :hello_world
+    assert_nil(assigns["request"])
+
+    ActionController::Base.view_controller_internals = true
+
+    get :hello_world
+    assert_kind_of ActionController::AbstractRequest, assigns["request"]
+  end
+  
+  def test_render_xml
+    get :render_xml_hello
+    assert_equal "<html>\n  <p>Hello David</p>\n<p>This is grand!</p>\n</html>\n", @response.body
+  end
+
+  def test_render_xml_with_default
+    get :greeting
+    assert_equal "<p>This is grand!</p>\n", @response.body
+  end
+
+  def test_layout_rendering
+    get :layout_test
+    assert_equal "<html>Hello world!</html>", @response.body
+  end
+
+  def test_layout_test_with_different_layout
+    get :layout_test_with_different_layout
+    assert_equal "<html>Hello world!</html>", @response.body
+  end
+
+  def test_rendering_without_layout
+    get :rendering_without_layout
+    assert_equal "Hello world!", @response.body
+  end
+
+  def test_rendering_nothing_on_layout
+    get :rendering_nothing_on_layout
+    assert_equal "", @response.body
+  end
+
+  def test_render_xml_with_layouts
+    get :builder_layout_test
+    assert_equal "<wrapper>\n<html>\n  <p>Hello </p>\n<p>This is grand!</p>\n</html>\n</wrapper>\n", @response.body
+  end
+
+  # def test_partials_list
+  #   get :partials_list
+  #   assert_equal "goodbyeHello: davidHello: marygoodbye\n", @response.body
+  # end
+
+  def test_partial_only
+    get :partial_only
+    assert_equal "only partial", @response.body
+  end
+
+  def test_partial_only_with_layout
+    get :partial_only_with_layout
+    assert_equal "<html>only partial</html>", @response.body
+  end
+
+  def test_render_to_string
+    get :hello_in_a_string
+    assert_equal "How's there? goodbyeHello: davidHello: marygoodbye\n", @response.body
+  end
+
+  def test_nested_rendering
+    get :hello_world
+    assert_equal "Living in a nested world", Fun::GamesController.process(@request, @response).body
+  end
+
+  def test_accessing_params_in_template
+    get :accessing_params_in_template, :name => "David"
+    assert_equal "Hello: David", @response.body
+  end
+
+  def test_accessing_params_in_template_with_layout
+    get :accessing_params_in_template_with_layout, :name => "David"
+    assert_equal "<html>Hello: David</html>", @response.body
+  end
+
+  def test_render_with_explicit_template
+    get :render_with_explicit_template
+    assert_response :success
+  end
+end