dynflow 0.2.0 → 0.3.0

data/lib/dynflow/simple_world.rb

@@ -6,6 +6,7 @@ module Dynflow
       # we can check consistency here because SimpleWorld doesn't expect
       # remote executor being in place.
       self.consistency_check
+      self.execute_planned_execution_plans
     end
 
     def default_options

data/lib/dynflow/testing/dummy_world.rb

@@ -4,13 +4,14 @@ module Dynflow
       extend Mimic
       mimic! World
 
-      attr_reader :clock, :executor
+      attr_reader :clock, :executor, :middleware
       attr_accessor :action
 
       def initialize
         @logger_adapter = Testing.logger_adapter
         @clock          = ManagedClock.new
         @executor       = DummyExecutor.new(self)
+        @middleware     = Middleware::World.new
       end
 
       def action_logger
@@ -28,6 +29,7 @@ module Dynflow
       def event(execution_plan_id, step_id, event, future = Future.new)
         executor.event execution_plan_id, step_id, event, future
       end
+
     end
   end
 end

data/lib/dynflow/version.rb

@@ -1,3 +1,3 @@
 module Dynflow
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/lib/dynflow/web_console.rb

@@ -1,6 +1,7 @@
 require 'dynflow'
 require 'pp'
 require 'sinatra'
+require 'yaml'
 
 module Dynflow
   class WebConsole < Sinatra::Base
@@ -24,12 +25,16 @@ module Dynflow
         settings.world
       end
 
+      def prettify_value(value)
+        YAML.dump(value)
+      end
+
       def prettyprint(value)
         value = prettyprint_references(value)
         if value
-          pretty_value = value.pretty_inspect
+          pretty_value = prettify_value(value)
           <<-HTML
-            <pre class="prettyprint">#{h(pretty_value)}</pre>
+            <pre class="prettyprint lang-yaml">#{h(pretty_value)}</pre>
           HTML
         else
           ""

data/lib/dynflow/world.rb

@@ -3,7 +3,7 @@ module Dynflow
     include Algebrick::TypeCheck
 
     attr_reader :executor, :persistence, :transaction_adapter, :action_classes, :subscription_index,
-                :logger_adapter, :options
+                :logger_adapter, :options, :middleware
 
     def initialize(options_hash = {})
       @options             = default_options.merge options_hash
@@ -13,6 +13,7 @@ module Dynflow
       @persistence         = Persistence.new(self, persistence_adapter)
       @executor            = Type! option_val(:executor), Executors::Abstract
       @action_classes      = option_val(:action_classes)
+      @middleware          = Middleware::World.new
       calculate_subscription_index
 
       executor.initialized.wait
@@ -47,6 +48,7 @@ module Dynflow
     # reload actions classes, intended only for devel
     def reload!
       @action_classes.map! { |klass| klass.to_s.constantize }
+      middleware.clear_cache!
       calculate_subscription_index
     end
 
@@ -74,7 +76,11 @@ module Dynflow
       execution_plan = plan(action_class, *args)
       planned        = execution_plan.state == :planned
       finished       = if planned
-                         execute(execution_plan.id)
+                         begin
+                           execute(execution_plan.id)
+                         rescue => exception
+                           Future.new.fail exception
+                         end
                        else
                          Future.new.resolve(execution_plan)
                        end
@@ -122,15 +128,19 @@ module Dynflow
     # After the executor is unregistered, the consistency check should be performed
     # to fix the orphaned plans as well.
     def consistency_check
-      abnormal_execution_plans = self.persistence.find_execution_plans filters: { 'state' => %w(running planning) }
+      abnormal_execution_plans =
+          self.persistence.find_execution_plans filters: { 'state' => %w(running planning) }
       if abnormal_execution_plans.empty?
         logger.info 'Clean start.'
       else
         format_str = '%36s %10s %10s'
         message    = ['Abnormal execution plans, process was probably killed.',
-                      'Following ExecutionPlans will be set to paused, admin has to fix them manually.',
+                      'Following ExecutionPlans will be set to paused, ',
+                      'it should be fixed manually by administrator.',
                       (format format_str, 'ExecutionPlan', 'state', 'result'),
-                      *(abnormal_execution_plans.map { |ep| format format_str, ep.id, ep.state, ep.result })]
+                      *(abnormal_execution_plans.map do |ep|
+                        format format_str, ep.id, ep.state, ep.result
+                      end)]
 
         logger.error message.join("\n")
 
