dkastner-hutch 0.17.1

data/spec/hutch/broker_spec.rb

@@ -0,0 +1,325 @@
+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 { 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
+      expect(broker).to receive(:set_up_amqp_connection)
+      broker.connect
+    end
+
+    it 'sets up the api connection' do
+      expect(broker).to receive(:set_up_api_connection)
+      broker.connect
+    end
+
+    it 'does not disconnect' do
+      expect(broker).not_to receive(:disconnect)
+      broker.connect
+    end
+
+    context 'when given a block' do
+      it 'disconnects' do
+        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
+        expect(broker).not_to receive(:set_up_api_connection)
+        broker.connect options
+      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 }
+
+      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 { expect(set_up_amqp_connection).to raise_error }
+    end
+
+    context 'with channel_prefetch set' do
+      let(:prefetch_value) { 1 }
+      before { config[:channel_prefetch] = prefetch_value }
+      after  { broker.disconnect }
+
+      it "set's channel's prefetch" do
+        expect_any_instance_of(Bunny::Channel).
+          to receive(:prefetch).with(prefetch_value)
+        broker.set_up_amqp_connection
+      end
+    end
+
+    context 'with force_publisher_confirms set' do
+      let(:force_publisher_confirms_value) { true }
+      before { config[:force_publisher_confirms] = force_publisher_confirms_value }
+      after  { broker.disconnect }
+
+      it 'waits for confirmation' do
+        expect_any_instance_of(Bunny::Channel).
+          to receive(:confirm_select)
+        broker.set_up_amqp_connection
+      end
+    end
+  end
+
+  describe '#set_up_api_connection', rabbitmq: true do
+    context 'with valid details' do
+      before { broker.set_up_api_connection }
+      after  { broker.disconnect }
+
+      describe '#api_client' do
+        subject { super().api_client }
+        it { is_expected.to be_a CarrotTop }
+      end
+    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 { expect(set_up_api_connection).to raise_error }
+    end
+  end
+
+  describe '#queue' do
+    let(:channel) { double('Channel') }
+    let(:arguments) { { foo: :bar } }
+    before { allow(broker).to receive(:channel) { channel } }
+
+    it 'applies a global namespace' do
+      config[:namespace] = 'mirror-all.service'
+      expect(broker.channel).to receive(:queue) do |*args|
+        args.first == ''
+        args.last == arguments
+      end
+      broker.queue('test', arguments)
+    end
+  end
+
+  describe '#bindings', rabbitmq: true do
+    around { |example| broker.connect { example.run } }
+    subject { broker.bindings }
+
+    context 'with no bindings' do
+      describe '#keys' do
+        subject { super().keys }
+        it { is_expected.not_to include 'test' }
+      end
+    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 { is_expected.to 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 { allow(broker).to receive(:bindings).and_return('consumer' => ['d']) }
+
+    it 'calls bind for each routing key' do
+      routing_keys.each do |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
+      expect(queue).to 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 { 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])
+        expect(broker.bindings).to include({ queue.name => [routing_key] })
+      end
+    end
+  end
+
+  describe '#wait_on_threads' do
+    let(:thread) { double('Thread') }
+    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_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_falsey }
+    end
+  end
+
+  describe '#stop' do
+    let(:thread_1) { double('Thread') }
+    let(:thread_2) { double('Thread') }
+    let(:work_pool) { double('Bunny::ConsumerWorkPool') }
+    let(:config) { { graceful_exit_timeout: 2 } }
+
+    before do
+      allow(broker).to receive(:channel_work_pool).and_return(work_pool)
+    end
+
+    it 'gracefully stops the work pool' do
+      expect(work_pool).to receive(:shutdown)
+      expect(work_pool).to receive(:join).with(2)
+      expect(work_pool).to receive(:kill)
+
+      broker.stop
+    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
+        expect(broker.exchange).to receive(:publish).once
+        broker.publish('test.key', 'message')
+      end
+
+      it 'sets default properties' do
+        expect(broker.exchange).to receive(:publish).with(
+          JSON.dump("message"),
+          hash_including(
+            persistent: true,
+            routing_key: 'test.key',
+            content_type: 'application/json'
+          )
+        )
+
+        broker.publish('test.key', 'message')
+      end
+
+      it 'allows passing message properties' do
+        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
+            allow(Hutch).to receive(:global_properties).and_return(app_id: 'app')
+          end
+
+          it 'merges the properties' do
+            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
+            allow(Hutch).to receive(:global_properties).and_return(proc { { app_id: 'app' } })
+          end
+
+          it 'calls the proc and merges the properties' do
+            expect(broker.exchange).
+              to receive(:publish).with('"message"', hash_including(app_id: 'app'))
+            broker.publish('test.key', 'message')
+          end
+        end
+      end
+
+      context 'with force_publisher_confirms not set in the config' do
+        it 'does not wait for confirms on the channel' do
+          expect_any_instance_of(Bunny::Channel).
+            to_not receive(:wait_for_confirms)
+          broker.publish('test.key', 'message')
+        end
+      end
+
+      context 'with force_publisher_confirms set in the config' do
+        let(:force_publisher_confirms_value) { true }
+
+        before do
+          config[:force_publisher_confirms] = force_publisher_confirms_value
+        end
+
+        it 'waits for confirms on the channel' do
+          expect_any_instance_of(Bunny::Channel).
+            to receive(:wait_for_confirms)
+          broker.publish('test.key', 'message')
+        end
+      end
+    end
+
+    context 'without a valid connection' do
+      it 'raises an exception' do
+        expect { broker.publish('test.key', 'message') }.
+          to raise_exception(Hutch::PublishError)
+      end
+
+      it 'logs an error' do
+        expect(broker.logger).to receive(:error)
+        broker.publish('test.key', 'message') rescue nil
+      end
+    end
+  end
+end
+

