hutch 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: db5d3539145e0b5196542b4157d4262045f4e414
-  data.tar.gz: 072daf962f5ff1cd2c63278b97bd2d11efcd37e0
+  metadata.gz: 803369cb7619eae888379612cf278d49133a3f68
+  data.tar.gz: 4eb4a16d6b7a12441b9e56d972ebcc413b5fec82
 SHA512:
-  metadata.gz: fd18ffdbf03f1bbc8f18e9bbb71a3e92937392873c482ed1a2ba2bf7ccb6fc1b8e03ad1ed6dee2e1b09e03dfee6c15e59b4f8311c882a9b95e19c5cdb88d90c8
-  data.tar.gz: 241814297de25974719b07d728fb236df4b3de062997c033d50e79223bbb0609bb331f45d563efc8206ded3b0d2722583bb87e1b160a0e8a5a8744b0838a57ca
+  metadata.gz: 3f557376e9db220197b6f6f99cd28621593ed3a5f0bc96e26c471fb40b7b54e3f79564cad661873b223c7688713112bbf5536b705efdb0d3aa4b86d88725cd6b
+  data.tar.gz: d497420735d0567a167290a9de4130d66635f4ef36d5b1f674ca77e0320956518014cbc91054d72b10dc16ef3c2edc5498e47dd7a1b6ddce4edb013a757158ff

data/.travis.yml

@@ -1,7 +1,7 @@
 language: ruby
 rvm:
-  - "2.1.0"
-  - "2.0.0"
-  - "1.9.3"
+  - 2.1.0
+  - 2.0.0
+  - 1.9.3
 services:
   - rabbitmq

data/CHANGELOG.md

@@ -1,4 +1,16 @@
-## 0.9.0 — unreleased
+## 0.10.0 — unreleased
+
+### Bunny Update
+
+Bunny is updated to `1.4.x`.
+
+### Exceptions in Error Handlers Don't Prevent Nacks
+
+Exceptions in error handlers no longer prevent messages from being
+`basic.nack`-ed.
+
+
+## 0.9.0 — May 13, 2014
 
 ### Platform-aware Signal Registration
 

data/hutch.gemspec

@@ -1,10 +1,10 @@
 require File.expand_path('../lib/hutch/version', __FILE__)
 
 Gem::Specification.new do |gem|
-  gem.add_runtime_dependency 'bunny', '~> 1.2.1'
+  gem.add_runtime_dependency 'bunny', '>= 1.5.1'
   gem.add_runtime_dependency 'carrot-top', '~> 0.0.7'
   gem.add_runtime_dependency 'multi_json', '~> 1.5'
-  gem.add_development_dependency 'rspec', '~> 2.12.0'
+  gem.add_development_dependency 'rspec', '~> 3.0'
   gem.add_development_dependency 'simplecov', '~> 0.7.1'
 
   gem.name = 'hutch'

data/lib/hutch/broker.rb

@@ -19,8 +19,11 @@ module Hutch
       set_up_api_connection if options.fetch(:enable_http_api_use, true)
 
       if block_given?
-        yield
-        disconnect
+        begin
+          yield
+        ensure
+          disconnect
+        end
       end
     end
 
@@ -46,6 +49,16 @@ module Hutch
     end
 
     def open_connection!
