class ExecutorTest

Public Instance Methods

test_avoids_double_wrapping() click to toggle source
# File activesupport/test/executor_test.rb, line 57
def test_avoids_double_wrapping
  called = []
  executor.to_run { called << :run }
  executor.to_complete { called << :complete }

  executor.wrap do
    called << :early
    executor.wrap do
      called << :body
    end
    called << :late
  end

  assert_equal [:run, :early, :body, :late, :complete], called
end
test_callbacks_execute_in_shared_context() click to toggle source
# File actionpack/test/dispatch/executor_test.rb, line 112
def test_callbacks_execute_in_shared_context
  result = false
  executor.to_run { @in_shared_context = true }
  executor.to_complete { result = @in_shared_context }

  call_and_return_body.close
  assert result
  assert !defined?(@in_shared_context) # it's not in the test itself
end
test_callbacks_share_state() click to toggle source
# File activesupport/test/executor_test.rb, line 21
def test_callbacks_share_state
  result = false
  executor.to_run { @foo = true }
  executor.to_complete { result = @foo }

  executor.wrap {}

  assert result
end
test_class_serial_is_unaffected() click to toggle source
# File activesupport/test/executor_test.rb, line 196
def test_class_serial_is_unaffected
  skip if !defined?(RubyVM)

  hook = Class.new do
    define_method(:run) do
      nil
    end

    define_method(:complete) do |state|
      nil
    end
  end.new

  executor.register_hook(hook)

  before = RubyVM.stat(:class_serial)
  executor.wrap {}
  executor.wrap {}
  executor.wrap {}
  after = RubyVM.stat(:class_serial)

  assert_equal before, after
end
test_complete_callbacks_are_called_on_close() click to toggle source
# File actionpack/test/dispatch/executor_test.rb, line 87
def test_complete_callbacks_are_called_on_close
  completed = false
  executor.to_complete { completed = true }

  body = call_and_return_body
  assert !completed

  body.close
  assert completed
end
test_complete_callbacks_are_called_on_exceptions() click to toggle source
# File actionpack/test/dispatch/executor_test.rb, line 98
def test_complete_callbacks_are_called_on_exceptions
  completed = false
  executor.to_complete { completed = true }

  begin
    call_and_return_body do
      raise "error"
    end
  rescue
  end

  assert completed
end
test_exception_skips_uninvoked_hook() click to toggle source
# File activesupport/test/executor_test.rb, line 113
def test_exception_skips_uninvoked_hook
  supplied_state = :none

  hook = Class.new do
    define_method(:run) do
      :some_state
    end

    define_method(:complete) do |state|
      supplied_state = state
    end
  end.new

  executor.to_run do
    raise DummyError
  end
  executor.register_hook(hook)

  assert_raises(DummyError) do
    executor.wrap {}
  end

  assert_equal :none, supplied_state
end
test_exception_unwinds_invoked_hook() click to toggle source
# File activesupport/test/executor_test.rb, line 138
def test_exception_unwinds_invoked_hook
  supplied_state = :none

  hook = Class.new do
    define_method(:run) do
      :some_state
    end

    define_method(:complete) do |state|
      supplied_state = state
    end
  end.new

  executor.register_hook(hook)
  executor.to_run do
    raise DummyError
  end

  assert_raises(DummyError) do
    executor.wrap {}
  end

  assert_equal :some_state, supplied_state
end
test_exceptions_unwind() click to toggle source
# File activesupport/test/executor_test.rb, line 43
def test_exceptions_unwind
  called = []
  executor.to_run { called << :run_1 }
  executor.to_run { raise DummyError }
  executor.to_run { called << :run_2 }
  executor.to_complete { called << :complete }

  assert_raises(DummyError) do
    executor.wrap { called << :body }
  end

  assert_equal [:run_1, :complete], called
