dynflow 1.3.0 → 1.4.0

data/test/future_execution_test.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require_relative 'test_helper'
 
 module Dynflow
@@ -17,7 +18,7 @@ module Dynflow
         let(:world) { WorldFactory.create_world }
         let(:delayed_plan) do
           delayed_plan = world.delay(::Support::DummyExample::Dummy, { :start_at => @start_at })
-          delayed_plan.must_be :scheduled?
+          _(delayed_plan).must_be :scheduled?
           world.persistence.load_delayed_plan(delayed_plan.execution_plan_id)
         end
         let(:history_names) do
@@ -31,40 +32,40 @@ module Dynflow
           it 'handles wrong plan state' do
             delayed_plan.execution_plan.state = :planning
             abstract_delayed_executor.send(:process, [delayed_plan], @start_at)
-            delayed_plan.execution_plan.state.must_equal :planned
+            _(delayed_plan.execution_plan.state).must_equal :planned
 
             delayed_plan.execution_plan.set_state(:running, true)
             abstract_delayed_executor.send(:process, [delayed_plan], @start_at)
-            delayed_plan.execution_plan.state.must_equal :running
+            _(delayed_plan.execution_plan.state).must_equal :running
           end
         end
 
         it 'returns the progress as 0' do
-          execution_plan.progress.must_equal 0
+          _(execution_plan.progress).must_equal 0
         end
 
         it 'marks the plan as failed when issues in serialied phase' do
           world.persistence.delete_execution_plans({})
-          e = proc { world.delay(::Support::DummyExample::DummyCustomDelaySerializer, { :start_at => @start_at }, :fail) }.must_raise RuntimeError
-          e.message.must_equal 'Enforced serializer failure'
+          e = _(proc { world.delay(::Support::DummyExample::DummyCustomDelaySerializer, { :start_at => @start_at }, :fail) }).must_raise RuntimeError
+          _(e.message).must_equal 'Enforced serializer failure'
           plan = world.persistence.find_execution_plans(page: 0, per_page: 1, order_by: :ended_at, desc: true).first
-          plan.state.must_equal :stopped
-          plan.result.must_equal :error
+          _(plan.state).must_equal :stopped
+          _(plan.result).must_equal :error
         end
 
         it 'delays the action' do
-          execution_plan.steps.count.must_equal 1
-          delayed_plan.start_at.inspect.must_equal (@start_at).inspect
-          history_names.call(execution_plan).must_equal ['delay']
+          _(execution_plan.steps.count).must_equal 1
+          _(delayed_plan.start_at.inspect).must_equal (@start_at).inspect
+          _(history_names.call(execution_plan)).must_equal ['delay']
         end
 
         it 'allows cancelling the delayed plan' do
-          execution_plan.state.must_equal :scheduled
-          execution_plan.cancellable?.must_equal true
+          _(execution_plan.state).must_equal :scheduled
+          _(execution_plan.cancellable?).must_equal true
           execution_plan.cancel.each(&:wait)
           execution_plan = world.persistence.load_execution_plan(self.execution_plan.id)
-          execution_plan.state.must_equal :stopped
-          execution_plan.result.must_equal :cancelled
+          _(execution_plan.state).must_equal :stopped
+          _(execution_plan.result).must_equal :cancelled
           assert_nil execution_plan.delay_record
         end
 
@@ -72,30 +73,30 @@ module Dynflow
           @start_at = Time.now.utc - 100
           delayed_plan
           past_delayed_plans = world.persistence.find_past_delayed_plans(@start_at + 10)
-          past_delayed_plans.length.must_equal 1
-          past_delayed_plans.first.execution_plan_uuid.must_equal execution_plan.id
+          _(past_delayed_plans.length).must_equal 1
+          _(past_delayed_plans.first.execution_plan_uuid).must_equal execution_plan.id
         end
 
         it 'delayed plans can be planned and executed' do
-          execution_plan.state.must_equal :scheduled
+          _(execution_plan.state).must_equal :scheduled
           delayed_plan.plan
