lapine 1.0.1 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 17ff6eda9eaea1807ee77240e11fa2dc336f7350
-  data.tar.gz: b94a4cbada011e8f4fe12e6873b2def2ab923e27
+  metadata.gz: 564e7001cbbd4468d842e013cc437610a25b0c24
+  data.tar.gz: 90a86db4889bed75801d7278b0710b36e0c3f38c
 SHA512:
-  metadata.gz: f68160452a12c78121c0175e2cbf8448924a6d4dd075de8e5051628240cb097b2e3bf8ecd6bf3b5779a83b3a8b24fb020fdd7b977caa71d236628bb44ea68d13
-  data.tar.gz: 391d24cbd65e613f44f46df60eca15c1958c20466b01eb3425faea7448225127f45f6e78758ddc7f3b2b9ef56ce4259bfa1fe283c68c768b5bbde7bd214b9dbf
+  metadata.gz: 9096e3d40022bfb83e8aff47aac3f299e162cd644f56679c6294ba8bbd3d3438fa8df47b1fbfffe5f466743b208df7334ea0b2cb8d032ce0ee9a0b990224e4db
+  data.tar.gz: 41f326c4642272bf3ea3f9a32a964dae81e07dfea940edfcc14017b5828ebe0baf77206c17430f50754f7e8b39400581f1c98a2f1c34aeaee4c5b0fec69aed74

data/Changelog.md

@@ -1,6 +1,21 @@
 Change Log
 ==========
 
+## 1.1.2
+
+* Exchanges are saved using thread variables instead of fiber variables
+* Move memoization of connections and exchanges to Configuration
+
+## 1.1.1
+
+* Fix potential thread safety issue with publisher connections to
+  RabbitMQ
+
+## 1.1.0
+
+* Lapine consumer can be configured with middleware
+  * Error handling, json decoding, and message acknowledgement now happen in middleware
+
 ## 1.0.1
 
 * Increased verbosity of errors

data/lib/lapine.rb

@@ -22,17 +22,17 @@ module Lapine
   end
 
   def self.find_exchange(name)
-    exchange = config.exchange_properties[name]
-    raise UndefinedExchange.new("No exchange for #{name}") unless exchange
-    return config.exchanges[name].exchange if config.exchanges[name]
-    config.exchanges[name] = Lapine::Exchange.new(name, exchange)
+    exchange = config.exchanges[name]
+    return exchange.exchange if (exchange && exchange.connected?)
+
+    exchange_configuration = config.exchange_properties[name]
+    raise UndefinedExchange.new("No exchange configuration for #{name}") unless exchange_configuration
+
+    config.exchanges[name] = Lapine::Exchange.new(name, exchange_configuration)
     config.exchanges[name].exchange
   end
 
   def self.close_connections!
-    config.exchanges.values.each do |exchange|
-      exchange.close!
-      config.exchanges.delete exchange.name
-    end
+    config.close_connections!
   end
 end

data/lib/lapine/configuration.rb

@@ -1,5 +1,9 @@
 module Lapine
   class Configuration
+    def initialize
+      @active_connections = {}
+    end
+
     def connections
       @connections ||= {}
     end
@@ -8,12 +12,58 @@ module Lapine
       @connection_properties ||= {}
     end
 
+    def channels_by_exchange_id
+      @channels_by_exchange_id ||= {}
+    end
+
+    def register_channel(object_id, channel)
+      channels_by_exchange_id[object_id] = channel
+    end
+
+    def cleanup_exchange(id)
+      return unless channels_by_exchange_id[id]
+      channel = channels_by_exchange_id[id]
+      channel.connection.logger.info "Closing channel for exchange #{id}, thread: #{Thread.current.object_id}"
+      channel.close
+      channels_by_exchange_id[id] = nil
+    end
+
+    # Exchanges need to be saved in a thread-local variable, rather than a fiber-local variable,
+    # because in the context of some applications (such as Sidekiq, which uses Celluloid) individual
+    # bits of work are done in fibers that are immediately reaped.
     def exchanges
-      @exchanges ||= {}
+      Thread.current.thread_variable_get(:lapine_exchanges) ||
+        Thread.current.thread_variable_set(:lapine_exchanges, {})
     end
 
     def exchange_properties
       @exchange_properties ||= {}
     end