data/spec/hutch/cli_spec.rb

@@ -0,0 +1,80 @@
+require 'hutch/cli'
+require 'tempfile'
+
+describe Hutch::CLI do
+  let(:cli) { Hutch::CLI.new }
+
+  describe "#parse_options" do
+    context "--config" do
+      context "when the config file does not exist" do
+        let(:file) { "/path/to/nonexistant/file" }
+        before { allow(STDERR).to receive(:write) }
+
+        it "bails" do
+          expect {
+            cli.parse_options(["--config=#{file}"])
+          }.to raise_error SystemExit
+        end
+      end
+
+      context "when the config file exists" do
+        let(:file) do
+          Tempfile.new("hutch-test-config.yaml").to_path
+        end
+
+        it "parses the config" do
+          expect(Hutch::Config).to receive(:load_from_file)
+          cli.parse_options(["--config=#{file}"])
+        end
+      end
+    end
+
+    context "--mq-tls-key" do
+      context "when the keyfile file does not exist" do
+        let(:file) { "/path/to/nonexistant/file" }
+        before { allow(STDERR).to receive(:write) }
+
+        it "bails" do
+          expect {
+            cli.parse_options(["--mq-tls-key=#{file}"])
+          }.to raise_error SystemExit
+        end
+      end
+
+      context "when the keyfile file exists" do
+        let(:file) do
+          Tempfile.new("hutch-test-key.pem").to_path
+        end
+
+        it "sets mq_tls_key to the file" do
+          expect(Hutch::Config).to receive(:mq_tls_key=)
+          cli.parse_options(["--mq-tls-key=#{file}"])
+        end
+      end
+    end
+
+    context "--mq-tls-cert" do
+      context "when the certfile file does not exist" do
+        let(:file) { "/path/to/nonexistant/file" }
+        before { allow(STDERR).to receive(:write) }
+
+        it "bails" do
+          expect {
+            cli.parse_options(["--mq-tls-cert=#{file}"])
+          }.to raise_error SystemExit
+        end
+      end
+
+      context "when the certfile file exists" do
+        let(:file) do
+          Tempfile.new("hutch-test-cert.pem").to_path
+        end
+
+        it "sets mq_tls_cert to the file" do
+          expect(Hutch::Config).to receive(:mq_tls_cert=)
+          cli.parse_options(["--mq-tls-cert=#{file}"])
+        end
+      end
+    end
+  end
+end

data/spec/hutch/config_spec.rb