@@ -147,13 +157,23 @@ module Dynflow
       end
     end
 
+    # should be called after World is initialized, SimpleWorld does it automatically
+    def execute_planned_execution_plans
+      planned_execution_plans =
+          self.persistence.find_execution_plans filters: { 'state' => %w(planned) }
+      planned_execution_plans.each { |ep| execute ep.id }
+    end
+
     private
 
     def calculate_subscription_index
-      @subscription_index = action_classes.each_with_object(Hash.new { |h, k| h[k] = [] }) do |klass, index|
-        next unless klass.subscribe
-        Array(klass.subscribe).each { |subscribed_class| index[subscribed_class.to_s.constantize] << klass }
-      end.tap { |o| o.freeze }
+      @subscription_index =
+          action_classes.each_with_object(Hash.new { |h, k| h[k] = [] }) do |klass, index|
+            next unless klass.subscribe
+            Array(klass.subscribe).each do |subscribed_class|
+              index[subscribed_class.to_s.constantize] << klass
+            end
+          end.tap { |o| o.freeze }
     end
 
     def option_val(key)

data/test/action_test.rb

@@ -1,5 +1,4 @@
 require_relative 'test_helper'
-require_relative 'code_workflow_example'
 
 module Dynflow
 
@@ -65,8 +64,8 @@ module Dynflow
     specify { smart_action_class.all_children.wont_include smarter_action_class.finalize_phase }
 
     describe 'World#subscribed_actions' do
-      event_action_class      = CodeWorkflowExample::Triage
-      subscribed_action_class = CodeWorkflowExample::NotifyAssignee
+      event_action_class      = Support::CodeWorkflowExample::Triage
+      subscribed_action_class = Support::CodeWorkflowExample::NotifyAssignee
 
       specify { subscribed_action_class.subscribe.must_equal event_action_class }
       specify { world.subscribed_actions(event_action_class).must_include subscribed_action_class }
@@ -78,7 +77,7 @@ module Dynflow
     include WorldInstance
 
     let :execution_plan do
-      id, planned, finished = *world.trigger(CodeWorkflowExample::IncomingIssues, issues_data)
+      id, planned, finished = *world.trigger(Support::CodeWorkflowExample::IncomingIssues, issues_data)
       raise unless planned
       finished.value
     end
@@ -90,11 +89,11 @@ module Dynflow
 
     let :presenter do
       execution_plan.actions.find do |action|
-        action.is_a? CodeWorkflowExample::IncomingIssues
+        action.is_a? Support::CodeWorkflowExample::IncomingIssues
       end
     end
 
-    specify { presenter.action_class.must_equal CodeWorkflowExample::IncomingIssues }
+    specify { presenter.action_class.must_equal Support::CodeWorkflowExample::IncomingIssues }
 
     it 'allows aggregating data from other actions' do
       presenter.summary.must_equal(assignees: ["John Doe"])

data/test/execution_plan_test.rb

@@ -1,5 +1,4 @@
 require_relative 'test_helper'
-require_relative 'code_workflow_example'
 
 module Dynflow
   module ExecutionPlanTest
@@ -16,7 +15,7 @@ module Dynflow
       describe 'serialization' do
 
         let :execution_plan do
-          world.plan(CodeWorkflowExample::FastCommit, 'sha' => 'abc123')
+          world.plan(Support::CodeWorkflowExample::FastCommit, 'sha' => 'abc123')
         end
 
         let :deserialized_execution_plan do
@@ -47,7 +46,7 @@ module Dynflow
       describe '#result' do
 
         let :execution_plan do
-          world.plan(CodeWorkflowExample::FastCommit, 'sha' => 'abc123')
+          world.plan(Support::CodeWorkflowExample::FastCommit, 'sha' => 'abc123')
         end
 
         describe 'for error in planning phase' do
@@ -107,7 +106,7 @@ module Dynflow
 
       describe 'plan steps' do
         let :execution_plan do
