stomp 1.1.10 → 1.2.0

data/test/test_connection1p.rb

@@ -0,0 +1,251 @@
+# -*- encoding: utf-8 -*-
+
+$:.unshift(File.dirname(__FILE__))
+
+require 'test_helper'
+
+class TestConnection1P < Test::Unit::TestCase
+  include TestBase
+  
+  def setup
+    @conn = get_connection()
+  end
+
+  def teardown
+    @conn.disconnect if @conn.open? # allow tests to disconnect
+  end
+  #
+  def test_conn_1p_0000
+    assert @conn.open?
+  end
+  #
+  def test_conn_1p_0010
+    #
+    cha = {:host => "localhost"}
+    assert_raise Stomp::Error::ProtocolErrorConnect do
+      conn = Stomp::Connection.open(user, passcode, host, port, false, 5, cha)
+    end    
+    #
+    chb = {"accept-version" => "1.0"}
+    assert_raise Stomp::Error::ProtocolErrorConnect do
+      conn = Stomp::Connection.open(user, passcode, host, port, false, 5, chb)
+    end    
+  end
+  #
+  def test_conn_1p_0020
+    #
+    cha = {:host => "localhost", "accept-version" => "1.0"}
+    cha[:host] = "/" if ENV['STOMP_RABBIT']
+    conn = nil
+    assert_nothing_raised do
+      conn = Stomp::Connection.open(user, passcode, host, port, false, 5, cha)
+      conn.disconnect
+    end
+    assert_equal conn.protocol, Stomp::SPL_10
+  end
+  #
+  def test_conn_1p_0030
+    #
+    cha = {:host => "localhost", "accept-version" => "1.1"}
+    cha[:host] = "/" if ENV['STOMP_RABBIT']
+    conn = nil
+    assert_nothing_raised do
+      conn = Stomp::Connection.open(user, passcode, host, port, false, 5, cha)
+      conn.disconnect
+    end
+    assert_equal conn.protocol, Stomp::SPL_11
+  end
+  #
+  def test_conn_1p_0040
+    #
+    cha = {:host => "localhost", "accept-version" => "1.1"}
+    cha[:host] = "/" if ENV['STOMP_RABBIT']
+    cha["heart-beat"] = "0,0" # No heartbeats
+    conn = nil
+    assert_nothing_raised do
+      conn = Stomp::Connection.open(user, passcode, host, port, false, 5, cha)
+      conn.disconnect
+    end
+    assert_equal conn.protocol, Stomp::SPL_11
+  end
+  #
+
+  def test_conn_1p_0050
+    #
+    cha = {:host => "localhost", "accept-version" => "1.1"}
+    cha[:host] = "/" if ENV['STOMP_RABBIT']
+    cha["heart-beat"] = "10,10,20" # Bad header Heartbeats
+    conn = nil
+    assert_raise Stomp::Error::InvalidHeartBeatHeaderError do
+      conn = Stomp::Connection.open(user, passcode, host, port, false, 5, cha)
+    end
+  end
+  #
+  def test_conn_11h_0060
+    #
+    cha = {:host => "localhost", "accept-version" => "1.1"}
+    cha[:host] = "/" if ENV['STOMP_RABBIT']
+    cha["heart-beat"] = "a,10" # Bad header Heartbeats
+    conn = nil
+    assert_raise Stomp::Error::InvalidHeartBeatHeaderError do
+      conn = Stomp::Connection.open(user, passcode, host, port, false, 5, cha)
+    end
+  end
+  #
+  def test_conn_1p_0070
+    #
+    cha = {:host => "localhost", "accept-version" => "1.1"}
+    cha[:host] = "/" if ENV['STOMP_RABBIT']
+    cha["heart-beat"] = "500,1000" # Valid heart beat headers
+    conn = nil
+    assert_nothing_raised do
+      conn = Stomp::Connection.open(user, passcode, host, port, false, 5, cha)
+      conn.disconnect
+    end
+  end
+
+  #
+  def test_conn_1p_0080
+    #
+    cha = {:host => "localhost", "accept-version" => "1.1"}
+    cha[:host] = "/" if ENV['STOMP_RABBIT']
+    cha["heart-beat"] = "5000,0" # Valid heart beat headers, send only
+    conn = nil
+    logger = Tlogger.new
+    assert_nothing_raised do
+      conn = Stomp::Connection.open(user, passcode, host, port, false, 5, cha)
+      conn.set_logger(logger)
+      sleep 65
+      conn.set_logger(nil)
+      conn.disconnect
+    end
+  end if ENV['STOMP_HB11LONG']
+
+  #
+  def test_conn_1p_0090
+    #
+    cha = {:host => "localhost", "accept-version" => "1.1"}
+    cha[:host] = "/" if ENV['STOMP_RABBIT']
+    cha["heart-beat"] = "0,10000" # Valid heart beat headers, receive only
+    conn = nil
+    logger = Tlogger.new
+    assert_nothing_raised do
+      conn = Stomp::Connection.open(user, passcode, host, port, false, 5, cha)
+#      m = conn.receive # This will hang forever .....
+      conn.set_logger(logger)
+      sleep 65
+      conn.set_logger(nil)
+      conn.disconnect
+    end
+  end if ENV['STOMP_HB11LONG']
+
+  #
+  def test_conn_1p_0100
+    #
+    cha = {:host => "localhost", "accept-version" => "1.1"}
+    cha[:host] = "/" if ENV['STOMP_RABBIT']
+    cha["heart-beat"] = "5000,10000" # Valid heart beat headers, send and receive
+    conn = nil
+    logger = Tlogger.new
+    assert_nothing_raised do
+      conn = Stomp::Connection.open(user, passcode, host, port, false, 5, cha)
+#      m = conn.receive # This will hang forever .....
+      conn.set_logger(logger)
+      sleep 65
+      conn.set_logger(nil)
+      conn.disconnect
+    end
+  end if ENV['STOMP_HB11LONG']
+  #
+  def test_conn_1p_0110
+    #
+    cha = {:host => "localhost", "accept-version" => "1.1"}
+    cha[:host] = "/" if ENV['STOMP_RABBIT']
+    cha["heart-beat"] = "0,0" # No heartbeats
+    conn = nil
+    conn = Stomp::Connection.open(user, passcode, host, port, false, 5, cha)
+    good_data = [
+      "\x41\xc3\xb1\x42",
+      "\xc2\x80", # 2 byte characters
+      "\xc2\xbf",
+      "\xdf\x80",
+      "\xdf\xbf",
+      "\xe0\xa0\x80", # 3 byte characters
+      "\xe0\xbf\x80",
+      "\xe0\xa0\xbf",
+      "\xe0\xbf\xbf",
+      "\xf1\x80\x80\x80", # 4 byte characters
+      "\xf1\xbf\xbf\xbf",
+      "\xf2\x80\x80\x80",
+      "\xf2\xbf\xbf\xbf",
+      "\xf3\x80\x80\x80",
+      "\xf3\xbf\xbf\xbf",
+    ]
+    good_data.each do |string|
+      assert conn.valid_utf8?(string), "good unicode specs 01: #{string}"
+    end
+    conn.disconnect
+  end
+
+  #
+  def test_conn_1p_0120
+    #
+    cha = {:host => "localhost", "accept-version" => "1.1"}
+    cha[:host] = "/" if ENV['STOMP_RABBIT']
+    cha["heart-beat"] = "0,0" # No heartbeats
+    conn = nil
+    conn = Stomp::Connection.open(user, passcode, host, port, false, 5, cha)
+    bad_data = [
+      "\x41\xc2\xc3\xb1\x42",
+      "\xed\xa0\x80", # UTF-16 surrogate halves
+      "\xed\xad\xbf",
+      "\xed\xae\x80",
+      "\xed\xaf\xbf",
+      "\xed\xb0\x80",
+      "\xed\xbe\x80",
+      "\xed\xbf\xbf",
+      "\xc0", # Single bytes
+      "\xc1",
+      "\xf5","\xf6","\xf7","\xf8","\xf9","\xfa","\xfb","\xfc",
+      "\xfd","\xfe","\xff",
+      "\xc0\x80", # Not shortest representation
+      "\xc1\x80",
+      "\xc0\x30",
+      "\xc1\x30",
+      "\xe0\x80\x80",
+      "\xf0\x80\x80\x80",
+    ]
+    bad_data.each do |string|
+      assert !conn.valid_utf8?(string), "bad unicode specs 01: #{string}"
+    end
+    conn.disconnect
+  end
+
+  # Repeated headers test. Currently:
+  # - Apollo emits repeated headers for a 1.1 connection only
+  # - RabbitMQ does not emit repeated headers under any circumstances
+  def test_conn_1p_0120
+    dest = make_destination
+    msg = "payload: #{Time.now.to_f}"
+    shdrs = { "key1" => "val1", "key2" => "val2",
+      "key3" => ["kv3", "kv2", "kv1"] }
+    assert_nothing_raised {
+      @conn.publish dest, msg, shdrs
+    }
+    #
+    sid = @conn.uuid()
+    @conn.subscribe dest, :id => sid
+    #
+    received = @conn.receive
+    assert_equal msg, received.body
+    if @conn.protocol != Stomp::SPL_10
+      assert_equal shdrs["key3"], received.headers["key3"] unless ENV['STOMP_RABBIT']
+    else
+      assert_equal "kv3", received.headers["key3"]
+    end
+    #
+    @conn.unsubscribe dest, :id => sid
+  end
+
+end if ENV['STOMP_TEST11']
+

