dynflow 1.3.0 → 1.4.0

data/test/execution_plan_test.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require_relative 'test_helper'
 
 module Dynflow
@@ -30,8 +31,8 @@ module Dynflow
 
           it 'restores the plan properly' do
             assert deserialized_execution_plan.valid?
-            deserialized_execution_plan.id.must_equal execution_plan.id
-            deserialized_execution_plan.label.must_equal execution_plan.label
+            _(deserialized_execution_plan.id).must_equal execution_plan.id
+            _(deserialized_execution_plan.label).must_equal execution_plan.label
 
             assert_steps_equal execution_plan.root_plan_step, deserialized_execution_plan.root_plan_step
             assert_equal execution_plan.steps.keys, deserialized_execution_plan.steps.keys
@@ -77,8 +78,8 @@ module Dynflow
         end
 
         it 'is determined by the action#label method of entry action' do
-          execution_plan.label.must_equal 'Support::CodeWorkflowExample::FastCommit'
-          dummy_execution_plan.label.must_equal 'dummy_action'
+          _(execution_plan.label).must_equal 'Support::CodeWorkflowExample::FastCommit'
+          _(dummy_execution_plan.label).must_equal 'dummy_action'
         end
       end
       describe '#result' do
@@ -92,8 +93,8 @@ module Dynflow
           before { execution_plan.steps[2].set_state :error, true }
 
           it 'should be :error' do
-            execution_plan.result.must_equal :error
-            execution_plan.error?.must_equal true
+            _(execution_plan.result).must_equal :error
+            _(execution_plan.error?).must_equal true
           end
 
         end
@@ -106,7 +107,7 @@ module Dynflow
           end
 
           it 'should be :error' do
-            execution_plan.result.must_equal :error
+            _(execution_plan.result).must_equal :error
           end
 
         end
@@ -119,7 +120,7 @@ module Dynflow
           end
 
           it 'should be :pending' do
-            execution_plan.result.must_equal :pending
+            _(execution_plan.result).must_equal :pending
           end
 
         end
@@ -134,7 +135,7 @@ module Dynflow
           end
 
           it 'should be :warning' do
-            execution_plan.result.must_equal :warning
+            _(execution_plan.result).must_equal :warning
           end
 
         end
@@ -148,7 +149,7 @@ module Dynflow
 
         it 'does not have itself as a sub plan' do
           assert execution_plan.actions.count >= 2
-          execution_plan.sub_plans.must_be :empty?
+          _(execution_plan.sub_plans).must_be :empty?
         end
       end
 
@@ -185,9 +186,9 @@ module Dynflow
         end
 
         it 'stores the ids for plan, run and finalize steps' do
-          action.plan_step_id.must_equal 3
-          action.run_step_id.must_equal 4
-          action.finalize_step_id.must_equal 5
+          _(action.plan_step_id).must_equal 3
+          _(action.run_step_id).must_equal 4
+          _(action.finalize_step_id).must_equal 5
         end
       end
 
@@ -200,7 +201,7 @@ module Dynflow
         end
 
         it 'allows setting custom id for the execution plan' do
-          execution_plan.id.must_equal sample_uuid
+          _(execution_plan.id).must_equal sample_uuid
         end
       end
 
@@ -233,7 +234,7 @@ module Dynflow
           end
 
           it 'stops the planning right after the first error occurred' do
-            execution_plan.steps.size.must_equal 2
+            _(execution_plan.steps.size).must_equal 2
           end
         end
 
@@ -320,7 +321,7 @@ module Dynflow
             end
           end
           cancel_events = plan.cancel
-          cancel_events.size.must_equal 1
+          _(cancel_events.size).must_equal 1
           cancel_events.each(&:wait)
           finished.wait
         end
@@ -334,7 +335,7 @@ module Dynflow
             end
           end
           cancel_events = plan.cancel true
-          cancel_events.size.must_equal 1
+          _(cancel_events.size).must_equal 1
           cancel_events.each(&:wait)
           finished.wait
         end
@@ -346,9 +347,9 @@ module Dynflow
         end
 
         it 'provides the access to the actions data via steps #action' do
-          execution_plan.steps.size.must_equal 20
+          _(execution_plan.steps.size).must_equal 20
           execution_plan.steps.each do |_, step|
-            step.action(execution_plan).phase.must_equal Action::Present
+            _(step.action(execution_plan).phase).must_equal Action::Present
           end
         end
       end
@@ -359,9 +360,9 @@ module Dynflow
           error = ExecutionPlan::Steps::Error.new_from_hash(exception_class: "RenamedError",
                                                             message: "This errror is not longer here",
                                                             backtrace: [])
-          error.exception_class.name.must_equal "RenamedError"
-          error.exception_class.to_s.must_equal "Dynflow::Errors::UnknownError[RenamedError]"
-          error.exception.inspect.must_equal "Dynflow::Errors::UnknownError[RenamedError]: This errror is not longer here"
+          _(error.exception_class.name).must_equal "RenamedError"
+          _(error.exception_class.to_s).must_equal "Dynflow::Errors::UnknownError[RenamedError]"
+          _(error.exception.inspect).must_equal "Dynflow::Errors::UnknownError[RenamedError]: This errror is not longer here"
         end
 
       end
@@ -379,26 +380,26 @@ module Dynflow
 
         it 'unlocks the locks on transition to stopped' do
           plan = world.plan(SingletonAction)
-          plan.state.must_equal :planned
+          _(plan.state).must_equal :planned
           lock_filter = ::Dynflow::Coordinator::SingletonActionLock
                           .unique_filter plan.entry_action.class.name
-          world.coordinator.find_locks(lock_filter).count.must_equal 1
+          _(world.coordinator.find_locks(lock_filter).count).must_equal 1
           plan = world.execute(plan.id).wait!.value
-          plan.state.must_equal :stopped
-          plan.result.must_equal :success
-          world.coordinator.find_locks(lock_filter).count.must_equal 0
+          _(plan.state).must_equal :stopped
+          _(plan.result).must_equal :success
+          _(world.coordinator.find_locks(lock_filter).count).must_equal 0
         end
 
         it 'unlocks the locks on transition to paused' do
           plan = world.plan(SingletonAction, :fail => true)
-          plan.state.must_equal :planned
+          _(plan.state).must_equal :planned
           lock_filter = ::Dynflow::Coordinator::SingletonActionLock
                           .unique_filter plan.entry_action.class.name
