msgr 1.2.0 → 1.4.0

data/spec/fixtures/msgr_routes_test_drain.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+route 'abc', to: 'consumer1#action1'
+route 'def', to: 'consumer1#action2'
+route 'ghi', to: 'consumer2#action1'

data/spec/integration/dummy/Rakefile

@@ -3,6 +3,6 @@
 # Add your own tasks in files placed in lib/tasks ending in .rake,
 # for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
 
-require File.expand_path('../config/application', __FILE__)
+require File.expand_path('config/application', __dir__)
 
 Dummy::Application.load_tasks

data/spec/integration/dummy/bin/bundle

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
 load Gem.bin_path('bundler', 'bundle')

data/spec/integration/dummy/bin/rails

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-APP_PATH = File.expand_path('../../config/application', __FILE__)
+APP_PATH = File.expand_path('../config/application', __dir__)
 require_relative '../config/boot'
 require 'rails/commands'

data/spec/integration/dummy/config/application.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require File.expand_path('../boot', __FILE__)
+require File.expand_path('boot', __dir__)
 
 require 'rails/all'
 

data/spec/integration/dummy/config/boot.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Set up gems listed in the Gemfile.
-ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../../../Gemfile', __FILE__)
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../../Gemfile', __dir__)
 
 require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])
-$LOAD_PATH.unshift File.expand_path('../../../../lib', __FILE__)
+$LOAD_PATH.unshift File.expand_path('../../../lib', __dir__)

data/spec/integration/dummy/config/environment.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Load the Rails application.
-require File.expand_path('../application', __FILE__)
+require File.expand_path('application', __dir__)
 
 # Initialize the Rails application.
 Dummy::Application.initialize!

data/spec/integration/dummy/config/rabbitmq.yml

@@ -1,5 +1,5 @@
 common: &common
-  uri: amqp://localhost/
+  uri: <%= ENV.fetch("AMQP_SERVER", "amqp://localhost/") %>
 
 test:
   <<: *common

data/spec/integration/msgr/dispatcher_spec.rb

@@ -4,7 +4,19 @@ require 'spec_helper'
 
 class DispatcherTestConsumer < Msgr::Consumer
   def index
-    puts "<<< #{payload}"
+    self.class.called!
+  end
+
+  class << self
+    def calls
+      @calls ||= 0
+    end
+
+    attr_writer :calls
+
+    def called!
+      self.calls += 1
+    end
   end
 end
 
@@ -19,55 +31,59 @@ describe Msgr::Dispatcher do
   let(:config) { {max: 1} }
   let(:consumer) { 'DispatcherTestConsumer' }
   let(:route) do
-    double(:route).tap do |t|
+    instance_double('Msgr::Route').tap do |t|
       allow(t).to receive(:consumer).and_return consumer
       allow(t).to receive(:action).and_return 'index'
     end
   end
   let(:channel) do
-    double(:channel).tap do |c|
+    instance_double('Msgr::Channel').tap do |c|
       allow(c).to receive(:ack)
     end
   end
   let(:delivery_info) do
-    double(:delivery_info).tap do |ti|
+    instance_double('Bunny::DeliveryInfo').tap do |ti|
       allow(ti).to receive(:delivery_tag).and_return(3)
     end
   end
   let(:payload) { {} }
   let(:metadata) do
-    double(:metadata).tap do |metadata|
+    instance_double('Bunny::MessageProperties').tap do |metadata|
       allow(metadata).to receive(:content_type).and_return('text/plain')
     end
   end
   let(:message) { Msgr::Message.new channel, delivery_info, metadata, payload, route }
   let(:action) { -> { dispatcher.call message } }
 
-  it 'should consume message' do
-    expect_any_instance_of(DispatcherTestConsumer).to receive(:index)
-    dispatcher.call message
+  it 'consumes message' do
+    expect do
+      dispatcher.call message
+    end.to change(DispatcherTestConsumer, :calls).by(1)
   end
 
   context 'with not acknowledged message' do
-    before { dispatcher.call message }
     subject { message }
-    it { should be_acked }
+
+    before { dispatcher.call message }
+
+    it { is_expected.to be_acked }
   end
 
   describe 'exception swallowing' do
     let(:consumer) { 'DispatcherRaiseConsumer' }
+
     before do
       allow(message).to receive(:nack)
     end
 
-    it 'should swallow exceptions by default' do
+    it 'swallows exceptions by default' do
       expect { dispatcher.call(message) }.not_to raise_error
     end
 
     context 'with raise_exceptions configuration option and a synchronous pool' do
       let(:config) { super().merge(raise_exceptions: true) }
 
-      it 'should raise the exception' do
+      it 'raises the exception' do
         expect { dispatcher.call(message) }.to raise_error(ArgumentError)
       end
     end

