rbpm 0.0.1

data/test/rbpm_simple_tests.rb

@@ -0,0 +1,103 @@
+require 'test/unit'
+require 'rbpm'
+
+#a simple join node
+class MyNode
+  def action(token, caller)
+    token.workflow.class.log "mynode action"
+    
+    parent_token = token.parent
+    token.done
+    
+    result = parent_token.childs? ? nil : [[:default, parent_token]]
+    
+    token.workflow.class.log "wait for other tokens" unless result
+    
+    result
+  end
+end
+
+class DemoWorkflow < Workflow
+  
+  def initialize(do_fork)
+    super()
+    @do_fork = do_fork
+  end
+  
+  def self.log(s)
+    @@logs = [] unless defined? @@logs
+    @@logs << s
+  end
+  
+  def self.logs
+    @@logs
+  end
+  
+  start_node :start, :trans => :hello
+  
+  node :hello,
+      :on_enter => lambda { |token, caller| log "entering hello node - hello world" },
+      :trans => :hello2, 
+      :trans_action => lambda { |token, caller| log "leaving hello node using default transition" }
+  
+  node :hello2,
+       :trans => :end,
+       :my_other_trans => :hello3,
+       :my_other_trans_action => lambda { log "leaving using my_other transition" }
+            
+  def hello2_action(token, caller)
+    if @do_fork 
+      clazz.log "node hello2 decides to leave using the my_other transition"
+      return [[:my_other, token.fork], [:my_other, token.fork]]
+    else
+      #turns hello2 into a simple fork action 
+      clazz.log "node hello2 decides to leave using the default transition"
+      return [[:default, token]]
+    end
+  end
+  
+  node :hello3,
+      :on_enter => lambda { log "entering in hello3" },
+      :action_singleton => MyNode.new,
+      :trans => :end
+  
+  end_node :end,
+      :on_enter => lambda { log "entering end" }
+end
+
+class FirstRbpmTest < Test::Unit::TestCase
+  
+  def test_misc_with_fork
+    do_test_misc(true)
+  end
+  
+  def test_misc_without_fork
+    do_test_misc(false)
+  end
+  
+  def do_test_misc(do_fork)
+    wf = DemoWorkflow.new(do_fork)
+    
+    t = wf.start
+    
+    assert_equal :end, t.node   
+    
+    assert_equal "entering hello node - hello world", wf.class.logs.shift
+    assert_equal "leaving hello node using default transition", wf.class.logs.shift
+    
+    if do_fork
+      assert_equal "node hello2 decides to leave using the my_other transition", wf.class.logs.shift
+      assert_equal "leaving using my_other transition", wf.class.logs.shift
+      assert_equal "entering in hello3", wf.class.logs.shift
+      assert_equal "mynode action", wf.class.logs.shift
+      assert_equal "wait for other tokens", wf.class.logs.shift
+      assert_equal "leaving using my_other transition", wf.class.logs.shift
+      assert_equal "entering in hello3", wf.class.logs.shift
+      assert_equal "mynode action", wf.class.logs.shift
+    else
+      assert_equal "node hello2 decides to leave using the default transition", wf.class.logs.shift
+    end    
+    
+    assert_equal "entering end", wf.class.logs.shift
+  end
+end

data/test/rbpm_state_tests.rb

@@ -0,0 +1,61 @@
+require 'test/unit'
+require 'rbpm'
+
+class DemoWorkflow2 < Workflow
+  
+  def self.log(s)
+    @@logs = [] unless defined? @@logs
+    @@logs << s
+  end
+  
+  def self.logs
+    @@logs
+  end
+  
+  start_node :start, 
+      :on_enter => :my_start_enter_act,
+      :trans => :hello
+  
+  def my_start_enter_act(token, caller)
+    clazz.log "entering start" 
+  end
+  
+  state_node :hello, 
+      :on_enter => lambda { log "entering hello" },
+      :trans => :end
+  
+  end_node :end
+  
+  def end_on_enter(token, caller)
+    clazz.log "entering end"
+  end
+end
+
+class StateRbpmTest < Test::Unit::TestCase
+
+  def test_state_and_persistence
+    wf = DemoWorkflow2.new()
+    t = wf.start
+    
+    assert_equal "entering start", wf.class.logs.shift
+    assert_equal "entering hello", wf.class.logs.shift
+    assert_equal :hello, t.node   
+    
+    File.open("demo_wf_2.txt", "w+") do |f|
+      Marshal.dump(wf, f)
+    end
+    
+    wf, t = nil, nil
+    File.open("demo_wf_2.txt") do |f|
+      wf = Marshal.load(f)
+    end
+    t = wf.tokens[0]
+    
+    assert_equal :hello, t.node
+    
+    t.signal
+    
+    assert_equal "entering end", wf.class.logs.shift
+    assert_equal :end, t.node
+  end
+end

