dynflow 1.3.0 → 1.4.0

data/lib/dynflow/utils/priority_queue.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   module Utils
     # Heavily inspired by rubyworks/pqueue

data/lib/dynflow/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
-  VERSION = '1.3.0'.freeze
+  VERSION = '1.4.0'
 end

data/lib/dynflow/watchers/memory_consumption_watcher.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'get_process_mem'
 
 module Dynflow

data/lib/dynflow/web.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'dynflow'
 require 'pp'
 require 'sinatra/base'

data/lib/dynflow/web/console.rb

@@ -1,4 +1,5 @@
 
+# frozen_string_literal: true
 module Dynflow
   module Web
     class Console < Sinatra::Base

data/lib/dynflow/web/console_helpers.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   module Web
     module ConsoleHelpers

data/lib/dynflow/web/filtering_helpers.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   module Web
     module FilteringHelpers

data/lib/dynflow/web/world_helpers.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   module Web
     module WorldHelpers

data/lib/dynflow/web_console.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'dynflow/web'
 
 warn %{"require 'dynflow/web_console'" is deprecated, use "require 'dynflow/web'" instead}

data/lib/dynflow/world.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+# frozen_string_literal: true
 require 'dynflow/world/invalidation'
 
 module Dynflow
@@ -29,7 +30,12 @@ module Dynflow
                                                 :backup_deleted_plans => @config.backup_deleted_plans,
                                                 :backup_dir => @config.backup_dir)
       @coordinator            = Coordinator.new(@config.coordinator_adapter)
-      @executor               = @config.executor
+      if @config.executor
+        @executor = Executors::Parallel.new(self,
+                                            executor_class: @config.executor,
+                                            heartbeat_interval: @config.executor_heartbeat_interval,
+                                            queues_options: @config.queues)
+      end
       @action_classes         = @config.action_classes
       @auto_rescue            = @config.auto_rescue
       @exit_on_terminate      = Concurrent::AtomicBoolean.new(@config.exit_on_terminate)
@@ -217,6 +223,10 @@ module Dynflow
       publish_request(Dispatcher::Event[execution_plan_id, step_id, event], done, false)
     end
 
+    def plan_event(execution_plan_id, step_id, event, time, accepted = Concurrent::Promises.resolvable_future)
+      publish_request(Dispatcher::Event[execution_plan_id, step_id, event, time], accepted, false)
+    end
+
     def ping(world_id, timeout, done = Concurrent::Promises.resolvable_future)
       publish_request(Dispatcher::Ping[world_id, true], done, false, timeout)
     end

data/lib/dynflow/world/invalidation.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Dynflow
   class World
     module Invalidation
@@ -35,8 +36,13 @@ module Dynflow
         with_valid_execution_plan_for_lock(planning_lock) do |plan|
           plan.steps.values.each { |step| invalidate_step step }
 
-          state = plan.plan_steps.all? { |step| step.state == :success } ? :planned : :stopped
+          state = if plan.plan_steps.any? && plan.plan_steps.all? { |step| step.state == :success }
+                    :planned
+                  else
+                    :stopped
+                  end
           plan.update_state(state)
+
           coordinator.release(planning_lock)
           execute(plan.id) if plan.state == :planned
         end

data/test/abnormal_states_recovery_test.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+# frozen_string_literal: true
 require_relative 'test_helper'
 require 'ostruct'
 
@@ -64,11 +65,11 @@ module Dynflow
           it 'when no executor is available, marks the plans as paused' do
             executor_world_2.terminate.wait
             with_invalidation_while_executing(false) do |plan|
-              plan.state.must_equal :paused
-              plan.result.must_equal :pending
+              _(plan.state).must_equal :paused
+              _(plan.result).must_equal :pending
               expected_history = [['start execution', executor_world.id],
                                   ['terminate execution', executor_world.id]]
-              plan.execution_history.map { |h| [h.name, h.world_id] }.must_equal(expected_history)
+              _(plan.execution_history.map { |h| [h.name, h.world_id] }).must_equal(expected_history)
             end
           end
 
@@ -103,14 +104,14 @@ module Dynflow
             client_world.invalidate(executor_world.registered_world)
             expected_locks = ["lock world-invalidation:#{executor_world.id}",
                               "unlock world-invalidation:#{executor_world.id}"]
-            client_world.coordinator.adapter.lock_log.must_equal(expected_locks)
+            _(client_world.coordinator.adapter.lock_log).must_equal(expected_locks)
           end
 
           it "prevents from running the consistency checks twice on the same world concurrently" do
             client_world.invalidate(executor_world.registered_world)
             expected_locks = ["lock world-invalidation:#{executor_world.id}",
                               "unlock world-invalidation:#{executor_world.id}"]