end
test_hook_insertion_order() click to toggle source
# File activesupport/test/executor_test.rb, line 163
def test_hook_insertion_order
  invoked = []
  supplied_state = []

  hook_class = Class.new do
    attr_accessor :letter

    define_method(:initialize) do |letter|
      self.letter = letter
    end

    define_method(:run) do
      invoked << :"run_#{letter}"
      :"state_#{letter}"
    end

    define_method(:complete) do |state|
      invoked << :"complete_#{letter}"
      supplied_state << state
    end
  end

  executor.register_hook(hook_class.new(:a))
  executor.register_hook(hook_class.new(:b))
  executor.register_hook(hook_class.new(:c), outer: true)
  executor.register_hook(hook_class.new(:d))

  executor.wrap {}

  assert_equal [:run_c, :run_a, :run_b, :run_d, :complete_a, :complete_b, :complete_d, :complete_c], invoked
  assert_equal [:state_a, :state_b, :state_d, :state_c], supplied_state
end
test_hooks_carry_state() click to toggle source
# File activesupport/test/executor_test.rb, line 73
def test_hooks_carry_state
  supplied_state = :none

  hook = Class.new do
    define_method(:run) do
      :some_state
    end

    define_method(:complete) do |state|
      supplied_state = state
    end
  end.new

  executor.register_hook(hook)

  executor.wrap {}

  assert_equal :some_state, supplied_state
end
test_it_calls_close_on_underlying_object_when_close_is_called_on_body() click to toggle source
# File actionpack/test/dispatch/executor_test.rb, line 53
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_nil_state_is_sufficient() click to toggle source
# File activesupport/test/executor_test.rb, line 93
def test_nil_state_is_sufficient
  supplied_state = :none

  hook = Class.new do
    define_method(:run) do
      nil
    end

    define_method(:complete) do |state|
      supplied_state = state
    end
  end.new

  executor.register_hook(hook)

  executor.wrap {}

  assert_nil supplied_state
end
test_returned_body_object_always_responds_to_close() click to toggle source
# File actionpack/test/dispatch/executor_test.rb, line 24
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/executor_test.rb, line 29
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/executor_test.rb, line 39
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/executor_test.rb, line 65
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
test_run_callbacks_are_called_before_close() click to toggle source
# File actionpack/test/dispatch/executor_test.rb, line 75
def test_run_callbacks_are_called_before_close
  running = false
  executor.to_run { running = true }

  body = call_and_return_body
  assert running

  running = false
  body.close
  assert !running
end
test_separate_classes_can_wrap() click to toggle source
# File activesupport/test/executor_test.rb, line 220
def test_separate_classes_can_wrap
  other_executor = Class.new(ActiveSupport::Executor)

  called = []
  executor.to_run { called << :run }
  executor.to_complete { called << :complete }
  other_executor.to_run { called << :other_run }
  other_executor.to_complete { called << :other_complete }

  executor.wrap do
    other_executor.wrap do
      called << :body
    end
  end

  assert_equal [:run, :other_run, :body, :other_complete, :complete], called
end
test_separated_calls_invoke_callbacks() click to toggle source
# File activesupport/test/executor_test.rb, line 31
def test_separated_calls_invoke_callbacks
  called = []
  executor.to_run { called << :run }
  executor.to_complete { called << :complete }

  state = executor.run!
  called << :body
  state.complete!

  assert_equal [:run, :body, :complete], called
end
test_wrap_invokes_callbacks() click to toggle source
# File activesupport/test/executor_test.rb, line 9
def test_wrap_invokes_callbacks
  called = []
  executor.to_run { called << :run }
  executor.to_complete { called << :complete }

  executor.wrap do
    called << :body
  end

  assert_equal [:run, :body, :complete], called
end

Private Instance Methods

call_and_return_body(&block) click to toggle source
# File actionpack/test/dispatch/executor_test.rb, line 123
def call_and_return_body(&block)
  app = middleware(block || proc { [200, {}, "response"] })
  _, _, body = app.call("rack.input" => StringIO.new(""))
  body
end
executor() click to toggle source
# File actionpack/test/dispatch/executor_test.rb, line 133
def executor
  @executor ||= Class.new(ActiveSupport::Executor)
end
middleware(inner_app) click to toggle source
# File actionpack/test/dispatch/executor_test.rb, line 129
def middleware(inner_app)
  ActionDispatch::Executor.new(inner_app, executor)
end