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

516 lines
14 KiB
Ruby
Raw Normal View History

applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
require "abstract_unit"
require "concurrent/atomic/count_down_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
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
response.headers["Content-Type"] = "text/event-stream"
Creating an SSE class to be used with ActionController::Live.
2013-07-14 18:48:57 -04:00
sse = SSE.new(response.stream)
sse.write("{\"name\":\"John\"}")
remove redundant curlies from hash arguments
2016-08-06 13:44:11 -04:00
sse.write(name: "Ryan")
Creating an SSE class to be used with ActionController::Live.
2013-07-14 18:48:57 -04:00
ensure
sse.close
end
def sse_with_event
sse = SSE.new(response.stream, event: "send-name")
sse.write("{\"name\":\"John\"}")
remove redundant curlies from hash arguments
2016-08-06 13:44:11 -04:00
sse.write(name: "Ryan")
Creating an SSE class to be used with ActionController::Live.
2013-07-14 18:48:57 -04:00
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
Add multiple lines message support for SSE module
2014-05-12 11:44:26 -04:00
def sse_with_multiple_line_message
sse = SSE.new(response.stream)
sse.write("first line.\nsecond line.")
ensure
sse.close
end
Creating an SSE class to be used with ActionController::Live.
2013-07-14 18:48:57 -04:00
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
Add multiple lines message support for SSE module
2014-05-12 11:44:26 -04:00
def test_sse_with_multiple_line_message
get :sse_with_multiple_line_message
wait_for_response_stream_close
first_response, second_response = response.body.split("\n")
assert_match(/data: first line/, first_response)
assert_match(/data: second line/, second_response)
end
Creating an SSE class to be used with ActionController::Live.
2013-07-14 18:48:57 -04:00
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
stop directly referencing the request and response objects
2015-09-23 19:40:56 -04:00
attr_accessor :latch, :tc, :error_latch
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
added live responses which can be written and read in separate threads
2012-07-29 20:26:07 -04:00
def self.controller_path
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
"test"
added live responses which can be written and read in separate threads
2012-07-29 20:26:07 -04:00
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
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
render plain: "zomg"
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
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
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
response.headers["Content-Type"] = "text/event-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
%w{ hello world }.each do |word|
response.stream.write word
end
response.stream.close
end
def blocking_stream
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
response.headers["Content-Type"] = "text/event-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
%w{ hello world }.each do |word|
response.stream.write word
Replaced `ActiveSupport::Concurrency::Latch` with concurrent-ruby. The concurrent-ruby gem is a toolset containing many concurrency utilities. Many of these utilities include runtime-specific optimizations when possible. Rather than clutter the Rails codebase with concurrency utilities separate from the core task, such tools can be superseded by similar tools in the more specialized gem. This commit replaces `ActiveSupport::Concurrency::Latch` with `Concurrent::CountDownLatch`, which is functionally equivalent.
2015-07-13 14:22:54 -04:00
latch.wait
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
response.stream.close
end
Fix deadlock that can occur when child live thread tries to load a constant after writing to the stream.
2016-08-15 17:08:46 -04:00
def write_sleep_autoload
path = File.join(File.dirname(__FILE__), "../fixtures")
ActiveSupport::Dependencies.autoload_paths << path
response.headers["Content-Type"] = "text/event-stream"
response.stream.write "before load"
sleep 0.01
Silence a warning
2016-10-07 15:21:48 -04:00
silence_warning do
::LoadMe
end
Fix deadlock that can occur when child live thread tries to load a constant after writing to the stream.
2016-08-15 17:08:46 -04:00
response.stream.close
latch.count_down
Add three new rubocop rules Style/SpaceBeforeBlockBraces Style/SpaceInsideBlockBraces Style/SpaceInsideHashLiteralBraces Fix all violations in the repository.
2016-08-16 03:30:11 -04:00
ActiveSupport::Dependencies.autoload_paths.reject! { |p| p == path }
Fix deadlock that can occur when child live thread tries to load a constant after writing to the stream.
2016-08-15 17:08:46 -04:00
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
def thread_locals
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
tc.assert_equal "aaron", Thread.current[:setting]
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
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -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
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
render plain: "stale" if stale?(etag: "123", template: false)
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
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
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
render "doesntexist"
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
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 ""
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
render "doesntexist"
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
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
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
response.headers["Content-Type"] = "text/event-stream"
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.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
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
raise "An exception occurred..."
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
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
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04: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
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
response.headers["Content-Type"] = "text/event-stream"
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.on_error do
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
raise "We need to go deeper."
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
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04: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
Handle client disconnect during live streaming .. even when the producer is blocked for a write.
2014-05-31 21:05:00 -04:00
def overfill_buffer_and_die
stop directly referencing the request and response objects
2015-09-23 19:40:56 -04:00
logger = ActionController::Base.logger || Logger.new($stdout)
response.stream.on_error do
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
logger.warn "Error while streaming."
stop directly referencing the request and response objects
2015-09-23 19:40:56 -04:00
error_latch.count_down
end
Handle client disconnect during live streaming .. even when the producer is blocked for a write.
2014-05-31 21:05:00 -04:00
# Write until the buffer is full. It doesn't expose that
# information directly, so we must hard-code its size:
10.times do
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
response.stream.write "."
Handle client disconnect during live streaming .. even when the producer is blocked for a write.
2014-05-31 21:05:00 -04:00
end
# .. plus one more, because the #each frees up a slot:
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
response.stream.write "."
Handle client disconnect during live streaming .. even when the producer is blocked for a write.
2014-05-31 21:05:00 -04:00
Replaced `ActiveSupport::Concurrency::Latch` with concurrent-ruby. The concurrent-ruby gem is a toolset containing many concurrency utilities. Many of these utilities include runtime-specific optimizations when possible. Rather than clutter the Rails codebase with concurrency utilities separate from the core task, such tools can be superseded by similar tools in the more specialized gem. This commit replaces `ActiveSupport::Concurrency::Latch` with `Concurrent::CountDownLatch`, which is functionally equivalent.
2015-07-13 14:22:54 -04:00
latch.count_down
Handle client disconnect during live streaming .. even when the producer is blocked for a write.
2014-05-31 21:05:00 -04:00
# This write will block, and eventually raise
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
response.stream.write "x"
Handle client disconnect during live streaming .. even when the producer is blocked for a write.
2014-05-31 21:05:00 -04:00
20.times do
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
response.stream.write "."
Handle client disconnect during live streaming .. even when the producer is blocked for a write.
2014-05-31 21:05:00 -04:00
end
end
def ignore_client_disconnect
response.stream.ignore_disconnect = true
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
response.stream.write "" # commit
Handle client disconnect during live streaming .. even when the producer is blocked for a write.
2014-05-31 21:05:00 -04:00
# These writes will be ignored
15.times do
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
response.stream.write "x"
Handle client disconnect during live streaming .. even when the producer is blocked for a write.
2014-05-31 21:05:00 -04:00
end
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
logger.info "Work complete"
Replaced `ActiveSupport::Concurrency::Latch` with concurrent-ruby. The concurrent-ruby gem is a toolset containing many concurrency utilities. Many of these utilities include runtime-specific optimizations when possible. Rather than clutter the Rails codebase with concurrency utilities separate from the core task, such tools can be superseded by similar tools in the more specialized gem. This commit replaces `ActiveSupport::Concurrency::Latch` with `Concurrent::CountDownLatch`, which is functionally equivalent.
2015-07-13 14:22:54 -04:00
latch.count_down
Handle client disconnect during live streaming .. even when the producer is blocked for a write.
2014-05-31 21:05:00 -04:00
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
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
assert response.stream.closed?, "stream should be closed"
assert response.committed?, "response should be committed"
assert response.sent?, "response 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
disable controller / view thread spawning in tests Tests can (and do) access the database from the main thread. In this case they were starting a transaction, then making a request. The request would create a new thread, which would allocate a new database connection. Since the main thread started a transaction that contains data that the new thread wants to see, the new thread would not see it due to data visibility from transactions. Spawning the new thread in production is fine because middleware should not be doing database manipulation similar to the test harness. Before 603fe20c it was possible to set the database connection id based on a thread local, but 603fe20c changes the connection lookup code to never look at the "connection id" but only at the thread object itself. Without that indirection, we can't force threads to use the same connection pool as another thread. Fixes #23483
2016-02-05 14:42:06 -05:00
def setup
super
def @controller.new_controller_thread
Thread.new { yield }
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
get :set_cookie
Add three new rubocop rules Style/SpaceBeforeBlockBraces Style/SpaceInsideBlockBraces Style/SpaceInsideHashLiteralBraces Fix all violations in the repository.
2016-08-16 03:30:11 -04:00
assert_equal({ "hello" => "world" }, @response.cookies)
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
assert_equal "hello world", @response.body
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
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
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
assert_equal "text/event-stream", @response.headers["Content-Type"]
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
Fix deadlock that can occur when child live thread tries to load a constant after writing to the stream.
2016-08-15 17:08:46 -04:00
def test_delayed_autoload_after_write_within_interlock_hook
# Simulate InterlockHook
ActiveSupport::Dependencies.interlock.start_running
res = get :write_sleep_autoload
res.each {}
ActiveSupport::Dependencies.interlock.done_running
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
def test_async_stream
Skip the failing tests on Rubinius for now
2015-03-02 11:14:45 -05:00
rubinius_skip "https://github.com/rubinius/rubinius/issues/2934"
Replaced `ActiveSupport::Concurrency::Latch` with concurrent-ruby. The concurrent-ruby gem is a toolset containing many concurrency utilities. Many of these utilities include runtime-specific optimizations when possible. Rather than clutter the Rails codebase with concurrency utilities separate from the core task, such tools can be superseded by similar tools in the more specialized gem. This commit replaces `ActiveSupport::Concurrency::Latch` with `Concurrent::CountDownLatch`, which is functionally equivalent.
2015-07-13 14:22:54 -04:00
@controller.latch = Concurrent::CountDownLatch.new
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
parts = ["hello", "world"]
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
don't touch the response object until after we call `get`
2015-09-23 18:59:32 -04:00
get :blocking_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
don't touch the response object until after we call `get`
2015-09-23 18:59:32 -04:00
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
Replaced `ActiveSupport::Concurrency::Latch` with concurrent-ruby. The concurrent-ruby gem is a toolset containing many concurrency utilities. Many of these utilities include runtime-specific optimizations when possible. Rather than clutter the Rails codebase with concurrency utilities separate from the core task, such tools can be superseded by similar tools in the more specialized gem. This commit replaces `ActiveSupport::Concurrency::Latch` with `Concurrent::CountDownLatch`, which is functionally equivalent.
2015-07-13 14:22:54 -04:00
@controller.latch = Concurrent::CountDownLatch.new
ol.count_down
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
}
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -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
Handle client disconnect during live streaming .. even when the producer is blocked for a write.
2014-05-31 21:05:00 -04:00
def test_abort_with_full_buffer
Replaced `ActiveSupport::Concurrency::Latch` with concurrent-ruby. The concurrent-ruby gem is a toolset containing many concurrency utilities. Many of these utilities include runtime-specific optimizations when possible. Rather than clutter the Rails codebase with concurrency utilities separate from the core task, such tools can be superseded by similar tools in the more specialized gem. This commit replaces `ActiveSupport::Concurrency::Latch` with `Concurrent::CountDownLatch`, which is functionally equivalent.
2015-07-13 14:22:54 -04:00
@controller.latch = Concurrent::CountDownLatch.new
stop directly referencing the request and response objects
2015-09-23 19:40:56 -04:00
@controller.error_latch = Concurrent::CountDownLatch.new
Handle client disconnect during live streaming .. even when the producer is blocked for a write.
2014-05-31 21:05:00 -04:00
capture_log_output do |output|
modernizes hash syntax in actionpack
2016-08-06 13:35:13 -04:00
get :overfill_buffer_and_die, format: "plain"
stop directly referencing the request and response objects
2015-09-23 19:40:56 -04:00
t = Thread.new(response) { |resp|
resp.await_commit
_, _, body = resp.to_a
body.each do
@controller.latch.wait
body.close
break
end
}
Handle client disconnect during live streaming .. even when the producer is blocked for a write.
2014-05-31 21:05:00 -04:00
t.join
stop directly referencing the request and response objects
2015-09-23 19:40:56 -04:00
@controller.error_latch.wait
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
assert_match "Error while streaming", output.rewind && output.read
Handle client disconnect during live streaming .. even when the producer is blocked for a write.
2014-05-31 21:05:00 -04:00
end
end
def test_ignore_client_disconnect
Replaced `ActiveSupport::Concurrency::Latch` with concurrent-ruby. The concurrent-ruby gem is a toolset containing many concurrency utilities. Many of these utilities include runtime-specific optimizations when possible. Rather than clutter the Rails codebase with concurrency utilities separate from the core task, such tools can be superseded by similar tools in the more specialized gem. This commit replaces `ActiveSupport::Concurrency::Latch` with `Concurrent::CountDownLatch`, which is functionally equivalent.
2015-07-13 14:22:54 -04:00
@controller.latch = Concurrent::CountDownLatch.new
Handle client disconnect during live streaming .. even when the producer is blocked for a write.
2014-05-31 21:05:00 -04:00
call `get` instead of controller.process we want the request to go through the test harness, not directly call the methods on the controller
2015-09-23 19:44:00 -04:00
capture_log_output do |output|
get :ignore_client_disconnect
Handle client disconnect during live streaming .. even when the producer is blocked for a write.
2014-05-31 21:05:00 -04:00
call `get` instead of controller.process we want the request to go through the test harness, not directly call the methods on the controller
2015-09-23 19:44:00 -04:00
t = Thread.new(response) { |resp|
resp.await_commit
_, _, body = resp.to_a
body.each do
body.close
break
end
}
Handle client disconnect during live streaming .. even when the producer is blocked for a write.
2014-05-31 21:05:00 -04:00
t.join
Timeout.timeout(3) do
Replaced `ActiveSupport::Concurrency::Latch` with concurrent-ruby. The concurrent-ruby gem is a toolset containing many concurrency utilities. Many of these utilities include runtime-specific optimizations when possible. Rather than clutter the Rails codebase with concurrency utilities separate from the core task, such tools can be superseded by similar tools in the more specialized gem. This commit replaces `ActiveSupport::Concurrency::Latch` with `Concurrent::CountDownLatch`, which is functionally equivalent.
2015-07-13 14:22:54 -04:00
@controller.latch.wait
Handle client disconnect during live streaming .. even when the producer is blocked for a write.
2014-05-31 21:05:00 -04:00
end
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
assert_match "Work complete", output.rewind && output.read
Handle client disconnect during live streaming .. even when the producer is blocked for a write.
2014-05-31 21:05:00 -04:00
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
def test_thread_locals_get_copied
@controller.tc = self
Thread.current[:originating_thread] = Thread.current.object_id
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
Thread.current[:setting] = "aaron"
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
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
remove controller construction also remove req / res references
2015-09-23 19:42:15 -04:00
get :default_header
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
assert response.headers["Content-Type"]
header hash is duped before being sent up the rack stack
2012-07-29 23:26:40 -04:00
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
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -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
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
assert_match "Missing template test/doesntexist", output.rewind && output.read
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
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
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
assert_equal "", response.body
assert_match "Missing template test/doesntexist", output.rewind && output.read
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
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
FIX: Randomly failing test when running without GIL.
2015-10-23 02:33:33 -04:00
current_threads = Thread.list
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|
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
get :exception_with_callback, format: "text/event-stream"
FIX: Randomly failing test when running without GIL.
2015-10-23 02:33:33 -04:00
# Wait on the execution of all threads
(Thread.list - current_threads).each(&:join)
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_equal %(data: "500 Internal Server Error"\n\n), response.body
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
assert_match "An exception occurred...", output.rewind && output.read
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
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
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
get :exception_in_controller, format: "text/event-stream"
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
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
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
get :bad_request_error, format: "text/event-stream"
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
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|
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
get :exception_in_exception_callback, format: "text/event-stream"
assert_equal "", response.body
assert_match "We need to go deeper", output.rewind && output.read
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
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
remove controller construction also remove req / res references
2015-09-23 19:42:15 -04:00
assert_equal 200, response.status.to_i
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
end
def test_stale_with_etag
Response etags to always be weak: Prefixed W/ to value returned by ActionDispatch::Http::Cache::Response#etag= such that etags set in fresh_when and stale? are weak. For #17556.
2014-11-10 00:23:31 -05:00
@request.if_none_match = %(W/"#{Digest::MD5.hexdigest('123')}")
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
get :with_stale
remove controller construction also remove req / res references
2015-09-23 19:42:15 -04:00
assert_equal 304, response.status.to_i
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
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
Fix `make_response!` when called by `serve` in `RouteSet` All of our tests were testing the `ActionController::Live` behavior in a standalone environment, without going through the router or behaving like a real application. This resulted in `ActionController::Live` throwing the exception `undefined method 'request' for #<ActionDispatch::Request:0x00000003ad1148>` because `make_response!` was expecting a response instead of a request. The expectation of a response came from `set_response!` in non-router tests setting the response and passing it to `make_response!`. In the case of an application we would hit `serve` in `RouteSet` first which would send us to `make_response!` with a request sent instead of a response. The changes here remove `set_response!` so `make_response!` always receives a request. Thanks to KalabiYau for help with the investigation and solution. Fixes #22524 [Eileen M. Uchitelle & KalabiYau]
2015-12-09 07:51:02 -05:00
class LiveStreamRouterTest < ActionDispatch::IntegrationTest
class TestController < ActionController::Base
include ActionController::Live
def index
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
response.headers["Content-Type"] = "text/event-stream"
Fix `make_response!` when called by `serve` in `RouteSet` All of our tests were testing the `ActionController::Live` behavior in a standalone environment, without going through the router or behaving like a real application. This resulted in `ActionController::Live` throwing the exception `undefined method 'request' for #<ActionDispatch::Request:0x00000003ad1148>` because `make_response!` was expecting a response instead of a request. The expectation of a response came from `set_response!` in non-router tests setting the response and passing it to `make_response!`. In the case of an application we would hit `serve` in `RouteSet` first which would send us to `make_response!` with a request sent instead of a response. The changes here remove `set_response!` so `make_response!` always receives a request. Thanks to KalabiYau for help with the investigation and solution. Fixes #22524 [Eileen M. Uchitelle & KalabiYau]
2015-12-09 07:51:02 -05:00
sse = SSE.new(response.stream)
sse.write("{\"name\":\"John\"}")
remove redundant curlies from hash arguments
2016-08-06 13:44:11 -04:00
sse.write(name: "Ryan")
Fix `make_response!` when called by `serve` in `RouteSet` All of our tests were testing the `ActionController::Live` behavior in a standalone environment, without going through the router or behaving like a real application. This resulted in `ActionController::Live` throwing the exception `undefined method 'request' for #<ActionDispatch::Request:0x00000003ad1148>` because `make_response!` was expecting a response instead of a request. The expectation of a response came from `set_response!` in non-router tests setting the response and passing it to `make_response!`. In the case of an application we would hit `serve` in `RouteSet` first which would send us to `make_response!` with a request sent instead of a response. The changes here remove `set_response!` so `make_response!` always receives a request. Thanks to KalabiYau for help with the investigation and solution. Fixes #22524 [Eileen M. Uchitelle & KalabiYau]
2015-12-09 07:51:02 -05:00
ensure
sse.close
end
end
def self.call(env)
routes.call(env)
end
def self.routes
@routes ||= ActionDispatch::Routing::RouteSet.new
end
routes.draw do
applies new string literal convention in actionpack/test The current code base is not uniform. After some discussion, we have chosen to go with double quotes by default.
2016-08-06 12:54:50 -04:00
get "/test" => "live_stream_router_test/test#index"
Fix `make_response!` when called by `serve` in `RouteSet` All of our tests were testing the `ActionController::Live` behavior in a standalone environment, without going through the router or behaving like a real application. This resulted in `ActionController::Live` throwing the exception `undefined method 'request' for #<ActionDispatch::Request:0x00000003ad1148>` because `make_response!` was expecting a response instead of a request. The expectation of a response came from `set_response!` in non-router tests setting the response and passing it to `make_response!`. In the case of an application we would hit `serve` in `RouteSet` first which would send us to `make_response!` with a request sent instead of a response. The changes here remove `set_response!` so `make_response!` always receives a request. Thanks to KalabiYau for help with the investigation and solution. Fixes #22524 [Eileen M. Uchitelle & KalabiYau]
2015-12-09 07:51:02 -05:00
end
def app
self.class
end
test "streaming served through the router" do
get "/test"
assert_response :ok
assert_match(/data: {\"name\":\"John\"}/, response.body)
assert_match(/data: {\"name\":\"Ryan\"}/, response.body)
end
end
Copy permalink