kotovalexarian-likes-github/rails--rails
1
0
Fork 0
mirror of https://github.com/rails/rails.git synced 2022-11-09 12:12:34 -05:00
Code Releases Activity
rails--rails/actionpack/test/controller/live_stream_test.rb

350 lines
9.6 KiB
Ruby
Raw Normal View History

added live responses which can be written and read in separate threads
2012-07-29 20:26:07 -04:00
require 'abstract_unit'
Controller actions are processed in a separate thread for live responses. Processing controller actions in a separate thread allows us to work around the rack api - we can allow the user to set status and headers, then block until the first bytes are written. As soon as the first bytes are written, the main thread can return the status, headers, and (essentially) a queue for the body.
2012-07-29 22:23:19 -04:00
require 'active_support/concurrency/latch'
live controllers should have live responses detect the type of controller we're testing and return the right type of response based on that controller. This allows us to stop doing the weird sleep thing.
2014-02-28 18:22:35 -05:00
Thread.abort_on_exception = true
added live responses which can be written and read in separate threads
2012-07-29 20:26:07 -04:00
module ActionController
Creating an SSE class to be used with ActionController::Live.
2013-07-14 18:48:57 -04:00
class SSETest < ActionController::TestCase
class SSETestController < ActionController::Base
include ActionController::Live
def basic_sse
response.headers['Content-Type'] = 'text/event-stream'
sse = SSE.new(response.stream)
sse.write("{\"name\":\"John\"}")
sse.write({ name: "Ryan" })
ensure
sse.close
end
def sse_with_event
sse = SSE.new(response.stream, event: "send-name")
sse.write("{\"name\":\"John\"}")
sse.write({ name: "Ryan" })
ensure
sse.close
end
def sse_with_retry
sse = SSE.new(response.stream, retry: 1000)
sse.write("{\"name\":\"John\"}")
sse.write({ name: "Ryan" }, retry: 1500)
ensure
sse.close
end
def sse_with_id
sse = SSE.new(response.stream)
sse.write("{\"name\":\"John\"}", id: 1)
sse.write({ name: "Ryan" }, id: 2)
ensure
sse.close
end
end
tests SSETestController
def wait_for_response_stream_close
use the body proxy to freeze headers avoid freezing the headers until the web server has actually read data from the body proxy. Once the webserver has read data, then we should throw an error if someone tries to set a header
2014-03-12 20:40:08 -04:00
response.body
Creating an SSE class to be used with ActionController::Live.
2013-07-14 18:48:57 -04:00
end
def test_basic_sse
get :basic_sse
wait_for_response_stream_close
assert_match(/data: {\"name\":\"John\"}/, response.body)
assert_match(/data: {\"name\":\"Ryan\"}/, response.body)
end
def test_sse_with_event_name
get :sse_with_event
wait_for_response_stream_close
assert_match(/data: {\"name\":\"John\"}/, response.body)
assert_match(/data: {\"name\":\"Ryan\"}/, response.body)
assert_match(/event: send-name/, response.body)
end
def test_sse_with_retry
get :sse_with_retry
wait_for_response_stream_close
first_response, second_response = response.body.split("\n\n")
assert_match(/data: {\"name\":\"John\"}/, first_response)
assert_match(/retry: 1000/, first_response)
assert_match(/data: {\"name\":\"Ryan\"}/, second_response)
assert_match(/retry: 1500/, second_response)
end
def test_sse_with_id
get :sse_with_id
wait_for_response_stream_close
first_response, second_response = response.body.split("\n\n")
assert_match(/data: {\"name\":\"John\"}/, first_response)
assert_match(/id: 1/, first_response)
assert_match(/data: {\"name\":\"Ryan\"}/, second_response)
assert_match(/id: 2/, second_response)
end
end
Controller actions are processed in a separate thread for live responses. Processing controller actions in a separate thread allows us to work around the rack api - we can allow the user to set status and headers, then block until the first bytes are written. As soon as the first bytes are written, the main thread can return the status, headers, and (essentially) a queue for the body.
2012-07-29 22:23:19 -04:00
class LiveStreamTest < ActionController::TestCase
use built-in exception handling in live controllers when an exception happens in an action before the response has been committed, then we should re-raise the exception in the main thread. This lets us reuse the existing exception handling.
2014-02-28 18:39:08 -05:00
class Exception < StandardError
end
added live responses which can be written and read in separate threads
2012-07-29 20:26:07 -04:00
class TestController < ActionController::Base
Controller actions are processed in a separate thread for live responses. Processing controller actions in a separate thread allows us to work around the rack api - we can allow the user to set status and headers, then block until the first bytes are written. As soon as the first bytes are written, the main thread can return the status, headers, and (essentially) a queue for the body.
2012-07-29 22:23:19 -04:00
include ActionController::Live
attr_accessor :latch, :tc
added live responses which can be written and read in separate threads
2012-07-29 20:26:07 -04:00
def self.controller_path
'test'
end
only write the jar if the response isn't committed when streaming responses, we need to make sure the cookie jar is written to the headers before returning up the stack. This commit introduces a new method on the response object that writes the cookie jar to the headers as the response is committed. The middleware and test framework will not write the cookie headers if the response has already been committed. fixes #14352
2014-03-12 19:07:04 -04:00
def set_cookie
cookies[:hello] = "world"
response.stream.write "hello world"
response.close
end
close the response when the response body is set so that normal render calls will work
2012-07-29 23:33:16 -04:00
def render_text
render :text => 'zomg'
end
header hash is duped before being sent up the rack stack
2012-07-29 23:26:40 -04:00
def default_header
response.stream.write "<html><body>hi</body></html>"
response.stream.close
end
added live responses which can be written and read in separate threads
2012-07-29 20:26:07 -04:00
def basic_stream
Controller actions are processed in a separate thread for live responses. Processing controller actions in a separate thread allows us to work around the rack api - we can allow the user to set status and headers, then block until the first bytes are written. As soon as the first bytes are written, the main thread can return the status, headers, and (essentially) a queue for the body.
2012-07-29 22:23:19 -04:00
response.headers['Content-Type'] = 'text/event-stream'
%w{ hello world }.each do |word|
response.stream.write word
end
response.stream.close
end
def blocking_stream
response.headers['Content-Type'] = 'text/event-stream'
%w{ hello world }.each do |word|
response.stream.write word
latch.await
end
response.stream.close
end
def thread_locals
tc.assert_equal 'aaron', Thread.current[:setting]
Alias refute methods to assert_not and perfer assert_not on tests
2012-12-28 18:49:41 -05:00
tc.assert_not_equal Thread.current.object_id, Thread.current[:originating_thread]
Controller actions are processed in a separate thread for live responses. Processing controller actions in a separate thread allows us to work around the rack api - we can allow the user to set status and headers, then block until the first bytes are written. As soon as the first bytes are written, the main thread can return the status, headers, and (essentially) a queue for the body.
2012-07-29 22:23:19 -04:00
response.headers['Content-Type'] = 'text/event-stream'
added live responses which can be written and read in separate threads
2012-07-29 20:26:07 -04:00
%w{ hello world }.each do |word|
response.stream.write word
end
response.stream.close
end
Handle conditional get in live requests - this will prevent error when using stale on live streams(issue #9636)
2013-03-14 04:13:10 -04:00
def with_stale
render :text => 'stale' if stale?(:etag => "123")
end
Exception handling for controllers using ActionController::Live Any exceptions that occured at the view or controller level for a controller using ActionController::Live would cause the server to either hang with an open socket indefinitely, or immediately crash (depending on whether the server was launched with rails s or directly). Changed the behavior of exceptions to act the same as streaming templates for html requests, and allow for an on_error callback if needed.
2013-03-07 17:49:03 -05:00
def exception_in_view
render 'doesntexist'
end
re-raise error if error occurs before committing in streaming update the tests, using an if-else
2014-02-17 21:41:21 -05:00
def exception_in_view_after_commit
response.stream.write ""
render 'doesntexist'
end
Exception handling for controllers using ActionController::Live Any exceptions that occured at the view or controller level for a controller using ActionController::Live would cause the server to either hang with an open socket indefinitely, or immediately crash (depending on whether the server was launched with rails s or directly). Changed the behavior of exceptions to act the same as streaming templates for html requests, and allow for an on_error callback if needed.
2013-03-07 17:49:03 -05:00
def exception_with_callback
response.headers['Content-Type'] = 'text/event-stream'
response.stream.on_error do
response.stream.write %(data: "500 Internal Server Error"\n\n)
response.stream.close
end
use built-in exception handling in live controllers when an exception happens in an action before the response has been committed, then we should re-raise the exception in the main thread. This lets us reuse the existing exception handling.
2014-02-28 18:39:08 -05:00
response.stream.write "" # make sure the response is committed
Exception handling for controllers using ActionController::Live Any exceptions that occured at the view or controller level for a controller using ActionController::Live would cause the server to either hang with an open socket indefinitely, or immediately crash (depending on whether the server was launched with rails s or directly). Changed the behavior of exceptions to act the same as streaming templates for html requests, and allow for an on_error callback if needed.
2013-03-07 17:49:03 -05:00
raise 'An exception occurred...'
end
Correct prestreaming controller response status. if the controller action has not yet streamed any data, actions should process as normal, and errors should trigger the appropriate behavior (500, or in the case of ActionController::BadRequest, a 400 Bad Request)
2014-02-15 16:05:00 -05:00
def exception_in_controller
use built-in exception handling in live controllers when an exception happens in an action before the response has been committed, then we should re-raise the exception in the main thread. This lets us reuse the existing exception handling.
2014-02-28 18:39:08 -05:00
raise Exception, 'Exception in controller'
Correct prestreaming controller response status. if the controller action has not yet streamed any data, actions should process as normal, and errors should trigger the appropriate behavior (500, or in the case of ActionController::BadRequest, a 400 Bad Request)
2014-02-15 16:05:00 -05:00
end
def bad_request_error
raise ActionController::BadRequest
end
Exception handling for controllers using ActionController::Live Any exceptions that occured at the view or controller level for a controller using ActionController::Live would cause the server to either hang with an open socket indefinitely, or immediately crash (depending on whether the server was launched with rails s or directly). Changed the behavior of exceptions to act the same as streaming templates for html requests, and allow for an on_error callback if needed.
2013-03-07 17:49:03 -05:00
def exception_in_exception_callback
response.headers['Content-Type'] = 'text/event-stream'
response.stream.on_error do
raise 'We need to go deeper.'
end
use built-in exception handling in live controllers when an exception happens in an action before the response has been committed, then we should re-raise the exception in the main thread. This lets us reuse the existing exception handling.
2014-02-28 18:39:08 -05:00
response.stream.write ''
Exception handling for controllers using ActionController::Live Any exceptions that occured at the view or controller level for a controller using ActionController::Live would cause the server to either hang with an open socket indefinitely, or immediately crash (depending on whether the server was launched with rails s or directly). Changed the behavior of exceptions to act the same as streaming templates for html requests, and allow for an on_error callback if needed.
2013-03-07 17:49:03 -05:00
response.stream.write params[:widget][:didnt_check_for_nil]
end
added live responses which can be written and read in separate threads
2012-07-29 20:26:07 -04:00
end
tests TestController
Exception handling for controllers using ActionController::Live Any exceptions that occured at the view or controller level for a controller using ActionController::Live would cause the server to either hang with an open socket indefinitely, or immediately crash (depending on whether the server was launched with rails s or directly). Changed the behavior of exceptions to act the same as streaming templates for html requests, and allow for an on_error callback if needed.
2013-03-07 17:49:03 -05:00
def assert_stream_closed
assert response.stream.closed?, 'stream should be closed'
use the body proxy to freeze headers avoid freezing the headers until the web server has actually read data from the body proxy. Once the webserver has read data, then we should throw an error if someone tries to set a header
2014-03-12 20:40:08 -04:00
assert response.sent?, 'stream should be sent'
Exception handling for controllers using ActionController::Live Any exceptions that occured at the view or controller level for a controller using ActionController::Live would cause the server to either hang with an open socket indefinitely, or immediately crash (depending on whether the server was launched with rails s or directly). Changed the behavior of exceptions to act the same as streaming templates for html requests, and allow for an on_error callback if needed.
2013-03-07 17:49:03 -05:00
end
def capture_log_output
output = StringIO.new
old_logger, ActionController::Base.logger = ActionController::Base.logger, ActiveSupport::Logger.new(output)
begin
yield output
ensure
ActionController::Base.logger = old_logger
end
end
only write the jar if the response isn't committed when streaming responses, we need to make sure the cookie jar is written to the headers before returning up the stack. This commit introduces a new method on the response object that writes the cookie jar to the headers as the response is committed. The middleware and test framework will not write the cookie headers if the response has already been committed. fixes #14352
2014-03-12 19:07:04 -04:00
def test_set_cookie
@controller = TestController.new
get :set_cookie
assert_equal({'hello' => 'world'}, @response.cookies)
assert_equal "hello world", @response.body
end
make sure set_response! sets the correct response object
2012-07-29 22:46:36 -04:00
def test_set_response!
@controller.set_response!(@request)
assert_kind_of(Live::Response, @controller.response)
assert_equal @request, @controller.response.request
end
added live responses which can be written and read in separate threads
2012-07-29 20:26:07 -04:00
def test_write_to_stream
Controller actions are processed in a separate thread for live responses. Processing controller actions in a separate thread allows us to work around the rack api - we can allow the user to set status and headers, then block until the first bytes are written. As soon as the first bytes are written, the main thread can return the status, headers, and (essentially) a queue for the body.
2012-07-29 22:23:19 -04:00
@controller = TestController.new
added live responses which can be written and read in separate threads
2012-07-29 20:26:07 -04:00
get :basic_stream
Controller actions are processed in a separate thread for live responses. Processing controller actions in a separate thread allows us to work around the rack api - we can allow the user to set status and headers, then block until the first bytes are written. As soon as the first bytes are written, the main thread can return the status, headers, and (essentially) a queue for the body.
2012-07-29 22:23:19 -04:00
assert_equal "helloworld", @response.body
assert_equal 'text/event-stream', @response.headers['Content-Type']
end
def test_async_stream
@controller.latch = ActiveSupport::Concurrency::Latch.new
parts = ['hello', 'world']
@controller.request = @request
@controller.response = @response
t = Thread.new(@response) { |resp|
use the body proxy to freeze headers avoid freezing the headers until the web server has actually read data from the body proxy. Once the webserver has read data, then we should throw an error if someone tries to set a header
2014-03-12 20:40:08 -04:00
resp.await_commit
Controller actions are processed in a separate thread for live responses. Processing controller actions in a separate thread allows us to work around the rack api - we can allow the user to set status and headers, then block until the first bytes are written. As soon as the first bytes are written, the main thread can return the status, headers, and (essentially) a queue for the body.
2012-07-29 22:23:19 -04:00
resp.stream.each do |part|
assert_equal parts.shift, part
ol = @controller.latch
@controller.latch = ActiveSupport::Concurrency::Latch.new
ol.release
end
}
@controller.process :blocking_stream
Add timeout to test_async_stream Without timeout: this test executed infinitely on JRuby Passes on MRI With Timeout: this test gracefully fails on JRuby Passes on MRI, tested on v2.0 & v1.9.3
2013-08-02 10:57:28 -04:00
assert t.join(3), 'timeout expired before the thread terminated'
Controller actions are processed in a separate thread for live responses. Processing controller actions in a separate thread allows us to work around the rack api - we can allow the user to set status and headers, then block until the first bytes are written. As soon as the first bytes are written, the main thread can return the status, headers, and (essentially) a queue for the body.
2012-07-29 22:23:19 -04:00
end
def test_thread_locals_get_copied
@controller.tc = self
Thread.current[:originating_thread] = Thread.current.object_id
Thread.current[:setting] = 'aaron'
get :thread_locals
added live responses which can be written and read in separate threads
2012-07-29 20:26:07 -04:00
end
header hash is duped before being sent up the rack stack
2012-07-29 23:26:40 -04:00
def test_live_stream_default_header
@controller.request = @request
@controller.response = @response
@controller.process :default_header
_, headers, _ = @response.prepare!
assert headers['Content-Type']
end
close the response when the response body is set so that normal render calls will work
2012-07-29 23:33:16 -04:00
def test_render_text
get :render_text
make sure the body finishes rendering before checking response closure
2012-08-02 18:04:36 -04:00
assert_equal 'zomg', response.body
Exception handling for controllers using ActionController::Live Any exceptions that occured at the view or controller level for a controller using ActionController::Live would cause the server to either hang with an open socket indefinitely, or immediately crash (depending on whether the server was launched with rails s or directly). Changed the behavior of exceptions to act the same as streaming templates for html requests, and allow for an on_error callback if needed.
2013-03-07 17:49:03 -05:00
assert_stream_closed
end
def test_exception_handling_html
use built-in exception handling in live controllers when an exception happens in an action before the response has been committed, then we should re-raise the exception in the main thread. This lets us reuse the existing exception handling.
2014-02-28 18:39:08 -05:00
assert_raises(ActionView::MissingTemplate) do
Exception handling for controllers using ActionController::Live Any exceptions that occured at the view or controller level for a controller using ActionController::Live would cause the server to either hang with an open socket indefinitely, or immediately crash (depending on whether the server was launched with rails s or directly). Changed the behavior of exceptions to act the same as streaming templates for html requests, and allow for an on_error callback if needed.
2013-03-07 17:49:03 -05:00
get :exception_in_view
end
re-raise error if error occurs before committing in streaming update the tests, using an if-else
2014-02-17 21:41:21 -05:00
capture_log_output do |output|
get :exception_in_view_after_commit
assert_match %r((window\.location = "/500\.html"</script></html>)$), response.body
assert_match 'Missing template test/doesntexist', output.rewind && output.read
assert_stream_closed
end
use the body proxy to freeze headers avoid freezing the headers until the web server has actually read data from the body proxy. Once the webserver has read data, then we should throw an error if someone tries to set a header
2014-03-12 20:40:08 -04:00
assert response.body
use built-in exception handling in live controllers when an exception happens in an action before the response has been committed, then we should re-raise the exception in the main thread. This lets us reuse the existing exception handling.
2014-02-28 18:39:08 -05:00
assert_stream_closed
Exception handling for controllers using ActionController::Live Any exceptions that occured at the view or controller level for a controller using ActionController::Live would cause the server to either hang with an open socket indefinitely, or immediately crash (depending on whether the server was launched with rails s or directly). Changed the behavior of exceptions to act the same as streaming templates for html requests, and allow for an on_error callback if needed.
2013-03-07 17:49:03 -05:00
end
def test_exception_handling_plain_text
use built-in exception handling in live controllers when an exception happens in an action before the response has been committed, then we should re-raise the exception in the main thread. This lets us reuse the existing exception handling.
2014-02-28 18:39:08 -05:00
assert_raises(ActionView::MissingTemplate) do
Exception handling for controllers using ActionController::Live Any exceptions that occured at the view or controller level for a controller using ActionController::Live would cause the server to either hang with an open socket indefinitely, or immediately crash (depending on whether the server was launched with rails s or directly). Changed the behavior of exceptions to act the same as streaming templates for html requests, and allow for an on_error callback if needed.
2013-03-07 17:49:03 -05:00
get :exception_in_view, format: :json
end
re-raise error if error occurs before committing in streaming update the tests, using an if-else
2014-02-17 21:41:21 -05:00
capture_log_output do |output|
get :exception_in_view_after_commit, format: :json
assert_equal '', response.body
assert_match 'Missing template test/doesntexist', output.rewind && output.read
assert_stream_closed
end
Exception handling for controllers using ActionController::Live Any exceptions that occured at the view or controller level for a controller using ActionController::Live would cause the server to either hang with an open socket indefinitely, or immediately crash (depending on whether the server was launched with rails s or directly). Changed the behavior of exceptions to act the same as streaming templates for html requests, and allow for an on_error callback if needed.
2013-03-07 17:49:03 -05:00
end
use built-in exception handling in live controllers when an exception happens in an action before the response has been committed, then we should re-raise the exception in the main thread. This lets us reuse the existing exception handling.
2014-02-28 18:39:08 -05:00
def test_exception_callback_when_committed
Exception handling for controllers using ActionController::Live Any exceptions that occured at the view or controller level for a controller using ActionController::Live would cause the server to either hang with an open socket indefinitely, or immediately crash (depending on whether the server was launched with rails s or directly). Changed the behavior of exceptions to act the same as streaming templates for html requests, and allow for an on_error callback if needed.
2013-03-07 17:49:03 -05:00
capture_log_output do |output|
get :exception_with_callback, format: 'text/event-stream'
assert_equal %(data: "500 Internal Server Error"\n\n), response.body
assert_match 'An exception occurred...', output.rewind && output.read
assert_stream_closed
end
end
Correct prestreaming controller response status. if the controller action has not yet streamed any data, actions should process as normal, and errors should trigger the appropriate behavior (500, or in the case of ActionController::BadRequest, a 400 Bad Request)
2014-02-15 16:05:00 -05:00
def test_exception_in_controller_before_streaming
use built-in exception handling in live controllers when an exception happens in an action before the response has been committed, then we should re-raise the exception in the main thread. This lets us reuse the existing exception handling.
2014-02-28 18:39:08 -05:00
assert_raises(ActionController::LiveStreamTest::Exception) do
get :exception_in_controller, format: 'text/event-stream'
end
Correct prestreaming controller response status. if the controller action has not yet streamed any data, actions should process as normal, and errors should trigger the appropriate behavior (500, or in the case of ActionController::BadRequest, a 400 Bad Request)
2014-02-15 16:05:00 -05:00
end
def test_bad_request_in_controller_before_streaming
use built-in exception handling in live controllers when an exception happens in an action before the response has been committed, then we should re-raise the exception in the main thread. This lets us reuse the existing exception handling.
2014-02-28 18:39:08 -05:00
assert_raises(ActionController::BadRequest) do
get :bad_request_error, format: 'text/event-stream'
end
Correct prestreaming controller response status. if the controller action has not yet streamed any data, actions should process as normal, and errors should trigger the appropriate behavior (500, or in the case of ActionController::BadRequest, a 400 Bad Request)
2014-02-15 16:05:00 -05:00
end
use built-in exception handling in live controllers when an exception happens in an action before the response has been committed, then we should re-raise the exception in the main thread. This lets us reuse the existing exception handling.
2014-02-28 18:39:08 -05:00
def test_exceptions_raised_handling_exceptions_and_committed
Exception handling for controllers using ActionController::Live Any exceptions that occured at the view or controller level for a controller using ActionController::Live would cause the server to either hang with an open socket indefinitely, or immediately crash (depending on whether the server was launched with rails s or directly). Changed the behavior of exceptions to act the same as streaming templates for html requests, and allow for an on_error callback if needed.
2013-03-07 17:49:03 -05:00
capture_log_output do |output|
get :exception_in_exception_callback, format: 'text/event-stream'
assert_equal '', response.body
assert_match 'We need to go deeper', output.rewind && output.read
assert_stream_closed
end
close the response when the response body is set so that normal render calls will work
2012-07-29 23:33:16 -04:00
end
Handle conditional get in live requests - this will prevent error when using stale on live streams(issue #9636)
2013-03-14 04:13:10 -04:00
def test_stale_without_etag
get :with_stale
assert_equal 200, @response.status.to_i
end
def test_stale_with_etag
@request.if_none_match = Digest::MD5.hexdigest("123")
get :with_stale
assert_equal 304, @response.status.to_i
end
added live responses which can be written and read in separate threads
2012-07-29 20:26:07 -04:00
end
set the error callback to a nice default in case nobody set an error callback and an error happens
2014-02-28 14:57:15 -05:00
class BufferTest < ActionController::TestCase
def test_nil_callback
buf = ActionController::Live::Buffer.new nil
assert buf.call_on_error
end
end
added live responses which can be written and read in separate threads
2012-07-29 20:26:07 -04:00
end
Copy permalink