dynflow 1.8.2 → 1.8.4

data/test/execution_plan_test.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 
 module Dynflow
   module ExecutionPlanTest
     describe ExecutionPlan do
-
       include PlanAssertions
 
       let(:world) { WorldFactory.create_world }
@@ -15,7 +15,6 @@ module Dynflow
       end
 
       describe 'serialization' do
-
         let :execution_plan do
           world.plan(Support::CodeWorkflowExample::FastCommit, 'sha' => 'abc123')
         end
@@ -25,7 +24,6 @@ module Dynflow
         end
 
         describe 'serialized execution plan' do
-
           before { execution_plan.save }
           after { world.persistence.delete_execution_plans(:uuid => execution_plan.id) }
 
@@ -46,26 +44,24 @@ module Dynflow
 
           it 'handles issues with loading the data' do
             world.persistence.adapter.send(:table, :step)
-              .where(execution_plan_uuid: execution_plan.id).delete
+                 .where(execution_plan_uuid: execution_plan.id).delete
             refute deserialized_execution_plan.valid?
             assert_equal Dynflow::Errors::DataConsistencyError, deserialized_execution_plan.exception.class
             [:label, :state, :started_at, :ended_at].each do |attr|
               assert_equal execution_plan.send(attr).to_s,
-                           deserialized_execution_plan.send(attr).to_s,
-                           "invalid plan is supposed to still store #{attr}"
+                deserialized_execution_plan.send(attr).to_s,
+                "invalid plan is supposed to still store #{attr}"
             end
             [:execution_time, :real_time].each do |attr|
               assert_equal execution_plan.send(attr).to_f,
-                           deserialized_execution_plan.send(attr).to_f,
-                           "invalid plan is supposed to still store #{attr}"
+                deserialized_execution_plan.send(attr).to_f,
+                "invalid plan is supposed to still store #{attr}"
             end
             assert_equal execution_plan.execution_history.events,
-                         deserialized_execution_plan.execution_history.events,
-                         "invalid plan is supposed to still store execution history"
+              deserialized_execution_plan.execution_history.events,
+              "invalid plan is supposed to still store execution history"
           end
-
         end
-
       end
 
       describe '#label' do
@@ -83,24 +79,20 @@ module Dynflow
         end
       end
       describe '#result' do
-
         let :execution_plan do
           world.plan(Support::CodeWorkflowExample::FastCommit, 'sha' => 'abc123')
         end
 
         describe 'for error in planning phase' do
-
           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
           end
-
         end
 
         describe 'for error in running phase' do
-
           before do
             step_id = execution_plan.run_flow.all_step_ids[2]
             execution_plan.steps[step_id].set_state :error, true
@@ -109,11 +101,9 @@ module Dynflow
           it 'should be :error' do
             _(execution_plan.result).must_equal :error
           end
-
         end
 
         describe 'for pending step in running phase' do
-
           before do
             step_id = execution_plan.run_flow.all_step_ids[2]
             execution_plan.steps[step_id].set_state :pending, true
@@ -122,11 +112,9 @@ module Dynflow
           it 'should be :pending' do
             _(execution_plan.result).must_equal :pending
           end
-
         end
 
         describe 'for all steps successful or skipped' do
-
           before do
             execution_plan.run_flow.all_step_ids.each_with_index do |step_id, index|
               step = execution_plan.steps[step_id]
@@ -137,9 +125,7 @@ module Dynflow
           it 'should be :warning' do
             _(execution_plan.result).must_equal :warning
           end
-
         end
-
       end
 
       describe 'sub plans' do
@@ -171,11 +157,9 @@ module Dynflow
                   NotifyAssignee
           PLAN_STEPS
         end
-
       end
 
       describe 'persisted action' do
-
         let :execution_plan do
           world.plan(Support::CodeWorkflowExample::IncomingIssues, issues_data)
         end
@@ -206,7 +190,6 @@ module Dynflow
       end
 
       describe 'planning algorithm' do
-
         describe 'single dependencies' do
           let :execution_plan do
             world.plan(Support::CodeWorkflowExample::IncomingIssues, issues_data)
@@ -225,7 +208,6 @@ module Dynflow
                   18: NotifyAssignee(pending) {"triage"=>Step(13).output}
             RUN_FLOW
           end
-
         end
 
         describe 'error in planning phase' do
@@ -286,7 +268,6 @@ module Dynflow
         end
 
         describe 'finalize flow' do