+
+    def active_connection(name)
+      conn = @active_connections[name]
+      return conn if (conn && conn.connected?)
+
+      @active_connections[name] = begin
+        @conn = Bunny.new(connection_props_for(name)).tap do |conn|
+          conn.start
+        end
+      end
+    end
+
+    def close_connections!
+      @active_connections.values.map(&:close)
+      @active_connections = {}
+      Thread.current.thread_variable_set(:lapine_exchanges, nil)
+    end
+
+    def connection_props_for(name)
+      return unless connection_properties[name]
+      connection_properties[name].dup.tap do |props|
+        if defined?(Rails)
+          props.merge!(logger: Rails.logger)
+        end
+      end
+    end
   end
 end

data/lib/lapine/consumer/dispatcher.rb

@@ -5,13 +5,12 @@ module Lapine
   module Consumer
     class Dispatcher
       class DefaultErrorHandler
-
         def call(e, data, _metadata)
           $stderr.puts "Lapine::Dispatcher unable to dispatch, #{e.message}, data: #{data}"
         end
       end
 
-      attr_reader :delegate_class, :raw_payload, :metadata, :logger
+      attr_reader :delegate_class, :message, :payload
 
       def self.error_handler=(handler)
         @error_handler = handler
@@ -21,24 +20,16 @@ module Lapine
         @error_handler || DefaultErrorHandler.new
       end
 
-      def initialize(delegate_class, raw_payload, metadata, logger)
+      def initialize(delegate_class, message)
         @delegate_class = delegate_class
-        @raw_payload = raw_payload
-        @metadata = metadata
-        @logger = logger
+        @message = message
+        @payload = message.decoded_payload
       end
 
       def dispatch
-        Lapine::DTrace.fire!(:dispatch_enter, delegate_class.name, raw_payload)
-        begin
-          json = Oj.load(raw_payload)
-          with_timed_logging(json) { do_dispatch(json) }
-        rescue Oj::Error => e
-          self.class.error_handler.call(e, raw_payload, metadata)
-        rescue StandardError => e
-          self.class.error_handler.call(e, json, metadata)
-        end
-        Lapine::DTrace.fire!(:dispatch_return, delegate_class.name, raw_payload)
+        Lapine::DTrace.fire!(:dispatch_enter, delegate_class.name, message.payload)
+        with_timed_logging(payload) { do_dispatch(payload) }
+        Lapine::DTrace.fire!(:dispatch_return, delegate_class.name, message.payload)
       end
 
       private
@@ -48,7 +39,7 @@ module Lapine
         ret = yield
         time_end = Time.now
         duration = (time_end - time) * 1000
-        logger.info "Processing rabbit message handler:#{delegate_class.name} duration(ms):#{duration} payload:#{json.inspect}"
+        message.logger.info "Processing rabbit message handler:#{delegate_class.name} duration(ms):#{duration} payload:#{json.inspect}"
         ret
       end
 
@@ -58,7 +49,7 @@ module Lapine
 
       def do_dispatch(payload)
         delegate_method_names.each do |meth|
-          return delegate_class.send(meth, payload, metadata) if delegate_class.respond_to?(meth)
+          return delegate_class.send(meth, payload, message.metadata) if delegate_class.respond_to?(meth)
         end
       end
     end

data/lib/lapine/consumer/message.rb

@@ -0,0 +1,28 @@
+module Lapine
+  module Consumer
+    class Message < Hash
+      def initialize(payload, metadata, logger)
+        super(nil)
+        self['payload'] = payload
+        self['metadata'] = metadata
+        self['logger'] = logger
+      end
+
+      def payload
+        self['payload']
+      end
+
+      def decoded_payload
+        self['decoded_payload']
+      end
+
+      def metadata
+        self['metadata']
+      end
+
+      def logger
+        self['logger']
+      end
+    end
+  end
+end

data/lib/lapine/consumer/middleware.rb

