dynflow 1.2.1 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '00091e6971f6c6bbcc56f3a03564b2de6f437db1985375caa2171d3f9859a0f7'
-  data.tar.gz: e48ae6152594e70147b362b1e7ae4b0923cc645d38005af56b69c9e6f1cd5a31
+  metadata.gz: ddba15f840b26c5148fcebf8a0b69ff22abc0bba1fe70d2fa02e32722003011b
+  data.tar.gz: 4c7c6a7c3d23e1e0684ef61fa44ccf1cd44ff76cfba9c0e8e3b0587b9674ffeb
 SHA512:
-  metadata.gz: e00b1eb7cf2bd103fe79d8a0e3046143f77548c380b2504b4fc3093b5c4a4929160f704f781e0565eacefb7cf493bd7b5ec6a8f5c2a5b0490e3f521285513a73
-  data.tar.gz: 1d3aef7335990a1ff72fecd0b36bb444227f0f216aaf44677d66d453a8d29b470a58e7d2ccee4349ba341a12a4ca14306d6d4c5167f5ac7e375c36fed19362cd
+  metadata.gz: a5b836d767ef81131f217d82467d96410c63140bb38e247489b33b9386df2ddb30aff56da3b42bff216fd6a419f714176d0e111415e6793c3c534bdbfcbd6938
+  data.tar.gz: 01a74517eb6500b5e986759d017f2886c1a5032d81e026d1e41450033935dfab9c342bf4ced411da56b2cf3daefd79a82a1137d97030567bbcbe517a4e9599cb

data/.rubocop.yml

@@ -1,5 +1,8 @@
 inherit_from: .rubocop_todo.yml
 
+AllCops:
+  TargetRubyVersion: 2.2
+
 # Cop supports --auto-correct.
 # Configuration parameters: AllowForAlignment, ForceEqualSignAlignment.
 Style/ExtraSpacing:

data/lib/dynflow/action/with_sub_plans.rb

@@ -76,16 +76,16 @@ module Dynflow
     end
 
     # Helper for creating sub plans
-    def trigger(*args)
+    def trigger(action_class, *args)
       if uses_concurrency_control
-        trigger_with_concurrency_control(*args)
+        trigger_with_concurrency_control(action_class, *args)
       else
-        world.trigger { world.plan_with_caller(self, *args) }
+        world.trigger { world.plan_with_options(action_class: action_class, args: args, caller_action: self) }
       end
     end
 
-    def trigger_with_concurrency_control(*args)
-      record = world.plan_with_caller(self, *args)
+    def trigger_with_concurrency_control(action_class, *args)
+      record = world.plan_with_options(action_class: action_class, args: args, caller_action: self)
       records = [[record.id], []]
       records.reverse! unless record.state == :planned
       @world.throttle_limiter.handle_plans!(execution_plan_id, *records).first

data/lib/dynflow/active_job/queue_adapter.rb

@@ -3,15 +3,19 @@ module Dynflow
     module QueueAdapters
       module QueueMethods
         def enqueue(job)
-          ::Rails.application.dynflow.world.trigger(JobWrapper, job.serialize).tap do |plan|
-            job.provider_job_id = plan.id
+          ::Rails.application.dynflow.world.trigger do |world|
+            job.provider_job_id = job.job_id
+            world.plan_with_options(id: job.provider_job_id, action_class: JobWrapper, args: [job.serialize])
           end
         end
 
         def enqueue_at(job, timestamp)
-          ::Rails.application.dynflow.world.delay(JobWrapper, { :start_at => Time.at(timestamp) }, job.serialize).tap do |plan|
-            job.provider_job_id = plan.id
-          end
+          job.provider_job_id = job.job_id
+          ::Rails.application.dynflow.world
+            .delay_with_options(id: job.provider_job_id,
+                                action_class: JobWrapper,
+                                delay_options: { :start_at => Time.at(timestamp) },
+                                args: [job.serialize])
         end
       end
 
@@ -33,13 +37,13 @@ module Dynflow
 
         def plan(attributes)
           input[:job_class] = attributes['job_class']
-          input[:job_arguments] = attributes['arguments']
           input[:queue] = attributes['queue_name']
