hutch 0.18.0 → 1.1.0

data/lib/yard-settings/handler.rb

@@ -0,0 +1,38 @@
+# :nodoc:
+class SettingsHandlerBase < YARD::Handlers::Ruby::Base
+  handles method_call :string_setting
+  handles method_call :number_setting
+  handles method_call :boolean_setting
+
+  namespace_only
+
+  def process
+    name = statement.parameters.first.jump(:tstring_content, :ident).source
+    object = YARD::CodeObjects::MethodObject.new(namespace, name)
+    register(object)
+
+    # Modify the code object for the new instance method
+    object.dynamic = true
+    # Add custom metadata to the object
+    object['custom_field'] = '(Found using method_missing)'
+
+    # Module-level configuration notes
+    hutch_config = YARD::CodeObjects::ModuleObject.new(:root, "Hutch::Config")
+    collection_name = statement.first.first
+    default_value = statement.parameters[1].jump(:tstring_content, :ident).source
+
+    (hutch_config['setting_rows'] ||= []) << {
+      name: name,
+      default_value: default_value,
+      type: collection_name.sub('_setting', '').capitalize,
+      description: object.docstring,
+      first_line_of_description: first_line_of_description(object)
+    }
+  end
+
+  def first_line_of_description(object)
+    return '' if object.docstring.blank?
+
+    object.docstring.lines.first
+  end
+end

data/lib/yard-settings/yard-settings.rb

@@ -0,0 +1,2 @@
+YARD::Templates::Engine.register_template_path(File.dirname(__FILE__) + '/../../templates')
+require File.join(File.dirname(__FILE__), 'handler') if RUBY19

data/spec/hutch/broker_spec.rb

@@ -2,8 +2,16 @@ require 'spec_helper'
 require 'hutch/broker'
 
 describe Hutch::Broker do
-  let(:config) { deep_copy(Hutch::Config.user_config) }
-  subject(:broker) { Hutch::Broker.new(config) }
+  before do
+    Hutch::Config.initialize(client_logger: Hutch::Logging.logger)
+    @config = Hutch::Config.to_hash
+  end
+  let!(:config) { @config }
+  after do
+    Hutch::Config.instance_variable_set(:@config, nil)
+    Hutch::Config.initialize
+  end
+  let(:broker) { Hutch::Broker.new(config) }
 
   describe '#connect' do
     before { allow(broker).to receive(:set_up_amqp_connection) }
@@ -53,93 +61,183 @@ describe Hutch::Broker do
     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 '#set_up_amqp_connection' do
+    it 'opens a connection, channel and declares an exchange' do
+      expect(broker).to receive(:open_connection!).ordered
+      expect(broker).to receive(:open_channel!).ordered
+      expect(broker).to receive(:declare_exchange!).ordered
 
-      describe '#connection', adapter: :bunny do
-        subject { super().connection }
-        it { is_expected.to be_a Hutch::Adapters::BunnyAdapter }
-      end
+      broker.set_up_amqp_connection
+    end
+  end
 
-      describe '#connection', adapter: :march_hare do
-        subject { super().connection }
-        it { is_expected.to be_a Hutch::Adapters::MarchHareAdapter }
-      end
+  describe '#open_connection', rabbitmq: true do
+    describe 'return value' do
+      subject { broker.open_connection }
+      after { subject.close }
 
-      describe '#channel', adapter: :bunny do
-        subject { super().channel }
-        it { is_expected.to be_a Bunny::Channel }
-      end
+      it(nil, adapter: :bunny)      { is_expected.to be_a Hutch::Adapters::BunnyAdapter }
+      it(nil, adapter: :march_hare) { is_expected.to be_a Hutch::Adapters::MarchHareAdapter }
+    end
 
-      describe '#channel', adapter: :march_hare do
-        subject { super().channel }
-        it { is_expected.to be_a MarchHare::Channel }
+    context 'when given invalid details' do
+      before { config[:mq_host] = 'notarealhost' }
+      it { expect { broker.open_connection }.to raise_error(StandardError) }
+    end
+
+    it 'does not set #connection' do
+      connection = broker.open_connection
+
+      expect(broker.connection).to be_nil
+
+      connection.close
+    end
+
+    context 'when configured with a URI' do
+      context 'which specifies the port' do
+        before { config[:uri] = 'amqp://guest:guest@127.0.0.1:5672/' }
+
+        it 'successfully connects' do
+          c = broker.open_connection
+          expect(c).to be_open
+          c.close
+        end
       end
 
