basquiat 1.2.0 → 1.3.0.pre.1

data/lib/basquiat/interfaces/base.rb

@@ -1,7 +1,7 @@
 require 'set'
 
 module Basquiat
-  # base module extend the classes that will use the event infrastructure
+  # Base module used to extend the classes so that they will be able to use the event infrastructure
   module Base
     class << self
       def extended(klass)
@@ -14,41 +14,62 @@ module Basquiat
     end
 
     def reload_adapter_from_configuration
-      @adapter = Kernel.const_get(Basquiat.configuration.default_adapter).new
-      @adapter.adapter_options Basquiat.configuration.adapter_options
+      @adapter = Kernel.const_get Basquiat.configuration.default_adapter
+      adapter_options Basquiat.configuration.adapter_options
     end
 
-    def event_adapter=(adapter)
-      @adapter = adapter.new
+    # @!attribute [rw] adapter
+    #   Initializes and return a instance of the default adapter specified on Basquiat.configuration.default_adapter
+    #   @return [Basquiat::Adapter] the adapter instance for the current class
+    #   @deprecated event_adapter is deprecated and will be removed eventually. Please use {#adapter}.
+    def adapter=(adapter_klass)
+      @adapter = adapter_klass.new
     end
+    alias_method :event_adapter=, :adapter=
 
     def adapter
       @adapter ||= Kernel.const_get(Basquiat.configuration.default_adapter).new
     end
 
+    # @param opts [Hash] The adapter specific options. Defaults to Basquiat.configuration.adapter_options
     def adapter_options(opts = Basquiat.configuration.adapter_options)
       adapter.adapter_options(opts)
     end
 
+    # Publishes the message of type event to the queue. Note that the message will be converted to a JSON
+    # @param event [String] the event name
+    # @param message [#to_json] Message to be JSONfied and sent to the Message Queue
     def publish(event, message)
       adapter.publish(event, message)
     end
 
+    # Subscribe the event with the proc passed.
+    # @param event_name [String] the event name
+    # @param proc [Symbol, #call] the proc to be executed when the event is consumed.
+    #   You can pass anything that answers to call or a symbol.
+    #   If a symbol is passed it will try to look for a public class method of the same name.
     def subscribe_to(event_name, proc)
       proc = make_callable(proc)
       adapter.subscribe_to(event_name, proc)
     end
 
+    # Utility method to force a disconnect from the message queue.
+    # @note The adapter should reconnect automatically.
     def disconnect
       adapter.disconnect
     end
 
+    # Utility method to check connection status
+    # @return [truthy, falsey]
     def connected?
       adapter.connected?
     end
 
-    def listen(block: true)
-      adapter.listen(block: block)
+    # Starts the consumer loop
+    # @param block [Boolean] If it should block the thread. The relevance of this is dictated by the adapter.
+    #   Defaults to true.
+    def listen(block: true, rescue_proc: -> {})
+      adapter.listen(block: block, rescue_proc: rescue_proc)
     end
 
     private

data/lib/basquiat/support/configuration.rb

@@ -1,6 +1,6 @@
-require 'basquiat/support/hash_refinements'
 require 'naught'
 require 'erb'
+require 'basquiat/support/hash_refinements'
 
 module Basquiat
   require 'logger'
@@ -9,8 +9,32 @@ module Basquiat
   class Configuration
     using HashRefinements
 
+    def initialize
+      @yaml        = {}
+      @rescue_proc = lambda do |exception, message|
+        logger.error do
+          { exception: exception, stack_trace: exception.stack_trace, message: message }.to_json
+        end
+        fail exception
+      end
+    end
+
+    # @!attribute queue_name
+    #   @return [String] the queue name. Defaults to 'basquiat.queue'
+    # @!attribute exchange_name
+    #   @return [String] the exchange name. Defaults to 'basquiat.exchange'
+    # @!attribute logger
+    #   @return [Logger] return the application logger. Defaults to {DefaultLogger}.
+    # @!attribute environment
+    #   @return [Symbol] return the set environment or the value of the 'BASQUIAT_ENV' environment variable
+    #     or :development
     attr_writer :queue_name, :exchange_name, :logger, :environment
 
+    # @!attribute rescue_proc
+    #   @return [#call] return the callable to be executed when some exception is thrown. The callable receives the
+    #     exception and message
+    attr_accessor :rescue_proc
+
     def queue_name
       @queue_name || 'basquiat.queue'
     end