+          input[:job_data] = attributes
           plan_self
         end
 
         def run
-          input[:job_class].constantize.perform_now(*input[:job_arguments])
+          ::ActiveJob::Base.execute(input[:job_data])
         end
 
         def label

data/lib/dynflow/director.rb

@@ -119,7 +119,9 @@ module Dynflow
     def work_failed(work)
       if (manager = @execution_plan_managers[work.execution_plan_id])
         manager.terminate
-        finish_manager(manager)
+        # Don't try to store when the execution plan went missing
+        plan_missing = @world.persistence.find_execution_plans(:filters => { uuid: work.execution_plan_id }).empty?
+        finish_manager(manager, store: !plan_missing)
       end
     end
 
@@ -144,24 +146,26 @@ module Dynflow
     def unless_done(manager, work_items)
       return [] unless manager
       if manager.done?
-        finish_manager(manager)
-        return []
+        try_to_rescue(manager) || finish_manager(manager)
       else
         return work_items
       end
     end
 
-    def finish_manager(manager)
+    def try_to_rescue(manager)
+      rescue!(manager) if rescue?(manager)
+    end
+
+    def finish_manager(manager, store: true)
+      update_execution_plan_state(manager) if store
+      return []
+    ensure
       @execution_plan_managers.delete(manager.execution_plan.id)
-      if rescue?(manager)
-        rescue!(manager)
-      else
-        set_future(manager)
-      end
+      set_future(manager)
     end
 
     def rescue?(manager)
-      if @world.terminating? || !(@world.auto_rescue && manager.execution_plan.state == :paused)
+      if @world.terminating? || !(@world.auto_rescue && manager.execution_plan.error?)
         false
       elsif !@rescued_steps.key?(manager.execution_plan.id)
         # we have not rescued this plan yet
@@ -179,11 +183,12 @@ module Dynflow
       # to put this logic of making sure we don't run rescues in endless loop
       @rescued_steps[manager.execution_plan.id] ||= Set.new
       @rescued_steps[manager.execution_plan.id].merge(manager.execution_plan.failed_steps.map(&:id))
-      rescue_plan_id = manager.execution_plan.rescue_plan_id
-      if rescue_plan_id
-        @world.executor.execute(rescue_plan_id, manager.future, false)
+      new_state = manager.execution_plan.prepare_for_rescue
+      if new_state == :running
+        return manager.restart
       else
-        set_future(manager)
+        manager.execution_plan.state = new_state
+        return false
       end
     end
 
@@ -207,6 +212,28 @@ module Dynflow
       nil
     end
 
+    def update_execution_plan_state(manager)
+      execution_plan = manager.execution_plan
+      case execution_plan.state
+      when :running
+        if execution_plan.error?
+          execution_plan.execution_history.add('pause execution', @world.id)
+          execution_plan.update_state(:paused)
+        elsif manager.done?
+          execution_plan.execution_history.add('finish execution', @world.id)
+          execution_plan.update_state(:stopped)
+        end
+        # If the state is marked as running without errors but manager is not done,
+        # we let the invalidation procedure to handle re-execution on other executor
+      when :paused
+        execution_plan.execution_history.add('pause execution', @world.id)
+        execution_plan.save
+      when :stopped
+        execution_plan.execution_history.add('finish execution', @world.id)
+        execution_plan.save
+      end
+    end
+
     def set_future(manager)
       @rescued_steps.delete(manager.execution_plan.id)
       manager.future.fulfill manager.execution_plan

data/lib/dynflow/director/execution_plan_manager.rb

@@ -24,6 +24,12 @@ module Dynflow
         start_run or start_finalize or finish
       end
 
+      def restart
+        @run_manager = nil
+        @finalize_manager = nil
+        start
+      end
+
       def prepare_next_step(step)
         StepWorkItem.new(execution_plan.id, step, step.queue).tap do |work|
           @running_steps_manager.add(step, work)
@@ -97,8 +103,6 @@ module Dynflow
       end
 
       def finish
-        execution_plan.execution_history.add('finish execution', @world.id)
-        @execution_plan.update_state(execution_plan.error? ? :paused : :stopped)
         return no_work
       end
 

data/lib/dynflow/execution_plan.rb

