estorm-message-processor 0.1.6 → 0.2.1

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    OWQ1NzMyOWVlMzEzZmFmZDE4NjIzODlhMjFhMjUyOTk0Yzg2ZWU2Zg==
-  data.tar.gz: !binary |-
-    MTIzYjcyZjFmOWMyMGQzZjAzNzJmODRmYjg3ZDE3ZGJiYjkzYWFmZQ==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    MDcwMjYxMDRkMDg1MWQ0MDYzODUyZmJlNmU0N2U5OTFhYmM3Yzc0ZGJhMTc5
-    NzU3YzU1ZTFhMThmM2IzYmUyNTJlMGQ2YWEyOWFmZDVlZDI4ZGZmOTI0YmM0
-    NzEyN2NhNjc5MWY2MmQxYWMwZDNmYzA2ZWQ4MGRkNmU4ODYzZTI=
-  data.tar.gz: !binary |-
-    MDExOGQwZDE1YTc0ODgzZmM0ZjYwY2E5Mjk3ODUxM2RmNGQyMThmYjg0Njc1
-    YmIyMzEzNDI2Y2ZlMTgzODNhMWVlMDg4Mzg4MzM1ZGYwMzM2ZmY3ZTZkMGRk
-    MzE3MGFkZTYyMDc0NzkwMzFhYjY3MDQ3OTI3YjI2YWEyZmY1Y2U=
+SHA1:
+  metadata.gz: 2b81f8b2169e098058d7854e7aa8c485575d545f
+  data.tar.gz: 1503e3b04071f9874f3412d6a5d40e4ee3c41245
+SHA512:
+  metadata.gz: d799962de1b19fca425f5e875339ea1c8de9fba92d3f012a42c92ba07113e38b8cc78595bc4cc262349ea654ffbe74f222bf910abb1aa8c885352d09bc35781c
+  data.tar.gz: a8160bd65e5e878a7b2df3f04eba6f85e97bab2e7618bf6d9f23d482ce2765b3944c97d29e8722c35a99e30890c943f908b449d8651c19c2fdb5fa104e5ca14c

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    estorm-message-processor (0.1.6)
+    estorm-message-processor (0.2.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -6,17 +6,17 @@ estorm-message-processor gem
 ============
 
 
-Simple gem to use in rails apps for AMQP inclusiong. Send a hash via AMQP and then have the message processor process the files.  See the test pages
+Simple gem to use in rails apps for AMQP inclusion. Send a hash via AMQP and then have the message processor process the files.  See the test pages
 
 Usage
 =======
 
-pull in the normal files for ruby.  Everytime a message is received with 'command' => "sendtemplates" delegate to that callback So add more delegate_routings and you will be able to handle multiple commands
+pull in the normal files for ruby.  Everytime a message is received with 'command' => "sendtemplates" delegated to that callback So add more delegate_routings and you will be able to handle multiple commands
 
 ## Setup delegate processor
-This is the callback processor
+This is the callback processor in the consumer.  Just define this in your script with the name of procedure like delegate_XXXXX
 
-    class EstormMessageProcessor::Base
+    class EstormMessageProcessor::Consumer
     def delegate_sendtemplates(cmdhash)
     p=Promotion.find(cmdhash['promotion'].to_i)
     data=YAML.load(p.data)
@@ -27,18 +27,18 @@ This is the callback processor
 
 # Start the Message Processor
     begin
-    config={:url => AMQPURL,:connecturlflag=> Rails.env.production? ,:queuename => CONTACT_MESSAGE, :blocking => true}
+    config={:url => AMQPURL,:connecturlflag=> Rails.env.production? ,:queuename => CONTACT_MESSAGE, :blocking => true, :timeout => 0, :consumer_name => "test consumer"}
     #puts "Starting SMS Gateway. Please check the log at #{LOGFILE}"
     EstormMessageProcessor::Base.logger=Logger.new(STDOUT) 
     puts "Starting Bunny Contact Processor on #{config.inspect} "  
     mp = EstormMessageProcessor::Base.new
-    mp.start(config)
+    mp.start(config)  # THIS MAY NEED TO BE IN a THREAD
     rescue Exception => ex
     puts "Exception in Message Processor: #{ex} at #{ex.backtrace.join("\n")}"
     end  
 
 # send a message using the client
-Use the client to send a message to the delegate processor (background task)
+Use the client to send a message to the delegate processor (background task). Note the command set to the callback processor above.  You can also see multiple sends in the test files.
 
     def bunny_send
     cmdhash={'command'=>'sendtemplates', 'promotion'=>self.id.to_s}
@@ -47,6 +47,6 @@ Use the client to send a message to the delegate processor (background task)
     bunny.bunny_send(AMQPURL,Rails.env.production?,CONTACT_MESSAGE,cmdhash)
     end
 
-# config[:exit_when_empty] = true if you want to just process the messages in the queue
+# set the config[:timeout] value if you want the task to exit.  (eg supposedly this is how long until no message is received for the consumer to exist the processing loop)
 This is useful if you have a back ground task that you want to run occasionally and just process the messages and exit.  For example on heroku you can schedule a job to run every hour and it will process the messages and exit.  This will keep the costs down for the background task on heroku.  (Of course you need to ensure that the job time is shorter than the heroku scheduler time)
 

data/lib/estorm-message-processor/base.rb

@@ -4,7 +4,7 @@ require 'yaml'
 
 module EstormMessageProcessor
   class Base  
-       attr_reader :queue, :channel, :consumer
+       attr_reader :queue, :channel, :consumer, :conn
        # MT id counter.
        @@mt_id = 0
        def Base.logger
@@ -36,25 +36,34 @@ module EstormMessageProcessor
        end
 
        def tear_down_bunny
-          if @conn!=nil && @conn.open?
+          if @conn!=nil && @conn.open? && @channel!=nil && @channel.open?
+            sleep 1
             @consumer.cancel if @consumer!=nil && !@consumer.cancelled?
-            sleep 0.5
-            @conn.close if @channel != nil && @channel.open?
+            sleep 1
+          #  @queue.unsubscribe
+          #  @conn.close if @channel != nil && @channel.open?
+          #  sleep 0.5
           end
           msg= "closing bunny"
           logger.info msg
        end
+       
        def queue_mgmt(config)
           msg= "[*] Waiting for messages in #{@queue.name}.  blocking is #{config[:blocking]}"
           logger.info msg
           count=0
+        #  @channel.prefetch(1)   # set quality of service to only delivery one message at a time....
+          msg_count,consumer_count = @consumer.queue_statistics  # just to get the stats before entering hte queue
        #  @queue.subscribe(:block => config[:blocking]) do |delivery_info, properties, body|
          @consumer.on_delivery() do |delivery_info, metadata, payload|
             @consumer.process_messages(delivery_info,metadata,payload)
+       #     @consumer.channel.acknowledge(delivery_info.delivery_tag, false) if @consumer.channel!=nil && @consumer.channel.open?
             msg=   "ON DELIVERY: #{@consumer.count}: messages processed"
             logger.info msg
-            msg_count,consumer_count = @consumer.queue_statistics
-            @consumer.cancel if msg_count==0 and config[:exit_when_empty]
+             
+               # ack the message to get the next message
+            #msg_count,consumer_count = @consumer.queue_statistics  # POSSIBLE RACE CONDITION
+           # @consumer.cancel if msg_count==0 && config[:exit_when_empty]
            end
        end
        
@@ -62,21 +71,24 @@ module EstormMessageProcessor
        def start(config)
          msg= "Connecting to bunny environment #{config.inspect}"
          logger.info msg
-         config[:exit_when_empty]=false if config[:exit_when_empty]==nil
          setup_bunny_communications(config[:url],config[:connecturlflag],config[:queuename])
-         @consumer=EstormMessageProcessor::Consumer.new(@channel, @queue, config[:consumer_name], true, false, config)
+         #@consumer=EstormMessageProcessor::Consumer.new(@channel, @queue, config[:consumer_name], true, false, config)
+         @consumer=EstormMessageProcessor::Consumer.new(@channel, @queue)
+         
          @consumer.logger=logger
          raise "consumer creation problem" if @consumer==nil
          msg_count,consumer_count =@consumer.queue_statistics
          queue_mgmt(config)  
-         @queue.subscribe_with(@consumer, :block => config[:blocking])
-         
-         loop do   
+         # the block flag shuts down the thread. the timeout values says whether to unsubscriber
+         #need to set ack to true to manage the qos parameter
+        # retval= @queue.subscribe_with(@consumer,:ack => true, :block => config[:blocking], :timeout => config[:timeout])
+        #  retval= @queue.subscribe_with(@consumer,:ack => true, :block => config[:blocking])
+        retval= @queue.subscribe_with(@consumer, :block => config[:blocking])
+        # loop do   
              #should loop forever if blocking... otherwise needs  a loop
-            sleep 2
-            break if @consumer.cancelled?
-          end
-         msg= "Ending======about to tear_down_bunny...."
+         #   sleep 1
+        #  end
+         msg= "Ending======about to tear_down_bunny [retval: #{retval}]...."
          logger.info msg
          tear_down_bunny
            

data/lib/estorm-message-processor/client.rb

@@ -27,8 +27,9 @@ module EstormMessageProcessor
   def connection
     @conn
   end
-  def bunny_send_no_close(url,flag,queuename,cmdhash)
-    @conn,@channel=setup_bunny(url,flag)
+  #def bunny_send_no_close(url,flag,queuename,cmdhash)
+  def bunny_send_no_close(queuename,cmdhash)
+    # @conn,@channel=setup_bunny(url,flag)
     @queue    = @channel.queue(queuename)
     #cmdhash={'command'=>'sendtemplates', 'promotion'=>self.id.to_s}
     @channel.default_exchange.publish(cmdhash.to_yaml, :routing_key => @queue.name)

data/test/coverage/index.html

@@ -14,7 +14,7 @@
       <img src="./assets/0.7.1/loading.gif" alt="loading"/>
     </div>
     <div id="wrapper" style="display:none;">
-      <div class="timestamp">Generated <abbr class="timeago" title="2013-10-16T10:53:32+08:00">2013-10-16T10:53:32+08:00</abbr></div>
+      <div class="timestamp">Generated <abbr class="timeago" title="2013-10-17T08:53:34+08:00">2013-10-17T08:53:34+08:00</abbr></div>
       <ul class="group_tabs"></ul>
 
       <div id="content">

data/test/test_consumer.rb

@@ -27,8 +27,9 @@ class EstormConsumerProcessTest <  Minitest::Test
   end
   def test_cancel
     puts "testing consumer"
-    config={:url => 'fakeurl',:connecturlflag=> false,:queuename => 'testconsumerqueue', :blocking => true, :consumer_name => "test consumer"}
+    config={:url => 'fakeurl',:connecturlflag=> false,:queuename => 'testconsumerqueue', :blocking => true, :timeout => 0, :consumer_name => "test consumer"}
     @f.setup_bunny_communications(config[:url],config[:connecturlflag],config[:queuename])
+    assert @f.channel.open? , "channel should be open"
     @consumer = EstormMessageProcessor::Consumer.new(@f.channel, @f.queue)
      @consumer.logger=@f.logger
     assert !@consumer.cancelled?, "should not be cancelled"
@@ -39,7 +40,7 @@ class EstormConsumerProcessTest <  Minitest::Test
   end 
   def test_consumer_increment
      puts "testing consumer"
-     config={:url => 'fakeurl',:connecturlflag=> false,:queuename => 'testconsumerqueue', :blocking => true, :consumer_name => "test consumer"}
+     config={:url => 'fakeurl',:connecturlflag=> false,:queuename => 'testconsumerqueue',:timeout => 0, :blocking => true, :consumer_name => "test consumer"}
      @f.setup_bunny_communications(config[:url],config[:connecturlflag],config[:queuename])
      @consumer = EstormMessageProcessor::Consumer.new(@f.channel, @f.queue)
      @consumer.logger=@f.logger
@@ -49,9 +50,17 @@ class EstormConsumerProcessTest <  Minitest::Test
         assert @consumer.increment
         assert @consumer.count==2, "should  be 2 but is #{@consumer.count}"
    end
+    def test_qos
+      puts "test startup"
+      config={:url => 'fakeurl',:connecturlflag=> false,:queuename => 'testdelegatequeue', :timeout => 0,:blocking => true,:consumer_name => "test consumer delete startup consumer"}
+        cmdhash={'command'=>'testdelegate', 'temp'=>'test_delegate'}
+         @f.setup_bunny_communications(config[:url],config[:connecturlflag],config[:queuename])
+         res=@f.channel.prefetch(1)
+     assert res.is_a?(AMQ::Protocol::Basic::QosOk), "should set prefetch #{res} methods "
+    end
    def test_delegate
      puts "test startup"
-     config={:url => 'fakeurl',:connecturlflag=> false,:queuename => 'testdelegatequeue', :blocking => true,:consumer_name => "test consumer delete startup consumer"}
+     config={:url => 'fakeurl',:connecturlflag=> false,:queuename => 'testdelegatequeue', :timeout => 0,:blocking => true,:consumer_name => "test consumer delete startup consumer"}
        cmdhash={'command'=>'testdelegate', 'temp'=>'test_delegate'}
         @f.setup_bunny_communications(config[:url],config[:connecturlflag],config[:queuename])
          @consumer = EstormMessageProcessor::Consumer.new(@f.channel, @f.queue)
@@ -63,7 +72,7 @@ class EstormConsumerProcessTest <  Minitest::Test
    end
   def test_consumer
     puts "testing consumer"
-    config={:url => 'fakeurl',:connecturlflag=> false,:queuename => 'testconsumerqueue2', :blocking => true, :consumer_name => "test consumer"}
+    config={:url => 'fakeurl',:connecturlflag=> false,:queuename => 'testconsumerqueue2', :timeout => 0, :blocking => true, :consumer_name => "test consumer"}
     @f.setup_bunny_communications(config[:url],config[:connecturlflag],config[:queuename])
     @consumer = EstormMessageProcessor::Consumer.new(@f.channel, @f.queue)
     @consumer.logger=@f.logger
@@ -84,7 +93,7 @@ class EstormConsumerProcessTest <  Minitest::Test
   end
   def test_queueu_stats
      puts "testing consumer"
-      config={:url => 'fakeurl',:connecturlflag=> false,:queuename => 'testconsumerqueue', :blocking => true, :consumer_name => "test consumer2"}
+      config={:url => 'fakeurl',:connecturlflag=> false,:queuename => 'testconsumerqueue', :timeout => 0,:blocking => true, :consumer_name => "test consumer2"}
       @f.setup_bunny_communications(config[:url],config[:connecturlflag],config[:queuename])
       @consumer = EstormMessageProcessor::Consumer.new(@f.channel, @f.queue)
       @consumer.logger=@f.logger

data/test/test_estorm.rb

@@ -62,7 +62,7 @@ class EstormMessageProcessTest <  Minitest::Test
   
   def test_delegate
     puts "test delegate"
-    config={:url => 'fakeurl',:connecturlflag=> false,:queuename => 'testdelegatequeue', :blocking => true,:consumer_name => "test consumer delete startup consumer"}
+    config={:url => 'fakeurl',:connecturlflag=> false,:timeout => 0,:queuename => 'testdelegatequeue', :blocking => true,:consumer_name => "test consumer delete startup consumer"}
       cmdhash={'command'=>'testdelegate', 'temp'=>'test_delegate'}
       t1 =Thread.new {
          @f.start(config) }
@@ -70,26 +70,29 @@ class EstormMessageProcessTest <  Minitest::Test
     assert @f.consumer!=nil, "consumer should not be nil"
     @f.consumer.send("delegate_testdelegate",cmdhash)
    assert MessageFlag.flag==true, "should receive message and set temp #{MessageFlag.flag}"
+   sleep 3
   end
   def test_basic_startup
     puts "test basic startup"
-    config={:url => 'fakeurl',:connecturlflag=> false,:queuename => 'testbasicqueue', :blocking => false,:consumer_name => "test basic non blocking consumer"}
+    config={:url => 'fakeurl',:connecturlflag=> false,:timeout => 0,:queuename => 'testbasicqueue', :blocking => false,:consumer_name => "test basic non blocking consumer"}
     
     t1 =Thread.new {
       @f.start(config) }
     sleep 2
-    @f.tear_down_bunny     #NEED TO FIGURE OUT HOW TO STOP
+   # @f.tear_down_bunny     #NEED TO FIGURE OUT HOW TO STOP
     assert true,"should get here test_startup"
   end
   def test_startup
     puts "test startup"
-    config={:url => 'fakeurl',:connecturlflag=> false,:queuename => 'testqueue', :blocking => true,:consumer_name => "test startup consumer"}
+    config={:url => 'fakeurl',:connecturlflag=> false,:timeout => 0,:queuename => 'testqueue', :blocking => true,:consumer_name => "test startup consumer"}
     t1 =Thread.new {
        @f.start(config) }
     sleep 2
     @f.tear_down_bunny    
+    sleep 1
     t1.exit
     assert true,"should get here test_startup"
+    sleep 3
   end
   def test_1yaml
     puts "in yaml test"
@@ -102,11 +105,11 @@ class EstormMessageProcessTest <  Minitest::Test
   def test_message
     puts "test  message"
     assert MessageFlag.flag==false, "should be flase #{MessageFlag.inspect}"
-    config={:url => 'fakeurl',:connecturlflag=> false,:queuename => 'testseveralMessages', :blocking => true, :consumer_name => "test message consumer"}
+    config={:url => 'fakeurl',:connecturlflag=> false,:timeout => 0,:queuename => 'testsevalMessages', :blocking => true, :consumer_name => "test message consumer"}
     t1=Thread.new {
     @f.start(config) 
     puts " should not get here this thread about to exit in tes_messag"}
-    sleep 6
+    sleep 1
     t2= Thread.new {
       
       cmdhash={'command'=>'testdelegate', 'temp'=>'temp'}
@@ -116,22 +119,23 @@ class EstormMessageProcessTest <  Minitest::Test
        puts "after bunny send test_message"
          }
     puts "after client in test message"
-    sleep 1
+    sleep 5
+    
       assert MessageFlag.flag==true, "should receive message and set temp #{MessageFlag.flag}"
    
-     @f.tear_down_bunny 
+     sleep 1
      t1.exit
      t2.exit
-     
+     sleep 1
   end
   def test_several_message
      puts "test several  message"
      assert MessageFlag.flag==false, "should be flase #{MessageFlag.inspect}"
-     config={:url => 'fakeurl',:connecturlflag=> false,:queuename => 'testqueueMessage', :blocking => true, :consumer_name => "test message consumer"}
+     config={:url => 'fakeurl',:connecturlflag=> false,:timeout => 0,:queuename => 'testqueuesMessage', :blocking => true, :consumer_name => "test message consumer"}
      t1=Thread.new {
      @f.start(config) 
      puts " should not get here this thread about to exit in tes_messag"}
-     sleep 2
+     sleep 1
      t2= Thread.new {
 
        cmdhash={'command'=>'testdelegate2', 'temp'=>'serveral messages'}
@@ -144,26 +148,71 @@ class EstormMessageProcessTest <  Minitest::Test
             }
           }
      puts "after client in test message"
