class ReloaderTest

Public Instance Methods

test_class_unload_block() click to toggle source
# File activesupport/test/reloader_test.rb, line 74
def test_class_unload_block
  called = []
  reloader.before_class_unload { called << :before_unload }
  reloader.after_class_unload { called << :after_unload }
  reloader.to_run do
    class_unload! do
      called << :unload
    end
  end
  reloader.wrap { called << :body }

  assert_equal [:before_unload, :unload, :after_unload, :body], called
end
test_complete_callbacks_are_called_on_exceptions() click to toggle source
# File actionpack/test/dispatch/reloader_test.rb, line 135
def test_complete_callbacks_are_called_on_exceptions
  completed = false
  reloader.to_complete { completed = true }

  begin
    call_and_return_body do
      raise "error"
    end
  rescue
  end

  assert completed
end
test_complete_callbacks_are_called_when_body_is_closed() click to toggle source
# File actionpack/test/dispatch/reloader_test.rb, line 113
def test_complete_callbacks_are_called_when_body_is_closed
  completed = false
  reloader.to_complete { completed = true }

  body = call_and_return_body
  assert !completed

  body.close
  assert completed
end
test_condition_specifies_when_to_reload() click to toggle source
# File actionpack/test/dispatch/reloader_test.rb, line 61
def test_condition_specifies_when_to_reload
  i, j = 0, 0, 0, 0

  reloader = reloader(lambda { i < 3 })
  reloader.to_prepare { |*args| i += 1 }
  reloader.to_complete { |*args| j += 1 }

  app = middleware(lambda { |env| [200, {}, []] }, reloader)
  5.times do
    resp = app.call({})
    resp[2].close
  end
  assert_equal 3, i
  assert_equal 3, j
end
test_full_reload_sequence() click to toggle source
# File activesupport/test/reloader_test.rb, line 48
def test_full_reload_sequence
  called = []
  reloader.to_prepare { called << :prepare }
  reloader.to_run { called << :reloader_run }
  reloader.to_complete { called << :reloader_complete }
  reloader.executor.to_run { called << :executor_run }
  reloader.executor.to_complete { called << :executor_complete }

  reloader.wrap {}
  assert_equal [:executor_run, :reloader_run, :prepare, :reloader_complete, :executor_complete], called

  called = []
  reloader.reload!
  assert_equal [:executor_run, :reloader_run, :prepare, :reloader_complete, :executor_complete, :prepare], called

  reloader.check = lambda { false }

  called = []
  reloader.wrap {}
  assert_equal [:executor_run, :executor_complete], called

  called = []
  reloader.reload!
  assert_equal [:executor_run, :reloader_run, :prepare, :reloader_complete, :executor_complete, :prepare], called
end
test_it_calls_close_on_underlying_object_when_close_is_called_on_body() click to toggle source
# File actionpack/test/dispatch/reloader_test.rb, line 91
def test_it_calls_close_on_underlying_object_when_close_is_called_on_body
  close_called = false
  body = call_and_return_body do
    b = MyBody.new do
      close_called = true
    end
    [200, { "Content-Type" => "text/html" }, b]
  end
  body.close
  assert close_called
end
test_only_run_when_check_passes() click to toggle source
# File activesupport/test/reloader_test.rb, line 34
def test_only_run_when_check_passes
  r = new_reloader { true }
  invoked = false
  r.to_run { invoked = true }
  r.wrap {}
  assert invoked

  r = new_reloader { false }
  invoked = false
  r.to_run { invoked = true }
  r.wrap {}
  assert !invoked
end
test_prepare_callback() click to toggle source
# File activesupport/test/reloader_test.rb, line 6
def test_prepare_callback
  prepared = completed = false
  reloader.to_prepare { prepared = true }
  reloader.to_complete { completed = true }

  assert !prepared
  assert !completed
  reloader.prepare!
  assert prepared
  assert !completed

  prepared = false
  reloader.wrap do
    assert prepared
    prepared = false
  end
  assert !prepared
end
test_prepare_callbacks() click to toggle source
# File actionpack/test/dispatch/reloader_test.rb, line 29
def test_prepare_callbacks
  a = b = c = nil
  reloader.to_prepare { |*args| a = b = c = 1 }
  reloader.to_prepare { |*args| b = c = 2 }
  reloader.to_prepare { |*args| c = 3 }

  # Ensure to_prepare callbacks are not run when defined
  assert_nil a || b || c

  # Run callbacks
  call_and_return_body

  assert_equal 1, a
  assert_equal 2, b
  assert_equal 3, c
end
test_prepare_callbacks_arent_called_when_body_is_closed() click to toggle source
# File actionpack/test/dispatch/reloader_test.rb, line 124
def test_prepare_callbacks_arent_called_when_body_is_closed
  prepared = false
  reloader.to_prepare { prepared = true }

  body = call_and_return_body
  prepared = false

  body.close
  assert !prepared
end
test_prepend_prepare_callback() click to toggle source
# File activesupport/test/reloader_test.rb, line 25
def test_prepend_prepare_callback
  i = 10
  reloader.to_prepare { i += 1 }
  reloader.to_prepare(prepend: true) { i = 0 }

  reloader.prepare!
  assert_equal 1, i
end
test_returned_body_object_always_responds_to_close() click to toggle source
# File actionpack/test/dispatch/reloader_test.rb, line 46
def test_returned_body_object_always_responds_to_close
  body = call_and_return_body
  assert_respond_to body, :close
end
test_returned_body_object_always_responds_to_close_even_if_called_twice() click to toggle source
# File actionpack/test/dispatch/reloader_test.rb, line 51
def test_returned_body_object_always_responds_to_close_even_if_called_twice
  body = call_and_return_body
  assert_respond_to body, :close
  body.close

  body = call_and_return_body
  assert_respond_to body, :close
  body.close
end
test_returned_body_object_behaves_like_underlying_object() click to toggle source
# File actionpack/test/dispatch/reloader_test.rb, line 77
def test_returned_body_object_behaves_like_underlying_object
  body = call_and_return_body 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
test_returned_body_object_responds_to_all_methods_supported_by_underlying_object() click to toggle source
# File actionpack/test/dispatch/reloader_test.rb, line 103
def test_returned_body_object_responds_to_all_methods_supported_by_underlying_object
  body = call_and_return_body do
    [200, { "Content-Type" => "text/html" }, MyBody.new]
  end
  assert_respond_to body, :size
  assert_respond_to body, :each
  assert_respond_to body, :foo
  assert_respond_to body, :bar
end

Private Instance Methods

call_and_return_body(&block) click to toggle source
# File actionpack/test/dispatch/reloader_test.rb, line 150
def call_and_return_body(&block)
  app = middleware(block || proc { [200, {}, "response"] })
  _, _, body = app.call("rack.input" => StringIO.new(""))
  body
end
middleware(inner_app, reloader = reloader()) click to toggle source
# File actionpack/test/dispatch/reloader_test.rb, line 156
def middleware(inner_app, reloader = reloader())
  ActionDispatch::Reloader.new(inner_app, reloader)
end
new_reloader(&check) click to toggle source
# File activesupport/test/reloader_test.rb, line 89
def new_reloader(&check)
  Class.new(ActiveSupport::Reloader).tap do |r|
    r.check = check
    r.executor = Class.new(ActiveSupport::Executor)
  end
end
reloader(check = lambda { true }) click to toggle source
# File actionpack/test/dispatch/reloader_test.rb, line 160
def reloader(check = lambda { true })
  @reloader ||= begin
                  reloader = Class.new(ActiveSupport::Reloader)
                  reloader.check = check
                  reloader
                end
end