stompserver_ng 1.0.6

data/test/noserver/test_topic_manager.rb

@@ -0,0 +1,79 @@
+require 'logger'
+$:.unshift File.dirname(__FILE__)
+require 'mocklogger'
+#
+require 'stomp_server/topic_manager'
+require 'test/unit' unless defined? $ZENTEST and $ZENTEST
+
+class TestTopics < Test::Unit::TestCase
+
+  class UserMock
+    attr_accessor :data
+    def initialize ; @data = '' ; end
+    def stomp_send_data(data); @data += data.to_s ; end
+  end
+  
+  class MessageMock
+    attr_accessor :headers, :data, :command
+    def initialize(dest, msg)  
+      @headers = { 'destination' => dest }
+      @data = msg
+    end
+    def to_s ; @data ; end
+  end
+  
+  def setup
+    @t = StompServer::TopicManager.new
+    @log = Logger.new(STDOUT)
+    @log.level = Logger::DEBUG
+  end
+    
+  def test_subscribe
+    @log.debug("test_subscribe starts")
+    u = UserMock.new
+    t = 'foo'
+    @t.subscribe(t, u)
+    
+    m1 = MessageMock.new('foo', 'foomsg')
+    m2 = MessageMock.new('bar', 'barmsg')
+    @t.sendmsg(m1)
+    assert_equal(m1.data, u.data)
+    
+    u.data = ''
+    @t.sendmsg(m2)
+    assert_equal('', u.data)
+    @log.debug("test_subscribe ends")
+  end
+
+  def test_unsubscribe
+    @log.debug("test_unsubscribe starts")
+    u = UserMock.new
+    t = 'foo'
+    @t.subscribe(t, u)
+    
+    m1 = MessageMock.new('foo', 'foomsg')
+    @t.sendmsg(m1)
+    assert_equal(m1.data, u.data)
+
+    @t.unsubscribe(t,u)
+    u.data = ''
+    @t.sendmsg(m1)
+    assert_equal('', u.data)        
+    @log.debug("test_unsubscribe ends")
+  end
+
+  def test_sendmsg
+    @log.debug("test_sendmsg starts")
+    u = UserMock.new
+    t = 'foo'
+    @t.subscribe(t, u)
+    
+    m1 = MessageMock.new('foo', 'foomsg')
+    @t.sendmsg(m1)
+    assert_equal(m1.data, u.data)
+    assert_equal('MESSAGE', m1.command)
+    @log.debug("test_sendmsg ends")
+  end
+
+end
+

data/test/noserver/ts_all_no_server.rb

@@ -0,0 +1,12 @@
+#
+# Run all tests which do not require a server instance to be up.
+#
+here=File.dirname(__FILE__)
+$:.unshift File.join(here,"..","..", "lib")
+$:.unshift File.join(here)
+Dir.glob("#{here}/test_*.rb").each do |file|
+#  next if file =~ /test_0/
+  puts "Will require unit test file: #{file}"
+  require file
+end
+

data/test/props.yaml

@@ -0,0 +1,5 @@
+--- 
+:userid: login
+:password: passcode
+:host: localhost
+:port: 51613