-      describe '#exchange', adapter: :bunny do
-        subject { super().exchange }
-        it { is_expected.to be_a Bunny::Exchange }
+      context 'which does not specify port and uses the amqp scheme' do
+        before { config[:uri] = 'amqp://guest:guest@127.0.0.1/' }
+
+        it 'successfully connects' do
+          c = broker.open_connection
+          expect(c).to be_open
+          c.close
+        end
       end
 
-      describe '#exchange', adapter: :march_hare do
-        subject { super().exchange }
-        it { is_expected.to be_a MarchHare::Exchange }
+      context 'which specifies the amqps scheme' do
+        before { config[:uri] = 'amqps://guest:guest@127.0.0.1/' }
+
+        it 'utilises TLS' do
+          expect(Hutch::Adapter).to receive(:new).with(
+            hash_including(tls: true, port: 5671)
+          ).and_return(instance_double('Hutch::Adapter', start: nil))
+
+          broker.open_connection
+        end
       end
     end
+  end
 
-    context 'when given invalid details' do
-      before { config[:mq_host] = 'notarealhost' }
-      let(:set_up_amqp_connection) { ->{ broker.set_up_amqp_connection } }
+  describe '#open_connection!' do
+    it 'sets the #connection to #open_connection' do
+      connection = double('connection').as_null_object
+
+      expect(broker).to receive(:open_connection).and_return(connection)
+
+      broker.open_connection!
 
-      specify { expect(set_up_amqp_connection).to raise_error }
+      expect(broker.connection).to eq(connection)
+    end
+  end
+
+  describe '#open_channel', rabbitmq: true do
+    before { broker.open_connection! }
+    after { broker.disconnect }
+
+    describe 'return value' do
+      subject { broker.open_channel }
+
+      it(nil, adapter: :bunny)      { is_expected.to be_a Bunny::Channel }
+      it(nil, adapter: :march_hare) { is_expected.to be_a MarchHare::Channel }
+    end
+
+    it 'does not set #channel' do
+      broker.open_channel
+      expect(broker.channel).to be_nil
     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", adapter: :bunny do
-        expect_any_instance_of(Bunny::Channel).
-          to receive(:prefetch).with(prefetch_value)
-        broker.set_up_amqp_connection
+        expect_any_instance_of(Bunny::Channel).to receive(:prefetch).with(prefetch_value)
+        broker.open_channel
       end
 
       it "set's channel's prefetch", adapter: :march_hare do
-        expect_any_instance_of(MarchHare::Channel).
-          to receive(:prefetch=).with(prefetch_value)
-        broker.set_up_amqp_connection
+        expect_any_instance_of(MarchHare::Channel).to receive(:prefetch=).with(prefetch_value)
+        broker.open_channel
       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', adapter: :bunny do
-        expect_any_instance_of(Bunny::Channel).
-          to receive(:confirm_select)
-        broker.set_up_amqp_connection
+        expect_any_instance_of(Bunny::Channel).to receive(:confirm_select)
+        broker.open_channel
       end
 
       it 'waits for confirmation', adapter: :march_hare do
-        expect_any_instance_of(MarchHare::Channel).
-          to receive(:confirm_select)
-        broker.set_up_amqp_connection
+        expect_any_instance_of(MarchHare::Channel).to receive(:confirm_select)
+        broker.open_channel
       end
     end
   end
 
