backlog 0.9.1 → 0.10.0

data/vendor/rails/actionpack/test/controller/raw_post_test.rb

@@ -1,74 +0,0 @@
-require "#{File.dirname(__FILE__)}/../abstract_unit"
-
-class RawPostDataTest < Test::Unit::TestCase
-  def setup
-    ENV.delete('RAW_POST_DATA')
-    @request_body = 'a=1'
-  end
-
-  def test_post_with_urlencoded_body
-    ENV['REQUEST_METHOD'] = 'POST'
-    ENV['CONTENT_TYPE'] = ' apPlication/x-Www-form-urlEncoded; charset=utf-8'
-    assert_equal ['1'], cgi.params['a']
-    assert_raw_post_data
-  end
-
-  def test_post_with_empty_content_type_treated_as_urlencoded
-    ENV['REQUEST_METHOD'] = 'POST'
-    ENV['CONTENT_TYPE'] = ''
-    assert_equal ['1'], cgi.params['a']
-    assert_raw_post_data
-  end
-
-  def test_post_with_unrecognized_content_type_ignores_body
-    ENV['REQUEST_METHOD'] = 'POST'
-    ENV['CONTENT_TYPE'] = 'foo/bar'
-    assert cgi.params.empty?
-    assert_no_raw_post_data
-  end
-
-  def test_put_with_urlencoded_body
-    ENV['REQUEST_METHOD'] = 'PUT'
-    ENV['CONTENT_TYPE'] = 'application/x-www-form-urlencoded'
-    assert_equal ['1'], cgi.params['a']
-    assert_raw_post_data
-  end
-
-  def test_put_with_empty_content_type_ignores_body
-    ENV['REQUEST_METHOD'] = 'PUT'
-    ENV['CONTENT_TYPE'] = ''
-    assert cgi.params.empty?
-    assert_no_raw_post_data
-  end
-
-  def test_put_with_unrecognized_content_type_ignores_body
-    ENV['REQUEST_METHOD'] = 'PUT'
-    ENV['CONTENT_TYPE'] = 'foo/bar'
-    assert cgi.params.empty?
-    assert_no_raw_post_data
-  end
-
-  private
-    def cgi
-      unless defined? @cgi
-        ENV['CONTENT_LENGTH'] = @request_body.size.to_s
-        @cgi = CGI.new('query', StringIO.new(@request_body.dup))
-      end
-
-      @cgi
-    end
-
-    def assert_raw_post_data
-      assert_not_nil ENV['RAW_POST_DATA']
-      assert ENV['RAW_POST_DATA'].frozen?
-      assert_equal @request_body, ENV['RAW_POST_DATA']
-
-      assert_equal '', cgi.stdinput.read
-    end
-
-    def assert_no_raw_post_data
-      assert_nil ENV['RAW_POST_DATA']
-
-      assert_equal @request_body, cgi.stdinput.read
-    end
-end

data/vendor/rails/actionpack/test/controller/record_identifier_test.rb

