dynflow 0.0.1

data/.gitignore

@@ -0,0 +1 @@
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gem 'multi_json'
+gem 'activesupport'
+gem 'apipie-params', :git => '/home/inecas/Projects/apipie-params'
+
+group :development do
+  gem 'pry'
+end

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 Pavel Pokorný
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,151 @@
+DYNamic workFLOW
+================
+
+In traditional workflow engines, you specify a static workflow and
+then run it with various inputs. Dynflow takes different approach.
+
+You specify the inputs and the workflow is generated on the fly. You
+can either specify the steps explicitly or subscribe one action to
+another. This is suitable for plugin architecture, where you can't
+write the whole process on one place.
+
+Dynflow doesn't differentiate between workflow and action. Instead,
+every action can populate another actions, effectively producing the
+resulting set of steps.
+
+The whole execution is done in three phases:
+
+1. *Planning phase*
+
+  Construct the execution plan for the workflow. It's invoked by
+  calling `trigger` on an action. Two mechanisms are used to get the set
+  of actions to be executed:
+
+    a. explicit calls of `plan_action` methods in the `plan` method
+
+    b. implicit associations: an action A subscribes to an action B,
+    which means that the action A is executed whenever the action B
+    occurs.
+
+The output of this phase is a set of actions and their inputs.
+
+2. *Execution phase*
+
+  The plan is being executed step by step, calling the run method of
+  an action with corresponding input. The results of every action are
+  written into output attribute.
+
+  The run method should be stateless, with all the needed information
+  included in the input from planning phase. This allows us to
+  control the workflow execution: the state of every action can be
+  serialized therefore the workflow itself can be persisted. This makes
+  it easy to recover from failed actions by rerunning it.
+
+3. *Finalization phase*
+
+  Take the results from the execution phase and perform some additional
+  tasks. This is suitable for example for recording the results into
+  database.
+
+Every action can participate in every phase.
+
+Example
+-------
+
+One code snippet is worth 1000 words:
+
+```ruby
+# The anatomy of action class
+
+# every action needs to inherit from Dynflow::Action
+class Action < Dynflow::Action
+
+  # OPTIONAL: the input format for the execution phase of this action
+  # (https://github.com/iNecas/apipie-params for more details.
+  # Validations can be performed against this description (turned off
+  # for now)
+  input_format do
+    param :id, Integer
+    param :name, String
+  end
+
+  # OPTIONAL: every action can produce an output in the execution
+  # phase. This allows to describe the output.
+  output_format do
+    param :uuid, String
+  end
+
+  # OPTIONAL: this specifies that this action should be performed when
+  # AnotherAction is triggered.
+  def self.subscribe
+    AnotherAction
+  end
+
+  # OPTIONAL: executed during the planning phase. It's possible to
+  # specify explicitly the workflow here. By default it schedules just
+  # this action.
+  def plan(object_1, object_2)
+    # +plan_action+ schedules the SubAction to be part of this
+    # workflow
+    # the +object_1+ is passed to the +SubAction#plan+ method.
+    plan_action SubAction, object_1
+    # we can specify, where in the workflow this action should be
+    # placed, as well as prepare the input.
+    plan_self {'id' => object_2.id, 'name' => object_2.name}
+  end
+
+  # OPTIONAL: run the execution part of this action. Transform the
+  # data from +input+ to +output+. When not specified, the action is
+  # not used in the execution phase.
+  def run
+    output['uuid'] = "#{input['name']}-#{input['id']}"
+  end
+
+  # OPTIONAL: finalize the action after the execution phase finishes.
+  # in the +input+ and +output+ attributes are available the data from
+  # execution phase. in the +outputs+ argument, all the execution
+  # phase actions are available, each providing its input and output.
+  def finalize(outputs)
+    puts output['uuid']
+  end
+end
+```
+
+One can generate the execution plan for an action without actually
+running it:
+
+```ruby
+pp Publish.plan(short_article)
+# the expanded workflow is:
+# [
+#  [Publish, {"title"=>"Short", "body"=>"Short"}],
+#  [Review, {"title"=>"Short", "body"=>"Short"}],
+#  [Print, {"title"=>"Short", "body"=>"Short", "color"=>false}]
+# ]
+```
+
+Therefore it's suitable for the plan methods to not have any side
+effects (except of database writes that can be roll-backed)
+
+In the finalization phase, `finalize` method is called on every action
+if defined. The order is the same as in the execution plan.
+
+Every action should be as atomic as possible, providing better
+granularity when manipulating the process. Since every action can be
+subscribed by another one, adding new behaviour to an existing
+workflow is really simple.
+
+The input and output format can be used for defining the interface
+that other developers can use when extending the workflows.
+
+See the examples directory for more complete examples.
+
+License
+-------
+
+MIT
+
+Author
+------
+
+Ivan Nečas

