hutch 0.25.0-java → 2.0.0-java

data/spec/hutch/consumer_spec.rb

@@ -28,6 +28,32 @@ describe Hutch::Consumer do
     ComplexConsumer
   end
 
+  let(:consumer_using_quorum_queue) do
+    unless defined? ConsumerUsingQuorumQueue
+      class ConsumerUsingQuorumQueue
+        include Hutch::Consumer
+        consume 'hutch.test1'
+        arguments foo: :bar
+        
+        quorum_queue
+      end
+    end
+    ConsumerUsingQuorumQueue
+  end
+
+  let(:consumer_using_classic_queue) do
+    unless defined? ConsumerUsingLazyQueue
+      class ConsumerUsingLazyQueue
+        include Hutch::Consumer
+        consume 'hutch.test1'
+        arguments foo: :bar
+        lazy_queue
+        classic_queue
+      end
+    end
+    ConsumerUsingLazyQueue
+  end
+
   describe 'module inclusion' do
     it 'registers the class as a consumer' do
       expect(Hutch).to receive(:register_consumer) do |klass|
@@ -71,6 +97,54 @@ describe Hutch::Consumer do
     end
   end
 
+  describe '.without_namespace' do
+    it 'is false by default' do
+      expect(simple_consumer.without_namespace?).to eq(false)
+    end
+
+    it 'returns true after calling without_namespace' do
+      simple_consumer.without_namespace
+      expect(simple_consumer.without_namespace?).to eq(true)
+    end
+  end
+
+  describe 'default queue mode' do
+    it 'does not specify any mode by default' do
+      expect(simple_consumer.queue_mode).to eq(nil)
+      expect(simple_consumer.queue_type).to eq(nil)
+    end
+  end
+
+  describe '.lazy_queue' do
+    context 'when queue mode has been set explicitly to lazy' do
+      it 'sets queue mode to lazy' do
+        expect(consumer_using_classic_queue.queue_mode).to eq('lazy')
+      end
+    end
+  end
+
+  describe '.classic_queue' do
+    context 'when queue type has been set explicitly to classic' do
+      it 'sets queue type to classic' do
+        expect(consumer_using_classic_queue.queue_type).to eq('classic')
+      end
+    end
+  end
+
+  describe '.quorum_queue' do
+    context 'when queue type has been set explicitly to quorum' do
+      it 'sets queue type to quorum' do
+        expect(consumer_using_quorum_queue.queue_type).to eq('quorum')
+      end
+
+      it 'accepts initial group size as an option' do
+        consumer = simple_consumer
+        expect { consumer.quorum_queue(initial_group_size: 3) }
+          .to change { consumer.initial_group_size }.to(3)
+      end
+    end
+  end
+
   describe '.arguments' do
     let(:args) { { foo: :bar} }
 
@@ -82,15 +156,30 @@ describe Hutch::Consumer do
   end
 
   describe '.get_arguments' do
-
     context 'when defined' do
-      it { expect(complex_consumer.get_arguments).to eq(foo: :bar) }
+      it { expect(complex_consumer.get_arguments).to include(foo: :bar) }
     end
 
-    context 'when not defined' do
-      it { expect(simple_consumer.get_arguments).to eq({}) }
+    context 'when queue is lazy' do
+      it 'has the x-queue-mode argument set to lazy' do
+        expect(consumer_using_classic_queue.get_arguments['x-queue-mode'])
+          .to eq('lazy')
+      end
     end
 
+    context "when queue's type is quorum" do
+      let(:arguments) { consumer_using_quorum_queue.get_arguments }
+      it 'has the x-queue-type argument set to quorum' do
+        expect(arguments['x-queue-type']).to eq('quorum')
+        expect(arguments).to_not have_key('x-quorum-initial-group-size')
+      end
+
+      it 'has the x-quorum-initial-group-size argument set to quorum' do
+        consumer_using_quorum_queue.quorum_queue(initial_group_size: 5)
+        expect(arguments['x-queue-type']).to eq('quorum')
+        expect(arguments['x-quorum-initial-group-size']).to eq(5)
+      end
+    end
   end
 
   describe '.get_queue_name' do