+  describe '#open_channel!' do
+    it 'sets the #channel to #open_channel' do
+      channel = double('channel').as_null_object
+
+      expect(broker).to receive(:open_channel).and_return(channel)
+
+      broker.open_channel!
+
+      expect(broker.channel).to eq(channel)
+    end
+  end
+
+  describe '#declare_exchange' do
+    before do
+      broker.open_connection!
+      broker.open_channel!
+    end
+    after { broker.disconnect }
+
+    describe 'return value' do
+      subject { broker.declare_exchange }
+
+      it(nil, adapter: :bunny)      { is_expected.to be_a Bunny::Exchange }
+      it(nil, adapter: :march_hare) { is_expected.to be_a MarchHare::Exchange }
+    end
+
+    it 'does not set #exchange' do
+      broker.declare_exchange
+      expect(broker.exchange).to be_nil
+    end
+  end
+
+  describe '#declare_exchange!' do
+    it 'sets the #exchange to #declare_exchange' do
+      exchange = double('exchange').as_null_object
+
+      expect(broker).to receive(:declare_exchange).and_return(exchange)
+
+      broker.declare_exchange!
+
+      expect(broker.exchange).to eq(exchange)
+    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 }
+        subject { broker.api_client }
         it { is_expected.to be_a CarrotTop }
       end
     end
@@ -149,7 +247,7 @@ describe Hutch::Broker do
       after  { broker.disconnect }
       let(:set_up_api_connection) { ->{ broker.set_up_api_connection } }
 
-      specify { expect(set_up_api_connection).to raise_error }
+      specify { expect(set_up_api_connection).to raise_error(StandardError) }
     end
   end
 
@@ -192,7 +290,7 @@ describe Hutch::Broker do
 
   describe '#bind_queue' do
 
-    around { |example| broker.connect { example.run } }
+    around { |example| broker.connect(host: "127.0.0.1") { example.run } }
 
     let(:routing_keys) { %w( a b c ) }
     let(:queue) { double('Queue', bind: nil, unbind: nil, name: 'consumer') }
@@ -225,21 +323,6 @@ describe Hutch::Broker do
     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', adapter: :bunny do
     let(:thread_1) { double('Thread') }
     let(:thread_2) { double('Thread') }
@@ -280,12 +363,12 @@ describe Hutch::Broker do
 
       it 'publishes to the exchange' do
         expect(broker.exchange).to receive(:publish).once
-        broker.publish('test.key', 'message')
+        broker.publish('test.key', {key: "value"})
       end
 
       it 'sets default properties' do
         expect(broker.exchange).to receive(:publish).with(
-          JSON.dump("message"),
+          JSON.dump({key: "value"}),
           hash_including(
             persistent: true,
             routing_key: 'test.key',
@@ -293,12 +376,12 @@ describe Hutch::Broker do
           )
         )
 
-        broker.publish('test.key', 'message')
+        broker.publish('test.key', {key: "value"})
       end
 
       it 'allows passing message properties' do
         expect(broker.exchange).to receive(:publish).once
-        broker.publish('test.key', 'message', {expiration: "2000", persistent: false})
+        broker.publish('test.key', {key: "value"}, {expiration: "2000", persistent: false})
       end
 
       context 'when there are global properties' do
@@ -309,8 +392,8 @@ describe Hutch::Broker do
 
           it 'merges the properties' do
             expect(broker.exchange).
-              to receive(:publish).with('"message"', hash_including(app_id: 'app'))
-            broker.publish('test.key', 'message')
+              to receive(:publish).with('{"key":"value"}', hash_including(app_id: 'app'))
+            broker.publish('test.key', {key: "value"})
           end
         end
 
@@ -321,8 +404,8 @@ describe Hutch::Broker do
 
           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')
+              to receive(:publish).with('{"key":"value"}', hash_including(app_id: 'app'))
+            broker.publish('test.key', {key: "value"})
           end
         end
       end
@@ -331,13 +414,13 @@ describe Hutch::Broker do
         it 'does not wait for confirms on the channel', adapter: :bunny do
           expect_any_instance_of(Bunny::Channel).
             to_not receive(:wait_for_confirms)
-          broker.publish('test.key', 'message')
+          broker.publish('test.key', {key: "value"})
         end
 
         it 'does not wait for confirms on the channel', adapter: :march_hare do
           expect_any_instance_of(MarchHare::Channel).
             to_not receive(:wait_for_confirms)
-          broker.publish('test.key', 'message')
+          broker.publish('test.key', {key: "value"})
         end
       end
 
