klomp 0.0.4 → 0.0.5

data/ChangeLog.md

@@ -1,6 +1,11 @@
 Changes
 --------------------------------------------------------------------------------
 
+0.0.5 (2012/8/10)
+================================================================================
+
+- set message send/receive logging to debug instead of info
+
 0.0.4 (2012/6/22)
 ================================================================================
 

data/Gemfile

@@ -2,6 +2,7 @@ source "http://rubygems.org"
 
 gem "onstomp", "~> 1.0.7"
 # gem 'onstomp', :path => '../onstomp'
+gem "stomp", "~> 1.2.4"
 gem "json"
 gem "uuid", "~> 2.3.5"
 

data/Gemfile.lock

@@ -9,6 +9,7 @@ GEM
       systemu (~> 2.5.0)
     onstomp (1.0.7)
     rake (0.9.2.2)
+    stomp (1.2.4)
     systemu (2.5.1)
     thor (0.15.2)
     uuid (2.3.5)
@@ -23,4 +24,5 @@ DEPENDENCIES
   json
   onstomp (~> 1.0.7)
   rake
+  stomp (~> 1.2.4)
   uuid (~> 2.3.5)

data/README.md

@@ -1,16 +1,16 @@
 # Klomp
 
-Klomp is a simple wrapper around the [OnStomp](https://github.com/meadvillerb/onstomp/)
-library with some additional HA and usability features:
+Klomp is a simple wrapper around the [Stomp](https://github.com/stompgem/stomp)
+and [OnStomp](https://github.com/meadvillerb/onstomp/) libraries with some
+additional HA and usability features:
 
 * When initialized with multiple broker URIs, Klomp will publish messages to
 one broker at a time, but will consume from all brokers simultaneously. This is
-a slight improvement over the regular [OnStomp::Failover::Client](http://mdvlrb.com/onstomp/OnStomp/Failover/Client.html)
-which handles all publishing and subscribing through a single "active" broker.
-This traditional one-broker-at-a-time technique can lead to a split-brain
-scenario in which messages are only received by a subset of your STOMP clients.
-By consuming from all brokers simultaneously, Klomp ensures that no message is
-left behind.
+a slight improvement over traditional failover clients that work by publishing
+and subscribing through a single "active" broker. This one-broker-at-a-time
+technique can lead to a split-brain scenario in which messages are only
+received by a subset of your STOMP clients. By consuming from all brokers
+simultaneously, Klomp ensures that no message is left behind.
 
 * Where applicable, message bodies are automatically translated between native
 Ruby and JSON objects.
@@ -26,14 +26,13 @@ subscribe block.
 ## Example usage
 
 The goal is that you should be able to use most (if not all) of the standard
-OnStomp API (see [OnStomp's UserNarrative](https://github.com/meadvillerb/onstomp/blob/master/extra_doc/UserNarrative.md))
-via a `Klomp::Client`:
+Stomp/OnStomp APIs via a `Klomp::Client`:
 
     client = Klomp::Client.new([ ... ])
 
 However, there will be some differences in the API due to how `Klomp::Client`
-manages connections. For example, while the `connected?` method normally
-returns a boolean value, Klomp's `connected?` will return an array of booleans
+manages connections. For example, while OnStomp's `connected?` method normally
+returns a single boolean value, Klomp's `connected?` will return many booleans
 (i.e. one result for each broker).
 
 ### Fibonacci back-off retry behavior
@@ -59,6 +58,11 @@ pass implements a `#generate` method that returns a string ID.
     <th>Default value</th>
     <th>Description</th>
   </tr>
+  <tr>
+    <td>:adapter</td>
+    <td>:onstomp</td>
+    <td>Stomp library to use. Currently, only :stomp and :onstomp are supported.</td>
+  </tr>
   <tr>
     <td>:translate_json</td>
     <td>true</td>
@@ -75,9 +79,9 @@ pass implements a `#generate` method that returns a string ID.
     <td>Logger object</td>
   </tr>
   <tr>
-  <td>:uuid</td>
-  <td>UUID.new</td>
-  <td>UUID generator object, responds to :generate and returns an ID</td>
+    <td>:uuid</td>
+    <td>UUID.new</td>
+    <td>UUID generator object, responds to :generate and returns an ID</td>
   </tr>
 </table>
 
@@ -102,9 +106,7 @@ failover.
 
 ## Change Log
 
-### 0.0.1
-
-* Initial release
+See the [ChangeLog file](/livingsocial/klomp/blob/master/ChangeLog.md).
 
 ## License
 

data/lib/klomp.rb

@@ -1,5 +1,5 @@
 require 'klomp/client'
 
 module Klomp
-  VERSION = '0.0.4'
+  VERSION = '0.0.5'
 end

data/lib/klomp/client.rb

@@ -1,21 +1,50 @@
 require 'onstomp'
 require 'onstomp/failover'
+require 'stomp'
 require 'json'
 require 'uuid'
 require 'logger'
+require 'pp'
 
 class OnStomp::Failover::Client
   # Save previous N, N-1 delays for fibonacci backoff
   attr_accessor :prev_retry_delay
 end
 
+class Hash
+  def to_query_string
+    self.inject([]) { |memo,(k,v)| memo + ["#{k}=#{v}"] }.join('&')
+  end
+end
+
 module Klomp
 
   class Client
-    attr_reader :read_conn, :write_conn
+    attr_reader :read_conn, :write_conn, :all_conn
     attr_accessor :last_connect_exception
 
+    WRITE_ONLY_METHODS = [
+      :abort,
+      :begin,
+      :commit,
+    ]
+
+    READ_ONLY_METHODS = [
+      :ack,
+      :nack,
+    ]
+
+    TRANSLATE_METHODS = {
+      :connected? => {
+        :stomp => :open?
+      },
+      :ack => {
+        :stomp => :acknowledge
+      }
+    }
+
     def initialize(uri, options={})
+      @adapter        = options.fetch(:adapter, :onstomp)
       @translate_json = options.fetch(:translate_json, true)
       @auto_reply_to  = options.fetch(:auto_reply_to, true)
       @logger         = options.fetch(:logger, nil)
@@ -27,44 +56,91 @@ module Klomp
       options[:retry_delay]    ||= 1
       options[:retry_attempts] ||= -1
 
-      if uri.is_a?(Array)
-        @write_conn = OnStomp::Failover::Client.new(uri, options)
-        @read_conn = uri.map {|obj| OnStomp::Failover::Client.new([obj], options) }
+      case @adapter
+      when :onstomp
+        if uri.is_a?(Array)
+          @write_conn = OnStomp::Failover::Client.new(uri, options)
+          @read_conn = uri.map {|obj| OnStomp::Failover::Client.new([obj], options) }
+        else
+          @write_conn = OnStomp::Failover::Client.new([uri], options)
+          @read_conn = [@write_conn]
+        end
+      when :stomp
+        # Failover in the Stomp library is kind of flaky. If the client
+        # temporarily loses its connection, it is eventually able to reconnect
+        # and resume sending messages. However, the subscribe thread never
+        # seems to recover. One workaround I discovered is to always create new
+        # clients with the following URL scheme:
+        #
+        # failover:(stomp://localhost,stomp://localhost)
+        #
+        # Notice that we're using a failover URL in which the same host is
+        # specified twice. It's a pretty silly hack, but it's the only way I've
+        # been able to get failover to work reliably.
+        #
+        # - Mike Conigliaro
+        #
+        if uri.is_a?(Array)
+          @write_conn = Stomp::Client.new("failover:(#{uri.join(',')})?#{options.to_query_string}")
+          @read_conn = uri.map {|obj| Stomp::Client.new("failover:(#{obj},#{obj})?#{options.to_query_string}") }
+        else
+          @write_conn = Stomp::Client.new("failover:(#{uri},#{uri})?#{options.to_query_string}")
+          @read_conn = [@write_conn]
+        end
       else
-        @write_conn = OnStomp::Failover::Client.new([uri], options)
-        @read_conn = [@write_conn]
+        raise ArgumentError, "Klomp does not support the #{@adapter} library"
       end
       @all_conn = ([@write_conn] + @read_conn).uniq
       configure_connections
     end
 
     def connect
-      @all_conn.each do |conn|
-        begin
-          attempts = conn.retry_attempts
-          conn.retry_attempts = 1
-          conn.connect
-        rescue OnStomp::Failover::MaximumRetriesExceededError
-          location = conn.active_client.uri.dup.tap {|u| u.password = 'REDACTED' }.to_s
-          msg = ": #{last_connect_exception.message}" if last_connect_exception
-          raise OnStomp::ConnectFailedError, "initial connection failed for #{location}#{msg}"
-        ensure
-          conn.retry_attempts = attempts
+      case @adapter
+      when :onstomp
+        @all_conn.each do |conn|
+          begin
+            attempts = conn.retry_attempts
+            conn.retry_attempts = 1
+            conn.connect
+          rescue OnStomp::Failover::MaximumRetriesExceededError
+            location = conn.active_client.uri.dup.tap {|u| u.password = 'REDACTED' }.to_s
+            msg = ": #{last_connect_exception.message}" if last_connect_exception
+            raise OnStomp::ConnectFailedError, "initial connection failed for #{location}#{msg}"
+          ensure
+            conn.retry_attempts = attempts
+          end
         end
       end
       self
     end
 
-    def send(dest, body, headers={}, &cb)
+    def disconnect
+      method = case @adapter
+      when :onstomp
+        :disconnect
+      when :stomp
+        :close
+      end
+      @all_conn.inject({}) { |memo,obj| memo.update({ obj => obj.__send__(method) }) }
+    end
+
+    def send(dest, body, headers={}, &block)
       if @translate_json && body.respond_to?(:to_json)
         body = body.to_json
-        headers[:'content-type'] = 'application/json'
+        headers['content-type'] = 'application/json'
       else
         body = body.to_s
       end
-      uuid = headers[:id] = @uuid.generate if @uuid
-      log.info("[Sending] ID=#{uuid} Destination=#{dest} Body=#{body.inspect} Headers=#{headers.inspect}") if log
-      @write_conn.send(dest, body, headers, &cb)
+      uuid = headers['id'] = @uuid.generate if @uuid
+      log.debug("[Sending] ID=#{uuid} Destination=#{dest} Body=#{body.inspect} Headers=#{headers.inspect}") if log
+
+      method = case @adapter
+      when :onstomp
+        :send
+      when :stomp
+        :publish
+      end
+      @write_conn.__send__(method, dest, body, headers, &block)
     end
     alias publish send
 
@@ -72,7 +148,7 @@ module Klomp
       frames = []
       @read_conn.each do |c|
         frames << c.subscribe(*args) do |msg|
-          log.info("[Received] ID=#{msg[:id]} Body=#{msg.body.inspect} Headers=#{msg.headers.to_hash.inspect}") if log
+          log.debug("[Received] ID=#{msg.headers['id']} Body=#{msg.body.inspect} Headers=#{msg.headers.to_hash.inspect}") if log
           if @translate_json
             msg.body = begin
               JSON.parse(msg.body)
@@ -81,11 +157,11 @@ module Klomp
             end
           end
           reply_args = yield msg
-          if @auto_reply_to && !msg.headers[:'reply-to'].nil?
+          if @auto_reply_to && !msg.headers['reply-to'].nil?
             if reply_args.is_a?(Array)
-              send(msg.headers[:'reply-to'], *reply_args)
+              send(msg.headers['reply-to'], *reply_args)
             else
-              send(msg.headers[:'reply-to'], reply_args)
+              send(msg.headers['reply-to'], reply_args)
             end
           end
         end
@@ -94,11 +170,16 @@ module Klomp
     end
 
     def unsubscribe(frames, headers={})
-      if !frames.respond_to?(:length) || frames.length != @read_conn.length
-        raise ArgumentError,
-          "frames is not an array or its length does not match number of connections"
+      case @adapter
+      when :onstomp
+        if !frames.respond_to?(:length) || frames.length != @read_conn.length
+          raise ArgumentError,
+            "frames is not an array or its length does not match number of connections"
+        end
+        frames.each_with_index.map {|f,i| @read_conn[i].unsubscribe f, headers }
+      else
+        @read_conn.each { |obj| obj.unsubscribe(frames, headers) }
       end
-      frames.each_with_index.map {|f,i| @read_conn[i].unsubscribe f, headers }
     end
 
     def subscriptions
@@ -109,47 +190,45 @@ module Klomp
       @logger
     end
 
-    WRITE_ONLY_METHODS = [
-      :abort,
-      :begin,
-      :commit,
-    ]
-
-    READ_ONLY_METHODS = [
-      :ack,
-      :nack,
-    ]
-
     def method_missing(method, *args, &block)
+      if TRANSLATE_METHODS.has_key?(method) && TRANSLATE_METHODS[method].has_key?(@adapter)
+        method = TRANSLATE_METHODS[method][@adapter]
+      end
+
       case method
       when *WRITE_ONLY_METHODS
         @write_conn.__send__(method, *args, &block)
       when *READ_ONLY_METHODS
-        @read_conn.map {|c| c.__send__(method, *args, &block) }
+        @read_conn.inject({}) { |memo,obj| memo.update({ obj => obj.__send__(method, *args, &block) }) }
       else
-        @all_conn.map {|c| c.__send__(method, *args) }
+        @all_conn.inject({}) { |memo,obj| memo.update({ obj => obj.__send__(method, *args, &block) }) }
       end
     end
 
     private
+
     def configure_connections
-      klomp_client = self
-      @all_conn.each do |c|
-        if @fib_retry_backoff
-          c.before_failover_retry do |conn, attempt|
-            if attempt == 1
-              conn.prev_retry_delay, conn.retry_delay = 0, 1
-            else
-              conn.prev_retry_delay, conn.retry_delay = conn.retry_delay, conn.prev_retry_delay + conn.retry_delay
+      case @adapter
+      when :onstomp
+        klomp_client = self
+        @all_conn.each do |c|
+          if @fib_retry_backoff
+            c.before_failover_retry do |conn, attempt|
+              if attempt == 1
+                conn.prev_retry_delay, conn.retry_delay = 0, 1
+              else
+                conn.prev_retry_delay, conn.retry_delay = conn.retry_delay, conn.prev_retry_delay + conn.retry_delay
+              end
             end
           end
-        end
 
-        c.on_failover_connect_failure do
-          klomp_client.last_connect_exception = $!
+          c.on_failover_connect_failure do
+            klomp_client.last_connect_exception = $!
+          end
         end
       end
     end
+
   end
 
 end

data/tasks/test_failover.rake

@@ -10,12 +10,12 @@ task :test_failover do
   client = Klomp::Client.new([
     'stomp://admin:password@localhost:61613',
     'stomp://admin:password@127.0.0.1:62613'
-  ]).connect
+  ], :adapter => :onstomp).connect
 
   last_i = nil
   client.subscribe("/queue/test") do |msg|
     print "-"
-    last_i = msg.body.to_i
+    last_i = msg.body.gsub('"', '').to_i
   end
 
   begin

data/test/test_client_all.rb

@@ -0,0 +1,167 @@
+require 'minitest/autorun'
+require 'minitest/pride'
+
+require 'klomp'
+require File.expand_path('../test_helper', __FILE__)
+
+describe Klomp::Client do
+
+  include KlompTestHelpers
+
+  before do
+    @uris = [
+      'stomp://admin:password@localhost:61613',
+      'stomp://admin:password@127.0.0.1:62613'
+    ]
+    @destination = '/queue/test_component.test_event'
+  end
+
+  [ :onstomp, :stomp ].each do |adapter|
+
+    it "(#{adapter}) has a logger" do
+      logger = Logger.new(STDOUT)
+      client = Klomp::Client.new(@uris, :adapter => adapter, :logger => logger)
+      assert_equal client.log, logger
+    end
+
+    it "(#{adapter}) sends all unknown options through to the underlying library" do
+      client = Klomp::Client.new(@uris.first, :adapter => adapter, :haz_cheezburgers => true, :retry_attempts => 42).connect
+      assert client.connected?.values.all?
+      assert_equal 42, client.write_conn.retry_attempts if adapter == :onstomp
+      client.disconnect
+    end
+
+    it "(#{adapter}) accepts a single uri and establishes separate failover connections for writes and reads" do
+      client = Klomp::Client.new(@uris.first, :adapter => adapter).connect
+      assert_equal [client.write_conn], client.read_conn
+      assert client.connected?.values.all?
+      client.disconnect
+    end
+
+    it "(#{adapter}) accepts an array of uris and establishes separate failover connections for writes and reads" do
+      client = Klomp::Client.new(@uris, :adapter => adapter).connect
+      assert client.all_conn.length == @uris.length + 1
+      assert client.connected?.values.all?
+      client.disconnect
+    end
+
+    it "(#{adapter}) disconnnects" do
+      client = Klomp::Client.new(@uris.first, :adapter => adapter).connect
+      assert client.connected?.values.all?
+      client.disconnect
+      refute client.connected?.values.any?
+    end
+
+    it "(#{adapter}) sends requests and gets responses" do
+      client = Klomp::Client.new(@uris, :adapter => adapter).connect
+      body  = { 'body' => rand(36**128).to_s(36) }
+
+      client.send(@destination, body, :ack=>'client')
+      got_message = false
+      client.subscribe(@destination) do |msg|
+        got_message = true if msg.body == body
+        client.ack(msg)
+      end
+      let_background_processor_run
+      client.disconnect
+
+      assert got_message
+    end
+
+    it "(#{adapter}) automatically publishes responses to the reply-to destination" do
+      client        = Klomp::Client.new(@uris, :adapter => adapter).connect
+      reply_to_body = { 'reply_to_body' => rand(36**128).to_s(36) }
+
+      client.send(@destination, nil, { 'reply-to' => @destination })
+
+      got_message = false
+      client.subscribe(@destination) do |msg|
+        got_message = true if msg.body == reply_to_body
+        reply_to_body
+      end
+      let_background_processor_run
+      client.disconnect
+
+      assert got_message
+    end
+
+    it "(#{adapter}) sends messages with uuids in the 'id' header" do
+      client = Klomp::Client.new(@uris, :adapter => adapter, :translate_json => false).connect
+      client.send(@destination, '')
+
+      received_message = false
+      client.subscribe(@destination) do |msg|
+        received_message = msg
+      end
+      let_background_processor_run
+      client.disconnect
+
+      assert received_message
+      assert received_message.headers['id'], "message did not have an id"
+      assert received_message.headers['id'] =~ /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
+        "message id did not look like a uuid"
+    end
+
+    it "(#{adapter}) allows customization of the uuid generator" do
+      generator = Object.new
+      def generator.generate; "42"; end
+
+      client = Klomp::Client.new(@uris, :adapter => adapter, :translate_json => false, :uuid => generator).connect
+      client.send(@destination, '')
+
+      received_message = false
+      client.subscribe(@destination) do |msg|
+        received_message = msg
+      end
+      let_background_processor_run
+      client.disconnect
+
+      assert received_message
+      assert received_message.headers['id'], "message did not have an id"
+      assert_equal "42", received_message.headers['id']
+    end
+
+    it "(#{adapter}) allows disabling generated message ids" do
+      client = Klomp::Client.new(@uris, :adapter => adapter, :translate_json => false, :uuid => false).connect
+      client.send(@destination, '')
+
+      received_message = false
+      client.subscribe(@destination) do |msg|
+        received_message = msg
+      end
+      let_background_processor_run
+      client.disconnect
+
+      assert received_message
+      refute received_message.headers['id'], "message had an id"
+    end
+
+    it "(#{adapter}) logs message ids" do
+      logger = Object.new
+      def logger.msgs; @msgs; end
+      def logger.debug(msg) (@msgs ||= []) << msg end
+
+      client = Klomp::Client.new(@uris, :adapter => adapter, :translate_json => false, :logger => logger).connect
+      client.send(@destination, '')
+
+      received_message = false
+      client.subscribe(@destination) do |msg|
+        received_message = msg
+      end
+      let_background_processor_run
+      client.disconnect
+
+      assert received_message
+      assert received_message.headers['id'], "message did not have an id"
+
+      assert_equal 2, logger.msgs.length
+      assert logger.msgs[0] =~ /\[Sending\] ID=([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/
+      sent_id = $1
+      assert logger.msgs[1] =~ /\[Received\] ID=([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/
+      received_id = $1
+      assert_equal sent_id, received_id
+    end
+
+  end
+
+end

data/test/test_client_onstomp.rb

@@ -0,0 +1,81 @@
+require 'minitest/autorun'
+require 'minitest/pride'
+
+require 'klomp'
+require File.expand_path('../test_helper', __FILE__)
+
+describe Klomp::Client do
+
+  include KlompTestHelpers
+
+  before do
+    @adapter = :onstomp
+    @uris = [
+      'stomp://admin:password@localhost:61613',
+      'stomp://admin:password@127.0.0.1:62613'
+    ]
+    @destination = '/queue/test_component.test_event'
+  end
+
+  it "raises an error if authentication fails" do
+    assert_raises OnStomp::ConnectFailedError do
+      Klomp::Client.new(@uris.first.sub('password', 'psswrd'), :adapter => @adapter).connect
+    end
+  end
+
+  it "sends heartbeat" do
+    client = Klomp::Client.new(@uris, :adapter => @adapter).connect
+    client.beat
+    client.disconnect
+  end
+
+  it "unsubscribes" do
+    client = Klomp::Client.new(@uris, :adapter => @adapter).connect
+
+    subscribe_frames = client.subscribe(@destination) { |msg| }
+    unsub_frames = client.unsubscribe(subscribe_frames)
+    let_background_processor_run
+    client.disconnect
+
+    assert_equal subscribe_frames.length, unsub_frames.length
+    assert client.subscriptions.flatten.empty?, "expected connection to have no subscriptions"
+  end
+
+  it 'uses a fibonacci back-off approach to reconnect' do
+    good_client = Object.new
+    def good_client.connect; true; end
+    def good_client.connected?; true; end
+    def good_client.connection; true; end
+
+    bad_client = Object.new
+    def bad_client.connect; raise "could not connect"; end
+    def bad_client.connected?; false; end
+
+    test_context = self
+    attempts = 0
+    conn = nil
+    fib = lambda {|n| (1..n).inject([0, 1]) {|fib,_| [fib[1], fib[0]+fib[1]]}.first}
+
+    pool_class = Class.new do
+      def initialize(*) end
+      def each(&blk) end
+      define_method :next_client do
+        attempts += 1
+        test_context.assert_equal fib[attempts], conn.retry_delay
+        if attempts == 6
+          good_client
+        else
+          bad_client
+        end
+      end
+    end
+
+    client = Klomp::Client.new(@uris.first, :adapter => @adapter, :pool => pool_class)
+    conn = client.write_conn
+    def conn.sleep_for_retry(*) end # skip sleep between retries for test
+
+    client.reconnect
+    assert_equal 6, attempts
+  end
+
+end

data/test/test_client_stomp.rb

@@ -0,0 +1,27 @@
+require 'minitest/autorun'
+require 'minitest/pride'
+
+require 'klomp'
+require File.expand_path('../test_helper', __FILE__)
+
+describe Klomp::Client do
+
+  include KlompTestHelpers
+
+  before do
+    @adapter = :stomp
+    @uris = [
+      'stomp://admin:password@localhost:61613',
+      'stomp://admin:password@127.0.0.1:62613'
+    ]
+    @destination = '/queue/test_component.test_event'
+  end
+
+  it "unsubscribes" do
+    client = Klomp::Client.new(@uris, :adapter => @adapter).connect
+    client.subscribe(@destination) { |msg| }
+    client.unsubscribe(@destination)
+    client.disconnect
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: klomp
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-22 00:00:00.000000000 Z
+date: 2012-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: onstomp
@@ -78,7 +78,9 @@ files:
 - lib/klomp.rb
 - lib/klomp/client.rb
 - tasks/test_failover.rake
-- test/test_client.rb
+- test/test_client_all.rb
+- test/test_client_onstomp.rb
+- test/test_client_stomp.rb
 - test/test_helper.rb
 homepage: https://github.com/livingsocial/klomp
 licenses: []
@@ -94,7 +96,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 395786091883431087
+      hash: -1938950018895640841
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -103,10 +105,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.21
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: A simple wrapper around the OnStomp library with additional features
 test_files:
-- test/test_client.rb
+- test/test_client_all.rb
+- test/test_client_onstomp.rb
+- test/test_client_stomp.rb
 - test/test_helper.rb

data/test/test_client.rb

@@ -1,232 +0,0 @@
-require 'minitest/autorun'
-require 'minitest/pride'
-
-require 'klomp'
-require File.expand_path('../test_helper', __FILE__)
-
-describe Klomp::Client do
-
-  include KlompTestHelpers
-
-  before do
-    @uris = [
-      'stomp://admin:password@localhost:61613',
-      'stomp://admin:password@127.0.0.1:62613'
-    ]
-    @destination = '/queue/test_component.test_event'
-  end
-
-  it 'accepts a single uri and establishes separate failover connections for writes and reads' do
-    client = Klomp::Client.new(@uris.first).connect
-
-    assert_equal [client.write_conn], client.read_conn
-    assert client.write_conn.connected?
-
-    client.disconnect
-  end
-
-  it 'accepts an array of uris and establishes separate failover connections for writes and reads' do
-    client = Klomp::Client.new(@uris).connect
-
-    assert client.write_conn.connected?
-    refute_empty client.read_conn
-    client.read_conn.each do |obj|
-      assert obj.connected?
-    end
-
-    client.disconnect
-  end
-
-  it 'raises an error if authentication fails' do
-    assert_raises OnStomp::ConnectFailedError do
-      Klomp::Client.new(@uris.first.sub('password', 'psswrd')).connect
-    end
-  end
-
-  it 'disconnnects' do
-    client = Klomp::Client.new(@uris.first).connect
-    assert client.write_conn.connected?
-    client.disconnect
-    refute client.write_conn.connected?
-  end
-
-  it 'has a logger' do
-    logger = Logger.new(STDOUT)
-    client = Klomp::Client.new(@uris, :logger=>logger)
-    assert_equal client.log, logger
-  end
-
-  it 'sends heartbeat' do
-    client = Klomp::Client.new(@uris).connect
-    client.beat
-    client.disconnect
-  end
-
-  it 'sends requests and gets responses' do
-    client = Klomp::Client.new(@uris).connect
-    body  = { 'body' => rand(36**128).to_s(36) }
-
-    client.send(@destination, body, :ack=>'client')
-
-    got_message = false
-    client.subscribe(@destination) do |msg|
-      got_message = true if msg.body == body
-      client.ack(msg)
-    end
-    let_background_processor_run
-    assert got_message
-
-    client.disconnect
-  end
-
-  it 'automatically publishes responses to the reply-to destination' do
-    client        = Klomp::Client.new(@uris).connect
-    reply_to_body = { 'reply_to_body' => rand(36**128).to_s(36) }
-
-    client.send(@destination, nil, { 'reply-to' => @destination })
-
-    got_message = false
-    client.subscribe(@destination) do |msg|
-      got_message = true if msg.body == reply_to_body
-      reply_to_body
-    end
-    let_background_processor_run
-    assert got_message
-
-    client.disconnect
-  end
-
-  it 'unsubscribes' do
-    client = Klomp::Client.new(@uris).connect
-
-    subscribe_frames = client.subscribe(@destination) { |msg| }
-    unsub_frames = client.unsubscribe(subscribe_frames)
-    assert_equal subscribe_frames.length, unsub_frames.length
-    let_background_processor_run
-
-    assert client.subscriptions.flatten.empty?, "expected connection to have no subscriptions"
-
-    client.disconnect
-  end
-
-  it 'sends all unknown options through to OnStomp' do
-    client = Klomp::Client.new(@uris.first, :haz_cheezburgers => true, :retry_attempts => 42).connect
-    assert client.write_conn.connected?
-    assert_equal 42, client.write_conn.retry_attempts
-    client.disconnect
-  end
-
-  it 'uses a fibonacci back-off approach to reconnect' do
-    good_client = Object.new
-    def good_client.connect; true; end
-    def good_client.connected?; true; end
-    def good_client.connection; true; end
-
-    bad_client = Object.new
-    def bad_client.connect; raise "could not connect"; end
-    def bad_client.connected?; false; end
-
-    test_context = self
-    attempts = 0
-    conn = nil
-    fib = lambda {|n| (1..n).inject([0, 1]) {|fib,_| [fib[1], fib[0]+fib[1]]}.first}
-
-    pool_class = Class.new do
-      def initialize(*) end
-      def each(&blk) end
-      define_method :next_client do
-        attempts += 1
-        test_context.assert_equal fib[attempts], conn.retry_delay
-        if attempts == 6
-          good_client
-        else
-          bad_client
-        end
-      end
-    end
-
-    client = Klomp::Client.new(@uris.first, :pool => pool_class)
-    conn = client.write_conn
-    def conn.sleep_for_retry(*) end # skip sleep between retries for test
-
-    client.reconnect
-    assert_equal 6, attempts
-  end
-
-  it 'sends messages with uuids in the :id header' do
-    client = Klomp::Client.new(@uris, :translate_json => false).connect
-    client.send(@destination, '')
-
-    received_message = false
-    client.subscribe(@destination) do |msg|
-      received_message = msg
-    end
-    let_background_processor_run
-    assert received_message
-    assert received_message[:id], "message did not have an id"
-    assert received_message[:id] =~ /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
-      "message id did not look like a uuid"
-
-    client.disconnect
-  end
-
-  it 'allows customization of the uuid generator' do
-    generator = Object.new
-    def generator.generate; "42"; end
-
-    client = Klomp::Client.new(@uris, :translate_json => false, :uuid => generator).connect
-    client.send(@destination, '')
-
-    received_message = false
-    client.subscribe(@destination) do |msg|
-      received_message = msg
-    end
-    let_background_processor_run
-    assert received_message
-    assert received_message[:id], "message did not have an id"
-    assert_equal "42", received_message[:id]
-
-    client.disconnect
-  end
-
-  it 'allows disabling generated message ids' do
-    client = Klomp::Client.new(@uris, :translate_json => false, :uuid => false).connect
-    client.send(@destination, '')
-
-    received_message = false
-    client.subscribe(@destination) do |msg|
-      received_message = msg
-    end
-    let_background_processor_run
-    assert received_message
-    refute received_message[:id], "message had an id"
-
-    client.disconnect
-  end
-
-  it 'logs message ids' do
-    logger = Object.new
-    def logger.msgs; @msgs; end
-    def logger.info(msg) (@msgs ||= []) << msg end
-
-    client = Klomp::Client.new(@uris, :translate_json => false, :logger => logger).connect
-    client.send(@destination, '')
-
-    received_message = false
-    client.subscribe(@destination) do |msg|
-      received_message = msg
-    end
-    let_background_processor_run
-    assert received_message
-    assert received_message[:id], "message did not have an id"
-
-    assert_equal 2, logger.msgs.length
-    assert logger.msgs[0] =~ /\[Sending\] ID=([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/
-    sent_id = $1
-    assert logger.msgs[1] =~ /\[Received\] ID=([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/
-    received_id = $1
-    assert_equal sent_id, received_id
-
-    client.disconnect
-  end
-end