ruote-stomp 2.2.0.a

data/spec/participant_spec_kit.rb

@@ -0,0 +1,192 @@
+
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+
+describe RuoteStomp::ParticipantProxy, :type => :ruote do
+
+  it "supports 'forget' as participant attribute" do
+
+    pdef = ::Ruote.process_definition :name => 'test' do
+      sequence do
+        stomp :queue => 'test1', :forget => true
+        echo 'done.'
+      end
+    end
+
+    @engine.register_participant(:stomp, RuoteStomp::ParticipantProxy)
+
+    run_definition(pdef)
+
+    @tracer.to_s.should == 'done.'
+
+    begin
+      Timeout::timeout(10) do
+        @msg = nil
+        MQ.queue('test1', :durable => true).subscribe { |msg| @msg = msg }
+
+        loop do
+          break unless @msg.nil?
+          sleep 0.1
+        end
+      end
+    rescue Timeout::Error
+      violated "Timeout waiting for message"
+    end
+
+    @msg.should match(/^\{.*\}$/) # JSON message by default
+  end
+
+  it "supports 'forget' as participant option" do
+
+    pdef = ::Ruote.process_definition :name => 'test' do
+      sequence do
+        stomp :queue => 'test4'
+        echo 'done.'
+      end
+    end
+
+    @engine.register_participant(
+      :stomp, RuoteStomp::ParticipantProxy, 'forget' => true)
+
+    run_definition(pdef)
+
+    @tracer.to_s.should == "done."
+
+    begin
+      Timeout::timeout(5) do
+        @msg = nil
+        MQ.queue('test4', :durable => true).subscribe { |msg| @msg = msg }
+
+        loop do
+          break unless @msg.nil?
+          sleep 0.1
+        end
+      end
+    rescue Timeout::Error
+      violated "Timeout waiting for message"
+    end
+
+    @msg.should match(/^\{.*\}$/) # JSON message by default
+  end
+
+  it "supports custom messages instead of workitems" do
+
+    pdef = ::Ruote.process_definition :name => 'test' do
+      sequence do
+        stomp :queue => 'test2', :message => 'foo', :forget => true
+        echo 'done.'
+      end
+    end
+
+    @engine.register_participant(:stomp, RuoteStomp::ParticipantProxy)
+
+    run_definition(pdef)
+
+    @tracer.to_s.should == "done."
+
+    begin
+      Timeout::timeout(5) do
+        @msg = nil
+        MQ.queue('test2', :durable => true).subscribe { |msg| @msg = msg }
+
+        loop do
+          break unless @msg.nil?
+          sleep 0.1
+        end
+      end
+    rescue Timeout::Error
+      violated "Timeout waiting for message"
+    end
+
+    @msg.should == 'foo'
+  end
+
+  it "supports 'queue' as a participant option" do
+
+    pdef = ::Ruote.process_definition :name => 'test' do
+      sequence do
+        stomp :forget => true
+        echo 'done.'
+      end
+    end
+
+    @engine.register_participant(
+      :stomp, RuoteStomp::ParticipantProxy, 'queue' => 'test5')
+
+    run_definition(pdef)
+
+    @tracer.to_s.should == 'done.'
+
+    begin
+      Timeout::timeout(5) do
+        @msg = nil
+        MQ.queue('test5', :durable => true).subscribe { |msg| @msg = msg }
+
+        loop do
+          break unless @msg.nil?
+          sleep 0.1
+        end
+      end
+    rescue Timeout::Error
+      violated "Timeout waiting for message"
+    end
+  end
+
+  it "passes 'participant_options' over stomp" do
+
+    pdef = ::Ruote.process_definition :name => 'test' do
+      stomp :queue => 'test6', :forget => true
+    end
+
+    @engine.register_participant(:stomp, RuoteStomp::ParticipantProxy)
+
+    run_definition(pdef)
+
+    msg = nil
+
+    begin
+      Timeout::timeout(10) do
+
+        MQ.queue('test6', :durable => true).subscribe { |m| msg = m }
+
+        loop do
+          break unless msg.nil?
+          sleep 0.1
+        end
+      end
+    rescue Timeout::Error
+      violated "Timeout waiting for message"
+    end
+
+    wi = Rufus::Json.decode(msg)
+    params = wi['fields']['params']
+
+    params['queue'].should == 'test6'
+    params['forget'].should == true
+    params['participant_options'].should == { 'forget' => false, 'queue' => nil }
+  end
+
+  it "doesn't create 1 queue instance per delivery" do
+
+    pdef = ::Ruote.process_definition do
+      stomp :queue => 'test7', :forget => true
+    end
+
+    mq_count = 0
+    ObjectSpace.each_object(MQ) { |o| mq_count += 1 }
+
+    @engine.register_participant(:stomp, RuoteStomp::ParticipantProxy)
+
+    10.times do
+      run_definition(pdef)
+    end
+
+    sleep 1
+
+    count = 0
+    ObjectSpace.each_object(MQ) { |o| count += 1 }
+
+    count.should == mq_count + 1
+  end
+end
+