-          world.coordinator.find_locks(lock_filter).count.must_equal 1
+          _(world.coordinator.find_locks(lock_filter).count).must_equal 1
           plan = world.execute(plan.id).wait!.value
-          plan.state.must_equal :paused
-          plan.result.must_equal :error
-          world.coordinator.find_locks(lock_filter).count.must_equal 0
+          _(plan.state).must_equal :paused
+          _(plan.result).must_equal :error
+          _(world.coordinator.find_locks(lock_filter).count).must_equal 0
         end
       end
     end

data/test/executor_test.rb

@@ -1,445 +1,489 @@
 # -*- coding: utf-8 -*-
+# frozen_string_literal: true
 require_relative 'test_helper'
 require 'mocha/minitest'
 
+require 'sidekiq'
+require 'sidekiq/api'
+require 'sidekiq/testing'
+::Sidekiq::Testing::inline!
+require 'dynflow/executors/sidekiq/core'
+
+module RedisMocks
+  def release_orchestrator_lock; end
+  def wait_for_orchestrator_lock; end
+  def reacquire_orchestrator_lock; end
+end
+
+::Dynflow::Executors::Sidekiq::Core.send(:prepend, RedisMocks)
+
 module Dynflow
   module ExecutorTest
-    describe "executor" do
+    [::Dynflow::Executors::Parallel::Core, ::Dynflow::Executors::Sidekiq::Core].each do |executor|
+      describe executor do
+        include PlanAssertions
 
-      include PlanAssertions
+        after do
+          ::Dynflow.instance_variable_set('@process_world', nil)
+        end
 
-      let(:world) { WorldFactory.create_world }
+        before do
+          executor.any_instance.stubs(:begin_startup!)
+        end
 
-      let :issues_data do
-        [{ 'author' => 'Peter Smith', 'text' => 'Failing test' },
-         { 'author' => 'John Doe', 'text' => 'Internal server error' }]
-      end
+        let(:world) do
+          world = WorldFactory.create_world { |c| c.executor = executor }
+          ::Dynflow.instance_variable_set('@process_world', world)
+          world
+        end
 
-      let :failing_issues_data do
-        [{ 'author' => 'Peter Smith', 'text' => 'Failing test' },
-         { 'author' => 'John Doe', 'text' => 'trolling' }]
-      end
+        let :issues_data do
+          [{ 'author' => 'Peter Smith', 'text' => 'Failing test' },
+           { 'author' => 'John Doe', 'text' => 'Internal server error' }]
+        end
 
-      let :finalize_failing_issues_data do
-        [{ 'author' => 'Peter Smith', 'text' => 'Failing test' },
-         { 'author' => 'John Doe', 'text' => 'trolling in finalize' }]
-      end
+        let :failing_issues_data do
+          [{ 'author' => 'Peter Smith', 'text' => 'Failing test' },
+           { 'author' => 'John Doe', 'text' => 'trolling' }]
+        end
 
-      let :failed_execution_plan do
-        plan = world.plan(Support::CodeWorkflowExample::IncomingIssues, failing_issues_data)
-        plan = world.execute(plan.id).value
-        plan.state.must_equal :paused
-        plan
-      end
+        let :finalize_failing_issues_data do
+          [{ 'author' => 'Peter Smith', 'text' => 'Failing test' },
+           { 'author' => 'John Doe', 'text' => 'trolling in finalize' }]
+        end
 
-      let :finalize_failed_execution_plan do
-        plan = world.plan(Support::CodeWorkflowExample::IncomingIssues, finalize_failing_issues_data)
-        plan = world.execute(plan.id).value
-        plan.state.must_equal :paused
-        plan
-      end
+        let :failed_execution_plan do
+          plan = world.plan(Support::CodeWorkflowExample::IncomingIssues, failing_issues_data)
+          plan = world.execute(plan.id).value
+          _(plan.state).must_equal :paused
+          plan
+        end
 
-      let :persisted_plan do
-        world.persistence.load_execution_plan(execution_plan.id)
-      end
+        let :finalize_failed_execution_plan do
+          plan = world.plan(Support::CodeWorkflowExample::IncomingIssues, finalize_failing_issues_data)
+          plan = world.execute(plan.id).value
+          _(plan.state).must_equal :paused
+          plan
+        end
 
-      let :executor_class do
-        Executors::Parallel
-      end
+        let :persisted_plan do
+          world.persistence.load_execution_plan(execution_plan.id)
+        end
 
-      describe "execution plan state" do
+        describe "execution plan state" do
 
-        describe "after successful planning" do
+          describe "after successful planning" do
 
-          let :execution_plan do
-            world.plan(Support::CodeWorkflowExample::IncomingIssues, issues_data)
-          end
+            let :execution_plan do
+              world.plan(Support::CodeWorkflowExample::IncomingIssues, issues_data)
+            end
 
-          it "is pending" do
-            execution_plan.state.must_equal :planned
-          end
+            it "is pending" do
+              _(execution_plan.state).must_equal :planned
+            end
 
-          describe "when finished successfully" do
-            it "is stopped" do
-              world.execute(execution_plan.id).value.tap do |plan|
-                plan.state.must_equal :stopped
+            describe "when finished successfully" do
+              it "is stopped" do
+                world.execute(execution_plan.id).value.tap do |plan|
+                  _(plan.state).must_equal :stopped
+                end
               end
             end
-          end
 
-          describe "when finished with error" do
-            it "is paused" do
-              world.execute(failed_execution_plan.id).value.tap do |plan|
-                plan.state.must_equal :paused
+            describe "when finished with error" do
+              it "is paused" do
+                world.execute(failed_execution_plan.id).value.tap do |plan|
+                  _(plan.state).must_equal :paused
+                end
               end
             end
           end
-        end
 
-        describe "after error in planning" do
+          describe "after error in planning" do
 
-          class FailingAction < Dynflow::Action
-            def plan
-              raise "I failed"
+            class FailingAction < Dynflow::Action
+              def plan
+                raise "I failed"
+              end
             end
-          end
 
-          let :execution_plan do
-            world.plan(FailingAction)
-          end
+            let :execution_plan do
+              world.plan(FailingAction)
+            end
 
-          it "is stopped" do
-            execution_plan.state.must_equal :stopped
-          end
+            it "is stopped" do
+              _(execution_plan.state).must_equal :stopped
+            end
 
-        end
+          end
 
-        describe "when being executed" do
-          include TestHelpers
+          describe "when being executed" do
+            include TestHelpers
 