-     sleep 1
-      @f.tear_down_bunny 
+     sleep 15
+  #    @f.tear_down_bunny 
+      sleep 1
        assert MessageFlag.testval==7, "should receive 7 message and set temp #{MessageFlag.testval}"
      
 
       t1.exit
       t2.exit
-
+      sleep 3
    end
+   def test_several_message_again
+       puts "test several  message"
+       assert MessageFlag.flag==false, "should be flase #{MessageFlag.inspect}"
+       config={:url => 'fakeurl',:connecturlflag=> false,:timeout => 0,:queuename => 'testqueuesMessage again', :blocking => true, :consumer_name => "test message consumer"}
+       t1=Thread.new {
+       @f.start(config) 
+       puts " should not get here this thread about to exit in tes_messag"}
+       sleep 1
+       t2= Thread.new {
+
+         cmdhash={'command'=>'testdelegate2', 'temp'=>'serveral messages'}
+          puts "----> to system [x] sending  #{cmdhash.inspect}"
+          1.upto(7) { |i| 
+           bunnysender=EstormMessageProcessor::Client.new
+           cmdhash['temp']="mesage #{i}"
+           bunnysender.bunny_send(config[:url],config[:connnecturlflag],config[:queuename],cmdhash)
+            puts "after bunny send test_message"
+              }
+            }
+       puts "after client in test message"
+       sleep 15
+    #    @f.tear_down_bunny 
+        sleep 1
+         assert MessageFlag.testval==7, "should receive 7 message and set temp #{MessageFlag.testval}"
+         count=4
+          t2= Thread.new {
+
+            cmdhash={'command'=>'testdelegate2', 'temp'=>'serveral messages'}
+             puts "----> to system [x] sending  #{cmdhash.inspect}"
+             1.upto(count) { |i| 
+              bunnysender=EstormMessageProcessor::Client.new
+              cmdhash['temp']="mesage #{i}"
+              bunnysender.bunny_send(config[:url],config[:connnecturlflag],config[:queuename],cmdhash)
+               puts "after bunny send test_message"
+                 }
+               }
+        sleep 10
+          assert MessageFlag.testval==7+count, "should receive #{7+count} message and set temp #{MessageFlag.testval}"
+        t1.exit
+        t2.exit
+        sleep 3
+     end
   def test_client
        puts "test client  -- basic"
        cmdhash={'command'=>'testdelegate2', 'promotion'=>2.to_s}
        puts "----> to system [x] sending  #{cmdhash.inspect}"