data/spec/integration/msgr/railtie_spec.rb

@@ -6,139 +6,29 @@ describe Msgr::Railtie do
   describe 'configuration options' do
     let(:config) { Rails.configuration }
 
-    it 'should have `msgr` key' do
+    it 'has `msgr` key' do
       expect(config).to respond_to :msgr
     end
   end
 
-  describe '#parse_config' do
-    let(:settings) { {} }
-    let(:action) { described_class.parse_config settings }
-    subject { action }
-
-    context 'with incorrect settings' do
-      subject { -> { action } }
-
-      context 'with config without url' do
-        let(:settings) { {'test' => {hans: 'otto'}} }
-
-        it { should raise_error 'Could not load rabbitmq environment config: URI missing.' }
-      end
-
-      context 'with invalid autostart value' do
-        let(:settings) { {'test' => {uri: 'hans', autostart: 'unvalid'}} }
-
-        it { should raise_error 'Invalid value for rabbitmq config autostart: "unvalid"' }
-      end
-
-      context 'with invalid checkcredentials value' do
-        let(:settings) { {'test' => {uri: 'hans', checkcredentials: 'unvalid'}} }
-
-        it { should raise_error 'Invalid value for rabbitmq config checkcredentials: "unvalid"' }
-      end
-
-      context 'with invalid raise_exceptions value' do
-        let(:settings) { {'test' => {uri: 'franz', raise_exceptions: 'unvalid'}} }
-
-        it { should raise_error 'Invalid value for rabbitmq config raise_exceptions: "unvalid"' }
-      end
-    end
-
-    context 'without set routes file' do
-      let(:settings) { {'test' => {uri: 'test'}} }
-
-      context '[:routing_file]' do
-        subject { super()[:routing_file] }
-        it { should eq Rails.root.join('config/msgr.rb').to_s }
-      end
-    end
-
-    context 'with set routes file' do
-      let(:settings) { {'test' => {uri: 'test', 'routing_file' => 'my fancy file'}} }
-
-      context '[:routing_file]' do
-        subject { super()[:routing_file] }
-        it { should eq 'my fancy file' }
-      end
-    end
-
-    context 'with uri as symbol' do
-      let(:settings) { {'test' => {uri: 'hans'}} }
-
-      context '[:uri]' do
-        subject { super()[:uri] }
-        it { should eq 'hans' }
-      end
-    end
-
-    context 'with uri as string' do
-      let(:settings) { {'test' => {'uri' => 'hans'}} }
-
-      context '[:uri]' do
-        subject { super()[:uri] }
-        it { should eq 'hans' }
-      end
-    end
-
-    context 'without raise_exceptions config' do
-      let(:settings) { {'test' => {'uri' => 'hans'}, 'development' => {'uri' => 'hans_dev'}} }
-
-      describe '[:raise_exceptions]' do
-        subject { super()[:raise_exceptions] }
-        it { should eq false }
-      end
-    end
-  end
-
   describe '#load' do
-    let(:config) do
-      cfg = ActiveSupport::OrderedOptions.new
-      cfg.rabbitmq_config = Rails.root.join 'config', 'rabbitmq.yml'
-      cfg
-    end
-
-    context 'with autostart is true' do
-      it 'should not start Msgr' do
-        expect(Msgr).to receive(:start)
-        expect(Msgr::Railtie).to receive(:load_config).and_return('test' => {uri: 'test', autostart: true})
-        Msgr::Railtie.load config
-      end
-    end
-
-    context 'without autostart value' do
-      it 'should not start Msgr' do
-        expect(Msgr).to_not receive(:start)
-        expect(Msgr::Railtie).to receive(:load_config).and_return('test' => {uri: 'test'})
-        Msgr::Railtie.load config
-      end
+    before do
+      allow(Msgr).to receive(:start)
+      allow(Msgr.client).to receive(:connect)
     end
 
     context 'without checkcredentials value' do
-      it 'should connect to rabbitmq directly to check credentials' do
-        expect_any_instance_of(Msgr::Client).to receive(:connect)
-        expect(Msgr::Railtie).to receive(:load_config).and_return('test' => {uri: 'test'})
-        Msgr::Railtie.load config
+      it 'connects to rabbitmq directly to check credentials' do
+        described_class.load({})
+        expect(Msgr.client).to have_received(:connect)
       end
     end
 
     context 'with checkcredentials is false' do