data/spec/receiver_spec.rb

@@ -0,0 +1,142 @@
+
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+require 'ruote/participant'
+
+
+describe RuoteStomp::Receiver do
+
+  after(:each) do
+    purge_engine
+  end
+
+  it "handles replies" do
+
+    pdef = Ruote.process_definition :name => 'test' do
+      set :field => 'foo', :value => 'foo'
+      sequence do
+        echo '${f:foo}'
+        stomp :queue => '/queue/test3'
+        echo '${f:foo}'
+      end
+    end
+
+    @engine.register_participant(:stomp, RuoteStomp::ParticipantProxy)
+
+    RuoteStomp::Receiver.new(@engine)
+
+    wfid = @engine.launch(pdef)
+
+    workitem = nil
+
+    begin
+      Timeout::timeout(5) do
+
+        # MQ.queue('test3', :durable => true).subscribe { |msg|
+        #   wi = Ruote::Workitem.new(Rufus::Json.decode(msg))
+        #   workitem = wi if wi.wfid == wfid
+        # }
+        
+        $stomp.subscribe("/queue/test3", {}) do |message|
+          wi = Ruote::Workitem.new(Rufus::Json.decode(message.body))
+          workitem = wi if wi.wfid == wfid
+        end
+
+        loop do
+          break unless workitem.nil?
+          sleep 0.1
+        end
+      end
+    rescue Timeout::Error
+      fail "Timeout waiting for message"
+    end
+
+    workitem.fields['foo'] = "bar"
+
+    #MQ.queue('ruote_workitems', :durable => true).publish(Rufus::Json.encode(workitem.to_h), :persistent => true)
+    $stomp.publish '/queue/ruote_workitems', 
+      Rufus::Json.encode(workitem.to_h), 
+      { :persistent => true }
+    @engine.wait_for(wfid)
+
+    @engine.should_not have_errors
+    @engine.should_not have_remaining_expressions
+
+    @tracer.to_s.should == "foo\nbar"
+  end
+
+  it "launches processes" do
+
+    json = {
+      'definition' => %{
+        Ruote.process_definition :name => 'test' do
+          sequence do
+            echo '${f:foo}'
+          end
+        end
+      },
+      'fields' => { 'foo' => 'bar' }
+    }.to_json
+
+    RuoteStomp::Receiver.new(@engine, :launchitems => true, :unsubscribe => true)
+
+    # MQ.queue(
+    #   'ruote_workitems', :durable => true
+    # ).publish(
+    #   json, :persistent => true
+    # )
+    
+    $stomp.publish '/queue/ruote_workitems', json, { :persistent => true }
+    
+
+    sleep 0.5
+
+    @engine.should_not have_errors
+    @engine.should_not have_remaining_expressions
+
+    @tracer.to_s.should == 'bar'
+  end
+
+  it 'accepts a custom :queue' do
+
+    RuoteStomp::Receiver.new(
+      @engine, :queue => '/queue/mario', :launchitems => true, :unsubscribe => true)
+
+    @engine.register_participant 'alpha', Ruote::StorageParticipant
+
+    json = Rufus::Json.encode({
+      'definition' => "Ruote.define { alpha }"
+    })
+
+    # MQ.queue(
+    #   'ruote_workitems', :durable => true
+    # ).publish(
+    #   json, :persistent => true
+    # )
+    
+    $stomp.publish '/queue/ruote_workitems', 
+      json, 
+      { :persistent => true }
+
+    sleep 1
+
+    @engine.processes.size.should == 0
+      # nothing happened
+
+    # MQ.queue(
+    #   'mario', :durable => true
+    # ).publish(
+    #   json, :persistent => true
+    # )
+    
+    $stomp.publish '/queue/mario', 
+      json, 
+      { :persistent => true }
+
+    sleep 1
+
+    @engine.processes.size.should == 1
+      # launch happened
+  end
+end
+