data/Rakefile

@@ -0,0 +1,7 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib' << 'test'
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end

data/dynflow.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "dynflow/version"
+
+Gem::Specification.new do |s|
+  s.name        = "dynflow"
+  s.version     = Dynflow::VERSION
+  s.authors     = ["Ivan Necas"]
+  s.email       = ["inecas@redhat.com"]
+  s.homepage    = "http://github.com/iNecas/eventum"
+  s.summary     = "DYNamic workFLOW engine"
+  s.description = "Generate and executed workflows dynamically based "+
+                  "on input data and leave it open for others to jump into it as well"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ["lib"]
+
+  s.add_dependency "activesupport"
+  s.add_dependency "multi_json"
+  s.add_dependency "apipie-params"
+  s.add_development_dependency "minitest"
+end

data/examples/events.rb

@@ -0,0 +1,71 @@
+# Shows how Dynflow can be used for events architecture: actions are
+# subscribed to an event. When the event is triggered all the
+# subscribed actions are preformed.
+
+$:.unshift(File.expand_path('../../lib', __FILE__))
+
+require 'dynflow'
+require 'pp'
+
+# this is an event that can be triggered.
+# it has an input format so that the interface is given
+# TODO: the validations are turned off right now
+class Click < Dynflow::Action
+  input_format do
+    param :x, Integer
+    param :y, Integer
+  end
+end
+
+# SayHello subscibes to the event: it's run when the event is triggered
+class SayHello < Dynflow::Action
+
+  def self.subscribe
+    Click
+  end
+
+  def run
+    puts "Hello World"
+  end
+end
+
+# we can subscribe more actions to an event
+class SayPosition < Dynflow::Action
+
+  def self.subscribe
+    Click
+  end
+
+  def run
+    puts "your position is [#{input['x']} - #{input['y']}]"
+  end
+
+end
+
+# we can even subscribe to an action that is subscribed to an event
+class SayGoodbye < Dynflow::Action
+
+  def self.subscribe
+    SayPosition
+  end
+
+  def run
+    puts "Good Bye"
+  end
+end
+
+Click.trigger('x' => 5, 'y' => 4)
+# gives us:
+# Hello World
+# your position is [5 - 4]
+# Good Bye
+
+pp Click.plan('x' => 5, 'y' => 4)
+# returns the execution plan for the event (nothing is triggered):
+# [
+# since the event is action as well, it could have a run method
+#  [Click,        {"x"=>5, "y"=>4}],
+#  [SayHello,     {"x"=>5, "y"=>4}],
+#  [SayPosition,  {"x"=>5, "y"=>4}],
+#  [SayGoodbye,   {"x"=>5, "y"=>4}]
+# ]

data/examples/workflow.rb