@@ -27,19 +51,24 @@ module Basquiat
       (@environment || ENV['BASQUIAT_ENV'] || 'development').to_sym
     end
 
+    # Loads a YAML file with the configuration options
+    # @param path [String] the path of the configuration file
     def config_file=(path)
       load_yaml(path)
       setup_basic_options
     end
 
+    # @return [Hash] return the configured adapter options. Defaults to an empty {::Hash}
     def adapter_options
       config.fetch(:adapter_options) { Hash.new }
     end
 
+    # @return [String] return the configured default adapter. Defaults to {Adapters::Test}
     def default_adapter
-      config.fetch(:default_adapter) { Basquiat::Adapter::Test }
+      config.fetch(:default_adapter) { 'Basquiat::Adapters::Test' }
     end
 
+    # Used by the railtie. Forces the reconfiguration of all extended classes
     def reload_classes
       Basquiat::Base.descendants.each(&:reload_adapter_from_configuration)
     end
@@ -47,7 +76,7 @@ module Basquiat
     private
 
     def config
-      @yaml.fetch(environment)
+      @yaml.fetch(environment, {})
     end
 
     def load_yaml(path)
@@ -55,7 +84,7 @@ module Basquiat
     end
 
     def setup_basic_options
-      @queue_name    ||= config.fetch(:queue_name) { 'basquiat.exchange' }
+      @queue_name ||= config.fetch(:queue_name) { 'basquiat.exchange' }
       @exchange_name ||= config.fetch(:exchange_name) { 'basquiat.queue' }
     end
   end

data/lib/basquiat/support/hash_refinements.rb

@@ -1,5 +1,14 @@
 module Basquiat
   module HashRefinements
+    # @!method deep_merge
+    #   Merges self with other_hash recursively
+    #   @param other_hash [Hash] hash to be merged into self
+    #   @return [self]
+
+    # @!method symbolize_keys
+    #   Symbolize all the keys in a given hash. Works with nested hashes
+    #   @return [Hash] return other hash with the symbolized keys
+
     refine Hash do
       def deep_merge(other_hash)
         other_hash.each_pair do |key, value|

data/lib/basquiat/support/json.rb

@@ -1,9 +1,18 @@
 module Basquiat
+  # A simple MultiJson wrapper to protect against eventual API changes.
   module Json
+    # Serializes an Object into a JSON
+    # @see MultiJson.dump
+    # @param object [Object] object to be serialized
+    # @return [String] JSON representation of the object
     def self.encode(object)
       MultiJson.dump(object)
     end
 
+    # De-serializes a JSON into a Hash
+    # @see MultiJson.load
+    # @param object [Object] object to be de-serialized
+    # @return [Hash] Hash representing the JSON. The keys are symbolized by default
     def self.decode(object)
       MultiJson.load(object, symbolize_keys: true)
     rescue MultiJson::ParseError

data/lib/basquiat/version.rb

@@ -1,4 +1,4 @@
 # Version file
 module Basquiat
-  VERSION = '1.2.0'
+  VERSION = '1.3.0-1'
 end

data/lib/basquiat.rb

@@ -8,21 +8,26 @@ require 'basquiat/adapters'
 require 'basquiat/version'
 require 'basquiat/interfaces/base'
 
-# Overall namespace And config class
+# Overall namespace config class
 module Basquiat
   class << self
+    # resets the gems configuration. Useful for testing and not much else
     def reset
       @configuration = Configuration.new
     end
 
+    # @return [Configuration] returns or initializes the Configuration object
     def configuration
       @configuration ||= Configuration.new
     end
 
+    # used to configure the gem using a block
+    # @yieldparam [Configuration] configuration the current {Configuration} instance
     def configure
       yield configuration
     end
 
+    # @return [Logger] shorthand for configuration.logger
     def logger
       configuration.logger
     end

data/spec/lib/adapters/base_adapter_spec.rb

@@ -11,7 +11,7 @@ describe Basquiat::Adapters::Base do
   end
 
   it 'raise error when using an unregistered strategy' do
-    # expect(adapter.use_strategy(:not_here)).to raise_error StrategyNotRegistered
+    expect { adapter.class.strategy(:not_here) }.to raise_error Basquiat::Errors::StrategyNotRegistered
   end
 
   it 'register a requeue strategy' do

