dynflow 0.7.7 → 0.7.8

data/README.md

@@ -6,7 +6,7 @@
 ![Gem version](https://img.shields.io/gem/v/dynflow.svg?style=flat)
 ![License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat)
 
-**Note:** *There is a project page and documentation being build in url <http://http://dynflow.github.io/>.
+**Note:** *There is a project page and documentation being build in url <http://dynflow.github.io/>.
 It's still work in progress but you may find useful information there. It'll eventually replace 
 this README.*
 

data/doc/pages/Gemfile

@@ -4,5 +4,4 @@ gem 'rake'
 gem 'jekyll'
 gem 'pry'
 gem 'ruby-nuggets' # require by tags plugin
-
-gem 'pry'
+gem 'therubyracer'

data/doc/pages/Rakefile

@@ -17,9 +17,10 @@ task :publish do
       system 'git fetch --all'
       system 'git reset --hard origin/master'
     end
-    system 'jekyll build'
+    sh 'jekyll build'
     Dir.chdir(root + '/public') do
-      system 'git ac -m Update'
+      system 'git add -A .'
+      system 'git commit -m Update'
       system 'git push'
     end
   end

data/lib/dynflow/action.rb

@@ -371,9 +371,14 @@ module Dynflow
 
     # DSL for run phase
 
+    def suspended_action
+      phase! Run
+      @suspended_action ||= Action::Suspended.new(self)
+    end
+
     def suspend(&block)
       phase! Run
-      block.call Action::Suspended.new self if block
+      block.call suspended_action if block
       throw SUSPEND, SUSPEND
     end
 

data/lib/dynflow/action/polling.rb

@@ -1,6 +1,12 @@
+require 'dynflow/action/timeouts'
+
 module Dynflow
   module Action::Polling
 
+    def self.included(base)
+      base.send :include, Action::Timeouts
+    end
+
     Poll = Algebrick.atom
 
     def run(event = nil)
@@ -13,6 +19,9 @@ module Dynflow
         end
       when Poll
         poll_external_task_with_rescue
+      when Action::Timeouts::Timeout
+        process_timeout
+        suspend
       else
         raise "unrecognized event #{event}"
       end

data/lib/dynflow/action/timeouts.rb

@@ -0,0 +1,13 @@
+module Dynflow
+  module Action::Timeouts
+    Timeout = Algebrick.atom
+
+    def process_timeout
+      fail("Timeout exceeded.")
+    end
+
+    def schedule_timeout(seconds)
+      world.clock.ping suspended_action, seconds, Timeout
+    end
+ end
+end

data/lib/dynflow/persistence.rb

@@ -34,6 +34,10 @@ module Dynflow
       end
     end
 
+    def delete_execution_plans(filters, batch_size = 1000)
+      adapter.delete_execution_plans(filters, batch_size)
+    end
+
     def load_execution_plan(id)
       execution_plan_hash = adapter.load_execution_plan(id)
       ExecutionPlan.new_from_hash(execution_plan_hash, @world)

data/lib/dynflow/persistence_adapters/abstract.rb

@@ -30,12 +30,20 @@ module Dynflow
       # @option options [Integer] per_page the number of the items on page
       # @option options [Symbol] order_by name of the column to use for ordering
       # @option options [true, false] desc set to true if order should be descending
-      # @option options [Hash{ Symbol => Object,Array<object> }] filters hash represents
+      # @option options [Hash{ String => Object,Array<object> }] filters hash represents
       #   set of allowed values for a given key representing column
       def find_execution_plans(options = {})
         raise NotImplementedError
       end
 
+      # @param filters [Hash{ String => Object }] filters to determine
+      #   what to delete
+      # @param batch_size the size of the chunks to iterate over when
+      #   performing the deletion
+      def delete_execution_plans(filters, batch_size = 1000)
+        raise NotImplementedError
+      end
+
       def load_execution_plan(execution_plan_id)
         raise NotImplementedError
       end

data/lib/dynflow/persistence_adapters/sequel.rb

@@ -36,13 +36,26 @@ module Dynflow
       end
 
       def find_execution_plans(options = {})
-        data_set = filter(order(paginate(table(:execution_plan), options), options), options)
+        data_set = filter(order(paginate(table(:execution_plan), options), options), options[:filters])
 
         data_set.map do |record|
           HashWithIndifferentAccess.new(MultiJson.load(record[:data]))
         end
       end
 
+      def delete_execution_plans(filters, batch_size = 1000)
+        count = 0
+        filter(table(:execution_plan), filters).each_slice(batch_size) do |plans|
+          uuids = plans.map { |p| p.fetch(:uuid) }
+          @db.transaction do
+            table(:step).where(execution_plan_uuid: uuids).delete
+            table(:action).where(execution_plan_uuid: uuids).delete
+            count += table(:execution_plan).where(uuid: uuids).delete
+          end
+        end
+        return count
+      end
+
       def load_execution_plan(execution_plan_id)
         load :execution_plan, uuid: execution_plan_id
       end
@@ -68,9 +81,9 @@ module Dynflow
       end
 
       def to_hash
-        { execution_plans: table(:execution_plan).all,
-          steps:           table(:step).all,
-          actions:         table(:action).all }
+        { execution_plans: table(:execution_plan).all.to_a,
+          steps:           table(:step).all.to_a,
+          actions:         table(:action).all.to_a }
       end
 
       private
@@ -148,10 +161,10 @@ module Dynflow
         data_set.order_by options[:desc] ? ::Sequel.desc(order_by) : order_by
       end
 
-      def filter(data_set, options)
-        filters = Type! options[:filters], NilClass, Hash
+      def filter(data_set, filters)
+        Type! filters, NilClass, Hash
         return data_set if filters.nil?
-        unknown = filters.keys - META_DATA.fetch(:execution_plan) - %w[caller_execution_plan_id caller_action_id]
+        unknown = filters.keys - META_DATA.fetch(:execution_plan) - %w[uuid caller_execution_plan_id caller_action_id]
 
         if filters.key?('caller_action_id') && !filters.key?('caller_execution_plan_id')
           raise ArgumentError, "caller_action_id given but caller_execution_plan_id missing"

data/lib/dynflow/testing/dummy_executor.rb

@@ -12,11 +12,15 @@ module Dynflow
         @events_to_process << [execution_plan_id, step_id, event, future]
       end
 
+      # returns true if some event was processed.
       def progress
         events = @events_to_process.dup
         clear
         events.each do |execution_plan_id, step_id, event, future|
           future.resolve true
+          if event && world.action.state != :suspended
+            return false
+          end
           world.action.execute event
         end
       end

data/lib/dynflow/testing/factories.rb

@@ -97,8 +97,9 @@ module Dynflow
 
       def progress_action_time action
         Match! action.phase, Action::Run
-        action.world.clock.progress
-        action.world.executor.progress
+        if action.world.clock.progress
+          return action.world.executor.progress
+        end
       end
     end
   end

data/lib/dynflow/testing/managed_clock.rb

@@ -5,30 +5,29 @@ module Dynflow
       attr_reader :pending_pings
 
       include Algebrick::Types
-      Timer = Algebrick.type do
-        fields! who:   Object, # to ping back
-                when:  type { variants Time, Numeric }, # to deliver
-                what:  Maybe[Object], # to send
-                where: Symbol # it should be delivered, which method
-      end
-
-      module Timer
-        include Clock::Timer
-      end
 
       def initialize
         @pending_pings = []
       end
 
       def ping(who, time, with_what = nil, where = :<<)
+        time  = current_time + time if time.is_a? Numeric
         with = with_what.nil? ? None : Some[Object][with_what]
-        @pending_pings << Timer[who, time, with, where]
+        @pending_pings << Clock::Timer[who, time, with, where]
+        @pending_pings.sort!
       end
 
       def progress
-        copy = @pending_pings.dup
-        clear
-        copy.each { |ping| ping.apply }
+        if next_ping = @pending_pings.shift
+          # we are testing an isolated system = we can move in time
+          # without actually waiting
+          @current_time = next_ping.when
+          next_ping.apply
+        end
+      end
+
+      def current_time
+        @current_time ||= Time.now
       end
 
       def clear

data/lib/dynflow/version.rb

@@ -1,3 +1,3 @@
 module Dynflow
-  VERSION = '0.7.7'
+  VERSION = '0.7.8'
 end

data/test/action_test.rb

@@ -172,85 +172,138 @@ module Dynflow
         end
       end
 
-      let(:plan) do
-        create_and_plan_action TestPollingAction, { task_args: 'do something' }
-      end
-
-      before do
-        TestPollingAction.config = TestPollingAction::Config.new
+      class NonRunningExternalService < ExternalService
+        def poll(id)
+          return { message: 'nothing changed' }
+        end
       end
 
-      def next_ping(action)
-        action.world.clock.pending_pings.first
-      end
+      class TestTimeoutAction < TestPollingAction
+        class Config < TestPollingAction::Config
+          def initialize
+            super
+            @external_service = NonRunningExternalService.new
+          end
+        end
 
-      it 'initiates the external task' do
-        action   = run_action plan
+        def done?
+          self.state == :error
+        end
 
-        action.output[:task][:task_id].must_equal 123
+        def invoke_external_task
+          schedule_timeout(5)
+          super
+        end
       end
 
-      it 'polls till the task is done' do
-        action   = run_action plan
+      describe'without timeout' do
+        let(:plan) do
+          create_and_plan_action TestPollingAction, { task_args: 'do something' }
+        end
 
-        9.times { progress_action_time action }
-        action.done?.must_equal false
-        next_ping(action).wont_be_nil
-        action.state.must_equal :suspended
+        before do
+          TestPollingAction.config = TestPollingAction::Config.new
+        end
 
-        progress_action_time action
-        action.done?.must_equal true
-        next_ping(action).must_be_nil
-        action.state.must_equal :success
-      end
+        def next_ping(action)
+          action.world.clock.pending_pings.first
+        end
 
-      it 'tries to poll for the old task when resuming' do
-        action   = run_action plan
-        action.output[:task][:progress].must_equal 0
-        run_action action
-        action.output[:task][:progress].must_equal 10
-      end
+        it 'initiates the external task' do
+          action   = run_action plan
 
-      it 'invokes the external task again when polling on the old one fails' do
-        action   = run_action plan
-        action.world.silence_logger!
-        action.external_service.will_fail
-        action.output[:task][:progress].must_equal 0
-        run_action action
-        action.output[:task][:progress].must_equal 0
-      end
+          action.output[:task][:task_id].must_equal 123
+        end
 
-      it 'tolerates some failure while polling' do
-        action   = run_action plan
-        action.external_service.will_fail
-        action.world.silence_logger!
+        it 'polls till the task is done' do
+          action   = run_action plan
 
-        TestPollingAction.config.poll_max_retries = 3
-        (1..2).each do |attempt|
-          progress_action_time action
-          action.poll_attempts[:failed].must_equal attempt
+          9.times { progress_action_time action }
+          action.done?.must_equal false
           next_ping(action).wont_be_nil
           action.state.must_equal :suspended
+
+          progress_action_time action
+          action.done?.must_equal true
+          next_ping(action).must_be_nil
+          action.state.must_equal :success
         end
 
-        progress_action_time action
-        action.poll_attempts[:failed].must_equal 3
-        next_ping(action).must_be_nil
-        action.state.must_equal :error
-      end
+        it 'tries to poll for the old task when resuming' do
+          action   = run_action plan
+          action.output[:task][:progress].must_equal 0
+          run_action action
+          action.output[:task][:progress].must_equal 10
+        end
+
+        it 'invokes the external task again when polling on the old one fails' do
+          action   = run_action plan
+          action.world.silence_logger!
+          action.external_service.will_fail
+          action.output[:task][:progress].must_equal 0
+          run_action action
+          action.output[:task][:progress].must_equal 0
+        end
+
+        it 'tolerates some failure while polling' do
+          action   = run_action plan
+          action.external_service.will_fail
+          action.world.silence_logger!
+
+          TestPollingAction.config.poll_max_retries = 3
+          (1..2).each do |attempt|
+            progress_action_time action
+            action.poll_attempts[:failed].must_equal attempt
+            next_ping(action).wont_be_nil
+            action.state.must_equal :suspended
+          end
+
+          progress_action_time action
+          action.poll_attempts[:failed].must_equal 3
+          next_ping(action).must_be_nil
+          action.state.must_equal :error
+        end
 
-      it 'allows increasing poll interval in a time' do
-        TestPollingAction.config.poll_intervals = [1, 2]
-        TestPollingAction.config.attempts_before_next_interval = 1
+        it 'allows increasing poll interval in a time' do
+          TestPollingAction.config.poll_intervals = [1, 2]
+          TestPollingAction.config.attempts_before_next_interval = 2
 
-        action   = run_action plan
-        next_ping(action).when.must_equal 1
-        progress_action_time action
-        next_ping(action).when.must_equal 2
-        progress_action_time action
-        next_ping(action).when.must_equal 2
+          action   = run_action plan
+          pings = []
+          pings << next_ping(action)
+          progress_action_time action
+          pings << next_ping(action)
+          progress_action_time action
+          pings << next_ping(action)
+          progress_action_time action
+          (pings[1].when - pings[0].when).must_be_close_to 1
+          (pings[2].when - pings[1].when).must_be_close_to 2
+        end
       end
 
+      describe 'with timeout' do
+        let(:plan) do
+          create_and_plan_action TestTimeoutAction, { task_args: 'do something' }
+        end
+
+        before do
+          TestTimeoutAction.config = TestTimeoutAction::Config.new
+          TestTimeoutAction.config.poll_intervals = [2]
+        end
+
+        it 'timesout' do
+          action   = run_action plan
+          iterations = 0
+          while progress_action_time action
+            # we count the number of iterations till the timeout occurs
+            iterations += 1
+          end
+          action.state.must_equal :error
+          # two polls in 2 seconds intervals untill the 5 seconds
+          # timeout appears
+          iterations.must_equal 3
+        end
+      end
     end
 
     describe Action::WithSubPlans do

data/test/persistence_test.rb

@@ -0,0 +1,191 @@
+require_relative 'test_helper'
+require 'fileutils'
+
+module Dynflow
+  module PersistenceTest
+    describe 'persistence adapters' do
+
+      let :execution_plans_data do
+        [{ id: 'plan1', state: 'paused' },
+         { id: 'plan2', state: 'stopped' },
+         { id: 'plan3', state: 'paused' }]
+      end
+
+      let :action_data do
+        { id: 1, caller_execution_plan_id: nil, caller_action_id: nil }
+      end
+
+      let :step_data do
+        { id: 1,
+          state: 'success',
+          started_at: '2015-02-24 10:00',
+          ended_at: '2015-02-24 10:01',
+          real_time: 1.1,
+          execution_time: 0.1,
+          action_id: 1,
+          progress_done: 1,
+          progress_weight: 2.5 }
+      end
+
+      def prepare_plans
+        execution_plans_data.map do |h|
+          h.merge result:    nil, started_at: (Time.now-20).to_s, ended_at: (Time.now-10).to_s,
+              real_time: 0.0, execution_time: 0.0
+        end.tap do |plans|
+          plans.each { |plan| adapter.save_execution_plan(plan[:id], plan) }
+        end
+      end
+
+      def prepare_action(plan)
+        adapter.save_action(plan, action_data[:id], action_data)
+      end
+
+      def prepare_step(plan)
+        adapter.save_step(plan, step_data[:id], step_data)
+      end
+
+      def prepare_plans_with_actions
+        prepare_plans.each do |plan|
+          prepare_action(plan[:id])
+        end
+      end
+
+      def prepare_plans_with_steps
+        prepare_plans_with_actions.map do |plan|
+          prepare_step(plan[:id])
+        end
+      end
+
+      def self.it_acts_as_persistence_adapter
+        before do
+          # the tests expect clean field
+          adapter.delete_execution_plans({})
+        end
+        describe '#find_execution_plans' do
+          it 'supports pagination' do
+            prepare_plans
+            if adapter.pagination?
+              loaded_plans = adapter.find_execution_plans(page: 0, per_page: 1)
+              loaded_plans.map { |h| h[:id] }.must_equal ['plan1']
+
+              loaded_plans = adapter.find_execution_plans(page: 1, per_page: 1)
+              loaded_plans.map { |h| h[:id] }.must_equal ['plan2']
+            end
+          end
+
+          it 'supports ordering' do
+            prepare_plans
+            if adapter.ordering_by.include?(:state)
+              loaded_plans = adapter.find_execution_plans(order_by: 'state')
+              loaded_plans.map { |h| h[:id] }.must_equal ['plan1', 'plan3', 'plan2']
+
+              loaded_plans = adapter.find_execution_plans(order_by: 'state', desc: true)
+              loaded_plans.map { |h| h[:id] }.must_equal ['plan2', 'plan3', 'plan1']
+            end
+          end
+
+          it 'supports filtering' do
+            prepare_plans
+            if adapter.ordering_by.include?(:state)
+              loaded_plans = adapter.find_execution_plans(filters: { state: ['paused'] })
+              loaded_plans.map { |h| h[:id] }.must_equal ['plan1', 'plan3']
+
+              loaded_plans = adapter.find_execution_plans(filters: { state: ['stopped'] })
+              loaded_plans.map { |h| h[:id] }.must_equal ['plan2']
+
+              loaded_plans = adapter.find_execution_plans(filters: { state: [] })
+              loaded_plans.map { |h| h[:id] }.must_equal []
+
+              loaded_plans = adapter.find_execution_plans(filters: { state: ['stopped', 'paused'] })
+              loaded_plans.map { |h| h[:id] }.must_equal ['plan1', 'plan2', 'plan3']
+
+              loaded_plans = adapter.find_execution_plans(filters: { 'state' => ['stopped', 'paused'] })
+              loaded_plans.map { |h| h[:id] }.must_equal ['plan1', 'plan2', 'plan3']
+            end
+          end
+        end
+
+        describe '#load_execution_plan and #save_execution_plan' do
+          it 'serializes/deserializes the plan data' do
+            -> { adapter.load_execution_plan('plan1') }.must_raise KeyError
+            prepare_plans
+            adapter.load_execution_plan('plan1')[:id].must_equal 'plan1'
+            adapter.load_execution_plan('plan1')['id'].must_equal 'plan1'
+            adapter.load_execution_plan('plan1').keys.size.must_equal 7
+
+            adapter.save_execution_plan('plan1', nil)
+            -> { adapter.load_execution_plan('plan1') }.must_raise KeyError
+          end
+        end
+
+        describe '#delete_execution_plans' do
+          it 'deletes selected execution plans, including steps and actions' do
+            prepare_plans_with_steps
+            adapter.delete_execution_plans('uuid' => 'plan1').must_equal 1
+            -> { adapter.load_execution_plan('plan1') }.must_raise KeyError
+            -> { adapter.load_action('plan1', action_data[:id]) }.must_raise KeyError
+            -> { adapter.load_step('plan1', step_data[:id]) }.must_raise KeyError
+
+            # testing that no other plans where affected
+            adapter.load_execution_plan('plan2')
+            adapter.load_action('plan2', action_data[:id])
+            adapter.load_step('plan2', step_data[:id])
+
+            prepare_plans_with_steps
+            adapter.delete_execution_plans('state' => 'paused').must_equal 2
+            -> { adapter.load_execution_plan('plan1') }.must_raise KeyError
+            adapter.load_execution_plan('plan2') # nothing raised
+            -> { adapter.load_execution_plan('plan3') }.must_raise KeyError
+          end
+        end
+
+        describe '#load_action and #save_action' do
+          it 'serializes/deserializes the action data' do
+            prepare_plans
+            action_id = action_data[:id]
+            -> { adapter.load_action('plan1', action_id) }.must_raise KeyError
+
+            prepare_action('plan1')
+            loaded_action = adapter.load_action('plan1', action_id)
+            loaded_action[:id].must_equal action_id
+            loaded_action.must_equal(action_data.stringify_keys)
+
+            adapter.save_action('plan1', action_id, nil)
+            -> { adapter.load_action('plan1', action_id) }.must_raise KeyError
+
+            adapter.save_execution_plan('plan1', nil)
+          end
+        end
+
+        describe '#load_step and #save_step' do
+          it 'serializes/deserializes the step data' do
+            prepare_plans_with_actions
+            step_id = step_data[:id]
+            prepare_step('plan1')
+            loaded_step = adapter.load_step('plan1', step_id)
+            loaded_step[:id].must_equal step_id
+            loaded_step.must_equal(step_data.stringify_keys)
+          end
+        end
+      end
+
+      describe Dynflow::PersistenceAdapters::Sequel do
+        let(:adapter) { Dynflow::PersistenceAdapters::Sequel.new 'sqlite:/' }
+
+        it_acts_as_persistence_adapter
+
+        it 'allows inspecting the persisted content' do
+          plans = prepare_plans
+
+          plans.each do |original|
+            stored = adapter.to_hash.fetch(:execution_plans).find { |ep| ep[:uuid].strip == original[:id] }
+            stored.each { |k, v| stored[k] = v.to_s if v.is_a? Time }
+            adapter.class::META_DATA.fetch(:execution_plan).each do |name|
+              stored.fetch(name.to_sym).must_equal original.fetch(name.to_sym)
+            end
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynflow
 version: !ruby/object:Gem::Version
-  version: 0.7.7
+  version: 0.7.8
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-17 00:00:00.000000000 Z
+date: 2015-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -348,6 +348,7 @@ files:
 - lib/dynflow/action/progress.rb
 - lib/dynflow/action/rescue.rb
 - lib/dynflow/action/suspended.rb
+- lib/dynflow/action/timeouts.rb
 - lib/dynflow/action/with_sub_plans.rb
 - lib/dynflow/clock.rb
 - lib/dynflow/daemon.rb
@@ -432,7 +433,7 @@ files:
 - test/execution_plan_test.rb
 - test/executor_test.rb
 - test/middleware_test.rb
-- test/persistance_adapters_test.rb
+- test/persistence_test.rb
 - test/remote_via_socket_test.rb
 - test/rescue_test.rb
 - test/support/code_workflow_example.rb
@@ -493,7 +494,7 @@ test_files:
 - test/execution_plan_test.rb
 - test/executor_test.rb
 - test/middleware_test.rb
-- test/persistance_adapters_test.rb
+- test/persistence_test.rb
 - test/remote_via_socket_test.rb
 - test/rescue_test.rb
 - test/support/code_workflow_example.rb

data/test/persistance_adapters_test.rb

@@ -1,173 +0,0 @@
-require_relative 'test_helper'
-require 'fileutils'
-
-module PersistenceAdapterTest
-  def storage
-    raise NotImplementedError
-  end
-
-  def prepare_plans
-    proto_plans = [{ id: 'plan1', state: 'paused' },
-                   { id: 'plan2', state: 'stopped' },
-                   { id: 'plan3', state: 'paused' }]
-    proto_plans.map do |h|
-      h.merge result:    nil, started_at: (Time.now-20).to_s, ended_at: (Time.now-10).to_s,
-              real_time: 0.0, execution_time: 0.0
-    end.tap do |plans|
-      plans.each { |plan| storage.save_execution_plan(plan[:id], plan) }
-    end
-  end
-
-  def test_load_execution_plans
-    plans        = prepare_plans
-    loaded_plans = storage.find_execution_plans
-    loaded_plans.size.must_equal 3
-    loaded_plans.must_include plans[0].with_indifferent_access
-    loaded_plans.must_include plans[1].with_indifferent_access
-  end
-
-  def test_pagination
-    prepare_plans
-    if storage.pagination?
-      loaded_plans = storage.find_execution_plans(page: 0, per_page: 1)
-      loaded_plans.map { |h| h[:id] }.must_equal ['plan1']
-
-      loaded_plans = storage.find_execution_plans(page: 1, per_page: 1)
-      loaded_plans.map { |h| h[:id] }.must_equal ['plan2']
-    end
-  end
-
-  def test_ordering
-    prepare_plans
-    if storage.ordering_by.include?(:state)
-      loaded_plans = storage.find_execution_plans(order_by: 'state')
-      loaded_plans.map { |h| h[:id] }.must_equal ['plan1', 'plan3', 'plan2']
-
-      loaded_plans = storage.find_execution_plans(order_by: 'state', desc: true)
-      loaded_plans.map { |h| h[:id] }.must_equal ['plan2', 'plan3', 'plan1']
-    end
-  end
-
-  def test_filtering
-    prepare_plans
-    if storage.ordering_by.include?(:state)
-      loaded_plans = storage.find_execution_plans(filters: { state: ['paused'] })
-      loaded_plans.map { |h| h[:id] }.must_equal ['plan1', 'plan3']
-
-      loaded_plans = storage.find_execution_plans(filters: { state: ['stopped'] })
-      loaded_plans.map { |h| h[:id] }.must_equal ['plan2']
-
-      loaded_plans = storage.find_execution_plans(filters: { state: [] })
-      loaded_plans.map { |h| h[:id] }.must_equal []
-
-      loaded_plans = storage.find_execution_plans(filters: { state: ['stopped', 'paused'] })
-      loaded_plans.map { |h| h[:id] }.must_equal ['plan1', 'plan2', 'plan3']
-
-      loaded_plans = storage.find_execution_plans(filters: { 'state' => ['stopped', 'paused'] })
-      loaded_plans.map { |h| h[:id] }.must_equal ['plan1', 'plan2', 'plan3']
-    end
-  end
-
-  def test_save_execution_plan
-    plan = { id:        'plan1', state: :pending, result: nil, started_at: nil, ended_at: nil,
-             real_time: 0.0, execution_time: 0.0 }
-    -> { storage.load_execution_plan('plan1') }.must_raise KeyError
-
-    storage.save_execution_plan('plan1', plan)
-    storage.load_execution_plan('plan1')[:id].must_equal 'plan1'
-    storage.load_execution_plan('plan1')['id'].must_equal 'plan1'
-    storage.load_execution_plan('plan1').keys.size.must_equal 7
-
-    storage.save_execution_plan('plan1', nil)
-    -> { storage.load_execution_plan('plan1') }.must_raise KeyError
-  end
-
-  def test_save_action
-    plan = { id:        'plan1', state: :pending, result: nil, started_at: nil, ended_at: nil,
-             real_time: 0.0, execution_time: 0.0 }
-    storage.save_execution_plan('plan1', plan)
-
-    action = { id: 1, caller_execution_plan_id: nil, caller_action_id: nil }
-    -> { storage.load_action('plan1', 1) }.must_raise KeyError
-
-    storage.save_action('plan1', 1, action)
-    storage.load_action('plan1', 1)[:id].must_equal 1
-    storage.load_action('plan1', 1)['id'].must_equal 1
-    storage.load_action('plan1', 1).keys.must_equal %w[id caller_execution_plan_id caller_action_id]
-
-    storage.save_action('plan1', 1, nil)
-    -> { storage.load_action('plan1', 1) }.must_raise KeyError
-
-    storage.save_execution_plan('plan1', nil)
-  end
-
-end
-
-class SequelTest < MiniTest::Spec
-  include PersistenceAdapterTest
-
-  def storage
-    @storage ||= Dynflow::PersistenceAdapters::Sequel.new 'sqlite:/'
-  end
-
-  def test_stores_meta_data
-    plans = prepare_plans
-
-    plans.each do |original|
-      stored = storage.to_hash.fetch(:execution_plans).find { |ep| ep[:uuid] == original[:id] }
-      stored.each { |k, v| stored[k] = v.to_s if v.is_a? Time }
-      storage.class::META_DATA.fetch(:execution_plan).each do |name|
-        stored.fetch(name.to_sym).must_equal original.fetch(name.to_sym)
-      end
-    end
-  end
-end
-
-#class MemoryTest < MiniTest::Unit::TestCase
-#  include PersistenceAdapterTest
-#
-#  def storage
-#    @storage ||= Dynflow::PersistenceAdapters::Memory.new
-#  end
-#end
-#
-#class SimpleFileStorageTest < MiniTest::Unit::TestCase
-#  include PersistenceAdapterTest
-#
-#  def storage_path
-#    "#{File.dirname(__FILE__)}/simple_file_storage"
-#  end
-#
-#  def setup
-#    Dir.mkdir storage_path
-#  end
-#
-#  def storage
-#    @storage ||= begin
-#      Dynflow::PersistenceAdapters::SimpleFileStorage.new storage_path
-#    end
-#  end
-#
-#  def teardown
-#    FileUtils.rm_rf storage_path
-#  end
-#end
-#
-#require 'dynflow/persistence_adapters/active_record'
-#
-#class ActiveRecordTest < MiniTest::Unit::TestCase
-#  include PersistenceAdapterTest
-#
-#  def setup
-#    ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
-#    ::ActiveRecord::Migrator.migrate Dynflow::PersistenceAdapters::ActiveRecord.migrations_path
-#  end
-#
-#  def storage
-#    @storage ||= begin
-#      Dynflow::PersistenceAdapters::ActiveRecord.new
-#    end
-#  end
-#end
-
-