dynflow 0.7.9 → 0.8.0

data/test/abnormal_states_recovery_test.rb

@@ -0,0 +1,152 @@
+# -*- coding: utf-8 -*-
+require_relative 'test_helper'
+
+module Dynflow
+  module ConsistencyCheckTest
+
+    describe "consistency check" do
+
+      include TestHelpers
+
+      def with_invalidation_while_executing(finish)
+        triggered = while_executing_plan do |executor|
+          if Connectors::Direct === executor.connector
+            # for better simulation of invalidation with direct executor
+            executor.connector.stop_listening(executor)
+          end
+          client_world.invalidate(executor.registered_world)
+        end
+        plan = if finish
+                 finish_the_plan(triggered)
+               else
+                 triggered.finished.wait
+                 client_world.persistence.load_execution_plan(triggered.id)
+               end
+        yield plan
+      ensure
+        # just to workaround state transition checks due to our simulation
+        # of second world being inactive
+        if plan
+          plan.set_state(:running, true)
+          plan.save
+        end
+      end
+
+      let(:persistence_adapter) { WorldFactory.persistence_adapter }
+      let(:shared_connector) { Connectors::Direct.new }
+      let(:connector) { Proc.new { |world| shared_connector.start_listening(world); shared_connector } }
+      let(:executor_world) { create_world(true) }
+      let(:executor_world_2) { create_world(true) }
+      let(:client_world) { create_world(false) }
+      let(:client_world_2) { create_world(false) }
+
+      describe "for plans assigned to invalid world" do
+
+        before do
+          # mention the executors to make sure they are initialized
+          [executor_world, executor_world_2]
+        end
+
+        describe 'world invalidation' do
+          it 'removes the world from the register' do
+            client_world.invalidate(executor_world.registered_world)
+            worlds = client_world.coordinator.find_worlds
+            refute_includes(worlds, executor_world.registered_world)
+          end
+
+          it 'schedules the plans to be run on different executor' do
+            with_invalidation_while_executing(true) do |plan|
+              assert_plan_reexecuted(plan)
+            end
+          end
+
+          it 'when no executor is available, marks the plans as paused' do
+            executor_world_2.terminate.wait
+            with_invalidation_while_executing(false) do |plan|
+              plan.state.must_equal :paused
+              plan.result.must_equal :pending
+              expected_history = [['start execution', executor_world.id],
+                                  ['terminate execution', executor_world.id]]
+              plan.execution_history.map { |h| [h.name, h.world_id] }.must_equal(expected_history)
+            end
+          end
+
+          it "prevents from running the invalidation twice on the same world" do
+            client_world.invalidate(executor_world.registered_world)
+            expected_locks = ["lock world-invalidation:#{executor_world.id}",
+                              "unlock world-invalidation:#{executor_world.id}"]
+            client_world.coordinator.adapter.lock_log.must_equal(expected_locks)
+          end
+
+          it "prevents from running the consistency checks twice on the same world concurrently" do
+            client_world.invalidate(executor_world.registered_world)
+            expected_locks = ["lock world-invalidation:#{executor_world.id}",
+                              "unlock world-invalidation:#{executor_world.id}"]
+            client_world.coordinator.adapter.lock_log.must_equal(expected_locks)
+          end
+        end
+      end
+
+      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
+        end
+
+        it "prevents from running the auto-execution twice" do
+          client_world.auto_execute
+          expected_locks = ["lock auto-execute", "unlock auto-execute"]
+          client_world.coordinator.adapter.lock_log.must_equal(expected_locks)
+        end
+
+        it "re-runs the plans that were planned but not executed" do
+          triggered = client_world.trigger(Support::DummyExample::Dummy)
+          triggered.finished.wait
+          executor_world.auto_execute
+          plan = wait_for do
+            plan = client_world.persistence.load_execution_plan(triggered.id)
+            if plan.state == :stopped
+              plan
+            end
+          end
+          expected_history = [['start execution', executor_world.id],
+                              ['finish execution', executor_world.id]]
+          plan.execution_history.map { |h| [h.name, h.world_id] }.must_equal(expected_history)
+        end
+
+        it "re-runs the plans that were terminated but not re-executed (because no available executor)" do
+          executor_world # mention it to get initialized
+          triggered = while_executing_plan { |executor| executor.terminate.wait }
+          executor_world_2.auto_execute
+          finish_the_plan(triggered)
+          plan = wait_for do
+            plan = client_world.persistence.load_execution_plan(triggered.id)
+            if plan.state == :stopped
+              plan
+            end
+          end
+          assert_plan_reexecuted(plan)
+        end
+
+        it "doesn't rerun the plans that were paused with error" do
+          executor_world # mention it to get initialized
+          triggered = client_world.trigger(Support::DummyExample::FailingDummy)
+          triggered.finished.wait
+          executor_world.auto_execute
+          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]]
+          plan.execution_history.map { |h| [h.name, h.world_id] }.must_equal(expected_history)
+        end
+      end
+    end
+  end
+end
+