data/spec/hutch/error_handlers/airbrake_spec.rb

@@ -1,5 +1,8 @@
 require 'spec_helper'
 
+# The airbrake gem is MRI-only, see the Gemfile
+return if defined?(JRUBY_VERSION)
+
 describe Hutch::ErrorHandlers::Airbrake do
   let(:error_handler) { Hutch::ErrorHandlers::Airbrake.new }
 
@@ -14,7 +17,7 @@ describe Hutch::ErrorHandlers::Airbrake do
 
     it "logs the error to Airbrake" do
       message_id = "1"
-      properties = OpenStruct.new(message_id: message_id)
+      properties = Struct.new(:message_id).new(message_id)
       payload = "{}"
       consumer = double
       ex = error

data/spec/hutch/error_handlers/bugsnag_spec.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Hutch::ErrorHandlers::Bugsnag do
+  let(:error_handler) { described_class.new }
+
+  before do
+    Bugsnag.configure do |bugsnag|
+      bugsnag.api_key = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+      bugsnag.logger = Logger.new(File::NULL) # suppress logging
+    end
+  end
+
+  describe "#handle" do
+    let(:error) do
+      begin
+        raise "Stuff went wrong"
+      rescue RuntimeError => err
+        err
+      end
+    end
+
+    it "logs the error to Bugsnag" do
+      message_id = "1"
+      properties = Struct.new(:message_id).new(message_id)
+      payload = "{}"
+      consumer = double
+      ex = error
+      message = {
+        payload: payload,
+        consumer: consumer
+      }
+
+      expect(::Bugsnag).to receive(:notify).with(ex).and_call_original
+      expect_any_instance_of(::Bugsnag::Report).to receive(:add_tab).with(:hutch, message)
+      error_handler.handle(properties, payload, consumer, ex)
+    end
+  end
+
+  describe "#handle_setup_exception" do
+    let(:error) do
+      begin
+        raise "Stuff went wrong"
+      rescue RuntimeError => err
+        err
+      end
+    end
+
+    it "logs the error to Bugsnag" do
+      ex = error
+      expect(::Bugsnag).to receive(:notify).with(ex)
+      error_handler.handle_setup_exception(ex)
+    end
+  end
+end

data/spec/hutch/error_handlers/honeybadger_spec.rb

@@ -14,7 +14,7 @@ describe Hutch::ErrorHandlers::Honeybadger do
 
     it "logs the error to Honeybadger" do
       message_id = "1"
-      properties = OpenStruct.new(message_id: message_id)
+      properties = Struct.new(:message_id).new(message_id)
       payload = "{}"
       consumer = double
       ex = error

data/spec/hutch/error_handlers/logger_spec.rb

@@ -4,7 +4,7 @@ describe Hutch::ErrorHandlers::Logger do
   let(:error_handler) { Hutch::ErrorHandlers::Logger.new }
 
   describe '#handle' do
-    let(:properties) { OpenStruct.new(message_id: "1") }
+    let(:properties) { Struct.new(:message_id).new("1") }
     let(:payload) { "{}" }
     let(:error) { double(message: "Stuff went wrong", class: "RuntimeError",
                        backtrace: ["line 1", "line 2"]) }