-
           let :execution_plan do
             world.plan(Support::CodeWorkflowExample::IncomingIssues, issues_data)
           end
@@ -301,7 +282,6 @@ module Dynflow
                 20: IncomingIssues(pending) {\"issues\"=>[{\"author\"=>\"Peter Smith\", \"text\"=>\"Failing test\"}, {\"author\"=>\"John Doe\", \"text\"=>\"Internal server error\"}]}
             RUN_FLOW
           end
-
         end
       end
 
@@ -355,7 +335,6 @@ module Dynflow
       end
 
       describe ExecutionPlan::Steps::Error do
-
         it "doesn't fail when deserializing with missing class" do
           error = ExecutionPlan::Steps::Error.new_from_hash(exception_class: "RenamedError",
                                                             message: "This errror is not longer here",
@@ -364,7 +343,6 @@ module Dynflow
           _(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
 
       describe 'with singleton actions' do
@@ -382,7 +360,7 @@ module Dynflow
           plan = world.plan(SingletonAction)
           _(plan.state).must_equal :planned
           lock_filter = ::Dynflow::Coordinator::SingletonActionLock
-                          .unique_filter plan.entry_action.class.name
+                        .unique_filter plan.entry_action.class.name
           _(world.coordinator.find_locks(lock_filter).count).must_equal 1
           plan = world.execute(plan.id).wait!.value
           _(plan.state).must_equal :stopped
@@ -394,7 +372,7 @@ module Dynflow
           plan = world.plan(SingletonAction, :fail => true)
           _(plan.state).must_equal :planned
           lock_filter = ::Dynflow::Coordinator::SingletonActionLock
-                          .unique_filter plan.entry_action.class.name
+                        .unique_filter plan.entry_action.class.name
           _(world.coordinator.find_locks(lock_filter).count).must_equal 1
           plan = world.execute(plan.id).wait!.value
           _(plan.state).must_equal :paused

data/test/executor_test.rb

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 require 'mocha/minitest'
 
@@ -11,11 +12,13 @@ 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)
+::Dynflow::Executors::Sidekiq::Core.prepend RedisMocks
 
 module Dynflow
   module ExecutorTest
@@ -71,9 +74,7 @@ module Dynflow
         end
 
         describe "execution plan state" do
-
           describe "after successful planning" do
-
             let :execution_plan do
               world.plan(Support::CodeWorkflowExample::IncomingIssues, issues_data)
             end
@@ -100,7 +101,6 @@ module Dynflow
           end
 
           describe "after error in planning" do
-
             class FailingAction < Dynflow::Action
               def plan
                 raise "I failed"
@@ -114,7 +114,6 @@ module Dynflow
             it "is stopped" do
               _(execution_plan.state).must_equal :stopped
             end
-
           end
 
           describe "when being executed" do
@@ -166,7 +165,6 @@ module Dynflow
         end
 
         describe "execution of run flow" do
-
           before do
             TestExecutionLog.setup
           end
@@ -230,8 +228,8 @@ module Dynflow
             describe 'handling errors in setup' do
               let :execution_plan do
                 world.plan(Support::DummyExample::Polling,
-                           external_task_id: '123',
-                           text:             'troll setup')
+                  external_task_id: '123',
+                  text:             'troll setup')
               end
 
               it 'fails' do
@@ -310,8 +308,8 @@ module Dynflow
               describe 'plan with one action' do
                 let :execution_plan do
                   world.plan(Support::DummyExample::Polling,
-                             { external_task_id: '123',
-                               text:             'pause in progress 20%' })
+                    { external_task_id: '123',
+                      text:             'pause in progress 20%' })
                 end
 
                 it 'determines the progress of the execution plan in percents' do
@@ -325,8 +323,8 @@ module Dynflow
               describe 'plan with more action' do
                 let :execution_plan do
                   world.plan(Support::DummyExample::WeightedPolling,
-                             { external_task_id: '123',
-                               text:             'pause in progress 20%' })
+                    { external_task_id: '123',
+                      text:             'pause in progress 20%' })
                 end
 
                 it 'takes the steps weight in account' do
@@ -341,8 +339,8 @@ module Dynflow
             describe 'works when resumed after error' do
               let :execution_plan do
                 world.plan(Support::DummyExample::Polling,
-                           { external_task_id: '123',
-                             text:             'troll progress' })
+                  { external_task_id: '123',
+                    text:             'troll progress' })
               end
 
               specify do