-          execution_plan.state.must_equal :planned
-          execution_plan.result.must_equal :pending
+          _(execution_plan.state).must_equal :planned
+          _(execution_plan.result).must_equal :pending
           assert_planning_success execution_plan
-          history_names.call(execution_plan).must_equal ['delay']
+          _(history_names.call(execution_plan)).must_equal ['delay']
           delayed_plan.execute.future.wait
           executed = world.persistence.load_execution_plan(delayed_plan.execution_plan_uuid)
-          executed.state.must_equal :stopped
-          executed.result.must_equal :success
-          executed.execution_history.count.must_equal 3
+          _(executed.state).must_equal :stopped
+          _(executed.result).must_equal :success
+          _(executed.execution_history.count).must_equal 3
         end
 
         it 'expired plans can be failed' do
           delayed_plan.timeout
-          execution_plan.state.must_equal :stopped
-          execution_plan.result.must_equal :error
-          execution_plan.errors.first.message.must_match /could not be started before set time/
-          history_names.call(execution_plan).must_equal %W(delay timeout)
+          _(execution_plan.state).must_equal :stopped
+          _(execution_plan.result).must_equal :error
+          _(execution_plan.errors.first.message).must_match /could not be started before set time/
+          _(history_names.call(execution_plan)).must_equal %W(delay timeout)
         end
 
       end
@@ -112,18 +113,18 @@ module Dynflow
           persistence.expect(:find_past_delayed_plans, [], [start_time])
           persistence.expect(:find_past_delayed_plans, [], [start_time + options[:poll_interval]])
           dummy_world.stub :persistence, persistence do
-            klok.pending_pings.length.must_equal 0
+            _(klok.pending_pings.length).must_equal 0
             delayed_executor.start.wait
-            klok.pending_pings.length.must_equal 1
-            klok.pending_pings.first.who.ref.must_be_same_as delayed_executor.core
-            klok.pending_pings.first.when.must_equal start_time + options[:poll_interval]
+            _(klok.pending_pings.length).must_equal 1
+            _(klok.pending_pings.first.who.ref).must_be_same_as delayed_executor.core
+            _(klok.pending_pings.first.when).must_equal start_time + options[:poll_interval]
             klok.progress
             delayed_executor.terminate.wait
-            klok.pending_pings.length.must_equal 1
-            klok.pending_pings.first.who.ref.must_be_same_as delayed_executor.core
-            klok.pending_pings.first.when.must_equal start_time + 2 * options[:poll_interval]
+            _(klok.pending_pings.length).must_equal 1
+            _(klok.pending_pings.first.who.ref).must_be_same_as delayed_executor.core
+            _(klok.pending_pings.first.when).must_equal start_time + 2 * options[:poll_interval]
             klok.progress
-            klok.pending_pings.length.must_equal 0
+            _(klok.pending_pings.length).must_equal 0
           end
         end
       end
@@ -149,27 +150,27 @@ module Dynflow
 
         it 'noop serializer [de]serializes correctly for simple types' do
           input = [1, 2.0, 'three', ['four-1', 'four-2'], { 'five' => 5 }]
-          simulated_use.call(Dynflow::Serializers::Noop, input).must_equal input
+          _(simulated_use.call(Dynflow::Serializers::Noop, input)).must_equal input
         end
 
         it 'args! raises if not deserialized' do
-          proc { serialized_serializer.args! }.must_raise RuntimeError
+          _(proc { serialized_serializer.args! }).must_raise RuntimeError
           deserialized_serializer.args! # Must not raise
         end
 
         it 'serialized_args! raises if not serialized' do
-          proc { deserialized_serializer.serialized_args! }.must_raise RuntimeError
+          _(proc { deserialized_serializer.serialized_args! }).must_raise RuntimeError
           serialized_serializer.serialized_args! # Must not raise
         end
 
         it 'performs_serialization!' do
           deserialized_serializer.perform_serialization!
-          deserialized_serializer.serialized_args!.must_equal args
+          _(deserialized_serializer.serialized_args!).must_equal args
         end
 
         it 'performs_deserialization!' do
           serialized_serializer.perform_deserialization!