@@ -0,0 +1,140 @@
+# Shows how Dynflow can be used for dynamic workflow definition
+# and execution.
+# In a planning phase of an action, a sub-action can be planned as
+# well.
+
+
+$:.unshift(File.expand_path('../../lib', __FILE__))
+
+require 'dynflow'
+require 'pp'
+
+class Article < Struct.new(:title, :body, :color); end
+
+class Publish < Dynflow::Action
+  input_format do
+    param :title, Integer
+    param :body, Integer
+  end
+
+  # plan can take arbitrary arguments. The args are passed from the
+  # trigger method.
+  def plan(article)
+    # we can explicitly plan a subaction
+    plan_self 'title' => article.title, 'body' => article.body
+    plan_action Review, article
+  end
+
+  def run
+    puts 'Starting'
+  end
+
+  # after all actions are run, there is a finishing phase. All the
+  # actions with +finished+ action defined are called, passing all the
+  # performed actions (with inputs and outputs)
+  def finalize(outputs)
+    printer_action = outputs.find { |o| o.is_a? Print }
+    puts "Printer says '#{printer_action.output['message']}'"
+  end
+end
+
+class Review < Dynflow::Action
+
+  # the actions can provide an output for the finalizing phase
+  output_format do
+    param :rating, Integer
+  end
+
+  # the plan method takes the same arguments as the parent action
+  def plan(article)
+    # in the input attribute the input for the parent action is
+    # available
+    plan_self input
+  end
+
+  # if no plan method given, the input is the same as the action that
+  # triggered it
+  def run
+    puts "Reviewing #{input['title']}"
+    raise "Too Short" if input['body'].size < 6
+    output['rating'] = input['body'].size
+  end
+
+  def finalize(outputs)
+    # +input+ and +output+ attributes are available in the finalizing
+    # phase as well.
+    puts "The rating was #{output['rating']}"
+  end
+
+end
+
+class Print < Dynflow::Action
+
+  input_format do
+    param :title, Integer
+    param :body, Integer
+    param :color, :boolean
+  end
+
+  output_format do
+    param :message, String
+  end
+
+  # if needed, we can subscribe to an action instead of explicitly
+  # specifying it in the plan method. Suitable for plugin architecture.
+  def self.subscribe
+    Review # sucessful review means we can print
+  end
+
+  def plan(article)
+    plan_self input.merge('color' => article.color)
+  end
+
+  def run
+    if input['color']
+      puts "Printing in color"
+    else
+      puts "Printing blank&white"
+    end
+    output['message'] = "Here you are"
+  end
+end
+
+short_article = Article.new('Short', 'Short', false)
+long_article = Article.new('Long', 'This is long', false)
+colorful_article = Article.new('Long Color', 'This is long in color', true)
+
+pp Publish.plan(short_article)
+# the expanded workflow is:
+# [
+#  [Publish, {"title"=>"Short", "body"=>"Short"}],
+#  [Review, {"title"=>"Short", "body"=>"Short"}],
+#  [Print, {"title"=>"Short", "body"=>"Short", "color"=>false}]
+# ]
+
+begin
+  Publish.trigger(short_article)
+rescue => e
+  puts e.message
+end
+# Produces:
+# Starting
+# Reviewing Short
+# Too Short
+
+Publish.trigger(long_article)
+# Produces:
+# Starting
+# Reviewing Long
+# Printing blank&white
+# Printer says 'Here you are'
+# The rating was 12
+
+
+Publish.trigger(colorful_article)
+# Produces:
+# Starting
+# Reviewing Long Color
+# Printing in color
+# Printer says 'Here you are'
+# The rating was 21

data/lib/dynflow.rb

@@ -0,0 +1,11 @@
+require 'dynflow/logger'
+require 'dynflow/message'
+require 'dynflow/dispatcher'
+require 'dynflow/bus'
+require 'dynflow/orch_request'
+require 'dynflow/orch_response'
+require 'dynflow/action'
+
+module Dynflow
+
+end

data/lib/dynflow/action.rb

@@ -0,0 +1,121 @@
+module Dynflow
+  class Action < Message
+
+    # only for the planning phase: flag indicating that the action
+    # was triggered from subscription. If so, the implicit plan
+    # method uses the input of the parent action. Otherwise, the
+    # argument the plan_action is used as default.
+    attr_accessor :from_subscription
+
+    def self.inherited(child)
+      self.actions << child
+    end
+
+    def self.actions
+      @actions ||= []
+    end
+
+    def self.subscribe
+      nil
+    end
+
+    def self.require
+      nil
+    end
+
+    def initialize(input, output = {})
+      # for preparation phase
+      @execution_plan = []
+
+      output ||= {}
+      super('input' => input, 'output' => output)
+    end
+
+    def input
+      @data['input']
+    end
+
+    def input=(input)
+      @data['input'] = input
+    end
+
+    def output
+      @data['output']
+    end
+
+    # the block contains the expression in Apipie::Params::DSL
+    # describing the format of message
+    def self.input_format(&block)
+      if block
+        @input_format_block = block
+      elsif @input_format_block
+        @input_format ||= Apipie::Params::Description.define(&@input_format_block)
+      else
+        nil
+      end
+    end
+
+    # the block contains the expression in Apipie::Params::DSL
+    # describing the format of message
+    def self.output_format(&block)
+      if block
+        @output_format_block = block
+      elsif @output_format_block
+        @output_format ||= Apipie::Params::Description.define(&@output_format_block)
+      else
+        nil
+      end
+    end
+
+    def self.trigger(*args)
+      Dynflow::Bus.trigger(self.plan(*args))
+    end
+
+    def self.plan(*args)
+      action = self.new({})
+      yield action if block_given?
+      action.plan(*args)
+      action.add_subscriptions(*args)
+      action.execution_plan
+    end
+
+    # for subscribed actions: by default take the input of the
+    # subscribed action
+    def plan(*args)
+      if from_subscription
+        # if the action is triggered by subscription, by default use the
+        # input of parent action
+        plan_self(self.input)
+      else
+        # in this case, the action was triggered by plan_action. Use
+        # the argument specified there.
+        plan_self(args.first)
+      end
+    end
+
+    def plan_self(input)
+      self.input = input
+      @execution_plan << [self.class, input]
+    end
+
+    def plan_action(action_class, *args)
+      sub_action_plan = action_class.plan(*args) do |action|
+        action.input = self.input
+      end
+      @execution_plan.concat(sub_action_plan)
+    end
+
+    def add_subscriptions(*plan_args)
+      @execution_plan.concat(Dispatcher.execution_plan_for(self, *plan_args))
+    end
+
+    def execution_plan
+      @execution_plan
+    end
+
+    def validate!
+      self.clss.output_format.validate!(@data['output'])
+    end
+
+  end
+end