-            client_world.coordinator.adapter.lock_log.must_equal(expected_locks)
+            _(client_world.coordinator.adapter.lock_log).must_equal(expected_locks)
           end
 
           it "handles missing execution plans" do
@@ -120,7 +121,7 @@ module Dynflow
             expected_locks = ["lock world-invalidation:#{executor_world.id}",
                               "unlock execution-plan:missing",
                               "unlock world-invalidation:#{executor_world.id}"]
-            client_world.coordinator.adapter.lock_log.must_equal(expected_locks)
+            _(client_world.coordinator.adapter.lock_log).must_equal(expected_locks)
           end
 
           it 'releases singleton locks belonging to missing execution plan' do
@@ -134,7 +135,7 @@ module Dynflow
                               "unlock execution-plan:#{execution_plan_id}",
                               "unlock singleton-action:#{action_class}",
                               "unlock world-invalidation:#{executor_world.id}"]
-            client_world.coordinator.adapter.lock_log.must_equal(expected_locks)
+            _(client_world.coordinator.adapter.lock_log).must_equal(expected_locks)
           end
 
           describe 'planning locks' do
@@ -148,7 +149,7 @@ module Dynflow
                                 "unlock execution-plan:#{plan.id}", # planning lock
                                 "lock execution-plan:#{plan.id}", # execution lock
                                 "unlock world-invalidation:#{client_world.id}"]
-              executor_world.coordinator.adapter.lock_log.must_equal(expected_locks)
+              _(executor_world.coordinator.adapter.lock_log).must_equal(expected_locks)
               wait_for do
                 plan = client_world_2.persistence.load_execution_plan(plan.id)
                 plan.state == :stopped
@@ -167,9 +168,9 @@ module Dynflow
               expected_locks = ["lock world-invalidation:#{client_world.id}",
                                 "unlock execution-plan:#{plan.id}",
                                 "unlock world-invalidation:#{client_world.id}"]
-              client_world_2.coordinator.adapter.lock_log.must_equal(expected_locks)
+              _(client_world_2.coordinator.adapter.lock_log).must_equal(expected_locks)
               plan = client_world_2.persistence.load_execution_plan(plan.id)
-              plan.state.must_equal :stopped
+              _(plan.state).must_equal :stopped
             end
 
             it 'releases orphaned planning locks without execution plans' do
@@ -179,7 +180,7 @@ module Dynflow
               expected_locks = ["lock world-invalidation:#{client_world.id}",
                                 "unlock execution-plan:#{uuid}",
                                 "unlock world-invalidation:#{client_world.id}"]
-              client_world_2.coordinator.adapter.lock_log.must_equal(expected_locks)
+              _(client_world_2.coordinator.adapter.lock_log).must_equal(expected_locks)
             end
           end
         end
@@ -194,10 +195,10 @@ module Dynflow
         it "prevents from running the auto-execution twice" do
           client_world.auto_execute
           expected_locks = ["lock auto-execute", "unlock auto-execute"]
-          client_world.coordinator.adapter.lock_log.must_equal(expected_locks)
+          _(client_world.coordinator.adapter.lock_log).must_equal(expected_locks)
           lock = Coordinator::AutoExecuteLock.new(client_world)
           client_world.coordinator.acquire(lock)
-          client_world.auto_execute.must_equal []
+          _(client_world.auto_execute).must_equal []
         end
 
         it "re-runs the plans that were planned but not executed" do
@@ -212,7 +213,7 @@ module Dynflow
           end
           expected_history = [['start execution', executor_world.id],
                               ['finish execution', executor_world.id]]
-          plan.execution_history.map { |h| [h.name, h.world_id] }.must_equal(expected_history)
+          _(plan.execution_history.map { |h| [h.name, h.world_id] }).must_equal(expected_history)
         end
 
         it "re-runs the plans that were terminated but not re-executed (because no available executor)" do
@@ -236,10 +237,10 @@ module Dynflow
           retries = executor_world.auto_execute
           retries.each(&:wait)
           plan = client_world.persistence.load_execution_plan(triggered.id)
-          plan.state.must_equal :paused
+          _(plan.state).must_equal :paused
           expected_history = [['start execution', executor_world.id],
                               ['pause execution', executor_world.id]]
-          plan.execution_history.map { |h| [h.name, h.world_id] }.must_equal(expected_history)
+          _(plan.execution_history.map { |h| [h.name, h.world_id] }).must_equal(expected_history)
         end
       end
 
