hutch 0.1.0

data/spec/hutch/broker_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+require 'hutch/broker'
+
+describe Hutch::Broker do
+  let(:config) { deep_copy(Hutch::Config.user_config) }
+  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) }
+
+    it 'sets up the amqp connection' do
+      broker.should_receive(:set_up_amqp_connection)
+      broker.connect
+    end
+
+    it 'sets up the api connection' do
+      broker.should_receive(:set_up_api_connection)
+      broker.connect
+    end
+
+    it 'does not disconnect' do
+      broker.should_not_receive(:disconnect)
+      broker.connect
+    end
+
+    context 'when given a block' do
+      it 'disconnects' do
+        broker.should_receive(:disconnect).once
+        broker.connect { }
+      end
+    end
+  end
+
+  describe '#set_up_amqp_connection', rabbitmq: true do
+    context 'with valid details' 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 }
+    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 }
+    end
+  end
+
+  describe '#set_up_api_connection', rabbitmq: true do
+    context 'with valid details' do
+      before { broker.set_up_api_connection }
+      after  { broker.disconnect }
+
+      its(:api_client) { should be_a CarrotTop }
+    end
+
+    context 'when given invalid details' do
+      before { config[:mq_api_host] = 'notarealhost' }
+      after  { broker.disconnect }
+      let(:set_up_api_connection) { ->{ broker.set_up_api_connection } }
+
+      specify { set_up_api_connection.should raise_error }
+    end
+  end
+
+  describe '#bindings', rabbitmq: true do
+    around { |example| broker.connect { example.run } }
+    subject { broker.bindings }
+
+    context 'with no bindings' do
+      its(:keys) { should_not include 'test' }
+    end
+
+    context 'with a binding' do
+      around do |example|
+        queue = broker.queue('test').bind(broker.exchange, routing_key: 'key')
+        example.run
+        queue.unbind(broker.exchange, routing_key: 'key').delete
+      end
+
+      it { should include({ 'test' => ['key'] }) }
+    end
+  end
+
+  describe '#bind_queue' do
+    around { |example| broker.connect { example.run } }
+    let(:routing_keys) { %w( a b c ) }
+    let(:queue) { double('Queue', bind: nil, unbind: nil, name: 'consumer') }
+    before { broker.stub(bindings: { '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)
+      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')
+      broker.bind_queue(queue, routing_keys)
+    end
+
+    context '(rabbitmq integration test)', rabbitmq: true do
+      let(:queue) { broker.queue('consumer') }
+      let(:routing_key) { 'key' }
+
+      before { broker.unstub(:bindings) }
+      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] })
+      end
+    end
+  end
+
+  describe '#wait_on_threads' do
+    let(:thread) { double('Thread') }
+    before { broker.stub(work_pool_threads: 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 }
+    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 }
+    end
+  end
+
+  describe '#publish' do
+    context 'with a valid connection' do
+      before { broker.set_up_amqp_connection }
+      after  { broker.disconnect }
+
+      it 'publishes to the exchange' do
+        broker.exchange.should_receive(:publish).once
+        broker.publish('test.key', 'message')
+      end
+    end
+
+    context 'without a valid connection' do
+      it 'logs an error' do
+        broker.logger.should_receive(:error)
+        broker.publish('test.key', 'message')
+      end
+    end
+  end
+end
+

data/spec/hutch/config_spec.rb

@@ -0,0 +1,69 @@
+require 'hutch/config'
+
+describe Hutch::Config do
+  let(:new_value) { 'not-localhost' }
+
+  describe '.get' do
+    context 'for valid attributes' do
+      subject { Hutch::Config.get(:mq_host) }
+
+      context 'with no overridden value' do
+        it { should == 'localhost' }
+      end
+
+      context 'with an overridden value' do
+        before  { Hutch::Config.stub(user_config: { mq_host: new_value }) }
+        it { should == 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 }
+    end
+  end
+
+  describe '.set' do
+    context 'for valid attributes' do
+      before  { Hutch::Config.set(:mq_host, new_value) }
+      subject { Hutch::Config.user_config[:mq_host] }
+
+      context 'sets value in user config hash' do
+        it { should == 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 }
+    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)
+        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 }
+    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)
+        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 }
+    end
+  end
+end