-          let :execution_plan do
-            world.plan(Support::CodeWorkflowExample::IncomingIssue, { 'text' => 'get a break' })
-          end
+            let :execution_plan do
+              world.plan(Support::CodeWorkflowExample::IncomingIssue, { 'text' => 'get a break' })
+            end
 
-          before do
-            TestPause.setup
-            @execution = world.execute(execution_plan.id)
-          end
+            before do
+              TestPause.setup
+              @execution = world.execute(execution_plan.id)
+            end
 
-          after do
-            @execution.wait
-            TestPause.teardown
-          end
+            after do
+              @execution.wait
+              TestPause.teardown
+            end
 
-          it "is running" do
-            TestPause.when_paused do
-              plan = world.persistence.load_execution_plan(execution_plan.id)
-              plan.state.must_equal :running
-              triage = plan.run_steps.find do |s|
-                s.action_class == Support::CodeWorkflowExample::Triage
+            it "is running" do
+              TestPause.when_paused do
+                plan = world.persistence.load_execution_plan(execution_plan.id)
+                _(plan.state).must_equal :running
+                triage = plan.run_steps.find do |s|
+                  s.action_class == Support::CodeWorkflowExample::Triage
+                end
+                _(triage.state).must_equal :running
+                _(world.persistence.load_step(triage.execution_plan_id, triage.id, world).state).must_equal :running
               end
-              triage.state.must_equal :running
-              world.persistence.
-                  load_step(triage.execution_plan_id, triage.id, world).
-                  state.must_equal :running
             end
-          end
 
-          it "fails when trying to execute again" do
-            TestPause.when_paused do
-              assert_raises(Dynflow::Error) { world.execute(execution_plan.id).value! }
+            it "fails when trying to execute again" do
+              TestPause.when_paused do
+                assert_raises(Dynflow::Error) { world.execute(execution_plan.id).value! }
+              end
             end
-          end
 
-          it "handles when the execution plan is deleted" do
-            TestPause.when_paused do
-              world.persistence.delete_execution_plans(uuid: [execution_plan.id])
-            end
-            director = get_director(world)
-            wait_for('execution plan removed from executor') do
-              !director.current_execution_plan_ids.include?(execution_plan.id)
+            it "handles when the execution plan is deleted" do
+              TestPause.when_paused do
+                world.persistence.delete_execution_plans(uuid: [execution_plan.id])
+              end
+              director = get_director(world)
+              wait_for('execution plan removed from executor') do
+                !director.current_execution_plan_ids.include?(execution_plan.id)
+              end
+              _(world.persistence.find_execution_plans(filters: { uuid: [execution_plan.id] })).must_be :empty?
             end
-            world.persistence.find_execution_plans(filters: { uuid: [execution_plan.id] }).must_be :empty?
           end
         end
-      end
 
-      describe "execution of run flow" do
+        describe "execution of run flow" do
 
-        before do
-          TestExecutionLog.setup
-        end
+          before do
+            TestExecutionLog.setup
+          end
 
-        let :result do
-          world.execute(execution_plan.id).value!
-        end
+          let :result do
+            world.execute(execution_plan.id).value!
+          end
 
-        after do
-          TestExecutionLog.teardown
-        end
+          after do
+            TestExecutionLog.teardown
+          end
 
-        def persisted_plan
-          result
-          super
-        end
+          def persisted_plan
+            result
+            super
+          end
 
-        describe 'cancellable action' do
-          describe 'successful' do
-            let :execution_plan do
-              world.plan(Support::CodeWorkflowExample::CancelableSuspended, {})
-            end
+          describe 'cancellable action' do
+            describe 'successful' do
+              let :execution_plan do
+                world.plan(Support::CodeWorkflowExample::CancelableSuspended, {})
+              end
 
-            it "doesn't cause problems" do
-              result.result.must_equal :success
-              result.state.must_equal :stopped
+              it "doesn't cause problems" do
+                _(result.result).must_equal :success
+                _(result.state).must_equal :stopped
+              end
             end
-          end
 
-          describe 'canceled' do
-            let :execution_plan do
-              world.plan(Support::CodeWorkflowExample::CancelableSuspended, { text: 'cancel-self' })
-            end
+            describe 'canceled' do
+              let :execution_plan do
+                world.plan(Support::CodeWorkflowExample::CancelableSuspended, { text: 'cancel-self' })
+              end
 
-            it 'cancels' do
-              result.result.must_equal :success
-              result.state.must_equal :stopped
-              action = world.persistence.load_action result.steps[2]
-              action.output[:task][:progress].must_equal 30
-              action.output[:task][:cancelled].must_equal true
+              it 'cancels' do
+                _(result.result).must_equal :success
+                _(result.state).must_equal :stopped
+                action = world.persistence.load_action result.steps[2]
+                _(action.output[:task][:progress]).must_equal 30
+                _(action.output[:task][:cancelled]).must_equal true
+              end
             end
-          end
 
-          describe 'canceled failed' do
-            let :execution_plan do
-              world.plan(Support::CodeWorkflowExample::CancelableSuspended, { text: 'cancel-fail cancel-self' })
-            end
+            describe 'canceled failed' do
+              let :execution_plan do
+                world.plan(Support::CodeWorkflowExample::CancelableSuspended, { text: 'cancel-fail cancel-self' })
+              end
 
-            it 'fails' do
-              result.result.must_equal :error
-              result.state.must_equal :paused
-              step = result.steps[2]
-              step.error.message.must_equal 'action cancelled'
-              action = world.persistence.load_action step
-              action.output[:task][:progress].must_equal 30
+              it 'fails' do
+                _(result.result).must_equal :error
+                _(result.state).must_equal :paused
+                step = result.steps[2]
+                _(step.error.message).must_equal 'action cancelled'
+                action = world.persistence.load_action step
+                _(action.output[:task][:progress]).must_equal 30
+              end
             end
           end
-        end
 
-        describe 'suspended action' do
-          describe 'handling errors in setup' do
-            let :execution_plan do
-              world.plan(Support::DummyExample::Polling,
-                         external_task_id: '123',
-                         text:             'troll setup')
-            end
+          describe 'suspended action' do
+            describe 'handling errors in setup' do
+              let :execution_plan do
+                world.plan(Support::DummyExample::Polling,
+                           external_task_id: '123',
+                           text:             'troll setup')
+              end
 
-            it 'fails' do
-              assert_equal :error, result.result
-              assert_equal :paused, result.state
-              assert_equal :error, result.run_steps.first.state
+              it 'fails' do
+                assert_equal :error, result.result
+                assert_equal :paused, result.state
+                assert_equal :error, result.run_steps.first.state
+              end
             end