-          serialized_serializer.args.must_equal args
+          _(serialized_serializer.args).must_equal args
         end
       end
 
@@ -181,9 +182,9 @@ module Dynflow
         end
 
         it "allows access to serializer's args" do
-          serializer.args.must_be :nil?
-          delayed_plan.args.must_equal args
-          serializer.args.must_equal args
+          _(serializer.args).must_be :nil?
+          _(delayed_plan.args).must_equal args
+          _(serializer.args).must_equal args
         end
       end
     end

data/test/memory_cosumption_watcher_test.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require_relative 'test_helper'
 require 'fileutils'
 require 'dynflow/watchers/memory_consumption_watcher'
@@ -12,7 +13,7 @@ module Dynflow
           world.expect(:clock, clock)
           init_interval = 1000
           clock.expect(:ping, true) do |clock_who, clock_when, _|
-            clock_when.must_equal init_interval
+            _(clock_when).must_equal init_interval
           end
 
           Dynflow::Watchers::MemoryConsumptionWatcher.new world, 1, initial_wait: init_interval
@@ -30,11 +31,11 @@ module Dynflow
           init_interval = 1000
           polling_interval = 2000
           clock.expect(:ping, true) do |clock_who, clock_when, _|
-            clock_when.must_equal init_interval
+            _(clock_when).must_equal init_interval
             true
           end
           clock.expect(:ping, true) do |clock_who, clock_when, _|
-            clock_when.must_equal polling_interval
+            _(clock_when).must_equal polling_interval
             true
           end
           memory_info_provider.expect(:bytes, 0)
@@ -63,7 +64,7 @@ module Dynflow
 
           init_interval = 1000
           clock.expect(:ping, true) do |clock_who, clock_when, _|
-            clock_when.must_equal init_interval
+            _(clock_when).must_equal init_interval
             true
           end
           memory_info_provider.expect(:bytes, 10)

data/test/middleware_test.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require_relative 'test_helper'
 
 module Dynflow
@@ -16,31 +17,31 @@ module Dynflow
         plan = world.persistence.load_delayed_plan delay.execution_plan_id
         plan.plan
         plan.execute.future.wait
-        log.must_equal %w[LogMiddleware::before_delay
-                          delay
-                          LogMiddleware::after_delay
-                          LogMiddleware::before_plan_phase
-                          LogMiddleware::before_plan
-                          plan
-                          LogMiddleware::after_plan
-                          LogMiddleware::after_plan_phase
-                          LogMiddleware::before_run
-                          run
-                          LogMiddleware::after_run
-                          LogMiddleware::before_finalize_phase
-                          LogMiddleware::before_finalize
-                          finalize
-                          LogMiddleware::after_finalize
-                          LogMiddleware::after_finalize_phase]
+        _(log).must_equal %w[LogMiddleware::before_delay
+                             delay
+                             LogMiddleware::after_delay
+                             LogMiddleware::before_plan_phase
+                             LogMiddleware::before_plan
+                             plan
+                             LogMiddleware::after_plan
+                             LogMiddleware::after_plan_phase
+                             LogMiddleware::before_run
+                             run
+                             LogMiddleware::after_run
+                             LogMiddleware::before_finalize_phase
+                             LogMiddleware::before_finalize
+                             finalize
+                             LogMiddleware::after_finalize
+                             LogMiddleware::after_finalize_phase]
       end
 
       it "inherits the middleware" do
         world.trigger(Support::MiddlewareExample::SubAction, {}).finished.wait
-        log.must_equal %w[LogRunMiddleware::before_run
-                          AnotherLogRunMiddleware::before_run
-                          run
-                          AnotherLogRunMiddleware::after_run
-                          LogRunMiddleware::after_run]
+        _(log).must_equal %w[LogRunMiddleware::before_run
+                             AnotherLogRunMiddleware::before_run
+                             run
+                             AnotherLogRunMiddleware::after_run
+                             LogRunMiddleware::after_run]
       end
 
       describe "world.middleware" do