data/spec/receiver_spec_kit.rb

@@ -0,0 +1,126 @@
+
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+require 'ruote/participant'
+
+
+describe RuoteStomp::Receiver do
+
+  after(:each) do
+    purge_engine
+  end
+
+  it "handles replies" do
+
+    pdef = Ruote.process_definition :name => 'test' do
+      set :field => 'foo', :value => 'foo'
+      sequence do
+        echo '${f:foo}'
+        stomp :queue => 'test3'
+        echo '${f:foo}'
+      end
+    end
+
+    @engine.register_participant(:stomp, RuoteStomp::ParticipantProxy)
+
+    RuoteStomp::Receiver.new(@engine)
+
+    wfid = @engine.launch(pdef)
+
+    workitem = nil
+
+    begin
+      Timeout::timeout(5) do
+
+        MQ.queue('test3', :durable => true).subscribe { |msg|
+          wi = Ruote::Workitem.new(Rufus::Json.decode(msg))
+          workitem = wi if wi.wfid == wfid
+        }
+
+        loop do
+          break unless workitem.nil?
+          sleep 0.1
+        end
+      end
+    rescue Timeout::Error
+      violated "Timeout waiting for message"
+    end
+
+    workitem.fields['foo'] = "bar"
+
+    MQ.queue('ruote_workitems', :durable => true).publish(Rufus::Json.encode(workitem.to_h), :persistent => true)
+
+    @engine.wait_for(wfid)
+
+    @engine.should_not have_errors
+    @engine.should_not have_remaining_expressions
+
+    @tracer.to_s.should == "foo\nbar"
+  end
+
+  it "launches processes" do
+
+    json = {
+      'definition' => %{
+        Ruote.process_definition :name => 'test' do
+          sequence do
+            echo '${f:foo}'
+          end
+        end
+      },
+      'fields' => { 'foo' => 'bar' }
+    }.to_json
+
+    RuoteStomp::Receiver.new(@engine, :launchitems => true, :unsubscribe => true)
+
+    MQ.queue(
+      'ruote_workitems', :durable => true
+    ).publish(
+      json, :persistent => true
+    )
+
+    sleep 0.5
+
+    @engine.should_not have_errors
+    @engine.should_not have_remaining_expressions
+
+    @tracer.to_s.should == 'bar'
+  end
+
+  it 'accepts a custom :queue' do
+
+    #@engine.noisy = true
+
+    RuoteStomp::Receiver.new(
+      @engine, :queue => 'mario', :launchitems => true, :unsubscribe => true)
+
+    @engine.register_participant 'alpha', Ruote::StorageParticipant
+
+    json = Rufus::Json.encode({
+      'definition' => "Ruote.define { alpha }"
+    })
+
+    MQ.queue(
+      'ruote_workitems', :durable => true
+    ).publish(
+      json, :persistent => true
+    )
+
+    sleep 1
+
+    @engine.processes.size.should == 0
+      # nothing happened
+
+    MQ.queue(
+      'mario', :durable => true
+    ).publish(
+      json, :persistent => true
+    )
+
+    sleep 1
+
+    @engine.processes.size.should == 1
+      # launch happened
+  end
+end
+