-          end
 
-          describe 'running' do
-            let :execution_plan do
-              world.plan(Support::DummyExample::Polling, { :external_task_id => '123' })
-            end
+            describe 'events' do
+              include TestHelpers
 
-            it "doesn't cause problems" do
-              result.result.must_equal :success
-              result.state.must_equal :stopped
+              let(:clock) { Dynflow::Testing::ManagedClock.new }
+              let :execution_plan do
+                world.plan(Support::DummyExample::PlanEventsAction, ping_time: 0.5)
+              end
+
+              it 'handles planning events' do
+                world.stub(:clock, clock) do
+                  world.execute(execution_plan.id)
+                  ping = wait_for do
+                    clock.pending_pings.first
+                  end
+                  assert ping.what.value.is_a?(Director::Event)
+                  clock.progress
+                  wait_for do
+                    world.persistence.load_execution_plan(execution_plan.id).result == :success
+                  end
+                end
+              end
             end
 
-            it 'does set times' do
-              result.started_at.wont_be_nil
-              result.ended_at.wont_be_nil
-              result.execution_time.must_be :<, result.real_time
+            describe 'running' do
+              let :execution_plan do
+                world.plan(Support::DummyExample::Polling, { :external_task_id => '123' })
+              end
 
-              step_sum = result.steps.values.map(&:execution_time).reduce(:+)
+              it "doesn't cause problems" do
+                _(result.result).must_equal :success
+                _(result.state).must_equal :stopped
+              end
 
-              # Storing floats can lead to slight deviations, 1ns precision should be enough
-              result.execution_time.must_be_close_to step_sum, 0.000_001
+              it 'does set times' do
+                refute_nil result.started_at
+                refute_nil result.ended_at
+                _(result.execution_time).must_be :<, result.real_time
 
-              plan_step = result.steps[1]
-              plan_step.started_at.wont_be_nil
-              plan_step.ended_at.wont_be_nil
-              plan_step.execution_time.must_equal plan_step.real_time
+                step_sum = result.steps.values.map(&:execution_time).reduce(:+)
 
-              run_step = result.steps[2]
-              run_step.started_at.wont_be_nil
-              run_step.ended_at.wont_be_nil
-              run_step.execution_time.must_be :<, run_step.real_time
-            end
-          end
+                # Storing floats can lead to slight deviations, 1ns precision should be enough
+                _(result.execution_time).must_be_close_to step_sum, 0.000_001
 
-          describe 'progress' do
-            before do
-              TestPause.setup
-              @running_plan = world.execute(execution_plan.id)
-            end
+                plan_step = result.steps[1]
+                refute_nil plan_step.started_at
+                refute_nil plan_step.ended_at
+                _(plan_step.execution_time).must_equal plan_step.real_time
 
-            after do
-              @running_plan.wait
-              TestPause.teardown
+                run_step = result.steps[2]
+                refute_nil run_step.started_at
+                refute_nil run_step.ended_at
+                _(run_step.execution_time).must_be :<, run_step.real_time
+              end
             end
 
-            describe 'plan with one action' do
-              let :execution_plan do
-                world.plan(Support::DummyExample::Polling,
-                           { external_task_id: '123',
-                             text:             'pause in progress 20%' })
+            describe 'progress' do
+              before do
+                TestPause.setup
+                @running_plan = world.execute(execution_plan.id)
+              end
+
+              after do
+                @running_plan.wait
+                TestPause.teardown
+              end
+
+              describe 'plan with one action' do
+                let :execution_plan do
+                  world.plan(Support::DummyExample::Polling,
+                             { external_task_id: '123',
+                               text:             'pause in progress 20%' })
+                end
+
+                it 'determines the progress of the execution plan in percents' do
+                  TestPause.when_paused do
+                    plan = world.persistence.load_execution_plan(execution_plan.id)
+                    _(plan.progress.round(2)).must_equal 0.2
+                  end
+                end
               end
 
-              it 'determines the progress of the execution plan in percents' do
-                TestPause.when_paused do
-                  plan = world.persistence.load_execution_plan(execution_plan.id)
-                  plan.progress.round(2).must_equal 0.2
+              describe 'plan with more action' do
+                let :execution_plan do
+                  world.plan(Support::DummyExample::WeightedPolling,
+                             { external_task_id: '123',
+                               text:             'pause in progress 20%' })
+                end
+
+                it 'takes the steps weight in account' do
+                  TestPause.when_paused do
+                    plan = world.persistence.load_execution_plan(execution_plan.id)
+                    _(plan.progress.round(2)).must_equal 0.42
+                  end
                 end
               end
             end
 
-            describe 'plan with more action' do
+            describe 'works when resumed after error' do
               let :execution_plan do
-                world.plan(Support::DummyExample::WeightedPolling,
+                world.plan(Support::DummyExample::Polling,
                            { external_task_id: '123',
-                             text:             'pause in progress 20%' })
+                             text:             'troll progress' })
               end
 
-              it 'takes the steps weight in account' do
-                TestPause.when_paused do
-                  plan = world.persistence.load_execution_plan(execution_plan.id)
-                  plan.progress.round(2).must_equal 0.42
-                end
+              specify do
+                assert_equal :paused, result.state
+                assert_equal :error, result.result
+                assert_equal :error, result.run_steps.first.state
+
+                ep = world.execute(result.id).value
+                assert_equal :stopped, ep.state
+                assert_equal :success, ep.result
+                assert_equal :success, ep.run_steps.first.state
               end
             end
+
           end
 
-          describe 'works when resumed after error' do
+          describe "action with empty flows" do
+
             let :execution_plan do
-              world.plan(Support::DummyExample::Polling,
-                         { external_task_id: '123',
-                           text:             'troll progress' })
+              world.plan(Support::CodeWorkflowExample::Dummy, { :text => "dummy" }).tap do |plan|
+                assert_equal plan.run_flow.size, 0
+                assert_equal plan.finalize_flow.size, 0
+              end.tap do |w|
+                w
+              end
             end
 
-            specify do
-              assert_equal :paused, result.state
-              assert_equal :error, result.result
-              assert_equal :error, result.run_steps.first.state
-
-              ep = world.execute(result.id).value
-              assert_equal :stopped, ep.state
-              assert_equal :success, ep.result
-              assert_equal :success, ep.run_steps.first.state
+            it "doesn't cause problems" do
+              _(result.result).must_equal :success
+              _(result.state).must_equal :stopped
             end