-      it 'should connect to rabbitmq directly to check credentials' do
-        expect_any_instance_of(Msgr::Client).to_not receive(:connect)
-        expect(Msgr::Railtie).to receive(:load_config).and_return('test' => {uri: 'test', checkcredentials: false})
-        Msgr::Railtie.load config
+      it 'connects to rabbitmq directly to check credentials' do
+        described_class.load({checkcredentials: false})
+        expect(Msgr.client).not_to have_received(:connect)
       end
     end
   end
-
-  # describe '#load_config'
-  #   let(:options) { {} }
-
-  #   subject { Msgr::Railtie.load_config options }
-
-  #   if Rails::Application.methods.include(:config_for)
-  #     it 'should use config_for' do
-
-  #     end
-  #   end
-  # end
 end

data/spec/integration/spec_helper.rb

@@ -10,15 +10,14 @@ Coveralls.wear! do
   add_filter 'spec'
 end
 
-#
 ENV['RAILS_ENV'] ||= 'test'
 ENV['RAILS_GROUPS'] = ['rails', ENV['RAILS_GROUPS']].reject(&:nil?).join(',')
-require File.expand_path('../dummy/config/environment', __FILE__)
+require File.expand_path('dummy/config/environment', __dir__)
 require 'rspec/rails'
 
 # Requires supporting ruby files with custom matchers and macros, etc,
 # in spec/support/ and its subdirectories.
-Dir[File.expand_path('../support/**/*.rb', __FILE__)].each {|f| require f }
+Dir[File.expand_path('support/**/*.rb', __dir__)].sort.each {|f| require f }
 
 # Checks for pending migrations before tests are run.
 # If you are not using ActiveRecord, you can remove this line.

data/spec/integration/{msgr_spec.rb → test_controller_spec.rb}

@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 describe TestController, type: :request do
-  it 'should send messages on :index' do
+  it 'sends messages on :index' do
     get '/'
   end
 end

data/spec/unit/msgr/client_spec.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Msgr::Client do
+  subject(:client) { described_class.new config }
+
+  let(:config) { {} }
+
+  describe '#uri' do
+    subject(:uri) { client.uri.to_s }
+
+    context 'with default config' do
+      it 'uses the default config' do
+        expect(uri).to eq 'amqp://127.0.0.1'
+      end
+    end
+
+    context 'without vhost' do
+      let(:config) { {uri: 'amqp://rabbit'} }
+
+      it 'does not specify a vhost' do
+        expect(uri).to eq 'amqp://rabbit'
+      end
+    end
+
+    context 'with empty vhost' do
+      let(:config) { {uri: 'amqp://rabbit/'} }
+
+      it 'does not specify a vhost' do
+        expect(uri).to eq 'amqp://rabbit'
+      end
+    end
+
+    context 'with explicit vhost' do
+      let(:config) { {uri: 'amqp://rabbit/some_vhost'} }
+
+      # This behavior is due to legacy parsing in Msgr's config.
+      # We interpret the entire path (incl. the leading slash)
+      # as vhost. As per AMQP rules, this means the leading slash
+      # is part of the vhost, which means it has to be URL encoded.
+      # This will likely change with the next major release.
+      it 'uses the entire path as vhost' do
+        expect(uri).to eq 'amqp://rabbit/%2Fsome_vhost'
+      end
+    end
+
+    context 'with URI and vhost' do
+      let(:config) { {uri: 'amqp://rabbit/some_vhost', vhost: 'real_vhost'} }
+
+      # This is currently the only way to specify a vhost without
+      # leading slash (as a vhost in the :uri config would have
+      # an extra URL encoded leading slash).
+      it 'uses the explicit vhost' do
+        expect(uri).to eq 'amqp://rabbit/real_vhost'
+      end
+    end
+  end
+
+  describe 'drain' do
+    subject(:drain) { client.drain }
+
+    let(:config) { {routing_file: 'spec/fixtures/msgr_routes_test_drain.rb'} }
+    let(:channel_stub) { instance_double('Msgr::Channel', prefetch: true) }
+    let(:queue_stub) { instance_double('Bunny::Queue', purge: true) }
+
+    before do
+      allow(Msgr::Channel).to receive(:new).and_return(channel_stub)
+      allow(channel_stub).to receive(:queue).and_return(queue_stub).at_most(3).times
+    end
+
+    it 'requests purges for all configured routes' do
+      drain
+
+      expect(Msgr::Channel).to have_received(:new).exactly(3).times
+      expect(channel_stub).to have_received(:queue).with('msgr.consumer.Consumer1Consumer.action1', passive: true).once
+      expect(channel_stub).to have_received(:queue).with('msgr.consumer.Consumer1Consumer.action2', passive: true).once
+      expect(channel_stub).to have_received(:queue).with('msgr.consumer.Consumer2Consumer.action1', passive: true).once
+
+      expect(queue_stub).to have_received(:purge).exactly(3).times
+    end
+  end
+end