-          world.plan(CodeWorkflowExample::IncomingIssues, issues_data)
+          world.plan(Support::CodeWorkflowExample::IncomingIssues, issues_data)
         end
 
         it 'stores the information about the sub actions' do
@@ -129,7 +128,7 @@ module Dynflow
       describe 'persisted action' do
 
         let :execution_plan do
-          world.plan(CodeWorkflowExample::IncomingIssues, issues_data)
+          world.plan(Support::CodeWorkflowExample::IncomingIssues, issues_data)
         end
 
         let :action do
@@ -148,7 +147,7 @@ module Dynflow
 
         describe 'single dependencies' do
           let :execution_plan do
-            world.plan(CodeWorkflowExample::IncomingIssues, issues_data)
+            world.plan(Support::CodeWorkflowExample::IncomingIssues, issues_data)
           end
 
           it 'constructs the plan of actions to be executed in run phase' do
@@ -169,7 +168,7 @@ module Dynflow
 
         describe 'multi dependencies' do
           let :execution_plan do
-            world.plan(CodeWorkflowExample::Commit, 'sha' => 'abc123')
+            world.plan(Support::CodeWorkflowExample::Commit, 'sha' => 'abc123')
           end
 
           it 'constructs the plan of actions to be executed in run phase' do
@@ -186,7 +185,7 @@ module Dynflow
 
         describe 'sequence and concurrence keyword used' do
           let :execution_plan do
-            world.plan(CodeWorkflowExample::FastCommit, 'sha' => 'abc123')
+            world.plan(Support::CodeWorkflowExample::FastCommit, 'sha' => 'abc123')
           end
 
           it 'constructs the plan of actions to be executed in run phase' do
@@ -202,7 +201,7 @@ module Dynflow
 
         describe 'subscribed action' do
           let :execution_plan do
-            world.plan(CodeWorkflowExample::DummyTrigger, {})
+            world.plan(Support::CodeWorkflowExample::DummyTrigger, {})
           end
 
           it 'constructs the plan of actions to be executed in run phase' do
@@ -218,7 +217,7 @@ module Dynflow
         describe 'finalize flow' do
 
           let :execution_plan do
-            world.plan(CodeWorkflowExample::IncomingIssues, issues_data)
+            world.plan(Support::CodeWorkflowExample::IncomingIssues, issues_data)
           end
 
           it 'plans the finalize steps in a sequence' do
@@ -237,7 +236,7 @@ module Dynflow
 
       describe 'accessing actions results' do
         let :execution_plan do
-          world.plan(CodeWorkflowExample::IncomingIssues, issues_data)
+          world.plan(Support::CodeWorkflowExample::IncomingIssues, issues_data)
         end
 
         it 'provides the access to the actions data via Action::Presenter' do

data/test/executor_test.rb

@@ -1,5 +1,4 @@
 require_relative 'test_helper'
-require_relative 'code_workflow_example'
 
 module Dynflow
   module ExecutorTest
@@ -28,19 +27,15 @@ module Dynflow
              { 'author' => 'John Doe', 'text' => 'trolling in finalize' }]
           end
 
-          let :execution_plan do
-            world.plan(CodeWorkflowExample::IncomingIssues, issues_data)
-          end
-
           let :failed_execution_plan do
-            plan = world.plan(CodeWorkflowExample::IncomingIssues, failing_issues_data)
+            plan = world.plan(Support::CodeWorkflowExample::IncomingIssues, failing_issues_data)
             plan = world.execute(plan.id).value
             plan.state.must_equal :paused
             plan
           end
 
           let :finalize_failed_execution_plan do
-            plan = world.plan(CodeWorkflowExample::IncomingIssues, finalize_failing_issues_data)
+            plan = world.plan(Support::CodeWorkflowExample::IncomingIssues, finalize_failing_issues_data)
             plan = world.execute(plan.id).value
             plan.state.must_equal :paused
             plan
@@ -58,10 +53,29 @@ module Dynflow
 
             describe "after successful planning" do
 
+              let :execution_plan do
+                world.plan(Support::CodeWorkflowExample::IncomingIssues, issues_data)
+              end
+
               it "is pending" do
                 execution_plan.state.must_equal :planned
               end
 