data/spec/lib/adapters/base_message_spec.rb

@@ -7,10 +7,4 @@ describe Basquiat::Adapters::BaseMessage do
     expect(message.fetch(:data)).to eq('everything is AWESOME!')
     expect { message.fetch(:error) }.to raise_error KeyError
   end
-
-  [:ack?, :unack, :requeue, :delay_redelivery].each do |meth|
-    it "raise a SubclassResponsibility error if #{meth} isn't implemented" do
-      expect { message.public_send(meth) }.to raise_error Basquiat::Errors::SubclassResponsibility
-    end
-  end
 end

data/spec/lib/adapters/rabbitmq/configuration_spec.rb

@@ -19,11 +19,11 @@ describe Basquiat::Adapters::RabbitMq::Configuration do
   end
 
   it '#connection_options' do
-    expect(config.connection_options.keys).to contain_exactly(:servers, :auth, :failover)
+    expect(config.connection_options.keys).to contain_exactly(:hosts, :auth, :port)
   end
 
   it '#session_options' do
-    expect(config.session_options.keys).to contain_exactly(:exchange, :queue, :publisher)
+    expect(config.session_options.keys).to contain_exactly(:exchange, :queue, :publisher, :consumer)
   end
 
   context 'Strategies' do

data/spec/lib/adapters/rabbitmq/connection_spec.rb

@@ -4,17 +4,12 @@ require 'basquiat/adapters/rabbitmq_adapter'
 describe Basquiat::Adapters::RabbitMq::Connection do
   subject(:connection) { Basquiat::Adapters::RabbitMq::Connection }
 
-  let(:servers) do
-    [{ host: ENV.fetch('BASQUIAT_RABBITMQ_1_PORT_5672_TCP_ADDR') { 'localhost' },
-       port: ENV.fetch('BASQUIAT_RABBITMQ_1_PORT_5672_TCP_PORT') { 5672 } }]
-  end
-
-  before(:each) do
-    Basquiat.configure { |c| c.logger = Logger.new('log/basquiat.log') }
+  let(:hosts) do
+    [ENV.fetch('BASQUIAT_RABBITMQ_1_PORT_5672_TCP_ADDR') { 'localhost' }]
   end
 
   it '#connected?' do
-    conn = connection.new(servers: servers)
+    conn = connection.new(hosts: hosts)
     expect(conn.connected?).to be_falsey
     conn.start
     expect(conn.connected?).to_not be_truthy
@@ -23,22 +18,22 @@ describe Basquiat::Adapters::RabbitMq::Connection do
 
   context 'failover' do
     let(:failover) do
-      { default_timeout: 0.2, max_retries: 2, threaded: false }
+      { default_timeout: 0.2, max_retries: 2, connection_timeout: 0.3 }
     end
 
-    before(:each) { servers.unshift(host: 'localhost', port: 1234) }
+    before(:each) { hosts.unshift('172.168.0.124') }
 
     it 'tries a reconnection after a few seconds' do
