dynflow 1.3.0 → 1.4.0

data/test/activejob_adapter_test.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require_relative 'test_helper'
 require 'active_job'
 require 'dynflow/active_job/queue_adapter'

data/test/batch_sub_tasks_test.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require_relative 'test_helper'
 
 module Dynflow
@@ -72,7 +73,7 @@ module Dynflow
         plan = world.persistence.load_execution_plan(plan.id)
         action = plan.entry_action
 
-        action.output[:batch_count].must_equal action.total_count / action.batch_size
+        _(action.output[:batch_count]).must_equal action.total_count / action.batch_size
       end
 
       it 'can resume tasks' do
@@ -82,17 +83,17 @@ module Dynflow
         wait_for { future.resolved? }
         plan = world.persistence.load_execution_plan(plan.id)
         action = plan.entry_action
-        action.output[:batch_count].must_equal 1
-        future.value.state.must_equal :paused
+        _(action.output[:batch_count]).must_equal 1
+        _(future.value.state).must_equal :paused
 
         FailureSimulator.wont_fail!
         future = world.execute plan.id
         wait_for { future.resolved? }
         action = future.value.entry_action
-        future.value.state.must_equal :stopped
-        action.output[:batch_count].must_equal (action.total_count / action.batch_size) + 1
-        action.output[:total_count].must_equal action.total_count
-        action.output[:success_count].must_equal action.total_count
+        _(future.value.state).must_equal :stopped
+        _(action.output[:batch_count]).must_equal (action.total_count / action.batch_size) + 1
+        _(action.output[:total_count]).must_equal action.total_count
+        _(action.output[:success_count]).must_equal action.total_count
       end
 
       it 'is controlled only by total_count and output[:planned_count]' do
@@ -101,12 +102,12 @@ module Dynflow
         wait_for { future.resolved? }
         plan = world.persistence.load_execution_plan(plan.id)
         action = plan.entry_action
-        action.send(:can_spawn_next_batch?).must_equal false
-        action.current_batch.must_be :empty?
+        _(action.send(:can_spawn_next_batch?)).must_equal false
+        _(action.current_batch).must_be :empty?
         action.output[:pending_count] = 0
         action.output[:success_count] = 5
-        action.send(:can_spawn_next_batch?).must_equal false
-        action.current_batch.must_be :empty?
+        _(action.send(:can_spawn_next_batch?)).must_equal false
+        _(action.current_batch).must_be :empty?
       end
 
     end

data/test/clock_test.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require_relative 'test_helper'
 require 'logger'
 
@@ -8,7 +9,7 @@ describe clock_class do
   let(:clock) { clock_class.spawn 'clock' }
 
   it 'refuses who without #<< method' do
-    -> { clock.ping Object.new, 0.1, :pong }.must_raise TypeError
+    _(-> { clock.ping Object.new, 0.1, :pong }).must_raise TypeError
     clock.ping [], 0.1, :pong
   end
 

data/test/concurrency_control_test.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require_relative 'test_helper'
 
 module Dynflow
@@ -80,9 +81,9 @@ module Dynflow
       end
 
       def check_step(plan, total, finished)
-        world.throttle_limiter.observe(plan.id).length.must_equal (total - finished)
-        plan.sub_plans.select { |sub| planned? sub }.count.must_equal (total - finished)
-        plan.sub_plans.select { |sub| successful? sub }.count.must_equal finished
+        _(world.throttle_limiter.observe(plan.id).length).must_equal (total - finished)
+        _(plan.sub_plans.select { |sub| planned? sub }.count).must_equal (total - finished)
+        _(plan.sub_plans.select { |sub| successful? sub }.count).must_equal finished
       end
 
       def planned?(plan)
@@ -126,7 +127,7 @@ module Dynflow
         future = world.execute plan.id
         wait_for { future.resolved? }
         plan.sub_plans.all? { |sub| successful? sub }