data/test/rbpm_transition_tests.rb

@@ -0,0 +1,94 @@
+require 'test/unit'
+require 'rbpm'
+
+$mylog = {}
+
+class TWf1 < Workflow
+  start_node :start, 
+      :trans => :end,
+      :trans_action => :my_trans_action
+  end_node :end
+  
+  def my_trans_action(token, caller)
+    $mylog[:trans_action] = true
+  end
+end
+
+class TWf2 < Workflow
+  start_node :start, 
+      :trans => :end,
+      :trans_action => :my_trans_action
+  end_node :end
+  
+  def self.my_trans_action(token, caller)
+    $mylog[:trans_action] = true
+  end
+end
+
+class TWf3 < Workflow
+  start_node :start, :trans => :end
+  end_node :end
+  
+  def start_default_trans_action(token, caller)
+    $mylog[:trans_action] = true
+  end
+end
+
+class TWf4 < Workflow
+  start_node :start, :foo_trans => :end
+  end_node :end
+  
+  def start_foo_trans_action(token, caller)
+    $mylog[:trans_action] = true
+  end
+end
+
+class TWf5 < Workflow
+  start_node :start, :trans => :end
+  end_node :end
+  
+  def self.start_default_trans_action(token, caller)
+    $mylog[:trans_action] = true
+  end
+end
+
+class TWf6 < Workflow
+  start_node :start, 
+      :trans => :end,
+      :trans_action => lambda { $mylog[:trans_action] = true }
+  end_node :end
+end
+
+class TWf7 < Workflow
+  start_node :start, 
+      :no_trans => :no_end, 
+      :no_trans_cond => '"no" == token[:my_cond]',
+      :yes_trans => :yes_end,
+      :yes_trans_cond => '"yes" == token[:my_cond]'
+  end_node :no_end
+  end_node :yes_end
+end
+
+class FewMoreRbpm2Test < Test::Unit::TestCase
+
+  def test_transition_ctions
+    [TWf1, TWf2, TWf3, TWf4, TWf5, TWf6].each do |workflow|
+      wf1 = workflow.new
+    
+      $mylog.clear
+      
+      t = wf1.start()
+      
+      assert_equal :end, t.node   
+      assert_not_nil $mylog[:trans_action]
+    end
+  end
+  
+  def test_transition_conditions
+    ["no", "yes"].each do |no_yes|
+      wf = TWf7.new
+      t = wf.start :my_cond => no_yes
+      assert_equal (no_yes + "_end").to_sym, t.node
+    end
+  end
+end

data/test/rbpm_versionning_tests.rb

@@ -0,0 +1,44 @@
+require 'test/unit'
+require 'rbpm'
+
+module FooBarWorkflowVersion1
+  class FooBarWorkflow 
+    def foo
+      "v1"
+    end
+    def bar
+      WorkflowVersionManager.create_workflow_instance('FooBarWorkflow', 1).foo
+    end
+  end
+end
+
+module FooBarWorkflowVersion3
+  class FooBarWorkflow 
+    def foo
+      "v3"
+    end
+  end
+end
+
+module FooBarWorkflowVersion2
+  class FooBarWorkflow 
+    def foo
+      "v2"
+    end
+    def bar
+      WorkflowVersionManager.create_workflow_instance('FooBarWorkflow').foo
+    end
+  end
+end
+
+class VersionningTests < Test::Unit::TestCase
+
+  def test_versionning
+    assert_equal "v3", WorkflowVersionManager.create_workflow_instance('FooBarWorkflow').foo
+    assert_equal "v3", WorkflowVersionManager.create_workflow_instance('FooBarWorkflow', 2).bar
+    assert_equal "v1", WorkflowVersionManager.create_workflow_instance('FooBarWorkflow', 1).bar
+    (1..3).each do |version|
+      assert_equal "v#{version}", WorkflowVersionManager.create_workflow_instance('FooBarWorkflow', version).foo
+    end
+  end
+end

data/test/ruby_lang_tests.rb