@@ -0,0 +1,129 @@
+require 'lapine/consumer/middleware/error_handler'
+require 'lapine/consumer/middleware/message_ack_handler'
+require 'lapine/consumer/middleware/json_decoder'
+
+module Lapine
+  module Consumer
+    #
+    # Consumer middleware can be registered as follows:
+    #
+    #   Lapine::Consumer::Middleware.add MyClass
+    #   Lapine::Consumer::Middleware.add MyClass, argument
+    #   Lapine::Consumer::Middleware.add_before MyClass, MyOtherClass, argument
+    #   Lapine::Consumer::Middleware.add_after MyClass, MyOtherClass, argument
+    #
+    # Middleware should follow the pattern:
+    #
+    #   class MyMiddleware
+    #     attr_reader :app
+    #
+    #     def initialize(app, *arguments)
+    #       @app = app
+    #     end
+    #
+    #     def call(message)
+    #       # do stuff
+    #       app.call(message)
+    #     end
+    #   end
+    #
+    module Middleware
+      # A Register of a middleware class that messages will be passed through
+      # on the way to being dispatched.
+      class Register < Struct.new(:klass, :args)
+        def create_new(app)
+          klass.new(app, *args)
+        end
+      end
+
+      DEFAULT_MIDDLEWARE = [
+        Register.new(MessageAckHandler),
+        Register.new(ErrorHandler),
+        Register.new(JsonDecoder)
+      ].freeze
+
+      class << self
+        def add(klass, *args)
+          registry << [klass, args]
+        end
+
+        def add_before(before_klass, klass, *args)
+          idx = registry.index_of(before_klass)
+          raise MiddlewareNotFound.new("#{before_klass} not registered in Lapine middleware") unless idx
+          registry.insert(idx, klass, args)
+        end
+
+        def add_after(after_klass, klass, *args)
+          idx = registry.index_of(after_klass)
+          raise MiddlewareNotFound.new("#{after_klass} not registered in Lapine middleware") unless idx
+          registry.insert(idx + 1, klass, args)
+        end
+
+        def delete(klass)
+          registry.delete(klass)
+        end
+
+        def registry
+          @registry ||= Registry.new(DEFAULT_MIDDLEWARE.dup)
+        end
+
+        def create_chain(app)
+          registry.map { |r| r.create_new(app) }
+        end
+
+        def app
+          App.new.tap do |app|
+            app.chain = create_chain(app)
+          end
+        end
+      end
+
+      class App
+        attr_accessor :chain
+
+        def call(message, &block)
+          chain << block if block_given?
+          current_register = chain.shift
+          current_register.call(message) if current_register
+        end
+      end
+
+      # Registry holds records of each middleware class that is added to the
+      # consumer middleware chain.
+      class Registry
+        include Enumerable
+
+        attr_reader :registry
+
+        def initialize(registry = [])
+          @registry = registry
+        end
+
+        def all
+          registry
+        end
+
+        def each(&blk)
+          all.each(&blk)
+        end
+
+        def delete(klass)
+          registry.reject! { |register| register.klass == klass }
+        end
+
+        def <<(klass_args)
+          insert(-1, klass_args[0], klass_args[1])
+        end
+
+        def index_of(klass)
+          registry.find_index { |register| register.klass == klass }
+        end
+
+        def insert(index, klass, args)
+          raise Lapine::DuplicateMiddleware if index_of(klass)
+          registry.insert(index, Register.new(klass, args))
+        end
+      end
+    end
+  end
+end

data/lib/lapine/consumer/middleware/error_handler.rb

@@ -0,0 +1,19 @@
+module Lapine
+  module Consumer
+    module Middleware
+      class ErrorHandler
+        attr_reader :app
+
+        def initialize(app)
+          @app = app
+        end
+
+        def call(message)
+          app.call(message)
+        rescue StandardError => e
+          Lapine::Consumer::Dispatcher.error_handler.call(e, message.payload, message.metadata)
+        end
+      end
+    end
+  end
+end

data/lib/lapine/consumer/middleware/json_decoder.rb

@@ -0,0 +1,20 @@
+require 'oj'
+
+module Lapine
+  module Consumer
+    module Middleware
+      class JsonDecoder
+        attr_reader :app
+
+        def initialize(app)
+          @app = app
+        end
+
+        def call(message)
+          message['decoded_payload'] = Oj.load(message.payload)
+          app.call(message)
+        end
+      end
+    end
+  end
+end