-        world.throttle_limiter.core.ask!(:running).must_equal [0]
+        _(world.throttle_limiter.core.ask!(:running)).must_equal [0]
       end
 
       it 'limits by concurrency level' do
@@ -135,7 +136,7 @@ module Dynflow
         plan = world.plan(ParentAction, total, level)
         future = world.execute plan.id
         wait_for { future.resolved? }
-        world.throttle_limiter.core.ask!(:running).max.must_be :<=, level
+        _(world.throttle_limiter.core.ask!(:running).max).must_be :<=, level
       end
 
       it 'allows to cancel' do
@@ -147,8 +148,8 @@ module Dynflow
           world.event(plan.id, plan.steps.values.last.id, ::Dynflow::Action::Cancellable::Cancel)
           wait_for { triggered.resolved? }
           plan = world.persistence.load_execution_plan(plan.id)
-          plan.entry_action.output[:failed_count].must_equal total
-          world.throttle_limiter.core.ask!(:running).max.must_be :<=, 0
+          _(plan.entry_action.output[:failed_count]).must_equal total
+          _(world.throttle_limiter.core.ask!(:running).max).must_be :<=, 0
         end
       end
 
@@ -165,21 +166,21 @@ module Dynflow
           wait_for { plan.sub_plans_count == total }
           wait_for { klok.progress; plan.sub_plans.all? { |sub| successful? sub } }
           # 10 tasks over 10 seconds, one task at a time, 1 task every second
-          get_interval.call(plan).must_equal 1.0
+          _(get_interval.call(plan)).must_equal 1.0
 
           plan = world.plan(ParentAction, total, 4, 10)
           world.execute(plan.id)
           wait_for { plan.sub_plans_count == total }
           wait_for { klok.progress; plan.sub_plans.all? { |sub| successful? sub } }
           # 10 tasks over 10 seconds, four tasks at a time, 1 task every 0.25 second
-          get_interval.call(plan).must_equal 0.25
+          _(get_interval.call(plan)).must_equal 0.25
 
           plan = world.plan(ParentAction, total, nil, 10)
           world.execute(plan.id)
           wait_for { plan.sub_plans_count == total }
           wait_for { klok.progress; plan.sub_plans.all? { |sub| successful? sub } }
           # 1o tasks over 10 seconds, one task at a time (default), 1 task every second
-          get_interval.call(plan).must_equal 1.0
+          _(get_interval.call(plan)).must_equal 1.0
         end
       end
 
@@ -204,9 +205,9 @@ module Dynflow
             check_step(plan, total, finished)
           end
           end_time = klok.current_time
-          (end_time - start_time).must_equal 4
-          world.throttle_limiter.observe(plan.id).must_equal []
-          world.throttle_limiter.core.ask!(:running).max.must_be :<=, level
+          _((end_time - start_time)).must_equal 4
+          _(world.throttle_limiter.observe(plan.id)).must_equal []
+          _(world.throttle_limiter.core.ask!(:running).max).must_be :<=, level
         end
       end
 
@@ -218,7 +219,7 @@ module Dynflow
         plan = world.plan(ParentAction, total, level, time_span)
         future = world.execute(plan.id)
         wait_for { future.resolved? }
-        plan.sub_plans.all? { |sub| sub.result == :error }.must_equal true
+        _(plan.sub_plans.all? { |sub| sub.result == :error }).must_equal true
       end
 
       it 'cancels tasks which could not be started within the time window' do
@@ -230,14 +231,14 @@ module Dynflow
           future = world.execute(plan.id)
           wait_for { plan.sub_plans_count == total && plan.sub_plans.all? { |sub| sub.result == :pending } }
           planned, running = plan.sub_plans.partition { |sub| planned? sub }
-          planned.count.must_equal total - level
-          running.count.must_equal level
-          world.throttle_limiter.observe(plan.id).length.must_equal (total - 1)
+          _(planned.count).must_equal total - level
+          _(running.count).must_equal level
+          _(world.throttle_limiter.observe(plan.id).length).must_equal (total - 1)
           4.times { klok.progress }
           wait_for { future.resolved? }
           finished, stopped = plan.sub_plans.partition { |sub| successful? sub }
