msgr 1.2.0 → 1.3.0

data/spec/unit/msgr/client_spec.rb

@@ -0,0 +1,88 @@
+# 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(:channel_stub) { instance_double('Msgr::Channel', prefetch: true) }
+    let(:queue_stub) { instance_double('Bunny::Queue', purge: true) }
+
+    before do
+      client.routes.configure do
+        route 'abc', to: 'consumer1#action1'
+        route 'def', to: 'consumer1#action2'
+        route 'ghi', to: 'consumer2#action1'
+      end
+
+      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,62 @@
 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
   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 method name' do
         expect(route.consumer).to eq 'TestResourceFooConsumer'
       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

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

@@ -3,25 +3,15 @@
 require 'spec_helper'
 
 describe Msgr::Routes do
-  let(:routes) { Msgr::Routes.new }
+  let(:routes) { described_class.new }
 
   describe '#configure' do
-    let(:block) { proc {} }
-
-    it 'should evaluate given block within instance context' do
-      expect(routes).to receive(:instance_eval) do |&p|
-        expect(p).to be block
-      end
-
-      routes.configure(&block)
-    end
-
-    it 'should allow to call instance method in gven block' do
-      expect(routes).to receive(:test_instance_method).with(:abc)
-
+    it 'allows to configure the instance in given block' do
       routes.configure do
-        test_instance_method :abc
+        route 'abc', to: 'consumer#action'
       end
+
+      expect(routes.routes.first.keys).to eq ['abc']
     end
   end
 
@@ -35,7 +25,7 @@ describe Msgr::Routes do
 
     let(:each) { routes.each }
 
