stompserver_ng 1.0.6

data/test/test_0015_ack_conn.rb

@@ -0,0 +1,78 @@
+require 'rubygems'
+require 'stomp'
+#
+require 'test/unit'
+$:.unshift File.dirname(__FILE__)
+require 'test_0000_base'
+#
+# Test "ack" and :ack on a subscribe to a Stomp Connection.
+#
+class Test_0015_Ack_Conn < Test_0000_Base
+
+  # Setup.
+  # * Open a Stomp Connection
+  # * Set the test queue name
+  # * Set the message to use.
+  # * Set counter for looping tests
+  def setup
+    super
+    open_conn()
+    @queuename = "/queue/connack/" + name
+    @test_message = "What's up doc?"
+    @times = 10
+    #
+  end
+
+  # Teardown.
+  # # Connection disconnect.
+  def teardown
+    disconnect_conn()
+  end
+
+  # Test ACK of a single message
+  def test_0010_ack_conn_one
+    ack_conn_test("ack")
+  end
+=begin
+  # Test ACK of a single message using symbol header
+  def test_0020_ack_conn_one_sym
+    ack_conn_test(:ack)
+  end
+
+  # Test ACK of multiple messages
+  def test_0030_ack_conn_mult
+    ack_conn_test("ack", @times)
+  end
+
+  # Test ACK of multiple messages using symbol header
+  def test_0040_ack_conn_mult_sym
+    ack_conn_test(:ack, @times)
+  end
+=end
+  private
+
+  def ack_conn_test(ackparm = nil, ntimes = 1)
+    #
+    received = nil
+    assert_nothing_raised() {
+      ntimes.times do |n|
+        @conn.publish(@queuename, "#{@test_message} #{n+1}")
+      end
+    }
+    #
+    connection_subscribe(@queuename, { ackparm => "client" })
+    #
+    count = 0
+    assert_nothing_raised() {
+      ntimes.times do |n| 
+        received = @conn.receive 
+        @conn.ack(received.headers["message-id"]) 
+        count += 1
+      end
+    }
+    #
+    assert_equal(ntimes,count,"count should be the same: #{@queuename}")
+  end
+
+end # of class
+

data/test/test_0017_ack_client.rb

@@ -0,0 +1,78 @@
+require 'rubygems'
+require 'stomp'
+#
+require 'test/unit'
+$:.unshift File.dirname(__FILE__)
+require 'test_0000_base'
+#
+# Test ack => client using a Stomp Client.
+#
+class Test_0017_Ack_Client < Test_0000_Base
+
+  # Setup.
+  # * Queue Name
+  # * Message body
+  # * Count for multiples
+  # * Open a Stomp Client
+  def setup
+    super
+    @queue_name = "/queue/ackclisgl/" + name()
+    @test_message = "The Answer is Blowin' in the Wind."
+    @times = 10
+    open_client()
+  end
+
+  # Teardown.
+  # * Close the Stomp Client
+  def teardown
+    close_client()
+  end
+
+  # Test ACK from client
+  def test_0010_ack_send_receive
+    ack_client_test(:ackparm => "ack", :times => 1, :mod => "0010")
+  end
+
+  # Test ACK from client with symbol
+  def test_0020_ack_send_receive_sym
+    ack_client_test(:ackparm => :ack, :times => 1, :mod => "0020")
+  end
+
+  # Test ACK from client with miltiple messages
+  def test_0030_ack_send_receive_mult
+    ack_client_test(:ackparm => "ack", :times => @times, :mod => "0030")
+  end
+
+  # Test ACK from client with symbol and multiple messages
+  def test_0040_ack_send_receive_mult_sym
+    ack_client_test(:ackparm => :ack, :times => @times, :mod => "0040")
+  end
+
+  private
+
+  def ack_client_test(params = {})
+    received = nil
+    count = 0
+    assert_nothing_raised() {
+      params[:times].times do |n|
+        @client.publish(@queue_name, "#{@test_message} #{n+1}", 
+          {"persistent" => true, 
+          "client-id" => "0017_putr_#{params[:mod]}", 
+          "reply-to" => @queue_name} )
+      end
+      @client.subscribe(@queue_name,
+        {"persistent" => true, 
+          "client-id" => "0017_getr_#{params[:mod]}",
+          params[:ackparm] => "client" } 
+          ) do |message|
+        received = message
+        @client.acknowledge(received)   # ACK the message
+        count += 1
+      end
+      sleep 2.0 until received
+    }
+    assert_equal(params[:times],count,"counts should match: #{@queue_name}")
+  end
+
+end # of class
+

data/test/test_0019_ack_no_ack.rb

