dynflow 1.3.0 → 1.4.0

data/test/rescue_test.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require_relative 'test_helper'
 
 module Dynflow
@@ -26,11 +27,11 @@ module Dynflow
           end
 
           it 'suggests skipping the action' do
-            execution_plan.rescue_strategy.must_equal Action::Rescue::Skip
+            _(execution_plan.rescue_strategy).must_equal Action::Rescue::Skip
           end
 
           it "doesn't rescue" do
-            rescued_plan.state.must_equal :paused
+            _(rescued_plan.state).must_equal :paused
           end
         end
 
@@ -41,11 +42,11 @@ module Dynflow
           end
 
           it 'suggests skipping the action' do
-            execution_plan.rescue_strategy.must_equal Action::Rescue::Skip
+            _(execution_plan.rescue_strategy).must_equal Action::Rescue::Skip
           end
 
           it "doesn't rescue" do
-            rescued_plan.state.must_equal :paused
+            _(rescued_plan.state).must_equal :paused
           end
         end
 
@@ -56,11 +57,11 @@ module Dynflow
           end
 
           it 'suggests skipping the action' do
-            execution_plan.rescue_strategy.must_equal Action::Rescue::Skip
+            _(execution_plan.rescue_strategy).must_equal Action::Rescue::Skip
           end
 
           it "doesn't rescue" do
-            rescued_plan.state.must_equal :paused
+            _(rescued_plan.state).must_equal :paused
           end
         end
 
@@ -71,11 +72,11 @@ module Dynflow
           end
 
           it 'suggests skipping the action' do
-            execution_plan.rescue_strategy.must_equal Action::Rescue::Skip
+            _(execution_plan.rescue_strategy).must_equal Action::Rescue::Skip
           end
 
           it "doesn't rescue" do
-            rescued_plan.state.must_equal :paused
+            _(rescued_plan.state).must_equal :paused
           end
         end
 
@@ -86,11 +87,11 @@ module Dynflow
           end
 
           it 'suggests pausing the plan' do
-            execution_plan.rescue_strategy.must_equal Action::Rescue::Pause
+            _(execution_plan.rescue_strategy).must_equal Action::Rescue::Pause
           end
 
           it "doesn't rescue" do
-            rescued_plan.state.must_equal :paused
+            _(rescued_plan.state).must_equal :paused
           end
         end
 
@@ -101,11 +102,11 @@ module Dynflow
           end
 
           it 'suggests failing the plan' do
-            execution_plan.rescue_strategy.must_equal Action::Rescue::Fail
+            _(execution_plan.rescue_strategy).must_equal Action::Rescue::Fail
           end
 
           it "doesn't rescue" do
-            rescued_plan.state.must_equal :paused
+            _(rescued_plan.state).must_equal :paused
           end
         end
       end
@@ -124,9 +125,9 @@ module Dynflow
           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].