@@ -351,26 +434,28 @@ describe Hutch::Broker do
         it 'waits for confirms on the channel', adapter: :bunny do
           expect_any_instance_of(Bunny::Channel).
             to receive(:wait_for_confirms)
-          broker.publish('test.key', 'message')
+          broker.publish('test.key', {key: "value"})
         end
 
         it 'waits for confirms on the channel', adapter: :march_hare do
           expect_any_instance_of(MarchHare::Channel).
             to receive(:wait_for_confirms)
-          broker.publish('test.key', 'message')
+          broker.publish('test.key', {key: "value"})
         end
       end
     end
 
     context 'without a valid connection' do
+      before { broker.set_up_amqp_connection; broker.disconnect }
+
       it 'raises an exception' do
-        expect { broker.publish('test.key', 'message') }.
+        expect { broker.publish('test.key', {key: "value"}) }.
           to raise_exception(Hutch::PublishError)
       end
 
       it 'logs an error' do
         expect(broker.logger).to receive(:error)
-        broker.publish('test.key', 'message') rescue nil
+        broker.publish('test.key', {key: "value"}) rescue nil
       end
     end
   end

data/spec/hutch/cli_spec.rb

@@ -4,6 +4,19 @@ require 'tempfile'
 describe Hutch::CLI do
   let(:cli) { Hutch::CLI.new }
 
+  describe "#start_work_loop" do
+    context "connection error during setup" do
+      let(:error) { Hutch::ConnectionError.new }
+      it "gets reported using error handlers" do
+        allow(Hutch).to receive(:connect).and_raise(error)
+        Hutch::Config[:error_handlers].each do |backend|
+          expect(backend).to receive(:handle_setup_exception).with(error)
+        end
+        cli.start_work_loop
+      end
+    end
+  end
+
   describe "#parse_options" do
     context "--config" do
       context "when the config file does not exist" do
@@ -13,7 +26,7 @@ describe Hutch::CLI do
         it "bails" do
           expect {
             cli.parse_options(["--config=#{file}"])
-          }.to raise_error SystemExit
+          }.to raise_error SystemExit, "Config file '/path/to/nonexistant/file' not found"
         end
       end
 
@@ -37,7 +50,7 @@ describe Hutch::CLI do
         it "bails" do
           expect {
             cli.parse_options(["--mq-tls-key=#{file}"])
-          }.to raise_error SystemExit
+          }.to raise_error SystemExit, "Private key file '/path/to/nonexistant/file' not found"
         end
       end
 
@@ -61,7 +74,7 @@ describe Hutch::CLI do
         it "bails" do
           expect {
             cli.parse_options(["--mq-tls-cert=#{file}"])
-          }.to raise_error SystemExit
+          }.to raise_error SystemExit, "Certificate file '/path/to/nonexistant/file' not found"
         end
       end
 

data/spec/hutch/config_spec.rb

@@ -4,23 +4,40 @@ require 'tempfile'
 describe Hutch::Config do
   let(:new_value) { 'not-localhost' }
 
+  before do
+    Hutch::Config.instance_variable_set(:@config, nil)
+    Hutch::Config.initialize
+  end
+
+  after do
+    Hutch::Config.instance_variable_set(:@config, nil)
+  end
+
   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') }
+        it { is_expected.to eq('127.0.0.1') }
       end
 
       context 'with an overridden value' do
-        before  { allow(Hutch::Config).to receive_messages(user_config: { mq_host: new_value }) }
+        before do
+          Hutch::Config.set(:mq_host, new_value)
+        end
+
         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 }
+      let(:invalid_get) do
+        -> { Hutch::Config.get(:invalid_attr) }
+      end
+
+      specify do
+        expect(invalid_get).to raise_error Hutch::UnknownAttributeError
+      end
     end
   end
 
@@ -32,11 +49,54 @@ describe Hutch::Config do
       context 'sets value in user config hash' do
         it { is_expected.to eq(new_value) }
       end