-    it 'should iterate over configured routes' do
+    it 'iterates over configured routes' do
       expect(each.size).to eq 2
 
       expect(each.map(&:keys)).to eq [%w[abc.#], %w[edf.#]]
@@ -45,15 +35,16 @@ describe Msgr::Routes do
   end
 
   describe '#route' do
-    let(:subject) { -> { routes.route 'routing.key', to: 'test2#index2' } }
+    subject(:route) { -> { routes.route 'routing.key', to: 'test2#index2' } }
+
     let(:last_route) { routes.routes.last }
 
-    it 'should add a new route' do
-      expect { subject.call }.to change { routes.routes.size }.from(0).to(1)
+    it 'adds a new route' do
+      expect { route.call }.to change { routes.routes.size }.from(0).to(1)
     end
 
-    it 'should add given route' do
-      subject.call
+    it 'adds given route' do
+      route.call
 
       expect(last_route.keys).to eq %w[routing.key]
       expect(last_route.consumer).to eq 'Test2Consumer'
@@ -61,26 +52,26 @@ describe Msgr::Routes do
     end
 
     context 'with same target' do
-      let(:subject) do
+      subject(:route) do
         lambda do
           routes.route 'routing.key', to: 'test#index'
           routes.route 'another.routing.key', to: 'test#index'
         end
       end
 
-      it 'should only add one new route' do
-        expect { subject.call }.to change { routes.routes.size }.from(0).to(1)
+      it 'onlies add one new route' do
+        expect { route.call }.to change { routes.routes.size }.from(0).to(1)
       end
 
-      it 'should add second binding to first route' do
-        subject.call
+      it 'adds second binding to first route' do
+        route.call
         expect(routes.routes.first.keys).to eq %w[routing.key another.routing.key]
       end
     end
   end
 
   describe '#files' do
-    it 'should allow to add route paths' do
+    it 'allows to add route paths' do
       routes.files << 'abc.rb'
       routes.files += %w[cde.rb edf.rb]
 
@@ -89,16 +80,20 @@ describe Msgr::Routes do
   end
 
   describe 'reload' do
-    before { File.stub(:exist?).and_return(true) }
+    before do
+      allow(File).to receive(:exist?).and_return(true)
+      allow(routes).to receive(:load)
+    end
 
-    it 'should trigger load for all files' do
-      expect(routes).to receive(:load).with('cde.rb').ordered
-      expect(routes).to receive(:load).with('edf.rb').ordered
+    it 'triggers load for all files' do
       routes.files += %w[cde.rb edf.rb]
       routes.reload
+
+      expect(routes).to have_received(:load).with('cde.rb').ordered
+      expect(routes).to have_received(:load).with('edf.rb').ordered
     end
 
-    it 'should clear old routes before reloading' do
+    it 'clears old routes before reloading' do
       routes.route 'abc', to: 'abc#test'
       routes.reload
       expect(routes.each.size).to eq 0
@@ -106,11 +101,13 @@ describe Msgr::Routes do
   end
 
   describe 'load' do
-    let(:file) { 'spec/fixtures/msgr-routes-test-1.rb' }
+    let(:file) { 'spec/fixtures/msgr_routes_test_1.rb' }
 
-    it 'should eval given file within routes context' do
-      expect(routes).to receive(:route).with('abc.#', to: 'test#index')
+    it 'evals given file within routes context' do
       routes.load file
+      expect(routes.routes.count).to eq 1
+      expect(routes.routes.first.keys).to eq ['abc.#']
+      expect(routes.routes.first.name).to eq 'msgr.consumer.TestConsumer.index'
     end
   end
 end

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

@@ -5,7 +5,6 @@ require 'spec_helper'
 class Receiver
 end
 
-#
 class MsgrTestConsumer < Msgr::Consumer
   def index
     Receiver.index
@@ -26,7 +25,7 @@ end
 
 describe Msgr do
   let(:queue) { Queue.new }
-  let(:client) { Msgr::Client.new size: 1, prefix: SecureRandom.hex(2) }
+  let(:client) { Msgr::Client.new size: 1, prefix: SecureRandom.hex(2), uri: ENV['AMQP_SERVER'] }
 
   before do
     client.routes.configure do
@@ -36,43 +35,51 @@ describe Msgr do
     end
 
     client.start
+
+    allow(Receiver).to receive(:index) { queue << :end }
+    allow(Receiver).to receive(:batch) {|msg| queue << msg }
+
+    error_count = 0
+    allow(Receiver).to receive(:error) do
+      error_count += 1
+      raise 'error' if error_count == 1
+
+      queue << :end
+    end
   end
 
   after do
     client.stop delete: true
   end
 
-  it 'should dispatch published methods to consumer' do
-    expect(Receiver).to receive(:index) { queue << :end }
-
+  it 'dispatches published methods to consumer' do
     client.publish 'Payload', to: 'test.index'
 
     Timeout.timeout(4) { queue.pop }
-  end
 
-  it 'should redelivery failed messages' do
-    expect(Receiver).to receive(:error).ordered.and_raise RuntimeError
-    expect(Receiver).to receive(:error).ordered { queue << :end }
+    expect(Receiver).to have_received(:index).exactly(1).time
+  end
 
+  it 'redelivers failed messages' do
     client.publish 'Payload', to: 'test.error'
 
     Timeout.timeout(4) { queue.pop }
-  end
 
-  it 'should receive 2 messages when prefetch is set to 2' do
-    expect(Receiver).to receive(:batch).twice { |msg| queue << msg }
+    expect(Receiver).to have_received(:error).exactly(2).times
+  end
 
+  it 'receives 2 messages when prefetch is set to 2' do
     2.times { client.publish 'Payload', to: 'test.batch' }
 
     2.times { Timeout.timeout(4) { queue.pop } }
-  end
 
-  it 'should not bulk ack all unacknowledged messages when acknowledging the last one' do
-    expect(Receiver).to receive(:batch).exactly(3).times { |msg| queue << msg }
+    expect(Receiver).to have_received(:batch).exactly(2).times
+  end
 
+  it 'does not bulk ack all unacknowledged messages when acknowledging the last one' do
     2.times { client.publish 'Payload', to: 'test.batch' }
 
-    messages = 2.times.map { Timeout.timeout(4) { queue.pop } }
+    messages = Array.new(2) { Timeout.timeout(4) { queue.pop } }
     messages[1].ack
     messages[0].nack
 
@@ -80,5 +87,7 @@ describe Msgr do
     message = Timeout.timeout(4) { queue.pop }
     expect(message.payload).to eq(messages[0].payload)
     expect(message.delivery_info.redelivered).to eq(true)
+
+    expect(Receiver).to have_received(:batch).exactly(3).times
   end
 end