data/lib/dynflow/bus.rb

@@ -0,0 +1,56 @@
+require 'active_support/inflector'
+require 'forwardable'
+module Dynflow
+  class Bus
+
+    class << self
+      extend Forwardable
+
+      def_delegators :impl, :wait_for, :process, :trigger, :finalize
+
+      def impl
+        @impl ||= Bus::MemoryBus.new
+      end
+      attr_writer :impl
+    end
+
+    def finalize(outputs)
+      outputs.each do |action|
+        if action.respond_to?(:finalize)
+          action.finalize(outputs)
+        end
+      end
+    end
+
+    def process(action_class, input, output = nil)
+      # TODO: here goes the message validation
+      action = action_class.new(input, output)
+      action.run if action.respond_to?(:run)
+      return action
+    end
+
+    def wait_for(*args)
+      raise NotImplementedError, 'Abstract method'
+    end
+
+    def logger
+      @logger ||= Dynflow::Logger.new(self.class)
+    end
+
+    class MemoryBus < Bus
+
+      def initialize
+        super
+      end
+
+      def trigger(execution_plan)
+        outputs = []
+        execution_plan.each do |(action_class, input)|
+          outputs << self.process(action_class, input)
+        end
+        self.finalize(outputs)
+      end
+
+    end
+  end
+end

data/lib/dynflow/dispatcher.rb

@@ -0,0 +1,36 @@
+module Dynflow
+  class Dispatcher
+    class << self
+      def finalizers
+        @finalizers ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      def subscribed_actions(action)
+        Action.actions.find_all do |sub_action|
+          case sub_action.subscribe
+          when Hash
+            sub_action.subscribe.keys.include?(action.class)
+          when Array
+            sub_action.subscribe.include?(action.class)
+          else
+            sub_action.subscribe == action.class
+          end
+        end
+      end
+
+      def execution_plan_for(action, *plan_args)
+        ordered_actions = subscribed_actions(action).sort_by(&:name)
+
+        execution_plan = []
+        ordered_actions.each do |action_class|
+          sub_action_plan = action_class.plan(*plan_args) do |sub_action|
+            sub_action.input = action.input
+            sub_action.from_subscription = true
+          end
+          execution_plan.concat(sub_action_plan)
+        end
+        return execution_plan
+      end
+    end
+  end
+end

data/lib/dynflow/logger.rb

@@ -0,0 +1,34 @@
+require 'forwardable'
+require 'logger'
+
+module Dynflow
+  class Logger
+    extend Forwardable
+
+    def_delegators :@impl, :debug, :info, :warn; :error
+
+    class DummyLogger < ::Logger
+      def initialize(identifier)
+        super(nil)
+      end
+    end
+
+
+    def initialize(identifier, impl = nil)
+      @impl = self.class.logger_class.new(identifier)
+    end
+
+    class << self
+
+      def logger_class
+        unless @logger_class
+          @logger_class ||= DummyLogger
+        end
+        return @logger_class
+      end
+
+      attr_writer :logger_class
+    end
+
+  end
+end

data/lib/dynflow/message.rb