@@ -69,7 +69,7 @@ module Dynflow
 
     # all params with default values are part of *private* api
     def initialize(world,
-                   id                = SecureRandom.uuid,
+                   id                = nil,
                    label             = nil,
                    state             = :pending,
                    root_plan_step    = nil,
@@ -81,7 +81,7 @@ module Dynflow
                    execution_time    = nil,
                    real_time         = 0.0,
                    execution_history = ExecutionHistory.new)
-
+      id ||= SecureRandom.uuid
       @id                = Type! id, String
       @world             = Type! world, World
       @label             = Type! label, String, NilClass
@@ -199,16 +199,17 @@ module Dynflow
       persistence.find_execution_plan_counts(filters: { 'caller_execution_plan_id' => self.id })
     end
 
-    def rescue_plan_id
+    def prepare_for_rescue
       case rescue_strategy
       when Action::Rescue::Pause
-        nil
+        :paused
       when Action::Rescue::Fail
-        update_state :stopped
-        nil
+        :stopped
       when Action::Rescue::Skip
         failed_steps.each { |step| self.skip(step) }
-        self.id
+        :running
+      else
+        :paused
       end
     end
 
@@ -232,14 +233,6 @@ module Dynflow
       self.steps.values.find_all {|step| states.include?(step.state) }
     end
 
-    def rescue_from_error
-      if rescue_plan_id = self.rescue_plan_id
-        @world.execute(rescue_plan_id)
-      else
-        raise Errors::RescueError, 'Unable to rescue from the error'
-      end
-    end
-
     def generate_action_id
       @last_action_id ||= 0
       @last_action_id += 1

data/lib/dynflow/persistence_adapters/sequel_migrations/011_placeholder.rb

@@ -0,0 +1,4 @@
+Sequel.migration do
+  # Placeholder for 011_add_uuid_column.rb - it was readded in
+  # 018_add_uuid_column.rb with fixed check for postgresql
+end

data/lib/dynflow/persistence_adapters/sequel_migrations/{011_add_uuid_column.rb → 018_add_uuid_column.rb}

@@ -38,7 +38,7 @@ end
 
 Sequel.migration do
   up do
-    if database_type == :postgresql
+    if database_type.to_s.include?('postgres')
       with_foreign_key_recreation do
         to_uuid :dynflow_execution_plans, :uuid
         to_uuid :dynflow_actions,         :execution_plan_uuid
@@ -49,7 +49,7 @@ Sequel.migration do
   end
 
   down do
-    if database_type == :postgresql
+    if database_type.to_s.include?('postgres')
       with_foreign_key_recreation do
         from_uuid :dynflow_execution_plans, :uuid
         from_uuid :dynflow_actions,         :execution_plan_uuid

data/lib/dynflow/version.rb

@@ -1,3 +1,3 @@
 module Dynflow
-  VERSION = '1.2.1'.freeze
+  VERSION = '1.2.2'.freeze
 end

data/lib/dynflow/world.rb

@@ -183,26 +183,23 @@ module Dynflow
       end
     end
 
-    def delay(*args)
-      delay_with_caller(nil, *args)
+    def delay(action_class, delay_options, *args)
+      delay_with_options(action_class: action_class, args: args, delay_options: delay_options)
     end
 
-    def delay_with_caller(caller_action, action_class, delay_options, *args)
+    def delay_with_options(action_class:, args:, delay_options:, id: nil, caller_action: nil)
       raise 'No action_class given' if action_class.nil?
-      execution_plan = ExecutionPlan.new(self)
+      execution_plan = ExecutionPlan.new(self, id)
       execution_plan.delay(caller_action, action_class, delay_options, *args)
       Scheduled[execution_plan.id]
     end
 
     def plan(action_class, *args)
-      ExecutionPlan.new(self).tap do |execution_plan|
-        execution_plan.prepare(action_class)
-        execution_plan.plan(*args)
-      end
+      plan_with_options(action_class: action_class, args: args)
     end
 
-    def plan_with_caller(caller_action, action_class, *args)
-      ExecutionPlan.new(self).tap do |execution_plan|
+    def plan_with_options(action_class:, args:, id: nil, caller_action: nil)
+      ExecutionPlan.new(self, id).tap do |execution_plan|
         execution_plan.prepare(action_class, caller_action: caller_action)
         execution_plan.plan(*args)
       end