+
+      context 'type casting' do
+        context 'number attributes' do
+          before  { Hutch::Config.set(:heartbeat, new_value) }
+          subject(:value) { Hutch::Config.user_config[:heartbeat] }
+
+          let(:new_value) { "0" }
+
+
+          specify 'casts values to integers' do
+            expect(value).to eq 0
+          end
+        end
+      end
+
+      context 'boolean attributes' do
+        before  { Hutch::Config.set(:autoload_rails, new_value) }
+        subject(:value) { Hutch::Config.user_config[:autoload_rails] }
+
+        let(:new_value) { "t" }
+
+
+        specify 'casts values to booleans' do
+          expect(value).to eq true
+        end
+      end
+
+      context 'string attributes' do
+        before  { Hutch::Config.set(:mq_exchange_type, new_value) }
+        subject(:value) { Hutch::Config.user_config[:mq_exchange_type] }
+
+        let(:new_value) { 1 }
+
+
+        specify 'does not perform any typecasting' do
+          expect(value).to eq new_value
+        end
+      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 }
+      let(:invalid_set) do
+        -> { Hutch::Config.set(:invalid_attr, new_value) }
+      end
+
+      specify do
+        expect(invalid_set).to raise_error Hutch::UnknownAttributeError
+      end
     end
   end
 
@@ -49,9 +109,33 @@ describe Hutch::Config do
     end
 
     context 'for an invalid attribute' do
-      let(:invalid_getter) { ->{ Hutch::Config.invalid_attr } }
+      let(:invalid_getter) { -> { Hutch::Config.invalid_attr } }
       specify { expect(invalid_getter).to raise_error NoMethodError }
     end
+
+    context 'for an ENV-overriden value attribute' do
+      around do |example|
+        ENV['HUTCH_MQ_HOST'] = 'example.com'
+        ENV['HUTCH_MQ_PORT'] = '10001'
+        ENV['HUTCH_MQ_TLS'] = 'true'
+        example.run
+        ENV.delete('HUTCH_MQ_HOST')
+        ENV.delete('HUTCH_MQ_PORT')
+        ENV.delete('HUTCH_MQ_TLS')
+      end
+
+      it 'returns the override' do
+        expect(Hutch::Config.mq_host).to eq 'example.com'
+      end
+
+      it 'returns the override for integers' do
+        expect(Hutch::Config.mq_port).to eq 10_001
+      end
+
+      it 'returns the override for booleans' do
+        expect(Hutch::Config.mq_tls).to eq true
+      end
+    end
   end
 
   describe 'a magic setter' do
@@ -63,7 +147,7 @@ describe Hutch::Config do
     end
 
     context 'for an invalid attribute' do
-      let(:invalid_setter) { ->{ Hutch::Config.invalid_attr = new_value } }
+      let(:invalid_setter) { -> { Hutch::Config.invalid_attr = new_value } }
       specify { expect(invalid_setter).to raise_error NoMethodError }
     end
   end
@@ -81,9 +165,9 @@ describe Hutch::Config do
     context 'when an attribute is invalid' do
       let(:config_data) { { random_attribute: 'socks' } }
       it 'raises an error' do
-        expect {
+        expect do
           Hutch::Config.load_from_file(file)
-        }.to raise_error(NoMethodError)
+        end.to raise_error(NoMethodError)
       end
     end
 
@@ -96,26 +180,21 @@ describe Hutch::Config do
         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
+    context 'when using ERB' do
+      let(:host) { 'localhost' }
+      let(:file) do
+        Tempfile.new('configs.yaml').tap do |t|
+          t.write(config_contents)
+          t.rewind
+        end
       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
@@ -123,4 +202,24 @@ YAML
       end
     end
   end
+
+  context 'developer ergonomics' do
+    it 'will accept strings and symbols as config keys' do
+      expect(Hutch::Config.get(:mq_host)).to eq '127.0.0.1'
+      expect(Hutch::Config.get('mq_host')).to eq '127.0.0.1'
+    end
+
+    describe 'it will not overwrite existing config' do
+      it 'with defaults' do
+        expect(Hutch::Config.get(:mq_host)).to eq '127.0.0.1'
+        Hutch::Config.initialize
+
+        Hutch::Config.set(:mq_host, 'example2.com')
+
+        expect(Hutch::Config.get(:mq_host)).to eq 'example2.com'
+        Hutch::Config.initialize
+        expect(Hutch::Config.get(:mq_host)).to eq 'example2.com'
+      end
+    end
+  end
 end