@@ -356,11 +354,9 @@ module Dynflow
                 assert_equal :success, ep.run_steps.first.state
               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
@@ -379,11 +375,9 @@ module Dynflow
               world.execute(execution_plan.id)
               assert_raises(Dynflow::Error) { world.execute(execution_plan.id).value! }
             end
-
           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
@@ -395,7 +389,6 @@ module Dynflow
               _(result.result).must_equal :success
               _(result.state).must_equal :stopped
             end
-
           end
 
           describe 'running' do
@@ -417,7 +410,6 @@ module Dynflow
               EXECUTED_RUN_FLOW
             end
           end
-
         end
 
         describe "execution of finalize flow" do
@@ -438,10 +430,10 @@ module Dynflow
 
             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" }] })
+                { "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" })
+                { "author" => "Peter Smith", "text" => "Failing test" })
             end
           end
 
@@ -454,7 +446,6 @@ module Dynflow
               _(TestExecutionLog.finalize.size).must_equal 0
             end
           end
-
         end
 
         describe "re-execution of run flow after fix in run phase" do
@@ -493,13 +484,11 @@ module Dynflow
             13: Triage(success) {\"author\"=>\"John Doe\", \"text\"=>\"ok\"} --> {\"classification\"=>{\"assignee\"=>\"John Doe\", \"severity\"=>\"medium\"}}
             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
+            EXECUTED_RUN_FLOW
           end
-
         end
 
         describe "re-execution of run flow after fix in finalize phase" do
-
           after do
             TestExecutionLog.teardown
           end
@@ -532,13 +521,11 @@ module Dynflow
               14: Triage(success) {\"author\"=>\"John Doe\", \"text\"=>\"ok\"} --> {\"classification\"=>{\"assignee\"=>\"John Doe\", \"severity\"=>\"medium\"}}
               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
+            EXECUTED_RUN_FLOW
           end
-
         end
 
         describe "re-execution of run flow after skipping" do
-
           after do
             TestExecutionLog.teardown
           end
@@ -571,7 +558,7 @@ module Dynflow
             13: Triage(skipped) {\"author\"=>\"John Doe\", \"text\"=>\"trolling\"} --> {}
             16: UpdateIssue(skipped) {\"author\"=>\"John Doe\", \"text\"=>\"trolling\", \"assignee\"=>Step(13).output[:classification][:assignee], \"severity\"=>Step(13).output[:classification][:severity]} --> {}
             18: NotifyAssignee(skipped) {\"triage\"=>Step(13).output} --> {}
-          EXECUTED_RUN_FLOW
+            EXECUTED_RUN_FLOW
 
             assert_finalize_flow <<-FINALIZE_FLOW, resumed_execution_plan
         Dynflow::Flows::Sequence
@@ -580,8 +567,7 @@ module Dynflow
           14: Triage(skipped) {\"author\"=>\"John Doe\", \"text\"=>\"trolling\"} --> {}
           19: NotifyAssignee(skipped) {\"triage\"=>Step(13).output} --> {}
           20: IncomingIssues(success) {\"issues\"=>[{\"author\"=>\"Peter Smith\", \"text\"=>\"Failing test\"}, {\"author\"=>\"John Doe\", \"text\"=>\"trolling\"}]} --> {}
-          FINALIZE_FLOW
-
+            FINALIZE_FLOW
           end
         end
 
@@ -617,7 +603,6 @@ module Dynflow
           end
 
           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)
@@ -631,7 +616,6 @@ module Dynflow
               assert manager.done?
             end
           end
-
         end
 
         describe 'Pool::JobStorage' do
@@ -673,7 +657,6 @@ module Dynflow
             assert_nil storage.pop
           end
         end
-
       end
 
       describe 'termination' do
@@ -682,7 +665,7 @@ module Dynflow
         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 )
+          suspended = world.trigger(Support::DummyExample::DeprecatedEventedAction, :timeout => 3)
           sleep 0.2
           world.terminate.wait
           _($slow_actions_done).must_equal 1

data/test/extensions_test.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 require 'active_support/time'
 

data/test/flows_test.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 require 'mocha/minitest'
 
 module Dynflow
   describe 'flow' do
-
     class TestRegistry < Flows::Registry
       class << self
         def reset!
@@ -22,7 +22,7 @@ module Dynflow
         TestRegistry.register!(TestRegistry, 'TS')
         TestRegistry.register!(Integer, 'I')
         map = TestRegistry.instance_variable_get("@serialization_map")
-        _(map).must_equal({'TS' => TestRegistry, 'I' => Integer})
+        _(map).must_equal({ 'TS' => TestRegistry, 'I' => Integer })
       end
 
       it "prevents overwriting values" do

data/test/future_execution_test.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 
 module Dynflow
@@ -9,7 +10,6 @@ module Dynflow
       include Dynflow::Testing::Factories
 
       describe 'action scheduling' do
-
         before do
           @start_at = Time.now.utc + 180
           world.persistence.delete_delayed_plans({})
@@ -98,10 +98,9 @@ module Dynflow
           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/
+          _(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
 
       describe 'polling delayed executor' do

data/test/memory_cosumption_watcher_test.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 require 'fileutils'
 require 'dynflow/watchers/memory_consumption_watcher'

data/test/middleware_test.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 
 module Dynflow
   module MiddlewareTest
-
     describe 'Middleware' do
       let(:world) { WorldFactory.create_world }
       let(:log) { Support::MiddlewareExample::LogMiddleware.log }
@@ -77,8 +77,7 @@ module Dynflow
           let(:world_with_middleware) do
             WorldFactory.create_world.tap do |world|
               world.middleware.use(Support::MiddlewareExample::AnotherLogRunMiddleware,
-                                   after: Support::MiddlewareExample::LogRunMiddleware)
-
+                after: Support::MiddlewareExample::LogRunMiddleware)
             end
           end
 
@@ -112,7 +111,7 @@ module Dynflow
       it "allows access the running action" do
         world = WorldFactory.create_world
         world.middleware.use(Support::MiddlewareExample::ObservingMiddleware,
-                             replace: Support::MiddlewareExample::LogRunMiddleware)
+          replace: Support::MiddlewareExample::LogRunMiddleware)
         world.trigger(Support::MiddlewareExample::Action, message: 'hello').finished.wait
         _(log).must_equal %w[input#message:hello
                              run
@@ -122,7 +121,7 @@ module Dynflow
       it "allows modification of the running action when delaying execution" do
         world = WorldFactory.create_world
         world.middleware.use(Support::MiddlewareExample::AnotherObservingMiddleware,
-                             replace: Support::MiddlewareExample::LogRunMiddleware)
+          replace: Support::MiddlewareExample::LogRunMiddleware)
         delay = world.delay(Support::MiddlewareExample::Action, { :start_at => Time.now - 60 })
         plan = world.persistence.load_delayed_plan delay.execution_plan_id
         plan.plan
@@ -183,7 +182,6 @@ module Dynflow
           _(presenter_without_middleware.input['text']).must_equal('Lord Voldemort is comming')
         end
       end
-
     end
   end
 end

data/test/persistence_test.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 require 'tmpdir'
 require 'ostruct'
@@ -6,7 +7,6 @@ require 'ostruct'
 module Dynflow
   module PersistenceTest
     describe 'persistence adapters' do
-
       let :execution_plans_data do
         [{ id: 'plan1', :label => 'test1', root_plan_step_id: 1, class: 'Dynflow::ExecutionPlan', state: 'paused' },
          { id: 'plan2', :label => 'test2', root_plan_step_id: 1, class: 'Dynflow::ExecutionPlan', state: 'stopped' },
@@ -20,8 +20,8 @@ module Dynflow
          caller_execution_plan_id: nil,
          caller_action_id: nil,
          class: 'Dynflow::Action',
-         input: {key: 'value'},
-         output: {something: 'else'},
+         input: { key: 'value' },
+         output: { something: 'else' },
          plan_step_id: 1,
          run_step_id: 2,
          finalize_step_id: 3
@@ -150,9 +150,9 @@ module Dynflow
               _(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))
+                :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']
             end
@@ -169,29 +169,29 @@ module Dynflow
             prepare_and_save_plans
             if adapter.ordering_by.include?('state')
               loaded_plans = adapter.find_execution_plan_statuses(filters: { label: ['test1'] })
-              _(loaded_plans).must_equal({ 'plan1' => { state: 'paused', result: nil} })
+              _(loaded_plans).must_equal({ 'plan1' => { state: 'paused', result: nil } })
 
               loaded_plans = adapter.find_execution_plan_statuses(filters: { state: ['paused'] })
-              _(loaded_plans).must_equal({"plan1"=>{:state=>"paused", :result=>nil},
-                                          "plan3"=>{:state=>"paused", :result=>nil},
-                                          "plan4"=>{:state=>"paused", :result=>nil}})
+              _(loaded_plans).must_equal({ "plan1" => { :state => "paused", :result => nil },
+                                          "plan3" => { :state => "paused", :result => nil },
+                                          "plan4" => { :state => "paused", :result => nil } })
 
               loaded_plans = adapter.find_execution_plan_statuses(filters: { state: ['stopped'] })
-              _(loaded_plans).must_equal({"plan2"=>{:state=>"stopped", :result=>nil}})
+              _(loaded_plans).must_equal({ "plan2" => { :state => "stopped", :result => nil } })
 
               loaded_plans = adapter.find_execution_plan_statuses(filters: { state: [] })
               _(loaded_plans).must_equal({})
 
               loaded_plans = adapter.find_execution_plan_statuses(filters: { state: ['stopped', 'paused'] })
-              _(loaded_plans).must_equal({"plan1"=>{:state=>"paused", :result=>nil},
-                                          "plan2"=>{:state=>"stopped", :result=>nil},
-                                          "plan3"=>{:state=>"paused", :result=>nil}, "plan4"=>{:state=>"paused", :result=>nil}})
+              _(loaded_plans).must_equal({ "plan1" => { :state => "paused", :result => nil },
+                                          "plan2" => { :state => "stopped", :result => nil },
+                                          "plan3" => { :state => "paused", :result => nil }, "plan4" => { :state => "paused", :result => nil } })
 
               loaded_plans = adapter.find_execution_plan_statuses(filters: { 'state' => ['stopped', 'paused'] })
-              _(loaded_plans).must_equal({"plan1"=>{:state=>"paused", :result=>nil},
-                                          "plan2"=>{:state=>"stopped", :result=>nil},
-                                          "plan3"=>{:state=>"paused", :result=>nil},
-                                          "plan4"=>{:state=>"paused", :result=>nil}})
+              _(loaded_plans).must_equal({ "plan1" => { :state => "paused", :result => nil },
+                                          "plan2" => { :state => "stopped", :result => nil },
+                                          "plan3" => { :state => "paused", :result => nil },
+                                          "plan4" => { :state => "paused", :result => nil } })
 
               loaded_plans = adapter.find_execution_plan_statuses(filters: { label: ['test1'], :delayed => true })
               _(loaded_plans).must_equal({})
@@ -229,9 +229,9 @@ module Dynflow
               _(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))
+                :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
             end
@@ -276,14 +276,14 @@ module Dynflow
           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']
               actions = CSV.read(backup_dir + "/actions.csv", :headers => true)
               assert_equal 1, actions.count
               assert_equal 'plan1', actions.first.to_hash['execution_plan_uuid']
-              steps = CSV.read(backup_dir +"/steps.csv", :headers => true)
+              steps = CSV.read(backup_dir + "/steps.csv", :headers => true)
               assert_equal 1, steps.count
               assert_equal 'plan1', steps.first.to_hash['execution_plan_uuid']
             end
@@ -376,7 +376,7 @@ module Dynflow
           it 'deletes output chunks' do
             prepare_plans_with_actions
 
-            adapter.save_output_chunks('plan1', 1, [{chunk: "Hello", timestamp: Time.now}, {chunk: "Bye", timestamp: Time.now}])
+            adapter.save_output_chunks('plan1', 1, [{ chunk: "Hello", timestamp: Time.now }, { chunk: "Bye", timestamp: Time.now }])
             chunks = adapter.load_output_chunks('plan1', 1)
             _(chunks.length).must_equal 2
             deleted = adapter.delete_output_chunks('plan1', 1)
@@ -451,7 +451,7 @@ module Dynflow
           envelopes         = [client_envelope, executor_envelope]
 
           envelopes.each { |e| adapter.push_envelope(e) }
-          adapter.insert_coordinator_record({"class"=>"Dynflow::Coordinator::ExecutorWorld",
+          adapter.insert_coordinator_record({ "class" => "Dynflow::Coordinator::ExecutorWorld",
                                              "id" => executor_world_id, "meta" => {}, "active" => true })
 
           assert_equal 1, adapter.prune_undeliverable_envelopes
@@ -526,7 +526,7 @@ module Dynflow
 
           value = 'a' * 1000
 
-          adata = action_data.merge({:output => { :key => value }})
+          adata = action_data.merge({ :output => { :key => value } })
           plan_record = adapter.send(:prepare_record, :execution_plan, plan.merge(:uuid => plan[:id]))
           action_record = adapter.send(:prepare_record, :action, adata.dup)