data/lib/dynflow/world/invalidation.rb

@@ -9,6 +9,7 @@ module Dynflow
       # @return [void]
       def invalidate(world)
         Type! world, Coordinator::ClientWorld, Coordinator::ExecutorWorld
+
         coordinator.acquire(Coordinator::WorldInvalidationLock.new(self, world)) do
           if world.is_a? Coordinator::ExecutorWorld
             old_execution_locks = coordinator.find_locks(class: Coordinator::ExecutionLock.name,
@@ -47,8 +48,8 @@ module Dynflow
           coordinator.release(execution_lock)
 
           if plan.error?
-            rescue_id = plan.rescue_plan_id
-            execute(rescue_id) if rescue_id
+            new_state = plan.prepare_for_rescue
+            execute(plan.id) if new_state == :running
           else
             if coordinator.find_worlds(true).any? # Check if there are any executors
               client_dispatcher.tell([:dispatch_request,

data/test/abnormal_states_recovery_test.rb

@@ -142,13 +142,7 @@ module Dynflow
       describe 'auto execute' do
 
         before do
-          client_world.persistence.find_execution_plans({}).each do |plan|
-            # make sure we don't handle plans from previous tests
-            # TODO: delete the plans instead, once we have
-            # https://github.com/Dynflow/dynflow/pull/141 merged
-            plan.set_state(:stopped, true)
-            plan.save
-          end
+          client_world.persistence.delete_execution_plans({})
         end
 
         it "prevents from running the auto-execution twice" do
@@ -198,7 +192,7 @@ module Dynflow
           plan = client_world.persistence.load_execution_plan(triggered.id)
           plan.state.must_equal :paused
           expected_history = [['start execution', executor_world.id],
-                              ['finish execution', executor_world.id]]
+                              ['pause execution', executor_world.id]]
           plan.execution_history.map { |h| [h.name, h.world_id] }.must_equal(expected_history)
         end
       end
@@ -318,10 +312,11 @@ module Dynflow
             plan
           end
 
+          let(:sample_uuid) { '11111111-2222-3333-4444-555555555555' }
           let(:valid_plan) { plan_in_state :running }
           let(:invalid_plan) { plan_in_state :stopped }
           let(:valid_lock)    { Coordinator::SingletonActionLock.new('MyClass1', valid_plan.id) }
-          let(:invalid_lock)  { Coordinator::SingletonActionLock.new('MyClass2', 'plan-id') }
+          let(:invalid_lock)  { Coordinator::SingletonActionLock.new('MyClass2', sample_uuid) }
           let(:invalid_lock2) { Coordinator::SingletonActionLock.new('MyClass3', invalid_plan.id) }
 
           it 'unlocks orphaned singleton action locks' do

data/test/activejob_adapter_test.rb

@@ -8,10 +8,13 @@ module Dynflow
 
     def perform(msg)
       puts "This job says #{msg}"
+      puts "provider_job_id is #{provider_job_id}"
     end
   end
 
   describe 'running jobs' do
+    include TestHelpers
+
     let :world do
       WorldFactory.create_world
     end
@@ -48,9 +51,13 @@ module Dynflow
       job = nil
       out, = capture_subprocess_io do
         job = SampleJob.perform_later 'hello'
+        wait_for do
+          plan = world.persistence.load_execution_plan(job.provider_job_id)
+          plan.state == :stopped
+        end
       end
-      assert world.persistence.load_execution_plan(job.provider_job_id)
       assert_match(/Enqueued Dynflow::SampleJob/, out)
+      assert_match(/provider_job_id is #{job.provider_job_id}/, out)
     end
 
     it 'schedules job in the future' do

data/test/execution_plan_test.rb

@@ -191,6 +191,19 @@ module Dynflow
         end
       end
 
+      describe 'custom plan id' do
+        let(:sample_uuid) { '60366107-9910-4815-a6c6-bc45ee2ea2b8' }
+        let :execution_plan do
+          world.plan_with_options(action_class: Support::CodeWorkflowExample::IncomingIssues,
+                                  args: [issues_data],
+                                  id: sample_uuid)
+        end
+
+        it 'allows setting custom id for the execution plan' do
+          execution_plan.id.must_equal sample_uuid
+        end
+      end
+
       describe 'planning algorithm' do
 
         describe 'single dependencies' do

data/test/executor_test.rb

@@ -138,6 +138,7 @@ module Dynflow
             wait_for('execution plan removed from executor') do
               !director.current_execution_plan_ids.include?(execution_plan.id)
             end
+            world.persistence.find_execution_plans(filters: { uuid: [execution_plan.id] }).must_be :empty?
           end
         end
       end

data/test/rescue_test.rb

@@ -15,125 +15,99 @@ module Dynflow
       end
 
       let :rescued_plan do
-        execution_plan.rescue_from_error.value
+        world.persistence.load_execution_plan(execution_plan.id)
       end
 
-      describe 'of simple skippable action in run phase' do
+      describe 'no auto rescue' do
+        describe 'of simple skippable action in run phase' do
 
-        let :execution_plan do
-          execute(Example::ActionWithSkip, 1, :error_on_run)
-        end
+          let :execution_plan do
+            execute(Example::ActionWithSkip, 1, :error_on_run)
+          end
 
-        it 'suggests skipping the action' do
-          execution_plan.rescue_strategy.must_equal Action::Rescue::Skip
-        end
+          it 'suggests skipping the action' do
+            execution_plan.rescue_strategy.must_equal Action::Rescue::Skip
+          end
 
-        it 'skips the action and continues' do
-          rescued_plan.state.must_equal :stopped
-          rescued_plan.result.must_equal :warning
-          rescued_plan.entry_action.output[:message].
-            must_equal "skipped because some error as you wish"
+          it "doesn't rescue" do
+            rescued_plan.state.must_equal :paused
+          end
         end
-      end
 
-      describe 'of simple skippable action in finalize phase' do
+        describe 'of simple skippable action in finalize phase' do
 
-        let :execution_plan do
-          execute(Example::ActionWithSkip, 1, :error_on_finalize)
-        end
+          let :execution_plan do
+            execute(Example::ActionWithSkip, 1, :error_on_finalize)
+          end
 
-        it 'suggests skipping the action' do
-          execution_plan.rescue_strategy.must_equal Action::Rescue::Skip
-        end
+          it 'suggests skipping the action' do
+            execution_plan.rescue_strategy.must_equal Action::Rescue::Skip
+          end
 
-        it 'skips the action and continues' do
-          rescued_plan.state.must_equal :stopped
-          rescued_plan.result.must_equal :warning
-          rescued_plan.entry_action.output[:message].must_equal "Been here"
+          it "doesn't rescue" do
+            rescued_plan.state.must_equal :paused
+          end
         end
 
-      end
+        describe 'of complex action with skips in run phase' do
 
-      describe 'of complex action with skips in run phase' do
-
-        let :execution_plan do
-          execute(Example::ComplexActionWithSkip, :error_on_run)
-        end
+          let :execution_plan do
+            execute(Example::ComplexActionWithSkip, :error_on_run)
+          end
 
-        it 'suggests skipping the action' do
-          execution_plan.rescue_strategy.must_equal Action::Rescue::Skip
-        end
+          it 'suggests skipping the action' do
+            execution_plan.rescue_strategy.must_equal Action::Rescue::Skip
+          end
 
-        it 'skips the action and continues' do
-          rescued_plan.state.must_equal :stopped
-          rescued_plan.result.must_equal :warning
-          skipped_action = rescued_plan.actions.find do |action|
-            action.run_step && action.run_step.state == :skipped
+          it "doesn't rescue" do
+            rescued_plan.state.must_equal :paused
           end
-          skipped_action.output[:message].must_equal "skipped because some error as you wish"
         end
 
-      end
-
-      describe 'of complex action with skips in finalize phase' do
+        describe 'of complex action with skips in finalize phase' do
 
-        let :execution_plan do
-          execute(Example::ComplexActionWithSkip, :error_on_finalize)
-        end
+          let :execution_plan do
+            execute(Example::ComplexActionWithSkip, :error_on_finalize)
+          end
 
-        it 'suggests skipping the action' do
-          execution_plan.rescue_strategy.must_equal Action::Rescue::Skip
-        end
+          it 'suggests skipping the action' do
+            execution_plan.rescue_strategy.must_equal Action::Rescue::Skip
+          end
 
-        it 'skips the action and continues' do
-          # we need to rescue twice for two errors in sequence
-          rescued_plan = execution_plan.rescue_from_error.value
-          rescued_plan = rescued_plan.rescue_from_error.value
-          rescued_plan.state.must_equal :stopped
-          rescued_plan.result.must_equal :warning
-          skipped_action = rescued_plan.actions.find do |action|
-            action.steps.find { |step| step && step.state == :skipped }
+          it "doesn't rescue" do
+            rescued_plan.state.must_equal :paused
           end
-          skipped_action.output[:message].must_equal "Been here"
         end
 
-      end
-
-      describe 'of complex action without skips' do
+        describe 'of complex action without skips' do
 
-        let :execution_plan do
-          execute(Example::ComplexActionWithoutSkip, :error_on_run)
-        end
+          let :execution_plan do
+            execute(Example::ComplexActionWithoutSkip, :error_on_run)
+          end
 
-        it 'suggests pausing the plan' do
-          execution_plan.rescue_strategy.must_equal Action::Rescue::Pause
-        end
+          it 'suggests pausing the plan' do
+            execution_plan.rescue_strategy.must_equal Action::Rescue::Pause
+          end
 
-        it 'fails rescuing' do
-          lambda { rescued_plan }.must_raise Errors::RescueError
+          it "doesn't rescue" do
+            rescued_plan.state.must_equal :paused
+          end
         end
 
-      end
+        describe 'of complex action with fail' do
 
-      describe 'of complex action with fail' do
-
-        let :execution_plan do
-          execute(Example::ComplexActionWithFail, :error_on_run)
-        end
+          let :execution_plan do
+            execute(Example::ComplexActionWithFail, :error_on_run)
+          end
 
-        it 'suggests failing the plan' do
-          execution_plan.rescue_strategy.must_equal Action::Rescue::Fail
-        end
+          it 'suggests failing the plan' do
+            execution_plan.rescue_strategy.must_equal Action::Rescue::Fail
+          end
 
-        it 'fails rescuing' do
-          proc { rescued_plan }.must_raise Errors::RescueError
-          execution_plan.state.must_equal :stopped
-          execution_plan.result.must_equal :error
-          execution_plan.steps_in_state(:success).count.must_equal 6
-          execution_plan.steps_in_state(:pending).count.must_equal 6
-          execution_plan.steps_in_state(:error).count.must_equal 1
+          it "doesn't rescue" do
+            rescued_plan.state.must_equal :paused
+          end
         end
-
       end
 
       describe 'auto rescue' do
@@ -144,8 +118,32 @@ module Dynflow
           end
         end
 
-        describe 'of plan with skips' do
+        describe 'of simple skippable action in run phase' do
+          let :execution_plan do
+            execute(Example::ActionWithSkip, 1, :error_on_run)
+          end
+
+          it 'skips the action and continues' do
+            rescued_plan.state.must_equal :stopped
+            rescued_plan.result.must_equal :warning
+            rescued_plan.entry_action.output[:message].
+              must_equal "skipped because some error as you wish"
+          end
+        end
 
+        describe 'of simple skippable action in finalize phase' do
+          let :execution_plan do
+            execute(Example::ActionWithSkip, 1, :error_on_finalize)
+          end
+
+          it 'skips the action and continues' do
+            rescued_plan.state.must_equal :stopped
+            rescued_plan.result.must_equal :warning
+            rescued_plan.entry_action.output[:message].must_equal "Been here"
+          end
+        end
+
+        describe 'of plan with skips' do
           let :execution_plan do
             execute(Example::ComplexActionWithSkip, :error_on_run)
           end
@@ -153,12 +151,29 @@ module Dynflow
           it 'skips the action and continues automatically' do
             execution_plan.state.must_equal :stopped
             execution_plan.result.must_equal :warning
+            skipped_action = rescued_plan.actions.find do |action|
+              action.run_step && action.run_step.state == :skipped
+            end
+            skipped_action.output[:message].must_equal "skipped because some error as you wish"
           end
+        end
 
+        describe 'of complex action with skips in finalize phase' do
+          let :execution_plan do
+            execute(Example::ComplexActionWithSkip, :error_on_finalize)
+          end
+
+          it 'skips the action and continues' do
+            rescued_plan.state.must_equal :stopped
+            rescued_plan.result.must_equal :warning
+            skipped_action = rescued_plan.actions.find do |action|
+              action.steps.find { |step| step && step.state == :skipped }
+            end
+            skipped_action.output[:message].must_equal "Been here"
+          end
         end
 
         describe 'of plan faild on auto-rescue' do
-
           let :execution_plan do
             execute(Example::ActionWithSkip, 1, :error_on_skip)
           end
@@ -167,11 +182,9 @@ module Dynflow
             execution_plan.state.must_equal :paused
             execution_plan.result.must_equal :error
           end
-
         end
 
         describe 'of plan without skips' do
-
           let :execution_plan do
             execute(Example::ComplexActionWithoutSkip, :error_on_run)
           end
@@ -179,12 +192,13 @@ module Dynflow
           it 'skips the action and continues automatically' do
             execution_plan.state.must_equal :paused
             execution_plan.result.must_equal :error
+            expected_history = [['start execution', world.id],
+                                ['pause execution', world.id]]
+            execution_plan.execution_history.map { |h| [h.name, h.world_id] }.must_equal(expected_history)
           end
-
         end
 
         describe 'of plan with fail' do
-
           let :execution_plan do
             execute(Example::ComplexActionWithFail, :error_on_run)
           end
@@ -195,6 +209,9 @@ module Dynflow
             execution_plan.steps_in_state(:success).count.must_equal 6
             execution_plan.steps_in_state(:pending).count.must_equal 6
             execution_plan.steps_in_state(:error).count.must_equal 1
+            expected_history = [['start execution', world.id],
+                                ['finish execution', world.id]]
+            execution_plan.execution_history.map { |h| [h.name, h.world_id] }.must_equal(expected_history)
           end
         end
 

data/test/test_helper.rb

@@ -225,11 +225,11 @@ module TestHelpers
   def assert_plan_reexecuted(plan)
     assert_equal :stopped, plan.state
     assert_equal :success, plan.result
-    assert_equal plan.execution_history.map(&:name),
-                 ['start execution',
+    assert_equal ['start execution',
                   'terminate execution',
                   'start execution',
-                  'finish execution']
+                  'finish execution'],
+                 plan.execution_history.map(&:name)
     refute_equal plan.execution_history.first.world_id, plan.execution_history.to_a.last.world_id
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynflow
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.2
 platform: ruby
 authors:
 - Ivan Necas
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-24 00:00:00.000000000 Z
+date: 2019-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -481,13 +481,14 @@ files:
 - lib/dynflow/persistence_adapters/sequel_migrations/008_rename_scheduled_plans_to_delayed_plans.rb
 - lib/dynflow/persistence_adapters/sequel_migrations/009_fix_mysql_data_length.rb
 - lib/dynflow/persistence_adapters/sequel_migrations/010_add_execution_plans_label.rb
-- lib/dynflow/persistence_adapters/sequel_migrations/011_add_uuid_column.rb
+- lib/dynflow/persistence_adapters/sequel_migrations/011_placeholder.rb
 - lib/dynflow/persistence_adapters/sequel_migrations/012_add_delayed_plans_serialized_args.rb
 - lib/dynflow/persistence_adapters/sequel_migrations/013_add_action_columns.rb
 - lib/dynflow/persistence_adapters/sequel_migrations/014_add_step_columns.rb
 - lib/dynflow/persistence_adapters/sequel_migrations/015_add_execution_plan_columns.rb
 - lib/dynflow/persistence_adapters/sequel_migrations/016_add_step_queue.rb
 - lib/dynflow/persistence_adapters/sequel_migrations/017_add_delayed_plan_frozen.rb
+- lib/dynflow/persistence_adapters/sequel_migrations/018_add_uuid_column.rb
 - lib/dynflow/rails.rb
 - lib/dynflow/rails/configuration.rb
 - lib/dynflow/rails/daemon.rb