data/lib/lapine/consumer/middleware/message_ack_handler.rb

@@ -0,0 +1,19 @@
+module Lapine
+  module Consumer
+    module Middleware
+      class MessageAckHandler
+        attr_reader :app
+
+        def initialize(app)
+          @app = app
+        end
+
+        def call(message)
+          app.call(message)
+        ensure
+          message.metadata.ack
+        end
+      end
+    end
+  end
+end

data/lib/lapine/consumer/runner.rb

@@ -5,6 +5,8 @@ require 'lapine/annotated_logger'
 require 'lapine/consumer/config'
 require 'lapine/consumer/connection'
 require 'lapine/consumer/environment'
+require 'lapine/consumer/message'
+require 'lapine/consumer/middleware'
 require 'lapine/consumer/topology'
 require 'lapine/consumer/dispatcher'
 
@@ -29,15 +31,18 @@ module Lapine
           topology.each_binding do |q, conn, routing_key, classes|
             queue = conn.channel.queue(q, @queue_properties).bind(conn.exchange, routing_key: routing_key)
             queue.subscribe(ack: true) do |metadata, payload|
-              classes.each do |clazz|
-                Lapine::Consumer::Dispatcher.new(clazz, payload, metadata, logger).dispatch
-              end
 
-              if config.debug?
-                @message_count += 1
-                @running_message_count += 1
+              message = Consumer::Message.new(payload, metadata, logger)
+              Middleware.app.call(message) do |message|
+                classes.each do |clazz|
+                  Lapine::Consumer::Dispatcher.new(clazz, message).dispatch
+                end
+
+                if config.debug?
+                  @message_count += 1
+                  @running_message_count += 1
+                end
               end
-              metadata.ack
 
               EventMachine.stop_event_loop if should_exit?
             end

data/lib/lapine/errors.rb

@@ -3,4 +3,7 @@ module Lapine
   class UndefinedConnection < LapineError; end
   class UndefinedExchange < LapineError; end
   class NilExchange < LapineError; end
+
+  class MiddlewareNotFound < LapineError; end
+  class DuplicateMiddleware < LapineError; end
 end

data/lib/lapine/exchange.rb

@@ -9,24 +9,26 @@ module Lapine
       @props = properties.dup
       @connection_name = props.delete(:connection)
       @exchange_type = props.delete(:type)
+      ObjectSpace.define_finalizer(self, proc { |id| Lapine.config.cleanup_exchange(id) })
     end
 
-    def exchange
-      reconnect unless @exchange && conn && conn.connected?
-      raise Lapine::NilExchange unless @exchange
-      @exchange
+    def connected?
+      @exchange.channel.connection.connected? &&
+        @exchange.channel.open?
     end
 
-    def reconnect
-      connection_props = Lapine.config.connection_properties[connection_name]
-      @conn = Bunny.new(connection_props)
-      conn.start
-      channel = conn.create_channel
-      @exchange = Bunny::Exchange.new(channel, exchange_type, name, props)
+    def exchange
+      @exchange ||= begin
+        conn = Lapine.config.active_connection(connection_name)
+        conn.logger.info "Creating channel for #{self.object_id}, thread: #{Thread.current.object_id}"
+        channel = conn.create_channel
+        Lapine.config.register_channel(self.object_id, channel)
+        Bunny::Exchange.new(channel, exchange_type, name, props)
+      end
     end
 
-    def close!
-      conn.close if conn.connected?
+    def close
+      @exchange.channel.close
     end
   end
 end

data/lib/lapine/test/exchange.rb

@@ -84,6 +84,10 @@ module Lapine
         @exchange = nil
         true
       end
+
+      def connected?
+        true
+      end
     end
   end
 end

data/lib/lapine/version.rb

@@ -1,3 +1,3 @@
 module Lapine
-  VERSION = '1.0.1'
+  VERSION = '1.1.2'
 end

data/spec/lib/lapine/consumer/dispatcher_spec.rb

@@ -3,12 +3,18 @@ require 'lapine/consumer/dispatcher'
 
 RSpec.describe Lapine::Consumer::Dispatcher do
 