data/test/test_helper.rb

@@ -1,8 +1,17 @@
+# -*- encoding: utf-8 -*-
+
 $:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
 
 require 'test/unit'
 require 'timeout'
 require 'stomp'
+require 'tlogger'
+
+begin
+  dummy = RUBY_ENGINE
+rescue NameError => ne
+  RUBY_ENGINE = "unknown"
+end
 
 # Helper routines
 module TestBase
@@ -35,6 +44,45 @@ module TestBase
     end
   end
 
+  def get_connection()
+    ch = get_conn_headers()
+    conn = Stomp::Connection.open(user, passcode, host, port, false, 5, ch)
+    conn
+  end
+
+  def get_client()
+    hash = { :hosts => [ 
+          {:login => user, :passcode => passcode, :host => host, :port => port},
+          ],
+          :connect_headers => get_conn_headers()
+        }
+
+    client = Stomp::Client.new(hash)
+    client
+  end
+
+  def get_conn_headers()
+    ch = {}
+    if ENV['STOMP_TEST11']
+      #
+      if Stomp::SUPPORTED.index(ENV['STOMP_TEST11'])
+        ch['accept-version'] = ENV['STOMP_TEST11']
+      else
+        ch['accept-version'] = Stomp::SPL_11
+      end
+      #
+      ch['host'] = ENV['STOMP_RABBIT'] ? "/" : host
+    end
+    ch
+  end
+
+  def conn_subscribe(dest, headers = {})
+    if @conn.protocol >= Stomp::SPL_11
+      headers[:id] = @conn.uuid() unless headers[:id]
+    end
+    @conn.subscribe dest, headers
+  end
+
   # Test helper methods
 
   def make_destination