@@ -1,103 +0,0 @@
-require File.dirname(__FILE__) + '/../abstract_unit'
-
-class Comment
-  attr_reader :id
-  def save; @id = 1 end
-  def new_record?; @id.nil? end
-  def name
-    @id.nil? ? 'new comment' : "comment ##{@id}"
-  end
-end
-
-class Comment::Nested < Comment; end
-
-class Test::Unit::TestCase
-  protected
-    def comments_url
-      'http://www.example.com/comments'
-    end
-    
-    def comment_url(comment)
-      "http://www.example.com/comments/#{comment.id}"
-    end
-end
-
-
-class RecordIdentifierTest < Test::Unit::TestCase
-  include ActionController::RecordIdentifier
-
-  def setup
-    @klass  = Comment
-    @record = @klass.new
-    @singular = 'comment'
-    @plural = 'comments'
-  end
-
-  def test_dom_id_with_new_record
-    assert_equal "new_#{@singular}", dom_id(@record)
-  end
-
-  def test_dom_id_with_new_record_and_prefix
-    assert_equal "custom_prefix_#{@singular}", dom_id(@record, :custom_prefix)
-  end
-
-  def test_dom_id_with_saved_record
-    @record.save
-    assert_equal "#{@singular}_1", dom_id(@record)
-  end
-
-  def test_dom_id_with_prefix
-    @record.save
-    assert_equal "edit_#{@singular}_1", dom_id(@record, :edit)
-  end
-
-  def test_partial_path
-    expected = "#{@plural}/#{@singular}"
-    assert_equal expected, partial_path(@record)
-    assert_equal expected, partial_path(Comment)
-  end
-
-  def test_dom_class
-    assert_equal @singular, dom_class(@record)
-  end
-  
-  def test_dom_class_with_prefix
-    assert_equal "custom_prefix_#{@singular}", dom_class(@record, :custom_prefix)
-  end
-
-  def test_singular_class_name
-    assert_equal @singular, singular_class_name(@record)
-  end
-
-  def test_singular_class_name_for_class
-    assert_equal @singular, singular_class_name(@klass)
-  end
-
-  def test_plural_class_name
-    assert_equal @plural, plural_class_name(@record)
-  end
-
-  def test_plural_class_name_for_class
-    assert_equal @plural, plural_class_name(@klass)
-  end
-
-  private
-    def method_missing(method, *args)
-      RecordIdentifier.send(method, *args)
-    end
-end
-
-class NestedRecordIdentifierTest < RecordIdentifierTest
-  def setup
-    @klass  = Comment::Nested
-    @record = @klass.new
-    @singular = 'comment_nested'
-    @plural = 'comment_nesteds'
-  end
-
-  def test_partial_path
-    expected = "comment/nesteds/nested"
-    assert_equal expected, partial_path(@record)
-    assert_equal expected, partial_path(Comment::Nested)
-  end
-end

data/vendor/rails/actionpack/test/controller/redirect_test.rb

