klomp 0.0.6 → 0.0.7

data/ChangeLog.md

@@ -1,6 +1,11 @@
 Changes
 --------------------------------------------------------------------------------
 
+0.0.7 (2012/8/15)
+================================================================================
+
+- back out the stomp/onstomp adapter code. we'll revisit this later
+
 0.0.6 (2012/8/10)
 ================================================================================
 

data/Gemfile

@@ -2,7 +2,6 @@ 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,7 +9,6 @@ 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)
@@ -24,5 +23,4 @@ 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 [Stomp](https://github.com/stompgem/stomp)
-and [OnStomp](https://github.com/meadvillerb/onstomp/) libraries with some
-additional HA and usability features:
+Klomp is a simple wrapper around the [OnStomp](https://github.com/meadvillerb/onstomp/)
+library 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 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.
+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.
 
 * Where applicable, message bodies are automatically translated between native
 Ruby and JSON objects.
@@ -26,13 +26,14 @@ subscribe block.
 ## Example usage
 
 The goal is that you should be able to use most (if not all) of the standard
-Stomp/OnStomp APIs via a `Klomp::Client`:
+OnStomp API (see [OnStomp's UserNarrative](https://github.com/meadvillerb/onstomp/blob/master/extra_doc/UserNarrative.md))
+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 OnStomp's `connected?` method normally
-returns a single boolean value, Klomp's `connected?` will return many booleans
+manages connections. For example, while the `connected?` method normally
+returns a boolean value, Klomp's `connected?` will return an array of booleans
 (i.e. one result for each broker).
 
 ### Fibonacci back-off retry behavior
@@ -58,11 +59,6 @@ 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>
@@ -79,9 +75,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>
 

data/lib/klomp.rb

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

data/lib/klomp/client.rb

@@ -3,47 +3,19 @@ require 'onstomp/failover'
 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, :all_conn
+    attr_reader :read_conn, :write_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)
@@ -55,93 +27,44 @@ module Klomp
       options[:retry_delay]    ||= 1
       options[:retry_attempts] ||= -1
 
-      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
-        require '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
+      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
-        raise ArgumentError, "Klomp does not support the #{@adapter} library"
+        @write_conn = OnStomp::Failover::Client.new([uri], options)
+        @read_conn = [@write_conn]
       end
       @all_conn = ([@write_conn] + @read_conn).uniq
       configure_connections
     end
 
     def connect
-      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
+      @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
       self
     end
 
-    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)
+    def send(dest, body, headers={}, &cb)
       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
+      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)
+      @write_conn.send(dest, body, headers, &cb)
     end
     alias publish send
 
@@ -149,7 +72,7 @@ module Klomp
       frames = []
       @read_conn.each do |c|
         frames << c.subscribe(*args) do |msg|
-          log.debug("[Received] ID=#{msg.headers['id']} Body=#{msg.body.inspect} Headers=#{msg.headers.to_hash.inspect}") if log
+          log.debug("[Received] ID=#{msg[:id]} Body=#{msg.body.inspect} Headers=#{msg.headers.to_hash.inspect}") if log
           if @translate_json
             msg.body = begin
               JSON.parse(msg.body)
@@ -158,11 +81,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
@@ -171,16 +94,11 @@ module Klomp
     end
 
     def unsubscribe(frames, headers={})
-      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) }
+      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 }
     end
 
     def subscriptions
@@ -191,45 +109,47 @@ module Klomp
       @logger
     end
 
-    def method_missing(method, *args, &block)
-      if TRANSLATE_METHODS.has_key?(method) && TRANSLATE_METHODS[method].has_key?(@adapter)
-        method = TRANSLATE_METHODS[method][@adapter]
-      end
+    WRITE_ONLY_METHODS = [
+      :abort,
+      :begin,
+      :commit,
+    ]
 
+    READ_ONLY_METHODS = [
+      :ack,
+      :nack,
+    ]
+
+    def method_missing(method, *args, &block)
       case method
       when *WRITE_ONLY_METHODS
         @write_conn.__send__(method, *args, &block)
       when *READ_ONLY_METHODS
-        @read_conn.inject({}) { |memo,obj| memo.update({ obj => obj.__send__(method, *args, &block) }) }
+        @read_conn.map {|c| c.__send__(method, *args, &block) }
       else
-        @all_conn.inject({}) { |memo,obj| memo.update({ obj => obj.__send__(method, *args, &block) }) }
+        @all_conn.map {|c| c.__send__(method, *args) }
       end
     end
 
     private
-
     def configure_connections
-      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
+      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
 
-          c.on_failover_connect_failure do
-            klomp_client.last_connect_exception = $!
-          end
+        c.on_failover_connect_failure do
+          klomp_client.last_connect_exception = $!
         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'
-  ], :adapter => :onstomp).connect
+  ]).connect
 
   last_i = nil
   client.subscribe("/queue/test") do |msg|
     print "-"
-    last_i = msg.body.gsub('"', '').to_i
+    last_i = msg.body.to_i
   end
 
   begin

data/test/test_client.rb

@@ -0,0 +1,232 @@
+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.debug(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

metadata

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

data/test/test_client_all.rb

@@ -1,167 +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
-
-  [ :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

@@ -1,81 +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
-    @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

@@ -1,27 +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
-    @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