+              describe "when finished successfully" do
+                it "is stopped" do
+                  world.execute(execution_plan.id).value.tap do |plan|
+                    plan.state.must_equal :stopped
+                  end
+                end
+              end
+
+              describe "when finished with error" do
+                it "is paused" do
+                  world.execute(failed_execution_plan.id).value.tap do |plan|
+                    plan.state.must_equal :paused
+                  end
+                end
+              end
             end
 
             describe "after error in planning" do
@@ -85,7 +99,7 @@ module Dynflow
             describe "when being executed" do
 
               let :execution_plan do
-                world.plan(CodeWorkflowExample::IncomingIssue, { 'text' => 'get a break' })
+                world.plan(Support::CodeWorkflowExample::IncomingIssue, { 'text' => 'get a break' })
               end
 
               before do
@@ -103,7 +117,7 @@ module Dynflow
                   plan.state.must_equal :running
                   triage = plan.steps.values.find do |s|
                     s.is_a?(Dynflow::ExecutionPlan::Steps::RunStep) &&
-                        s.action_class == Dynflow::CodeWorkflowExample::Triage
+                        s.action_class == Support::CodeWorkflowExample::Triage
                   end
                   triage.state.must_equal :running
                   world.persistence.
@@ -118,23 +132,6 @@ module Dynflow
                 end
               end
             end
-
-            describe "when finished successfully" do
-
-              it "is stopped" do
-                world.execute(execution_plan.id).value.tap do |plan|
-                  plan.state.must_equal :stopped
-                end
-              end
-            end
-
-            describe "when finished with error" do
-              it "is paused" do
-                world.execute(failed_execution_plan.id).value.tap do |plan|
-                  plan.state.must_equal :paused
-                end
-              end
-            end
           end
 
           describe "execution of run flow" do
@@ -144,25 +141,51 @@ module Dynflow
             end
 
             let :result do
-              world.execute(execution_plan.id).value.tap do |result|
-                raise result if result.is_a? Exception
-              end
+              world.execute(execution_plan.id).value!
             end
 
             after do
               TestExecutionLog.teardown
             end
 
-            let :persisted_plan do
+            def persisted_plan
               result
-              world.persistence.load_execution_plan(execution_plan.id)
+              super
             end
 
             describe 'cancellable action' do
 
+              describe event_class = Listeners::Serialization::Protocol::Event do
+                it 'de/serializes' do
+                  Klass = Class.new do
+                    def initialize(v)
+                      @v = v
+                    end
+
+                    def to_s
+                      @v.to_s
+                    end
+
+                    def ==(other)
+                      @v == other.instance_variable_get(:@v)
+                    end
+                  end
+
+                  object      = Klass.new :value
+                  event       = event_class['uuid', 0, object]
+                  hash        = event.to_hash
+                  json        = MultiJson.dump(hash)
+                  hash_loaded = MultiJson.load(json)
+                  assert_equal event[:event], event_class.from_hash(hash_loaded)[:event]
+                  assert_equal event, event_class.from_hash(hash_loaded)
+
+                  ExecutorTest.send :remove_const, :Klass
+                end
+              end
+
               describe 'successful' do
                 let :execution_plan do
-                  world.plan(CodeWorkflowExample::CancelableSuspended, {})
+                  world.plan(Support::CodeWorkflowExample::CancelableSuspended, {})
                 end
 
                 it "doesn't cause problems" do
@@ -173,7 +196,7 @@ module Dynflow
 
               describe 'canceled' do
                 let :execution_plan do
-                  world.plan(CodeWorkflowExample::CancelableSuspended, { text: 'cancel' })
+                  world.plan(Support::CodeWorkflowExample::CancelableSuspended, { text: 'cancel-self' })
                 end
 
                 it 'cancels' do
@@ -187,7 +210,7 @@ module Dynflow
 
               describe 'canceled failed' do
                 let :execution_plan do
-                  world.plan(CodeWorkflowExample::CancelableSuspended, { text: 'cancel fail' })
+                  world.plan(Support::CodeWorkflowExample::CancelableSuspended, { text: 'cancel-fail cancel-self' })
                 end
 
                 it 'fails' do