-          finished.count.must_equal level
-          stopped.count.must_equal (total - level)
+          _(finished.count).must_equal level
+          _(stopped.count).must_equal (total - level)
         end
       end
     end

data/test/coordinator_test.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require_relative 'test_helper'
 require 'fileutils'
 
@@ -11,13 +12,13 @@ module Dynflow
         it 'unlocks the lock, when the block is passed' do
           world.coordinator.acquire(Coordinator::AutoExecuteLock.new(world)) {}
           expected_locks = ["lock auto-execute", "unlock auto-execute"]
-          world.coordinator.adapter.lock_log.must_equal(expected_locks)
+          _(world.coordinator.adapter.lock_log).must_equal(expected_locks)
         end
 
         it "doesn't unlock, when the block is not passed" do
           world.coordinator.acquire(Coordinator::AutoExecuteLock.new(world))
           expected_locks = ["lock auto-execute"]
-          world.coordinator.adapter.lock_log.must_equal(expected_locks)
+          _(world.coordinator.adapter.lock_log).must_equal(expected_locks)
         end
 
         it 'supports unlocking by owner' do
@@ -35,23 +36,23 @@ module Dynflow
         it 'supports checking about locks' do
           world.coordinator.acquire(Coordinator::AutoExecuteLock.new(world))
           locks = world.coordinator.find_locks(Coordinator::AutoExecuteLock.unique_filter)
-          locks.map(&:world_id).must_equal([world.id])
+          _(locks.map(&:world_id)).must_equal([world.id])
         end
 
         it 'deserializes the data from the adapter when searching for locks' do
           lock = Coordinator::AutoExecuteLock.new(world)
           world.coordinator.acquire(lock)
           found_locks = world.coordinator.find_locks(owner_id: lock.owner_id)
-          found_locks.size.must_equal 1
-          found_locks.first.data.must_equal lock.data
+          _(found_locks.size).must_equal 1
+          _(found_locks.first.data).must_equal lock.data
 
           found_locks = world.coordinator.find_locks(class: lock.class.name, id: lock.id)
-          found_locks.size.must_equal 1
-          found_locks.first.data.must_equal lock.data
+          _(found_locks.size).must_equal 1
+          _(found_locks.first.data).must_equal lock.data
 
           another_lock = Coordinator::AutoExecuteLock.new(another_world)
           found_locks = world.coordinator.find_locks(owner_id: another_lock.owner_id)
-          found_locks.size.must_equal 0
+          _(found_locks.size).must_equal 0
         end
       end
 
@@ -76,15 +77,15 @@ module Dynflow
           dummy_record = DummyRecord.new('dummy', 'Foo')
           world.coordinator.create_record(dummy_record)
           saved_dummy_record = world.coordinator.find_records(class: dummy_record.class.name).first
-          saved_dummy_record.must_equal dummy_record
+          _(saved_dummy_record).must_equal dummy_record
 
           dummy_record.value = 'Bar'
           world.coordinator.update_record(dummy_record)
           saved_dummy_record = world.coordinator.find_records(class: dummy_record.class.name).first
-          saved_dummy_record.data.must_equal dummy_record.data
+          _(saved_dummy_record.data).must_equal dummy_record.data
 
           world.coordinator.delete_record(dummy_record)
-          world.coordinator.find_records(class: dummy_record.class.name).must_equal []
+          _(world.coordinator.find_records(class: dummy_record.class.name)).must_equal []
         end
       end
 
@@ -94,14 +95,12 @@ module Dynflow
           another_world.coordinator.acquire Coordinator::WorldInvalidationLock.new(another_world, another_world)
           world.terminate.wait
           expected_locks = ["lock auto-execute", "unlock auto-execute"]