@@ -0,0 +1,145 @@
+require 'rubygems'
+require 'stomp'
+#
+require 'test/unit'
+$:.unshift File.dirname(__FILE__)
+require 'test_0000_base'
+#
+# Test situations with a Stomp Client where ack mode is specified on a 
+# subscribe, but the message is initially never actually ACK'd.
+#
+class Test_0019_Ack_No_Ack < Test_0000_Base
+
+  # Setup.
+  # * Queue name
+  # * Message body
+  # * Connect stagger/reconnect wait time
+  def setup
+    super
+    @queue_name = "/queue/acknoack/" + name()
+    @test_message = "Bad moon risin' ....."
+    @reconnect_stagger = 0.5
+  end
+
+  # Teardown.
+  def teardown
+  end
+
+  # Test Ack No Ack Reget:
+  # * Send a messsage
+  # * Subscribe with ack, and receive
+  # * Never send an ACK
+  # * Reconnect and subscribe with ack => auto
+  # * Re-receive the same message
+  # Expectation: no client errors, and no server crashes.
+  def test_0020_ack_no_ack_reget
+    #
+    open_client()
+    #
+    received = no_ack_get()
+    # But now, do _not_ ack the message, just close the client connection
+    close_client()
+    #
+    # The re-connect and re-get sequence
+    #
+    sleep @reconnect_stagger  # Server needs to asynchronously complete disconnect
+    open_client()
+    #
+    received_02 = get_again("auto")
+    #
+    assert_equal(received.body, received_02.body, "message content should be the same")
+    # And so should the message ID.
+    assert_equal(received.headers["message-id"],received_02.headers["message-id"],
+      "message ID should be the same")  
+    #
+    close_client()
+  end
+
+  # Test Ack No Ack Reget:
+  # * Send a messsage
+  # * Subscribe with ack, and receive
+  # * Never send an ACK
+  # * Reconnect and subscribe with ack => client
+  # * Re-receive the same message
+  # * Actually ACK the message
+  # Expectation: no client errors, and no server crashes.
+  def test_0030_ack_no_ack_reget
+    #
+    open_client()
+    #
+    received = no_ack_get()
+    # But now, do _not_ ack the message, just close the client connection
+    close_client()
+    #
+    # The re-connect and re-get sequence
+    #
+    sleep @reconnect_stagger  # Server needs to asynchronously complete disconnect
+    open_client()
+    #
+    received_02 = get_again("client")
+    #
+    assert_equal(received.body, received_02.body, "message content should be the same")
+    # And so should the message ID.
+    assert_equal(received.headers["message-id"],received_02.headers["message-id"],
+      "message ID should be the same")  
+    #
+    close_client()
+  end
+
+  private
+
+  # Send a message, subscribe with "ack" => "client", and receive it.
+  # Do *not* send ACK reply.
+  def no_ack_get()
+    sleep @sleep_time if @sleep_time > 0
+    #
+    received = nil
+    assert_nothing_raised() {
+      # Send a single message to a queue
+      @client.publish(@queue_name, @test_message, 
+        {"persistent" => true, 
+          "client-id" => "ana_client_put", 
+          "reply-to" => @queue_name} )
+      sleep @sleep_time if @sleep_time > 0
+      # Subscribe with "ack" => "client", and receive the message
+      @client.subscribe(@queue_name,
+        {"persistent" => true, "client-id" => "ana_client_get",
+          "ack" => "client" } ) do |message|
+        received = message
+      end
+      sleep 0.5 until received
+      #
+      sleep @sleep_time if @sleep_time > 0
+      # Make sure what was received is the same is what was sent
+      assert_equal(@test_message, received.body, "get what ya' give .....")
+    }
+    received
+  end
+
+  # Subscribe and reget a message.  The subscription may or may not be
+  # ack => client, depending on the caller.  If ack => client is indicated,
+  # the message is actually ACK'd.
+  def get_again(ackmode)
+    sleep @sleep_time if @sleep_time > 0
+    #
+    received = nil
+    assert_nothing_raised() {
+      # Subscribe with ack as specified by caller
+      @client.subscribe(@queue_name,
+        {"persistent" => true, "client-id" => "anareg_client_reget",
+         "ack" => ackmode } ) do |message|
+        received = message
+      end
+      sleep 1.0 until received
+      #
+      sleep @sleep_time if @sleep_time > 0
+      # Make sure what was received is the same is what was sent
+      assert_equal(@test_message, received.body, "get again what ya' gave .....")
+      # Possible ACK, caller decides
+      @client.acknowledge(received) if ackmode == "client"
+    }
+    received
+  end
+
+end # of class
+

data/test/test_0022_ack_noack_conn.rb

