weel 1.0.3

data/test/ContinueTest.rb

@@ -0,0 +1,25 @@
+vim ./wfp_state_based/tc_interleavedparallelrouting.rb
+vim ./wfp_state_based/tc_deferredchoice.rb
+vim ./wfp_iteration/tc_structuredloop.rb
+vim ./wfp_adv_branching
+vim ./wfp_adv_branching/tc_multichoice_structuredsynchronizingmerge.rb
+vim ./wfp_adv_branching/tc_generalsynchronizingmerge.rb
+vim ./wfp_adv_branching/tc_localsynchronizingmerge.rb
+vim ./wfp_adv_branching/tc_threadmerge.rb
+vim ./wfp_adv_branching/tc_generalizedjoin.rb
+vim ./wfp_adv_branching/tc_threadsplit.rb
+vim ./wfp_adv_branching/tc_multimerge.rb
+vim ./wfp_adv_branching/tc_structured_discriminator.rb
+vim ./wfp_adv_branching/tc_structured_partial_join.rb
+vim ./basic/tc_codereplace.rb
+vim ./basic/tc_data.rb
+vim ./basic/tc_handler.rb
+vim ./basic/tc_parallel.rb
+vim ./basic/tc_search.rb
+vim ./basic/tc_endpoint.rb
+vim ./basic/tc_wf_control.rb
+vim ./basic/tc_choose.rb
+vim ./basic/tc_state.rb
+vim ./wfp_basic/tc_exclusivechoice_simplemerge.rb
+vim ./wfp_basic/tc_sequence.rb
+vim ./wfp_basic/tc_parallelsplit_synchronization.rb

data/test/TestHandlerWrapper.rb