data/spec/hutch/error_handlers/rollbar_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Hutch::ErrorHandlers::Rollbar do
+  let(:error_handler) { Hutch::ErrorHandlers::Rollbar.new }
+
+  describe '#handle' do
+    let(:error) do
+      begin
+        raise "Stuff went wrong"
+      rescue RuntimeError => err
+        err
+      end
+    end
+
+    it "logs the error to Rollbar" do
+      message_id = "1"
+      properties = Struct.new(:message_id).new(message_id)
+      payload = "{}"
+      consumer = double
+      ex = error
+      message = {
+        payload: payload,
+        consumer: consumer
+      }
+      expect(::Rollbar).to receive(:error).with(ex, message)
+      error_handler.handle(properties, payload, consumer, ex)
+    end
+  end
+
+  describe '#handle_setup_exception' do
+    let(:error) do
+      begin
+        raise "Stuff went wrong"
+      rescue RuntimeError => err
+        err
+      end
+    end
+
+    it "logs the error to Rollbar" do
+      ex = error
+      expect(::Rollbar).to receive(:error).with(ex)
+      error_handler.handle_setup_exception(ex)
+    end
+  end
+end

data/spec/hutch/error_handlers/sentry_spec.rb

@@ -3,8 +3,16 @@ require 'spec_helper'
 describe Hutch::ErrorHandlers::Sentry do
   let(:error_handler) { Hutch::ErrorHandlers::Sentry.new }
 
+  before do
+    Sentry.init do
+      # initialize Sentry so that the integration acutally works
+      # otherwise, all its methods are going to return early
+      # so it will be impossible to check if it actually works
+    end
+  end
+
   describe '#handle' do
-    let(:properties) { OpenStruct.new(message_id: "1") }
+    let(:properties) { Struct.new(:message_id).new("1") }
     let(:payload) { "{}" }
     let(:error) do
       begin
@@ -15,7 +23,8 @@ describe Hutch::ErrorHandlers::Sentry do
     end
 
     it "logs the error to Sentry" do
-      expect(Raven).to receive(:capture_exception).with(error, extra: { payload: payload })
+      expect(::Sentry).to receive(:capture_exception).with(error).and_call_original
+
       error_handler.handle(properties, payload, double, error)
     end
   end
@@ -30,7 +39,8 @@ describe Hutch::ErrorHandlers::Sentry do
     end
 
     it "logs the error to Sentry" do
-      expect(Raven).to receive(:capture_exception).with(error)
+      expect(::Sentry).to receive(:capture_exception).with(error).and_call_original
+
       error_handler.handle_setup_exception(error)
     end
   end

data/spec/hutch/message_spec.rb

@@ -4,7 +4,7 @@ describe Hutch::Message do
   let(:delivery_info) { double('Delivery Info') }
   let(:props) { double('Properties', content_type: "application/json") }
   let(:body) {{ foo: 'bar' }.with_indifferent_access}
-  let(:json_body) { MultiJson.dump(body) }
+  let(:json_body) { JSON.generate(body) }
   subject(:message) { Hutch::Message.new(delivery_info, props, json_body, Hutch::Config[:serializer]) }
 
   describe '#body' do

data/spec/hutch/tracers/datadog_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+RSpec.describe Hutch::Tracers::Datadog do
+  ::Datadog.logger.level = Logger::FATAL # suppress logging
+  
+  describe "#handle" do
+    subject(:handle) { tracer.handle(message) }
+
+    let(:tracer) { described_class.new(klass) }
+    let(:klass)  do
+      Class.new do
+        attr_reader :message
+
+        def initialize
+          @message = nil
+        end
+
+        def class
+          Struct.new(:name).new('ClassName')
+        end
+
+        def process(message)
+          @message = message
+        end
+      end.new
+    end
+    let(:message) { double(:message) }
+
+    before do
+      allow(::Datadog::Tracing).to receive(:trace).and_call_original
+    end
+
+    it 'uses Datadog tracer' do
+      handle
+
+      expect(::Datadog::Tracing).to have_received(:trace).with('ClassName',
+        hash_including(service: 'hutch', type: 'rabbitmq'))
+    end
+
+    it 'processes the message' do
+      expect {
+        handle
+      }.to change { klass.message }.from(nil).to(message)
+    end
+  end
+end

data/spec/hutch/waiter_spec.rb

@@ -22,7 +22,7 @@ RSpec.describe Hutch::Waiter do
       end
     end
 
