stomp 1.3.4 → 1.3.5

data/CHANGELOG.rdoc

@@ -1,3 +1,14 @@
+== 1.3.5 20160302
+
+* Add AMQ specific durable topic example.
+* Output error to stderr only in logger is undefined.
+* Move README changelog lower.
+* Handle newline at start of receive buffer.
+* Use Timeout::timeout instead of deprecated kernel version.
+* If socket open on reconnect, close it before new open.
+* On misc_err, make error messages more readable.
+* Attempt to support both Rspec 2.14.1+ and 3.x.
+
 == 1.3.4 20141202
 
 * Change :start_timeout default to 0 (might break some clients) (#98).

data/README.rdoc

@@ -8,33 +8,6 @@ An implementation of the Stomp protocol for Ruby. See:
 
 * [STOMP 1.0, 1.1, and 1.2] (http://stomp.github.com/index.html)
 
-===New
-
-See _CHANGELOG.rdoc_ for details.
-
-* Gem version 1.3.4. Miscellaneous fixes, see CHANGELOG.rdoc for details.
-* Gem version 1.3.3. Miscellaneous fixes, see CHANGELOG.rdoc for details.
-* Gem version 1.3.2. Miscellaneous fixes, see changelog for details.
-* Gem version 1.3.1. Bugfix for logging.
-* Gem version 1.3.0. Added ERROR frame raising as exception, added anonymous connections, miscellaneous other fixes.
-* Gem version 1.2.16. Fixed Stomp::Client to expose its connection's host parameters.
-* Gem version 1.2.15. Timeout cleanup, added license info to gemspec.
-* Gem version 1.2.14. Cleanup.
-* Gem version 1.2.13. Stomp::Client#unreceive max_redeliveries fix.
-* Gem version 1.2.12. Miscellaneous issue fixes and cleanup.
-* Gem version 1.2.11. JRuby and AMQ support fixes.
-* Gem version 1.2.10. Support failover from heartbeat threads.
-* Gem version 1.2.9. Miscellaneous fixes and changes.
-* Gem version 1.2.8. Stomp 1.1+ header codec inversion fix, test refactoring.
-* Gem version 1.2.7. Stomp 1.2 support and miscellaneous fixes.
-* Gem version 1.2.6. Miscellaneous fixes and changes.
-* Gem version 1.2.5. Restructure. Forks with modifcations will be affected.
-* Gem version 1.2.4. Stomp 1.1 heartbeat fix, autoflush capability, miscellaneous fixes.
-* Gem version 1.2.3. Miscellaneous fixes, see changelog for details.
-* Gem version 1.2.2. Performance and more SSL enhancements.
-* Gem version 1.2.1. Full support of SSL certificates.
-* Gem version 1.2.0. Support of Stomp protocol level 1.1.
-
 ===Hash Login Example Usage (this is the recommended login technique)
 
   hash = {
@@ -111,6 +84,34 @@ See _CHANGELOG.rdoc_ for details.
       p msg
     end
 
+===New
+
+See _CHANGELOG.rdoc_ for details.
+
+* Gem version 1.3.5. Miscellaneous fixes, see CHANGELOG.rdoc for details.
+* Gem version 1.3.4. Miscellaneous fixes, see CHANGELOG.rdoc for details.
+* Gem version 1.3.3. Miscellaneous fixes, see CHANGELOG.rdoc for details.
+* Gem version 1.3.2. Miscellaneous fixes, see changelog for details.
+* Gem version 1.3.1. Bugfix for logging.
+* Gem version 1.3.0. Added ERROR frame raising as exception, added anonymous connections, miscellaneous other fixes.
+* Gem version 1.2.16. Fixed Stomp::Client to expose its connection's host parameters.
+* Gem version 1.2.15. Timeout cleanup, added license info to gemspec.
+* Gem version 1.2.14. Cleanup.
+* Gem version 1.2.13. Stomp::Client#unreceive max_redeliveries fix.
+* Gem version 1.2.12. Miscellaneous issue fixes and cleanup.
+* Gem version 1.2.11. JRuby and AMQ support fixes.
+* Gem version 1.2.10. Support failover from heartbeat threads.
+* Gem version 1.2.9. Miscellaneous fixes and changes.
+* Gem version 1.2.8. Stomp 1.1+ header codec inversion fix, test refactoring.
+* Gem version 1.2.7. Stomp 1.2 support and miscellaneous fixes.
+* Gem version 1.2.6. Miscellaneous fixes and changes.
+* Gem version 1.2.5. Restructure. Forks with modifcations will be affected.
+* Gem version 1.2.4. Stomp 1.1 heartbeat fix, autoflush capability, miscellaneous fixes.
+* Gem version 1.2.3. Miscellaneous fixes, see changelog for details.
+* Gem version 1.2.2. Performance and more SSL enhancements.
+* Gem version 1.2.1. Full support of SSL certificates.
+* Gem version 1.2.0. Support of Stomp protocol level 1.1.
+
 ===Historical Information
 
 Up until March 2009 the project was maintained and primarily developed by Brian McCallister.
@@ -155,4 +156,8 @@ The following people have contributed to Stomp:
 * Glenn Roberts
 * Ian Smith
 * Orazio Cotroneo
+* m4rCsi
+* Michael Klishin
+* Patrick Sharp
+* Wayne Robinson
 

data/Rakefile

@@ -37,7 +37,7 @@ begin
     gem.homepage = "https://github.com/stompgem/stomp"
     gem.authors = ["Brian McCallister", 'Marius Mathiesen', 'Thiago Morello',
         'Guy M. Allard']
-    gem.add_development_dependency "rspec", '>= 2.3'
+    gem.add_development_dependency "rspec", '>= 2.14.1'
     gem.extra_rdoc_files = [ "README.rdoc", "CHANGELOG.rdoc", "LICENSE",
       "lib/**/*.rb", "examples/**/*.rb",
       "test/**/*.rb" ]

data/examples/amqdurasub.rb

@@ -0,0 +1,81 @@
+# -*- encoding: utf-8 -*-
+
+#
+# The current require dance for different Ruby versions.
+# Change this to suit your requirements.
+#
+if Kernel.respond_to?(:require_relative)
+  require_relative("./stomp11_common")
+else
+  $LOAD_PATH << File.dirname(__FILE__)
+  require "stomp11_common"
+end
+
+=begin
+
+  A recent experience suggested that we might provide an example of how
+  to establish a "durable" topic subscription using ActiveMQ.
+
+  This code attempts to do that.
+
+  References: 
+
+  http://activemq.apache.org/stomp.html
+
+  http://activemq.apache.org/how-does-a-queue-compare-to-a-topic.html
+
+  http://activemq.apache.org/how-do-durable-queues-and-topics-work.html
+
+  Specifically, locate the section titled: ActiveMQ extensions to Stomp.
+
+  There are two programmatic requirements:
+
+  1) On CONNECT, indicate to AMQ the code will be using durable topic 
+    subscription(s).
+    Done by providing a "cilent-id" CONNECT header.
+
+  2) On SUBSCRIBE, indicate an AMQ specific (uniqie) subscription ID.  Done
+    by providing a "activemq.subscriptionName" header to SUBSCRIBE.
+
+=end
+
+# login hash
+hash = { :hosts => [ 
+       {:login => 'guest', :passcode => 'guest', :host => 'localhost', :port => 61613, :ssl => false}, # AMQ
+      ],
+      :reliable => true,
+			:closed_check => false, 
+      :connect_headers => {:host => "localhost", :"accept-version" => "1.0",
+        # Requirement 1, name should be unique.
+        :"client-id" => "dursubcli01",  # REF the 1st AMQ link above
+			} 
+    }
+# The topic
+topic = "/topic/topicName"
+
+# Establish the client connection
+cli = Stomp::Client.open(hash)
+# SUBSCRIBE Headers
+sh = { "activemq.subscriptionName" => "subname01" } # REF the 1st AMQ link above
+# And the client subscribe
+cli.subscribe(topic, sh) do |msg|
+  puts "msg: #{msg}"
+end
+# Wait for a very long time, usually exit via ^C
+puts "Press ^C to exit"
+sleep 1000000
+puts "Done yet?"
+
+=begin
+  At this point open your AMQ admin console (port 8161 usually), and examine 
+  the 'subscribers' section.  You should see an instance of this client 
+  displayed in the "Active Durable Topic Subscribers" section.
+
+  When you press ^C to exit this program, return to the AMQ console and
+  refresh the display.  (Do not restart AMQ).  You should see this client in the
+  "Offline Durable Topic Subscribers" section.
+=end
+
+
+
+

data/lib/connection/netio.rb

@@ -31,6 +31,8 @@ module Stomp
         end
         #
         return nil if line.nil?
+        #An extra \n at the beginning of the frame, possibly not caught by is_ready?
+        line = '' if line == "\n"
         # p [ "wiredatain_01", line ]
         line = _normalize_line_end(line) if @protocol >= Stomp::SPL_12
         # If the reading hangs for more than X seconds, abort the parsing process.

data/lib/connection/utils.rb

@@ -245,9 +245,13 @@ module Stomp
           @failure = $!
           raise unless @reliable
           errstr = "receive failed: #{$!}"
-          unless slog(:on_miscerr, log_params, "es_oldrecv: " + errstr)
-            $stderr.print errstr
-          end
+          unless slog(:on_miscerr, log_params, "es1_oldrecv: " + errstr)
+            $stderr.print "\non_miscerr\n"
+            $stderr.print log_params.inspect
+            $stderr.print "\n"
+            $stderr.print "es2_oldrecv: " + errstr
+            $stderr.print "\n"
+         end
 
           # !!! This initiates a re-connect !!!
           _reconn_prep()
@@ -257,6 +261,7 @@ module Stomp
 
     # _reconn_prep prepares for a reconnect retry
     def _reconn_prep()
+      close_socket()
       if @parameters
         change_host()
       end

data/lib/stomp/client.rb

@@ -87,7 +87,7 @@ module Stomp
       check_arguments!()
 
       begin
-        timeout(@start_timeout) {
+        Timeout::timeout(@start_timeout) {
           create_error_handler
           create_connection(autoflush)
           start_listeners()

data/lib/stomp/connection.rb

@@ -442,8 +442,9 @@ module Stomp
       super_result = __old_receive()
       if super_result.nil? && @reliable && !closed?
         errstr = "connection.receive returning EOF as nil - resetting connection.\n"
-        slog(:on_miscerr, log_params, "es_recv: " + errstr)
-        $stderr.print errstr
+        unless slog(:on_miscerr, log_params, "es_recv: " + errstr)
+          $stderr.print errstr
+        end
 
         # !!! This initiates a re-connect !!!
         # The call to __old_receive() will in turn call socket().  Before

data/lib/stomp/message.rb

@@ -102,8 +102,6 @@ module Stomp
       "<Stomp::Message headers=#{headers.inspect} body='#{body}' command='#{command}' >"
     end
 
-    private
-
     # is_blank? tests if a data value is nil or empty.
     def is_blank?(value)
       value.nil? || (value.respond_to?(:empty?) && value.empty?)

data/lib/stomp/null_logger.rb

@@ -3,8 +3,11 @@
 module Stomp
   class NullLogger
     def on_miscerr(parms, error_msg)
-      $stderr.print parms
+      $stderr.print "\non_miscerr\n"
+      $stderr.print parms.inspect
+      $stderr.print "\n"
       $stderr.print error_msg
+      $stderr.print "\n"
     end
 
     def on_connecting(parms); end

data/lib/stomp/version.rb

@@ -6,7 +6,7 @@ module Stomp
   module Version  #:nodoc: all
     MAJOR = 1
     MINOR = 3
-    PATCH = 4
+    PATCH = 5
     STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
   end
 end

data/spec/client_shared_examples.rb

@@ -11,58 +11,58 @@ shared_examples_for "standard Client" do
 
   describe "the closed? method" do
     it "should be false when the connection is open" do
-      @mock_connection.stub!(:closed?).and_return(false)
-      @client.closed?.should == false
+      allow(@mock_connection).to receive(:closed?).and_return(false)
+      expect(@client.closed?).to eq(false)
     end
 
     it "should be true when the connection is closed" do
-      @mock_connection.stub!(:closed?).and_return(true)
-      @client.closed?.should == true
+      allow(@mock_connection).to receive(:closed?).and_return(true)
+      expect(@client.closed?).to eq(true)
     end
   end
 
   describe "the open? method" do
     it "should be true when the connection is open" do
-      @mock_connection.stub!(:open?).and_return(true)
-      @client.open?.should == true
+      allow(@mock_connection).to receive(:open?).and_return(true)
+      expect(@client.open?).to eq(true)
     end
 
     it "should be false when the connection is closed" do
-      @mock_connection.stub!(:open?).and_return(false)
-      @client.open?.should == false
+      allow(@mock_connection).to receive(:open?).and_return(false)
+      expect(@client.open?).to eq(false)
     end
   end
 
   describe "the subscribe method" do
 
     before(:each) do
-      @mock_connection.stub!(:subscribe).and_return(true)
+      allow(@mock_connection).to receive(:subscribe).and_return(true)
     end
 
     it "should raise RuntimeError if not passed a block" do
-      lambda {
+      expect {
         @client.subscribe(@destination)
-      }.should raise_error
+      }.to raise_error(RuntimeError)
     end
 
     it "should not raise an error when passed a block" do
-      lambda {
+      expect {
         @client.subscribe(@destination) {|msg| received = msg}
-      }.should_not raise_error
+      }.not_to raise_error
     end
 
     it "should raise RuntimeError on duplicate subscriptions" do
-      lambda {
+      expect {
         @client.subscribe(@destination)
         @client.subscribe(@destination)
-      }.should raise_error
+      }.to raise_error(RuntimeError)
     end
 
     it "should raise RuntimeError with duplicate id headers" do
-      lambda {
+      expect {
         @client.subscribe(@destination, {'id' => 'abcdef'})
         @client.subscribe(@destination, {'id' => 'abcdef'})
-      }.should raise_error
+      }.to raise_error(RuntimeError)
     end
 
   end

data/spec/client_spec.rb

@@ -8,9 +8,9 @@ describe Stomp::Client do
   let(:null_logger) { double("mock Stomp::NullLogger") }
 
   before(:each) do
-    Stomp::NullLogger.stub(:new).and_return(null_logger)
+    allow(Stomp::NullLogger).to receive(:new).and_return(null_logger)
     @mock_connection = double('connection', :autoflush= => true)
-    Stomp::Connection.stub(:new).and_return(@mock_connection)
+    allow(Stomp::Connection).to receive(:new).and_return(@mock_connection)
   end
 
   describe "(created with no params)" do
@@ -20,15 +20,15 @@ describe Stomp::Client do
     end
 
     it "should not return any errors" do
-      lambda {
+      expect {
         @client = Stomp::Client.new
-      }.should_not raise_error
+      }.not_to raise_error
     end
 
     it "should not return any errors when created with the open constructor" do
-      lambda {
+      expect {
         @client = Stomp::Client.open
-      }.should_not raise_error
+      }.not_to raise_error
     end
 
     it_should_behave_like "standard Client"
@@ -43,34 +43,53 @@ describe Stomp::Client do
                                               :port => 12345,
                                               :host => 'dummy host',
                                               :ssl => 'dummy ssl')
-      Stomp::Connection.stub(:new).and_return(@mock_connection)
+      allow(Stomp::Connection).to receive(:new).and_return(@mock_connection)
       @client = Stomp::Client.new
     end
 
     describe 'it should delegate parameters to its connection' do
       subject { @client }
 
-      its(:login) { should eql 'dummy login' }
-      its(:passcode) { should eql 'dummy passcode' }
-      its(:port) { should eql 12345 }
-      its(:host) { should eql 'dummy host' }
-      its(:ssl) { should eql 'dummy ssl' }
+      describe '#login' do
+        subject { super().login }
+        it { should eql 'dummy login' }
+      end
+
+      describe '#passcode' do
+        subject { super().passcode }
+        it { should eql 'dummy passcode' }
+      end
+
+      describe '#port' do
+        subject { super().port }
+        it { should eql 12345 }
+      end
+
+      describe '#host' do
+        subject { super().host }
+        it { should eql 'dummy host' }
+      end
+
+      describe '#ssl' do
+        subject { super().ssl }
+        it { should eql 'dummy ssl' }
+      end
     end
   end
 
   describe "(autoflush)" do
     it "should delegate to the connection for accessing the autoflush property" do
-      @mock_connection.should_receive(:autoflush)
+      expect(@mock_connection).to receive(:autoflush)
       Stomp::Client.new.autoflush
     end
 
     it "should delegate to the connection for setting the autoflush property" do
-      @mock_connection.should_receive(:autoflush=).with(true)
+      expect(@mock_connection).to receive(:autoflush=).with(true)
       Stomp::Client.new.autoflush = true
     end
 
     it "should set the autoflush property on the connection when passing in autoflush as a parameter to the Stomp::Client" do
-      @mock_connection.should_receive(:autoflush=).with(true)
+      expect(@mock_connection).to receive(:autoflush=).with(true)
       Stomp::Client.new("login", "password", 'localhost', 61613, false, true)
     end
   end
@@ -78,33 +97,33 @@ describe Stomp::Client do
   describe "(created with invalid params)" do
 
     it "should return ArgumentError if port is nil" do
-      lambda {
+      expect {
         @client = Stomp::Client.new('login', 'passcode', 'localhost', nil)
-      }.should raise_error
+      }.to raise_error(ArgumentError)
     end
 
     it "should return ArgumentError if port is < 1" do
-      lambda {
+      expect {
         @client = Stomp::Client.new('login', 'passcode', 'localhost', 0)
-      }.should raise_error
+      }.to raise_error(ArgumentError)
     end
 
     it "should return ArgumentError if port is > 65535" do
-      lambda {
+      expect {
         @client = Stomp::Client.new('login', 'passcode', 'localhost', 65536)
-      }.should raise_error
+      }.to raise_error(ArgumentError)
     end
 
     it "should return ArgumentError if port is empty" do
-      lambda {
+      expect {
         @client = Stomp::Client.new('login', 'passcode', 'localhost', '')
-      }.should raise_error
+      }.to raise_error(ArgumentError)
     end
 
     it "should return ArgumentError if reliable is something other than true or false" do
-      lambda {
+      expect {
         @client = Stomp::Client.new('login', 'passcode', 'localhost', '12345', 'foo')
-      }.should raise_error
+      }.to raise_error(ArgumentError)
     end
 
   end
@@ -116,7 +135,7 @@ describe Stomp::Client do
     end
 
     it "should properly parse the URL provided" do
-      Stomp::Connection.should_receive(:new).with(:hosts => [{:login => 'testlogin',
+      expect(Stomp::Connection).to receive(:new).with(:hosts => [{:login => 'testlogin',
                                                               :passcode => 'testpassword',
                                                               :host => 'localhost',
                                                               :port => 12345}],
@@ -135,7 +154,7 @@ describe Stomp::Client do
     end
 
     it "should properly parse the URL provided" do
-      Stomp::Connection.should_receive(:new).with(:hosts => [{:login => '',
+      expect(Stomp::Connection).to receive(:new).with(:hosts => [{:login => '',
                                                               :passcode => '',
                                                               :host => 'foobar',
                                                               :port => 12345}],
@@ -155,7 +174,7 @@ describe Stomp::Client do
     end
 
     it "should properly parse the URL provided" do
-      Stomp::Connection.should_receive(:new).with(:hosts => [{:login => '',
+      expect(Stomp::Connection).to receive(:new).with(:hosts => [{:login => '',
                                                               :passcode => '',
                                                               :host => 'foo-bar',
                                                               :port => 12345}],
@@ -175,7 +194,7 @@ describe Stomp::Client do
     end
 
     it "should properly parse the URL provided" do
-      Stomp::Connection.should_receive(:new).with(:hosts => [{:login => 'test-login',
+      expect(Stomp::Connection).to receive(:new).with(:hosts => [{:login => 'test-login',
                                                               :passcode => 'testpasscode',
                                                               :host => 'foobar',
                                                               :port => 12345}],
@@ -195,7 +214,7 @@ describe Stomp::Client do
     end
 
     it "should properly parse the URL provided" do
-      Stomp::Connection.should_receive(:new).with(:hosts => [{:login => 'test-login',
+      expect(Stomp::Connection).to receive(:new).with(:hosts => [{:login => 'test-login',
                                                               :passcode => 'testpasscode',
                                                               :host => 'foo-bar',
                                                               :port => 12345}],
@@ -218,7 +237,7 @@ describe Stomp::Client do
     end
 
     it "should properly parse the URL provided" do
-      Stomp::Connection.should_receive(:new).with(:hosts => [{:login => '',
+      expect(Stomp::Connection).to receive(:new).with(:hosts => [{:login => '',
                                                               :passcode => '',
                                                               :host => 'host.foobar.com',
                                                               :port => 12345}],
@@ -238,7 +257,7 @@ describe Stomp::Client do
     end
 
     it "should properly parse the URL provided" do
-      Stomp::Connection.should_receive(:new).with(:hosts => [{:login => 'testlogin',
+      expect(Stomp::Connection).to receive(:new).with(:hosts => [{:login => 'testlogin',
                                                               :passcode => 'testpasscode',
                                                               :host => 'host.foobar.com',
                                                               :port => 12345}],
@@ -275,10 +294,10 @@ describe Stomp::Client do
 
       @parameters.merge!({:logger => null_logger})
       
-      Stomp::Connection.should_receive(:new).with(@parameters)
+      expect(Stomp::Connection).to receive(:new).with(@parameters)
       
       client = Stomp::Client.new(url)
-      client.parameters.should == @parameters
+      expect(client.parameters).to eq(@parameters)
     end
     
     it "should properly parse a URL with failover:" do
@@ -292,10 +311,10 @@ describe Stomp::Client do
       
       @parameters.merge!({:logger => null_logger})
       
-      Stomp::Connection.should_receive(:new).with(@parameters)
+      expect(Stomp::Connection).to receive(:new).with(@parameters)
       
       client = Stomp::Client.new(url)
-      client.parameters.should == @parameters
+      expect(client.parameters).to eq(@parameters)
     end
     
     it "should properly parse a URL without user and password" do
@@ -308,10 +327,10 @@ describe Stomp::Client do
       
       @parameters.merge!({:logger => null_logger})
       
-      Stomp::Connection.should_receive(:new).with(@parameters)
+      expect(Stomp::Connection).to receive(:new).with(@parameters)
       
       client = Stomp::Client.new(url)
-      client.parameters.should == @parameters
+      expect(client.parameters).to eq(@parameters)
     end
     
     it "should properly parse a URL with user and/or password blank" do
@@ -324,10 +343,10 @@ describe Stomp::Client do
       
       @parameters.merge!({:logger => null_logger})
       
-      Stomp::Connection.should_receive(:new).with(@parameters)
+      expect(Stomp::Connection).to receive(:new).with(@parameters)
       
       client = Stomp::Client.new(url)
-      client.parameters.should == @parameters
+      expect(client.parameters).to eq(@parameters)
     end
     
     it "should properly parse a URL with the options query" do
@@ -355,10 +374,10 @@ describe Stomp::Client do
       
       @parameters.merge!({:logger => null_logger})
       
-      Stomp::Connection.should_receive(:new).with(@parameters)
+      expect(Stomp::Connection).to receive(:new).with(@parameters)
       
       client = Stomp::Client.new(url)
-      client.parameters.should == @parameters
+      expect(client.parameters).to eq(@parameters)
     end
     
   end

data/spec/connection_spec.rb

@@ -43,8 +43,8 @@ describe Stomp::Connection do
     # clone() does a shallow copy, we want a deep one so we can garantee the hosts order
     normal_parameters = Marshal::load(Marshal::dump(@parameters))
 
-    @tcp_socket = mock(:tcp_socket, :close => nil, :puts => nil, :write => nil, :setsockopt => nil, :flush => true)
-    TCPSocket.stub!(:open).and_return @tcp_socket
+    @tcp_socket = double(:tcp_socket, :close => nil, :puts => nil, :write => nil, :setsockopt => nil, :flush => true)
+    allow(TCPSocket).to receive(:open).and_return @tcp_socket
     @connection = Stomp::Connection.new(normal_parameters)
   end
 
@@ -68,13 +68,13 @@ describe Stomp::Connection do
     }
 
     it "should call flush on the socket when autoflush is true" do
-      @tcp_socket.should_receive(:flush)
+      expect(@tcp_socket).to receive(:flush)
       @connection = Stomp::Connection.new(parameter_hash.merge("autoflush" => true))
       @connection.publish "/queue", "message", :suppress_content_length => false
     end
 
     it "should not call flush on the socket when autoflush is false" do
-      @tcp_socket.should_not_receive(:flush)
+      expect(@tcp_socket).not_to receive(:flush)
       @connection = Stomp::Connection.new(parameter_hash)
       @connection.publish "/queue", "message", :suppress_content_length => false
     end    
@@ -108,61 +108,61 @@ describe Stomp::Connection do
       }
       
       @connection = Stomp::Connection.new(used_hash)
-      @connection.instance_variable_get(:@parameters).should == @parameters
+      expect(@connection.instance_variable_get(:@parameters)).to eq(@parameters)
     end
    
     it "should start with first host in array" do
-      @connection.instance_variable_get(:@host).should == "localhost"
+      expect(@connection.instance_variable_get(:@host)).to eq("localhost")
     end
     
     it "should change host to next one with randomize false" do
       @connection.send(:change_host) # use .send(:name) to test a private method!
-      @connection.instance_variable_get(:@host).should == "remotehost"
+      expect(@connection.instance_variable_get(:@host)).to eq("remotehost")
     end
     
     it "should use default port (61613) if none is given" do
       hash = {:hosts => [{:login => "login2", :passcode => "passcode2", :host => "remotehost", :ssl => false}]}
       @connection = Stomp::Connection.new hash
-      @connection.instance_variable_get(:@port).should == 61613
+      expect(@connection.instance_variable_get(:@port)).to eq(61613)
     end
 
     context "should be able pass reliable as part of hash" do
       it "should be false if reliable is set to false" do
         hash = @parameters.merge({:reliable => false })
         connection = Stomp::Connection.new(hash)
-        connection.instance_variable_get(:@reliable).should be_false
+        expect(connection.instance_variable_get(:@reliable)).to be false
       end
       
       it "should be true if reliable is set to true" do
         hash = @parameters.merge({:reliable => true })
         connection = Stomp::Connection.new(hash)
-        connection.instance_variable_get(:@reliable).should be_true
+        expect(connection.instance_variable_get(:@reliable)).to be true
       end
       
       it "should be true if reliable is not set" do
         connection = Stomp::Connection.new(@parameters)
-        connection.instance_variable_get(:@reliable).should be_true
+        expect(connection.instance_variable_get(:@reliable)).to be true
       end
     end
     
     context "when dealing with content-length header" do
       it "should not suppress it when receiving :suppress_content_length => false" do
-        @tcp_socket.should_receive(:puts).with("content-length:7")
+        expect(@tcp_socket).to receive(:puts).with("content-length:7")
         @connection.publish "/queue", "message", :suppress_content_length => false
       end
       
       it "should not suppress it when :suppress_content_length is nil" do
-        @tcp_socket.should_receive(:puts).with("content-length:7")
+        expect(@tcp_socket).to receive(:puts).with("content-length:7")
         @connection.publish "/queue", "message"
       end
     
       it "should suppress it when receiving :suppress_content_length => true" do
-        @tcp_socket.should_not_receive(:puts).with("content-length:7")
+        expect(@tcp_socket).not_to receive(:puts).with("content-length:7")
         @connection.publish "/queue", "message", :suppress_content_length => true
       end
       
       it "should get the correct byte length when dealing with Unicode characters" do
-        @tcp_socket.should_receive(:puts).with("content-length:18")
+        expect(@tcp_socket).to receive(:puts).with("content-length:18")
         @connection.publish "/queue", "сообщение"  # 'сообщение' is 'message' in Russian
       end
     end
@@ -184,31 +184,31 @@ describe Stomp::Connection do
       end
       
       it "should use a transaction" do
-        @connection.should_receive(:begin).with(@transaction_id).ordered
-        @connection.should_receive(:commit).with(@transaction_id).ordered
+        expect(@connection).to receive(:begin).with(@transaction_id).ordered
+        expect(@connection).to receive(:commit).with(@transaction_id).ordered
         @connection.unreceive @message
       end
     
       it "should acknowledge the original message if ack mode is client" do
-        @connection.should_receive(:ack).with(@message.headers["message-id"], :transaction => @transaction_id)
+        expect(@connection).to receive(:ack).with(@message.headers["message-id"], :transaction => @transaction_id)
         @connection.subscribe(@message.headers["destination"], :ack => "client")
         @connection.unreceive @message
       end
       
       it "should acknowledge the original message if forced" do      
         @connection.subscribe(@message.headers["destination"])
-        @connection.should_receive(:ack)
+        expect(@connection).to receive(:ack)
         @connection.unreceive(@message, :force_client_ack => true)
       end
       
       it "should not acknowledge the original message if ack mode is not client or it did not subscribe to the queue" do      
         @connection.subscribe(@message.headers["destination"], :ack => "client")
-        @connection.should_receive(:ack)
+        expect(@connection).to receive(:ack)
         @connection.unreceive @message
         
         # At this time the message headers are symbolized
         @connection.unsubscribe(@message.headers[:destination])
-        @connection.should_not_receive(:ack)
+        expect(@connection).not_to receive(:ack)
         @connection.unreceive @message
         @connection.subscribe(@message.headers[:destination], :ack => "individual")
         @connection.unreceive @message
@@ -216,14 +216,14 @@ describe Stomp::Connection do
       
       it "should send the message back to the queue it came" do
         @connection.subscribe(@message.headers["destination"], :ack => "client")
-        @connection.should_receive(:publish).with(@message.headers["destination"], @message.body, @retry_headers)
+        expect(@connection).to receive(:publish).with(@message.headers["destination"], @message.body, @retry_headers)
         @connection.unreceive @message
       end
       
       it "should increment the retry_count header" do
         @message.headers["retry_count"] = 4
         @connection.unreceive @message
-        @message.headers[:retry_count].should == 5
+        expect(@message.headers[:retry_count]).to eq(5)
       end
       
       it "should not send the message to the dead letter queue as persistent if retry_count is less than max redeliveries" do
@@ -233,7 +233,7 @@ describe Stomp::Connection do
         @message.headers["retry_count"] = max_redeliveries - 1
         transaction_id = "transaction-#{@message.headers["message-id"]}-#{@message.headers["retry_count"]}"
         @retry_headers = @retry_headers.merge :transaction => transaction_id, :retry_count => @message.headers["retry_count"] + 1
-        @connection.should_receive(:publish).with(@message.headers["destination"], @message.body, @retry_headers)
+        expect(@connection).to receive(:publish).with(@message.headers["destination"], @message.body, @retry_headers)
         @connection.unreceive @message, :dead_letter_queue => dead_letter_queue, :max_redeliveries => max_redeliveries
       end
       
@@ -245,14 +245,14 @@ describe Stomp::Connection do
         @message.headers["retry_count"] = max_redeliveries
         transaction_id = "transaction-#{@message.headers["message-id"]}-#{@message.headers["retry_count"]}"
         @retry_headers = @retry_headers.merge :persistent => true, :transaction => transaction_id, :retry_count => @message.headers["retry_count"] + 1, :original_destination=> @message.headers["destination"]
-        @connection.should_receive(:publish).with(dead_letter_queue, @message.body, @retry_headers)
+        expect(@connection).to receive(:publish).with(dead_letter_queue, @message.body, @retry_headers)
         @connection.unreceive @message, :dead_letter_queue => dead_letter_queue, :max_redeliveries => max_redeliveries
       end
       
       it "should rollback the transaction and raise the exception if happened during transaction" do
-        @connection.should_receive(:publish).and_raise "Error"
-        @connection.should_receive(:abort).with(@transaction_id)
-        lambda {@connection.unreceive @message}.should raise_error("Error")
+        expect(@connection).to receive(:publish).and_raise "Error"
+        expect(@connection).to receive(:abort).with(@transaction_id)
+        expect {@connection.unreceive @message}.to raise_error("Error")
       end
     
     end
@@ -260,9 +260,9 @@ describe Stomp::Connection do
     describe "when sending a nil message body" do
       it "should should not raise an error" do
         @connection = Stomp::Connection.new("niluser", "nilpass", "localhost", 61613)
-        lambda {
+        expect {
           @connection.publish("/queue/nilq", nil)
-        }.should_not raise_error
+        }.not_to raise_error
      end
     end
 
@@ -284,55 +284,55 @@ describe Stomp::Connection do
       
       before(:each) do
         ssl_parameters = {:hosts => [{:login => "login2", :passcode => "passcode2", :host => "remotehost", :ssl => true}]}
-        @ssl_socket = mock(:ssl_socket, :puts => nil, :write => nil, 
+        @ssl_socket = double(:ssl_socket, :puts => nil, :write => nil, 
           :setsockopt => nil, :flush => true)
-        @ssl_socket.stub!(:sync_close=)
+        allow(@ssl_socket).to receive(:sync_close=)
         
-        TCPSocket.should_receive(:open).and_return @tcp_socket
-        OpenSSL::SSL::SSLSocket.should_receive(:new).and_return(@ssl_socket)
-        @ssl_socket.should_receive(:connect)
+        expect(TCPSocket).to receive(:open).and_return @tcp_socket
+        expect(OpenSSL::SSL::SSLSocket).to receive(:new).and_return(@ssl_socket)
+        expect(@ssl_socket).to receive(:connect)
         
         @connection = Stomp::Connection.new ssl_parameters
       end
     
       it "should use ssl socket if ssl use is enabled" do
-        @connection.instance_variable_get(:@socket).should == @ssl_socket
+        expect(@connection.instance_variable_get(:@socket)).to eq(@ssl_socket)
       end
     
       it "should use default port for ssl (61612) if none is given" do
-        @connection.instance_variable_get(:@port).should == 61612
+        expect(@connection.instance_variable_get(:@port)).to eq(61612)
       end
       
     end
 
     describe "when called to increase reconnect delay" do
       it "should exponentialy increase when use_exponential_back_off is true" do
-        @connection.send(:increase_reconnect_delay).should == 0.02
-        @connection.send(:increase_reconnect_delay).should == 0.04
-        @connection.send(:increase_reconnect_delay).should == 0.08
+        expect(@connection.send(:increase_reconnect_delay)).to eq(0.02)
+        expect(@connection.send(:increase_reconnect_delay)).to eq(0.04)
+        expect(@connection.send(:increase_reconnect_delay)).to eq(0.08)
       end
       it "should not increase when use_exponential_back_off is false" do
         @parameters[:use_exponential_back_off] = false
         @connection = Stomp::Connection.new(@parameters)
-        @connection.send(:increase_reconnect_delay).should == 0.01
-        @connection.send(:increase_reconnect_delay).should == 0.01
+        expect(@connection.send(:increase_reconnect_delay)).to eq(0.01)
+        expect(@connection.send(:increase_reconnect_delay)).to eq(0.01)
       end
       it "should not increase when max_reconnect_delay is reached" do
         @parameters[:initial_reconnect_delay] = 8.0
         @connection = Stomp::Connection.new(@parameters)
-        @connection.send(:increase_reconnect_delay).should == 16.0
-        @connection.send(:increase_reconnect_delay).should == 30.0
+        expect(@connection.send(:increase_reconnect_delay)).to eq(16.0)
+        expect(@connection.send(:increase_reconnect_delay)).to eq(30.0)
       end
       
       it "should change to next host on socket error" do
         @connection.instance_variable_set(:@failure, "some exception")
         #retries the same host
-        TCPSocket.should_receive(:open).and_raise "exception"
+        expect(TCPSocket).to receive(:open).and_raise "exception"
         #tries the new host
-        TCPSocket.should_receive(:open).and_return @tcp_socket
+        expect(TCPSocket).to receive(:open).and_return @tcp_socket
 
         @connection.send(:socket)
-        @connection.instance_variable_get(:@host).should == "remotehost"
+        expect(@connection.instance_variable_get(:@host)).to eq("remotehost")
       end
       
       it "should use default options if those where not given" do
@@ -373,7 +373,7 @@ describe Stomp::Connection do
         }
         
         @connection = Stomp::Connection.new(used_hash)
-        @connection.instance_variable_get(:@parameters).should == expected_hash
+        expect(@connection.instance_variable_get(:@parameters)).to eq(expected_hash)
       end
       
       it "should use the given options instead of default ones" do
@@ -415,7 +415,7 @@ describe Stomp::Connection do
         received_hash.delete(:hosts)
         used_hash.delete(:hosts)
         
-        received_hash.should == used_hash
+        expect(received_hash).to eq(used_hash)
       end
       
     end
@@ -424,12 +424,12 @@ describe Stomp::Connection do
   
   describe "when closing a socket" do
     it "should close the tcp connection" do
-      @tcp_socket.should_receive(:close)
-      @connection.__send__(:close_socket).should be_true # Use Object.__send__
+      expect(@tcp_socket).to receive(:close)
+      expect(@connection.__send__(:close_socket)).to be true # Use Object.__send__
     end
     it "should ignore exceptions" do
-      @tcp_socket.should_receive(:close).and_raise "exception"
-      @connection.__send__(:close_socket).should be_true # Use Object.__send__
+      expect(@tcp_socket).to receive(:close).and_raise "exception"
+      expect(@connection.__send__(:close_socket)).to be true # Use Object.__send__
     end
   end
 
@@ -438,11 +438,11 @@ describe Stomp::Connection do
       host = @parameters[:hosts][0]
       @connection = Stomp::Connection.new(host[:login], host[:passcode], host[:host], host[:port], reliable = true, 5, connect_headers = {})
       @connection.instance_variable_set(:@connection_attempts, 10000)
-      @connection.send(:max_reconnect_attempts?).should be_false
+      expect(@connection.send(:max_reconnect_attempts?)).to be false
     end
     it "should return false if max_reconnect_attempts = 0" do
       @connection.instance_variable_set(:@connection_attempts, 10000)
-      @connection.send(:max_reconnect_attempts?).should be_false
+      expect(@connection.send(:max_reconnect_attempts?)).to be false
     end
     it "should return true if connection attempts > max_reconnect_attempts" do
       limit = 10000
@@ -450,17 +450,17 @@ describe Stomp::Connection do
       @connection = Stomp::Connection.new(@parameters)
       
       @connection.instance_variable_set(:@connection_attempts, limit-1)
-      @connection.send(:max_reconnect_attempts?).should be_false
+      expect(@connection.send(:max_reconnect_attempts?)).to be false
       
       @connection.instance_variable_set(:@connection_attempts, limit)
-      @connection.send(:max_reconnect_attempts?).should be_true
+      expect(@connection.send(:max_reconnect_attempts?)).to be true
     end
     # These should be raised for the user to deal with
     it "should not rescue MaxReconnectAttempts" do
       @connection = Stomp::Connection.new(@parameters)
-      @connection.stub(:socket).and_raise(Stomp::Error::MaxReconnectAttempts)
+      allow(@connection).to receive(:socket).and_raise(Stomp::Error::MaxReconnectAttempts)
       
-      expect { @connection.receive() }.to raise_error
+      expect { @connection.receive() }.to raise_error(RuntimeError)
     end
   end
 

data/spec/message_spec.rb

@@ -9,11 +9,12 @@ describe Stomp::Message do
     context 'with invalid parameters' do
       it 'should return an empty message when receiving an empty string or nil parameter' do
         message = Stomp::Message.new('')
-        message.should be_empty
+        expect(message).to be_empty
+        # message.should be_empty
       end
 
       it 'should raise Stomp::Error::InvalidFormat when receiving a invalid formated message' do
-        lambda{ Stomp::Message.new('any invalid format') }.should raise_error(Stomp::Error::InvalidFormat)
+        expect{ Stomp::Message.new('any invalid format') }.to raise_error(Stomp::Error::InvalidFormat)
       end
     end
 
@@ -24,15 +25,15 @@ describe Stomp::Message do
       end
 
       it 'should parse the headers' do
-        subject.headers.should ==  {'session' => 'host_address'}
+        expect(subject.headers).to eq({'session' => 'host_address'})
       end
 
       it 'should parse the body' do
-        subject.body.should == @message[3]
+        expect(subject.body).to eq(@message[3])
       end
 
       it 'should parse the command' do
-        subject.command.should == @message[0].chomp
+        expect(subject.command).to eq(@message[0].chomp)
       end
     end
     
@@ -43,15 +44,15 @@ describe Stomp::Message do
       end
 
       it 'should parse the headers' do
-        subject.headers.should ==  {'session' => 'host_address'}
+        expect(subject.headers).to eq({'session' => 'host_address'})
       end
 
       it 'should parse the body' do
-        subject.body.should == @message[3]
+        expect(subject.body).to eq(@message[3])
       end
 
       it 'should parse the command' do
-        subject.command.should == @message[0].chomp
+        expect(subject.command).to eq(@message[0].chomp)
       end
     end
   end

data/spec/spec_helper.rb

@@ -5,4 +5,7 @@ dir = File.dirname(__FILE__)
 lib_path = File.expand_path("#{dir}/../lib")
 $LOAD_PATH.unshift lib_path unless $LOAD_PATH.include?(lib_path)
 
+puts "RSpec version: #{RSpec::Version::STRING}"
+$stdout.flush
+
 require 'stomp'

data/stomp.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{stomp}
-  s.version = "1.3.4"
+  s.version = "1.3.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Brian McCallister", "Marius Mathiesen", "Thiago Morello", "Guy M. Allard"]
-  s.date = %q{2014-12-02}
+  s.date = %q{2016-03-02}
   s.description = %q{Ruby client for the Stomp messaging protocol.  Note that this gem is no longer supported on rubyforge.}
   s.email = ["brianm@apache.org", "marius@stones.com", "morellon@gmail.com", "allard.guy.m@gmail.com"]
   s.executables = ["catstomp", "stompcat"]
@@ -17,6 +17,7 @@ Gem::Specification.new do |s|
     "CHANGELOG.rdoc",
     "LICENSE",
     "README.rdoc",
+    "examples/amqdurasub.rb",
     "examples/client11_ex1.rb",
     "examples/client11_putget1.rb",
     "examples/conn11_ex1.rb",
@@ -80,6 +81,7 @@ Gem::Specification.new do |s|
     "Rakefile",
     "bin/catstomp",
     "bin/stompcat",
+    "examples/amqdurasub.rb",
     "examples/client11_ex1.rb",
     "examples/client11_putget1.rb",
     "examples/conn11_ex1.rb",
@@ -154,12 +156,12 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<rspec>, [">= 2.3"])
+      s.add_development_dependency(%q<rspec>, [">= 2.14.1"])
     else
-      s.add_dependency(%q<rspec>, [">= 2.3"])
+      s.add_dependency(%q<rspec>, [">= 2.14.1"])
     end
   else
-    s.add_dependency(%q<rspec>, [">= 2.3"])
+    s.add_dependency(%q<rspec>, [">= 2.14.1"])
   end
 end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: stomp
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: false
   segments: 
   - 1
   - 3
-  - 4
-  version: 1.3.4
+  - 5
+  version: 1.3.5
 platform: ruby
 authors: 
 - Brian McCallister
@@ -18,7 +18,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2014-12-02 00:00:00 -05:00
+date: 2016-03-02 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -29,11 +29,12 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 5
+        hash: 53
         segments: 
         - 2
-        - 3
-        version: "2.3"
+        - 14
+        - 1
+        version: 2.14.1
   type: :development
   version_requirements: *id001
 description: Ruby client for the Stomp messaging protocol.  Note that this gem is no longer supported on rubyforge.
@@ -51,6 +52,7 @@ extra_rdoc_files:
 - CHANGELOG.rdoc
 - LICENSE
 - README.rdoc
+- examples/amqdurasub.rb
 - examples/client11_ex1.rb
 - examples/client11_putget1.rb
 - examples/conn11_ex1.rb
@@ -113,6 +115,7 @@ files:
 - Rakefile
 - bin/catstomp
 - bin/stompcat
+- examples/amqdurasub.rb
 - examples/client11_ex1.rb
 - examples/client11_putget1.rb
 - examples/conn11_ex1.rb