@@ -0,0 +1,120 @@
+class TestHandlerWrapper < WEEL::HandlerWrapperBase
+  def initialize(args,endpoint=nil,position=nil,continue=nil)
+    @__myhandler_stopped = false
+    @__myhandler_position = position
+    @__myhandler_continue = continue
+    @__myhandler_endpoint = endpoint
+    @__myhandler_returnValue = nil
+  end
+
+  # executes a ws-call to the given endpoint with the given parameters. the call
+  # can be executed asynchron, see finished_call & return_value
+  def activity_handle(passthrough, parameters)
+    $long_track << "CALL #{@__myhandler_position}: passthrough=[#{passthrough}], endpoint=[#{@__myhandler_endpoint}], parameters=[#{parameters.inspect}]\n"
+    $short_track << "C#{@__myhandler_position}"
+
+    if @__myhandler_endpoint == 'stop it'
+      raise WEEL::Signal::Stop
+    end
+    if parameters[:call]
+      @t = Thread.new do
+        parameters[:call].call
+        @__myhandler_returnValue = parameters.has_key?(:result) ? parameters[:result] : 'Handler_Dummy_Result'
+        @__myhandler_continue.continue
+      end   
+      # give nothing back 
+    else
+      @__myhandler_returnValue = parameters.has_key?(:result) ? parameters[:result] : 'Handler_Dummy_Result'
+      @__myhandler_continue.continue
+    end  
+  end
+ 
+  # returns the result of the last handled call
+  def activity_result_value
+    @__myhandler_returnValue
+  end
+  # Called if the WS-Call should be interrupted. The decision how to deal
+  # with this situation is given to the handler. To provide the possibility
+  # of a continue the Handler will be asked for a passthrough
+  def activity_stop
+    $long_track += "STOPPED #{@__myhandler_position}\n"
+    $short_track << "S#{@__myhandler_position}"
+    @t.exit if @t
+    @__myhandler_stopped = true
+  end
+  # is called from WEEL after stop_call to ask for a passthrough-value that may give
+  # information about how to continue the call. This passthrough-value is given
+  # to activity_handle if the workflow is configured to do so.
+  def activity_passthrough_value
+    "SOME passthrough"
+  end
+
+  # Called if the execution of the actual activity_handle is not necessary anymore
+  # It is definit that the call will not be continued.
+  # At this stage, this is only the case if parallel branches are not needed
+  # anymore to continue the workflow
+  def activity_no_longer_necessary
+    $long_track += "NO_LONGER_NECCESARY #{@__myhandler_position}\n"
+    $short_track << "NLN#{@__myhandler_position}"
+    @t.exit if @t
+    @__myhandler_returnValue = "No longer necessary"
+    @__myhandler_stopped = true
+  end
+  # Is called if a Activity is executed correctly
+  def inform_activity_manipulate
+    $long_track += "MANIPULATE #{@__myhandler_position}\n"
+    $short_track << "M#{@__myhandler_position}"
+  end
+  # Is called if a Activity is executed correctly
+  def inform_activity_done
+    $long_track += "DONE #{@__myhandler_position}\n"
+    $short_track << "D#{@__myhandler_position}"
+  end
+  # Is called if a Activity is executed with an error
+  def inform_activity_failed(err)
+    $long_track += "FAILED #{@__myhandler_position}: #{err}\n"
+    $short_track << "F#{@__myhandler_position}"
+    raise(err)
+  end
+  def inform_syntax_error(err,code)
+    $long_track += "ERROR: Syntax messed with error #{err}\n"
+    $short_track << "E"
+    raise(err)
+  end
+  def inform_state_change(newstate)
+    $long_track += "---> STATE #{newstate}\n"
+    $short_track << "|#{newstate}|"
+  end
+end
+
+module TestMixin #{{{
+  def setup
+    $long_track = ""
+    $short_track = ""
+    @wf = TestWorkflow.new
+  end
+
+  def teardown
+    @wf.stop.join
+    $long_track = ""
+    $short_track = ""
+  end
+
+  def wf_assert(what,cond=true)
+    if cond
+      assert($long_track.include?(what),"Missing \"#{what}\":\n#{$long_track}")
+    else  
+      assert(!$long_track.include?(what),"Missing \"#{what}\":\n#{$long_track}")
+    end
+  end
+  def wf_sassert(what,cond=true)
+    if cond
+      assert($short_track.include?(what),"#{$short_track}\nNot Present \"#{what}\":\n#{$long_track}")
+    else  
+      assert(!$short_track.include?(what),"#{$short_track}\nNot Present \"#{what}\":\n#{$long_track}")
+    end
+  end
+  def wf_rsassert(pat='')
+    assert($short_track =~ /#{pat}/,"Somehow executed different #{$short_track} should be '#{pat}'")
+  end
+end  #}}}

data/test/TestWorkflow.rb

@@ -0,0 +1,35 @@
+require File.expand_path(::File.dirname(__FILE__) + '/../lib/weel')
+require File.expand_path(::File.dirname(__FILE__) + '/TestHandlerWrapper')
+
+class TestWorkflow < WEEL
+  handlerwrapper TestHandlerWrapper
+
+  endpoint :endpoint1 => 'http://www.heise.de'
+  endpoint :stop => 'stop it'
+  data :x => 'begin_'
+  
+  control flow do
+    activity :a1_1, :call, :endpoint1 do |result|
+      data.x += "#{result}"
+    end
+    parallel :wait => 2 do
+      parallel_branch do
+        activity :a2_1_1, :call, :endpoint1
+      end
+      parallel_branch do
+        activity :a2_2_1, :call, :endpoint1
+      end
+    end
+    activity :a3, :manipulate do
+      data.x += '_end'
+    end
+    choose do
+      alternative data.x != nil do
+        activity :a4a, :call, :endpoint1
+      end
+      otherwise do
+        activity :a4b, :call, :endpoint1
+      end
+    end
+  end
+end

data/test/basic/tc_choose.rb

@@ -0,0 +1,82 @@
+require 'test/unit'
+require File.expand_path(::File.dirname(__FILE__) + '/../TestWorkflow')
+
+class TestChoose < Test::Unit::TestCase
+  include TestMixin
+
+  def test_choose_alternative
+    @wf.description do
+      choose do
+        alternative true do
+          activity :a_1, :call, :endpoint1
+        end
+        alternative false do
+          activity :a_2, :call, :endpoint1
+        end
+        otherwise do
+          activity :a_3, :call, :endpoint1
+        end
+      end
+    end
+    @wf.start.join
+    wf_assert("CALL a_1: passthrough=[], endpoint=[http://www.heise.de], parameters=[{}]")
+    wf_assert("CALL a_2:",false)
+    wf_assert("CALL a_3:",false)
+  end
+
+  def test_choose_otherwise
+    @wf.description do
+      choose do
+        alternative false do
+          activity :a_1, :call, :endpoint1
+        end
+        otherwise do
+          activity :a_2, :call, :endpoint1
+        end
+      end
+    end
+    @wf.start.join
+    wf_assert("CALL a_2: passthrough=[], endpoint=[http://www.heise.de], parameters=[{}]")
+    wf_assert("CALL a_1:",false)
+  end
+
+  def test_choose_nested
+    @wf.description do
+      choose do
+        alternative true do
+          choose do
+            alternative false do
+              activity :a_1_1, :call, :endpoint1
+            end
+            alternative true do
+              choose do
+                alternative false do
+                  activity :a_1_1_1, :call, :endpoint1
+                end
+                otherwise do
+                  activity :a_1_1_2, :call, :endpoint1
+                end
+              end
+            end
+            otherwise do
+              activity :a_1_3, :call, :endpoint1
+            end
+          end
+        end
+        otherwise do
+          activity :a_2, :call, :endpoint1
+        end
+      end
+    end
+    @wf.start.join
+    wf_assert("CALL a_1_1_2: passthrough=[], endpoint=[http://www.heise.de], parameters=[{}]",true)
+    wf_assert("CALL a_1_1:",false)
+    wf_assert("CALL a_1_1_1:",false)
+    wf_assert("CALL a_1_3:",false)
+    wf_assert("CALL a_2:",false)
+  end
+
+  def test_choose_searchmode
+    
+  end
+end

data/test/basic/tc_codereplace.rb

@@ -0,0 +1,38 @@
+require 'test/unit'
+require File.expand_path(::File.dirname(__FILE__) + '/../TestWorkflow')
+
+class TestCodeReplace < Test::Unit::TestCase
+  include TestMixin
+
+  def test_replace
+    @wf.description do
+      activity :a_test_1_1, :call, :endpoint1
+      activity :a_test_1_2, :call, :endpoint1
+      activity :a_test_1_3, :call, :endpoint1
+    end
+    @wf.search WEEL::Position.new(:a_test_1_1, :at)
+    @wf.start.join
+    wf_assert("CALL a_test_1_1:")
+    wf_assert("CALL a_test_1_2:")
+    wf_assert("CALL a_test_1_3:")
+    wf_sassert("|running|Ca_test_1_1Da_test_1_1Ca_test_1_2Da_test_1_2Ca_test_1_3Da_test_1_3|finished|")
+  end
+  #def test_wfdescription_string
+  #  ret = @wf.description "activity :b_test_1_1, :call, :endpoint1"
+  #  @wf.search WEEL::Position.new(:b_test_1_1, :at)
+  #  @wf.start.join
+  #  wf_assert("DONE b_test_1_1")
+  #  wf_sassert("|running|Cb_test_1_1Db_test_1_1|finished|")
+  #end
+  def test_wfdescription_block
+    ret = @wf.description do
+      activity :c_test_1_1, :call, :endpoint1
+      activity :c_test_1_2, :call, :endpoint1
+    end
+
+    assert(ret.class == Proc, "wf_description should be nil => not available. codeblock was given!")
+    @wf.search WEEL::Position.new(:c_test_1_2, :at)
+    @wf.start.join
+    wf_sassert("|running|Cc_test_1_2Dc_test_1_2|finished|")
+  end
+end

data/test/basic/tc_data.rb

@@ -0,0 +1,32 @@
+require 'test/unit'
+require File.expand_path(::File.dirname(__FILE__) + '/../TestWorkflow')
+
+class TestData < Test::Unit::TestCase
+  include TestMixin
+
+  def test_check_data
+    data = @wf.data
+    assert(data.is_a?(Hash), "data is not a Hash")
+    assert(data.size == 1, "data has not exactly 1 element, it has #{data.size}")
+    assert(data.keys[0] == :x, "data.keys[0] has not the correct value [#{data.keys[0]}]")
+    assert(data[:x] == "begin_", "data[:x] has not the correct value")
+  end
+  def test_set_data_variable
+    @wf.data[:a] = "test1"
+    data = @wf.data
+    assert(data.is_a?(Hash), "data is not a Hash")
+    assert(data.keys.include?(:a), "data has no key :a")
+    assert(data[:a] == "test1", "data[:a] has not the correct value [#{data[:x]}]")
+  end
+  def test_set_data
+    @wf.data[:x] = "test1"
+    @wf.data[:y] = "test2"
+    data = @wf.data
+    assert(data.is_a?(Hash), "data is not a Hash")
+    assert(data.size == 2, "data has not exactly 1 element, it has #{data.size}")
+    assert(data.keys.include?(:x), "data has no key x")
+    assert(data.keys.include?(:y), "data has no key y")
+    assert(data[:x] == "test1", "data[:x] has not the correct value [#{data[:x]}]")
+    assert(data[:y] == "test2", "data[:y] has not the correct value [#{data[:y]}]")
+  end
+end

data/test/basic/tc_endpoint.rb

@@ -0,0 +1,40 @@
+require 'test/unit'
+require File.expand_path(::File.dirname(__FILE__) + '/../TestWorkflow')
+
+class TestEndpoint < Test::Unit::TestCase
+  include TestMixin
+
+  def test_check_endpoint
+    ep1 = @wf.endpoints[:endpoint1]
+    assert(ep1.is_a?(String), "Endpoint1 is no string but should be")
+    assert(ep1 == "http://www.heise.de", "Endpoint1 has wrong value [#{ep1}]")
+  end
+  def test_create_endpoint
+    @wf.endpoint :endpoint2 => "http://www.test.at"
+    ep2 = @wf.endpoints[:endpoint2]
+    assert(ep2.is_a?(String), "Endpoint1 is no string but should be")
+    assert(ep2 == "http://www.test.at", "Endpoint1 has wrong value [#{ep2}]")
+  end
+  def test_change_endpoint
+    @wf.endpoint :endpoint1 => "http://www.newpoint.com"
+    ep1 = @wf.endpoints[:endpoint1]
+    assert(ep1.is_a?(String), "Endpoint1 is no string but should be")
+    assert(ep1 == "http://www.newpoint.com", "Endpoint1 has wrong value [#{ep1}]")
+  end
+  def test_change_endpoint2
+    @wf.endpoints[:endpoint1] = "http://www.newpoint2.com"
+    ep1 = @wf.endpoints[:endpoint1]
+    assert(ep1.is_a?(String), "Endpoint1 is no string but should be")
+    assert(ep1 == "http://www.newpoint2.com", "Endpoint1 has wrong value [#{ep1}]")
+  end
+
+  def test_endpoints
+    @wf.endpoint :endpoint2 => "http://www.test.at" # asure that there is endpoint1 & endpoint2
+    @wf.endpoints[:endpoint1]="http://www.test2.com" # asure that ep1 has original value
+    eps = @wf.endpoints
+    assert(eps.is_a?(Hash), "Endpoints should result a Hash but returns a #{eps.class}")
+    assert(eps.size == 3, "Endpoints should have two entries: #{eps.inspect}")
+    assert(eps[:endpoint1] == "http://www.test2.com", "Endpoint 1 has wrong value or does not exist: #{eps.inspect}")
+    assert(eps[:endpoint2] == "http://www.test.at", "Endpoint 2 has wrong value or does not exist: #{eps.inspect}")
+  end
+end

data/test/basic/tc_handler.rb

@@ -0,0 +1,19 @@
+require 'test/unit'
+require File.expand_path(::File.dirname(__FILE__) + '/../TestWorkflow')
+
+class TestCaseHandler < Test::Unit::TestCase
+  include TestMixin
+
+  def test_handler
+    assert_raise RuntimeError do
+      @wf.handlerwrapper = String
+    end
+    assert_nothing_raised do
+      @wf.handlerwrapper = TestHandlerWrapper
+    end
+  end
+  def test_handlerargs
+    @wf.handlerwrapper_args =  ["1", "2"]
+    assert(@wf.handlerwrapper_args.is_a?(Array), "Handler arguments is not an array, it is a #{@wf.handlerwrapper_args.inspect}")
+  end
+end

data/test/basic/tc_parallel.rb

@@ -0,0 +1,115 @@
+require 'test/unit'
+require File.expand_path(::File.dirname(__FILE__) + '/../TestWorkflow')
+
+class TestParallel < Test::Unit::TestCase
+  include TestMixin
+
+  def test_parallel_simple
+    @wf.description do
+      parallel do
+        parallel_branch do
+          activity :a_1, :call, :endpoint1, :call =>  Proc.new{ sleep 0.5 }
+        end
+        parallel_branch do
+          activity :a_2, :call, :endpoint1, :call =>  Proc.new{ sleep 0.5 }
+        end
+        parallel_branch do
+          activity :a_3, :call, :endpoint1, :call =>  Proc.new{ sleep 0.5 }
+        end
+      end
+    end
+    wf = @wf.start
+    sleep(0.25)
+    wf_assert("CALL a_1:")
+    wf_assert("CALL a_2:")
+    wf_assert("CALL a_3:")
+    wf.join
+    wf_assert("DONE a_1")
+    wf_assert("DONE a_2")
+    wf_assert("DONE a_3")
+  end
+  def test_parallel_wait
+    @wf.description do
+      parallel :wait do
+        parallel_branch do
+          activity :a_1, :call, :endpoint1
+        end
+        parallel_branch do
+          activity :a_2, :call, :endpoint1, :call =>  Proc.new{ sleep 0.5 }
+        end
+      end
+      activity :a_3, :call, :endpoint1
+    end
+    @wf.start.join
+    wf_assert('CALL a_1')
+    wf_assert('DONE a_1')
+    wf_assert('CALL a_2')
+    wf_sassert('Da_2Ca_3Da_3|finished|')
+  end
+  def test_parallel_nowait
+    @wf.description do
+      parallel :wait => 1 do
+        parallel_branch do
+          activity :a_1, :call, :endpoint1
+        end
+        parallel_branch do
+          activity :a_2, :call, :endpoint1, :call =>  Proc.new{ sleep 8.5 }
+        end
+      end
+      activity :a_3, :call, :endpoint1
+    end
+    @wf.start.join
+    wf_assert('CALL a_1')
+    wf_assert('CALL a_2')
+    wf_sassert('NLNa_2Ca_3Da_3|finished|')
+  end
+  def test_parallel_no_longer_necessary
+    @wf.description do
+      parallel :wait => 1 do
+        parallel_branch do
+          activity :a_1, :call, :endpoint1
+        end
+        parallel_branch do
+          activity :a_2, :call, :endpoint1, :call =>  Proc.new{ sleep 0.5 }
+          activity :a_2_2, :call, :endpoint1
+        end
+      end
+      activity :a_3, :call, :endpoint1
+    end
+    @wf.start.join
+    wf_assert('CALL a_1')
+    wf_assert('CALL a_2')
+    wf_sassert('NLNa_2Ca_3Da_3|finished|')
+  end
+  def test_parallel_nested
+    # |- :a_1
+    # |-|-|- :a_2_1_1
+    # |-|-|- :a_2_1_2
+    # |-|-|- => :a_2_1_3
+    # |-|- :a_2_2
+    # |-|- :a_2_3
+    # |- => :a_3
+    @wf.description do
+      parallel :wait do
+        parallel_branch do activity :a_1, :call, :endpoint1 end
+        parallel_branch do
+          parallel :wait do
+            parallel_branch do
+              parallel :wait do
+                parallel_branch do activity :a_2_1_1, :call, :endpoint1, :call => Proc.new {sleep 0.2} end
+                parallel_branch do activity :a_2_1_2, :call, :endpoint1, :call => Proc.new {sleep 0.4}  end
+              end
+              activity :a_2_1_3, :call, :endpoint1, :call => Proc.new {sleep 0.8} 
+            end
+            parallel_branch do activity :a_2_2, :call, :endpoint1, :call => Proc.new {sleep 0.8}  end
+            parallel_branch do activity :a_2_3, :call, :endpoint1, :call => Proc.new {sleep 1.0}  end
+          end
+        end
+      end
+      activity :a_3, :call, :endpoint1
+    end
+    @wf.start.join
+    nump = $long_track.split("\n").delete_if{|e| !(e =~ /^(DONE)/)}
+    assert(nump == ["DONE a_1", "DONE a_2_1_1", "DONE a_2_1_2", "DONE a_2_2", "DONE a_2_3", "DONE a_2_1_3", "DONE a_3"], "not in the right order, sorry")
+  end
+end