data/test/action_test.rb

@@ -2,7 +2,8 @@ require_relative 'test_helper'
 
 module Dynflow
   describe 'action' do
-    include WorldInstance
+
+    let(:world) { WorldFactory.create_world }
 
     describe Action::Missing do
 
@@ -47,7 +48,6 @@ module Dynflow
     end
 
     describe Action::Present do
-      include WorldInstance
 
       let :execution_plan do
         result = world.trigger(Support::CodeWorkflowExample::IncomingIssues, issues_data)
@@ -92,7 +92,6 @@ module Dynflow
     end
 
     describe '#humanized_state' do
-      include WorldInstance
       include Testing
 
       class ActionWithHumanizedState < Dynflow::Action

data/test/clock_test.rb

@@ -5,10 +5,9 @@ clock_class = Dynflow::Clock
 
 describe clock_class do
 
-  let(:clock) { clock_class.new Logger.new($stderr) }
+  let(:clock) { clock_class.spawn 'clock' }
 
   it 'refuses who without #<< method' do
-    clock.initialized.wait
     -> { clock.ping Object.new, 0.1, :pong }.must_raise TypeError
     clock.ping [], 0.1, :pong
   end
@@ -16,7 +15,6 @@ describe clock_class do
 
   it 'pongs' do
     q = Queue.new
-    clock.initialized.wait
     start = Time.now
 
     clock.ping q, 0.1, o = Object.new
@@ -27,7 +25,6 @@ describe clock_class do
 
   it 'pongs on expected times' do
     q = Queue.new
-    clock.initialized.wait
     start = Time.now
 
     clock.ping q, 0.3, :a
@@ -43,7 +40,6 @@ describe clock_class do
   end
 
   it 'works under stress' do
-    clock.initialized.wait
     threads = Array.new(4) do
       Thread.new do
         q     = Queue.new

data/test/coordinator_test.rb

@@ -0,0 +1,152 @@
+require_relative 'test_helper'
+require 'fileutils'
+
+module Dynflow
+  module CoordinatorTest
+    describe Coordinator do
+      let(:world)         { WorldFactory.create_world }
+      let(:another_world) { WorldFactory.create_world }
+
+      describe 'locks' do
+        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)
+        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)
+        end
+
+        it 'supports unlocking by owner' do
+          lock = Coordinator::AutoExecuteLock.new(world)
+          tester = ConcurrentRunTester.new
+          tester.while_executing do
+            world.coordinator.acquire(lock)
+            tester.pause
+          end
+          world.coordinator.release_by_owner("world:#{world.id}")
+          world.coordinator.acquire(lock) # expected no error raised
+          tester.finish
+        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 = 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
+
+          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
+        end
+      end
+
+      describe 'records' do
+        class DummyRecord < Coordinator::Record
+          def initialize(id, value)
+            super
+            @data[:id] = value
+            @data[:value] = value
+          end
+
+          def value
+            @data[:value]
+          end
+
+          def value=(value)
+            @data[:value] = (value)
+          end
+        end
+
+        it 'allows CRUD record objects' do
+          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
+
+          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
+
+          world.coordinator.delete_record(dummy_record)
+          world.coordinator.find_records(class: dummy_record.class.name).must_equal []
+        end
+      end
+
+      describe 'on termination' do
+        it 'removes all the locks assigned to the given world' do
+          world.coordinator.acquire(Coordinator::AutoExecuteLock.new(world))
+          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)
+        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)
+        end
+      end
+
+      def self.it_supports_global_records
+        describe 'records handling' do
+          it 'prevents saving the same record twice' do
+            record = Coordinator::AutoExecuteLock.new(world)
+            tester = ConcurrentRunTester.new
+            tester.while_executing do
+              adapter.create_record(record)
+              tester.pause
+            end
+            -> { another_adapter.create_record(record) }.must_raise(Coordinator::DuplicateRecordError)
+            tester.finish
+          end
+
+          it 'allows saving different records' do
+            record = Coordinator::AutoExecuteLock.new(world)
+            another_record = Coordinator::WorldInvalidationLock.new(world, another_world)
+            tester = ConcurrentRunTester.new
+            tester.while_executing do
+              adapter.create_record(record)
+              tester.pause
+            end
+            another_adapter.create_record(another_record) # expected no error raised
+            tester.finish
+          end
+
+          it 'allows searching for the records on various criteria' do
+            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 = adapter.find_records(class: lock.class.name, id: lock.id)
+            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
+          end
+        end
+      end
+
+      describe CoordinatorAdapters::Sequel do
+        let(:adapter) { CoordinatorAdapters::Sequel.new(world) }
+        let(:another_adapter) { CoordinatorAdapters::Sequel.new(another_world) }
+        it_supports_global_records
+      end
+    end
+  end
+end

data/test/dispatcher_test.rb