-          end
-
-        end
-
-        describe "action with empty flows" do
 
-          let :execution_plan do
-            world.plan(Support::CodeWorkflowExample::Dummy, { :text => "dummy" }).tap do |plan|
-              assert_equal plan.run_flow.size, 0
-              assert_equal plan.finalize_flow.size, 0
-            end.tap do |w|
-              w
+            it 'will not run again' do
+              world.execute(execution_plan.id)
+              assert_raises(Dynflow::Error) { world.execute(execution_plan.id).value! }
             end
-          end
 
-          it "doesn't cause problems" do
-            result.result.must_equal :success
-            result.state.must_equal :stopped
           end
 
-          it 'will not run again' do
-            world.execute(execution_plan.id)
-            assert_raises(Dynflow::Error) { world.execute(execution_plan.id).value! }
-          end
+          describe 'action with empty run flow but some finalize flow' do
 
-        end
-
-        describe 'action with empty run flow but some finalize flow' do
+            let :execution_plan do
+              world.plan(Support::CodeWorkflowExample::DummyWithFinalize, { :text => "dummy" }).tap do |plan|
+                assert_equal plan.run_flow.size, 0
+                assert_equal plan.finalize_flow.size, 1
+              end
+            end
 
-          let :execution_plan do
-            world.plan(Support::CodeWorkflowExample::DummyWithFinalize, { :text => "dummy" }).tap do |plan|
-              assert_equal plan.run_flow.size, 0
-              assert_equal plan.finalize_flow.size, 1
+            it "doesn't cause problems" do
+              _(result.result).must_equal :success
+              _(result.state).must_equal :stopped
             end
-          end
 
-          it "doesn't cause problems" do
-            result.result.must_equal :success
-            result.state.must_equal :stopped
           end
 
-        end
-
-        describe 'running' do
-          let :execution_plan do
-            world.plan(Support::CodeWorkflowExample::IncomingIssues, issues_data)
-          end
+          describe 'running' do
+            let :execution_plan do
+              world.plan(Support::CodeWorkflowExample::IncomingIssues, issues_data)
+            end
 
-          it "runs all the steps in the run flow" do
-            assert_run_flow <<-EXECUTED_RUN_FLOW, persisted_plan
-              Dynflow::Flows::Concurrence
-                Dynflow::Flows::Sequence
-                  4: Triage(success) {"author"=>"Peter Smith", "text"=>"Failing test"} --> {"classification"=>{"assignee"=>"John Doe", "severity"=>"medium"}}
-                  7: UpdateIssue(success) {"author"=>"Peter Smith", "text"=>"Failing test", "assignee"=>"John Doe", "severity"=>"medium"} --> {}
-                  9: NotifyAssignee(success) {"triage"=>{"classification"=>{"assignee"=>"John Doe", "severity"=>"medium"}}} --> {}
-                Dynflow::Flows::Sequence
-                  13: Triage(success) {"author"=>"John Doe", "text"=>"Internal server error"} --> {"classification"=>{"assignee"=>"John Doe", "severity"=>"medium"}}
-                  16: UpdateIssue(success) {"author"=>"John Doe", "text"=>"Internal server error", "assignee"=>"John Doe", "severity"=>"medium"} --> {}
-                  18: NotifyAssignee(success) {"triage"=>{"classification"=>{"assignee"=>"John Doe", "severity"=>"medium"}}} --> {}
-            EXECUTED_RUN_FLOW
+            it "runs all the steps in the run flow" do
+              assert_run_flow <<-EXECUTED_RUN_FLOW, persisted_plan
+                Dynflow::Flows::Concurrence
+                  Dynflow::Flows::Sequence
+                    4: Triage(success) {"author"=>"Peter Smith", "text"=>"Failing test"} --> {"classification"=>{"assignee"=>"John Doe", "severity"=>"medium"}}
+                    7: UpdateIssue(success) {"author"=>"Peter Smith", "text"=>"Failing test", "assignee"=>"John Doe", "severity"=>"medium"} --> {}
+                    9: NotifyAssignee(success) {"triage"=>{"classification"=>{"assignee"=>"John Doe", "severity"=>"medium"}}} --> {}
+                  Dynflow::Flows::Sequence
+                    13: Triage(success) {"author"=>"John Doe", "text"=>"Internal server error"} --> {"classification"=>{"assignee"=>"John Doe", "severity"=>"medium"}}
+                    16: UpdateIssue(success) {"author"=>"John Doe", "text"=>"Internal server error", "assignee"=>"John Doe", "severity"=>"medium"} --> {}
+                    18: NotifyAssignee(success) {"triage"=>{"classification"=>{"assignee"=>"John Doe", "severity"=>"medium"}}} --> {}
+              EXECUTED_RUN_FLOW
+            end
           end
-        end
 
-      end
-
-      describe "execution of finalize flow" do
-        before do
-          TestExecutionLog.setup
-          result = world.execute(execution_plan.id).value
-          raise result if result.is_a? Exception
         end
 
-        after do
-          TestExecutionLog.teardown
-        end
-
-        describe "when run flow successful" do
-          let :execution_plan do
-            world.plan(Support::CodeWorkflowExample::IncomingIssues, issues_data)
+        describe "execution of finalize flow" do
+          before do
+            TestExecutionLog.setup
+            result = world.execute(execution_plan.id).value
+            raise result if result.is_a? Exception
           end
 
-          it "runs all the steps in the finalize flow" do
-            assert_finalized(Support::CodeWorkflowExample::IncomingIssues,
-                             { "issues" => [{ "author" => "Peter Smith", "text" => "Failing test" }, { "author" => "John Doe", "text" => "Internal server error" }] })
-            assert_finalized(Support::CodeWorkflowExample::Triage,
-                             { "author" => "Peter Smith", "text" => "Failing test" })
+          after do
+            TestExecutionLog.teardown
           end
-        end
 
-        describe "when run flow failed" do
-          let :execution_plan do
-            failed_execution_plan
-          end
+          describe "when run flow successful" do
+            let :execution_plan do
+              world.plan(Support::CodeWorkflowExample::IncomingIssues, issues_data)
+            end
 
-          it "doesn't run the steps in the finalize flow" do
-            TestExecutionLog.finalize.size.must_equal 0
+            it "runs all the steps in the finalize flow" do
+              assert_finalized(Support::CodeWorkflowExample::IncomingIssues,
+                               { "issues" => [{ "author" => "Peter Smith", "text" => "Failing test" },
+                                              { "author" => "John Doe", "text" => "Internal server error" }] })
+              assert_finalized(Support::CodeWorkflowExample::Triage,
+                               { "author" => "Peter Smith", "text" => "Failing test" })
+            end
           end
