radiant 0.8.0 → 0.8.1

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

@@ -1,6 +1,6 @@
 require 'abstract_unit'
 
-class BaseRackTest < Test::Unit::TestCase
+class BaseRackTest < ActiveSupport::TestCase
   def setup
     @env = {
       "HTTP_MAX_FORWARDS" => "10",
@@ -261,6 +261,23 @@ class RackResponseTest < BaseRackTest
     body.each { |part| parts << part }
     assert_equal ["0", "1", "2", "3", "4"], parts
   end
+
+  def test_streaming_block_with_flush_is_deprecated
+    @response.body = Proc.new do |response, output|
+      5.times do |n|
+        output.write(n)
+        output.flush
+      end
+    end
+
+    assert_deprecated(/output.flush is no longer needed/) do
+      @response.prepare!
+      status, headers, body = @response.to_a
+
+      parts = []
+      body.each { |part| parts << part }
+    end
+  end
 end
 
 class RackResponseHeadersTest < BaseRackTest

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

@@ -235,7 +235,10 @@ class RedirectTest < ActionController::TestCase
 
   def test_redirect_with_partial_params
     get :module_redirect
-    assert_redirected_to :action => 'hello_world'
+
+    assert_deprecated(/test_redirect_with_partial_params/) do
+      assert_redirected_to :action => 'hello_world'
+    end
   end
 
   def test_redirect_to_nil

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

@@ -0,0 +1,124 @@
+require 'abstract_unit'
+
+class ReloaderTests < ActiveSupport::TestCase
+  Reloader   = ActionController::Reloader
+  Dispatcher = ActionController::Dispatcher
+
+  class MyBody < Array
+    def initialize(&block)
+      @on_close = block
+    end
+
+    def foo
+      "foo"
+    end
+
+    def bar
+      "bar"
+    end
+
+    def close
+      @on_close.call if @on_close
+    end
+  end
+
+  def setup
+    @lock = Mutex.new
+  end
+
+  def test_it_reloads_the_application_before_yielding
+    Dispatcher.expects(:reload_application)
+    Reloader.run(@lock) do
+      [200, { "Content-Type" => "text/html" }, [""]]
+    end
+  end
+
+  def test_it_locks_before_yielding
+    lock = DummyMutex.new
+    Dispatcher.expects(:reload_application)
+    Reloader.run(lock) do
+      assert lock.locked?
+      [200, { "Content-Type" => "text/html" }, [""]]
+    end
+    assert lock.locked?
+  end
+
+  def test_it_unlocks_upon_calling_close_on_body
+    lock = DummyMutex.new
+    Dispatcher.expects(:reload_application)
+    headers, status, body = Reloader.run(lock) do
+      [200, { "Content-Type" => "text/html" }, [""]]
+    end
+    body.close
+    assert !lock.locked?
+  end
+
+  def test_it_unlocks_if_app_object_raises_exception
+    lock = DummyMutex.new
+    Dispatcher.expects(:reload_application)
+    assert_raise(RuntimeError) do
+      Reloader.run(lock) do
+        raise "oh no!"
+      end
+    end
+    assert !lock.locked?
+  end
+
+  def test_returned_body_object_always_responds_to_close
+    status, headers, body = Reloader.run(@lock) do
+      [200, { "Content-Type" => "text/html" }, [""]]
+    end
+    assert body.respond_to?(:close)
+  end
+
+  def test_returned_body_object_behaves_like_underlying_object
+    status, headers, body = Reloader.run(@lock) do
+      b = MyBody.new
+      b << "hello"
+      b << "world"
+      [200, { "Content-Type" => "text/html" }, b]
+    end
+    assert_equal 2, body.size
+    assert_equal "hello", body[0]
+    assert_equal "world", body[1]
+    assert_equal "foo", body.foo
+    assert_equal "bar", body.bar
+  end
+
+  def test_it_calls_close_on_underlying_object_when_close_is_called_on_body
+    close_called = false
+    status, headers, body = Reloader.run(@lock) do
+      b = MyBody.new do
+        close_called = true
+      end
+      [200, { "Content-Type" => "text/html" }, b]
+    end
+    body.close
+    assert close_called
+  end
+
+  def test_returned_body_object_responds_to_all_methods_supported_by_underlying_object
+    status, headers, body = Reloader.run(@lock) do
+      [200, { "Content-Type" => "text/html" }, MyBody.new]
+    end
+    assert body.respond_to?(:size)
+    assert body.respond_to?(:each)
+    assert body.respond_to?(:foo)
+    assert body.respond_to?(:bar)
+  end
+
+  def test_it_doesnt_clean_up_the_application_after_call
+    Dispatcher.expects(:cleanup_application).never
+    status, headers, body = Reloader.run(@lock) do
+      [200, { "Content-Type" => "text/html" }, MyBody.new]
+    end
+  end
+
+  def test_it_cleans_up_the_application_when_close_is_called_on_body
+    Dispatcher.expects(:cleanup_application)
+    status, headers, body = Reloader.run(@lock) do
+      [200, { "Content-Type" => "text/html" }, MyBody.new]
+    end
+    body.close
+  end
+end

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

@@ -193,20 +193,24 @@ class TestController < ActionController::Base
     render :inline =>  "<%= controller_name %>"
   end
 
+  def render_json_nil
+    render :json => nil
+  end
+
   def render_json_hello_world
-    render :json => {:hello => 'world'}.to_json
+    render :json => ActiveSupport::JSON.encode(:hello => 'world')
   end
 
   def render_json_hello_world_with_callback
-    render :json => {:hello => 'world'}.to_json, :callback => 'alert'
+    render :json => ActiveSupport::JSON.encode(:hello => 'world'), :callback => 'alert'
   end
 
   def render_json_with_custom_content_type
-    render :json => {:hello => 'world'}.to_json, :content_type => 'text/javascript'
+    render :json => ActiveSupport::JSON.encode(:hello => 'world'), :content_type => 'text/javascript'
   end
 
   def render_symbol_json
-    render :json => {:hello => 'world'}.to_json
+    render :json => ActiveSupport::JSON.encode(:hello => 'world')
   end
 
   def render_json_with_render_to_string
@@ -886,33 +890,39 @@ class RenderTest < ActionController::TestCase
     assert_equal "The secret is in the sauce\n", @response.body
   end
 
+  def test_render_json_nil
+    get :render_json_nil
+    assert_equal 'null', @response.body
+    assert_equal 'application/json', @response.content_type
+  end
+
   def test_render_json
     get :render_json_hello_world
-    assert_equal '{"hello": "world"}', @response.body
+    assert_equal '{"hello":"world"}', @response.body
     assert_equal 'application/json', @response.content_type
   end
 
   def test_render_json_with_callback
     get :render_json_hello_world_with_callback
-    assert_equal 'alert({"hello": "world"})', @response.body
+    assert_equal 'alert({"hello":"world"})', @response.body
     assert_equal 'application/json', @response.content_type
   end
 
   def test_render_json_with_custom_content_type
     get :render_json_with_custom_content_type
-    assert_equal '{"hello": "world"}', @response.body
+    assert_equal '{"hello":"world"}', @response.body
     assert_equal 'text/javascript', @response.content_type
   end
 
   def test_render_symbol_json
     get :render_symbol_json
-    assert_equal '{"hello": "world"}', @response.body
+    assert_equal '{"hello":"world"}', @response.body
     assert_equal 'application/json', @response.content_type
   end
 
   def test_render_json_with_render_to_string
     get :render_json_with_render_to_string
-    assert_equal '{"hello": "partial html"}', @response.body
+    assert_equal '{"hello":"partial html"}', @response.body
     assert_equal 'application/json', @response.content_type
   end
 

data/vendor/rails/actionpack/test/controller/request/json_params_parsing_test.rb

@@ -30,16 +30,36 @@ class JsonParamsParsingTest < ActionController::IntegrationTest
     )
   end
 