@@ -0,0 +1,146 @@
+require_relative 'test_helper'
+
+module Dynflow
+  module DispatcherTest
+    describe "dispatcher" do
+
+      include TestHelpers
+
+      let(:persistence_adapter) { WorldFactory.persistence_adapter }
+
+      def self.dispatcher_works_with_this_connector
+        describe 'connector basics' do
+          before do
+            # just mention the executor to initialize it
+            executor_world
+          end
+
+          describe 'execution passing' do
+            it 'succeeds when expected' do
+              result = client_world.trigger(Support::DummyExample::Dummy)
+              assert_equal :success, result.finished.value.result
+            end
+          end
+
+          describe 'event passing' do
+            it 'succeeds when expected' do
+              result = client_world.trigger(Support::DummyExample::EventedAction, :timeout => 3)
+              step = wait_for do
+                client_world.persistence.load_execution_plan(result.id).
+                    steps_in_state(:suspended).first
+              end
+              client_world.event(step.execution_plan_id, step.id, 'finish')
+              plan = result.finished.value
+              assert_equal('finish', plan.actions.first.output[:event])
+            end
+
+            it 'fails the future when the step is not accepting events' do
+              result = client_world.trigger(Support::CodeWorkflowExample::Dummy, { :text => "dummy" })
+              plan   = result.finished.value!
+              step   = plan.steps.values.first
+              future = client_world.event(plan.id, step.id, 'finish')
+              future.wait
+              assert future.failed?
+            end
+
+            it 'succeeds when executor acts as client' do
+              result = client_world.trigger(Support::DummyExample::ComposedAction, :timeout => 3)
+              plan = result.finished.value
+              assert_equal('finish', plan.actions.first.output[:event])
+            end
+          end
+        end
+      end
+
+      def self.supports_dynamic_retry
+        before do
+          # mention the executors to make sure they are initialized
+          @executors = [executor_world, executor_world_2]
+        end
+
+        describe 'when some executor is terminated and client is notified about the failure' do
+          specify 'client passes the work to another executor' do
+            triggered = while_executing_plan { |executor| executor.terminate.wait }
+            plan = finish_the_plan(triggered)
+            assert_plan_reexecuted(plan)
+          end
+        end
+
+      end
+
+      def self.supports_ping_pong
+        describe 'ping/pong' do
+          it 'succeeds when the world is available' do
+            ping_response = client_world.ping(executor_world.id, 0.5)
+            ping_response.wait
+            assert ping_response.success?
+          end
+
+          it 'time-outs when the world is not responding' do
+            executor_world.terminate.wait
+            ping_response = client_world.ping(executor_world.id, 0.5)
+            ping_response.wait
+            assert ping_response.failed?
+          end
+        end
+      end
+
+      def self.handles_no_executor_available
+        it 'fails to finish the future when no executor available' do
+          client_world # just to initialize the client world before terminating the executors
+          executor_world.terminate.wait
+          executor_world_2.terminate.wait
+          result = client_world.trigger(Support::DummyExample::Dummy)
+          result.finished.wait
+          assert result.finished.failed?
+          assert_match(/No executor available/, result.finished.reason.message)
+        end
+      end
+
+      describe 'direct connector - all in one' do
+        let(:connector) { Proc.new { |world| Connectors::Direct.new(world) } }
+        let(:executor_world) { create_world }
+        let(:client_world) { executor_world }
+
+        dispatcher_works_with_this_connector
+        supports_ping_pong
+      end
+
+      describe 'direct connector - multi executor multi client' do
+        let(:shared_connector) { Connectors::Direct.new() }
+        let(:connector) { Proc.new { |world| shared_connector.start_listening(world); shared_connector } }
+        let(:executor_world) { create_world(true) }
+        let(:executor_world_2) { create_world(true) }
+        let(:client_world) { create_world(false) }
+        let(:client_world_2) { create_world(false) }
+
+        dispatcher_works_with_this_connector
+        supports_dynamic_retry
+        supports_ping_pong
+        handles_no_executor_available
+      end
+
+      describe 'database connector - all in one' do
+        let(:connector) { Proc.new { |world| Connectors::Database.new(world, connector_polling_interval(world)) } }
+        let(:executor_world) { create_world }
+        let(:client_world) { executor_world }
+
+        dispatcher_works_with_this_connector
+        supports_ping_pong
+      end
+
+      describe 'database connector - multi executor multi client' do
+        let(:connector) { Proc.new { |world| Connectors::Database.new(world, connector_polling_interval(world)) } }
+        let(:executor_world) { create_world(true) }
+        let(:executor_world_2) { create_world(true) }
+        let(:client_world) { create_world(false) }
+        let(:client_world_2) { create_world(false) }
+
+        dispatcher_works_with_this_connector
+        supports_dynamic_retry
+        supports_ping_pong
+        handles_no_executor_available
+      end
+    end
+  end
+end