@@ -0,0 +1,126 @@
+require 'hutch/config'
+require 'tempfile'
+
+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 { is_expected.to eq('localhost') }
+      end
+
+      context 'with an overridden value' do
+        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 { expect(invalid_get).to 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 { is_expected.to eq(new_value) }
+      end
+    end
+
+    context 'for invalid attributes' do
+      let(:invalid_set) { ->{ Hutch::Config.set(:invalid_attr, new_value) } }
+      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
+        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 { expect(invalid_getter).to raise_error NoMethodError }
+    end
+  end
+
+  describe 'a magic setter' do
+    context 'for a valid attribute' do
+      it 'calls set' do
+        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 { expect(invalid_setter).to raise_error NoMethodError }
+    end
+  end
+
+  describe '.load_from_file' do
+    let(:host) { 'broker.yourhost.com' }
+    let(:username) { 'calvin' }
+    let(:file) do
+      Tempfile.new('configs.yaml').tap do |t|
+        t.write(YAML.dump(config_data))
+        t.rewind
+      end
+    end
+
+    context 'when an attribute is invalid' do
+      let(:config_data) { { random_attribute: 'socks' } }
+      it 'raises an error' do
+        expect {
+          Hutch::Config.load_from_file(file)
+        }.to raise_error(NoMethodError)
+      end
+    end
+
+    context 'when attributes are valid' do
+      let(:config_data) { { mq_host: host, mq_username: username } }
+
+      it 'loads in the config data' do
+        Hutch::Config.load_from_file(file)
+        expect(Hutch::Config.mq_host).to eq host
+        expect(Hutch::Config.mq_username).to eq username
+      end
+    end
+  end
+
+  describe '.load_from_file' do
+    let(:host) { 'localhost' }
+    let(:username) { 'calvin' }
+    let(:file) do
+      Tempfile.new('configs.yaml').tap do |t|
+        t.write(config_contents)
+        t.rewind
+      end
+    end
+
+    context 'when using ERb' do
+      let(:config_contents) do
+        <<-YAML
+mq_host: 'localhost'
+mq_username: '<%= "calvin" %>'
+YAML
+      end
+
+      it 'loads in the config data' do
+        Hutch::Config.load_from_file(file)
+        expect(Hutch::Config.mq_host).to eq host
+        expect(Hutch::Config.mq_username).to eq username
+      end
+    end
+  end
+end

data/spec/hutch/consumer_spec.rb

@@ -0,0 +1,130 @@
+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'
+        arguments foo: :bar
+      end
+    end
+    ComplexConsumer
+  end
+
+  describe 'module inclusion' do
+    it 'registers the class as a consumer' do
+      expect(Hutch).to receive(:register_consumer) do |klass|
+        expect(klass).to eq(simple_consumer)
+      end
+
+      simple_consumer
+    end
+  end
+
+
+  describe '.consume' do
+    it 'saves the routing key to the consumer' do
+      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
+        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' }
+
+      describe '#length' do
+        subject { super().length }
+        it { is_expected.to eq(1)}
+      end
+    end
+  end
+
+  describe '.queue_name' do
+    let(:queue_name) { 'foo' }
+
+    it 'overrides the queue name' do
+      simple_consumer.queue_name(queue_name)
+      expect(simple_consumer.get_queue_name).to eq(queue_name)
+    end
+  end
+
+  describe '.arguments' do
+    let(:args) { { foo: :bar} }
+
+    it 'overrides the arguments' do
+      simple_consumer.arguments(args)
+      expect(simple_consumer.get_arguments).to eq(args)
+    end
+
+  end
+
+  describe '.get_arguments' do
+
+    context 'when defined' do
+      it { expect(complex_consumer.get_arguments).to eq(foo: :bar) }
+    end
+
+    context 'when not defined' do
+      it { expect(simple_consumer.get_arguments).to eq({}) }
+    end
+
+  end
+
+  describe '.get_queue_name' do
+
+    context 'when queue name has been set explicitly' do
+      it 'returns the give queue name' do
+        class Foo
+          include Hutch::Consumer
+          queue_name "bar"
+        end
+
+        expect(Foo.get_queue_name).to eq("bar")
+      end
+    end
+
+    context 'when no queue name has been set' do
+      it 'replaces module separators with colons' do
+        module Foo
+          class Bar
+            include Hutch::Consumer
+          end
+        end
+
+        expect(Foo::Bar.get_queue_name).to eq('foo:bar')
+      end
+
+      it 'converts camelcase class names to snake case' do
+        class FooBarBAZ
+          include Hutch::Consumer
+        end
+
+        expect(FooBarBAZ.get_queue_name).to eq('foo_bar_baz')
+      end
+    end
+  end
+end
+

data/spec/hutch/error_handlers/airbrake_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Hutch::ErrorHandlers::Airbrake do
+  let(:error_handler) { Hutch::ErrorHandlers::Airbrake.new }
+
+  describe '#handle' do
+    let(:error) do
+      begin
+        raise "Stuff went wrong"
+      rescue RuntimeError => err
+        err
+      end
+    end
+
+    it "logs the error to Airbrake" do
+      message_id = "1"
+      payload = "{}"
+      consumer = double
+      ex = error
+      message = {
+        :error_class => ex.class.name,
+        :error_message => "#{ ex.class.name }: #{ ex.message }",
+        :backtrace => ex.backtrace,
+        :parameters => {
+          :payload => payload,
+          :consumer => consumer,
+        },
+        :cgi_data => ENV.to_hash,
+      }
+      expect(::Airbrake).to receive(:notify_or_ignore).with(ex, message)
+      error_handler.handle(message_id, payload, consumer, ex)
+    end
+  end
+end