-        end
 
-      end
+          describe "when run flow failed" do
+            let :execution_plan do
+              failed_execution_plan
+            end
 
-      describe "re-execution of run flow after fix in run phase" do
+            it "doesn't run the steps in the finalize flow" do
+              _(TestExecutionLog.finalize.size).must_equal 0
+            end
+          end
 
-        after do
-          TestExecutionLog.teardown
         end
 
-        let :resumed_execution_plan do
-          failed_step = failed_execution_plan.steps.values.find do |step|
-            step.state == :error
+        describe "re-execution of run flow after fix in run phase" do
+          after do
+            TestExecutionLog.teardown
           end
-          world.persistence.load_action(failed_step).tap do |action|
-            action.input[:text] = "ok"
-            world.persistence.save_action(failed_step.execution_plan_id, action)
+
+          let :resumed_execution_plan do
+            failed_step = failed_execution_plan.steps.values.find do |step|
+              step.state == :error
+            end
+            world.persistence.load_action(failed_step).tap do |action|
+              action.input[:text] = "ok"
+              world.persistence.save_action(failed_step.execution_plan_id, action)
+            end
+            TestExecutionLog.setup
+            world.execute(failed_execution_plan.id).value
           end
-          TestExecutionLog.setup
-          world.execute(failed_execution_plan.id).value
-        end
 
-        it "runs all the steps in the run flow" do
-          resumed_execution_plan.state.must_equal :stopped
-          resumed_execution_plan.result.must_equal :success
+          it "runs all the steps in the run flow" do
+            _(resumed_execution_plan.state).must_equal :stopped
+            _(resumed_execution_plan.result).must_equal :success
 
-          run_triages = TestExecutionLog.run.find_all do |action_class, input|
-            action_class == Support::CodeWorkflowExample::Triage
-          end
-          run_triages.size.must_equal 1
+            run_triages = TestExecutionLog.run.find_all do |action_class, input|
+              action_class == Support::CodeWorkflowExample::Triage
+            end
+            _(run_triages.size).must_equal 1
 