-  subject(:dispatcher) { Lapine::Consumer::Dispatcher.new(delegate, json, metadata, logger) }
+  subject(:dispatcher) { Lapine::Consumer::Dispatcher.new(delegate, message) }
+  let(:message) do
+    Lapine::Consumer::Message.new(json, metadata, logger).tap do |message|
+      message['decoded_payload'] = hash
+    end
+  end
+
   let(:logger) { double('logger') }
   let(:hash) { {'foo' => 'bar'} }
   let(:json) { Oj.dump(hash) }
-  let(:metadata) { double("metadata") }
-  let(:delegate) { double("delegate", name: "ClassName") }
+  let(:metadata) { double('metadata') }
+  let(:delegate) { double('delegate', name: 'ClassName') }
 
   let(:caught_errors) { [] }
 
@@ -16,22 +22,22 @@ RSpec.describe Lapine::Consumer::Dispatcher do
     Lapine::Consumer::Dispatcher.error_handler = nil
   end
 
-  describe "#delegation" do
-    context "success cases" do
+  describe '#delegation' do
+    context 'success cases' do
       before do
         expect(logger).to receive(:info).once.with(/Processing(.*)ClassName/)
       end
 
-      context ".handle_lapine_payload method" do
-        it "receives handle_lapine_payload" do
+      context '.handle_lapine_payload method' do
+        it 'receives handle_lapine_payload' do
           expect(delegate).to receive(:respond_to?).with(:handle_lapine_payload).and_return(true)
           expect(delegate).to receive(:handle_lapine_payload).once
           dispatcher.dispatch
         end
       end
 
-      context ".perform_async method" do
-        it "receives perform_async" do
+      context '.perform_async method' do
+        it 'receives perform_async' do
           expect(delegate).to receive(:respond_to?).with(:handle_lapine_payload).and_return(false)
           expect(delegate).to receive(:respond_to?).with(:perform_async).and_return(true)
           expect(delegate).to receive(:perform_async).once
@@ -39,45 +45,16 @@ RSpec.describe Lapine::Consumer::Dispatcher do
         end
       end
     end
+  end
+end
 
-    describe 'error cases' do
-
-      context 'custom error handler' do
-        before do
-          Lapine::Consumer::Dispatcher.error_handler = ->(error, data, metadata) {
-            caught_errors << [error, data, metadata]
-          }
-        end
-        context 'with invalid json' do
-          let(:json) { 'oh boy I am not actually JSON' }
-
-          it 'notifies the error handler with the raw payload' do
-            dispatcher.dispatch
-            expect(caught_errors).to include([an_instance_of(Oj::ParseError), json, metadata])
-          end
-        end
-
-        context 'with any other error' do
-          before { allow(dispatcher).to receive(:do_dispatch).and_raise(ArgumentError) }
-
-          it 'notifies error handler with the parsed json' do
-            dispatcher.dispatch
-            expect(caught_errors).to include([an_instance_of(ArgumentError), hash, metadata])
-          end
-        end
-      end
-
-      context 'default error handler' do
-        before { allow(dispatcher).to receive(:do_dispatch).and_raise(ArgumentError) }
-
-        it 'notifies default error handler' do
-          expect($stderr).to receive(:puts)
-          dispatcher.dispatch
-        end
-      end
-
+RSpec.describe Lapine::Consumer::Dispatcher::DefaultErrorHandler do
+  let(:payload) { double('payload') }
+  let(:metadata) { double('metadata') }
 
-    end
+  it 'puts to stderr' do
+    expect($stderr).to receive(:puts)
+    Lapine::Consumer::Dispatcher::DefaultErrorHandler.new.call(StandardError.new, payload, metadata)
   end
 end
 