@@ -199,40 +222,37 @@ module Dynflow
                   action.output[:progress].must_equal 30
                 end
               end
-            end
-
 
-            describe "suspended action" do
-              let :execution_plan do
-                world.plan(CodeWorkflowExample::DummySuspended, { :external_task_id => '123' })
-              end
+              if world_method == :remote_world
+                describe 'canceled externally' do
+                  let :execution_plan do
+                    world.plan(Support::CodeWorkflowExample::CancelableSuspended, { text: 'cancel-external' })
+                  end
 
-              it "doesn't cause problems" do
-                result.result.must_equal :success
-                result.state.must_equal :stopped
+                  it 'cancels' do
+                    finished = world.execute(execution_plan.id)
+                    sleep 0.05
+                    world.
+                        event(execution_plan.id, 2,
+                              Support::CodeWorkflowExample::CancelableSuspended::Cancel).
+                        value!.must_equal true
+                    result = finished.value!
+
+                    result.result.must_equal :success
+                    result.state.must_equal :stopped
+                    action = world.persistence.load_action result.steps[2]
+                    action.output[:progress].must_be :<=, 30
+                    action.output[:cancelled].must_equal true
+                  end
+                end
               end
 
-              it 'does set times' do
-                result.started_at.wont_be_nil
-                result.ended_at.wont_be_nil
-                result.execution_time.must_be :<, result.real_time
-                result.execution_time.must_equal(
-                    result.steps.inject(0) { |sum, (_, step)| sum + step.execution_time })
-
-                plan_step = result.steps[1]
-                plan_step.started_at.wont_be_nil
-                plan_step.ended_at.wont_be_nil
-                plan_step.execution_time.must_equal plan_step.real_time
-
-                run_step = result.steps[2]
-                run_step.started_at.wont_be_nil
-                run_step.ended_at.wont_be_nil
-                run_step.execution_time.must_be :<, run_step.real_time
-              end
+            end
 
+            describe 'suspended action' do
               describe 'handling errors in setup' do
                 let :execution_plan do