-    context 'a TERM signal is received' do
+    context 'a TERM signal is received', if: !defined?(JRUBY_VERSION) do
       it 'logs that hutch is stopping' do
         expect(Hutch::Logging.logger).to receive(:info)
           .with('caught SIGTERM, stopping hutch...')
@@ -32,7 +32,7 @@ RSpec.describe Hutch::Waiter do
       end
     end
 
-    context 'a INT signal is received' do
+    context 'a INT signal is received', if: !defined?(JRUBY_VERSION) do
       it 'logs that hutch is stopping' do
         expect(Hutch::Logging.logger).to receive(:info)
           .with('caught SIGINT, stopping hutch...')

data/spec/hutch/worker_spec.rb

@@ -4,7 +4,8 @@ require 'hutch/worker'
 describe Hutch::Worker do
   let(:consumer) { double('Consumer', routing_keys: %w( a b c ),
                           get_queue_name: 'consumer', get_arguments: {},
-                          get_serializer: nil) }
+                          get_options: {}, get_serializer: nil,
+                          without_namespace?: false) }
   let(:consumers) { [consumer, double('Consumer')] }
   let(:broker) { Hutch::Broker.new }
   let(:setup_procs) { Array.new(2) { Proc.new {} } }
@@ -32,20 +33,34 @@ describe Hutch::Worker do
 
   describe '#setup_queue' do
     let(:queue) { double('Queue', bind: nil, subscribe: nil) }
-    before { allow(broker).to receive_messages(queue: queue, bind_queue: nil) }
+    before { allow(broker).to receive_messages(queue: queue, bind_queue: nil, namespaced_queue_name: 'consumer') }
 
-    it 'creates a queue' do
-      expect(broker).to receive(:queue).with(consumer.get_queue_name, consumer.get_arguments).and_return(queue)
+    it 'creates a queue with a namespaced name' do
+      expect(broker).to receive(:namespaced_queue_name).with('consumer').and_return('ns:consumer')
+      expect(broker).to receive(:queue).with('ns:consumer', consumer.get_options).and_return(queue)
       worker.setup_queue(consumer)
     end
 
+    context 'when the consumer uses without_namespace' do
+      let(:consumer) { double('Consumer', routing_keys: %w( a b c ),
+                              get_queue_name: 'consumer', get_arguments: {},
+                              get_options: {}, get_serializer: nil,
+                              without_namespace?: true) }
+
+      it 'creates a queue without applying the namespace' do
+        expect(broker).not_to receive(:namespaced_queue_name)
+        expect(broker).to receive(:queue).with('consumer', consumer.get_options).and_return(queue)
+        worker.setup_queue(consumer)
+      end
+    end
+
     it 'binds the queue to each of the routing keys' do
       expect(broker).to receive(:bind_queue).with(queue, %w( a b c ))
       worker.setup_queue(consumer)
     end
 
     it 'sets up a subscription' do
-      expect(queue).to receive(:subscribe).with(consumer_tag: %r(^hutch\-.{36}$), manual_ack: true)
+      expect(queue).to receive(:subscribe).with(consumer_tag: %r(^hutch\-.{36}$), manual_ack: true, on_cancellation: kind_of(Proc))
       worker.setup_queue(consumer)
     end
 
@@ -53,7 +68,7 @@ describe Hutch::Worker do
       before { Hutch::Config.set(:consumer_tag_prefix, 'appname') }
 
       it 'sets up a subscription with the configured tag prefix' do
-        expect(queue).to receive(:subscribe).with(consumer_tag: %r(^appname\-.{36}$), manual_ack: true)
+        expect(queue).to receive(:subscribe).with(consumer_tag: %r(^appname\-.{36}$), manual_ack: true, on_cancellation: kind_of(Proc))
         worker.setup_queue(consumer)
       end
     end
