webroar 0.2.2

data/src/admin_panel/vendor/rails/actionpack/test/controller/capture_test.rb

@@ -0,0 +1,66 @@
+require 'abstract_unit'
+
+class CaptureController < ActionController::Base
+  def self.controller_name; "test"; end
+  def self.controller_path; "test"; end
+
+  def content_for
+    render :layout => "talk_from_action"
+  end
+
+  def content_for_with_parameter
+    render :layout => "talk_from_action"
+  end
+
+  def content_for_concatenated
+    render :layout => "talk_from_action"
+  end
+
+  def non_erb_block_content_for
+    render :layout => "talk_from_action"
+  end
+
+  def rescue_action(e) raise end
+end
+
+class CaptureTest < ActionController::TestCase
+  tests CaptureController
+
+  def setup
+    # 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.host = "www.nextangle.com"
+  end
+
+  def test_simple_capture
+    get :capturing
+    assert_equal "Dreamy days", @response.body.strip
+  end
+
+  def test_content_for
+    get :content_for
+    assert_equal expected_content_for_output, @response.body
+  end
+
+  def test_should_concatentate_content_for
+    get :content_for_concatenated
+    assert_equal expected_content_for_output, @response.body
+  end
+
+  def test_should_set_content_for_with_parameter
+    get :content_for_with_parameter
+    assert_equal expected_content_for_output, @response.body
+  end
+
+  def test_non_erb_block_content_for
+    get :non_erb_block_content_for
+    assert_equal expected_content_for_output, @response.body
+  end
+
+  private
+    def expected_content_for_output
+      "<title>Putting stuff in the title!</title>\n\nGreat stuff!"
+    end
+end

data/src/admin_panel/vendor/rails/actionpack/test/controller/content_type_test.rb

@@ -0,0 +1,168 @@
+require 'abstract_unit'
+
+class ContentTypeController < ActionController::Base
+  def render_content_type_from_body
+    response.content_type = Mime::RSS
+    render :text => "hello world!"
+  end
+
+  def render_defaults
+    render :text => "hello world!"
+  end
+
+  def render_content_type_from_render
+    render :text => "hello world!", :content_type => Mime::RSS
+  end
+
+  def render_charset_from_body
+    response.charset = "utf-16"
+    render :text => "hello world!"
+  end
+
+  def render_nil_charset_from_body
+    response.charset = nil
+    render :text => "hello world!"
+  end
+
+  def render_default_for_rhtml
+  end
+
+  def render_default_for_rxml
+  end
+
+  def render_default_for_rjs
+  end
+
+  def render_change_for_rxml
+    response.content_type = Mime::HTML
+    render :action => "render_default_for_rxml"
+  end
+
+  def render_default_content_types_for_respond_to
+    respond_to do |format|
+      format.html { render :text   => "hello world!" }
+      format.xml  { render :action => "render_default_content_types_for_respond_to.rhtml" }
+      format.js   { render :text   => "hello world!" }
+      format.rss  { render :text   => "hello world!", :content_type => Mime::XML }
+    end
+  end
+
+  def rescue_action(e) raise end
+end
+
+class ContentTypeTest < ActionController::TestCase
+  tests ContentTypeController
+
+  def setup
+    # 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)
+  end
+
+  def test_render_defaults
+    get :render_defaults
+    assert_equal "utf-8", @response.charset
+    assert_equal Mime::HTML, @response.content_type
+  end
+
+  def test_render_changed_charset_default
+    ContentTypeController.default_charset = "utf-16"
+    get :render_defaults
+    assert_equal "utf-16", @response.charset
+    assert_equal Mime::HTML, @response.content_type
+    ContentTypeController.default_charset = "utf-8"
+  end
+
+  def test_content_type_from_body
+    get :render_content_type_from_body
+    assert_equal "application/rss+xml", @response.content_type
+    assert_equal "utf-8", @response.charset
+  end
+
+  def test_content_type_from_render
+    get :render_content_type_from_render
+    assert_equal "application/rss+xml", @response.content_type
+    assert_equal "utf-8", @response.charset
+  end
+
+  def test_charset_from_body
+    get :render_charset_from_body
+    assert_equal Mime::HTML, @response.content_type
+    assert_equal "utf-16", @response.charset
+  end
+
+  def test_nil_charset_from_body
+    get :render_nil_charset_from_body
+    assert_equal Mime::HTML, @response.content_type
+    assert_equal "utf-8", @response.charset, @response.headers.inspect
+  end
+
+  def test_nil_default_for_rhtml
+    ContentTypeController.default_charset = nil
+    get :render_default_for_rhtml
+    assert_equal Mime::HTML, @response.content_type
+    assert_nil @response.charset, @response.headers.inspect
+  ensure
+    ContentTypeController.default_charset = "utf-8"
+  end
+
+  def test_default_for_rhtml
+    get :render_default_for_rhtml
+    assert_equal Mime::HTML, @response.content_type
+    assert_equal "utf-8", @response.charset
+  end
+
+  def test_default_for_rxml
+    get :render_default_for_rxml
+    assert_equal Mime::XML, @response.content_type
+    assert_equal "utf-8", @response.charset
+  end
+
+  def test_default_for_rjs
+    xhr :post, :render_default_for_rjs
+    assert_equal Mime::JS, @response.content_type
+    assert_equal "utf-8", @response.charset
+  end
+
+  def test_change_for_rxml
+    get :render_change_for_rxml
+    assert_equal Mime::HTML, @response.content_type
+    assert_equal "utf-8", @response.charset
+  end
+end
+
+class AcceptBasedContentTypeTest < ActionController::TestCase
+
+  tests ContentTypeController
+
+  def setup
+    ActionController::Base.use_accept_header = true
+  end
+
+  def teardown
+    ActionController::Base.use_accept_header = false
+  end
+
+
+  def test_render_default_content_types_for_respond_to
+    @request.accept = Mime::HTML.to_s
+    get :render_default_content_types_for_respond_to
+    assert_equal Mime::HTML, @response.content_type
+
+    @request.accept = Mime::JS.to_s
+    get :render_default_content_types_for_respond_to
+    assert_equal Mime::JS, @response.content_type
+  end
+
+  def test_render_default_content_types_for_respond_to_with_template
+    @request.accept = Mime::XML.to_s
+    get :render_default_content_types_for_respond_to
+    assert_equal Mime::XML, @response.content_type
+  end
+
+  def test_render_default_content_types_for_respond_to_with_overwrite
+    @request.accept = Mime::RSS.to_s
+    get :render_default_content_types_for_respond_to
+    assert_equal Mime::XML, @response.content_type
+  end
+end

data/src/admin_panel/vendor/rails/actionpack/test/controller/cookie_test.rb