@@ -0,0 +1,38 @@
+require 'forwardable'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/string/inflections'
+require 'apipie-params'
+
+module Dynflow
+  class Message
+
+    def ==(other)
+      self.encode == other.encode
+    end
+
+    extend Forwardable
+
+    def_delegators :@data, '[]', '[]='
+
+    attr_reader :data
+
+    def initialize(data = {})
+      @data = data.with_indifferent_access
+    end
+
+
+    def self.decode(data)
+      ret = data['message_type'].constantize.allocate
+      ret.instance_variable_set("@data", data['data'])
+      return ret
+    end
+
+    def encode
+      {
+        'message_type' => self.class.name,
+        'data' => @data
+      }
+    end
+
+  end
+end

data/lib/dynflow/orch_request.rb

@@ -0,0 +1,14 @@
+module Dynflow
+  class OrchRequest < Message
+    def self.response_class
+      unless self.name =~ /::Request\Z/
+        raise "Unexpected class name, #{self.name} expected to end with ::Request"
+      end
+      begin
+        self.name.sub(/::Request\Z/, '::Response').constantize
+      rescue NameError => e
+        OrchResponse
+      end
+    end
+  end
+end

data/lib/dynflow/orch_response.rb

@@ -0,0 +1,5 @@
+module Dynflow
+  class OrchResponse < Message
+
+  end
+end

data/lib/dynflow/version.rb

@@ -0,0 +1,3 @@
+module Dynflow
+  VERSION = "0.0.1"
+end

data/test/action_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+module Dynflow
+  class CloneRepo < Action
+
+    output_format do
+      param :id, String
+    end
+
+    def run
+      output['id'] = input['name']
+    end
+
+  end
+
+  class CloneRepoTest < ParticipantTestCase
+
+    def test_action
+      action = run_action(CloneRepo, {:name => "zoo"})
+      assert_equal(action.output['id'], "zoo")
+    end
+
+  end
+end

data/test/bus_test.rb

@@ -0,0 +1,55 @@
+require 'test_helper'
+require 'set'
+
+module Dynflow
+  class BusTest < BusTestCase
+    class Promotion < Action
+
+      def plan(repo_names, package_names)
+        repo_names.each do |repo_name|
+          plan_action(CloneRepo, {'name' => repo_name})
+        end
+
+        package_names.each do |package_name|
+          plan_action(ClonePackage, {'name' => package_name})
+        end
+      end
+
+    end
+
+    class CloneRepo < Action
+
+      input_format do
+        param :name, String
+      end
+
+      output_format do
+        param :id, String
+      end
+
+      def run
+        output['id'] = input['name']
+      end
+
+    end
+
+    def execution_plan
+      [
+       [CloneRepo, {'name' => 'zoo'}],
+       [CloneRepo, {'name' => 'foo'}],
+      ]
+    end
+
+    def test_optimistic_case
+      expect_input(CloneRepo, {'name' => 'zoo'}, {'id' => '123'})
+      expect_input(CloneRepo, {'name' => 'foo'}, {'id' => '456'})
+      first_action, second_action = assert_scenario
+
+      assert_equal({'name' => 'zoo'}, first_action.input)
+      assert_equal({'id' => '123'},   first_action.output)
+      assert_equal({'name' => 'foo'}, second_action.input)
+      assert_equal({'id' => '456'},   second_action.output)
+    end
+
+  end
+end

data/test/dispatcher_test.rb