@@ -61,6 +76,7 @@ describe Hutch::Worker do
     context 'with a configured consumer tag prefix that is too long' do
       let(:maximum_size) { 255 - SecureRandom.uuid.size - 1 }
       before { Hutch::Config.set(:consumer_tag_prefix, 'a'.*(maximum_size + 1)) }
+      after { Hutch::Config.set(:consumer_tag_prefix, 'hutch') }
 
       it 'raises an error' do
         expect { worker.setup_queue(consumer) }.to raise_error(/Tag must be 255 bytes long at most/)
@@ -68,28 +84,87 @@ describe Hutch::Worker do
     end
   end
 
+  describe '#handle_cancellation' do
+    let(:cancelled_channel) { double('Channel') }
+    let(:new_channel) { double('Channel') }
+    let(:log) { StringIO.new }
+
+    before do
+      allow(Hutch::Logging).to receive(:logger).and_return(Logger.new(log))
+      allow(broker).to receive(:channel).and_return(cancelled_channel)
+      allow(broker).to receive(:replace_channel!) do
+        allow(broker).to receive(:channel).and_return(new_channel)
+      end
+      allow(worker).to receive(:setup_queues)
+    end
+
+    context 'when the queue still exists' do
+      before { allow(broker).to receive(:queue_exists?).with('consumer').and_return(true) }
+
+      it 'replaces the channel and re-subscribes' do
+        expect(broker).to receive(:replace_channel!)
+        expect(worker).to receive(:setup_queues)
+
+        worker.handle_cancellation('consumer', cancelled_channel).join
+      end
+
+      it 'replaces the channel once for all the consumers that shared it' do
+        expect(broker).to receive(:replace_channel!).once
+
+        [
+          worker.handle_cancellation('consumer', cancelled_channel),
+          worker.handle_cancellation('consumer', cancelled_channel)
+        ].each(&:join)
+      end
+
+      it 'does not replace a channel that has already been replaced' do
+        expect(broker).not_to receive(:replace_channel!)
+
+        worker.handle_cancellation('consumer', double('An older channel')).join
+      end
+    end
+
+    context 'when the queue is gone' do
+      before { allow(broker).to receive(:queue_exists?).with('consumer').and_return(false) }
+
+      it 'does not re-subscribe' do
+        expect(broker).not_to receive(:replace_channel!)
+
+        worker.handle_cancellation('consumer', cancelled_channel)
+
+        log.rewind
+        expect(log.read).to match(/the queue no longer exists/)
+      end
+    end
+  end
+
   describe '#handle_message' do
+    subject { worker.handle_message(consumer, delivery_info, properties, payload) }
     let(:payload) { '{}' }
     let(:consumer_instance) { double('Consumer instance') }