+            _(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
@@ -137,9 +138,9 @@ module Dynflow
           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"
+            _(rescued_plan.state).must_equal :stopped
+            _(rescued_plan.result).must_equal :warning
+            _(rescued_plan.entry_action.output[:message]).must_equal "Been here"
           end
         end
 
@@ -149,12 +150,12 @@ module Dynflow
           end
 
           it 'skips the action and continues automatically' do
-            execution_plan.state.must_equal :stopped
-            execution_plan.result.must_equal :warning
+            _(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"
+            _(skipped_action.output[:message]).must_equal "skipped because some error as you wish"
           end
         end
 
@@ -164,12 +165,12 @@ module Dynflow
           end
 
           it 'skips the action and continues' do
-            rescued_plan.state.must_equal :stopped
-            rescued_plan.result.must_equal :warning
+            _(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"
+            _(skipped_action.output[:message]).must_equal "Been here"
           end
         end
 
@@ -179,8 +180,8 @@ module Dynflow
           end
 
           it 'tried to rescue only once' do
-            execution_plan.state.must_equal :paused
-            execution_plan.result.must_equal :error
+            _(execution_plan.state).must_equal :paused
+            _(execution_plan.result).must_equal :error
           end
         end
 
@@ -190,11 +191,11 @@ module Dynflow
           end
 
           it 'skips the action and continues automatically' do
-            execution_plan.state.must_equal :paused
-            execution_plan.result.must_equal :error
+            _(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)
+            _(execution_plan.execution_history.map { |h| [h.name, h.world_id] }).must_equal(expected_history)
           end
         end
 
@@ -204,14 +205,14 @@ module Dynflow
           end
 
           it 'fails the execution plan automatically' do
-            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
+            _(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
             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)
+            _(execution_plan.execution_history.map { |h| [h.name, h.world_id] }).must_equal(expected_history)
           end
         end
 

data/test/round_robin_test.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+# frozen_string_literal: true
 require_relative 'test_helper'
 
 module Dynflow
@@ -6,22 +7,22 @@ module Dynflow
     describe RoundRobin do
       let(:rr) { Dynflow::RoundRobin.new }
       specify do
-        rr.next.must_be_nil
-        rr.next.must_be_nil
-        rr.must_be_empty
+        assert_nil rr.next
+        assert_nil rr.next
+        _(rr).must_be_empty
         rr.add 1
-        rr.next.must_equal 1
-        rr.next.must_equal 1
+        _(rr.next).must_equal 1
+        _(rr.next).must_equal 1
         rr.add 2
-        rr.next.must_equal 2
-        rr.next.must_equal 1
-        rr.next.must_equal 2
+        _(rr.next).must_equal 2
+        _(rr.next).must_equal 1
+        _(rr.next).must_equal 2
         rr.delete 1
-        rr.next.must_equal 2
-        rr.next.must_equal 2
+        _(rr.next).must_equal 2
+        _(rr.next).must_equal 2
         rr.delete 2
-        rr.next.must_be_nil
-        rr.must_be_empty
+        assert_nil rr.next
+        _(rr).must_be_empty
       end
     end
   end

data/test/semaphores_test.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require_relative 'test_helper'
 
 module Dynflow
@@ -10,35 +11,35 @@ module Dynflow
       it 'can be used as counter' do
         expected_state = { :tickets => tickets_count, :free => 4, :meta => {} }
         semaphore = semaphore_class.new(tickets_count)
-        semaphore.tickets.must_equal tickets_count
-        semaphore.free.must_equal tickets_count
-        semaphore.waiting.must_be_empty
-        semaphore.get.must_equal 1
-        semaphore.free.must_equal tickets_count - 1
-        semaphore.get(3).must_equal 3
-        semaphore.free.must_equal tickets_count - (3 + 1)
-        semaphore.drain.must_equal 1
-        semaphore.free.must_equal tickets_count - (3 + 1 + 1)
+        _(semaphore.tickets).must_equal tickets_count
+        _(semaphore.free).must_equal tickets_count
+        _(semaphore.waiting).must_be_empty
+        _(semaphore.get).must_equal 1
+        _(semaphore.free).must_equal tickets_count - 1
+        _(semaphore.get(3)).must_equal 3
+        _(semaphore.free).must_equal tickets_count - (3 + 1)
+        _(semaphore.drain).must_equal 1
+        _(semaphore.free).must_equal tickets_count - (3 + 1 + 1)
         semaphore.release
-        semaphore.free.must_equal tickets_count - (3 + 1)
+        _(semaphore.free).must_equal tickets_count - (3 + 1)
         semaphore.release 3
-        semaphore.free.must_equal tickets_count - 1
-        semaphore.to_hash.must_equal expected_state
+        _(semaphore.free).must_equal tickets_count - 1
+        _(semaphore.to_hash).must_equal expected_state
       end
 
       it 'can have things waiting on it' do
         semaphore = semaphore_class.new 1
         allowed = semaphore.wait(1)
-        allowed.must_equal true
-        semaphore.free.must_equal 0
+        _(allowed).must_equal true
+        _(semaphore.free).must_equal 0
         allowed = semaphore.wait(2)
-        allowed.must_equal false
+        _(allowed).must_equal false
         allowed = semaphore.wait(3)
-        allowed.must_equal false
+        _(allowed).must_equal false
         waiting = semaphore.get_waiting
-        waiting.must_equal 2
+        _(waiting).must_equal 2
         waiting = semaphore.get_waiting
-        waiting.must_equal 3
+        _(waiting).must_equal 3
       end
 
     end
@@ -48,15 +49,15 @@ module Dynflow
 
       it 'always has free' do
         semaphore = semaphore_class.new
-        semaphore.free.must_equal 1
-        semaphore.get(5).must_equal 5
-        semaphore.free.must_equal 1
+        _(semaphore.free).must_equal 1
+        _(semaphore.get(5)).must_equal 5
+        _(semaphore.free).must_equal 1
       end
 
       it 'cannot have things waiting on it' do
         semaphore = semaphore_class.new
-        semaphore.wait(1).must_equal true
-        semaphore.has_waiting?.must_equal false
+        _(semaphore.wait(1)).must_equal true
+        _(semaphore.has_waiting?).must_equal false
       end
     end
 
@@ -71,25 +72,25 @@ module Dynflow
       end
 
       def assert_semaphore_state(semaphore, state_A, state_B)
-        semaphore.children[:child_A].free.must_equal state_A
-        semaphore.children[:child_B].free.must_equal state_B
-        semaphore.free.must_equal [state_A, state_B].min
+        _(semaphore.children[:child_A].free).must_equal state_A
+        _(semaphore.children[:child_B].free).must_equal state_B
+        _(semaphore.free).must_equal [state_A, state_B].min
       end
 
       it 'can be used as counter' do
         semaphore = semaphore_class.new(children)
         assert_semaphore_state semaphore, 3, 2
-        semaphore.get.must_equal 1
+        _(semaphore.get).must_equal 1
         assert_semaphore_state semaphore, 2, 1
-        semaphore.get.must_equal 1
+        _(semaphore.get).must_equal 1
         assert_semaphore_state semaphore, 1, 0
-        semaphore.get.must_equal 0
+        _(semaphore.get).must_equal 0
         assert_semaphore_state semaphore, 1, 0
         semaphore.release
         assert_semaphore_state semaphore, 2, 1
         semaphore.release(1, :child_B)
         assert_semaphore_state semaphore, 2, 2
-        semaphore.drain.must_equal 2
+        _(semaphore.drain).must_equal 2
         assert_semaphore_state semaphore, 0, 0
       end
     end

data/test/support/code_workflow_example.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'logger'
 
 module Support

data/test/support/dummy_example.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'logger'
 
 module Support
@@ -114,7 +115,7 @@ module Support
       end
     end
 
-    class EventedAction < Dynflow::Action
+    class DeprecatedEventedAction < Dynflow::Action
       def run(event = nil)
         case event
         when "timeout"
@@ -132,6 +133,18 @@ module Support
       end
     end
 
+    class PlanEventsAction < Dynflow::Action
+      def run(event = nil)
+        case event
+        when 'ping'
+          output[:result] = 'pinged'
+        when nil
+          plan_event('ping', input[:ping_time] || 0.5)
+          suspend
+        end
+      end
+    end
+
     class ComposedAction < Dynflow::Action
       def run(event = nil)
         match event,

data/test/support/middleware_example.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Support
   module MiddlewareExample
     class LogMiddleware < Dynflow::Middleware
@@ -99,7 +100,7 @@ module Support
       end
 
       def filter_sensitive_data
-        output[:spell] = '***'
+        output[:spell] = '***'.dup
       end
     end
 

data/test/support/rails/config/environment.rb

@@ -1 +1,2 @@
+# frozen_string_literal: true
 # This is a mock

data/test/support/rescue_example.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'logger'
 
 module Support

data/test/support/test_execution_log.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 class TestExecutionLog
 
   include Enumerable

data/test/test_helper.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'bundler/setup'
 require 'minitest/reporters'
 require 'minitest/autorun'
@@ -110,7 +111,7 @@ module WorldFactory
   # This world survives though the whole run of the test suite: careful with it, it can
   # introduce unnecessary test dependencies
   def self.logger_adapter
-    @adapter ||= Dynflow::LoggerAdapters::Simple.new $stderr, 4
+    @adapter ||= Dynflow::LoggerAdapters::Simple.new $stderr, ::Logger::FATAL
   end
 
   def self.persistence_adapter
@@ -176,7 +177,7 @@ module TestHelpers
       return ret if ret
       sleep 0.3
     end
-    raise "waiting for #{waiting_message} was not successful"
+    assert false, "waiting for #{waiting_message} was not successful"
   end
 
   def executor_id_for_plan(execution_plan_id)
@@ -187,7 +188,7 @@ module TestHelpers
   end
 
   def trigger_waiting_action
-    triggered = client_world.trigger(Support::DummyExample::EventedAction)
+    triggered = client_world.trigger(Support::DummyExample::DeprecatedEventedAction)
     wait_for { executor_id_for_plan(triggered.id) } # waiting for the plan to be picked by an executor
     triggered
   end
@@ -332,29 +333,29 @@ end
 module PlanAssertions
 
   def inspect_flow(execution_plan, flow)
-    out = ""
-    inspect_subflow(out, execution_plan, flow, "")
+    out = "".dup
+    inspect_subflow(out, execution_plan, flow, "".dup)
     out
   end
 
   def inspect_plan_steps(execution_plan)
-    out = ""
-    inspect_plan_step(out, execution_plan, execution_plan.root_plan_step, "")
+    out = "".dup
+    inspect_plan_step(out, execution_plan, execution_plan.root_plan_step, "".dup)
     out
   end
 
   def assert_planning_success(execution_plan)
-    execution_plan.plan_steps.all? { |plan_step| plan_step.state.must_equal :success, plan_step.error }
+    execution_plan.plan_steps.all? { |plan_step| _(plan_step.state).must_equal :success, plan_step.error }
   end
 
   def assert_run_flow(expected, execution_plan)
     assert_planning_success(execution_plan)
-    inspect_flow(execution_plan, execution_plan.run_flow).chomp.must_equal dedent(expected).chomp
+    _(inspect_flow(execution_plan, execution_plan.run_flow).chomp).must_equal dedent(expected).chomp
   end
 
   def assert_finalize_flow(expected, execution_plan)
     assert_planning_success(execution_plan)
-    inspect_flow(execution_plan, execution_plan.finalize_flow).chomp.must_equal dedent(expected).chomp
+    _(inspect_flow(execution_plan, execution_plan.finalize_flow).chomp).must_equal dedent(expected).chomp
   end
 
   def assert_run_flow_equal(expected_plan, execution_plan)
@@ -364,19 +365,19 @@ module PlanAssertions
   end
 
   def assert_steps_equal(expected, current)
-    current.id.must_equal expected.id
-    current.class.must_equal expected.class
-    current.state.must_equal expected.state
-    current.action_class.must_equal expected.action_class
-    current.action_id.must_equal expected.action_id
+    _(current.id).must_equal expected.id
+    _(current.class).must_equal expected.class
+    _(current.state).must_equal expected.state
+    _(current.action_class).must_equal expected.action_class
+    _(current.action_id).must_equal expected.action_id
 
     if expected.respond_to?(:children)
-      current.children.must_equal(expected.children)
+      _(current.children).must_equal(expected.children)
     end
   end
 
   def assert_plan_steps(expected, execution_plan)
-    inspect_plan_steps(execution_plan).chomp.must_equal dedent(expected).chomp
+    _(inspect_plan_steps(execution_plan).chomp).must_equal dedent(expected).chomp
   end
 
   def assert_finalized(action_class, input)