@@ -0,0 +1,123 @@
+require 'rubygems'
+require 'stomp'
+#
+require 'test/unit'
+$:.unshift File.dirname(__FILE__)
+require 'test_0000_base'
+#
+# Test situations with a Stomp Connection where ack mode is specified on a 
+# connection_subscribe, but the message is initially never actually ACK'd.
+#
+#
+class Test_0022_Ack_Noack_Conn < Test_0000_Base
+
+  # Setup.
+  # * Queue name
+  # * Message body
+  # * Connect stagger/reconnect wait time
+  def setup
+    super
+    open_conn()
+    @queuename = "/queue/connana1/" + name()
+    @test_message = "Blue Suede Shoes ..."
+    @reconnect_stagger = 0.5
+    #
+  end
+
+  # Teardown.
+  def teardown
+    disconnect_conn()
+  end
+
+  # Test Ack Conn No Ack Reget:
+  # * Send a messsage
+  # * Subscribe with ack, and receive
+  # * Never send an ACK
+  # * Reconnect and subscribe with ack => auto
+  # * Re-receive the same message
+  # Expectation: no client errors, and no server crashes.
+
+  def test_0020_ack_conn_no_ack_reget
+    received = no_ack_get()
+    #
+    disconnect_conn()
+    #
+    sleep @reconnect_stagger  # Let server clean up
+    open_conn()
+    received_02 = get_again("auto")
+    #
+    assert_equal(received.body, received_02.body, "message content should be the same")
+    # And so should the message ID.
+    assert_equal(received.headers["message-id"],received_02.headers["message-id"],
+      "message ID should be the same")  
+    #
+  end
+
+  # Test Ack No Ack Reget:
+  # * Send a messsage
+  # * Subscribe with ack, and receive
+  # * Never send an ACK
+  # * Reconnect and subscribe with ack => client
+  # * Re-receive the same message
+  # * Actually ACK the message
+  # Expectation: no client errors, and no server crashes.
+
+  def test_0030_ack_conn_no_ack
+    received = no_ack_get()
+    #
+    disconnect_conn()
+    #
+    sleep @reconnect_stagger  # Let server clean up
+    open_conn()
+    received_02 = get_again("client")
+    #
+    assert_equal(received.body, received_02.body, "message content should be the same")
+    # And so should the message ID.
+    assert_equal(received.headers["message-id"],received_02.headers["message-id"],
+      "message ID should be the same")  
+    #
+  end
+
+  private
+
+  # Send a message, subscribe with "ack" => "client", and receive it.
+  # Do *not* send ACK reply.
+  def no_ack_get()
+    received = nil
+    assert_nothing_raised() {
+      @conn.publish(@queuename, @test_message)
+      #
+      connection_subscribe(@queuename, { "ack" => "client" })
+      received = @conn.receive 
+    }
+    #
+    assert_not_nil(received, "something should be received")
+    assert_equal(@test_message, received.body, "received should match sent")
+    #
+    assert_not_nil(received.headers["message-id"], "message ID should be present")
+    #
+    received
+  end
+
+  # Subscribe and reget a message.  The subscription may or may not be
+  # ack => client, depending on the caller.  If ack => client is indicated,
+  # the message is actually ACK'd.
+  def get_again(ackmode)
+    received = nil
+    assert_nothing_raised() {
+      connection_subscribe(@queuename, { "ack" => ackmode })
+      received = @conn.receive 
+    }
+    #
+    assert_not_nil(received, "something should be received")
+    assert_equal(@test_message, received.body, "received should again match sent")
+    assert_not_nil(received.headers["message-id"], "message ID should be present")
+    #
+    assert_nothing_raised() {
+      @conn.ack(received.headers["message-id"]) if ackmode == "client"
+    }
+    received
+  end
+
+end # of class
+

data/test/test_0030_subscr_id.rb

@@ -0,0 +1,44 @@
+require 'rubygems'
+require 'stomp'
+#
+require 'test/unit'
+$:.unshift File.dirname(__FILE__)
+require 'test_0000_base'
+#
+# Basic connection tests.
+#
+class Test_0030_Subscr_Id < Test_0000_Base
+
+  # Setup
+  def setup
+    super
+    open_conn()
+  end
+
+  # Teardown
+  def teardown
+    disconnect_conn()
+  end
+
+  # Sanity check parameters
+  def test_0000_params
+    check_parms()
+  end
+
+
+  # Make sure we get 'subscription' header back from the server
+  def test_0010_subscribe_with_id
+    qname = "/queue/subscr/id/a.b"
+    send_message = "Subscribe with ID check message"
+    sub_id = "id-0010"
+    @conn.publish(qname,send_message)
+    @conn.subscribe(qname, {'id' => 'id-0010'})
+    #
+    rec_message = @conn.receive
+    assert_not_nil rec_message
+    assert_not_nil rec_message.headers['subscription']
+    assert_equal sub_id, rec_message.headers['subscription']
+  end
+
+end # of class
+