data/spec/lib/lapine/consumer/middleware_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+require 'lapine/consumer/dispatcher'
+require 'lapine/consumer/middleware'
+
+RSpec.describe Lapine::Consumer::Middleware do
+  class MiddlewareAddLetter
+    def initialize(app, letter)
+      @app = app
+      @letter = letter
+    end
+
+    def call(message)
+      message['letter'] = @letter
+      @app.call(message)
+    end
+  end
+
+  class MiddlewareCopyLetter
+    def initialize(app)
+      @app = app
+    end
+
+    def call(message)
+      message['middleware.copy_letter.ran'] = true
+      message['duplicate_letter'] = message['letter']
+      @app.call(message)
+    end
+  end
+
+  class RaisingMiddleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(_message)
+      raise StandardError.new('Raise')
+    end
+  end
+
+  class CatchingMiddleWare
+    def initialize(app)
+      @app = app
+    end
+
+    def call(message)
+      @app.call(message)
+    rescue StandardError => e
+      message['error_message'] = e.message
+    end
+  end
+
+  let(:metadata) { double('metadata', ack: true) }
+  let(:payload) { '{}' }
+  let(:message) { Lapine::Consumer::Message.new(payload, metadata, nil) }
+
+  describe '.add' do
+    before do
+      Lapine::Consumer::Middleware.tap do |middleware|
+        middleware.add MiddlewareAddLetter, 'f'
+      end
+    end
+
+    it 'is adds letter to hash' do
+      Lapine::Consumer::Middleware.app.call(message) do |message|
+        expect(message['letter']).to eq('f')
+      end
+    end
+
+    context 'when duplicate middleware is added' do
+      it 'raises' do
+        expect {
+          Lapine::Consumer::Middleware.tap do |middleware|
+            middleware.add MiddlewareAddLetter, 'f'
+          end
+        }.to raise_error(Lapine::DuplicateMiddleware)
+      end
+    end
+  end
+
+  describe '.delete' do
+    let(:registry) { Lapine::Consumer::Middleware.registry }
+
+    before do
+      Lapine::Consumer::Middleware.tap do |middleware|
+        middleware.add MiddlewareAddLetter, 'f'
+      end
+    end
+
+    it 'removes register that matches class name' do
+      expect(registry.index_of(MiddlewareAddLetter)).to be
+      Lapine::Consumer::Middleware.delete(MiddlewareAddLetter)
+      expect(registry.index_of(MiddlewareAddLetter)).not_to be
+    end
+  end
+
+  describe 'error handling' do
+    describe 'with default middleware' do
+      let(:error) { StandardError.new('doh') }
+
+      it 'runs through the dispatcher error_handler' do
+        errors = []
+        Lapine::Consumer::Dispatcher.error_handler = ->(e, data, md) {
+          errors << [e, data, md]
+        }
+        Lapine::Consumer::Middleware.app.call(message) { raise error }
+        expect(errors).to include([error, message.payload, message.metadata])
+      end
+    end
+
+    describe 'with custom middleware' do
+      before do
+        Lapine::Consumer::Middleware.tap do |middleware|
+          middleware.add CatchingMiddleWare
+          middleware.add RaisingMiddleware
+        end
+      end
+
+      it 'catches error' do
+        Lapine::Consumer::Middleware.app.call(message)
+        expect(message['error_message']).to eq('Raise')
+      end
+
+      it 'halts execution' do
+        expectation = double(called: true)
+        Lapine::Consumer::Middleware.app.call(message) do
+          expectation.called
+        end
+        expect(expectation).not_to have_received(:called)
+      end
+    end
+  end
+
+  describe '.add_before' do
+    before do
+      Lapine::Consumer::Middleware.tap do |middleware|
+        middleware.add MiddlewareAddLetter, 'f'
+        middleware.add_before MiddlewareAddLetter, MiddlewareCopyLetter
+      end
+
+      it 'prepends middleware' do
+        Lapine::Consumer::Middleware.app.call(message) do |message|
+          expect(message['letter']).to eq('f')
+          expect(message['duplicate_letter']).to be nil
+          expect(message['middleware.copy_letter.ran']).to be true
+        end
+      end
+    end
+  end
+
+  context '.add_after' do
+    before do
+      Lapine::Consumer::Middleware.tap do |middleware|
+        middleware.add MiddlewareAddLetter, 'f'
+        middleware.add_after MiddlewareAddLetter, MiddlewareCopyLetter
+      end
+
+      it 'prepends middleware' do
+        Lapine::Consumer::Middleware.app.call(message) do |message|
+          expect(message['letter']).to eq('f')
+          expect(message['duplicate_letter']).to be 'f'
+          expect(message['middleware.copy_letter.ran']).to be true
+        end
+      end
+    end
+  end
+end