data/test/test_message.rb

@@ -1,15 +1,23 @@
+#
+# !!!!
+#
+# This can *NOT* currently be marked as UTF-8 encoded. It uses invalid UTF-8
+# sequences for testing.  Tests will fail under 1.9.x+ if this file is marked
+# as UTF-8 encoded.
+#
+
 $:.unshift(File.dirname(__FILE__))
 #
 # Test Ruby 1.8 with $KCODE='U'
 #
 require 'test_helper'
 #
-class TestMessageKcode < Test::Unit::TestCase
+class TestMessage < Test::Unit::TestCase
   include TestBase
   #
   def setup
 		$KCODE = 'U' if RUBY_VERSION =~ /1\.8/
-    @conn = Stomp::Connection.open(user, passcode, host, port)
+    @conn = get_connection()
     # Message body data
 		@messages = [
 			"normal text message",
@@ -24,10 +32,15 @@ class TestMessageKcode < Test::Unit::TestCase
   end
 
 	# Various message bodies, including the failing test case reported
-  def test_kcode_001
+  def test_0010_kcode
 		#
 		dest = make_destination
-    @conn.subscribe dest
+    if @conn.protocol == Stomp::SPL_10
+      @conn.subscribe dest
+    else
+      sh = {}
+      @conn.subscribe dest, sh, @conn.uuid()
+    end
 		@messages.each do |abody|
 		  @conn.publish dest, abody
 			msg = @conn.receive
@@ -37,13 +50,18 @@ class TestMessageKcode < Test::Unit::TestCase
   end
 
 	# All possible byte values
-  def test_kcode_002
+  def test_0020_kcode
 		#
 		abody = ""
 		"\000".upto("\377") {|abyte| abody << abyte } 
 		#
 		dest = make_destination
-    @conn.subscribe dest
+    if @conn.protocol == Stomp::SPL_10
+      @conn.subscribe dest
+    else
+      sh = {}
+      @conn.subscribe dest, sh, @conn.uuid()
+    end
 	  @conn.publish dest, abody
 		msg = @conn.receive
 		assert_instance_of Stomp::Message , msg, "type check for #{abody}"
@@ -51,10 +69,15 @@ class TestMessageKcode < Test::Unit::TestCase
   end
 
 	# A single byte at a time
-  def test_kcode_003
+  def test_0030_kcode
 		#
 		dest = make_destination
-    @conn.subscribe dest
+    if @conn.protocol == Stomp::SPL_10
+      @conn.subscribe dest
+    else
+      sh = {:id => @conn.uuid()}
+      @conn.subscribe dest, sh
+    end
 		#
 		"\000".upto("\377") do |abody|
 			@conn.publish dest, abody
@@ -65,49 +88,76 @@ class TestMessageKcode < Test::Unit::TestCase
   end
 
 	#
-	def test_kcode_004
+	def test_0040_msg_create
 		#
 		assert_raise(Stomp::Error::InvalidFormat) {
-			aframe = Stomp::Message.new("junk")
+			aframe = Stomp::Message.new("junk", false)
 		}
 		#
 		assert_raise(Stomp::Error::InvalidFormat) {
-			aframe = Stomp::Message.new("command\njunk")
+			aframe = Stomp::Message.new("command\njunk", false)
 		}
 		#
 		assert_raise(Stomp::Error::InvalidFormat) {
-			aframe = Stomp::Message.new("command\nheaders\n\njunk")
+			aframe = Stomp::Message.new("command\nheaders\n\njunk", false)
 		}
 		#
 		assert_raise(Stomp::Error::InvalidServerCommand) {
-			aframe = Stomp::Message.new("junkcommand\nheaders\n\njunk\0\n\n")
+			aframe = Stomp::Message.new("junkcommand\nheaders\n\njunk\0\n\n", false)
 		}
 		#
 		assert_raise(Stomp::Error::InvalidFormat) {
-			aframe = Stomp::Message.new("ERROR\nbadheaders\n\njunk\0\n\n")
+			aframe = Stomp::Message.new("ERROR\nbadheaders\n\njunk\0\n\n", false)
 		}
 		#
 		assert_nothing_raised {
-			aframe = Stomp::Message.new("CONNECTED\nh1:val1\n\njunk\0\n")
+			aframe = Stomp::Message.new("CONNECTED\nh1:val1\n\njunk\0\n", false)
 		}
 		#
 		assert_nothing_raised {
-			aframe = Stomp::Message.new("MESSAGE\nh1:val1\n\njunk\0\n")
+			aframe = Stomp::Message.new("MESSAGE\nh1:val1\n\njunk\0\n", false)
 		}
 		#
 		assert_nothing_raised {
-			aframe = Stomp::Message.new("MESSAGE\nh2:val2\n\n\0")
+			aframe = Stomp::Message.new("MESSAGE\nh2:val2\n\n\0", false)
 		}
 		#
 		assert_nothing_raised {
-			aframe = Stomp::Message.new("RECEIPT\nh1:val1\n\njunk\0\n")
+			aframe = Stomp::Message.new("RECEIPT\nh1:val1\n\njunk\0\n", false)
 		}
 		#
 		assert_nothing_raised {
-			aframe = Stomp::Message.new("ERROR\nh1:val1\n\njunk\0\n")
+			aframe = Stomp::Message.new("ERROR\nh1:val1\n\njunk\0\n", false)
 		}
 
 	end
 
+	# Multiple headers with the same key
+	def test_0050_mh_msg_create
+    aframe = bframe = nil
+		assert_nothing_raised {
+      amsg = "MESSAGE\n" +
+        "h1:val1\n" + 
+        "h2:val3\n" + 
+        "h2:val2\n" + 
+        "h2:val1\n" + 
+        "h3:val1\n" + 
+        "\n" +
+        "payload" +
+        "\0\n"
+			aframe = Stomp::Message.new(amsg, false)
+			bframe = Stomp::Message.new(amsg, true)
+		}
+    #
+    assert aframe.headers["h2"].is_a?(String), "Expected a String"
+    assert_equal "val3", aframe.headers["h2"], "Expected 1st value"
+    #
+    assert bframe.headers["h2"].is_a?(Array), "Expected an Array"
+    assert_equal 3, bframe.headers["h2"].length, "Expected 3 values"
+    assert_equal "val3", bframe.headers["h2"][0], "Expected val3"
+    assert_equal "val2", bframe.headers["h2"][1], "Expected val2"
+    assert_equal "val1", bframe.headers["h2"][2], "Expected val1"
+  end
+
 end