-          world.coordinator.adapter.lock_log.must_equal(expected_locks)
+          _(world.coordinator.adapter.lock_log).must_equal(expected_locks)
         end
 
         it 'prevents new locks to be acquired by the world being terminated' do
           world.terminate
-          -> do
-            world.coordinator.acquire(Coordinator::AutoExecuteLock.new(world))
-          end.must_raise(Errors::InactiveWorldError)
+          _(-> { world.coordinator.acquire(Coordinator::AutoExecuteLock.new(world)) }).must_raise(Errors::InactiveWorldError)
         end
       end
 
@@ -114,7 +113,7 @@ module Dynflow
               adapter.create_record(record)
               tester.pause
             end
-            -> { another_adapter.create_record(record) }.must_raise(Coordinator::DuplicateRecordError)
+            _(-> { another_adapter.create_record(record) }).must_raise(Coordinator::DuplicateRecordError)
             tester.finish
           end
 
@@ -134,16 +133,16 @@ module Dynflow
             lock = Coordinator::AutoExecuteLock.new(world)
             adapter.create_record(lock)
             found_records = adapter.find_records(owner_id: lock.owner_id)
-            found_records.size.must_equal 1
-            found_records.first.must_equal lock.data
+            _(found_records.size).must_equal 1
+            _(found_records.first).must_equal lock.data
 
             found_records = adapter.find_records(class: lock.class.name, id: lock.id)
-            found_records.size.must_equal 1
-            found_records.first.must_equal lock.data
+            _(found_records.size).must_equal 1
+            _(found_records.first).must_equal lock.data
 
             another_lock = Coordinator::AutoExecuteLock.new(another_world)
             found_records = adapter.find_records(owner_id: another_lock.owner_id)
-            found_records.size.must_equal 0
+            _(found_records.size).must_equal 0
           end
         end
       end

data/test/daemon_test.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 require 'test_helper'
 require 'active_support'
-require 'mocha/mini_test'
+require 'mocha/minitest'
 require 'logging'
 require 'dynflow/testing'
 require_relative '../lib/dynflow/rails'

data/test/dead_letter_silencer_test.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require_relative 'test_helper'
 require 'ostruct'
 
@@ -10,7 +11,7 @@ module Dynflow
       let(:world) { WorldFactory.create_world }
 
       it 'is started for each world' do
-        world.dead_letter_handler.actor_class
+        _(world.dead_letter_handler.actor_class)
              .must_equal ::Dynflow::DeadLetterSilencer
       end
 
@@ -26,19 +27,20 @@ module Dynflow
         end
 
         it 'matches any' do
-          DeadLetterSilencer::Matcher.new(any, any, any).match?(letter).must_equal true
+          _(DeadLetterSilencer::Matcher.new(any, any, any).match?(letter)).must_equal true
         end
 
         it 'matches comparing for equality' do
-          DeadLetterSilencer::Matcher.new(sender, msg, receiver)
-                                     .match?(letter).must_equal true
-          DeadLetterSilencer::Matcher.new(any, :bad, any).match?(letter).must_equal false
+          matcher = DeadLetterSilencer::Matcher.new(sender, msg, receiver)
+          _(matcher.match?(letter)).must_equal true
+          matcher = DeadLetterSilencer::Matcher.new(any, :bad, any)
+          _(matcher.match?(letter)).must_equal false
         end
 
         it 'matches by calling the proc' do
           condition = proc { |actor_class| actor_class.is_a? Class }
-          DeadLetterSilencer::Matcher.new(condition, any, condition)
-                                     .match?(letter).must_equal true
+          matcher = DeadLetterSilencer::Matcher.new(condition, any, condition)
+          _(matcher.match?(letter)).must_equal true
         end
       end
     end

data/test/dispatcher_test.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require_relative 'test_helper'
 
 module Dynflow
@@ -24,7 +25,7 @@ module Dynflow
 
           describe 'event passing' do
             it 'succeeds when expected' do