data/test/runalltests.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+#
+for backup in $(ls $(pwd)/test/*~)
+do
+  rm $backup
+done
+#
+echo "==== Run All Tests ===="
+for test in $(ls $(pwd)/test/test_0*)
+do
+  echo $test
+  ruby -I $(pwd)/lib $test $*
+done
+

data/test/runtest.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+#
+ruby -I $(pwd)/lib $*
+

data/test/test_0000_base.rb

@@ -0,0 +1,107 @@
+require 'rubygems'
+require 'stomp'
+require 'test/unit'
+require 'yaml'
+require 'timeout'
+require 'digest/sha1'
+#
+class Test_0000_Base < Test::Unit::TestCase
+
+  # Base setup.
+  # * Load configuration parameters
+  # * Initialize connection and client instances.
+  # * Override sleep time from environment
+  def setup
+    @runparms = load_config()
+    @conn = nil
+    @client = nil
+    @sleep_time = ENV['TEST_SLEEP'] ? ENV['TEST_SLEEP'].to_f : 0.0
+  end # of setup
+
+  # Default test for the base class.  Will always pass.
+  # Required by the test framework.
+  def test_0000_default
+    assert(true)
+  end
+
+  private
+
+  # Load yaml configuration file
+  def load_config()
+    yfname = File.join(File.dirname(__FILE__), "props.yaml")
+    parms = YAML.load(File.open(yfname))
+    # Allow override of:
+    # * host
+    # * port
+    # * user name
+    # * user password
+    # from the environment.
+    parms[:host] = ENV['STOMP_HOST'] if ENV['STOMP_HOST']
+    parms[:port] = ENV['STOMP_PORT'] if ENV['STOMP_PORT']
+    parms[:userid] = ENV['STOMP_USER'] if ENV['STOMP_USER']
+    parms[:password] = ENV['STOMP_PASS'] if ENV['STOMP_PASS']
+    parms
+  end
+
+  protected
+
+  # Sanity check that required parms are present
+  def check_parms()
+    assert_not_nil(@runparms[:userid],"userid must be present")
+    assert_not_nil(@runparms[:password],"password must be present")
+    assert_not_nil(@runparms[:host],"host must be present")
+    assert_not_nil(@runparms[:port],"port must be present")
+  end
+
+  # Open a Stomp Connection
+  def open_conn()
+    assert_nothing_raised() {
+      @conn = Stomp::Connection.open(@runparms[:userid],
+        @runparms[:password], 
+        @runparms[:host], 
+        @runparms[:port])
+    }
+  end
+
+  # Disconnect a Stomp Connection
+  def disconnect_conn()
+    if @conn
+      assert_nothing_raised() {
+        @conn.disconnect
+      }
+    end
+    @conn = nil
+  end
+
+  # Open a Stomp Client
+  def open_client()
+    assert_nothing_raised() {
+      @client = Stomp::Client.open(@runparms[:userid],
+        @runparms[:password], 
+        @runparms[:host], 
+        @runparms[:port])
+    }
+  end
+
+  # Close a Stomp Client
+  def close_client()
+    assert_nothing_raised() {
+      @client.close if @client
+    }
+    @client = nil
+  end
+
+  # Convenience method for subscribing to a destination given a
+  # Stomp Connection.
+  def connection_subscribe(qname, headers = {}, subId = nil)
+    @conn.subscribe(qname, headers, subId)
+  end
+
+  #
+  def name
+    tstr = Time.now.to_f.to_s
+    "19x_name_" + Digest::SHA1.hexdigest(tstr)
+  end if RUBY_VERSION =~ /1\.9/
+
+end # of class
+

data/test/test_0001_conn.rb

@@ -0,0 +1,47 @@
+require 'rubygems'
+require 'stomp'
+#
+require 'test/unit'
+$:.unshift File.dirname(__FILE__)
+require 'test_0000_base'
+#
+# Basic connection tests.
+#
+class Test_0001_Conn < Test_0000_Base
+
+  #
+  def setup
+    super
+    @times = 10
+  end
+
+  # Sanity check parameters
+  def test_0000_params
+    check_parms()
+  end
+
+  # Single connect
+  def test_0010_connect
+    open_conn()
+    assert_not_nil(@conn, "connection should not be nil")
+    sleep @sleep_time if @sleep_time > 0
+  end
+
+  # Single disconnect
+  def test_0015_disconnect
+    disconnect_conn()
+    assert_nil(@conn, "connection should be nil after disconnect")
+  end
+
+  # Show that multiple connect/disconnect sequences in a row can be issued.
+  def test_0020_connect_disc_mult
+    @times.times do |n|
+      open_conn()
+      assert_not_nil(@conn, "connection should not be nil, try #{n}")
+      disconnect_conn()
+      assert_nil(@conn, "connection should be nil after disconnect, try #{n}")
+    end
+  end
+
+end # of class
+

data/test/test_0002_conn_sr.rb

@@ -0,0 +1,94 @@
+require 'rubygems'
+require 'stomp'
+#
+require 'test/unit'
+$:.unshift File.dirname(__FILE__)
+require 'test_0000_base'
+#
+# Test a basic send and receive over a Stomp Connection.
+#
+class Test_0002_Conn_SR < Test_0000_Base
+
+  # Setup.
+  # * Open the connection
+  # * Generate queue name for this test
+  # * Specify the message
+  def setup
+    super
+    open_conn()
+    @queuename = "/queue/connsr/" + name()
+    @test_message = "Abracadabra!"
+  end
+
+  # Teardown.
+  # * Disconnect
+  def teardown
+    disconnect_conn()
+  end
+
+  # Test a single send and receive over the same connection.
+  def test_0010_send_receive
+    received = nil
+    mtosend = @test_message + "-0010"
+    assert_nothing_raised() {
+      @conn.publish(@queuename, mtosend) 
+      connection_subscribe(@queuename)
+      received = @conn.receive 
+    }
+    assert_not_nil(received, "something should be received")
+    assert_equal(mtosend, received.body, "received should match sent")
+  end
+
+  # Test a single send and receive over different connections.
+  def test_0020_send_receive
+    received = nil
+    queuename = "/queue/connsr_0020/" + name()
+    mtosend = @test_message + "-0020"
+    assert_nothing_raised() {
+      @conn.publish(queuename, mtosend)
+      sleep 3
+    }
+    teardown
+    setup
+    assert_nothing_raised() {
+      connection_subscribe(queuename)
+      Timeout::timeout(4) do
+        received = @conn.receive 
+      end
+    }
+    assert_not_nil(received, "something should be received 20")
+    assert_equal(mtosend, received.body, "received should match sent 20")
+  end
+
+  # Test a single send and receive over different connections,
+  # issue subscribe before send:
+  # stompserver - fail
+  # AMQ - fail
+  # Note: 'fail' means that the second connection will issue 'receive', and
+  # no message will ever be received.
+  def test_0030_send_receive
+    received = nil
+    queuename = "/queue/connsr_0030/" + name()
+    mtosend = @test_message + "-0030"
+    assert_nothing_raised() {
+      connection_subscribe(queuename)  # This
+      @conn.publish(queuename, mtosend)
+      sleep 4                           # plus this cause fail
+      # NOTE!!! - without the above 'sleep':
+      # AMQ will sometimes fail, and sometimes succeed.  It seems to 
+      # depend on timing, current system load, .....
+    }
+    teardown
+    setup
+    assert_nothing_raised() {
+      connection_subscribe(queuename)
+    }
+    assert_raise(Timeout::Error) {
+      Timeout::timeout(4) do
+        received = @conn.receive 
+      end
+    }
+  end
+
+end # of class
+

data/test/test_0006_client.rb

@@ -0,0 +1,41 @@
+require 'rubygems'
+require 'stomp'
+#
+require 'test/unit'
+$:.unshift File.dirname(__FILE__)
+require 'test_0000_base'
+#
+# Test client open and close sequences.
+#
+class Test_0006_Client < Test_0000_Base
+
+  # Setup
+  # * Define number of loops for multiple tests.
+  def setup
+    super
+    @times = 10
+  end
+
+  # Teardown.
+  def teardown
+  end
+
+  # Single client open then close.
+  def test_0010_open_then_close
+    open_client()
+    assert_not_nil(@client, "client should not be nil")
+    close_client()
+    assert_nil(@client, "client should be nil after close")
+  end
+
+  # Multiple client open/close sequences.
+  def test_0020_open_then_close_mult
+    @times.times do |n|
+      open_client()
+      assert_not_nil(@client, "client should not be nil, try #{n}")
+      close_client()
+      assert_nil(@client, "client should be nil after close, try #{n}")
+    end
+  end
+end # of class
+

data/test/test_0011_send_recv.rb

@@ -0,0 +1,74 @@
+require 'rubygems'
+require 'stomp'
+#
+require 'test/unit'
+$:.unshift File.dirname(__FILE__)
+require 'test_0000_base'
+#
+# Test send and receive using a Stomp Client.
+#
+class Test_0011_Send_Recv < Test_0000_Base
+
+  # Setup
+  # * Specify test queue name
+  # * Specify message content
+  # * Loop count for multiple times tests
+  # * Open a Stomp Client
+  def setup
+    super
+    @queue_name = "/queue/sendrecv/" + name()
+    @test_message = "This is a test message."
+    @times = 10
+    open_client()
+  end
+
+  # Teardown.
+  # * Close the Stomp Client
+  def teardown
+    close_client()
+  end
+
+  # Test single message send and receive.
+  def test_0010_send_receive
+    assert_nothing_raised() {
+      received = nil
+      #
+      @client.publish(@queue_name, @test_message, 
+        {"persistent" => true, 
+        "client-id" => "0011_sr1send", 
+        "reply-to" => @queue_name} )
+      #
+      @client.subscribe(@queue_name,
+       {"persistent" => true, "client-id" => "0011_sr1recv"} ) do |message|
+        received = message
+      end
+      sleep 0.1 until received
+      assert_equal(@test_message, received.body, "what is sent should be received")
+    }
+  end
+
+  # Test send and receive of multiple messages.
+  def test_0020_send_mult_receive
+    assert_nothing_raised() {
+      received = nil
+      #
+      @times.times do |n|
+        @client.publish(@queue_name, @test_message + " #{n}", 
+          {"persistent" => true, 
+          "client-id" => "0011_srXsend", 
+          "reply-to" => @queue_name} )
+      end
+      #
+      count = 0
+      @client.subscribe(@queue_name,
+       {"persistent" => true, "client-id" => "0011_srXrecv"} ) do |message|
+        count += 1
+        received = message
+      end
+      sleep 0.25 until received
+      assert_equal(@times,count,"0011 counts should match")
+    }
+  end
+
+end # of class
+