+  test "logs error if parsing unsuccessful" do
+    with_test_routing do
+      begin
+        $stderr = StringIO.new
+        json = "[\"person]\": {\"name\": \"David\"}}"
+        post "/parse", json, {'CONTENT_TYPE' => 'application/json'}
+        assert_response :error
+        $stderr.rewind && err = $stderr.read
+        assert err =~ /Error occurred while parsing request parameters/
+      ensure
+        $stderr = STDERR
+      end
+    end
+  end
+
   private
     def assert_parses(expected, actual, headers = {})
+      with_test_routing do
+        post "/parse", actual, headers
+        assert_response :ok
+        assert_equal(expected, TestController.last_request_parameters)
+      end
+    end
+
+    def with_test_routing
       with_routing do |set|
         set.draw do |map|
           map.connect ':action', :controller => "json_params_parsing_test/test"
         end
-
-        post "/parse", actual, headers
-        assert_response :ok
-        assert_equal(expected, TestController.last_request_parameters)
+        yield
       end
     end
 end

data/vendor/rails/actionpack/test/controller/request/multipart_params_parsing_test.rb

@@ -96,7 +96,7 @@ class MultipartParamsParsingTest < ActionController::IntegrationTest
 
     # Ruby CGI doesn't handle multipart/mixed for us.
     files = params['files']
-    assert_kind_of String, files
+    assert_kind_of Tempfile, files
     files.force_encoding('ASCII-8BIT') if files.respond_to?(:force_encoding)
     assert_equal 19756, files.size
   end
@@ -133,46 +133,6 @@ class MultipartParamsParsingTest < ActionController::IntegrationTest
     end
   end
 
