ruote-maestrodev 2.2.1

data/test/functional/ft_20_storage_participant.rb

@@ -0,0 +1,543 @@
+
+#
+# testing ruote
+#
+# Thu Dec  3 22:39:03 JST 2009
+#
+
+require File.join(File.dirname(__FILE__), 'base')
+
+require 'ruote/part/storage_participant'
+
+
+class FtStorageParticipantTest < Test::Unit::TestCase
+  include FunctionalBase
+
+  def test_participant
+
+    pdef = Ruote.process_definition :name => 'def0' do
+      alpha
+    end
+
+    @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:alpha)
+
+    assert_equal 1, @engine.storage.get_many('workitems').size
+
+    alpha = Ruote::StorageParticipant.new
+    alpha.context = @engine.context
+
+    wi = alpha.first
+
+    assert_equal Ruote::Workitem, wi.class
+
+    wi = alpha[alpha.first.fei]
+    assert_equal Ruote::Workitem, wi.class
+
+    alpha.proceed(wi)
+
+    wait_for(wfid)
+
+    assert_nil @engine.process(wfid)
+  end
+
+  def test_purge
+
+    pdef = Ruote.process_definition :name => 'def0' do
+      alpha
+    end
+
+    @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:alpha)
+
+    assert_equal 1, @engine.storage.get_many('workitems').size
+
+    alpha = Ruote::StorageParticipant.new
+    alpha.context = @engine.context
+
+    assert !alpha.first.nil?
+
+    alpha.purge!
+
+    assert alpha.first.nil?
+  end
+
+  def test_all
+
+    n = 3
+
+    pdef = Ruote.process_definition :name => 'def0' do
+      alpha
+    end
+
+    @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    wfids = []
+
+    n.times { wfids << @engine.launch(pdef) }
+
+    while @engine.storage_participant.size < n
+      sleep 0.400
+    end
+
+    assert_equal(
+      [ Ruote::Workitem ] * 3,
+      @engine.storage_participant.all.collect { |wi| wi.class })
+
+    assert_equal 3, @engine.storage_participant.size
+    assert_equal 3, @engine.storage_participant.all(:count => true)
+  end
+
+  def test_by_wfid
+
+    pdef = Ruote.process_definition :name => 'def0' do
+      concurrence do
+        alpha
+        alpha
+      end
+    end
+
+    @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:alpha)
+    wait_for(:alpha)
+      # wait for the two workitems
+
+    alpha = Ruote::StorageParticipant.new
+    alpha.context = @engine.context
+
+    assert_equal 2, alpha.size
+    assert_equal 2, alpha.by_wfid(wfid).size
+    assert_equal 2, alpha.by_wfid(wfid, :count => true)
+  end
+
+  CON_AL_BRAVO = Ruote.process_definition :name => 'con_al_bravo' do
+    set 'f:place' => 'heiankyou'
+    concurrence do
+      sequence do
+        set 'f:character' => 'minamoto no hirosama'
+        alpha
+      end
+      sequence do
+        set 'f:character' => 'seimei'
+        set 'f:adversary' => 'doson'
+        bravo
+      end
+    end
+  end
+
+  def prepare_al_bravo
+
+    @engine.register_participant :alpha, Ruote::StorageParticipant
+    @engine.register_participant :bravo, Ruote::StorageParticipant
+
+    @wfid = @engine.launch(CON_AL_BRAVO)
+
+    wait_for(:bravo)
+
+    @part = Ruote::StorageParticipant.new
+    @part.context = @engine.context
+  end
+
+  def test_by_participant
+
+    prepare_al_bravo
+
+    assert_equal 2, @part.size
+    #@part.by_participant('alpha').each { |wi| p wi }
+    assert_equal Ruote::Workitem, @part.by_participant('alpha').first.class
+    assert_equal 1, @part.by_participant('alpha').size
+    assert_equal 1, @part.by_participant('bravo').size
+
+    assert_equal 1, @part.by_participant('alpha', :count => true)
+    assert_equal 1, @part.by_participant('bravo', :count => true)
+  end
+
+  def test_by_participant_and_limit
+
+    3.times do |i|
+      @engine.storage.put(
+        'type' => 'workitems',
+        '_id' => "0_#{i}!ffffff!20101219-yamamba",
+        'participant_name' => 'al',
+        'wfid' => '20101220-yamamba',
+        'fields' => {})
+    end
+    3.times do |i|
+      @engine.storage.put(
+        'type' => 'workitems',
+        '_id' => "1_#{i}!eeeeee!20101219-yamamba",
+        'participant_name' => 'bob',
+        'wfid' => '20101220-yamamba',
+        'fields' => {})
+    end
+
+    sp = @engine.storage_participant
+
+    assert_equal 6, sp.size
+
+    assert_equal 0, sp.by_participant('nada', :limit => 2).size
+    assert_equal 2, sp.by_participant('al', :limit => 2).size
+    assert_equal 2, sp.by_participant('al', :skip => 0, :limit => 2).size
+    assert_equal 2, sp.by_participant('al', :skip => 1, :limit => 2).size
+
+    assert_equal 2, sp.by_participant('bob', :skip => 0, :limit => 2).size
+    assert_equal 1, sp.by_participant('bob', :skip => 2, :limit => 2).size
+  end
+
+  def test_by_field
+
+    prepare_al_bravo
+
+    assert_equal 2, @part.size
+    assert_equal Ruote::Workitem, @part.by_field('place').first.class
+    assert_equal 2, @part.by_field('place').size
+    assert_equal 2, @part.by_field('character').size
+    assert_equal 1, @part.by_field('adversary').size
+    assert_equal 2, @part.by_field('character', :count => true)
+  end
+
+  def test_by_field_and_limit
+
+    prepare_al_bravo
+
+    assert_equal(
+      %w[ bravo ],
+      @part.by_field(
+        'character', :skip => 1, :limit => 2
+      ).collect { |wi| wi.participant_name })
+  end
+
+  def test_by_field_and_value
+
+    prepare_al_bravo
+
+    assert_equal 2, @part.size
+    assert_equal 0, @part.by_field('place', 'nara').size
+    assert_equal 2, @part.by_field('place', 'heiankyou').size
+    assert_equal 1, @part.by_field('character', 'minamoto no hirosama').size
+    assert_equal 2, @part.by_field('place', 'heiankyou', :count => true)
+  end
+
+  def test_query
+
+    prepare_al_bravo
+
+    wfid2 = @engine.launch(CON_AL_BRAVO, 'adversary' => 'B')
+    wait_for(:bravo)
+
+    #@part.query({}).each { |wi| puts '-' * 80; p wi }
+
+    assert_equal 4, @part.size
+    assert_equal 4, @part.query({}).size
+    assert_equal Ruote::Workitem, @part.query({}).first.class
+    assert_equal 2, @part.query(:wfid => @wfid).size
+    assert_equal 0, @part.query('place' => 'nara').size
+    assert_equal 4, @part.query('place' => 'heiankyou').size
+    assert_equal 2, @part.query(:wfid => @wfid, :place => 'heiankyou').size
+
+    assert_equal(
+      1,
+      @part.query(:adversary => 'B', :place => 'heiankyou').size)
+
+    assert_equal 2, @part.query('place' => 'heiankyou', :limit => 2).size
+    assert_equal 4, @part.query('place' => 'heiankyou', :limit => 20).size
+
+    assert_equal 4, @part.query(:count => true)
+
+    page0 =
+      @part.query('place' => 'heiankyou', :limit => 2).collect { |wi|
+        "#{wi.fei.wfid}-#{wi.participant_name}" }
+    page1 =
+      @part.query('place' => 'heiankyou', :offset => 2, :limit => 2).collect { |wi|
+        "#{wi.fei.wfid}-#{wi.participant_name}" }
+
+    assert_equal 4, (page0 + page1).sort.uniq.size
+
+    assert_equal(
+      2, @part.query('place' => 'heiankyou', :participant => 'alpha').size)
+
+    assert_equal 2, @part.query(:participant => 'alpha').size
+    assert_equal 2, @part.query(:participant => 'alpha', :count => true)
+  end
+
+  # Issue reported in
+  # http://groups.google.com/group/openwferu-users/browse_thread/thread/d0557c58f8636c9
+  #
+  def test_query_and_limit
+
+    n = 7
+
+    n.times do |i|
+      @engine.storage.put(
+        'type' => 'workitems',
+        '_id' => "0_#{i}!ffffff!20101219-yamamba",
+        'participant_name' => 'al',
+        'wfid' => '20101219-yamamba',
+        'fields' => {})
+    end
+    n.times do |i|
+      @engine.storage.put(
+        'type' => 'workitems',
+        '_id' => "1_#{i}!ffffff!20101219-yamamba",
+        'participant_name' => 'bob',
+        'wfid' => '20101219-yamamba',
+        'fields' => {})
+    end
+
+    sp = @engine.storage_participant
+
+    assert_equal n * 2, sp.query({}).size
+    assert_equal n * 2, sp.query(:offset => 0, :limit => 100).size
+    assert_equal n * 2, sp.query(:skip => 0, :limit => 100).size
+
+    assert_equal n / 2, sp.query(:offset => 0, :limit => n / 2).size
+    assert_equal n / 2, sp.query(:skip => 0, :limit => n / 2).size
+
+    assert_equal(
+      n / 2,
+      sp.query(:participant_name => 'al', :offset => 0, :limit => n / 2).size)
+    assert_equal(
+      n / 2,
+      sp.query(:participant_name => 'al', :skip => 0, :limit => n / 2).size)
+
+    assert_equal(
+      [ 'al' ] * (n / 2),
+      sp.query(
+        :participant_name => 'al', :skip => 0, :limit => n / 2
+      ).collect { |wi| wi.participant_name })
+  end
+
+  def test_initialize_engine_then_opts
+
+    @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    wfid = @engine.launch(Ruote.process_definition do
+      alpha
+    end)
+
+    wait_for(:alpha)
+
+    part = Ruote::StorageParticipant.new(@engine)
+
+    assert_equal 1, part.size
+  end
+
+  def test_cancel
+
+    pdef = Ruote.process_definition :name => 'def0' do
+      alpha
+    end
+
+    @engine.register_participant :alpha, Ruote::StorageParticipant
+
+    #noisy
+
+    wfid = @engine.launch(pdef)
+
+    wait_for(:alpha)
+
+    @engine.cancel_process(wfid)
+
+    wait_for(wfid)
+
+    assert_nil @engine.process(wfid)
+    assert_equal 0, Ruote::StorageParticipant.new(@engine).size
+  end
+
+  def test_shared_participant
+
+    @engine.register_participant 'step_.*', Ruote::StorageParticipant
+
+    wfid = @engine.launch(
+      Ruote.process_definition { sequence { step_one; step_two } })
+
+    wait_for(:step_one)
+
+    participant = Ruote::StorageParticipant.new(@engine)
+
+    items = participant.by_wfid(wfid)
+
+    assert_equal 1, participant.size
+    assert_equal 1, items.size
+    assert_equal 'step_one', items.first.participant_name
+
+    participant.proceed(items.first)
+
+    wait_for(:step_two)
+
+    items = participant.by_wfid(wfid)
+
+    assert_equal 1, participant.size
+    assert_equal 1, items.size
+    assert_equal 'step_two', items.first.participant_name
+
+    participant.proceed(items.first)
+
+    wait_for(wfid)
+
+    assert_nil @engine.process(wfid)
+  end
+
+  def test_update_workitem
+
+    @engine.register_participant 'alpha', Ruote::StorageParticipant
+
+    wfid = @engine.launch(Ruote.process_definition { alpha })
+
+    alpha = Ruote::StorageParticipant.new(@engine)
+
+    wait_for(:alpha)
+
+    wi = alpha.first
+
+    wi.fields['jidai'] = 'heian'
+
+    alpha.update(wi)
+
+    assert_equal 'heian', alpha.first.fields['jidai']
+  end
+
+  def test_registration
+
+    pa = @engine.register_participant 'alpha', Ruote::StorageParticipant
+
+    assert_equal Ruote::StorageParticipant, pa.class
+
+    assert_equal [], pa.all
+  end
+
+  def test_various_args
+
+    sp = @engine.register_participant 'alpha', Ruote::StorageParticipant
+
+    wfid = @engine.launch(Ruote.process_definition { alpha })
+
+    wait_for(:alpha)
+
+    wi = sp.first
+
+    assert_equal wi, sp[wi]
+    assert_equal wi, sp[wi.fei]
+    assert_equal wi, sp[wi.to_h]
+    assert_equal wi, sp[wi.fei.to_h]
+    assert_equal wi, sp[wi.fei.to_storage_id]
+  end
+
+  def test_by_fei
+
+    sp = @engine.register_participant 'alpha', Ruote::StorageParticipant
+
+    wfid = @engine.launch(Ruote.process_definition { alpha })
+
+    wait_for(:alpha)
+
+    wi = sp.first
+
+    assert_equal wi, sp.by_fei(wi)
+    assert_equal wi, sp.by_fei(wi.fei)
+    assert_equal wi, sp.by_fei(wi.to_h)
+    assert_equal wi, sp.by_fei(wi.fei.to_h)
+    assert_equal wi, sp.by_fei(wi.fei.to_storage_id)
+  end
+
+  def test_engine_storage_participant
+
+    @engine.register_participant 'step_.*', Ruote::StorageParticipant
+
+    wfid = @engine.launch(Ruote.process_definition { step_one })
+
+    wait_for(:step_one)
+
+    assert_equal 1, @engine.storage_participant.size
+    assert_equal 'step_one', @engine.storage_participant.first.participant_name
+  end
+
+  class MyParticipant < Ruote::StorageParticipant
+    def consume(wi)
+      @context.tracer << "consume\n"
+      super
+    end
+    #def update(wi)
+    #  @context.tracer << "update\n"
+    #  super
+    #end
+  end
+
+  def test_override_update
+
+    pdef = Ruote.define do
+      alpha
+    end
+
+    @engine.register do
+      alpha MyParticipant
+    end
+
+    @engine.launch(pdef)
+    @engine.wait_for(:alpha)
+
+    part = @engine.participant(:alpha)
+
+    initial_rev = part.first.h['_rev']
+
+    part.update(part.first)
+
+    assert_not_equal initial_rev, part.first.h['_rev']
+    assert_equal %w[ consume ], @tracer.to_a
+  end
+
+  def test_fetch
+
+    @engine.register do
+      catchall
+    end
+
+    @engine.launch(Ruote.define do
+      alpha
+    end)
+
+    @engine.wait_for(:alpha)
+
+    fei = @engine.storage_participant.first.fei
+
+    wi = @engine.storage_participant.send(:fetch, fei)
+
+    assert_equal Hash, wi.class
+  end
+
+  # StorageParticipant includes Enumerable, therefore, it should respond
+  # to select...
+  #
+  # http://groups.google.com/group/openwferu-users/t/6b594fd141f5d4b1
+  #
+  def test_select
+
+    @engine.register { catchall }
+
+    @engine.launch(Ruote.define do
+      concurrence { alpha; bravo; charly }
+    end)
+
+    while @engine.storage_participant.size < 3; end
+
+    assert_equal(
+      1,
+      @engine.storage_participant.select { |wi|
+        wi.participant_name == 'bravo'
+      }.size)
+  end
+end
+