@@ -0,0 +1,111 @@
+require 'abstract_unit'
+
+class CookieTest < ActionController::TestCase
+  class TestController < ActionController::Base
+    def authenticate
+      cookies["user_name"] = "david"
+    end
+
+    def authenticate_for_fourteen_days
+      cookies["user_name"] = { "value" => "david", "expires" => Time.utc(2005, 10, 10,5) }
+    end
+
+    def authenticate_for_fourteen_days_with_symbols
+      cookies[:user_name] = { :value => "david", :expires => Time.utc(2005, 10, 10,5) }
+    end
+
+    def set_multiple_cookies
+      cookies["user_name"] = { "value" => "david", "expires" => Time.utc(2005, 10, 10,5) }
+      cookies["login"]     = "XJ-122"
+    end
+
+    def access_frozen_cookies
+      cookies["will"] = "work"
+    end
+
+    def logout
+      cookies.delete("user_name")
+    end
+
+    def delete_cookie_with_path
+      cookies.delete("user_name", :path => '/beaten')
+      render :text => "hello world"
+    end
+
+    def authenticate_with_http_only
+      cookies["user_name"] = { :value => "david", :httponly => true }
+    end
+
+    def rescue_action(e)
+      raise unless ActionView::MissingTemplate # No templates here, and we don't care about the output
+    end
+  end
+
+  tests TestController
+
+  def setup
+    @request.host = "www.nextangle.com"
+  end
+
+  def test_setting_cookie
+    get :authenticate
+    assert_equal ["user_name=david; path=/"], @response.headers["Set-Cookie"]
+    assert_equal({"user_name" => "david"}, @response.cookies)
+  end
+
+  def test_setting_cookie_for_fourteen_days
+    get :authenticate_for_fourteen_days
+    assert_equal ["user_name=david; path=/; expires=Mon, 10-Oct-2005 05:00:00 GMT"], @response.headers["Set-Cookie"]
+    assert_equal({"user_name" => "david"}, @response.cookies)
+  end
+
+  def test_setting_cookie_for_fourteen_days_with_symbols
+    get :authenticate_for_fourteen_days_with_symbols
+    assert_equal ["user_name=david; path=/; expires=Mon, 10-Oct-2005 05:00:00 GMT"], @response.headers["Set-Cookie"]
+    assert_equal({"user_name" => "david"}, @response.cookies)
+  end
+
+  def test_setting_cookie_with_http_only
+    get :authenticate_with_http_only
+    assert_equal ["user_name=david; path=/; HttpOnly"], @response.headers["Set-Cookie"]
+    assert_equal({"user_name" => "david"}, @response.cookies)
+  end
+
+  def test_multiple_cookies
+    get :set_multiple_cookies
+    assert_equal 2, @response.cookies.size
+    assert_equal "user_name=david; path=/; expires=Mon, 10-Oct-2005 05:00:00 GMT", @response.headers["Set-Cookie"][0]
+    assert_equal "login=XJ-122; path=/", @response.headers["Set-Cookie"][1]
+    assert_equal({"login" => "XJ-122", "user_name" => "david"}, @response.cookies)
+  end
+
+  def test_setting_test_cookie
+    assert_nothing_raised { get :access_frozen_cookies }
+  end
+
+  def test_expiring_cookie
+    get :logout
+    assert_equal ["user_name=; path=/; expires=Thu, 01-Jan-1970 00:00:00 GMT"], @response.headers["Set-Cookie"]
+    assert_equal({"user_name" => nil}, @response.cookies)
+  end
+
+  def test_cookiejar_accessor
+    @request.cookies["user_name"] = "david"
+    @controller.request = @request
+    jar = ActionController::CookieJar.new(@controller)
+    assert_equal "david", jar["user_name"]
+    assert_equal nil, jar["something_else"]
+  end
+
+  def test_cookiejar_accessor_with_array_value
+    @request.cookies["pages"] = %w{1 2 3}
+    @controller.request = @request
+    jar = ActionController::CookieJar.new(@controller)
+    assert_equal %w{1 2 3}, jar["pages"]
+  end
+
+  def test_delete_cookie_with_path
+    get :delete_cookie_with_path
+    assert_equal ["user_name=; path=/beaten; expires=Thu, 01-Jan-1970 00:00:00 GMT"], @response.headers["Set-Cookie"]
+  end
+end

data/src/admin_panel/vendor/rails/actionpack/test/controller/deprecation/deprecated_base_methods_test.rb

@@ -0,0 +1,32 @@
+require 'abstract_unit'
+
+class DeprecatedBaseMethodsTest < ActionController::TestCase
+  class Target < ActionController::Base
+    def home_url(greeting)
+      "http://example.com/#{greeting}"
+    end
+
+    def raises_name_error
+      this_method_doesnt_exist
+    end
+
+    def rescue_action(e) raise e end
+  end
+
+  tests Target
+
+  def test_log_error_silences_deprecation_warnings
+    get :raises_name_error
+  rescue => e
+    assert_not_deprecated { @controller.send :log_error, e }
+  end
+
+  if defined? Test::Unit::Error
+    def test_assertion_failed_error_silences_deprecation_warnings
+      get :raises_name_error
+    rescue => e
+      error = Test::Unit::Error.new('testing ur doodz', e)
+      assert_not_deprecated { error.message }
+    end
+  end
+end

data/src/admin_panel/vendor/rails/actionpack/test/controller/dispatcher_test.rb