@@ -266,45 +267,45 @@ module Dynflow
 
           it 'performs the validity check on world creation if auto_validity_check enabled' do
             client_world.coordinator.register_world(invalid_world)
-            client_world.coordinator.find_worlds(false, id: invalid_world.id).wont_be_empty
+            _(client_world.coordinator.find_worlds(false, id: invalid_world.id)).wont_be_empty
             world_with_auto_validity_check
-            client_world.coordinator.find_worlds(false, id: invalid_world.id).must_be_empty
+            _(client_world.coordinator.find_worlds(false, id: invalid_world.id)).must_be_empty
           end
 
           it 'by default, the auto_validity_check is enabled only for executor words' do
             client_world_config = Config::ForWorld.new(Config.new.tap { |c| c.executor = false }, create_world )
-            client_world_config.auto_validity_check.must_equal false
+            _(client_world_config.auto_validity_check).must_equal false
 
-            executor_world_config = Config::ForWorld.new(Config.new.tap { |c| c.executor = lambda { |w, _| Executors::Parallel.new(w, 15) } }, create_world )
-            executor_world_config.auto_validity_check.must_equal true
+            executor_world_config = Config::ForWorld.new(Config.new.tap { |c| c.executor = Executors::Parallel::Core }, create_world )
+            _(executor_world_config.auto_validity_check).must_equal true
           end
 
           it 'reports the validation status' do
             client_world.coordinator.register_world(invalid_world)
             results = client_world.worlds_validity_check
-            client_world.coordinator.find_worlds(false, id: invalid_world.id).must_be_empty
+            _(client_world.coordinator.find_worlds(false, id: invalid_world.id)).must_be_empty
 
-            results[invalid_world.id].must_equal :invalidated
+            _(results[invalid_world.id]).must_equal :invalidated
 
-            results[client_world.id].must_equal :valid
+            _(results[client_world.id]).must_equal :valid
           end
 
           it 'allows checking only, without actual invalidation' do
             client_world.coordinator.register_world(invalid_world)
             results = client_world.worlds_validity_check(false)
-            client_world.coordinator.find_worlds(false, id: invalid_world.id).wont_be_empty
+            _(client_world.coordinator.find_worlds(false, id: invalid_world.id)).wont_be_empty
 
-            results[invalid_world.id].must_equal :invalid
+            _(results[invalid_world.id]).must_equal :invalid
           end
 
           it 'allows to filter the worlds to run the check on' do
             client_world.coordinator.register_world(invalid_world)
             client_world.coordinator.register_world(invalid_world_2)
-            client_world.coordinator.find_worlds(false, id: [invalid_world.id, invalid_world_2.id]).size.must_equal 2
+            _(client_world.coordinator.find_worlds(false, id: [invalid_world.id, invalid_world_2.id]).size).must_equal 2
 
             results = client_world.worlds_validity_check(true, :id => invalid_world.id)
-            results.must_equal(invalid_world.id =>  :invalidated)
-            client_world.coordinator.find_worlds(false, id: [invalid_world.id, invalid_world_2.id]).size.must_equal 1
+            _(results).must_equal(invalid_world.id =>  :invalidated)
+            _(client_world.coordinator.find_worlds(false, id: [invalid_world.id, invalid_world_2.id]).size).must_equal 1
           end
         end
       end
@@ -327,22 +328,22 @@ module Dynflow
           before do
             client_world.coordinator.acquire(valid_lock)
             client_world.coordinator.acquire(invalid_lock)
-            current_locks.must_include(valid_lock)
-            current_locks.must_include(invalid_lock)
+            _(current_locks).must_include(valid_lock)
+            _(current_locks).must_include(invalid_lock)
           end
 
           it 'performs the validity check on world creation if auto_validity_check enabled' do
             world_with_auto_validity_check
-            current_locks.must_include(valid_lock)
-            current_locks.wont_include(invalid_lock)
+            _(current_locks).must_include(valid_lock)
+            _(current_locks).wont_include(invalid_lock)
           end
 
           it 'performs the validity check on world creation if auto_validity_check enabled' do
             invalid_locks = client_world.locks_validity_check
-            current_locks.must_include(valid_lock)
-            current_locks.wont_include(invalid_lock)
-            invalid_locks.must_include(invalid_lock)
-            invalid_locks.wont_include(valid_lock)
+            _(current_locks).must_include(valid_lock)
+            _(current_locks).wont_include(invalid_lock)
+            _(invalid_locks).must_include(invalid_lock)
+            _(invalid_locks).wont_include(valid_lock)
           end
         end
 