@@ -1,180 +0,0 @@
-require File.dirname(__FILE__) + '/../abstract_unit'
-
-class WorkshopsController < ActionController::Base
-end
-
-class Workshop
-  attr_accessor :id, :new_record
-
-  def initialize(id, new_record)
-    @id, @new_record = id, new_record
-  end
-  
-  def new_record?
-    @new_record
-  end
-  
-  def to_s
-    id.to_s
-  end
-end
-
-class RedirectController < ActionController::Base
-  def simple_redirect
-    redirect_to :action => "hello_world"
-  end
-
-  def host_redirect
-    redirect_to :action => "other_host", :only_path => false, :host => 'other.test.host'
-  end
-
-  def module_redirect
-    redirect_to :controller => 'module_test/module_redirect', :action => "hello_world"
-  end
-
-  def redirect_with_assigns
-    @hello = "world"
-    redirect_to :action => "hello_world"
-  end
-
-  def redirect_to_back
-    redirect_to :back
-  end
-
-  def redirect_to_existing_record
-    redirect_to Workshop.new(5, false)
-  end
-
-  def redirect_to_new_record
-    redirect_to Workshop.new(5, true)
-  end
-
-  def rescue_errors(e) raise e end
-    
-  def rescue_action(e) raise end
-  
-  protected
-    def dashbord_url(id, message)
-      url_for :action => "dashboard", :params => { "id" => id, "message" => message }
-    end
-end
-
-class RedirectTest < Test::Unit::TestCase
-  def setup
-    @controller = RedirectController.new
-    @request    = ActionController::TestRequest.new
-    @response   = ActionController::TestResponse.new
-  end
-
-  def test_simple_redirect
-    get :simple_redirect
-    assert_response :redirect
-    assert_equal "http://test.host/redirect/hello_world", redirect_to_url
-  end
-
-  def test_simple_redirect_using_options
-    get :host_redirect
-    assert_response :redirect
-    assert_redirected_to :action => "other_host", :only_path => false, :host => 'other.test.host'
-  end
-
-  def test_redirect_error_with_pretty_diff
-    get :host_redirect
-    assert_response :redirect
-    begin
-      assert_redirected_to :action => "other_host", :only_path => true
-    rescue Test::Unit::AssertionFailedError => err
-      redirection_msg, diff_msg = err.message.scan(/<\{[^\}]+\}>/).collect { |s| s[2..-3] }
-      assert_match %r("only_path"=>false),        redirection_msg
-      assert_match %r("host"=>"other.test.host"), redirection_msg
-      assert_match %r("action"=>"other_host"),    redirection_msg
-      assert_match %r("only_path"=>true),         diff_msg
-      assert_match %r("host"=>"other.test.host"), diff_msg
-    end
-  end
-
-  def test_module_redirect
-    get :module_redirect
-    assert_response :redirect
-    assert_redirected_to "http://test.host/module_test/module_redirect/hello_world"
-  end
-
-  def test_module_redirect_using_options
-    get :module_redirect
-    assert_response :redirect
-    assert_redirected_to :controller => 'module_test/module_redirect', :action => 'hello_world'
-  end
-
-  def test_redirect_with_assigns
-    get :redirect_with_assigns
-    assert_response :redirect
-    assert_equal "world", assigns["hello"]
-  end
-
-  def test_redirect_to_back
-    @request.env["HTTP_REFERER"] = "http://www.example.com/coming/from"
-    get :redirect_to_back
-    assert_response :redirect
-    assert_equal "http://www.example.com/coming/from", redirect_to_url
-  end
-  
-  def test_redirect_to_back_with_no_referer
-    assert_raises(ActionController::RedirectBackError) {
-      @request.env["HTTP_REFERER"] = nil
-      get :redirect_to_back
-    }
-  end
-  
-  def test_redirect_to_record
-    ActionController::Routing::Routes.draw do |map|
-      map.resources :workshops
-      map.connect ':controller/:action/:id'
-    end
-    
-    get :redirect_to_existing_record
-    assert_equal "http://test.host/workshops/5", redirect_to_url
-
-    get :redirect_to_new_record
-    assert_equal "http://test.host/workshops", redirect_to_url
-  end
-end
-
-module ModuleTest
-  class ModuleRedirectController < ::RedirectController
-    def module_redirect
-      redirect_to :controller => '/redirect', :action => "hello_world"
-    end
-  end
-
-  class ModuleRedirectTest < Test::Unit::TestCase
-    def setup
-      @controller = ModuleRedirectController.new
-      @request    = ActionController::TestRequest.new
-      @response   = ActionController::TestResponse.new
-    end
-
-    def test_simple_redirect
-      get :simple_redirect
-      assert_response :redirect
-      assert_equal "http://test.host/module_test/module_redirect/hello_world", redirect_to_url
-    end
-
-    def test_simple_redirect_using_options
-      get :host_redirect
-      assert_response :redirect
-      assert_redirected_to :action => "other_host", :only_path => false, :host => 'other.test.host'
-    end
-
-    def test_module_redirect
-      get :module_redirect
-      assert_response :redirect
-      assert_equal "http://test.host/redirect/hello_world", redirect_to_url
-    end
-
-    def test_module_redirect_using_options
-      get :module_redirect
-      assert_response :redirect
-      assert_redirected_to :controller => 'redirect', :action => "hello_world"
-    end
-  end
-end

data/vendor/rails/actionpack/test/controller/render_test.rb