data/spec/hutch/consumer_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe Hutch::Consumer do
+  around(:each) do |example|
+    isolate_constants do
+      example.run
+    end
+  end
+
+  let(:simple_consumer) do
+    unless defined? SimpleConsumer
+      class SimpleConsumer
+        include Hutch::Consumer
+        consume 'hutch.test1'
+      end
+    end
+    SimpleConsumer
+  end
+
+  let(:complex_consumer) do
+    unless defined? ComplexConsumer
+      class ComplexConsumer
+        include Hutch::Consumer
+        consume 'hutch.test1', 'hutch.test2'
+      end
+    end
+    ComplexConsumer
+  end
+
+  describe 'module inclusion' do
+    it 'registers the class as a consumer' do
+      Hutch.should_receive(:register_consumer) do |klass|
+        klass.should == simple_consumer
+      end
+
+      simple_consumer
+    end
+  end
+
+
+  describe '.consume' do
+    it 'saves the routing key to the consumer' do
+      simple_consumer.routing_keys.should 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'
+      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}
+    end
+  end
+
+  describe '.queue_name' do
+    it 'replaces module separators with colons' do
+      module Foo
+        class Bar
+          include Hutch::Consumer
+        end
+      end
+
+      Foo::Bar.queue_name.should == 'foo:bar'
+    end
+
+    it 'converts camelcase class names to snake case' do
+      class FooBarBAZ
+        include Hutch::Consumer
+      end
+
+      FooBarBAZ.queue_name.should == 'foo_bar_baz'
+    end
+  end
+end
+

data/spec/hutch/error_handlers/logger_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Hutch::ErrorHandlers::Logger do
+  let(:error_handler) { Hutch::ErrorHandlers::Logger.new }
+
+  describe '#handle' do
+    let(:error) { stub(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)
+    end
+  end
+end

data/spec/hutch/error_handlers/sentry_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Hutch::ErrorHandlers::Sentry do
+  let(:error_handler) { Hutch::ErrorHandlers::Sentry.new }
+
+  describe '#handle' do
+    let(:error) do
+      begin
+        raise "Stuff went wrong"
+      rescue RuntimeError => err
+        err
+      end
+    end
+
+    it "logs the error to Sentry" do
+      Raven.should_receive(:capture_exception).with(error)
+      error_handler.handle("1", stub, error)
+    end
+  end
+end

data/spec/hutch/logger_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Hutch::Logging do
+  let(:dummy_object) do
+    class DummyObject
+      include Hutch::Logging
+    end
+  end
+
+  describe '#logger' do
+    context 'with the default logger' do
+      subject { Hutch::Logging.logger }
+
+      it { should be_instance_of(Logger) }
+    end
+
+    context 'with a custom logger' do
+      let(:dummy_logger) { mock("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
+      end
+    end
+  end
+end
+

data/spec/hutch/message_spec.rb

@@ -0,0 +1,35 @@
+require 'hutch/message'
+
+describe Hutch::Message do
+  let(:delivery_info) { double('Delivery Info') }
+  let(:props) { double('Properties') }
+  let(:body) {{ foo: 'bar' }}
+  let(:json_body) { MultiJson.dump(body) }
+  subject(:message) { Hutch::Message.new(delivery_info, props, json_body) }
+
+  its(:body) { should == body }
+
+  describe '[]' do
+    subject { message[:foo] }
+    it { should == 'bar' }
+  end
+
+  [:message_id, :timestamp].each do |method|
+    describe method.to_s do
+      it 'delegates to @properties' do
+        props.should_receive(method)
+        message.send(method)
+      end
+    end
+  end
+
+  [:routing_key, :exchange].each do |method|
+    describe method.to_s do
+      it 'delegates to @delivery_info' do
+        delivery_info.should_receive(method)
+        message.send(method)
+      end
+    end
+  end
+end
+

data/spec/hutch/worker_spec.rb

@@ -0,0 +1,80 @@
+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 ),
+                          queue_name: 'consumer') }
+  let(:consumers) { [consumer, double('Consumer')] }
+  let(:broker) { Hutch::Broker.new }
+  subject(:worker) { Hutch::Worker.new(broker, consumers) }
+
+  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)
+      end
+      worker.setup_queues
+    end
+  end
+
+  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) }
+
+    it 'creates a queue' do
+      broker.should_receive(:queue).with(consumer.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 ))
+      worker.setup_queue(consumer)
+    end
+
+    it 'sets up a subscription' do
+      queue.should_receive(:subscribe).with(ack: true)
+      worker.setup_queue(consumer)
+    end
+  end
+
+  describe '#handle_message' do
+    let(:payload) { '{}' }
+    let(:consumer_instance) { double('Consumer instance') }
+    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) }
+
+    it 'passes the message to the consumer' do
+      consumer_instance.should_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)
+      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') }
+
+      it 'logs the error' do
+        Hutch::Config[:error_handlers].each do |backend|
+          backend.should_receive(:handle)
+        end
+        worker.handle_message(consumer, delivery_info, properties, payload)
+      end
+
+      it 'acknowledges the message' do
+        broker.should_receive(:ack).with(delivery_info.delivery_tag)
+        worker.handle_message(consumer, delivery_info, properties, payload)
+      end
+    end
+  end
+end
+