@@ -52,11 +53,11 @@ module Dynflow
 
         it "puts the middleware to the beginning of the stack" do
           world_with_middleware.trigger(Support::MiddlewareExample::Action, {}).finished.wait
-          log.must_equal %w[AnotherLogRunMiddleware::before_run
-                            LogRunMiddleware::before_run
-                            run
-                            LogRunMiddleware::after_run
-                            AnotherLogRunMiddleware::after_run]
+          _(log).must_equal %w[AnotherLogRunMiddleware::before_run
+                               LogRunMiddleware::before_run
+                               run
+                               LogRunMiddleware::after_run
+                               AnotherLogRunMiddleware::after_run]
         end
       end
 
@@ -64,11 +65,11 @@ module Dynflow
         describe "before" do
           specify do
             world.trigger(Support::MiddlewareExample::SubActionBeforeRule, {}).finished.wait
-            log.must_equal %w[AnotherLogRunMiddleware::before_run
-                              LogRunMiddleware::before_run
-                              run
-                              LogRunMiddleware::after_run
-                              AnotherLogRunMiddleware::after_run]
+            _(log).must_equal %w[AnotherLogRunMiddleware::before_run
+                                 LogRunMiddleware::before_run
+                                 run
+                                 LogRunMiddleware::after_run
+                                 AnotherLogRunMiddleware::after_run]
           end
         end
 
@@ -83,27 +84,27 @@ module Dynflow
 
           specify do
             world_with_middleware.trigger(Support::MiddlewareExample::Action, {}).finished.wait
-            log.must_equal %w[LogRunMiddleware::before_run
-                              AnotherLogRunMiddleware::before_run
-                              run
-                              AnotherLogRunMiddleware::after_run
-                              LogRunMiddleware::after_run]
+            _(log).must_equal %w[LogRunMiddleware::before_run
+                                 AnotherLogRunMiddleware::before_run
+                                 run
+                                 AnotherLogRunMiddleware::after_run
+                                 LogRunMiddleware::after_run]
           end
         end
 
         describe "replace" do
           specify do
             world.trigger(Support::MiddlewareExample::SubActionReplaceRule, {}).finished.wait
-            log.must_equal %w[AnotherLogRunMiddleware::before_run
-                              run
-                              AnotherLogRunMiddleware::after_run]
+            _(log).must_equal %w[AnotherLogRunMiddleware::before_run
+                                 run
+                                 AnotherLogRunMiddleware::after_run]
           end
         end
 
         describe "remove" do
           specify do
             world.trigger(Support::MiddlewareExample::SubActionDoNotUseRule, {}).finished.wait
-            log.must_equal %w[run]
+            _(log).must_equal %w[run]
           end
         end
       end
@@ -113,9 +114,9 @@ module Dynflow
         world.middleware.use(Support::MiddlewareExample::ObservingMiddleware,
                              replace: Support::MiddlewareExample::LogRunMiddleware)
         world.trigger(Support::MiddlewareExample::Action, message: 'hello').finished.wait