@@ -372,9 +373,9 @@ module Dynflow
             client_world.coordinator.acquire(invalid_lock2)
             invalid_locks = client_world.coordinator.clean_orphaned_locks
             # It must invalidate locks which are missing or in paused/stopped
-            invalid_locks.must_include(invalid_lock)
-            invalid_locks.must_include(invalid_lock2)
-            invalid_locks.wont_include(valid_lock)
+            _(invalid_locks).must_include(invalid_lock)
+            _(invalid_locks).must_include(invalid_lock2)
+            _(invalid_locks).wont_include(valid_lock)
           end
         end
       end

data/test/action_test.rb

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
 require_relative 'test_helper'
-require 'mocha/mini_test'
+require 'mocha/minitest'
 
 module Dynflow
   describe 'action' do
@@ -26,7 +27,7 @@ module Dynflow
         Action.from_hash(action_data.merge(step: step), world)
       end
 
-      specify { subject.class.name.must_equal 'RenamedAction' }
+      specify { _(subject.class.name).must_equal 'RenamedAction' }
       specify { assert subject.is_a? Action }
     end
 
@@ -35,16 +36,16 @@ module Dynflow
       smart_action_class   = Class.new(Dynflow::Action)
       smarter_action_class = Class.new(smart_action_class)
 
-      specify { smart_action_class.all_children.must_include smarter_action_class }
-      specify { smart_action_class.all_children.size.must_equal 1 }
+      specify { _(smart_action_class.all_children).must_include smarter_action_class }
+      specify { _(smart_action_class.all_children.size).must_equal 1 }
 
       describe 'World#subscribed_actions' do
         event_action_class      = Support::CodeWorkflowExample::Triage
         subscribed_action_class = Support::CodeWorkflowExample::NotifyAssignee
 
-        specify { subscribed_action_class.subscribe.must_equal event_action_class }
-        specify { world.subscribed_actions(event_action_class).must_include subscribed_action_class }
-        specify { world.subscribed_actions(event_action_class).size.must_equal 1 }
+        specify { _(subscribed_action_class.subscribe).must_equal event_action_class }
+        specify { _(world.subscribed_actions(event_action_class)).must_include subscribed_action_class }
+        specify { _(world.subscribed_actions(event_action_class).size).must_equal 1 }
       end
     end
 
@@ -52,7 +53,7 @@ module Dynflow
 
       let :execution_plan do
         result = world.trigger(Support::CodeWorkflowExample::IncomingIssues, issues_data)
-        result.must_be :planned?
+        _(result).must_be :planned?
         result.finished.value
       end
 
@@ -65,10 +66,10 @@ module Dynflow
         execution_plan.root_plan_step.action execution_plan
       end
 
-      specify { presenter.class.must_equal Support::CodeWorkflowExample::IncomingIssues }
+      specify { _(presenter.class).must_equal Support::CodeWorkflowExample::IncomingIssues }
 
       it 'allows aggregating data from other actions' do
-        presenter.summary.must_equal(assignees: ["John Doe"])
+        _(presenter.summary).must_equal(assignees: ["John Doe"])
       end
     end
 
@@ -78,7 +79,7 @@ module Dynflow
 
       it 'fails when input is not serializable' do
         klass = Class.new(Dynflow::Action)
-        -> { create_and_plan_action klass, key: Object.new }.must_raise NoMethodError
+        _(-> { create_and_plan_action klass, key: Object.new }).must_raise NoMethodError
       end
 
       it 'fails when output is not serializable' do
@@ -88,7 +89,7 @@ module Dynflow
           end
         end
         action = create_and_plan_action klass, {}
-        -> { run_action action }.must_raise NoMethodError
+        _(-> { run_action action }).must_raise NoMethodError
       end
     end
 
@@ -113,7 +114,56 @@ module Dynflow
       it 'is customizable from an action' do
         plan   = create_and_plan_action ActionWithHumanizedState, {}
         action = run_action(plan)
