dynflow 0.3.0 → 0.4.0

data/lib/dynflow/testing/assertions.rb

@@ -20,7 +20,7 @@ module Dynflow
 
       # assert that +assert_actioned_plan+ was planned by +action+
       def assert_action_planed(action, planned_action_class)
-        Type! action, Dynflow::Action::PlanPhase
+        Match! action.phase, Action::Plan
         Match! action.state, :success
         found = action.execution_plan.planned_plan_steps.
             select { |a| a.is_a?(planned_action_class) }
@@ -31,7 +31,7 @@ module Dynflow
 
       # assert that +action+ has run-phase planned
       def assert_run_phase(action, input = nil, &block)
-        Type! action, Dynflow::Action::PlanPhase
+        Match! action.phase, Action::Plan
         Match! action.state, :success
         action.execution_plan.planned_run_steps.must_include action
         action.input.must_equal input.stringify_keys if input
@@ -40,21 +40,21 @@ module Dynflow
 
       # refute that +action+ has run-phase planned
       def refute_run_phase(action)
-        Type! action, Dynflow::Action::PlanPhase
+        Match! action.phase, Action::Plan
         Match! action.state, :success
         action.execution_plan.planned_run_steps.wont_include action
       end
 
       # assert that +action+ has finalize-phase planned
       def assert_finalize_phase(action)
-        Type! action, Dynflow::Action::PlanPhase
+        Match! action.phase, Action::Plan
         Match! action.state, :success
         action.execution_plan.planned_finalize_steps.must_include action
       end
 
       # refute that +action+ has finalize-phase planned
       def refute_finalize_phase(action)
-        Type! action, Dynflow::Action::PlanPhase
+        Match! action.phase, Action::Plan
         Match! action.state, :success
         action.execution_plan.planned_finalize_steps.wont_include action
       end

data/lib/dynflow/testing/dummy_execution_plan.rb

@@ -7,7 +7,7 @@ module Dynflow
       attr_reader :id, :planned_plan_steps, :planned_run_steps, :planned_finalize_steps
 
       def initialize
-        @id                     = Testing.get_id
+        @id                     = Testing.get_id.to_s
         @planned_plan_steps     = []
         @planned_run_steps      = []
         @planned_finalize_steps = []

data/lib/dynflow/testing/dummy_planned_action.rb

@@ -6,7 +6,8 @@ module Dynflow
 
       def initialize(klass)
         mimic! klass
-        @output = ExecutionPlan::OutputReference.new(Testing.get_id, Testing.get_id)
+        @output = ExecutionPlan::OutputReference.new(
+            Testing.get_id.to_s, Testing.get_id, Testing.get_id)
       end
 
       def execute(execution_plan, event, *args)

data/lib/dynflow/testing/dummy_world.rb

@@ -30,6 +30,10 @@ module Dynflow
         executor.event execution_plan_id, step_id, event, future
       end
 
+      def persistence
+        nil
+      end
+
     end
   end
 end

data/lib/dynflow/testing/factories.rb

@@ -7,17 +7,22 @@ module Dynflow
       def create_action(action_class, trigger = nil)
         execution_plan = DummyExecutionPlan.new
         step           = DummyStep.new
-        action_class.plan_phase.new(
+        action_class.new(
             { step:              DummyStep.new,
+              execution_plan:    execution_plan,
+              trigger:           trigger,
               execution_plan_id: execution_plan.id,
               id:                Testing.get_id,
-              plan_step_id:      step.id },
-            execution_plan, trigger)
+              phase:             Action::Plan,
+              plan_step_id:      step.id,
+              run_step_id:       nil,
+              finalize_step_id:  nil },
+            execution_plan.world)
       end
 
       # @return [Action::PlanPhase]
       def plan_action(plan_action, *args, &block)
-        Type! plan_action, Dynflow::Action::PlanPhase
+        Match! plan_action.phase, Action::Plan
 
         plan_action.execute *args, &block
         raise plan_action.error if plan_action.error
@@ -30,15 +35,17 @@ module Dynflow
 
       # @return [Action::RunPhase]
       def run_action(plan_action, event = nil, &stubbing)
-        Type! plan_action, Dynflow::Action::PlanPhase, Dynflow::Action::RunPhase
+        Match! plan_action.phase, Action::Plan, Action::Run
         step       = DummyStep.new