@@ -1,404 +0,0 @@
-require File.dirname(__FILE__) + '/../abstract_unit'
-
-unless defined?(Customer)
-  Customer = Struct.new("Customer", :name)
-end
-
-module Fun
-  class GamesController < ActionController::Base
-    def hello_world
-    end
-  end
-end
-
-
-class TestController < ActionController::Base
-  layout :determine_layout
-
-  def hello_world
-  end
-
-  def render_hello_world
-    render "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_action_hello_world_with_symbol
-    render_action :hello_world
-  end
-
-  def render_text_hello_world
-    render_text "hello world"
-  end
-
-  def render_json_hello_world
-    render_json({:hello => 'world'}.to_json)
-  end
-
-  def render_json_hello_world_with_callback
-    render_json({:hello => 'world'}.to_json, 'alert')
-  end
-
-  def render_symbol_json
-    render :json => {:hello => 'world'}.to_json
-  end
-
-  def render_custom_code
-    render_text "hello world", "404 Moved"
-  end
-
-  def render_text_appendix
-    render_text "hello world"
-    render_text ", goodbye!", "404 Not Found", true
-  end
-
-  def render_nothing_with_appendix
-    render_text "appended", nil, true
-  end
-
-  def render_xml_hello
-    @name = "David"
-    render "test/hello"
-  end
-
-  def heading
-    head :ok
-  end
-
-  def greeting
-    # let's just rely on the template
-  end
-
-  def layout_test
-    render_action "hello_world"
-  end
-
-  def builder_layout_test
-    render_action "hello"
-  end
-
-  def builder_partial_test
-    render_action "hello_world_container"
-  end
-
-  def partials_list
-    @test_unchanged = 'hello'
-    @customers = [ Customer.new("david"), Customer.new("mary") ]
-    render_action "list"
-  end
-
-  def partial_only
-    render_partial
-  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_template "Hello: <%= params[:name] %>"
-  end
-
-  def accessing_local_assigns_in_inline_template
-    name = params[:local_name]
-    render :inline => "<%= 'Goodbye, ' + local_name %>",
-           :locals => { :local_name => name }
-  end
-
-  def accessing_local_assigns_in_inline_template_with_string_keys
-    name = params[:local_name]
-    ActionView::Base.local_assigns_support_string_keys = true
-    render :inline => "<%= 'Goodbye, ' + local_name %>",
-           :locals => { "local_name" => name }
-    ActionView::Base.local_assigns_support_string_keys = false
-  end
-
-  def formatted_html_erb
-  end
-
-  def formatted_xml_erb
-  end
-
-  def render_to_string_test
-    @foo = render_to_string :inline => "this is a test"
-  end
-
-  def partial
-    render :partial => 'partial'
-  end
-  
-  def partial_as_rjs
-    render :update do |page|
-      page.replace :foo, :partial => 'partial'
-    end
-  end
-
-  def rescue_action(e) raise end
-
-  private
-    def determine_layout
-      case action_name
-        when "layout_test":         "layouts/standard"
-        when "builder_layout_test": "layouts/builder"
-        when "render_symbol_json":  "layouts/standard"  # to make sure layouts don't interfere
-      end
-    end
-end
-
-TestController.view_paths = [ File.dirname(__FILE__) + "/../fixtures/" ]
-Fun::GamesController.view_paths = [ File.dirname(__FILE__) + "/../fixtures/" ]
-
-class RenderTest < Test::Unit::TestCase
-  def setup
-    @request    = ActionController::TestRequest.new
-    @response   = ActionController::TestResponse.new
-    @controller = TestController.new
-
-    @request.host = "www.nextangle.com"
-  end
-
-  def test_simple_show
-    get :hello_world
-    assert_response 200
-    assert_template "test/hello_world"
-  end
-
-  def test_do_with_render
-    assert_deprecated_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_action_with_symbol
-    get :render_action_hello_world_with_symbol
-    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_json
-    get :render_json_hello_world
-    assert_equal '{hello: "world"}', @response.body
-    assert_equal 'application/json', @response.content_type
-  end
-
-  def test_do_with_render_json_with_callback
-    get :render_json_hello_world_with_callback
-    assert_equal 'alert({hello: "world"})', @response.body
-    assert_equal 'application/json', @response.content_type
-  end
-
-  def test_do_with_render_symbol_json
-    get :render_symbol_json
-    assert_equal '{hello: "world"}', @response.body
-    assert_equal 'application/json', @response.content_type
-  end
-
-  def test_do_with_render_custom_code
-    get :render_custom_code
-    assert_response 404
-  end
-
-  def test_do_with_render_text_appendix
-    get :render_text_appendix
-    assert_response 404
-    assert_equal 'hello world, goodbye!', @response.body
-  end
-
-  def test_do_with_render_nothing_with_appendix
-    get :render_nothing_with_appendix
-    assert_response 200
-    assert_equal 'appended', @response.body
-  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_render_xml
-    assert_deprecated_render { 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_render_xml_with_partial
-    get :builder_partial_test
-    assert_equal "<test>\n  <hello/>\n</test>\n", @response.body
-  end
-
-  def test_layout_rendering
-    get :layout_test
-    assert_equal "<html>Hello world!</html>", @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", process_request.body
-  # end
-
-  def test_partial_only
-    get :partial_only
-    assert_equal "only partial", @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_render_to_string_resets_assigns
-    get :render_to_string_test
-    assert_equal "The value of foo is: ::this is a test::\n", @response.body
-  end
-
-  def test_nested_rendering
-    @controller = Fun::GamesController.new
-    get :hello_world
-    assert_equal "Living in a nested world", @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_local_assigns_in_inline_template
-    get :accessing_local_assigns_in_inline_template, :local_name => "Local David"
-    assert_equal "Goodbye, Local David", @response.body
-  end
-
-  def test_accessing_local_assigns_in_inline_template_with_string_keys
-    get :accessing_local_assigns_in_inline_template_with_string_keys, :local_name => "Local David"
-    assert_equal "Goodbye, Local David", @response.body
-  end
-
-  def test_render_200_should_set_etag
-    get :render_hello_world_from_variable
-    assert_equal etag_for("hello david"), @response.headers['ETag']
-  end
-
-  def test_render_against_etag_request_should_304_when_match
-    @request.headers["HTTP_IF_NONE_MATCH"] = etag_for("hello david")
-    get :render_hello_world_from_variable
-    assert_equal "304 Not Modified", @response.headers['Status']
-    assert @response.body.empty?
-  end
-
-  def test_render_against_etag_request_should_200_when_no_match
-    @request.headers["HTTP_IF_NONE_MATCH"] = etag_for("hello somewhere else")
-    get :render_hello_world_from_variable
-    assert_equal "200 OK", @response.headers['Status']
-    assert !@response.body.empty?
-  end
-
-  def test_render_with_etag
-    get :render_hello_world_from_variable
-    expected_etag = etag_for('hello david')
-    assert_equal expected_etag, @response.headers['ETag']
-
-    @request.headers["HTTP_IF_NONE_MATCH"] = expected_etag
-    get :render_hello_world_from_variable
-    assert_equal "304 Not Modified", @response.headers['Status']
-
-    @request.headers["HTTP_IF_NONE_MATCH"] = "\"diftag\""
-    get :render_hello_world_from_variable
-    assert_equal "200 OK", @response.headers['Status']
-  end
-
-  def render_with_404_shouldnt_have_etag
-    get :render_custom_code
-    assert_nil @response.headers['ETag']
-  end
-
-  def test_etag_should_not_be_changed_when_already_set
-    expected_etag = etag_for("hello somewhere else")
-    @response.headers["ETag"] = expected_etag
-    get :render_hello_world_from_variable
-    assert_equal expected_etag, @response.headers['ETag']
-  end
-
-  def test_etag_should_govern_renders_with_layouts_too
-    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
-    assert_equal etag_for("<wrapper>\n<html>\n  <p>Hello </p>\n<p>This is grand!</p>\n</html>\n</wrapper>\n"), @response.headers['ETag']
-  end
-
-  def test_should_render_formatted_template
-    get :formatted_html_erb
-    assert_equal 'formatted html erb', @response.body
-  end
-  
-  def test_should_render_formatted_xml_erb_template
-    get :formatted_xml_erb, :format => :xml
-    assert_equal '<test>passed formatted xml erb</test>', @response.body
-  end
-  
-  def test_should_render_formatted_html_erb_template
-    get :formatted_xml_erb
-    assert_equal '<test>passed formatted html erb</test>', @response.body
-  end
-  
-  def test_should_render_formatted_html_erb_template_with_faulty_accepts_header
-    @request.env["HTTP_ACCEPT"] = "image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, appliction/x-shockwave-flash, */*"
-    get :formatted_xml_erb
-    assert_equal '<test>passed formatted html erb</test>', @response.body
-  end
-
-  def test_should_render_html_formatted_partial
-    get :partial
-    assert_equal 'partial html', @response.body
-  end
-
-  def test_should_render_html_formatted_partial_with_rjs
-    xhr :get, :partial_as_rjs
-    assert_equal %(Element.replace("foo", "partial html");), @response.body
-  end
-
-  def test_should_render_js_partial
-    xhr :get, :partial, :format => 'js'
-    assert_equal 'partial js', @response.body
-  end
-
-  protected
-    def assert_deprecated_render(&block)
-      assert_deprecated(/render/, &block)
-    end
-
-    def etag_for(text)
-      %("#{Digest::MD5.hexdigest(text)}")
-    end
-end