@@ -0,0 +1,108 @@
+require 'test_helper'
+
+module Dynflow
+
+  describe Dispatcher do
+    class Promotion < Action
+
+      def plan(repo_names, package_names)
+        repo_names.each do |repo_name|
+          plan_action(CloneRepo, {'name' => repo_name})
+        end
+
+        package_names.each do |package_name|
+          plan_action(ClonePackage, {'name' => package_name})
+        end
+
+        plan_self('actions' => repo_names.size + package_names.size)
+      end
+
+      input_format do
+        param :actions, Integer
+      end
+
+    end
+
+    class PromotionObserver < Action
+
+      def self.subscribe
+        Promotion
+      end
+
+    end
+
+    class CloneRepo < Action
+
+      input_format do
+        param :name, String
+      end
+
+      output_format do
+        param :id, String
+      end
+
+    end
+
+    class ClonePackage < Action
+
+      input_format do
+        param :name, String
+      end
+
+      output_format do
+        param :id, String
+      end
+
+    end
+
+    class UpdateIndex < Action
+
+      def self.subscribe
+        ClonePackage
+      end
+
+      def plan(input)
+        plan_action(YetAnotherAction, {'hello' => 'world'})
+        super
+      end
+
+      output_format do
+        param :indexed_name, String
+      end
+
+    end
+
+    class YetAnotherAction < Action
+
+      input_format do
+        param :name, String
+        param :hello, String
+      end
+
+      output_format do
+        param :hello, String
+      end
+
+      def plan(arg)
+        plan_self(input.merge(arg))
+      end
+
+    end
+
+    it "builds the execution plan" do
+      execution_plan = Promotion.plan(['zoo', 'foo'], ['elephant'])
+      expected_plan =
+        [
+         [CloneRepo, {'name' => 'zoo'}],
+         [CloneRepo, {'name' => 'foo'}],
+         [ClonePackage, {'name' => 'elephant'}],
+         [YetAnotherAction, {'name' => 'elephant', 'hello' => 'world'}],
+         [UpdateIndex, {'name' => 'elephant'}],
+         [Promotion, {'actions' => 3 }],
+         [PromotionObserver, {'actions' => 3 }]
+        ]
+      execution_plan.must_equal expected_plan
+    end
+
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,83 @@
+require 'test/unit'
+require 'minitest/spec'
+require 'dynflow'
+
+BUS_IMPL = Dynflow::Bus::MemoryBus
+
+class TestBus < BUS_IMPL
+
+  def initialize(expected_scenario)
+    super()
+    @expected_scenario = expected_scenario
+  end
+
+  def process(action_class, input, output = nil, stub = true)
+    expected = @expected_scenario.shift
+    if action_class == TestScenarioFinalizer || !stub || output
+      return super(action_class, input, output)
+    elsif action_class.name == expected[:action_class].name && input == expected[:input]
+      return action_class.new(expected[:input], expected[:output])
+    else
+      raise "Unexpected input. Expected #{expected[:action_class]} #{expected[:input].inspect}, got #{action_class} #{input.inspect}"
+    end
+  end
+
+end
+
+class TestScenarioFinalizer < Dynflow::Action
+
+  class << self
+
+    def recorded_outputs
+      @recorded_outputs
+    end
+
+    def init_recorded_outputs
+      @recorded_outputs = []
+    end
+
+    def save_recorded_outputs(recorded_outputs)
+      @recorded_outputs = recorded_outputs
+    end
+
+  end
+
+  def finalize(outputs)
+    self.class.save_recorded_outputs(outputs)
+  end
+
+end
+
+class BusTestCase < Test::Unit::TestCase
+
+  def setup
+    @expected_scenario = []
+  end
+
+  def expect_input(action_class, input, output)
+    @expected_scenario << {
+      :action_class => action_class,
+      :input => input,
+      :output => output
+    }
+  end
+
+  def assert_scenario
+    Dynflow::Bus.impl = TestBus.new(@expected_scenario)
+    event_outputs = nil
+    TestScenarioFinalizer.init_recorded_outputs
+    execution_plan = self.execution_plan
+    execution_plan << [TestScenarioFinalizer, {}]
+    Dynflow::Bus.trigger(execution_plan)
+    return TestScenarioFinalizer.recorded_outputs
+  end
+end
+
+class ParticipantTestCase < Test::Unit::TestCase
+
+  def run_action(action_class, input)
+    Dynflow::Bus.impl = Dynflow::Bus.new
+    output = Dynflow::Bus.process(action_class, input)
+    return output
+  end
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: dynflow
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Ivan Necas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: apipie-params
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Generate and executed workflows dynamically based on input data and leave
+  it open for others to jump into it as well
+email:
+- inecas@redhat.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- dynflow.gemspec
+- examples/events.rb
+- examples/workflow.rb
+- lib/dynflow.rb
+- lib/dynflow/action.rb
+- lib/dynflow/bus.rb
+- lib/dynflow/dispatcher.rb
+- lib/dynflow/logger.rb
+- lib/dynflow/message.rb
+- lib/dynflow/orch_request.rb
+- lib/dynflow/orch_response.rb
+- lib/dynflow/version.rb
+- test/action_test.rb
+- test/bus_test.rb
+- test/dispatcher_test.rb
+- test/test_helper.rb
+homepage: http://github.com/iNecas/eventum
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: DYNamic workFLOW engine
+test_files:
+- test/action_test.rb
+- test/bus_test.rb
+- test/dispatcher_test.rb
+- test/test_helper.rb