-        run_action = if Dynflow::Action::PlanPhase === plan_action
-                       plan_action.action_class.run_phase.new(
+        run_action = if plan_action.phase == Action::Plan
+                       plan_action.class.new(
                            { step:              step,
                              execution_plan_id: plan_action.execution_plan_id,
                              id:                plan_action.id,
                              plan_step_id:      plan_action.plan_step_id,
                              run_step_id:       step.id,
+                             finalize_step_id:  nil,
+                             phase:             Action::Run,
                              input:             plan_action.input },
                            plan_action.world)
 
@@ -56,15 +63,16 @@ module Dynflow
 
       # @return [Action::FinalizePhase]
       def finalize_action(run_action, &stubbing)
-        Type! run_action, Dynflow::Action::RunPhase
+        Match! run_action.phase, Action::Run
         step            = DummyStep.new
-        finalize_action = run_action.action_class.finalize_phase.new(
+        finalize_action = run_action.class.new(
             { step:              step,
               execution_plan_id: run_action.execution_plan_id,
               id:                run_action.id,
               plan_step_id:      run_action.plan_step_id,
               run_step_id:       run_action.run_step_id,
               finalize_step_id:  step.id,
+              phase:             Action::Finalize,
               input:             run_action.input },
             run_action.world)
 
@@ -74,7 +82,7 @@ module Dynflow
       end
 
       def progress_action_time action
-        Type! action, Dynflow::Action::RunPhase
+        Match! action.phase, Action::Run
         action.world.clock.progress
         action.world.executor.progress
       end

data/lib/dynflow/version.rb

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

data/lib/dynflow/world.rb

@@ -52,21 +52,35 @@ module Dynflow
       calculate_subscription_index
     end
 
-    class TriggerResult
-      include Algebrick::TypeCheck
+    TriggerResult = Algebrick.type do
+      # Returned by #trigger when planning fails.
+      PlaningFailed   = type { fields! execution_plan_id: String, error: Exception }
+      # Returned by #trigger when planning is successful but execution fails to start.
+      ExecutionFailed = type { fields! execution_plan_id: String, error: Exception }
+      # Returned by #trigger when planning is successful, #future will resolve after
+      # ExecutionPlan is executed.
+      Triggered       = type { fields! execution_plan_id: String, future: Future }
 
-      attr_reader :execution_plan_id, :planned, :finished
-      alias_method :id, :execution_plan_id
-      alias_method :planned?, :planned
+      variants PlaningFailed, ExecutionFailed, Triggered
+    end
+
+    module TriggerResult
+      def planned?
+        match self, PlaningFailed => false, ExecutionFailed => true, Triggered => true
+      end
+
+      def triggered?
+        match self, PlaningFailed => false, ExecutionFailed => false, Triggered => true
+      end
 
-      def initialize(execution_plan_id, planned, finished)
-        @execution_plan_id = Type! execution_plan_id, String
-        @planned           = Type! planned, TrueClass, FalseClass
-        @finished          = Type! finished, Future
+      def id
+        execution_plan_id
       end
+    end
 
-      def to_a
-        [execution_plan_id, planned, finished]
+    module Triggered
+      def finished
+        future
       end
     end
 
@@ -75,16 +89,16 @@ module Dynflow
     def trigger(action_class, *args)
       execution_plan = plan(action_class, *args)
       planned        = execution_plan.state == :planned
-      finished       = if planned
-                         begin
-                           execute(execution_plan.id)
-                         rescue => exception
-                           Future.new.fail exception
-                         end
-                       else
-                         Future.new.resolve(execution_plan)
-                       end
-      return TriggerResult.new(execution_plan.id, planned, finished)
+
+      if planned
+        begin
+          Triggered[execution_plan.id, execute(execution_plan.id)]
+        rescue => exception
+          ExecutionFailed[execution_plan.id, exception]
+        end
+      else
+        PlaningFailed[execution_plan.id, execution_plan.errors.first.exception]
+      end
     end
 
     def event(execution_plan_id, step_id, event, future = Future.new)

data/test/action_test.rb

@@ -1,102 +1,76 @@
 require_relative 'test_helper'
 
 module Dynflow
-
-
-  describe Action::Missing do
+  describe 'action' do
     include WorldInstance
 
-    let :action_data do
-      { class:             'RenamedAction',
-        id:                123,
-        input:             {},
-        execution_plan_id: 123 }
-    end
-
-    subject do
-      state_holder = ExecutionPlan::Steps::Abstract.allocate
-      state_holder.set_state :success, true
-      Action.from_hash(action_data, :run_phase, state_holder, world)
-    end
-
-    specify { subject.action_class.name.must_equal 'RenamedAction' }
-    specify { assert subject.is_a? Action }
-  end
-
-  describe "extending action phase" do
-
-    module TestExtending
-
-      module Extension
-        def new_method
-        end
+    describe Action::Missing do
+
+      let :action_data do
+        { class:             'RenamedAction',
+          id:                1,
+          input:             {},
+          output:            {},
+          execution_plan_id: '123',
+          plan_step_id:      2,
+          run_step_id:       3,
+          finalize_step_id:  nil,
+          phase:             Action::Run }
       end
 
-      class ExtendedAction < Dynflow::Action
-        def self.phase_modules
-          super.merge(run_phase: [Extension]) { |key, old, new| old + new }.freeze
-        end
+      subject do
+        step = ExecutionPlan::Steps::Abstract.allocate
+        step.set_state :success, true
+        Action.from_hash(action_data.merge(step: step), world)
       end
-    end
 
-    it "is possible to extend the action just for some phase" do
-      refute TestExtending::ExtendedAction.plan_phase.instance_methods.include?(:new_method)
-      refute Dynflow::Action.run_phase.instance_methods.include?(:new_method)
-      assert TestExtending::ExtendedAction.run_phase.instance_methods.include?(:new_method)
+      specify { subject.class.name.must_equal 'RenamedAction' }
+      specify { assert subject.is_a? Action }
     end
-  end
 
+    describe 'children' do
 
-  describe 'children' do
-    include WorldInstance
-
-    smart_action_class   = Class.new(Dynflow::Action)
-    smarter_action_class = Class.new(smart_action_class)
+      smart_action_class   = Class.new(Dynflow::Action)
+      smarter_action_class = Class.new(smart_action_class)
 
-    specify { refute smart_action_class.phase? }
-    specify { refute smarter_action_class.phase? }
-    specify { assert smarter_action_class.plan_phase.phase? }
+      specify { smart_action_class.all_children.must_include smarter_action_class }
+      specify { smart_action_class.all_children.size.must_equal 1 }
 
-    specify { smart_action_class.all_children.must_include smarter_action_class }
-    specify { smart_action_class.all_children.size.must_equal 1 }
-    specify { smart_action_class.all_children.wont_include smarter_action_class.plan_phase }
-    specify { smart_action_class.all_children.wont_include smarter_action_class.run_phase }
-    specify { smart_action_class.all_children.wont_include smarter_action_class.finalize_phase }
+      describe 'World#subscribed_actions' do
+        event_action_class      = Support::CodeWorkflowExample::Triage
+        subscribed_action_class = Support::CodeWorkflowExample::NotifyAssignee
 
-    describe 'World#subscribed_actions' do
-      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 }
-      specify { world.subscribed_actions(event_action_class).size.must_equal 1 }
+        specify { subscribed_action_class.subscribe.must_equal event_action_class }
+        specify { world.subscribed_actions(event_action_class).must_include subscribed_action_class }
+        specify { world.subscribed_actions(event_action_class).size.must_equal 1 }
+      end
     end
-  end
 
-  describe Action::Presenter do
-    include WorldInstance
+    describe Action::Present do
+      include WorldInstance
 
-    let :execution_plan do
-      id, planned, finished = *world.trigger(Support::CodeWorkflowExample::IncomingIssues, issues_data)
-      raise unless planned
-      finished.value
-    end
+      let :execution_plan do
+        result = world.trigger(Support::CodeWorkflowExample::IncomingIssues, issues_data)
+        result.must_be :planned?
+        result.finished.value
+      end
 
-    let :issues_data do
-      [{ 'author' => 'Peter Smith', 'text' => 'Failing test' },
-       { 'author' => 'John Doe', 'text' => 'Internal server error' }]
-    end
+      let :issues_data do
+        [{ 'author' => 'Peter Smith', 'text' => 'Failing test' },
+         { 'author' => 'John Doe', 'text' => 'Internal server error' }]
+      end
 
-    let :presenter do
-      execution_plan.actions.find do |action|
-        action.is_a? Support::CodeWorkflowExample::IncomingIssues
+      let :presenter do
+        execution_plan.actions.find do |action|
+          action.is_a? Support::CodeWorkflowExample::IncomingIssues
+        end
       end
-    end
 
-    specify { presenter.action_class.must_equal Support::CodeWorkflowExample::IncomingIssues }
+      specify { presenter.class.must_equal Support::CodeWorkflowExample::IncomingIssues }
 
-    it 'allows aggregating data from other actions' do
-      presenter.summary.must_equal(assignees: ["John Doe"])
+      it 'allows aggregating data from other actions' do
+        presenter.summary.must_equal(assignees: ["John Doe"])
+      end
     end
   end
 end

data/test/clock_test.rb

@@ -22,7 +22,7 @@ describe clock_class do
     clock.ping q, 0.1, o = Object.new
     assert_equal o, q.pop
     finish = Time.now
-    assert_in_delta 0.1, finish - start, 0.02
+    assert_in_delta 0.1, finish - start, 0.08
   end
 
   it 'pongs on expected times' do
@@ -35,11 +35,11 @@ describe clock_class do
     clock.ping q, 0.2, :c
 
     assert_equal :b, q.pop
-    assert_in_delta 0.1, Time.now - start, 0.02
+    assert_in_delta 0.1, Time.now - start, 0.08
     assert_equal :c, q.pop
-    assert_in_delta 0.2, Time.now - start, 0.02
+    assert_in_delta 0.2, Time.now - start, 0.08
     assert_equal :a, q.pop
-    assert_in_delta 0.3, Time.now - start, 0.02
+    assert_in_delta 0.3, Time.now - start, 0.08
   end
 
   it 'works under stress' do

data/test/execution_plan_test.rb

@@ -242,7 +242,7 @@ module Dynflow
         it 'provides the access to the actions data via Action::Presenter' do
           execution_plan.actions.size.must_equal 9
           execution_plan.actions.each do |action|
-            action.must_be_kind_of Action::Presenter
+            action.phase.must_equal Action::Present
           end
         end
       end

data/test/executor_test.rb

@@ -723,8 +723,9 @@ module Dynflow
             it 'does not accept new work' do
               assert world.terminate.wait
               result = world.trigger(Support::CodeWorkflowExample::Slow, 0.02)
-              result.planned.must_equal true
-              -> { result.finished.value! }.must_raise Dynflow::Error
+              result.must_be :planned?
+              result.wont_be :triggered?
+              result.error.must_be_kind_of Dynflow::Error
             end
 
             it 'it terminates when no work' do

data/test/remote_via_socket_test.rb

@@ -43,8 +43,9 @@ describe 'remote communication' do
   it 'raises when not connected' do
     remote_world = create_remote_world
     result       = remote_world.trigger Support::CodeWorkflowExample::Commit, 'sha'
-    result.planned.must_equal true
-    -> { result.finished.value! }.must_raise Dynflow::Error
+    result.must_be :planned?
+    result.wont_be :triggered?
+    result.error.must_be_kind_of Dynflow::Error
 
     terminate remote_world
   end
@@ -53,8 +54,9 @@ describe 'remote communication' do
     specify do
       remote_world = create_remote_world
       result       = remote_world.trigger Support::CodeWorkflowExample::Commit, 'sha'
-      result.planned.must_equal true
-      -> { result.finished.value! }.must_raise Dynflow::Error
+      result.must_be :planned?
+      result.wont_be :triggered?
+      result.error.must_be_kind_of Dynflow::Error
 
       remote_world.persistence.load_execution_plan(result.id).state.must_equal :planned
 
@@ -81,7 +83,7 @@ describe 'remote communication' do
                     remote_world: remote_world = create_remote_world }
 
         result = remote_world.trigger Support::CodeWorkflowExample::Commit, 'sha'
-        result.planned.must_equal true
+        result.must_be :planned?
         result.finished.value!.must_be_kind_of Dynflow::ExecutionPlan
 
         terminate *objects.values_at(*order)
@@ -101,9 +103,9 @@ describe 'remote communication' do
 
       terminate rmw1
 
-      -> { rmw1.trigger(Support::CodeWorkflowExample::Commit, 'sha').finished.value! }.
-          must_raise Dynflow::Error
-      rmw2.trigger(Support::CodeWorkflowExample::Commit, 'sha').finished.value!
+      refute rmw1.trigger(Support::CodeWorkflowExample::Commit, 'sha').triggered?
+      rmw2.trigger(Support::CodeWorkflowExample::Commit, 'sha').
+          finished.value!.must_be_kind_of Dynflow::ExecutionPlan
 
       terminate rmw2, listener, world
     end
@@ -114,7 +116,7 @@ describe 'remote communication' do
       remote_world = create_remote_world
 
       result = remote_world.trigger(Support::CodeWorkflowExample::Slow, 2)
-      result.planned.must_equal true
+      result.must_be :planned?
 
       terminate listener