@@ -0,0 +1,103 @@
+require 'abstract_unit'
+
+class DispatcherTest < Test::Unit::TestCase
+  Dispatcher = ActionController::Dispatcher
+
+  def setup
+    ENV['REQUEST_METHOD'] = 'GET'
+
+    Dispatcher.middleware = ActionController::MiddlewareStack.new do |middleware|
+      middlewares = File.expand_path(File.join(File.dirname(__FILE__), "../../lib/action_controller/middlewares.rb"))
+      middleware.instance_eval(File.read(middlewares))
+    end
+
+    # Clear callbacks as they are redefined by Dispatcher#define_dispatcher_callbacks
+    Dispatcher.instance_variable_set("@prepare_dispatch_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
+    Dispatcher.instance_variable_set("@before_dispatch_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
+    Dispatcher.instance_variable_set("@after_dispatch_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
+
+    Dispatcher.stubs(:require_dependency)
+  end
+
+  def teardown
+    ENV.delete 'REQUEST_METHOD'
+  end
+
+  def test_clears_dependencies_after_dispatch_if_in_loading_mode
+    ActiveSupport::Dependencies.expects(:clear).once
+    dispatch(false)
+  end
+
+  def test_reloads_routes_before_dispatch_if_in_loading_mode
+    ActionController::Routing::Routes.expects(:reload).once
+    dispatch(false)
+  end
+
+  def test_leaves_dependencies_after_dispatch_if_not_in_loading_mode
+    ActionController::Routing::Routes.expects(:reload).never
+    ActiveSupport::Dependencies.expects(:clear).never
+
+    dispatch
+  end
+
+  # Stub out dispatch error logger
+  class << Dispatcher
+    def log_failsafe_exception(status, exception); end
+  end
+
+  def test_failsafe_response
+    Dispatcher.any_instance.expects(:dispatch).raises('b00m')
+    ActionController::Failsafe.any_instance.expects(:log_failsafe_exception)
+
+    assert_nothing_raised do
+      assert_equal [
+        500,
+        {"Content-Type" => "text/html"},
+        "<html><body><h1>500 Internal Server Error</h1></body></html>"
+      ], dispatch
+    end
+  end
+
+  def test_prepare_callbacks
+    a = b = c = nil
+    Dispatcher.to_prepare { |*args| a = b = c = 1 }
+    Dispatcher.to_prepare { |*args| b = c = 2 }
+    Dispatcher.to_prepare { |*args| c = 3 }
+
+    # Ensure to_prepare callbacks are not run when defined
+    assert_nil a || b || c
+
+    # Run callbacks
+    Dispatcher.run_prepare_callbacks
+
+    assert_equal 1, a
+    assert_equal 2, b
+    assert_equal 3, c
+
+    # Make sure they are only run once
+    a = b = c = nil
+    dispatch
+    assert_nil a || b || c
+  end
+
+  def test_to_prepare_with_identifier_replaces
+    a = b = nil
+    Dispatcher.to_prepare(:unique_id) { |*args| a = b = 1 }
+    Dispatcher.to_prepare(:unique_id) { |*args| a = 2 }
+
+    Dispatcher.run_prepare_callbacks
+    assert_equal 2, a
+    assert_equal nil, b
+  end
+
+  private
+    def dispatch(cache_classes = true)
+      ActionController::Routing::RouteSet.any_instance.stubs(:call).returns([200, {}, 'response'])
+      Dispatcher.define_dispatcher_callbacks(cache_classes)
+      Dispatcher.new.call({})
+    end
+
+    def assert_subclasses(howmany, klass, message = klass.subclasses.inspect)
+      assert_equal howmany, klass.subclasses.size, message
+    end
+end

data/src/admin_panel/vendor/rails/actionpack/test/controller/fake_controllers.rb

@@ -0,0 +1,33 @@
+class << Object; alias_method :const_available?, :const_defined?; end
+  
+class ContentController < Class.new(ActionController::Base)
+end
+class NotAController
+end
+module Admin
+  class << self; alias_method :const_available?, :const_defined?; end
+  class UserController < Class.new(ActionController::Base); end
+  class NewsFeedController < Class.new(ActionController::Base); end
+end
+
+# For speed test
+class SpeedController < ActionController::Base;  end
+class SearchController        < SpeedController; end
+class VideosController        < SpeedController; end
+class VideoFileController     < SpeedController; end
+class VideoSharesController   < SpeedController; end
+class VideoAbusesController   < SpeedController; end
+class VideoUploadsController  < SpeedController; end
+class VideoVisitsController   < SpeedController; end
+class UsersController         < SpeedController; end
+class SettingsController      < SpeedController; end
+class ChannelsController      < SpeedController; end
+class ChannelVideosController < SpeedController; end
+class SessionsController      < SpeedController; end
+class LostPasswordsController < SpeedController; end
+class PagesController         < SpeedController; end
+
+ActionController::Routing::Routes.draw do |map|
+  map.route_one 'route_one', :controller => 'elsewhere', :action => 'flash_me'
+  map.connect ':controller/:action/:id'
+end

data/src/admin_panel/vendor/rails/actionpack/test/controller/fake_models.rb

@@ -0,0 +1,19 @@
+class Customer < Struct.new(:name, :id)
+  def to_param
+    id.to_s
+  end
+end
+
+class BadCustomer < Customer
+end
+
+class GoodCustomer < Customer
+end
+
+module Quiz
+  class Question < Struct.new(:name, :id)
+    def to_param
+      id.to_s
+    end
+  end
+end

data/src/admin_panel/vendor/rails/actionpack/test/controller/filter_params_test.rb

@@ -0,0 +1,49 @@
+require 'abstract_unit'
+
+class FilterParamController < ActionController::Base
+end
+
+class FilterParamTest < Test::Unit::TestCase
+  def setup
+    @controller = FilterParamController.new
+  end
+
+  def test_filter_parameters
+    assert FilterParamController.respond_to?(:filter_parameter_logging)
+    assert !@controller.respond_to?(:filter_parameters)
+
+    FilterParamController.filter_parameter_logging
+    assert @controller.respond_to?(:filter_parameters)
+
+    test_hashes = [[{},{},[]],
+    [{'foo'=>nil},{'foo'=>nil},[]],
+    [{'foo'=>'bar'},{'foo'=>'bar'},[]],
+    [{'foo'=>'bar'},{'foo'=>'bar'},%w'food'],
+    [{'foo'=>'bar'},{'foo'=>'[FILTERED]'},%w'foo'],
+    [{'foo'=>'bar', 'bar'=>'foo'},{'foo'=>'[FILTERED]', 'bar'=>'foo'},%w'foo baz'],
+    [{'foo'=>'bar', 'baz'=>'foo'},{'foo'=>'[FILTERED]', 'baz'=>'[FILTERED]'},%w'foo baz'],
+    [{'bar'=>{'foo'=>'bar','bar'=>'foo'}},{'bar'=>{'foo'=>'[FILTERED]','bar'=>'foo'}},%w'fo'],
+    [{'foo'=>{'foo'=>'bar','bar'=>'foo'}},{'foo'=>'[FILTERED]'},%w'f banana']]
+
+    test_hashes.each do |before_filter, after_filter, filter_words|
+      FilterParamController.filter_parameter_logging(*filter_words)
+      assert_equal after_filter, @controller.__send__(:filter_parameters, before_filter)
+
+      filter_words.push('blah')
+      FilterParamController.filter_parameter_logging(*filter_words) do |key, value|
+        value.reverse! if key =~ /bargain/
+      end
+
+      before_filter['barg'] = {'bargain'=>'gain', 'blah'=>'bar', 'bar'=>{'bargain'=>{'blah'=>'foo'}}}
+      after_filter['barg'] = {'bargain'=>'niag', 'blah'=>'[FILTERED]', 'bar'=>{'bargain'=>{'blah'=>'[FILTERED]'}}}
+
+      assert_equal after_filter, @controller.__send__(:filter_parameters, before_filter)
+    end
+  end
+
+  def test_filter_parameters_is_protected
+    FilterParamController.filter_parameter_logging(:foo)
+    assert !FilterParamController.action_methods.include?('filter_parameters')
+    assert_raise(NoMethodError) { @controller.filter_parameters([{'password' => '[FILTERED]'}]) }
+  end
+end