-        log.must_equal %w[input#message:hello
-                          run
-                          output#message:finished]
+        _(log).must_equal %w[input#message:hello
+                             run
+                             output#message:finished]
       end
 
       it "allows modification of the running action when delaying execution" do
@@ -126,11 +127,11 @@ module Dynflow
         plan = world.persistence.load_delayed_plan delay.execution_plan_id
         plan.plan
         plan.execute.future.wait
-        log.must_equal ["delay#set-input:#{world.id}",
-                        "plan#input:#{world.id}",
-                        "input#message:#{world.id}",
-                        'run',
-                        'output#message:finished']
+        _(log).must_equal ["delay#set-input:#{world.id}",
+                           "plan#input:#{world.id}",
+                           "input#message:#{world.id}",
+                           'run',
+                           'output#message:finished']
       end
 
       describe 'Presnet middleware' do
@@ -142,13 +143,13 @@ module Dynflow
 
         let :execution_plan do
           result = world.trigger(Support::CodeWorkflowExample::IncomingIssue, issue_data)
-          result.must_be :planned?
+          _(result).must_be :planned?
           result.finished.value
         end
 
         let :execution_plan_2 do
           result = world.trigger(Support::MiddlewareExample::SecretAction)
-          result.must_be :planned?
+          _(result).must_be :planned?
           result.finished.value
         end
 
@@ -173,13 +174,13 @@ module Dynflow
         end
 
         it 'filters the data ===' do
-          presenter.input['text'].must_equal('You-Know-Who is comming')
-          presenter_2.output['spell'].must_equal('***')
+          _(presenter.input['text']).must_equal('You-Know-Who is comming')
+          _(presenter_2.output['spell']).must_equal('***')
         end
 
         it "doesn't affect stored data" do
-          presenter.input['text'].must_equal('You-Know-Who is comming')
-          presenter_without_middleware.input['text'].must_equal('Lord Voldemort is comming')
+          _(presenter.input['text']).must_equal('You-Know-Who is comming')
+          _(presenter_without_middleware.input['text']).must_equal('Lord Voldemort is comming')
         end
       end
 

data/test/persistence_test.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require_relative 'test_helper'
 require 'tmpdir'
 
@@ -84,11 +85,13 @@ module Dynflow
         original.each do |key, value|
           loaded_value = loaded[key.to_s]
           if value.is_a?(Time)
-            loaded_value.inspect.must_equal value.inspect
+            _(loaded_value.inspect).must_equal value.inspect
           elsif value.is_a?(Hash)
             assert_equal_attributes!(value, loaded_value)
+          elsif value.nil?
+            assert_nil loaded[key.to_s]
           else
-            loaded[key.to_s].must_equal value
+            _(loaded[key.to_s]).must_equal value
           end
         end
       end
@@ -104,10 +107,10 @@ module Dynflow
             prepare_and_save_plans
             if adapter.pagination?
               loaded_plans = adapter.find_execution_plans(page: 0, per_page: 1)
-              loaded_plans.map { |h| h[:id] }.must_equal ['plan1']
+              _(loaded_plans.map { |h| h[:id] }).must_equal ['plan1']
 
               loaded_plans = adapter.find_execution_plans(page: 1, per_page: 1)
-              loaded_plans.map { |h| h[:id] }.must_equal ['plan2']
+              _(loaded_plans.map { |h| h[:id] }).must_equal ['plan2']
             end
           end
 
@@ -115,10 +118,10 @@ module Dynflow
             prepare_and_save_plans
             if adapter.ordering_by.include?('state')
               loaded_plans = adapter.find_execution_plans(order_by: 'state')
-              loaded_plans.map { |h| h[:id] }.must_equal %w(plan1 plan3 plan4 plan2)
+              _(loaded_plans.map { |h| h[:id] }).must_equal %w(plan1 plan3 plan4 plan2)
 
               loaded_plans = adapter.find_execution_plans(order_by: 'state', desc: true)
-              loaded_plans.map { |h| h[:id] }.must_equal %w(plan2 plan1 plan3 plan4)
+              _(loaded_plans.map { |h| h[:id] }).must_equal %w(plan2 plan1 plan3 plan4)
             end
           end
 
@@ -126,31 +129,31 @@ module Dynflow
             prepare_and_save_plans
             if adapter.ordering_by.include?('state')
               loaded_plans = adapter.find_execution_plans(filters: { label: ['test1'] })
-              loaded_plans.map { |h| h[:id] }.must_equal ['plan1']
+              _(loaded_plans.map { |h| h[:id] }).must_equal ['plan1']
               loaded_plans = adapter.find_execution_plans(filters: { state: ['paused'] })
-              loaded_plans.map { |h| h[:id] }.must_equal ['plan1', 'plan3', 'plan4']
+              _(loaded_plans.map { |h| h[:id] }).must_equal ['plan1', 'plan3', 'plan4']
 
               loaded_plans = adapter.find_execution_plans(filters: { state: ['stopped'] })
-              loaded_plans.map { |h| h[:id] }.must_equal ['plan2']
+              _(loaded_plans.map { |h| h[:id] }).must_equal ['plan2']
 
               loaded_plans = adapter.find_execution_plans(filters: { state: [] })
-              loaded_plans.map { |h| h[:id] }.must_equal []
+              _(loaded_plans.map { |h| h[:id] }).must_equal []
 
               loaded_plans = adapter.find_execution_plans(filters: { state: ['stopped', 'paused'] })
-              loaded_plans.map { |h| h[:id] }.must_equal %w(plan1 plan2 plan3 plan4)
+              _(loaded_plans.map { |h| h[:id] }).must_equal %w(plan1 plan2 plan3 plan4)
 
               loaded_plans = adapter.find_execution_plans(filters: { 'state' => ['stopped', 'paused'] })
-              loaded_plans.map { |h| h[:id] }.must_equal %w(plan1 plan2 plan3 plan4)
+              _(loaded_plans.map { |h| h[:id] }).must_equal %w(plan1 plan2 plan3 plan4)
 
               loaded_plans = adapter.find_execution_plans(filters: { label: ['test1'], :delayed => true })
-              loaded_plans.must_be_empty
+              _(loaded_plans).must_be_empty
 
               adapter.save_delayed_plan('plan1',
                                         :execution_plan_uuid => 'plan1',
                                         :start_at => format_time(Time.now + 60),
                                         :start_before => format_time(Time.now - 60))
               loaded_plans = adapter.find_execution_plans(filters: { label: ['test1'], :delayed => true })
-              loaded_plans.map { |h| h[:id] }.must_equal ['plan1']
+              _(loaded_plans.map { |h| h[:id] }).must_equal ['plan1']
             end
           end
         end
@@ -165,57 +168,57 @@ module Dynflow
             prepare_and_save_plans
             if adapter.ordering_by.include?('state')
               loaded_plans = adapter.find_execution_plan_counts(filters: { label: ['test1'] })
-              loaded_plans.must_equal 1
+              _(loaded_plans).must_equal 1
               loaded_plans = adapter.find_execution_plan_counts(filters: { state: ['paused'] })
-              loaded_plans.must_equal 3
+              _(loaded_plans).must_equal 3
 
               loaded_plans = adapter.find_execution_plan_counts(filters: { state: ['stopped'] })
-              loaded_plans.must_equal 1
+              _(loaded_plans).must_equal 1
 
               loaded_plans = adapter.find_execution_plan_counts(filters: { state: [] })
-              loaded_plans.must_equal 0
+              _(loaded_plans).must_equal 0
 
               loaded_plans = adapter.find_execution_plan_counts(filters: { state: ['stopped', 'paused'] })
-              loaded_plans.must_equal 4
+              _(loaded_plans).must_equal 4
 
               loaded_plans = adapter.find_execution_plan_counts(filters: { 'state' => ['stopped', 'paused'] })
-              loaded_plans.must_equal 4
+              _(loaded_plans).must_equal 4
 
               loaded_plans = adapter.find_execution_plan_counts(filters: { label: ['test1'], :delayed => true })
-              loaded_plans.must_equal 0
+              _(loaded_plans).must_equal 0
 
               adapter.save_delayed_plan('plan1',
                                         :execution_plan_uuid => 'plan1',
                                         :start_at => format_time(Time.now + 60),
                                         :start_before => format_time(Time.now - 60))
               loaded_plans = adapter.find_execution_plan_counts(filters: { label: ['test1'], :delayed => true })
-              loaded_plans.must_equal 1
+              _(loaded_plans).must_equal 1
             end
           end
         end
 
         describe '#load_execution_plan and #save_execution_plan' do
           it 'serializes/deserializes the plan data' do
-            -> { adapter.load_execution_plan('plan1') }.must_raise KeyError
+            _(-> { adapter.load_execution_plan('plan1') }).must_raise KeyError
             plan = prepare_and_save_plans.first
             loaded_plan = adapter.load_execution_plan('plan1')
-            loaded_plan[:id].must_equal 'plan1'
-            loaded_plan['id'].must_equal 'plan1'
+            _(loaded_plan[:id]).must_equal 'plan1'
+            _(loaded_plan['id']).must_equal 'plan1'
 
             assert_equal_attributes!(plan, loaded_plan)
 
             adapter.save_execution_plan('plan1', nil)
-            -> { adapter.load_execution_plan('plan1') }.must_raise KeyError
+            _(-> { adapter.load_execution_plan('plan1') }).must_raise KeyError
           end
         end
 
         describe '#delete_execution_plans' do
           it 'deletes selected execution plans, including steps and actions' do
             prepare_plans_with_steps
-            adapter.delete_execution_plans('uuid' => 'plan1').must_equal 1
-            -> { adapter.load_execution_plan('plan1') }.must_raise KeyError
-            -> { adapter.load_action('plan1', action_data[:id]) }.must_raise KeyError
-            -> { adapter.load_step('plan1', step_data[:id]) }.must_raise KeyError
+            _(adapter.delete_execution_plans('uuid' => 'plan1')).must_equal 1
+            _(-> { adapter.load_execution_plan('plan1') }).must_raise KeyError
+            _(-> { adapter.load_action('plan1', action_data[:id]) }).must_raise KeyError
+            _(-> { adapter.load_step('plan1', step_data[:id]) }).must_raise KeyError
 
             # testing that no other plans where affected
             adapter.load_execution_plan('plan2')
@@ -223,16 +226,16 @@ module Dynflow
             adapter.load_step('plan2', step_data[:id])
 
             prepare_plans_with_steps
-            adapter.delete_execution_plans('state' => 'paused').must_equal 3
-            -> { adapter.load_execution_plan('plan1') }.must_raise KeyError
+            _(adapter.delete_execution_plans('state' => 'paused')).must_equal 3
+            _(-> { adapter.load_execution_plan('plan1') }).must_raise KeyError
             adapter.load_execution_plan('plan2') # nothing raised
-            -> { adapter.load_execution_plan('plan3') }.must_raise KeyError
+            _(-> { adapter.load_execution_plan('plan3') }).must_raise KeyError
           end
 
           it 'creates backup dir and produce backup including steps and actions' do
             prepare_plans_with_steps
             Dir.mktmpdir do |backup_dir|
-              adapter.delete_execution_plans({'uuid' => 'plan1'}, 100, backup_dir).must_equal 1
+              _(adapter.delete_execution_plans({'uuid' => 'plan1'}, 100, backup_dir)).must_equal 1
               plans = CSV.read(backup_dir + "/execution_plans.csv", :headers => true)
               assert_equal 1, plans.count
               assert_equal 'plan1', plans.first.to_hash['uuid']
@@ -251,16 +254,16 @@ module Dynflow
             prepare_and_save_plans
             action = action_data.dup
             action_id = action_data[:id]
-            -> { adapter.load_action('plan1', action_id) }.must_raise KeyError
+            _(-> { adapter.load_action('plan1', action_id) }).must_raise KeyError
 
             prepare_action('plan1')
             loaded_action = adapter.load_action('plan1', action_id)
-            loaded_action[:id].must_equal action_id
+            _(loaded_action[:id]).must_equal action_id
 
             assert_equal_attributes!(action, loaded_action)
 
             adapter.save_action('plan1', action_id, nil)
-            -> { adapter.load_action('plan1', action_id) }.must_raise KeyError
+            _(-> { adapter.load_action('plan1', action_id) }).must_raise KeyError
 
             adapter.save_execution_plan('plan1', nil)
           end
@@ -269,9 +272,9 @@ module Dynflow
             prepare_and_save_plans
             prepare_action('plan1')
             loaded_data = adapter.load_actions_attributes('plan1', [:id, :run_step_id]).first
-            loaded_data.keys.count.must_equal 2
-            loaded_data[:id].must_equal action_data[:id]
-            loaded_data[:run_step_id].must_equal action_data[:run_step_id]
+            _(loaded_data.keys.count).must_equal 2
+            _(loaded_data[:id]).must_equal action_data[:id]
+            _(loaded_data[:run_step_id]).must_equal action_data[:run_step_id]
           end
 
           it 'allows to load actions in bulk using #load_actions' do
@@ -279,7 +282,7 @@ module Dynflow
             prepare_action('plan1')
             action = action_data.dup
             loaded_actions = adapter.load_actions('plan1', [1])
-            loaded_actions.count.must_equal 1
+            _(loaded_actions.count).must_equal 1
             loaded_action = loaded_actions.first
 
             assert_equal_attributes!(action, loaded_action)
@@ -292,7 +295,7 @@ module Dynflow
             step_id = step_data[:id]
             prepare_and_save_step('plan1')
             loaded_step = adapter.load_step('plan1', step_id)
-            loaded_step[:id].must_equal step_id
+            _(loaded_step[:id]).must_equal step_id
 
             assert_equal_attributes!(step_data, loaded_step)
           end
@@ -309,8 +312,8 @@ module Dynflow
             adapter.save_delayed_plan('plan4', :execution_plan_uuid => 'plan4', :frozen => false, :start_at => format_time(start_time - 60),
                                       :start_before => format_time(start_time - 60))
             plans = adapter.find_past_delayed_plans(start_time)
-            plans.length.must_equal 3
-            plans.map { |plan| plan[:execution_plan_uuid] }.must_equal %w(plan2 plan4 plan1)
+            _(plans.length).must_equal 3
+            _(plans.map { |plan| plan[:execution_plan_uuid] }).must_equal %w(plan2 plan4 plan1)
           end
 
           it 'does not find plans that are frozen' do
@@ -323,8 +326,8 @@ module Dynflow
                                       :start_before => format_time(start_time - 60))
 
             plans = adapter.find_past_delayed_plans(start_time)
-            plans.length.must_equal 1
-            plans.first[:execution_plan_uuid].must_equal 'plan1'
+            _(plans.length).must_equal 1
+            _(plans.first[:execution_plan_uuid]).must_equal 'plan1'
           end
         end
       end
@@ -342,11 +345,11 @@ module Dynflow
             adapter.class::META_DATA.fetch(:execution_plan).each do |name|
               value = original.fetch(name.to_sym)
               if value.nil?
-                stored.fetch(name.to_sym).must_be_nil
+                assert_nil stored.fetch(name.to_sym)
               elsif value.is_a?(Time)
-                stored.fetch(name.to_sym).inspect.must_equal value.inspect
+                _(stored.fetch(name.to_sym).inspect).must_equal value.inspect
               else
-                stored.fetch(name.to_sym).must_equal value
+                _(stored.fetch(name.to_sym)).must_equal value
               end
             end
           end
@@ -356,8 +359,8 @@ module Dynflow
           client_world_id   = '5678'
           executor_world_id = '1234'
           envelope_hash = ->(envelope) { Dynflow::Utils.indifferent_hash(Dynflow.serializer.dump(envelope)) }
-          executor_envelope = envelope_hash.call(Dispatcher::Envelope[123, client_world_id, executor_world_id, Dispatcher::Execution['111']])
-          client_envelope   = envelope_hash.call(Dispatcher::Envelope[123, executor_world_id, client_world_id, Dispatcher::Accepted])
+          executor_envelope = envelope_hash.call(Dispatcher::Envelope['123', client_world_id, executor_world_id, Dispatcher::Execution['111']])
+          client_envelope   = envelope_hash.call(Dispatcher::Envelope['123', executor_world_id, client_world_id, Dispatcher::Accepted])
           envelopes         = [client_envelope, executor_envelope]
 
           envelopes.each { |e| adapter.push_envelope(e) }
@@ -418,8 +421,8 @@ module Dynflow
 
           # Check the plan has the changed columns populated
           raw_plan = db[:dynflow_execution_plans].where(:uuid => 'plan1').first
-          raw_plan[:state].must_equal 'stopped'
-          raw_plan[:result].must_equal 'success'
+          _(raw_plan[:state]).must_equal 'stopped'
+          _(raw_plan[:result]).must_equal 'success'
 
           # Load the plan and assert it doesn't read attributes from data
           loaded_plan = adapter.load_execution_plan(plan[:id])