-       config={:url => 'fakeurl',:connecturlflag=> false,:queuename => 'testqueue7', :blocking => true, :consumer_name => "test consumer"}
+       config={:url => 'fakeurl',:connecturlflag=> false,:timeout => 0,:queuename => 'testqueue7', :blocking => true, :consumer_name => "test consumer"}
        bunny=EstormMessageProcessor::Client.new
        assert bunny!=nil, "bunny should not be nil"
-       bunny.bunny_send_no_close(config[:url],config[:connnecturlflag],config[:queuename],cmdhash)
+       bunny.setup_bunny(config[:url],config[:connnecturlflag])
+       bunny.bunny_send_no_close(config[:queuename],cmdhash)
        assert bunny.connection!=nil, "should be ok"
        res=bunny.connection.close
        assert res=='closed'.to_sym, "should be closed: #{res.inspect}"
+       sleep 3
   end
  
   

data/test/test_single.rb

@@ -0,0 +1,89 @@
+puts File.dirname(__FILE__)
+require 'yaml'
+require File.dirname(__FILE__) + '/test_helper.rb' 
+class MessageFlag
+ 
+  def self.reset
+    puts "reset called"
+     @@flag=false
+     @@test=0
+  end
+  def self.setflag
+     puts "set flag called"
+    @@flag=true
+  end
+  def self.flag
+   
+    @@flag
+  end
+  def self.testval
+    @@test
+  end
+  def self.increment
+    puts "increment called"
+    @@test=MessageFlag.testval+1
+  end
+end
+class EstormMessageProcessor::Consumer
+   
+   def delegate_testdelegate3(cmdhash)
+     msg= "DELEGATE CALLED: test delegate 3 received #{cmdhash.inspect}"
+     logger.info msg
+     puts msg
+     MessageFlag.increment
+   end
+end
+
+class EstormMessageProcessTest <  Minitest::Test
+
+  def setup
+    EstormMessageProcessor::Base.logger=Logger.new(STDERR) 
+    @f=EstormMessageProcessor::Base.new
+    @@temp=false
+    MessageFlag.reset
+    puts "after setup"
+  end
+  
+  def test_basic
+    assert @f!=nil, "should be valid"
+    assert !@@temp, "should be false"
+    assert !MessageFlag.flag, "should be false"
+    MessageFlag.setflag
+     assert MessageFlag.flag, "should be true"
+     assert MessageFlag.testval==0, "should be 0"
+       MessageFlag.increment
+        assert MessageFlag.flag, "should be false"
+  end
+  def test_processor_exits_after_queue_empty
+     puts "test several  message"
+     assert MessageFlag.flag==false, "should be flase #{MessageFlag.inspect}"
+     config={:url => 'fakeurl',:connecturlflag=> false,:queuename => 'testqueueMessageExit', :blocking => true, :consumer_name => "test exit consumer", :timeout => 10 }
+     # PRELOAD THE QUEUE WITH MESSAGES
+       bunnysender=EstormMessageProcessor::Client.new
+       bunnysender.setup_bunny(config[:url],config[:connnecturlflag])
+
+       cmdhash={'command'=>'testdelegate3', 'temp'=>'serveral messages'}
+        puts "----> to system [x] sending  #{cmdhash.inspect}"
+         
+        1.upto(7) { |i| 
+      
+         cmdhash['temp']="mesage #{i}"
+         bunnysender.bunny_send_no_close(config[:queuename],cmdhash)
+          puts "after bunny send test_message: #{cmdhash['temp']}"
+            }
+          
+     puts "after client in test message"
+      @f.start(config) 
+#        bunnysender.connection.close
+      puts " should  get here this thread about to exit in tes_messag"
+     
+      time=30
+      puts "sleeping #{time} seconds"
+      sleep time
+      
+     sleep 1
+       
+       assert MessageFlag.testval==7, "should receive 7 message and set temp #{MessageFlag.testval}"
+
+   end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: estorm-message-processor
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.2.1
 platform: ruby
 authors:
 - Scott Sproule
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-16 00:00:00.000000000 Z
+date: 2013-10-17 00:00:00.000000000 Z
 dependencies: []
 description: a gem to help rails app process AMQP queues for background jobs
 email: scott.sproule@ficonab.com
@@ -64,6 +64,7 @@ files:
 - test/test_consumer.rb
 - test/test_estorm.rb
 - test/test_helper.rb
+- test/test_single.rb
 - Gemfile
 - Gemfile.lock
 - README.md
@@ -77,12 +78,12 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: 1.3.4
 requirements: []