-        action.humanized_state.must_equal "waiting"
+        _(action.humanized_state).must_equal "waiting"
+      end
+    end
+
+    describe 'evented action' do
+      include Testing
+
+      class PlanEventedAction < Dynflow::Action
+        def run(event = nil)
+          case event
+          when "ping"
+            output[:status] = 'pinged'
+          when nil
+            plan_event('ping', input[:time])
+            suspend
+          else
+            self.output[:event] = event
+          end
+        end
+      end
+
+      it 'send planned event' do
+        plan = create_and_plan_action(PlanEventedAction, { time: 0.5 })
+        action = run_action plan
+
+        _(action.output[:status]).must_equal nil
+        _(action.world.clock.pending_pings.first).wont_be_nil
+        _(action.state).must_equal :suspended
+
+        progress_action_time action
+
+        _(action.output[:status]).must_equal 'pinged'
+        _(action.world.clock.pending_pings.first).must_be_nil
+        _(action.state).must_equal :success
+      end
+
+      it 'plans event immediately if no time is given' do
+        plan = create_and_plan_action(PlanEventedAction, { time: nil })
+        action = run_action plan
+
+        _(action.output[:status]).must_equal nil
+        _(action.world.clock.pending_pings.first).must_be_nil
+        _(action.world.executor.events_to_process.first).wont_be_nil
+        _(action.state).must_equal :suspended
+
+        action.world.executor.progress
+
+        _(action.output[:status]).must_equal 'pinged'
+        _(action.world.clock.pending_pings.first).must_be_nil
+        _(action.state).must_equal :success
       end
     end
 
@@ -222,7 +272,7 @@ module Dynflow
         end
       end
 
-      describe'without timeout' do
+      describe 'without timeout' do
         let(:plan) do
           create_and_plan_action TestPollingAction, { task_args: 'do something' }
         end
@@ -238,37 +288,37 @@ module Dynflow
         it 'initiates the external task' do
           action = run_action plan
 
-          action.output[:task][:task_id].must_equal 123
+          _(action.output[:task][:task_id]).must_equal 123
         end
 
         it 'polls till the task is done' do
           action = run_action plan
 
           9.times { progress_action_time action }
-          action.done?.must_equal false
-          next_ping(action).wont_be_nil
-          action.state.must_equal :suspended
+          _(action.done?).must_equal false
+          _(next_ping(action)).wont_be_nil
+          _(action.state).must_equal :suspended
 
           progress_action_time action
-          action.done?.must_equal true
-          next_ping(action).must_be_nil
-          action.state.must_equal :success
+          _(action.done?).must_equal true
+          _(next_ping(action)).must_be_nil
+          _(action.state).must_equal :success
         end
 
         it 'tries to poll for the old task when resuming' do
           action = run_action plan
-          action.output[:task][:progress].must_equal 0
+          _(action.output[:task][:progress]).must_equal 0
           run_action action
-          action.output[:task][:progress].must_equal 10
+          _(action.output[:task][:progress]).must_equal 10
         end
 
         it 'invokes the external task again when polling on the old one fails' do
           action = run_action plan
           action.world.silence_logger!
           action.external_service.will_fail
-          action.output[:task][:progress].must_equal 0
+          _(action.output[:task][:progress]).must_equal 0
           run_action action
-          action.output[:task][:progress].must_equal 0
+          _(action.output[:task][:progress]).must_equal 0
         end
 
         it 'tolerates some failure while polling' do
@@ -279,15 +329,15 @@ module Dynflow
           TestPollingAction.config.poll_max_retries = 3
           (1..2).each do |attempt|
             progress_action_time action
-            action.poll_attempts[:failed].must_equal attempt
-            next_ping(action).wont_be_nil
-            action.state.must_equal :suspended
+            _(action.poll_attempts[:failed]).must_equal attempt
+            _(next_ping(action)).wont_be_nil
+            _(action.state).must_equal :suspended
           end
 
           progress_action_time action
-          action.poll_attempts[:failed].must_equal 3
-          next_ping(action).must_be_nil
-          action.state.must_equal :error
+          _(action.poll_attempts[:failed]).must_equal 3
+          _(next_ping(action)).must_be_nil
+          _(action.state).must_equal :error
         end
 
         it 'allows increasing poll interval in a time' do
@@ -302,8 +352,8 @@ module Dynflow
           progress_action_time action
           pings << next_ping(action)
           progress_action_time action
-          (pings[1].when - pings[0].when).must_be_close_to 1
-          (pings[2].when - pings[1].when).must_be_close_to 2
+          _((pings[1].when - pings[0].when)).must_be_close_to 1
+          _((pings[2].when - pings[1].when)).must_be_close_to 2
         end
       end
 
@@ -324,10 +374,10 @@ module Dynflow
             # we count the number of iterations till the timeout occurs
             iterations += 1
           end
-          action.state.must_equal :error
+          _(action.state).must_equal :error
           # two polls in 2 seconds intervals untill the 5 seconds
           # timeout appears