-  # The lint wrapper is used in integration tests
-  # instead of a normal StringIO class
-  InputWrapper = Rack::Lint::InputWrapper
-
-  test "parses unwindable stream" do
-    InputWrapper.any_instance.stubs(:rewind).raises(Errno::ESPIPE)
-    params = parse_multipart('large_text_file')
-    assert_equal %w(file foo), params.keys.sort
-    assert_equal 'bar', params['foo']
-  end
-
-  test "uploads and reads file with unwindable input" do
-    InputWrapper.any_instance.stubs(:rewind).raises(Errno::ESPIPE)
-
-    with_test_routing do
-      post '/read', :uploaded_data => fixture_file_upload(FIXTURE_PATH + "/hello.txt", "text/plain")
-      assert_equal "File: Hello", response.body
-    end
-  end
-
-  test "passes through rack middleware and uploads file" do
-    with_muck_middleware do
-      with_test_routing do
-        post '/read', :uploaded_data => fixture_file_upload(FIXTURE_PATH + "/hello.txt", "text/plain")
-        assert_equal "File: Hello", response.body
-      end
-    end
-  end
-
-  test "passes through rack middleware and uploads file with unwindable input" do
-    InputWrapper.any_instance.stubs(:rewind).raises(Errno::ESPIPE)
-
-    with_muck_middleware do
-      with_test_routing do
-        post '/read', :uploaded_data => fixture_file_upload(FIXTURE_PATH + "/hello.txt", "text/plain")
-        assert_equal "File: Hello", response.body
-      end
-    end
-  end
-
   private
     def fixture(name)
       File.open(File.join(FIXTURE_PATH, name), 'rb') do |file|
@@ -199,25 +159,4 @@ class MultipartParamsParsingTest < ActionController::IntegrationTest
         yield
       end
     end
-
-    class MuckMiddleware
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        req = Rack::Request.new(env)
-        req.params # Parse params
-        @app.call(env)
-      end
-    end
-
-    def with_muck_middleware
-      original_middleware = ActionController::Dispatcher.middleware
-      middleware = original_middleware.dup
-      middleware.insert_after ActionController::RewindableInput, MuckMiddleware
-      ActionController::Dispatcher.middleware = middleware
-      yield
-      ActionController::Dispatcher.middleware = original_middleware
-    end
 end

data/vendor/rails/actionpack/test/controller/request/test_request_test.rb

@@ -0,0 +1,35 @@
+require 'abstract_unit'
+require 'stringio'
+
+class ActionController::TestRequestTest < ActiveSupport::TestCase
+
+  def setup
+    @request = ActionController::TestRequest.new
+  end
+
+  def test_test_request_has_session_options_initialized
+    assert @request.session_options
+  end
+  
+  Rack::Session::Abstract::ID::DEFAULT_OPTIONS.each_key do |option|
+    test "test_rack_default_session_options_#{option}_exists_in_session_options_and_is_default" do
+      assert_equal(Rack::Session::Abstract::ID::DEFAULT_OPTIONS[option], 
+                   @request.session_options[option], 
+                   "Missing rack session default option #{option} in request.session_options")
+    end
+    test "test_rack_default_session_options_#{option}_exists_in_session_options" do
+      assert(@request.session_options.has_key?(option), 
+                   "Missing rack session option #{option} in request.session_options")
+    end
+  end
+  
+  def test_session_id_exists_by_default
+    assert_not_nil(@request.session_options[:id])
+  end
+  
+  def test_session_id_different_on_each_call
+    prev_id = 
+    assert_not_equal(@request.session_options[:id], ActionController::TestRequest.new.session_options[:id])
+  end
+  
+end

data/vendor/rails/actionpack/test/controller/request/url_encoded_params_parsing_test.rb

@@ -126,45 +126,7 @@ class UrlEncodedParamsParsingTest < ActionController::IntegrationTest
     assert_parses expected, query
   end
 
-  test "passes through rack middleware and parses params" do
-    with_muck_middleware do
-      assert_parses({ "a" => { "b" => "c" } }, "a[b]=c")
-    end
-  end
-
-  # The lint wrapper is used in integration tests
-  # instead of a normal StringIO class
-  InputWrapper = Rack::Lint::InputWrapper
-
-  test "passes through rack middleware and parses params with unwindable input" do
-    InputWrapper.any_instance.stubs(:rewind).raises(Errno::ESPIPE)
-    with_muck_middleware do
-      assert_parses({ "a" => { "b" => "c" } }, "a[b]=c")
-    end
-  end
-
   private
-    class MuckMiddleware
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        req = Rack::Request.new(env)
-        req.params # Parse params
-        @app.call(env)
-      end
-    end
-
-    def with_muck_middleware
-      original_middleware = ActionController::Dispatcher.middleware
-      middleware = original_middleware.dup
-      middleware.insert_after ActionController::RewindableInput, MuckMiddleware
-      ActionController::Dispatcher.middleware = middleware
-      yield
-      ActionController::Dispatcher.middleware = original_middleware
-    end
-
     def with_test_routing
       with_routing do |set|
         set.draw do |map|