+      if @config[:uri] && !@config[:uri].empty?
+        u = URI.parse(@config[:uri])
+
+        @config[:mq_host]     = u.host
+        @config[:mq_port]     = u.port
+        @config[:mq_vhost]    = u.path.sub(/^\//, "")
+        @config[:mq_username] = u.user
+        @config[:mq_password] = u.password
+      end
+
       host     = @config[:mq_host]
       port     = @config[:mq_port]
       vhost    = @config[:mq_vhost]
@@ -57,7 +70,6 @@ module Hutch
       protocol = tls ? "amqps://" : "amqp://"
       sanitized_uri = "#{protocol}#{username}@#{host}:#{port}/#{vhost.sub(/^\//, '')}"
       logger.info "connecting to rabbitmq (#{sanitized_uri})"
-
       @connection = Bunny.new(host: host, port: port, vhost: vhost,
                               tls: tls, tls_key: tls_key, tls_cert: tls_cert,
                               username: username, password: password,
@@ -68,6 +80,7 @@ module Hutch
         @connection.start
       end
 
+      logger.info "connected to RabbitMQ at #{host} as #{username}"
       @connection
     end
 
@@ -148,6 +161,14 @@ module Hutch
       @channel.work_pool.kill
     end
 
+    def requeue(delivery_tag)
+      @channel.reject(delivery_tag, true)
+    end
+
+    def reject(delivery_tag, requeue=false)
+      @channel.reject(delivery_tag, requeue)
+    end
+
     def ack(delivery_tag)
       @channel.ack(delivery_tag, false)
     end

data/lib/hutch/cli.rb

@@ -12,7 +12,11 @@ module Hutch
     def run(argv = ARGV)
       parse_options(argv)
 
-      Hutch.logger.info "hutch booted with pid #{Process.pid}"
+      ::Process.daemon(true) if Hutch::Config.daemonise
+
+      write_pid if Hutch::Config.pidfile
+
+      Hutch.logger.info "hutch booted with pid #{::Process.pid}"
 
       if load_app && start_work_loop == :success
         # If we got here, the worker was shut down nicely
@@ -170,6 +174,14 @@ module Hutch
           Hutch::Config.namespace = namespace
         end
 
+        opts.on('-d', '--daemonise', 'Daemonise') do |daemonise|
+          Hutch::Config.daemonise = daemonise
+        end
+
+        opts.on('--pidfile PIDFILE', 'Pidfile') do |pidfile|
+          Hutch::Config.pidfile = pidfile
+        end
+
         opts.on('--version', 'Print the version and exit') do
           puts "hutch v#{VERSION}"
           exit 0
@@ -181,5 +193,12 @@ module Hutch
         end
       end.parse!(args)
     end
+
+    def write_pid
+      pidfile = File.expand_path(Hutch::Config.pidfile)
+      Hutch.logger.info "writing pid in #{pidfile}"
+      File.open(pidfile, 'w') { |f| f.puts ::Process.pid }
+    end
+
   end
 end

data/lib/hutch/config.rb

@@ -7,7 +7,7 @@ module Hutch
   module Config
     require 'yaml'
 
-    def self.initialize
+    def self.initialize(params={})
       @config = {
         mq_host: 'localhost',
         mq_port: 5672,
@@ -21,13 +21,18 @@ module Hutch
         mq_api_host: 'localhost',
         mq_api_port: 15672,
         mq_api_ssl: false,
+        # placeholder, allows specifying connection parameters
+        # as a URI.
+        uri: nil,
         log_level: Logger::INFO,
         require_paths: [],
         autoload_rails: true,
         error_handlers: [Hutch::ErrorHandlers::Logger.new],
         namespace: nil,
+        daemonise: false,
+        pidfile: nil,
         channel_prefetch: 0
-      }
+      }.merge(params)
     end
 
     def self.get(attr)

data/lib/hutch/consumer.rb

@@ -5,11 +5,21 @@ module Hutch
   # gain a class method called `consume`, which should be used to register
   # the routing keys a consumer is interested in.
   module Consumer
+    attr_accessor :broker, :delivery_info
+
     def self.included(base)
       base.extend(ClassMethods)
       Hutch.register_consumer(base)
     end
 
+    def reject!
+      broker.reject(delivery_info.delivery_tag)
+    end
+
+    def requeue!
+      broker.requeue(delivery_info.delivery_tag)
+    end
+
     module ClassMethods
       # Add one or more routing keys to the set of routing keys the consumer
       # wants to subscribe to.

data/lib/hutch/error_handlers/logger.rb

@@ -5,7 +5,7 @@ module Hutch
     class Logger
       include Logging
 
-      def handle(message_id, consumer, ex)
+      def handle(message_id, payload, consumer, ex)
         prefix = "message(#{message_id || '-'}): "
         logger.error prefix + "error in consumer '#{consumer}'"
         logger.error prefix + "#{ex.class} - #{ex.message}"

data/lib/hutch/error_handlers/sentry.rb

@@ -12,7 +12,7 @@ module Hutch
         end
       end
 
-      def handle(message_id, consumer, ex)
+      def handle(message_id, payload, consumer, ex)
         prefix = "message(#{message_id || '-'}): "
         logger.error prefix + "Logging event to Sentry"
         logger.error prefix + "#{ex.class} - #{ex.message}"

data/lib/hutch/message.rb

@@ -5,6 +5,8 @@ module Hutch
   class Message
     extend Forwardable
 
+    attr_reader :delivery_info, :properties, :payload
+
     def initialize(delivery_info, properties, payload)
       @delivery_info = delivery_info
       @properties    = properties

data/lib/hutch/version.rb

@@ -1,4 +1,4 @@
 module Hutch
-  VERSION = '0.9.0'.freeze
+  VERSION = '0.10.0'.freeze
 end
 

data/lib/hutch/worker.rb

@@ -81,17 +81,17 @@ module Hutch
       broker = @broker
       begin
         message = Message.new(delivery_info, properties, payload)
-        consumer.new.process(message)
+        consumer.new.tap { |c| c.broker, c.delivery_info = @broker, delivery_info }.process(message)
         broker.ack(delivery_info.delivery_tag)
       rescue StandardError => ex
-        handle_error(properties.message_id, consumer, ex)
         broker.nack(delivery_info.delivery_tag)
+        handle_error(properties.message_id, payload, consumer, ex)
       end
     end
 
-    def handle_error(message_id, consumer, ex)
+    def handle_error(message_id, payload, consumer, ex)
       Hutch::Config[:error_handlers].each do |backend|
-        backend.handle(message_id, consumer, ex)
+        backend.handle(message_id, payload, consumer, ex)
       end
     end
 

data/spec/hutch/broker_spec.rb

@@ -6,37 +6,48 @@ describe Hutch::Broker do
   subject(:broker) { Hutch::Broker.new(config) }
 
   describe '#connect' do
-    before { broker.stub(:set_up_amqp_connection) }
-    before { broker.stub(:set_up_api_connection) }
-    before { broker.stub(:disconnect) }
+    before { allow(broker).to receive(:set_up_amqp_connection) }
+    before { allow(broker).to receive(:set_up_api_connection) }
+    before { allow(broker).to receive(:disconnect) }
 
     it 'sets up the amqp connection' do
-      broker.should_receive(:set_up_amqp_connection)
+      expect(broker).to receive(:set_up_amqp_connection)
       broker.connect
     end
 
     it 'sets up the api connection' do
-      broker.should_receive(:set_up_api_connection)
+      expect(broker).to receive(:set_up_api_connection)
       broker.connect
     end
 
     it 'does not disconnect' do
-      broker.should_not_receive(:disconnect)
+      expect(broker).not_to receive(:disconnect)
       broker.connect
     end
 
     context 'when given a block' do
       it 'disconnects' do
-        broker.should_receive(:disconnect).once
+        expect(broker).to receive(:disconnect).once
         broker.connect { }
       end
     end
 
+    context 'when given a block that fails' do
+      let(:exception) { Class.new(StandardError) }
+
+      it 'disconnects' do
+        expect(broker).to receive(:disconnect).once
+        expect do
+          broker.connect { fail exception }
+        end.to raise_error(exception)
+      end
+    end
+
     context "with options" do
       let(:options) { { enable_http_api_use: false } }
 
       it "doesnt set up api" do
-        broker.should_not_receive(:set_up_api_connection)
+        expect(broker).not_to receive(:set_up_api_connection)
         broker.connect options
       end
     end
@@ -47,16 +58,27 @@ describe Hutch::Broker do
       before { broker.set_up_amqp_connection }
       after  { broker.disconnect }
 
-      its(:connection) { should be_a Bunny::Session }
-      its(:channel)    { should be_a Bunny::Channel }
-      its(:exchange)   { should be_a Bunny::Exchange }
+      describe '#connection' do
+        subject { super().connection }
+        it { is_expected.to be_a Bunny::Session }
+      end
+
+      describe '#channel' do
+        subject { super().channel }
+        it { is_expected.to be_a Bunny::Channel }
+      end
+
+      describe '#exchange' do
+        subject { super().exchange }
+        it { is_expected.to be_a Bunny::Exchange }
+      end
     end
 
     context 'when given invalid details' do
       before { config[:mq_host] = 'notarealhost' }
       let(:set_up_amqp_connection) { ->{ broker.set_up_amqp_connection } }
 
-      specify { set_up_amqp_connection.should raise_error }
+      specify { expect(set_up_amqp_connection).to raise_error }
     end
 
     context 'with channel_prefetch set' do
@@ -65,7 +87,8 @@ describe Hutch::Broker do
       after  { broker.disconnect }
 
       it "set's channel's prefetch" do
-        Bunny::Channel.any_instance.should_receive(:prefetch).with(prefetch_value)
+        expect_any_instance_of(Bunny::Channel).
+          to receive(:prefetch).with(prefetch_value)
         broker.set_up_amqp_connection
       end
     end
@@ -76,7 +99,10 @@ describe Hutch::Broker do
       before { broker.set_up_api_connection }
       after  { broker.disconnect }
 
-      its(:api_client) { should be_a CarrotTop }
+      describe '#api_client' do
+        subject { super().api_client }
+        it { is_expected.to be_a CarrotTop }
+      end
     end
 
     context 'when given invalid details' do
@@ -84,17 +110,19 @@ describe Hutch::Broker do
       after  { broker.disconnect }
       let(:set_up_api_connection) { ->{ broker.set_up_api_connection } }
 
-      specify { set_up_api_connection.should raise_error }
+      specify { expect(set_up_api_connection).to raise_error }
     end
   end
 
   describe '#queue' do
     let(:channel) { double('Channel') }
-    before { broker.stub(:channel) { channel } }
+    before { allow(broker).to receive(:channel) { channel } }
 
     it 'applies a global namespace' do
       config[:namespace] = 'mirror-all.service'
-      broker.channel.should_receive(:queue).with { |*args| args.first == 'mirror-all.service:test' }
+      expect(broker.channel).to receive(:queue) do |*args|
+        args.first == 'mirror-all.service:test'
+      end
       broker.queue('test')
     end
   end
@@ -104,7 +132,10 @@ describe Hutch::Broker do
     subject { broker.bindings }
 
     context 'with no bindings' do
-      its(:keys) { should_not include 'test' }
+      describe '#keys' do
+        subject { super().keys }
+        it { is_expected.not_to include 'test' }
+      end
     end
 
     context 'with a binding' do
@@ -114,7 +145,7 @@ describe Hutch::Broker do
         queue.unbind(broker.exchange, routing_key: 'key').delete
       end
 
-      it { should include({ 'test' => ['key'] }) }
+      it { is_expected.to include({ 'test' => ['key'] }) }
     end
   end
 
@@ -124,17 +155,17 @@ describe Hutch::Broker do
 
     let(:routing_keys) { %w( a b c ) }
     let(:queue) { double('Queue', bind: nil, unbind: nil, name: 'consumer') }
-    before { broker.stub(bindings: { 'consumer' => ['d'] }) }
+    before { allow(broker).to receive(:bindings).and_return('consumer' => ['d']) }
 
     it 'calls bind for each routing key' do
       routing_keys.each do |key|
-        queue.should_receive(:bind).with(broker.exchange, routing_key: key)
+        expect(queue).to receive(:bind).with(broker.exchange, routing_key: key)
       end
       broker.bind_queue(queue, routing_keys)
     end
 
     it 'calls unbind for each redundant existing binding' do
-      queue.should_receive(:unbind).with(broker.exchange, routing_key: 'd')
+      expect(queue).to receive(:unbind).with(broker.exchange, routing_key: 'd')
       broker.bind_queue(queue, routing_keys)
     end
 
@@ -142,29 +173,29 @@ describe Hutch::Broker do
       let(:queue) { broker.queue('consumer') }
       let(:routing_key) { 'key' }
 
-      before { broker.unstub(:bindings) }
+      before { allow(broker).to receive(:bindings).and_call_original }
       before { queue.bind(broker.exchange, routing_key: 'redundant-key') }
       after { queue.unbind(broker.exchange, routing_key: routing_key).delete }
 
       it 'results in the correct bindings' do
         broker.bind_queue(queue, [routing_key])
-        broker.bindings.should include({ queue.name => [routing_key] })
+        expect(broker.bindings).to include({ queue.name => [routing_key] })
       end
     end
   end
 
   describe '#wait_on_threads' do
     let(:thread) { double('Thread') }
-    before { broker.stub(work_pool_threads: threads) }
+    before { allow(broker).to receive(:work_pool_threads).and_return(threads) }
 
     context 'when all threads finish within the timeout' do
       let(:threads) { [double(join: thread), double(join: thread)] }
-      specify { expect(broker.wait_on_threads(1)).to be_true }
+      specify { expect(broker.wait_on_threads(1)).to be_truthy }
     end
 
     context 'when timeout expires for one thread' do
       let(:threads) { [double(join: thread), double(join: nil)] }
-      specify { expect(broker.wait_on_threads(1)).to be_false }
+      specify { expect(broker.wait_on_threads(1)).to be_falsey }
     end
   end
 
@@ -174,12 +205,12 @@ describe Hutch::Broker do
       after  { broker.disconnect }
 
       it 'publishes to the exchange' do
-        broker.exchange.should_receive(:publish).once
+        expect(broker.exchange).to receive(:publish).once
         broker.publish('test.key', 'message')
       end
 
       it 'sets default properties' do
-        broker.exchange.should_receive(:publish).with(
+        expect(broker.exchange).to receive(:publish).with(
           JSON.dump("message"),
           hash_including(
             persistent: true,
@@ -192,29 +223,31 @@ describe Hutch::Broker do
       end
 
       it 'allows passing message properties' do
-        broker.exchange.should_receive(:publish).once
+        expect(broker.exchange).to receive(:publish).once
         broker.publish('test.key', 'message', {expiration: "2000", persistent: false})
       end
 
       context 'when there are global properties' do
         context 'as a hash' do
           before do
-            Hutch.stub global_properties: { app_id: 'app' }
+            allow(Hutch).to receive(:global_properties).and_return(app_id: 'app')
           end
 
           it 'merges the properties' do
-            broker.exchange.should_receive(:publish).with('"message"', hash_including(app_id: 'app'))
+            expect(broker.exchange).
+              to receive(:publish).with('"message"', hash_including(app_id: 'app'))
             broker.publish('test.key', 'message')
           end
         end
 
         context 'as a callable object' do
           before do
-            Hutch.stub global_properties: proc { { app_id: 'app' } }
+            allow(Hutch).to receive(:global_properties).and_return(proc { { app_id: 'app' } })
           end
 
           it 'calls the proc and merges the properties' do
-            broker.exchange.should_receive(:publish).with('"message"', hash_including(app_id: 'app'))
+            expect(broker.exchange).
+              to receive(:publish).with('"message"', hash_including(app_id: 'app'))
             broker.publish('test.key', 'message')
           end
         end
@@ -228,7 +261,7 @@ describe Hutch::Broker do
       end
 
       it 'logs an error' do
-        broker.logger.should_receive(:error)
+        expect(broker.logger).to receive(:error)
         broker.publish('test.key', 'message') rescue nil
       end
     end

data/spec/hutch/cli_spec.rb

@@ -8,7 +8,7 @@ describe Hutch::CLI do
     context "--config" do
       context "when the config file does not exist" do
         let(:file) { "/path/to/nonexistant/file" }
-        before { STDERR.stub(:write) }
+        before { allow(STDERR).to receive(:write) }
 
         it "bails" do
           expect {
@@ -23,7 +23,7 @@ describe Hutch::CLI do
         end
 
         it "parses the config" do
-          Hutch::Config.should_receive(:load_from_file)
+          expect(Hutch::Config).to receive(:load_from_file)
           cli.parse_options(["--config=#{file}"])
         end
       end
@@ -32,7 +32,7 @@ describe Hutch::CLI do
     context "--mq-tls-key" do
       context "when the keyfile file does not exist" do
         let(:file) { "/path/to/nonexistant/file" }
-        before { STDERR.stub(:write) }
+        before { allow(STDERR).to receive(:write) }
 
         it "bails" do
           expect {
@@ -47,7 +47,7 @@ describe Hutch::CLI do
         end
 
         it "sets mq_tls_key to the file" do
-          Hutch::Config.should_receive(:mq_tls_key=)
+          expect(Hutch::Config).to receive(:mq_tls_key=)
           cli.parse_options(["--mq-tls-key=#{file}"])
         end
       end
@@ -56,7 +56,7 @@ describe Hutch::CLI do
     context "--mq-tls-cert" do
       context "when the certfile file does not exist" do
         let(:file) { "/path/to/nonexistant/file" }
-        before { STDERR.stub(:write) }
+        before { allow(STDERR).to receive(:write) }
 
         it "bails" do
           expect {
@@ -71,7 +71,7 @@ describe Hutch::CLI do
         end
 
         it "sets mq_tls_cert to the file" do
-          Hutch::Config.should_receive(:mq_tls_cert=)
+          expect(Hutch::Config).to receive(:mq_tls_cert=)
           cli.parse_options(["--mq-tls-cert=#{file}"])
         end
       end

data/spec/hutch/config_spec.rb

@@ -9,18 +9,18 @@ describe Hutch::Config do
       subject { Hutch::Config.get(:mq_host) }
 
       context 'with no overridden value' do
-        it { should == 'localhost' }
+        it { is_expected.to eq('localhost') }
       end
 
       context 'with an overridden value' do
-        before  { Hutch::Config.stub(user_config: { mq_host: new_value }) }
-        it { should == new_value }
+        before  { allow(Hutch::Config).to receive_messages(user_config: { mq_host: new_value }) }
+        it { is_expected.to eq(new_value) }
       end
     end
 
     context 'for invalid attributes' do
       let(:invalid_get) { ->{ Hutch::Config.get(:invalid_attr) } }
-      specify { invalid_get.should raise_error Hutch::UnknownAttributeError }
+      specify { expect(invalid_get).to raise_error Hutch::UnknownAttributeError }
     end
   end
 
@@ -30,41 +30,41 @@ describe Hutch::Config do
       subject { Hutch::Config.user_config[:mq_host] }
 
       context 'sets value in user config hash' do
-        it { should == new_value }
+        it { is_expected.to eq(new_value) }
       end
     end
 
     context 'for invalid attributes' do
       let(:invalid_set) { ->{ Hutch::Config.set(:invalid_attr, new_value) } }
-      specify { invalid_set.should raise_error Hutch::UnknownAttributeError }
+      specify { expect(invalid_set).to raise_error Hutch::UnknownAttributeError }
     end
   end
 
   describe 'a magic getter' do
     context 'for a valid attribute' do
       it 'calls get' do
-        Hutch::Config.should_receive(:get).with(:mq_host)
+        expect(Hutch::Config).to receive(:get).with(:mq_host)
         Hutch::Config.mq_host
       end
     end
 
     context 'for an invalid attribute' do
       let(:invalid_getter) { ->{ Hutch::Config.invalid_attr } }
-      specify { invalid_getter.should raise_error NoMethodError }
+      specify { expect(invalid_getter).to raise_error NoMethodError }
     end
   end
 
   describe 'a magic setter' do
     context 'for a valid attribute' do
       it 'calls set' do
-        Hutch::Config.should_receive(:set).with(:mq_host, new_value)
+        expect(Hutch::Config).to receive(:set).with(:mq_host, new_value)
         Hutch::Config.mq_host = new_value
       end
     end
 
     context 'for an invalid attribute' do
       let(:invalid_setter) { ->{ Hutch::Config.invalid_attr = new_value } }
-      specify { invalid_setter.should raise_error NoMethodError }
+      specify { expect(invalid_setter).to raise_error NoMethodError }
     end
   end
 
@@ -92,8 +92,8 @@ describe Hutch::Config do
 
       it 'loads in the config data' do
         Hutch::Config.load_from_file(file)
-        Hutch::Config.mq_host.should eq host
-        Hutch::Config.mq_username.should eq username
+        expect(Hutch::Config.mq_host).to eq host
+        expect(Hutch::Config.mq_username).to eq username
       end
     end
   end

data/spec/hutch/consumer_spec.rb

@@ -29,8 +29,8 @@ describe Hutch::Consumer do
 
   describe 'module inclusion' do
     it 'registers the class as a consumer' do
-      Hutch.should_receive(:register_consumer) do |klass|
-        klass.should == simple_consumer
+      expect(Hutch).to receive(:register_consumer) do |klass|
+        expect(klass).to eq(simple_consumer)
       end
 
       simple_consumer
@@ -40,20 +40,24 @@ describe Hutch::Consumer do
 
   describe '.consume' do
     it 'saves the routing key to the consumer' do
-      simple_consumer.routing_keys.should include 'hutch.test1'
+      expect(simple_consumer.routing_keys).to include 'hutch.test1'
     end
 
     context 'with multiple routing keys' do
       it 'registers the class once for each routing key' do
-        complex_consumer.routing_keys.should include 'hutch.test1'
-        complex_consumer.routing_keys.should include 'hutch.test2'
+        expect(complex_consumer.routing_keys).to include 'hutch.test1'
+        expect(complex_consumer.routing_keys).to include 'hutch.test2'
       end
     end
 
     context 'when given the same routing key multiple times' do
       subject { simple_consumer.routing_keys }
       before { simple_consumer.consume 'hutch.test1' }
-      its(:length) { should == 1}
+
+      describe '#length' do
+        subject { super().length }
+        it { is_expected.to eq(1)}
+      end
     end
   end
 
@@ -72,7 +76,7 @@ describe Hutch::Consumer do
           queue_name "bar"
         end
 
-        Foo.get_queue_name.should == "bar"
+        expect(Foo.get_queue_name).to eq("bar")
       end
     end
 
@@ -84,7 +88,7 @@ describe Hutch::Consumer do
           end
         end
 
-        Foo::Bar.get_queue_name.should == 'foo:bar'
+        expect(Foo::Bar.get_queue_name).to eq('foo:bar')
       end
 
       it 'converts camelcase class names to snake case' do
@@ -92,7 +96,7 @@ describe Hutch::Consumer do
           include Hutch::Consumer
         end
 
-        FooBarBAZ.get_queue_name.should == 'foo_bar_baz'
+        expect(FooBarBAZ.get_queue_name).to eq('foo_bar_baz')
       end
     end
   end

data/spec/hutch/error_handlers/logger_spec.rb

@@ -4,12 +4,12 @@ describe Hutch::ErrorHandlers::Logger do
   let(:error_handler) { Hutch::ErrorHandlers::Logger.new }
 
   describe '#handle' do
-    let(:error) { stub(message: "Stuff went wrong", class: "RuntimeError",
+    let(:error) { double(message: "Stuff went wrong", class: "RuntimeError",
                        backtrace: ["line 1", "line 2"]) }
 
     it "logs three separate lines" do
-      Hutch::Logging.logger.should_receive(:error).exactly(3).times
-      error_handler.handle("1", stub, error)
+      expect(Hutch::Logging.logger).to receive(:error).exactly(3).times
+      error_handler.handle("1", "{}", double, error)
     end
   end
 end

data/spec/hutch/error_handlers/sentry_spec.rb

@@ -13,8 +13,8 @@ describe Hutch::ErrorHandlers::Sentry do
     end
 
     it "logs the error to Sentry" do
-      Raven.should_receive(:capture_exception).with(error)
-      error_handler.handle("1", stub, error)
+      expect(Raven).to receive(:capture_exception).with(error)
+      error_handler.handle("1", "{}", double, error)
     end
   end
 end

data/spec/hutch/logger_spec.rb

@@ -11,16 +11,16 @@ describe Hutch::Logging do
     context 'with the default logger' do
       subject { Hutch::Logging.logger }
 
-      it { should be_instance_of(Logger) }
+      it { is_expected.to be_instance_of(Logger) }
     end
 
     context 'with a custom logger' do
-      let(:dummy_logger) { mock("Dummy logger", warn: true, info: true) }
+      let(:dummy_logger) { double("Dummy logger", warn: true, info: true) }
       after { Hutch::Logging.setup_logger }
 
       it "users the custom logger" do
         Hutch::Logging.logger = dummy_logger
-        Hutch::Logging.logger.should == dummy_logger
+        expect(Hutch::Logging.logger).to eq(dummy_logger)
       end
     end
   end

data/spec/hutch/message_spec.rb

@@ -7,17 +7,20 @@ describe Hutch::Message do
   let(:json_body) { MultiJson.dump(body) }
   subject(:message) { Hutch::Message.new(delivery_info, props, json_body) }
 
-  its(:body) { should == body }
+  describe '#body' do
+    subject { super().body }
+    it { is_expected.to eq(body) }
+  end
 
   describe '[]' do
     subject { message[:foo] }
-    it { should == 'bar' }
+    it { is_expected.to eq('bar') }
   end
 
   [:message_id, :timestamp].each do |method|
     describe method.to_s do
       it 'delegates to @properties' do
-        props.should_receive(method)
+        expect(props).to receive(method)
         message.send(method)
       end
     end
@@ -26,7 +29,7 @@ describe Hutch::Message do
   [:routing_key, :exchange].each do |method|
     describe method.to_s do
       it 'delegates to @delivery_info' do
-        delivery_info.should_receive(method)
+        expect(delivery_info).to receive(method)
         message.send(method)
       end
     end

data/spec/hutch/worker_spec.rb

@@ -2,7 +2,6 @@ require 'spec_helper'
 require 'hutch/worker'
 
 describe Hutch::Worker do
-  before { Raven.as_null_object }
   let(:consumer) { double('Consumer', routing_keys: %w( a b c ),
                           get_queue_name: 'consumer') }
   let(:consumers) { [consumer, double('Consumer')] }
@@ -12,7 +11,7 @@ describe Hutch::Worker do
   describe '#setup_queues' do
     it 'sets up queues for each of the consumers' do
       consumers.each do |consumer|
-        worker.should_receive(:setup_queue).with(consumer)
+        expect(worker).to receive(:setup_queue).with(consumer)
       end
       worker.setup_queues
     end
@@ -20,21 +19,21 @@ describe Hutch::Worker do
 
   describe '#setup_queue' do
     let(:queue) { double('Queue', bind: nil, subscribe: nil) }
-    before { worker.stub(consumer_queue: queue) }
-    before { broker.stub(queue: queue, bind_queue: nil) }
+    before { allow(worker).to receive_messages(consumer_queue: queue) }
+    before { allow(broker).to receive_messages(queue: queue, bind_queue: nil) }
 
     it 'creates a queue' do
-      broker.should_receive(:queue).with(consumer.get_queue_name).and_return(queue)
+      expect(broker).to receive(:queue).with(consumer.get_queue_name).and_return(queue)
       worker.setup_queue(consumer)
     end
 
     it 'binds the queue to each of the routing keys' do
-      broker.should_receive(:bind_queue).with(queue, %w( a b c ))
+      expect(broker).to receive(:bind_queue).with(queue, %w( a b c ))
       worker.setup_queue(consumer)
     end
 
     it 'sets up a subscription' do
-      queue.should_receive(:subscribe).with(ack: true)
+      expect(queue).to receive(:subscribe).with(ack: true)
       worker.setup_queue(consumer)
     end
   end
@@ -45,34 +44,36 @@ describe Hutch::Worker do
     let(:delivery_info) { double('Delivery Info', routing_key: '',
                                  delivery_tag: 'dt') }
     let(:properties) { double('Properties', message_id: nil) }
-    before { consumer.stub(new: consumer_instance) }
-    before { broker.stub(:ack) }
-    before { broker.stub(:nack) }
+    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=) }
 
     it 'passes the message to the consumer' do
-      consumer_instance.should_receive(:process).
+      expect(consumer_instance).to receive(:process).
                         with(an_instance_of(Hutch::Message))
       worker.handle_message(consumer, delivery_info, properties, payload)
     end
 
     it 'acknowledges the message' do
-      consumer_instance.stub(:process)
-      broker.should_receive(:ack).with(delivery_info.delivery_tag)
+      allow(consumer_instance).to receive(:process)
+      expect(broker).to receive(:ack).with(delivery_info.delivery_tag)
       worker.handle_message(consumer, delivery_info, properties, payload)
     end
 
     context 'when the consumer raises an exception' do
-      before { consumer_instance.stub(:process).and_raise('a consumer error') }
+      before { allow(consumer_instance).to receive(:process).and_raise('a consumer error') }
 
       it 'logs the error' do
         Hutch::Config[:error_handlers].each do |backend|
-          backend.should_receive(:handle)
+          expect(backend).to receive(:handle)
         end
         worker.handle_message(consumer, delivery_info, properties, payload)
       end
 
       it 'rejects the message' do
-        broker.should_receive(:nack).with(delivery_info.delivery_tag)
+        expect(broker).to receive(:nack).with(delivery_info.delivery_tag)
         worker.handle_message(consumer, delivery_info, properties, payload)
       end
     end
@@ -82,13 +83,13 @@ describe Hutch::Worker do
 
       it 'logs the error' do
         Hutch::Config[:error_handlers].each do |backend|
-          backend.should_receive(:handle)
+          expect(backend).to receive(:handle)
         end
         worker.handle_message(consumer, delivery_info, properties, payload)
       end
 
       it 'rejects the message' do
-        broker.should_receive(:nack).with(delivery_info.delivery_tag)
+        expect(broker).to receive(:nack).with(delivery_info.delivery_tag)
         worker.handle_message(consumer, delivery_info, properties, payload)
       end
     end

data/spec/hutch_spec.rb

@@ -8,8 +8,8 @@ describe Hutch do
     it 'saves the consumers in the global consumer list' do
       Hutch.register_consumer(consumer_a)
       Hutch.register_consumer(consumer_b)
-      Hutch.consumers.should include consumer_a
-      Hutch.consumers.should include consumer_b
+      expect(Hutch.consumers).to include consumer_a
+      expect(Hutch.consumers).to include consumer_b
     end
   end
 
@@ -21,8 +21,8 @@ describe Hutch do
       let(:action)  { Hutch.connect(options, config) }
 
       it 'passes options and config' do
-        Hutch::Broker.should_receive(:new).with(config).and_return broker
-        broker.should_receive(:connect).with options
+        expect(Hutch::Broker).to receive(:new).with(config).and_return broker
+        expect(broker).to receive(:connect).with options
 
         action
       end
@@ -30,15 +30,15 @@ describe Hutch do
       it 'sets @connect' do
         action
 
-        expect(Hutch.connected?).to be_true
+        expect(Hutch.connected?).to be_truthy
       end
     end
 
     context 'connected' do
-      before { Hutch.stub(:connected?).and_return true }
+      before { allow(Hutch).to receive(:connected?).and_return true }
 
       it 'does not reconnect' do
-        Hutch::Broker.should_not_receive :new
+        expect(Hutch::Broker).not_to receive :new
         Hutch.connect
       end
     end
@@ -48,12 +48,10 @@ describe Hutch do
     let(:broker) { double(Hutch::Broker) }
     let(:args) { ['test.key', 'message', { headers: { foo: 'bar' } }] }
 
-    before do
-      Hutch.stub broker: broker
-    end
+    before { allow(Hutch).to receive(:broker).and_return(broker) }
 
     it 'delegates to Hutch::Broker#publish' do
-      broker.should_receive(:publish).with(*args)
+      expect(broker).to receive(:publish).with(*args)
       Hutch.publish(*args)
     end
   end

data/spec/spec_helper.rb

@@ -15,6 +15,7 @@ require 'logger'
 
 RSpec.configure do |config|
   config.before(:all) { Hutch::Config.log_level = Logger::FATAL }
+  config.raise_errors_for_deprecations!
 end
 
 # Constants (classes, etc) defined within a block passed to this method

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: hutch
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Harry Marr
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-13 00:00:00.000000000 Z
+date: 2014-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: 1.2.1
+        version: 1.5.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: 1.2.1
+        version: 1.5.1
 - !ruby/object:Gem::Dependency
   name: carrot-top
   requirement: !ruby/object:Gem::Requirement
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.12.0
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.12.0
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement