Class ExecutorTest < ActiveSupport::TestCase

# File activesupport/test/executor_test.rb, line 55
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

# File actionpack/test/dispatch/executor_test.rb, line 110
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

# File activesupport/test/executor_test.rb, line 19
def test_callbacks_share_state
  result = false
  executor.to_run { @foo = true }
  executor.to_complete { result = @foo }

  executor.wrap { }

  assert result
end

# File actionpack/test/dispatch/executor_test.rb, line 85
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

# File actionpack/test/dispatch/executor_test.rb, line 96
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

# File activesupport/test/executor_test.rb, line 111
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

# File activesupport/test/executor_test.rb, line 136
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

# File activesupport/test/executor_test.rb, line 41
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

# File activesupport/test/executor_test.rb, line 71
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

# File actionpack/test/dispatch/executor_test.rb, line 51
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

# File activesupport/test/executor_test.rb, line 91
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_equal nil, supplied_state
end

# File actionpack/test/dispatch/executor_test.rb, line 22
def test_returned_body_object_always_responds_to_close
  body = call_and_return_body
  assert_respond_to body, :close
end

# File actionpack/test/dispatch/executor_test.rb, line 27
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

# File actionpack/test/dispatch/executor_test.rb, line 37
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

# File actionpack/test/dispatch/executor_test.rb, line 63
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

# File actionpack/test/dispatch/executor_test.rb, line 73
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

# File activesupport/test/executor_test.rb, line 161
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

# File activesupport/test/executor_test.rb, line 29
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

# File activesupport/test/executor_test.rb, line 7
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