data/spec/{msgr → unit}/msgr/connection_spec.rb

@@ -6,7 +6,7 @@ describe Msgr::Connection do
   describe '#rebind' do
     let(:conn) { double }
     let(:routes) { Msgr::Routes.new }
-    let(:connection) { Msgr::Connection.new conn, routes, dispatcher }
+    let(:connection) { described_class.new conn, routes, dispatcher }
 
     pending 'some tests missing -> only lets written'
   end

data/spec/unit/msgr/dispatcher_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+class MsgrAutoAckConsumer < Msgr::Consumer
+  self.auto_ack = true
+
+  def index; end
+end
+
+class MsgrManualAckConsumer < Msgr::Consumer
+  self.auto_ack = false
+
+  def index; end
+end
+
+describe Msgr::Dispatcher do
+  subject { dispatcher }
+
+  let(:config) { {} }
+  let(:args) { [config] }
+  let(:dispatcher) { described_class.new(*args) }
+
+  describe 'dispatch' do
+    it 'acks messages automatically if auto_ack is enabled' do
+      route_db = instance_double('Msgr::Route', consumer: 'MsgrAutoAckConsumer', action: :index)
+      msg_db = instance_spy('Msgr::Message', route: route_db, acked?: false)
+
+      dispatcher.dispatch(msg_db)
+
+      expect(msg_db).to have_received(:ack)
+      expect(msg_db).not_to have_received(:nack)
+    end
+
+    it 'does not ack messages if auto_ack is disabled' do
+      route_db = instance_double('Msgr::Route', consumer: 'MsgrManualAckConsumer', action: :index)
+      msg_db = instance_spy('Msgr::Message', route: route_db, acked?: false)
+
+      dispatcher.dispatch(msg_db)
+
+      expect(msg_db).not_to have_received(:ack)
+      expect(msg_db).not_to have_received(:nack)
+    end
+  end
+end

data/spec/{msgr → unit}/msgr/route_spec.rb

@@ -3,61 +3,76 @@
 require 'spec_helper'
 
 describe Msgr::Route do
+  subject { route }
+
   let(:routing_key) { 'routing.key.#' }
   let(:options) { {to: 'test#index'} }
   let(:args) { [routing_key, options] }
-  let(:route) { Msgr::Route.new(*args) }
-  subject { route }
+  let(:route) { described_class.new(*args) }
 
   describe '#initialize' do
-    it 'should require `to` option' do
+    it 'requires `to` option' do
       expect do
-        Msgr::Route.new(routing_key, {})
+        described_class.new(routing_key, {})
       end.to raise_error(ArgumentError)
     end
 
-    it 'should require routing_key' do
+    it 'requires routing_key' do
       expect do
-        Msgr::Route.new nil, options
+        described_class.new nil, options
       end.to raise_error(ArgumentError)
     end
 
-    it 'should require not empty routing_key' do
+    it 'requires not empty routing_key' do
       expect do
-        Msgr::Route.new '', options
+        described_class.new '', options
       end.to raise_error ArgumentError, /routing key required/i
     end
 
-    it 'should require `to: "consumer#action` format' do
+    it 'requires `to: "consumer#action` format' do
       expect do
-        Msgr::Route.new routing_key, to: 'abc'
+        described_class.new routing_key, to: 'abc'
       end.to raise_error ArgumentError, /invalid consumer format/i
     end
+
+    it 'allows namespaces in consumer' do
+      expect do
+        described_class.new routing_key, to: 'abc/def#ghi'
+      end.not_to raise_error
+    end
   end
 
   describe '#consumer' do
-    it 'should return consumer class name' do
+    it 'returns consumer class name' do
       expect(route.consumer).to eq 'TestConsumer'
     end
 
     context 'with underscore consumer name' do
       let(:options) { super().merge to: 'test_resource_foo#index' }
 
-      it 'should return camelized method name' do
+      it 'returns camelized class name' do
         expect(route.consumer).to eq 'TestResourceFooConsumer'
       end
     end
+
+    context 'with nested namespace in consumer name' do
+      let(:options) { super().merge to: 'nested/namespace/foo#index' }
+
+      it 'returns fully classified, classified class name' do
+        expect(route.consumer).to eq 'Nested::Namespace::FooConsumer'
+      end
+    end
   end
 
   describe '#action' do
-    it 'should return action method name' do
+    it 'returns action method name' do
       expect(route.action).to eq 'index'
     end
 
     context 'with camelCase action name' do
       let(:options) { super().merge to: 'test#myActionMethod' }
 
-      it 'should return underscore method name' do
+      it 'returns underscore method name' do
         expect(route.action).to eq 'my_action_method'
       end
     end