-    let(:delivery_info) { double('Delivery Info', routing_key: '',
+    let(:delivery_info) { double('Delivery Info', routing_key: '', channel: nil,
                                  delivery_tag: 'dt') }
     let(:properties) { double('Properties', message_id: nil, content_type: "application/json") }
+    let(:log) { StringIO.new }
     before { allow(consumer).to receive_messages(new: consumer_instance) }
     before { allow(broker).to receive(:ack) }
     before { allow(broker).to receive(:nack) }
     before { allow(consumer_instance).to receive(:broker=) }
     before { allow(consumer_instance).to receive(:delivery_info=) }
+    before { allow(Hutch::Logging).to receive(:logger).and_return(Logger.new(log)) }
 
     it 'passes the message to the consumer' do
       expect(consumer_instance).to receive(:process).
                         with(an_instance_of(Hutch::Message))
-      worker.handle_message(consumer, delivery_info, properties, payload)
+      expect(consumer_instance).to receive(:message_rejected?).and_return(false)
+      subject
     end
 
     it 'acknowledges the message' do
       allow(consumer_instance).to receive(:process)
-      expect(broker).to receive(:ack).with(delivery_info.delivery_tag)
-      worker.handle_message(consumer, delivery_info, properties, payload)
+      expect(broker).to receive(:ack).with(delivery_info.delivery_tag, channel: delivery_info.channel)
+      expect(consumer_instance).to receive(:message_rejected?).and_return(false)
+      subject
     end
 
     context 'when the consumer fails and a requeue is configured' do
@@ -106,47 +181,86 @@ describe Hutch::Worker do
         expect(broker).to_not receive(:nack)
         expect(broker).to receive(:requeue)
 
-        worker.handle_message(consumer, delivery_info, properties, payload)
+        subject
       end
     end
 
 
     context 'when the consumer raises an exception' do
+      let(:expected_log) { /ERROR .+ error in consumer .+ RuntimeError .+ backtrace:/m }
       before { allow(consumer_instance).to receive(:process).and_raise('a consumer error') }
 
       it 'logs the error' do
-        Hutch::Config[:error_handlers].each do |backend|
-          expect(backend).to receive(:handle)
-        end
-        worker.handle_message(consumer, delivery_info, properties, payload)
+        expect { subject }.to change { log.tap(&:rewind).read }.from("").to(expected_log)
       end
 
       it 'rejects the message' do
-        expect(broker).to receive(:nack).with(delivery_info.delivery_tag)
-        worker.handle_message(consumer, delivery_info, properties, payload)
+        expect(broker).to receive(:nack).with(delivery_info.delivery_tag, channel: delivery_info.channel)
+        subject
+      end
+
+      context 'when a custom error handler supports delivery info' do
+        let(:error_handler) do
+          Class.new(Hutch::ErrorHandlers::Base) do
+            def handle(_properties, _payload, _consumer, _ex, delivery_info)
+              raise unless delivery_info.delivery_tag == 'dt'
+              puts 'handled!'
+            end
+          end
+        end
+
+        around do |example|
+          original = Hutch::Config[:error_handlers]
+          Hutch::Config[:error_handlers] = [error_handler.new]
+          example.run
+          Hutch::Config[:error_handlers] = original
+        end
+
+        it 'calls the custom handler with delivery info' do
+          expect { subject }.to output("handled!\n").to_stdout
+        end
+      end
+
+      context 'when a custom error handler does not support delivery info' do
+        let(:error_handler) do
+          Class.new(Hutch::ErrorHandlers::Base) do
+            def handle(_properties, _payload, _consumer, _ex)
+              puts 'handled!'
+            end
+          end
+        end
+
+        around do |example|
+          original = Hutch::Config[:error_handlers]
+          Hutch::Config[:error_handlers] = [error_handler.new]
+          example.run
+          Hutch::Config[:error_handlers] = original
+        end
+
+        it 'calls the custom handler with delivery info' do
+          expect { subject }.to output("handled!\n").to_stdout
+        end
       end
     end
 
     context "when the payload is not valid json" do
       let(:payload) { "Not Valid JSON" }
+      let(:expected_log) { /ERROR .+ error in consumer .+ JSON::ParserError .+ backtrace:/m }
 
       it 'logs the error' do
-        Hutch::Config[:error_handlers].each do |backend|
-          expect(backend).to receive(:handle)
-        end
-        worker.handle_message(consumer, delivery_info, properties, payload)
+        expect { subject }.to change { log.tap(&:rewind).read }.from("").to(expected_log)
       end
 
       it 'rejects the message' do
-        expect(broker).to receive(:nack).with(delivery_info.delivery_tag)
-        worker.handle_message(consumer, delivery_info, properties, payload)
+        expect(broker).to receive(:nack).with(delivery_info.delivery_tag, channel: delivery_info.channel)
+        subject
       end
     end
   end
 
 
   describe '#acknowledge_error' do
-    let(:delivery_info) { double('Delivery Info', routing_key: '',
+    let(:delivery_info) { double('Delivery Info', routing_key: '', channel: nil,
                                  delivery_tag: 'dt') }
     let(:properties) { double('Properties', message_id: 'abc123') }