-          iterations.must_equal 3
+          _(iterations).must_equal 3
         end
       end
     end
@@ -442,9 +492,9 @@ module Dynflow
 
       specify "the sub-plan stores the information about its parent" do
         sub_plans = execution_plan.sub_plans
-        sub_plans.size.must_equal 2
-        execution_plan.sub_plans_count.must_equal 2
-        sub_plans.each { |sub_plan| sub_plan.caller_execution_plan_id.must_equal execution_plan.id }
+        _(sub_plans.size).must_equal 2
+        _(execution_plan.sub_plans_count).must_equal 2
+        sub_plans.each { |sub_plan| _(sub_plan.caller_execution_plan_id).must_equal execution_plan.id }
       end
 
       specify "the parent and sub-plan actions return root_action? properly" do
@@ -456,7 +506,7 @@ module Dynflow
       end
 
       specify "it saves the information about number for sub plans in the output" do
-        execution_plan.entry_action.output.must_equal('total_count'   => 2,
+        _(execution_plan.entry_action.output).must_equal('total_count'   => 2,
                                                       'failed_count'  => 0,
                                                       'success_count' => 2,
                                                       'pending_count' => 0)
@@ -464,49 +514,49 @@ module Dynflow
 
       specify "when a sub plan fails, the caller action fails as well" do
         FailureSimulator.fail_in_child_run = true
-        execution_plan.entry_action.output.must_equal('total_count'   => 2,
+        _(execution_plan.entry_action.output).must_equal('total_count'   => 2,
                                                       'failed_count'  => 2,
                                                       'success_count' => 0,
                                                       'pending_count' => 0)
-        execution_plan.state.must_equal :paused
-        execution_plan.result.must_equal :error
+        _(execution_plan.state).must_equal :paused
+        _(execution_plan.result).must_equal :error
       end
 
       describe 'resuming' do
         specify "resuming the action depends on the resume method definition" do
           FailureSimulator.fail_in_child_plan = true
-          execution_plan.state.must_equal :paused
+          _(execution_plan.state).must_equal :paused
           FailureSimulator.fail_in_child_plan = false
           resumed_plan = world.execute(execution_plan.id).value
-          resumed_plan.entry_action.output[:custom_resume].must_equal true
+          _(resumed_plan.entry_action.output[:custom_resume]).must_equal true
         end
 
         specify "by default, when no sub plans were planned successfully, it call create_sub_plans again" do
           FailureSimulator.fail_in_child_plan = true
-          execution_plan.state.must_equal :paused
+          _(execution_plan.state).must_equal :paused
           FailureSimulator.fail_in_child_plan = false
           resumed_plan = world.execute(execution_plan.id).value
-          resumed_plan.state.must_equal :stopped
-          resumed_plan.result.must_equal :success
+          _(resumed_plan.state).must_equal :stopped
+          _(resumed_plan.result).must_equal :success
         end
 
         specify "by default, when any sub-plan was planned, it succeeds only when the sub-plans were already finished" do
           FailureSimulator.fail_in_child_run = true
-          execution_plan.state.must_equal :paused
+          _(execution_plan.state).must_equal :paused
           sub_plans = execution_plan.sub_plans
 
           FailureSimulator.fail_in_child_run = false
           resumed_plan = world.execute(execution_plan.id).value
-          resumed_plan.state.must_equal :paused
+          _(resumed_plan.state).must_equal :paused
 
           world.execute(sub_plans.first.id).wait
           resumed_plan = world.execute(execution_plan.id).value
-          resumed_plan.state.must_equal :paused
+          _(resumed_plan.state).must_equal :paused
 
           sub_plans.drop(1).each { |sub_plan| world.execute(sub_plan.id).wait }
           resumed_plan = world.execute(execution_plan.id).value
-          resumed_plan.state.must_equal :stopped
-          resumed_plan.result.must_equal :success
+          _(resumed_plan.state).must_equal :stopped
+          _(resumed_plan.result).must_equal :success
         end
 
         describe ::Dynflow::Action::WithPollingSubPlans do
@@ -520,18 +570,18 @@ module Dynflow
               total = 2
               FailureSimulator.fail_in_child_plan = true
               triggered_plan = world.trigger(PollingParentAction, count: total)
-              polling_plan = world.persistence.load_execution_plan(triggered_plan.id)
 
-              wait_for do # Waiting for the sub plans to be spawned
+              polling_plan = nil
+              wait_for('the subplans to be spawned') do
                 polling_plan = world.persistence.load_execution_plan(triggered_plan.id)
                 polling_plan.sub_plans_count == total
               end
 
               # Moving the clock to make the parent check on sub plans
-              clock.pending_pings.count.must_equal 1
+              _(clock.pending_pings.count).must_equal 1
               clock.progress
 
-              wait_for do # Waiting for the parent to realise the sub plans failed
+              wait_for('the parent to realise the sub plans failed') do
                 polling_plan = world.persistence.load_execution_plan(triggered_plan.id)
                 polling_plan.state == :paused
               end
@@ -540,15 +590,15 @@ module Dynflow
 
               world.execute(polling_plan.id) # The actual resume
 
-              wait_for do # Waiting for new generation of sub plans to be spawned
+              wait_for('new generation of sub plans to be spawned') do
                 polling_plan.sub_plans_count == 2 * total
               end
 
               # Move the clock again
-              clock.pending_pings.count.must_equal 1
+              _(clock.pending_pings.count).must_equal 1
               clock.progress
 
-              wait_for do # Waiting for everything to finish successfully
+              wait_for('everything to finish successfully') do
                 polling_plan = world.persistence.load_execution_plan(triggered_plan.id)
                 polling_plan.state == :stopped && polling_plan.result == :success
               end
@@ -569,9 +619,9 @@ module Dynflow
               end
 
               # Moving the clock to make the parent check on sub plans
-              clock.pending_pings.count.must_equal 1
+              _(clock.pending_pings.count).must_equal 1
               clock.progress
-              clock.pending_pings.count.must_equal 0
+              _(clock.pending_pings.count).must_equal 0
 
               wait_for do # Waiting for the parent to realise the sub plans failed
                 polling_plan = world.persistence.load_execution_plan(triggered_plan.id)
@@ -613,8 +663,8 @@ module Dynflow
           end
           plan.cancel
           triggered_plan.finished.wait
-          triggered_plan.finished.value.state.must_equal :stopped
-          triggered_plan.finished.value.result.must_equal :success
+          _(triggered_plan.finished.value.state).must_equal :stopped
+          _(triggered_plan.finished.value.result).must_equal :success
         end
 
         it "sends the abort event to all actions that are running and support cancelling" do
@@ -627,10 +677,10 @@ module Dynflow
           end
           plan.cancel true
           triggered_plan.finished.wait
-          triggered_plan.finished.value.state.must_equal :stopped
-          triggered_plan.finished.value.result.must_equal :success
+          _(triggered_plan.finished.value.state).must_equal :stopped
+          _(triggered_plan.finished.value.result).must_equal :success
           plan.sub_plans.each do |sub_plan|
-            sub_plan.entry_action.output[:aborted].must_equal true
+            _(sub_plan.entry_action.output[:aborted]).must_equal true
           end
         end
       end
@@ -645,20 +695,20 @@ module Dynflow
           world.stub :clock, clock do
             total = 2
             plan = world.plan(PollingParentAction, count: total)
-            plan.state.must_equal :planned
-            clock.pending_pings.count.must_equal 0
+            _(plan.state).must_equal :planned
+            _(clock.pending_pings.count).must_equal 0
             world.execute(plan.id)
             wait_for do
               plan.sub_plans_count == total &&
                 plan.sub_plans.all? { |sub| sub.result == :success }
             end
-            clock.pending_pings.count.must_equal 1
+            _(clock.pending_pings.count).must_equal 1
             clock.progress
             wait_for do
               plan = world.persistence.load_execution_plan(plan.id)
               plan.state == :stopped
             end
-            clock.pending_pings.count.must_equal 0
+            _(clock.pending_pings.count).must_equal 0
           end
         end
 
@@ -667,14 +717,14 @@ module Dynflow
             total = 2
             plan = world.plan(PollingBulkParentAction, count: total)
             assert_nil plan.entry_action.output[:planning_finished]
-            clock.pending_pings.count.must_equal 0
+            _(clock.pending_pings.count).must_equal 0
             world.execute(plan.id)
             wait_for do
               plan = world.persistence.load_execution_plan(plan.id)
               plan.entry_action.output[:planning_finished] == 1
             end
             # Poll was set during #initiate
-            clock.pending_pings.count.must_equal 1
+            _(clock.pending_pings.count).must_equal 1
 
             # Wait for the sub plans to finish
             wait_for do
@@ -688,14 +738,14 @@ module Dynflow
               plan = world.persistence.load_execution_plan(plan.id)
               plan.state == :stopped
             end
-            plan.entry_action.output[:poll].must_equal 1
-            clock.pending_pings.count.must_equal 0
+            _(plan.entry_action.output[:poll]).must_equal 1
+            _(clock.pending_pings.count).must_equal 0
           end
         end
 
         it 'handles empty sub plans when calculating progress' do
           action = create_and_plan_action(PollingBulkParentAction, :count => 0)
-          action.run_progress.must_equal 0.1
+          _(action.run_progress).must_equal 0.1
         end
 
         describe ::Dynflow::Action::Singleton do
@@ -737,58 +787,58 @@ module Dynflow
 
           it 'unlocks the locks after #plan if no #run or #finalize' 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 after #finalize' do
             plan = world.plan(SingletonActionWithFinalize)
-            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 'does not unlock when getting suspended' do
             plan = world.plan(SuspendedSingletonAction)
-            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
             future = world.execute(plan.id)
             wait_for do
               plan = world.persistence.load_execution_plan(plan.id)
               plan.state == :running && plan.result == :pending
             end
-            world.coordinator.find_locks(lock_filter).count.must_equal 1
+            _(world.coordinator.find_locks(lock_filter).count).must_equal 1
             world.event(plan.id, 2, nil)
             plan = future.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 'can be triggered only once' do
             # plan1 acquires the lock in plan phase
             plan1 = world.plan(SingletonActionWithRun)
-            plan1.state.must_equal :planned
-            plan1.result.must_equal :pending
+            _(plan1.state).must_equal :planned
+            _(plan1.result).must_equal :pending
 
             # plan2 tries to acquire the lock in plan phase and fails
             plan2 = world.plan(SingletonActionWithRun)
-            plan2.state.must_equal :stopped
-            plan2.result.must_equal :error
-            plan2.errors.first.message.must_equal 'Action Dynflow::SingletonActionWithRun is already active'
+            _(plan2.state).must_equal :stopped
+            _(plan2.result).must_equal :error
+            _(plan2.errors.first.message).must_equal 'Action Dynflow::SingletonActionWithRun is already active'
 
             # Simulate some bad things happening
             plan1.entry_action.send(:singleton_unlock!)
@@ -799,42 +849,42 @@ module Dynflow
             # plan1 tries to relock on run
             # This should fail because the lock was taken by plan3
             plan1 = world.execute(plan1.id).wait!.value
-            plan1.state.must_equal :paused
-            plan1.result.must_equal :error
+            _(plan1.state).must_equal :paused
+            _(plan1.result).must_equal :error
 
             # plan3 can finish successfully because it holds the lock
             plan3 = world.execute(plan3.id).wait!.value
-            plan3.state.must_equal :stopped
-            plan3.result.must_equal :success
+            _(plan3.state).must_equal :stopped
+            _(plan3.result).must_equal :success
 
             # The lock was released when plan3 stopped
             lock_filter = ::Dynflow::Coordinator::SingletonActionLock
                               .unique_filter plan3.entry_action.class.name
-            world.coordinator.find_locks(lock_filter).must_be :empty?
+            _(world.coordinator.find_locks(lock_filter)).must_be :empty?
           end
 
           it 'cannot be unlocked by another action' do
             # plan1 doesn't keep its locks
             plan1 = world.plan(BadAction, true)
-            plan1.state.must_equal :planned
+            _(plan1.state).must_equal :planned
             lock_filter = ::Dynflow::Coordinator::SingletonActionLock
                               .unique_filter plan1.entry_action.class.name
-            world.coordinator.find_locks(lock_filter).count.must_equal 0
+            _(world.coordinator.find_locks(lock_filter).count).must_equal 0
             plan2 = world.plan(BadAction, false)
-            plan2.state.must_equal :planned
-            world.coordinator.find_locks(lock_filter).count.must_equal 1
+            _(plan2.state).must_equal :planned
+            _(world.coordinator.find_locks(lock_filter).count).must_equal 1
 
             # The locks held by plan2 can't be unlocked by plan1
             plan1.entry_action.singleton_unlock!
-            world.coordinator.find_locks(lock_filter).count.must_equal 1
+            _(world.coordinator.find_locks(lock_filter).count).must_equal 1
 
             plan1 = world.execute(plan1.id).wait!.value
-            plan1.state.must_equal :paused
-            plan1.result.must_equal :error
+            _(plan1.state).must_equal :paused
+            _(plan1.result).must_equal :error
 
             plan2 = world.execute(plan2.id).wait!.value
-            plan2.state.must_equal :stopped
-            plan2.result.must_equal :success
+            _(plan2.state).must_equal :stopped
+            _(plan2.result).must_equal :success
           end
         end
       end