-      conn = connection.new(servers:  [host: 'localhost', port: 1234],
+      conn = connection.new(hosts:    ['172.168.0.124'],
                             failover: { default_timeout: 0.2, max_retries: 1 })
       expect { conn.start }.to raise_error(Bunny::TCPConnectionFailed)
       conn.close
     end
 
     it 'uses another server after all retries on a single one' do
-      conn = connection.new(servers: servers, failover: failover)
+      conn = connection.new(hosts: hosts, failover: failover)
       expect { conn.start }.to_not raise_error
-      expect(conn.current_server_uri).to match "#{ENV.fetch('BASQUIAT_RABBITMQ_1_PORT_5672_TCP_PORT') { 5672 }}"
+      expect(conn.host).to match "#{ENV.fetch('BASQUIAT_RABBITMQ_1_PORT_5672_TCP_ADDR') { 'localhost' }}"
       conn.close
     end
   end

data/spec/lib/adapters/rabbitmq/events_spec.rb

@@ -18,8 +18,15 @@ describe Basquiat::Adapters::RabbitMq::Events do
 
   context 'wildcard keys' do
     let(:proc) { -> { 'Hello from the lambda! o/' } }
+
     describe '*' do
       let(:words) { %w(awesome lame dumb cool) }
+
+      it 'event.* does not match event_some_word' do
+        events['event.*'] = proc
+        expect { events['event_some_word'] }.to raise_error KeyError
+      end
+
       context 'matches any ONE word' do
         it 'at the end' do
           events['some.event.*'] = proc
@@ -70,7 +77,7 @@ describe Basquiat::Adapters::RabbitMq::Events do
           %w(some.cool.event cool.event).each do |event|
             expect(events[event]).to eq(proc)
           end
-          expect { events['event']}.to raise_error KeyError
+          expect { events['event'] }.to raise_error KeyError
         end
       end
     end

data/spec/lib/adapters/rabbitmq/requeue_strategies/auto_acknowledge_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'basquiat/adapters/rabbitmq_adapter'
+
+describe Basquiat::Adapters::RabbitMq::AutoAcknowledge do
+  let(:adapter) { Basquiat::Adapters::RabbitMq.new }
+  let(:base_options) do
+    { connection: { hosts: [ENV.fetch('BASQUIAT_RABBITMQ_1_PORT_5672_TCP_ADDR') { 'localhost' }],
+                    port:  ENV.fetch('BASQUIAT_RABBITMQ_1_PORT_5672_TCP_PORT') { 5672 } },
+      publisher:  { persistent: true },
+      requeue:    { enabled: false } }
+  end
+
+  before(:each) do
+    adapter.adapter_options(base_options)
+  end
+
+  after(:each) { remove_queues_and_exchanges(adapter) }
+
+  it 'set manual_ack to false' do
+    # Setup the strategy
+    adapter.strategy
+    expect(adapter.send(:options)[:consumer][:manual_ack]).to be_falsey
+  end
+end

data/spec/lib/adapters/rabbitmq/requeue_strategies/basic_acknowledge_spec.rb

@@ -4,8 +4,8 @@ require 'basquiat/adapters/rabbitmq_adapter'
 describe 'Requeue Strategies' do
   let(:adapter) { Basquiat::Adapters::RabbitMq.new }
   let(:base_options) do
-    { servers:   [{ host: ENV.fetch('BASQUIAT_RABBITMQ_1_PORT_5672_TCP_ADDR') { 'localhost' },
-                    port: ENV.fetch('BASQUIAT_RABBITMQ_1_PORT_5672_TCP_PORT') { 5672 } }],
+    { connection: { hosts: [ENV.fetch('BASQUIAT_RABBITMQ_1_PORT_5672_TCP_ADDR') { 'localhost' }],
+                    port:  ENV.fetch('BASQUIAT_RABBITMQ_1_PORT_5672_TCP_PORT') { 5672 } },
       publisher: { persistent: true } }
   end
 
@@ -18,7 +18,7 @@ describe 'Requeue Strategies' do
       adapter.listen(block: false)
 
       adapter.publish('some.event', data: 'stupid message')
-      sleep 0.7 # Wait for the listening thread.
+      sleep 0.5 # Wait for the listening thread.
 
       expect(adapter.session.queue.message_count).to eq(0)
       expect(adapter.session.queue).to_not have_unacked_messages
@@ -29,7 +29,7 @@ describe 'Requeue Strategies' do
       adapter.listen(block: false)
 
       adapter.publish('some.event', data: 'stupid message')
-      sleep 0.7 # Wait for the listening thread.
+      sleep 0.5 # Wait for the listening thread.
 
       expect(adapter.session.queue.message_count).to eq(0)
       expect(adapter.session.queue).to_not have_unacked_messages

data/spec/lib/adapters/rabbitmq/requeue_strategies/dead_lettering_spec.rb

@@ -4,28 +4,26 @@ require 'basquiat/adapters/rabbitmq_adapter'
 describe Basquiat::Adapters::RabbitMq::DeadLettering do
   let(:adapter) { Basquiat::Adapters::RabbitMq.new }
   let(:base_options) do
-    { servers:   [{ host: ENV.fetch('BASQUIAT_RABBITMQ_1_PORT_5672_TCP_ADDR') { 'localhost' },
-                    port: ENV.fetch('BASQUIAT_RABBITMQ_1_PORT_5672_TCP_PORT') { 5672 } }],
+    { connection: { hosts: [ENV.fetch('BASQUIAT_RABBITMQ_1_PORT_5672_TCP_ADDR') { 'localhost' }],
+                    port:  ENV.fetch('BASQUIAT_RABBITMQ_1_PORT_5672_TCP_PORT') { 5672 } },
       publisher: { persistent: true } }
   end
 
   before(:each) do
     adapter.adapter_options(base_options)
-    adapter.class.register_strategy :dlx, Basquiat::Adapters::RabbitMq::DeadLettering
+    adapter.adapter_options(requeue: { enabled: true, strategy: 'dead_lettering' })
   end
 
   after(:each) { remove_queues_and_exchanges(adapter) }
 
   it 'creates the dead letter exchange' do
-    adapter.adapter_options(requeue: { enabled: true, strategy: 'dlx' })
     adapter.strategy # initialize the strategy
     channel = adapter.session.channel
-    expect(channel.exchanges.keys).to contain_exactly('my.test_exchange', 'basquiat.dlx')
+    expect(channel.exchanges.keys).to contain_exactly('basquiat.exchange', 'basquiat.dlx')
   end
 
   it 'creates and binds a dead letter queue' do
     # Initialize the strategy since we won't be listening to anything
-    adapter.adapter_options(requeue: { enabled: true, strategy: 'dlx' })
     session = adapter.session
     adapter.strategy
 
@@ -33,7 +31,7 @@ describe Basquiat::Adapters::RabbitMq::DeadLettering do
     channel = session.channel
     expect(channel.queues.keys).to include('basquiat.dlq')
     expect(channel.queues['basquiat.dlq'].arguments)
-        .to match(hash_including('x-dead-letter-exchange' => session.exchange.name, 'x-message-ttl' => 1000))
+      .to match(hash_including('x-dead-letter-exchange' => session.exchange.name, 'x-message-ttl' => 1000))
     expect(session.queue.arguments).to match(hash_including('x-dead-letter-exchange' => 'basquiat.dlx'))
 
     expect do
@@ -42,9 +40,8 @@ describe Basquiat::Adapters::RabbitMq::DeadLettering do
     end.to change { channel.queues['basquiat.dlq'].message_count }.by(1)
   end
 
-  context 'if it was the queue that unacked the message then' do
+  context 'nacked the message from' do
     before(:each) do
-      adapter.adapter_options(requeue: { enabled: true, strategy: 'dlx' })
       session = adapter.session
       adapter.strategy # initialize strategy
 
@@ -56,12 +53,13 @@ describe Basquiat::Adapters::RabbitMq::DeadLettering do
       end
     end
 
-    it 'process the message' do
+    it 'this queue then process the message' do
       sample = 0
-      adapter.subscribe_to('sample.message', ->(msg) do
-        sample += 1
-        sample == 3 ? msg.ack : msg.unack
-      end)
+      adapter.subscribe_to('sample.message',
+                           lambda do |msg|
+                             sample += 1
+                             sample == 3 ? msg.ack : msg.nack
+                           end)
 
       adapter.listen(block: false)
       adapter.publish('sample.message', key: 'message')
@@ -70,24 +68,21 @@ describe Basquiat::Adapters::RabbitMq::DeadLettering do
       expect(sample).to eq(3)
     end
 
-    it 'else drop the message' do
+    it 'another queue then drop the message' do
       ack_count = 0
       sample    = 0
 
       other = Basquiat::Adapters::RabbitMq.new
-      other.adapter_options(base_options.merge(queue: { name: 'other_queue' }, requeue: { enabled: true, strategy: 'dlx' }))
-      other.subscribe_to('sample.message', ->(msg) do
-        ack_count += 1
-      end)
-
-      adapter.subscribe_to('sample.message', ->(msg) do
-        if sample == 3
-          msg.ack
-        else
-          sample += 1;
-          msg.unack
-        end
-      end)
+      other.adapter_options(base_options.merge(queue:
+                                                        { name: 'other_queue' },
+                                               requeue: { enabled: true, strategy: 'dead_lettering', ttl: 5 }))
+      other.subscribe_to('sample.message', ->(_msg) { ack_count += 1 })
+
+      adapter.subscribe_to('sample.message',
+                           lambda do |msg|
+                             sample += 1
+                             sample == 3 ? msg.ack : msg.nack
+                           end)
 
       other.listen(block: false)
       adapter.listen(block: false)

data/spec/lib/adapters/rabbitmq/requeue_strategies/delayed_delivery_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+require 'basquiat/adapters/rabbitmq_adapter'
+
+describe Basquiat::Adapters::RabbitMq::DelayedDelivery do
+  let(:adapter) { Basquiat::Adapters::RabbitMq.new }
+  let(:base_options) do
+    { connection: { hosts: [ENV.fetch('BASQUIAT_RABBITMQ_1_PORT_5672_TCP_ADDR') { 'localhost' }],
+                    port:  ENV.fetch('BASQUIAT_RABBITMQ_1_PORT_5672_TCP_PORT') { 5672 } },
+      publisher: { persistent: true } }
+  end
+
+  before(:each) do
+    adapter.adapter_options(base_options)
+    adapter.class.register_strategy :ddl, Basquiat::Adapters::RabbitMq::DelayedDelivery
+    adapter.adapter_options(requeue: { enabled: true, strategy: 'ddl' })
+    adapter.strategy # initialize the strategy
+  end
+
+  after(:each) { remove_queues_and_exchanges(adapter) }
+
+  it 'creates the dead letter exchange' do
+    channel = adapter.session.channel
+    expect(channel.exchanges.keys).to contain_exactly('basquiat.exchange', 'basquiat.dlx')
+  end
+
+  it 'creates the timeout queues' do
+    channel = adapter.session.channel
+    expect(channel.queues.keys).to contain_exactly('basquiat.ddlq_1', 'basquiat.ddlq_2', 'basquiat.ddlq_4',
+                                                   'basquiat.ddlq_8', 'basquiat.ddlq_16', 'basquiat.queue',
+                                                   'basquiat.ddlq_rejected')
+  end
+
+  it 'set the message ttl and dead letter exchange for the delayed queues' do
+    session = adapter.session
+    channel = session.channel
+    expect(channel.queues['basquiat.ddlq_1'].arguments)
+      .to match(hash_including('x-dead-letter-exchange' => session.exchange.name, 'x-message-ttl' => 1_000))
+
+    expect(channel.queues['basquiat.ddlq_8'].arguments['x-message-ttl']).to eq(8_000)
+  end
+
+  it 'binds the delayed queues' do
+    session = adapter.session
+    channel = session.channel
+    expect do
+      channel.exchanges['basquiat.dlx'].publish({ data: 'some message' }.to_json, routing_key: '1000.some.event')
+      sleep 0.1
+    end.to change { channel.queues['basquiat.ddlq_1'].message_count }.by(1)
+  end
+
+  it 'associates the event *.queue_name.event.name with event.name' do
+    message = ''
+    session = adapter.session
+    adapter.subscribe_to('some.event', ->(msg) { message = msg[:data].upcase })
+
+    adapter.listen(block: false)
+    session.publish('1000.basquiat.queue.some.event', data: 'some message')
+    sleep 0.5
+
+    expect(message).to eq('SOME MESSAGE')
+  end
+
+  context 'when a message is requeued' do
+    it 'is republished with the appropriate routing key' do
+      session = adapter.session
+      adapter.subscribe_to('some.event', ->(msg) { msg.requeue })
+      adapter.listen(block: false)
+
+      expect do
+        session.publish('some.event', data: 'some message')
+        sleep 0.3
+      end.to change { session.channel.queues['basquiat.ddlq_1'].message_count }.by(1)
+    end
+
+    it 'goes to the reject queue if a requeue would exceed the maximum timeout' do
+      session = adapter.session
+      adapter.subscribe_to('some.event', ->(msg) { msg.requeue })
+      adapter.listen(block: false)
+
+      expect do
+        session.publish('32000.basquiat.queue.some.event', data: 'some message')
+        sleep 0.3
+      end.to change { session.channel.queues['basquiat.ddlq_rejected'].message_count }.by(1)
+    end
+
+    it 'after it expires it is reprocessed by the right queue' do
+      analysed = 0
+      session  = adapter.session
+      adapter.subscribe_to('some.event',
+                           lambda do |msg|
+                             if analysed == 1
+                               msg.ack
+                             else
+                               analysed += 1
+                               msg.requeue
+                             end
+                           end)
+      adapter.listen(block: false)
+      session.publish('some.event', data: 'some message')
+      sleep 1.3
+      expect(analysed).to eq(1)
+      expect(session.queue).to_not have_unacked_messages
+    end
+  end
+end