-                  world.plan(CodeWorkflowExample::DummySuspended,
+                  world.plan(Support::CodeWorkflowExample::DummySuspended,
                              external_task_id: '123',
                              text:             'troll setup')
                 end
@@ -247,6 +267,35 @@ module Dynflow
                 end
               end
 
+              describe 'running' do
+                let :execution_plan do
+                  world.plan(Support::CodeWorkflowExample::DummySuspended, { :external_task_id => '123' })
+                end
+
+                it "doesn't cause problems" do
+                  result.result.must_equal :success
+                  result.state.must_equal :stopped
+                end
+
+                it 'does set times' do
+                  result.started_at.wont_be_nil
+                  result.ended_at.wont_be_nil
+                  result.execution_time.must_be :<, result.real_time
+                  result.execution_time.must_equal(
+                      result.steps.inject(0) { |sum, (_, step)| sum + step.execution_time })
+
+                  plan_step = result.steps[1]
+                  plan_step.started_at.wont_be_nil
+                  plan_step.ended_at.wont_be_nil
+                  plan_step.execution_time.must_equal plan_step.real_time
+
+                  run_step = result.steps[2]
+                  run_step.started_at.wont_be_nil
+                  run_step.ended_at.wont_be_nil
+                  run_step.execution_time.must_be :<, run_step.real_time
+                end
+              end
+
               describe 'progress' do
                 before do
                   TestPause.setup
@@ -260,7 +309,7 @@ module Dynflow
 
                 describe 'plan with one action' do
                   let :execution_plan do
-                    world.plan(CodeWorkflowExample::DummySuspended,
+                    world.plan(Support::CodeWorkflowExample::DummySuspended,
                                { external_task_id: '123',
                                  text:             'pause in progress 20%' })
                   end
@@ -275,7 +324,7 @@ module Dynflow
 
                 describe 'plan with more action' do
                   let :execution_plan do
-                    world.plan(CodeWorkflowExample::DummyHeavyProgress,
+                    world.plan(Support::CodeWorkflowExample::DummyHeavyProgress,
                                { external_task_id: '123',
                                  text:             'pause in progress 20%' })
                   end
@@ -291,7 +340,7 @@ module Dynflow
 
               describe 'works when resumed after error' do
                 let :execution_plan do
-                  world.plan(CodeWorkflowExample::DummySuspended,
+                  world.plan(Support::CodeWorkflowExample::DummySuspended,
                              { external_task_id: '123',
                                text:             'troll progress' })
                 end
@@ -315,7 +364,7 @@ module Dynflow
             describe "action with empty flows" do
 
               let :execution_plan do
-                world.plan(CodeWorkflowExample::Dummy, { :text => "dummy" }).tap do |plan|
+                world.plan(Support::CodeWorkflowExample::Dummy, { :text => "dummy" }).tap do |plan|
                   assert_equal plan.run_flow.size, 0
                   assert_equal plan.finalize_flow.size, 0
                 end.tap do |w|
@@ -338,7 +387,7 @@ module Dynflow
             describe 'action with empty run flow but some finalize flow' do
 
               let :execution_plan do
-                world.plan(CodeWorkflowExample::DummyWithFinalize, { :text => "dummy" }).tap do |plan|
+                world.plan(Support::CodeWorkflowExample::DummyWithFinalize, { :text => "dummy" }).tap do |plan|
                   assert_equal plan.run_flow.size, 0
                   assert_equal plan.finalize_flow.size, 1
                 end
@@ -351,24 +400,29 @@ module Dynflow
 
             end
 
-            it "runs all the steps in the run flow" do
-              assert_run_flow <<-EXECUTED_RUN_FLOW, persisted_plan
-            Dynflow::Flows::Concurrence
-              Dynflow::Flows::Sequence
-                4: Triage(success) {"author"=>"Peter Smith", "text"=>"Failing test"} --> {"classification"=>{"assignee"=>"John Doe", "severity"=>"medium"}}
-                7: UpdateIssue(success) {"author"=>"Peter Smith", "text"=>"Failing test", "assignee"=>"John Doe", "severity"=>"medium"} --> {}
-                9: NotifyAssignee(success) {"triage"=>{"classification"=>{"assignee"=>"John Doe", "severity"=>"medium"}}} --> {}
-              Dynflow::Flows::Sequence
-                13: Triage(success) {"author"=>"John Doe", "text"=>"Internal server error"} --> {"classification"=>{"assignee"=>"John Doe", "severity"=>"medium"}}
-                16: UpdateIssue(success) {"author"=>"John Doe", "text"=>"Internal server error", "assignee"=>"John Doe", "severity"=>"medium"} --> {}
-                18: NotifyAssignee(success) {"triage"=>{"classification"=>{"assignee"=>"John Doe", "severity"=>"medium"}}} --> {}
-              EXECUTED_RUN_FLOW
+            describe 'running' do
+              let :execution_plan do
+                world.plan(Support::CodeWorkflowExample::IncomingIssues, issues_data)
+              end
+
+              it "runs all the steps in the run flow" do
+                assert_run_flow <<-EXECUTED_RUN_FLOW, persisted_plan
+                  Dynflow::Flows::Concurrence
+                    Dynflow::Flows::Sequence
+                      4: Triage(success) {"author"=>"Peter Smith", "text"=>"Failing test"} --> {"classification"=>{"assignee"=>"John Doe", "severity"=>"medium"}}
+                      7: UpdateIssue(success) {"author"=>"Peter Smith", "text"=>"Failing test", "assignee"=>"John Doe", "severity"=>"medium"} --> {}
+                      9: NotifyAssignee(success) {"triage"=>{"classification"=>{"assignee"=>"John Doe", "severity"=>"medium"}}} --> {}
+                    Dynflow::Flows::Sequence
+                      13: Triage(success) {"author"=>"John Doe", "text"=>"Internal server error"} --> {"classification"=>{"assignee"=>"John Doe", "severity"=>"medium"}}
+                      16: UpdateIssue(success) {"author"=>"John Doe", "text"=>"Internal server error", "assignee"=>"John Doe", "severity"=>"medium"} --> {}
+                      18: NotifyAssignee(success) {"triage"=>{"classification"=>{"assignee"=>"John Doe", "severity"=>"medium"}}} --> {}
+                EXECUTED_RUN_FLOW
+              end
             end
 
           end
 
           describe "execution of finalize flow" do
-
             before do
               TestExecutionLog.setup
               result = world.execute(execution_plan.id).value
@@ -380,17 +434,19 @@ module Dynflow
             end
 
             describe "when run flow successful" do
+              let :execution_plan do
+                world.plan(Support::CodeWorkflowExample::IncomingIssues, issues_data)
+              end
 
               it "runs all the steps in the finalize flow" do
-                assert_finalized(Dynflow::CodeWorkflowExample::IncomingIssues,
+                assert_finalized(Support::CodeWorkflowExample::IncomingIssues,
                                  { "issues" => [{ "author" => "Peter Smith", "text" => "Failing test" }, { "author" => "John Doe", "text" => "Internal server error" }] })
-                assert_finalized(Dynflow::CodeWorkflowExample::Triage,
+                assert_finalized(Support::CodeWorkflowExample::Triage,
                                  { "author" => "Peter Smith", "text" => "Failing test" })
               end
             end
 
             describe "when run flow failed" do
-
               let :execution_plan do
                 failed_execution_plan
               end
@@ -425,7 +481,7 @@ module Dynflow
               resumed_execution_plan.result.must_equal :success
 
               run_triages = TestExecutionLog.run.find_all do |action_class, input|
-                action_class == CodeWorkflowExample::Triage
+                action_class == Support::CodeWorkflowExample::Triage
               end
               run_triages.size.must_equal 1
 
@@ -443,6 +499,7 @@ module Dynflow
             end
 
           end
+
           describe "re-execution of run flow after fix in finalize phase" do
 
             after do
@@ -466,7 +523,7 @@ module Dynflow
               resumed_execution_plan.result.must_equal :success
 
               run_triages = TestExecutionLog.finalize.find_all do |action_class, input|
-                action_class == CodeWorkflowExample::Triage
+                action_class == Support::CodeWorkflowExample::Triage
               end
               run_triages.size.must_equal 2
 
@@ -502,7 +559,7 @@ module Dynflow
               resumed_execution_plan.result.must_equal :success
 
               run_triages = TestExecutionLog.run.find_all do |action_class, input|
-                action_class == CodeWorkflowExample::Triage
+                action_class == Support::CodeWorkflowExample::Triage
               end
               run_triages.size.must_equal 0
 
@@ -531,6 +588,10 @@ module Dynflow
           end
 
           describe 'FlowManager' do
+            let :execution_plan do
+              world.plan(Support::CodeWorkflowExample::IncomingIssues, issues_data)
+            end
+
             let(:manager) { Executors::Parallel::FlowManager.new execution_plan, execution_plan.run_flow }
 
             def assert_next_steps(expected_next_step_ids, finished_step_id = nil, success = true)
@@ -645,13 +706,13 @@ module Dynflow
             if which == :normal_world
               it 'executes until its done when terminating' do
                 $slow_actions_done = 0
-                world.trigger(CodeWorkflowExample::Slow, 0.02)
+                world.trigger(Support::CodeWorkflowExample::Slow, 0.02)
                 world.terminate.wait
                 $slow_actions_done.must_equal 1
               end
 
               it 'executes until its done when terminating even suspended' do
-                result = world.trigger(CodeWorkflowExample::DummySuspended,
+                result = world.trigger(Support::CodeWorkflowExample::DummySuspended,
                                        external_task_id: '123',
                                        text:             'none')
                 world.terminate.wait
@@ -661,12 +722,14 @@ module Dynflow
 
             it 'does not accept new work' do
               assert world.terminate.wait
-              -> { world.trigger(CodeWorkflowExample::Slow, 0.02) }.must_raise Dynflow::Error
+              result = world.trigger(Support::CodeWorkflowExample::Slow, 0.02)
+              result.planned.must_equal true
+              -> { result.finished.value! }.must_raise Dynflow::Error
             end
 
             it 'it terminates when no work' do
               skip 'blocks occasionally' if which == :remote_world # FIXME
-              world.trigger(CodeWorkflowExample::Slow, 0.02).finished.wait
+              world.trigger(Support::CodeWorkflowExample::Slow, 0.02).finished.wait
               assert world.terminate.wait
             end