-          assert_run_flow <<-EXECUTED_RUN_FLOW, resumed_execution_plan
+            assert_run_flow <<-EXECUTED_RUN_FLOW, resumed_execution_plan
         Dynflow::Flows::Concurrence
           Dynflow::Flows::Sequence
             4: Triage(success) {\"author\"=>\"Peter Smith\", \"text\"=>\"Failing test\"} --> {\"classification\"=>{\"assignee\"=>\"John Doe\", \"severity\"=>\"medium\"}}
@@ -450,38 +494,38 @@ module Dynflow
             16: UpdateIssue(success) {\"author\"=>\"John Doe\", \"text\"=>\"trolling\", \"assignee\"=>\"John Doe\", \"severity\"=>\"medium\"} --> {}
             18: NotifyAssignee(success) {\"triage\"=>{\"classification\"=>{\"assignee\"=>\"John Doe\", \"severity\"=>\"medium\"}}} --> {}
           EXECUTED_RUN_FLOW
-        end
-
-      end
-
-      describe "re-execution of run flow after fix in finalize phase" do
+          end
 
-        after do
-          TestExecutionLog.teardown
         end
 
-        let :resumed_execution_plan do
-          failed_step = finalize_failed_execution_plan.steps.values.find do |step|
-            step.state == :error
+        describe "re-execution of run flow after fix in finalize phase" do
+
+          after do
+            TestExecutionLog.teardown
           end
-          world.persistence.load_action(failed_step).tap do |action|
-            action.input[:text] = "ok"
-            world.persistence.save_action(failed_step.execution_plan_id, action)
+
+          let :resumed_execution_plan do
+            failed_step = finalize_failed_execution_plan.steps.values.find do |step|
+              step.state == :error
+            end
+            world.persistence.load_action(failed_step).tap do |action|
+              action.input[:text] = "ok"
+              world.persistence.save_action(failed_step.execution_plan_id, action)
+            end
+            TestExecutionLog.setup
+            world.execute(finalize_failed_execution_plan.id).value
           end
-          TestExecutionLog.setup
-          world.execute(finalize_failed_execution_plan.id).value
-        end
 
-        it "runs all the steps in the finalize flow" do
-          resumed_execution_plan.state.must_equal :stopped
-          resumed_execution_plan.result.must_equal :success
+          it "runs all the steps in the finalize flow" do
+            _(resumed_execution_plan.state).must_equal :stopped
+            _(resumed_execution_plan.result).must_equal :success
 
-          run_triages = TestExecutionLog.finalize.find_all do |action_class, input|
-            action_class == Support::CodeWorkflowExample::Triage
-          end
-          run_triages.size.must_equal 2
+            run_triages = TestExecutionLog.finalize.find_all do |action_class, input|
+              action_class == Support::CodeWorkflowExample::Triage
+            end
+            _(run_triages.size).must_equal 2
 
-          assert_finalize_flow <<-EXECUTED_RUN_FLOW, resumed_execution_plan
+            assert_finalize_flow <<-EXECUTED_RUN_FLOW, resumed_execution_plan
             Dynflow::Flows::Sequence
               5: Triage(success) {\"author\"=>\"Peter Smith\", \"text\"=>\"Failing test\"} --> {\"classification\"=>{\"assignee\"=>\"John Doe\", \"severity\"=>\"medium\"}}
               10: NotifyAssignee(success) {\"triage\"=>{\"classification\"=>{\"assignee\"=>\"John Doe\", \"severity\"=>\"medium\"}}} --> {}
@@ -489,35 +533,35 @@ module Dynflow
               19: NotifyAssignee(success) {\"triage\"=>{\"classification\"=>{\"assignee\"=>\"John Doe\", \"severity\"=>\"medium\"}}} --> {}
               20: IncomingIssues(success) {\"issues\"=>[{\"author\"=>\"Peter Smith\", \"text\"=>\"Failing test\"}, {\"author\"=>\"John Doe\", \"text\"=>\"trolling in finalize\"}]} --> {}
           EXECUTED_RUN_FLOW
-        end
+          end
 
-      end
+        end
 
-      describe "re-execution of run flow after skipping" do
+        describe "re-execution of run flow after skipping" do
 
-        after do
-          TestExecutionLog.teardown
-        end
+          after do
+            TestExecutionLog.teardown
+          end
 
-        let :resumed_execution_plan do
-          failed_step = failed_execution_plan.steps.values.find do |step|
-            step.state == :error
+          let :resumed_execution_plan do
+            failed_step = failed_execution_plan.steps.values.find do |step|
+              step.state == :error
+            end
+            failed_execution_plan.skip(failed_step)
+            TestExecutionLog.setup
+            world.execute(failed_execution_plan.id).value
           end
-          failed_execution_plan.skip(failed_step)
-          TestExecutionLog.setup
-          world.execute(failed_execution_plan.id).value
-        end
 
-        it "runs all pending steps except skipped" do
-          resumed_execution_plan.state.must_equal :stopped
-          resumed_execution_plan.result.must_equal :warning
+          it "runs all pending steps except skipped" do
+            _(resumed_execution_plan.state).must_equal :stopped
+            _(resumed_execution_plan.result).must_equal :warning
 
-          run_triages = TestExecutionLog.run.find_all do |action_class, input|
-            action_class == Support::CodeWorkflowExample::Triage
-          end
-          run_triages.size.must_equal 0
+            run_triages = TestExecutionLog.run.find_all do |action_class, input|
+              action_class == Support::CodeWorkflowExample::Triage
+            end
+            _(run_triages.size).must_equal 0
 
-          assert_run_flow <<-EXECUTED_RUN_FLOW, resumed_execution_plan
+            assert_run_flow <<-EXECUTED_RUN_FLOW, resumed_execution_plan
         Dynflow::Flows::Concurrence
           Dynflow::Flows::Sequence
             4: Triage(success) {\"author\"=>\"Peter Smith\", \"text\"=>\"Failing test\"} --> {\"classification\"=>{\"assignee\"=>\"John Doe\", \"severity\"=>\"medium\"}}
@@ -529,7 +573,7 @@ module Dynflow
             18: NotifyAssignee(skipped) {\"triage\"=>Step(13).output} --> {}
           EXECUTED_RUN_FLOW
 
-          assert_finalize_flow <<-FINALIZE_FLOW, resumed_execution_plan
+            assert_finalize_flow <<-FINALIZE_FLOW, resumed_execution_plan
         Dynflow::Flows::Sequence
           5: Triage(success) {\"author\"=>\"Peter Smith\", \"text\"=>\"Failing test\"} --> {\"classification\"=>{\"assignee\"=>\"John Doe\", \"severity\"=>\"medium\"}}
           10: NotifyAssignee(success) {\"triage\"=>{\"classification\"=>{\"assignee\"=>\"John Doe\", \"severity\"=>\"medium\"}}} --> {}
@@ -538,159 +582,159 @@ module Dynflow
           20: IncomingIssues(success) {\"issues\"=>[{\"author\"=>\"Peter Smith\", \"text\"=>\"Failing test\"}, {\"author\"=>\"John Doe\", \"text\"=>\"trolling\"}]} --> {}
           FINALIZE_FLOW
 
+          end
         end
-      end
 
-      describe 'FlowManager' do
-        let :execution_plan do
-          world.plan(Support::CodeWorkflowExample::IncomingIssues, issues_data)
-        end
+        describe 'FlowManager' do
+          let :execution_plan do
+            world.plan(Support::CodeWorkflowExample::IncomingIssues, issues_data)
+          end
 
-        let(:manager) { Director::FlowManager.new execution_plan, execution_plan.run_flow }
+          let(:manager) { Director::FlowManager.new execution_plan, execution_plan.run_flow }
 
-        def assert_next_steps(expected_next_step_ids, finished_step_id = nil, success = true)
-          if finished_step_id
-            step       = manager.execution_plan.steps[finished_step_id]
-            next_steps = manager.cursor_index[step.id].what_is_next(step, success)
-          else
-            next_steps = manager.start
+          def assert_next_steps(expected_next_step_ids, finished_step_id = nil, success = true)
+            if finished_step_id
+              step       = manager.execution_plan.steps[finished_step_id]
+              next_steps = manager.cursor_index[step.id].what_is_next(step, success)
+            else
+              next_steps = manager.start
+            end
+            next_step_ids = next_steps.map(&:id)
+            assert_equal Set.new(expected_next_step_ids), Set.new(next_step_ids)
+          end
+
+          describe 'what_is_next' do
+            it 'returns next steps after required steps were finished' do
+              assert_next_steps([4, 13])
+              assert_next_steps([7], 4)
+              assert_next_steps([9], 7)
+              assert_next_steps([], 9)
+              assert_next_steps([16], 13)
+              assert_next_steps([18], 16)
+              assert_next_steps([], 18)
+              assert manager.done?
+            end
           end
-          next_step_ids = next_steps.map(&:id)
-          assert_equal Set.new(expected_next_step_ids), Set.new(next_step_ids)
-        end
 
-        describe 'what_is_next' do
-          it 'returns next steps after required steps were finished' do
-            assert_next_steps([4, 13])
-            assert_next_steps([7], 4)
-            assert_next_steps([9], 7)
-            assert_next_steps([], 9)
-            assert_next_steps([16], 13)
-            assert_next_steps([18], 16)
-            assert_next_steps([], 18)
-            assert manager.done?
-          end
-        end
+          describe 'what_is_next with errors' do
 
-        describe 'what_is_next with errors' do
+            it "doesn't return next steps if requirements failed" do
+              assert_next_steps([4, 13])
+              assert_next_steps([], 4, false)
+            end
 
-          it "doesn't return next steps if requirements failed" do
-            assert_next_steps([4, 13])
-            assert_next_steps([], 4, false)
+            it "is not done while other steps can be finished" do
+              assert_next_steps([4, 13])
+              assert_next_steps([], 4, false)
+              assert !manager.done?
+              assert_next_steps([], 13, false)
+              assert manager.done?
+            end
           end
 
-          it "is not done while other steps can be finished" do
-            assert_next_steps([4, 13])
-            assert_next_steps([], 4, false)
-            assert !manager.done?
-            assert_next_steps([], 13, false)
-            assert manager.done?
-          end
         end
 
-      end
+        describe 'Pool::JobStorage' do
+          FakeStep ||= Struct.new(:execution_plan_id)
 
-      describe 'Pool::JobStorage' do
-        FakeStep ||= Struct.new(:execution_plan_id)
-
-        let(:storage) { Dynflow::Executors::Parallel::Pool::JobStorage.new }
-        it do
-          storage.must_be_empty
-          storage.queue_size.must_equal(0)
-          storage.pop.must_be_nil
-          storage.pop.must_be_nil
-
-          storage.add s = FakeStep.new(1)
-          storage.queue_size.must_equal(1)
-          storage.pop.must_equal s
-          storage.must_be_empty
-          storage.pop.must_be_nil
-
-          storage.add s11 = FakeStep.new(1)
-          storage.add s12 = FakeStep.new(1)
-          storage.add s13 = FakeStep.new(1)
-          storage.add s21 = FakeStep.new(2)
-          storage.add s22 = FakeStep.new(2)
-          storage.add s31 = FakeStep.new(3)
-
-          storage.queue_size(1).must_equal(3)
-          storage.queue_size(4).must_equal(0)
-          storage.queue_size.must_equal(6)
-
-          storage.pop.must_equal s11
-          storage.pop.must_equal s12
-          storage.pop.must_equal s13
-          storage.pop.must_equal s21
-          storage.pop.must_equal s22
-          storage.pop.must_equal s31
-
-          storage.must_be_empty
-          storage.queue_size.must_equal(0)
-          storage.pop.must_be_nil
-        end
-      end
+          let(:storage) { Dynflow::Executors::Parallel::Pool::JobStorage.new }
+          it do
+            _(storage).must_be_empty
+            _(storage.queue_size).must_equal(0)
+            assert_nil storage.pop
+            assert_nil storage.pop
 
-    end
+            storage.add s = FakeStep.new(1)
+            _(storage.queue_size).must_equal(1)
+            _(storage.pop).must_equal s
+            _(storage).must_be_empty
+            assert_nil storage.pop
 
-    describe 'termination' do
-      let(:world) { WorldFactory.create_world }
-
-      it 'waits for currently running actions' do
-        $slow_actions_done = 0
-        running = world.trigger(Support::DummyExample::Slow, 1)
-        suspended = world.trigger(Support::DummyExample::EventedAction, :timeout => 3 )
-        sleep 0.2
-        world.terminate.wait
-        $slow_actions_done.must_equal 1
-        [running, suspended].each do |triggered|
-          plan = world.persistence.load_execution_plan(triggered.id)
-          plan.state.must_equal :paused
-          plan.result.must_equal :pending
+            storage.add s11 = FakeStep.new(1)
+            storage.add s12 = FakeStep.new(1)
+            storage.add s13 = FakeStep.new(1)
+            storage.add s21 = FakeStep.new(2)
+            storage.add s22 = FakeStep.new(2)
+            storage.add s31 = FakeStep.new(3)
+
+            _(storage.queue_size(1)).must_equal(3)
+            _(storage.queue_size(4)).must_equal(0)
+            _(storage.queue_size).must_equal(6)
+
+            _(storage.pop).must_equal s11
+            _(storage.pop).must_equal s12
+            _(storage.pop).must_equal s13
+            _(storage.pop).must_equal s21
+            _(storage.pop).must_equal s22
+            _(storage.pop).must_equal s31
+
+            _(storage).must_be_empty
+            _(storage.queue_size).must_equal(0)
+            assert_nil storage.pop
+          end
         end
+
       end
 
-      describe 'before_termination hooks' do
-        it 'runs before temination hooks' do
-          hook_run = false
-          world.before_termination { hook_run = true }
+      describe 'termination' do
+        let(:world) { WorldFactory.create_world }
+
+        it 'waits for currently running actions' do
+          $slow_actions_done = 0
+          running = world.trigger(Support::DummyExample::Slow, 1)
+          suspended = world.trigger(Support::DummyExample::DeprecatedEventedAction, :timeout => 3 )
+          sleep 0.2
           world.terminate.wait
-          assert hook_run
+          _($slow_actions_done).must_equal 1
+          [running, suspended].each do |triggered|
+            plan = world.persistence.load_execution_plan(triggered.id)
+            _(plan.state).must_equal :paused
+            _(plan.result).must_equal :pending
+          end
         end
 
-        it 'continues when some hook fails' do
-          run_hooks, failed_hooks = [], []
-          world.before_termination { run_hooks << 1 }
-          world.before_termination { run_hooks << 2; failed_hooks << 2; raise 'error' }
-          world.before_termination { run_hooks << 3 }
-          world.terminate.wait
-          run_hooks.must_equal [1, 2, 3]
-          failed_hooks.must_equal [2]
+        describe 'before_termination hooks' do
+          it 'runs before temination hooks' do
+            hook_run = false
+            world.before_termination { hook_run = true }
+            world.terminate.wait
+            assert hook_run
+          end
+
+          it 'continues when some hook fails' do
+            run_hooks, failed_hooks = [], []
+            world.before_termination { run_hooks << 1 }
+            world.before_termination { run_hooks << 2; failed_hooks << 2; raise 'error' }
+            world.before_termination { run_hooks << 3 }
+            world.terminate.wait
+            _(run_hooks).must_equal [1, 2, 3]
+            _(failed_hooks).must_equal [2]
+          end
         end
-      end
 
-      it 'does not accept new work' do
-        assert world.terminate.wait
-        ::Dynflow::Coordinator::PlanningLock.any_instance.stubs(:validate!)
-        result = world.trigger(Support::DummyExample::Slow, 0.02)
-        result.must_be :planned?
-        result.finished.wait
-        assert result.finished.rejected?
-        result.finished.reason.must_be_kind_of Concurrent::Actor::ActorTerminated
-      end
+        it 'does not accept new work' do
+          assert world.terminate.wait
+          ::Dynflow::Coordinator::PlanningLock.any_instance.stubs(:validate!)
+          result = world.trigger(Support::DummyExample::Slow, 0.02)
+          _(result).must_be :planned?
+          result.finished.wait
+          assert result.finished.rejected?
+          _(result.finished.reason).must_be_kind_of Concurrent::Actor::ActorTerminated
+        end
 
-      it 'it terminates when no work right after initialization' do
-        assert world.terminate.wait
-      end
+        it 'it terminates when no work right after initialization' do
+          assert world.terminate.wait
+        end
 
-      it 'second terminate works' do
-        assert world.terminate.wait
-        assert world.terminate.wait
-      end
+        it 'second terminate works' do
+          assert world.terminate.wait
+          assert world.terminate.wait
+        end
 
-      it 'second terminate works concurrently' do
-        assert [world.terminate, world.terminate].map(&:value).all?
+        it 'second terminate works concurrently' do
+          assert [world.terminate, world.terminate].map(&:value).all?
+        end
       end
     end
-
   end
 end