-              result = client_world.trigger(Support::DummyExample::EventedAction, :timeout => 3)
+              result = client_world.trigger(Support::DummyExample::DeprecatedEventedAction, :timeout => 3)
               step = wait_for do
                 client_world.persistence.load_execution_plan(result.id).
                     steps_in_state(:suspended).first

data/test/execution_plan_cleaner_test.rb

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
 require_relative 'test_helper'
-require 'mocha/mini_test'
+require 'mocha/minitest'
 
 module Dynflow
   module ExecutionPlanCleanerTest
@@ -28,16 +29,16 @@ module Dynflow
       let(:clock) { Testing::ManagedClock.new }
 
       it 'is disabled by default' do
-        default_world.execution_plan_cleaner.must_be_nil
-        world.execution_plan_cleaner
-             .must_be_instance_of ::Dynflow::Actors::ExecutionPlanCleaner
+        assert_nil default_world.execution_plan_cleaner
+        _(world.execution_plan_cleaner)
+          .must_be_instance_of ::Dynflow::Actors::ExecutionPlanCleaner
       end
 
       it 'periodically looks for old execution plans' do
         world.stub(:clock, clock) do
-          clock.pending_pings.count.must_equal 0
+          _(clock.pending_pings.count).must_equal 0
           world.execution_plan_cleaner.core.ask!(:start)
-          clock.pending_pings.count.must_equal 1
+          _(clock.pending_pings.count).must_equal 1
           world.persistence.expects(:find_old_execution_plans).returns([])
           world.persistence.expects(:delete_execution_plans).with(:uuid => [])
           clock.progress
@@ -48,7 +49,7 @@ module Dynflow
       it 'cleans up old plans' do
         world.stub(:clock, clock) do
           world.execution_plan_cleaner.core.ask!(:start)
-          clock.pending_pings.count.must_equal 1
+          _(clock.pending_pings.count).must_equal 1
           plans = (1..10).map { world.trigger SimpleAction }
                          .each { |plan| plan.finished.wait }
           world.persistence.find_execution_plans(:uuid => plans.map(&:id))
@@ -57,8 +58,8 @@ module Dynflow
             plan.save
           end
           world.execution_plan_cleaner.core.ask!(:clean!)
-          world.persistence.find_execution_plans(:uuid => plans.map(&:id))
-               .count.must_equal 0
+          plans = world.persistence.find_execution_plans(:uuid => plans.map(&:id))
+          _(plans.count).must_equal 0
         end
       end
 
@@ -66,12 +67,12 @@ module Dynflow
         world.stub(:clock, clock) do
           count = 10
           world.execution_plan_cleaner.core.ask!(:start)
-          clock.pending_pings.count.must_equal 1
+          _(clock.pending_pings.count).must_equal 1
           plans = (1..10).map { world.trigger SimpleAction }
                          .each { |plan| plan.finished.wait }
           world.execution_plan_cleaner.core.ask!(:clean!)
-          world.persistence.find_execution_plans(:uuid => plans.map(&:id))
-               .count.must_equal count
+          plans = world.persistence.find_execution_plans(:uuid => plans.map(&:id))
+          _(plans.count).must_equal count
         end
       end
     end

data/test/execution_plan_hooks_test.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require_relative 'test_helper'
 
 module Dynflow
@@ -137,7 +138,7 @@ module Dynflow
         plan = world.plan(ActionOnStop)
         plan = world.execute(plan.id).wait!.value
         assert Flag.raised?
-        plan.result.must_equal :success
+        _(plan.result).must_equal :success
       end
 
       it 'inherits the hooks when subclassing' do
@@ -158,7 +159,7 @@ module Dynflow
         refute Flag.raised?
         plan = world.trigger(ComposedAction)
         plan.finished.wait!
-        Flag.raised_count.must_equal 1
+        _(Flag.raised_count).must_equal 1
       end
     end
   end