dynflow 1.8.2 → 1.8.3

data/test/abnormal_states_recovery_test.rb

@@ -1,13 +1,12 @@
 # -*- coding: utf-8 -*-
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 require 'ostruct'
 
 module Dynflow
   module ConsistencyCheckTest
-
     describe "consistency check" do
-
       include TestHelpers
 
       def with_invalidation_while_executing(finish)
@@ -43,7 +42,6 @@ module Dynflow
       let(:client_world_2) { create_world(false) }
 
       describe "for plans assigned to invalid world" do
-
         before do
           # mention the executors to make sure they are initialized
           [executor_world, executor_world_2]
@@ -187,7 +185,6 @@ module Dynflow
       end
 
       describe 'auto execute' do
-
         before do
           client_world.persistence.delete_execution_plans({})
         end
@@ -273,10 +270,10 @@ module Dynflow
           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 = Config::ForWorld.new(Config.new.tap { |c| c.executor = false }, create_world)
             _(client_world_config.auto_validity_check).must_equal false
 
-            executor_world_config = Config::ForWorld.new(Config.new.tap { |c| c.executor = Executors::Parallel::Core }, create_world )
+            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
 
@@ -304,7 +301,7 @@ module Dynflow
             _(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)
+            _(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
@@ -382,4 +379,3 @@ module Dynflow
     end
   end
 end
-

data/test/action_test.rb

@@ -1,14 +1,13 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 require 'mocha/minitest'
 
 module Dynflow
   describe 'action' do
-
     let(:world) { WorldFactory.create_world }
 
     describe Action::Missing do
-
       let :action_data do
         { class:             'RenamedAction',
           id:                1,
@@ -32,7 +31,6 @@ module Dynflow
     end
 
     describe 'children' do
-
       smart_action_class   = Class.new(Dynflow::Action)
       smarter_action_class = Class.new(smart_action_class)
 
@@ -50,7 +48,6 @@ module Dynflow
     end
 
     describe Action::Present do
-
       let :execution_plan do
         result = world.trigger(Support::CodeWorkflowExample::IncomingIssues, issues_data)
         _(result).must_be :planned?
@@ -74,7 +71,6 @@ module Dynflow
     end
 
     describe 'serialization' do
-
       include Testing
 
       it 'fails when input is not serializable' do
@@ -196,10 +192,9 @@ module Dynflow
       end
 
       class TestPollingAction < Dynflow::Action
-
         class Config
           attr_accessor :external_service, :poll_max_retries,
-                        :poll_intervals, :attempts_before_next_interval
+            :poll_intervals, :attempts_before_next_interval
 
           def initialize
             @external_service              = ExternalService.new
@@ -383,7 +378,6 @@ module Dynflow
     end
 
     describe Action::WithSubPlans do
-
       class FailureSimulator
         class << self
           attr_accessor :fail_in_child_plan, :fail_in_child_run
@@ -399,7 +393,6 @@ module Dynflow
       end
 
       class ParentAction < Dynflow::Action
-
         include Dynflow::Action::WithSubPlans
 
         def plan(*_)
@@ -413,7 +406,7 @@ module Dynflow
 
         def resume(*args)
           output[:custom_resume] = true
-          super *args
+          super(*args)
         end
       end
 
@@ -481,7 +474,6 @@ module Dynflow
         def batch(from, size)
           total_count.times.drop(from).take(size)
         end
-
       end
 
       let(:execution_plan) { world.trigger(ParentAction, count: 2).finished.value }
@@ -506,7 +498,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)
@@ -514,7 +506,7 @@ 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)
@@ -789,7 +781,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
@@ -801,7 +793,7 @@ module Dynflow
             plan = world.plan(SingletonActionWithFinalize)
             _(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
@@ -813,7 +805,7 @@ module Dynflow
             plan = world.plan(SuspendedSingletonAction)
             _(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
             future = world.execute(plan.id)
             wait_for do
@@ -859,7 +851,7 @@ module Dynflow
 
             # The lock was released when plan3 stopped
             lock_filter = ::Dynflow::Coordinator::SingletonActionLock
-                              .unique_filter plan3.entry_action.class.name
+                          .unique_filter plan3.entry_action.class.name
             _(world.coordinator.find_locks(lock_filter)).must_be :empty?
           end
 
@@ -868,7 +860,7 @@ module Dynflow
             plan1 = world.plan(BadAction, true)
             _(plan1.state).must_equal :planned
             lock_filter = ::Dynflow::Coordinator::SingletonActionLock
-                              .unique_filter plan1.entry_action.class.name
+                          .unique_filter plan1.entry_action.class.name
             _(world.coordinator.find_locks(lock_filter).count).must_equal 0
             plan2 = world.plan(BadAction, false)
             _(plan2.state).must_equal :planned

data/test/activejob_adapter_test.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 require 'active_job'
 require 'dynflow/active_job/queue_adapter'
@@ -21,7 +22,7 @@ module Dynflow
     end
 
     before(:all) do
-      ::ActiveJob::QueueAdapters.send(:include, ::Dynflow::ActiveJob::QueueAdapters)
+      ::ActiveJob::QueueAdapters.include ::Dynflow::ActiveJob::QueueAdapters
       ::ActiveJob::Base.queue_adapter = :dynflow
       dynflow_mock = Minitest::Mock.new
       dynflow_mock.expect(:world, world)
@@ -71,4 +72,3 @@ module Dynflow
     end
   end
 end
-

data/test/batch_sub_tasks_test.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 
 module Dynflow
@@ -109,7 +110,6 @@ module Dynflow
         _(action.send(:can_spawn_next_batch?)).must_equal false
         _(action.current_batch).must_be :empty?
       end
-
     end
   end
 end

data/test/clock_test.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 require 'logger'
 
 clock_class = Dynflow::Clock
 
 describe clock_class do
-
   let(:clock) { clock_class.spawn 'clock' }
 
   it 'refuses who without #<< method' do
@@ -48,7 +48,6 @@ describe clock_class do
         assert_equal (0...times).to_a, Array.new(times) { q.pop }.sort
       end
     end
-    threads.each &:join
+    threads.each(&:join)
   end
-
 end

data/test/concurrency_control_test.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 
 module Dynflow
@@ -81,8 +82,8 @@ module Dynflow
       end
 
       def check_step(plan, total, finished)
-        _(world.throttle_limiter.observe(plan.id).length).must_equal (total - finished)
-        _(plan.sub_plans.select { |sub| planned? sub }.count).must_equal (total - finished)
+        _(world.throttle_limiter.observe(plan.id).length).must_equal(total - finished)
+        _(plan.sub_plans.select { |sub| planned? sub }.count).must_equal(total - finished)
         _(plan.sub_plans.select { |sub| successful? sub }.count).must_equal finished
       end
 
@@ -95,14 +96,12 @@ module Dynflow
       end
 
       class LoggingThrottleLimiter < Dynflow::ThrottleLimiter
-
         class LoggingCore < Dynflow::ThrottleLimiter::Core
-
           attr_reader :running
 
           def initialize(*args)
             @running = [0]
-            super *args
+            super(*args)
           end
 
           def release(*args)
@@ -233,12 +232,12 @@ module Dynflow
           planned, running = plan.sub_plans.partition { |sub| planned? sub }
           _(planned.count).must_equal total - level
           _(running.count).must_equal level
-          _(world.throttle_limiter.observe(plan.id).length).must_equal (total - 1)
+          _(world.throttle_limiter.observe(plan.id).length).must_equal(total - 1)
           4.times { klok.progress }
           wait_for { future.resolved? }
           finished, stopped = plan.sub_plans.partition { |sub| successful? sub }
           _(finished.count).must_equal level
-          _(stopped.count).must_equal (total - level)
+          _(stopped.count).must_equal(total - level)
         end
       end
     end

data/test/coordinator_test.rb

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

data/test/daemon_test.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'test_helper'
 require 'active_support'
 require 'mocha/minitest'
@@ -34,8 +35,8 @@ class DaemonTest < ActiveSupport::TestCase
     @daemon.stubs(:sleep).returns(true) # don't pause the execution
     @current_folder = File.expand_path('../support/rails/', __FILE__)
     ::ActiveRecord::Base.configurations = { 'development' => {} }
-    ::Dynflow::Rails::Configuration.any_instance.stubs(:initialize_persistence).
-      returns(WorldFactory.persistence_adapter)
+    ::Dynflow::Rails::Configuration.any_instance.stubs(:initialize_persistence)
+                                   .returns(WorldFactory.persistence_adapter)
   end
 
   teardown do

data/test/dead_letter_silencer_test.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 require 'ostruct'
 
@@ -12,7 +13,7 @@ module Dynflow
 
       it 'is started for each world' do
         _(world.dead_letter_handler.actor_class)
-             .must_equal ::Dynflow::DeadLetterSilencer
+          .must_equal ::Dynflow::DeadLetterSilencer
       end
 
       describe ::Dynflow::DeadLetterSilencer::Matcher do

data/test/dispatcher_test.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 
 module Dynflow
   module DispatcherTest
     describe "dispatcher" do
-
       include TestHelpers
 
       let(:persistence_adapter) { WorldFactory.persistence_adapter }
@@ -27,8 +27,8 @@ module Dynflow
             it 'succeeds when expected' do
               result = client_world.trigger(Support::DummyExample::DeprecatedEventedAction, :timeout => 3)
               step = wait_for do
-                client_world.persistence.load_execution_plan(result.id).
-                    steps_in_state(:suspended).first
+                client_world.persistence.load_execution_plan(result.id)
+                            .steps_in_state(:suspended).first
               end
               client_world.event(step.execution_plan_id, step.id, 'finish')
               plan = result.finished.value
@@ -53,7 +53,7 @@ module Dynflow
             it 'does not error on dispatching an optional event' do
               request = client_world.event('123', 1, nil, optional: true)
               request.wait(20)
-              assert_match /Could not find an executor for optional .*, discarding/, request.reason.message
+              assert_match(/Could not find an executor for optional .*, discarding/, request.reason.message)
             end
           end
         end
@@ -72,7 +72,6 @@ module Dynflow
             assert_plan_reexecuted(plan)
           end
         end
-
       end
 
       def self.supports_ping_pong

data/test/execution_plan_cleaner_test.rb

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

data/test/execution_plan_hooks_test.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'test_helper'
 
 module Dynflow

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