data/spec/lib/lapine_spec.rb

@@ -1,8 +1,10 @@
 require 'spec_helper'
 require 'lapine'
+require 'lapine/consumer'
 
 RSpec.describe Lapine do
-  let(:connection) { double('connection') }
+  let(:connection) { double('connection', close: true, logger: logger) }
+  let(:logger) { double('bunny logger', info: true) }
   let(:connection_properties) do
     {
       host: 'someplace.com'
@@ -47,18 +49,20 @@ RSpec.describe Lapine do
   end
 
   describe '.close_connections!' do
-    let(:connection1) { double('blah connection', close!: true, name: 'blah') }
-    let(:connection2) { double('blargh connection', close!: true, name: 'blargh') }
+    let(:connection1) { double('blah connection', close: true, name: 'blah') }
+    let(:connection2) { double('blargh connection', close: true, name: 'blargh') }
 
     before do
-      config.exchanges['blah'] = connection1
-      config.exchanges['blargh'] = connection2
+      config.instance_variable_set(:@active_connections, {
+          'blah' => connection1,
+          'blargh' => connection2
+        })
     end
 
     it 'calls close on each connection' do
       Lapine.close_connections!
-      expect(connection1).to have_received(:close!)
-      expect(connection2).to have_received(:close!)
+      expect(connection1).to have_received(:close)
+      expect(connection2).to have_received(:close)
     end
 
     it 'clears the exchanges' do
@@ -81,8 +85,8 @@ RSpec.describe Lapine do
     end
 
     context 'when exchange has been registered' do
-      let(:channel) { double('channel') }
-      let(:exchange) { double('exchange') }
+      let(:channel) { double('channel', connection: connection, open?: true) }
+      let(:exchange) { double('exchange', channel: channel) }
 
       before do
         allow(connection).to receive(:start)

data/spec/spec_helper.rb

@@ -20,7 +20,13 @@ RSpec.configure do |config|
   Kernel.srand config.seed
 
   config.before :each do
+    Lapine::Consumer::Dispatcher.error_handler = nil
     Lapine.instance_variable_set(:@config, nil)
+    Lapine::Consumer::Middleware.instance_variable_set(:@registry,nil)
+    Thread.current.thread_variable_set(:lapine_exchanges, nil)
+  end
 
+  config.after :each do
+    Lapine.close_connections!
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lapine
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.2
 platform: ruby
 authors:
 - Eric Saxby
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-27 00:00:00.000000000 Z
+date: 2015-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: amqp
@@ -181,6 +181,11 @@ files:
 - lib/lapine/consumer/connection.rb
 - lib/lapine/consumer/dispatcher.rb
 - lib/lapine/consumer/environment.rb
+- lib/lapine/consumer/message.rb
+- lib/lapine/consumer/middleware.rb
+- lib/lapine/consumer/middleware/error_handler.rb
+- lib/lapine/consumer/middleware/json_decoder.rb
+- lib/lapine/consumer/middleware/message_ack_handler.rb
 - lib/lapine/consumer/runner.rb
 - lib/lapine/consumer/topology.rb
 - lib/lapine/dtrace.rb
@@ -193,6 +198,7 @@ files:
 - spec/lib/lapine/consumer/config_spec.rb
 - spec/lib/lapine/consumer/connection_spec.rb
 - spec/lib/lapine/consumer/dispatcher_spec.rb
+- spec/lib/lapine/consumer/middleware_spec.rb
 - spec/lib/lapine/consumer/runner_spec.rb
 - spec/lib/lapine/consumer/topology_spec.rb
 - spec/lib/lapine/publisher_spec.rb
@@ -228,6 +234,7 @@ test_files:
 - spec/lib/lapine/consumer/config_spec.rb
 - spec/lib/lapine/consumer/connection_spec.rb
 - spec/lib/lapine/consumer/dispatcher_spec.rb
+- spec/lib/lapine/consumer/middleware_spec.rb
 - spec/lib/lapine/consumer/runner_spec.rb
 - spec/lib/lapine/consumer/topology_spec.rb
 - spec/lib/lapine/publisher_spec.rb