@@ -0,0 +1,116 @@
+require 'test/unit'
+
+class FooClazz
+  def self.foo
+    "outer"
+  end
+end
+
+class FooBarClazz
+  def self.foo
+    "foobar"
+  end
+end
+
+module BarModule
+  class BarClazz
+    def self.foo
+      "bar"
+    end
+  end
+  
+  class FooClazz
+    def self.foo
+      "inner"
+    end
+  end
+  
+  class Test
+    def self.foo
+      return FooClazz.foo + ":" + BarClazz.foo + ":" + FooBarClazz.foo
+    end
+  end
+end
+
+$MY_V1 = <<-ecode
+module MyV1
+  class MyClass
+    def foo
+      "v1"
+    end
+  end
+end
+ecode
+
+$MY_V1_B = <<-ecode
+module MyV1
+  class MyClass
+    def foo
+      "v1b"
+    end
+  end
+end
+ecode
+
+$MY_V2 = <<-ecode
+module MyV2
+  class MyClass
+    def foo
+      "v2"
+    end
+  end
+end
+ecode
+
+class SimpleRubyLangTests < Test::Unit::TestCase
+
+ def test_if_stuff
+   a = 1
+   a = 2 if false
+   assert_equal 1, a
+   b = 1 if false
+   assert_nil b
+ end
+
+  def test_regexp
+    a = "willi"
+    assert_not_nil "a_willi_b" =~ /_#{a}_/
+    assert_nil "a-willi_b" =~ /_#{a}_/
+  end
+
+  def test_class_loading_stuff
+    m_before = []
+    ObjectSpace.each_object(Module) do |m|
+      m_before << m.to_s
+    end
+    
+    assert_nil defined? MyV1::MyClass
+    assert_nil defined? MyV2::MyClass
+
+    eval($MY_V1)
+    assert_equal "v1", MyV1::MyClass.new.foo
+    
+    assert_not_nil defined? MyV1::MyClass
+    assert_nil defined? MyV2::MyClass
+    
+    eval($MY_V2)
+    assert_equal "v2", MyV2::MyClass.new.foo
+    
+    eval($MY_V1_B)
+    assert_equal "v1b", MyV1::MyClass.new.foo
+    
+    m_after = []
+    ObjectSpace.each_object(Module) do |m|
+      m_after << m.to_s
+    end
+    
+    m_new = m_after - m_before
+    assert_equal 4, m_new.length #2 * (Module + Class within Module)
+    
+    #puts m_new.join(", ") #=> SimpleRubyLangTests::MyV2::MyClass, SimpleRubyLangTests::MyV2, SimpleRubyLangTests::MyV1::MyClass, SimpleRubyLangTests::MyV1
+  end
+
+  def test_misc
+    assert_equal "inner:bar:foobar", BarModule::Test.foo
+  end
+end

data/test/ts_all.rb

@@ -0,0 +1,14 @@
+require 'test/unit'
+
+require 'test/rbpm_action_tests'
+require 'test/rbpm_ctxvars_tests.rb'           
+require 'test/rbpm_simple_tests.rb'            
+require 'test/rbpm_versionning_tests.rb'
+require 'test/rbpm_call_tests.rb'              
+require 'test/rbpm_exceptions_tests.rb'        
+require 'test/rbpm_state_tests.rb'             
+require 'test/rbpm_condition_tests.rb'         
+require 'test/rbpm_fork_join_tests.rb'       
+require 'test/rbpm_transition_tests.rb'        
+
+require 'test/ruby_lang_tests.rb'

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.10
+specification_version: 1
+name: rbpm
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2006-01-05
+summary: lightweight (jbpm-like) workflow framework
+require_paths: 
+  - lib
+email: furthermore@tschenett.ch
+homepage: http://rbpm.rubyforge.org
+rubyforge_project: 
+description: 
+autorequire: rbpm
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+authors: 
+  - Christian Tschenett
+files: 
+  - test/rbpm_action_tests.rb
+  - test/rbpm_call_tests.rb
+  - test/rbpm_condition_tests.rb
+  - test/rbpm_ctxvars_tests.rb
+  - test/rbpm_exceptions_tests.rb
+  - test/rbpm_fork_join_tests.rb
+  - test/rbpm_simple_tests.rb
+  - test/rbpm_state_tests.rb
+  - test/rbpm_transition_tests.rb
+  - test/rbpm_versionning_tests.rb
+  - test/ruby_lang_tests.rb
+  - test/ts_all.rb
+  - lib/rbpm.rb
+  - docs/sub_processes.png
+  - docs/todo.txt
+  - README
+test_files: 
+  - test/ts_all.rb
+rdoc_options: []
+extra_rdoc_files: 
+  - README
+executables: []
+extensions: []
+requirements: []
+dependencies: []