shivam 0.0.0-java

data/spec/hutch/error_handlers/sentry_raven_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Hutch::ErrorHandlers::SentryRaven do
+  let(:error_handler) { Hutch::ErrorHandlers::SentryRaven.new }
+
+  describe '#handle' do
+    let(:properties) { OpenStruct.new(message_id: "1") }
+    let(:payload) { "{}" }
+    let(:error) do
+      begin
+        raise "Stuff went wrong"
+      rescue RuntimeError => err
+        err
+      end
+    end
+
+    it "logs the error to Sentry" do
+      expect(Raven).to receive(:capture_exception).with(error, {extra: { payload: payload }})
+      error_handler.handle(properties, payload, double, error)
+    end
+  end
+
+  describe '#handle_setup_exception' do
+    let(:error) do
+      begin
+        raise "Stuff went wrong during setup"
+      rescue RuntimeError => err
+        err
+      end
+    end
+
+    it "logs the error to Sentry" do
+      expect(Raven).to receive(:capture_exception).with(error)
+      error_handler.handle_setup_exception(error)
+    end
+  end
+end

data/spec/hutch/error_handlers/sentry_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Hutch::ErrorHandlers::Sentry do
+  let(:error_handler) { Hutch::ErrorHandlers::Sentry.new }
+
+  before do
+    Sentry.init do
+      # initialize Sentry so that the integration acutally works
+      # otherwise, all its methods are going to return early
+      # so it will be impossible to check if it actually works
+    end
+  end
+
+  describe '#handle' do
+    let(:properties) { OpenStruct.new(message_id: "1") }
+    let(:payload) { "{}" }
+    let(:error) do
+      begin
+        raise "Stuff went wrong"
+      rescue RuntimeError => err
+        err
+      end
+    end
+
+    it "logs the error to Sentry" do
+      expect(::Sentry).to receive(:capture_exception).with(error).and_call_original
+
+      error_handler.handle(properties, payload, double, error)
+    end
+  end
+
+  describe '#handle_setup_exception' do
+    let(:error) do
+      begin
+        raise "Stuff went wrong during setup"
+      rescue RuntimeError => err
+        err
+      end
+    end
+
+    it "logs the error to Sentry" do
+      expect(::Sentry).to receive(:capture_exception).with(error).and_call_original
+
+      error_handler.handle_setup_exception(error)
+    end
+  end
+end

data/spec/hutch/logger_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Hutch::Logging do
+  let(:dummy_object) do
+    class DummyObject
+      include described_class
+    end
+  end
+
+  describe '#logger' do
+    around do |example|
+      old_logger = described_class.logger
+      described_class.setup_logger
+      example.run
+      described_class.logger = old_logger
+    end
+
+    context 'with the default logger' do
+      subject { described_class.logger }
+
+      it { is_expected.to be_instance_of(Logger) }
+    end
+
+    context 'with a custom logger' do
+      let(:dummy_logger) { double("Dummy logger") }
+
+      it "users the custom logger" do
+        described_class.logger = dummy_logger
+        expect(described_class.logger).to eq(dummy_logger)
+      end
+    end
+  end
+end
+

data/spec/hutch/message_spec.rb

@@ -0,0 +1,38 @@
+require 'hutch/message'
+
+describe Hutch::Message do
+  let(:delivery_info) { double('Delivery Info') }
+  let(:props) { double('Properties', content_type: "application/json") }
+  let(:body) {{ foo: 'bar' }.with_indifferent_access}
+  let(:json_body) { MultiJson.dump(body) }
+  subject(:message) { Hutch::Message.new(delivery_info, props, json_body, Hutch::Config[:serializer]) }
+
+  describe '#body' do
+    subject { super().body }
+    it { is_expected.to eq(body) }
+  end
+
+  describe '[]' do
+    subject { message[:foo] }
+    it { is_expected.to eq('bar') }
+  end
+
+  [:message_id, :timestamp].each do |method|
+    describe method.to_s do
+      it 'delegates to @properties' do
+        expect(props).to 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
+        expect(delivery_info).to receive(method)
+        message.send(method)
+      end
+    end
+  end
+end
+

data/spec/hutch/serializers/json_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Hutch::Serializers::JSON do
+  let(:subject) { described_class }
+
+  it "encode/decode" do
+    payload = { a: 1, b: 2 }
+    encoded = subject.encode(payload)
+    decoded = subject.decode(encoded)
+
+    expect(encoded).to eq "{\"a\":1,\"b\":2}"
+    expect(decoded).to eq("a" => 1, "b" => 2)
+    expect(decoded[:a]).to eq 1
+    expect(decoded[:b]).to eq 2
+  end
+
+end

data/spec/hutch/tracers/datadog_spec.rb

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

data/spec/hutch/waiter_spec.rb

@@ -0,0 +1,51 @@
+require 'hutch/waiter'
+
+RSpec.describe Hutch::Waiter do
+  describe '.wait_until_signaled' do
+    let(:pid) { Process.pid }
+    def start_kill_thread(signal)
+      Thread.new do
+        # sleep allows the worker time to set up the signal handling
+        # before the kill signal is sent.
+        sleep 0.001
+        Process.kill signal, pid
+      end
+    end
+
+    context 'a QUIT signal is received', if: RSpec::Support::Ruby.mri? do
+      it 'logs that hutch is stopping' do
+        expect(Hutch::Logging.logger).to receive(:info)
+          .with('caught SIGQUIT, stopping hutch...')
+
+        start_kill_thread('QUIT')
+        described_class.wait_until_signaled
+      end
+    end
+
+    context 'a TERM signal is received', if: !defined?(JRUBY_VERSION) do
+      it 'logs that hutch is stopping' do
+        expect(Hutch::Logging.logger).to receive(:info)
+          .with('caught SIGTERM, stopping hutch...')
+
+        start_kill_thread('TERM')
+        described_class.wait_until_signaled
+      end
+    end
+
+    context 'a INT signal is received', if: !defined?(JRUBY_VERSION) do
+      it 'logs that hutch is stopping' do
+        expect(Hutch::Logging.logger).to receive(:info)
+          .with('caught SIGINT, stopping hutch...')
+
+        start_kill_thread('INT')
+        described_class.wait_until_signaled
+      end
+    end
+  end
+
+  describe described_class::SHUTDOWN_SIGNALS do
+    it 'includes only things in Signal.list.keys' do
+      expect(described_class).to eq(described_class & Signal.list.keys)
+    end
+  end
+end

data/spec/hutch/worker_spec.rb

@@ -0,0 +1,184 @@
+require 'spec_helper'
+require 'hutch/worker'
+
+describe Hutch::Worker do
+  let(:consumer) { double('Consumer', routing_keys: %w( a b c ),
+                          get_queue_name: 'consumer', get_arguments: {},
+                          get_options: {}, get_serializer: nil) }
+  let(:consumers) { [consumer, double('Consumer')] }
+  let(:broker) { Hutch::Broker.new }
+  let(:setup_procs) { Array.new(2) { Proc.new {} } }
+  subject(:worker) { Hutch::Worker.new(broker, consumers, setup_procs) }
+
+  describe ".#run" do
+    it "calls each setup proc" do
+      setup_procs.each { |prc| expect(prc).to receive(:call) }
+      allow(worker).to receive(:setup_queues)
+      allow(Hutch::Waiter).to receive(:wait_until_signaled)
+      allow(broker).to receive(:stop)
+
+      worker.run
+    end
+  end
+
+  describe '#setup_queues' do
+    it 'sets up queues for each of the consumers' do
+      consumers.each do |consumer|
+        expect(worker).to receive(:setup_queue).with(consumer)
+      end
+      worker.setup_queues
+    end
+  end
+
+  describe '#setup_queue' do
+    let(:queue) { double('Queue', bind: nil, subscribe: nil) }
+    before { allow(broker).to receive_messages(queue: queue, bind_queue: nil) }
+
+    it 'creates a queue' do
+      expect(broker).to receive(:queue).with(consumer.get_queue_name, consumer.get_options).and_return(queue)
+      worker.setup_queue(consumer)
+    end
+
+    it 'binds the queue to each of the routing keys' do
+      expect(broker).to receive(:bind_queue).with(queue, %w( a b c ))
+      worker.setup_queue(consumer)
+    end
+
+    it 'sets up a subscription' do
+      expect(queue).to receive(:subscribe).with(consumer_tag: %r(^hutch\-.{36}$), manual_ack: true)
+      worker.setup_queue(consumer)
+    end
+
+    context 'with a configured consumer tag prefix' do
+      before { Hutch::Config.set(:consumer_tag_prefix, 'appname') }
+
+      it 'sets up a subscription with the configured tag prefix' do
+        expect(queue).to receive(:subscribe).with(consumer_tag: %r(^appname\-.{36}$), manual_ack: true)
+        worker.setup_queue(consumer)
+      end
+    end
+
+    context 'with a configured consumer tag prefix that is too long' do
+      let(:maximum_size) { 255 - SecureRandom.uuid.size - 1 }
+      before { Hutch::Config.set(:consumer_tag_prefix, 'a'.*(maximum_size + 1)) }
+
+      it 'raises an error' do
+        expect { worker.setup_queue(consumer) }.to raise_error(/Tag must be 255 bytes long at most/)
+      end
+    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, content_type: "application/json") }
+    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
+      expect(consumer_instance).to receive(:process).
+                        with(an_instance_of(Hutch::Message))
+      expect(consumer_instance).to receive(:message_rejected?).and_return(false)
+      worker.handle_message(consumer, delivery_info, properties, payload)
+    end
+
+    it 'acknowledges the message' do
+      allow(consumer_instance).to receive(:process)
+      expect(broker).to receive(:ack).with(delivery_info.delivery_tag)
+      expect(consumer_instance).to receive(:message_rejected?).and_return(false)
+      worker.handle_message(consumer, delivery_info, properties, payload)
+    end
+
+    context 'when the consumer fails and a requeue is configured' do
+
+      it 'requeues the message' do
+        allow(consumer_instance).to receive(:process).and_raise('failed')
+        requeuer = double
+        allow(requeuer).to receive(:handle) { |delivery_info, properties, broker, e|
+          broker.requeue delivery_info.delivery_tag
+          true
+        }
+        allow(worker).to receive(:error_acknowledgements).and_return([requeuer])
+        expect(broker).to_not receive(:ack)
+        expect(broker).to_not receive(:nack)
+        expect(broker).to receive(:requeue)
+
+        worker.handle_message(consumer, delivery_info, properties, payload)
+      end
+    end
+
+
+    context 'when the consumer raises an exception' do
+      before { allow(consumer_instance).to receive(:process).and_raise('a consumer error') }
+
+      it 'logs the error' do
+        Hutch::Config[:error_handlers].each do |backend|
+          expect(backend).to receive(:handle)
+        end
+        worker.handle_message(consumer, delivery_info, properties, payload)
+      end
+
+      it 'rejects the message' do
+        expect(broker).to receive(:nack).with(delivery_info.delivery_tag)
+        worker.handle_message(consumer, delivery_info, properties, payload)
+      end
+    end
+
+    context "when the payload is not valid json" do
+      let(:payload) { "Not Valid JSON" }
+
+      it 'logs the error' do
+        Hutch::Config[:error_handlers].each do |backend|
+          expect(backend).to receive(:handle)
+        end
+        worker.handle_message(consumer, delivery_info, properties, payload)
+      end
+
+      it 'rejects the message' do
+        expect(broker).to receive(:nack).with(delivery_info.delivery_tag)
+        worker.handle_message(consumer, delivery_info, properties, payload)
+      end
+    end
+  end
+
+
+  describe '#acknowledge_error' do
+    let(:delivery_info) { double('Delivery Info', routing_key: '',
+                                 delivery_tag: 'dt') }
+    let(:properties) { double('Properties', message_id: 'abc123') }
+
+    subject { worker.acknowledge_error delivery_info, properties, broker, StandardError.new }
+
+    it 'stops when it runs a successful acknowledgement' do
+      skip_ack = double handle: false
+      always_ack = double handle: true
+      never_used = double handle: true
+
+      allow(worker).
+        to receive(:error_acknowledgements).
+        and_return([skip_ack, always_ack, never_used])
+
+      expect(never_used).to_not receive(:handle)
+
+      subject
+    end
+
+    it 'defaults to nacking' do
+      skip_ack = double handle: false
+
+      allow(worker).
+        to receive(:error_acknowledgements).
+        and_return([skip_ack, skip_ack])
+
+      expect(broker).to receive(:nack)
+
+      subject
+    end
+  end
+end
+

data/spec/hutch_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe Hutch do
+  describe '.register_consumer' do
+    let(:consumer_a) { double('Consumer') }
+    let(:consumer_b) { double('Consumer') }
+
+    it 'saves the consumers in the global consumer list' do
+      Hutch.register_consumer(consumer_a)
+      Hutch.register_consumer(consumer_b)
+      expect(Hutch.consumers).to include consumer_a
+      expect(Hutch.consumers).to include consumer_b
+    end
+  end
+
+  describe '.connect' do
+    context 'not connected' do
+      let(:options) { double 'options' }
+      let(:config)  { double 'config' }
+      let(:broker)  { double 'broker' }
+      let(:action)  { Hutch.connect(options, config) }
+
+      it 'passes options and config' do
+        expect(Hutch::Broker).to receive(:new).with(config).and_return broker
+        expect(broker).to receive(:connect).with options
+
+        action
+      end
+
+    end
+
+    context 'connected' do
+      before { allow(Hutch).to receive(:connected?).and_return true }
+
+      it 'does not reconnect' do
+        expect(Hutch::Broker).not_to receive :new
+        Hutch.connect
+      end
+    end
+  end
+
+  describe '.connected?' do
+    subject(:connected?) { Hutch.connected? }
+
+    before { allow(Hutch).to receive(:broker).and_return(broker) }
+
+    context 'without a broker' do
+      let(:broker) { nil }
+
+      it { expect(connected?).to be_falsey }
+    end
+
+    context 'without a connection' do
+      let(:connection) { nil }
+      let(:broker) { double(:broker, connection: connection) }
+
+      it { expect(connected?).to be_falsey }
+    end
+
+    context 'with a closed connection' do
+      let(:connection) { double(:connection, open?: false) }
+      let(:broker) { double(:broker, connection: connection) }
+
+      it { expect(connected?).to be_falsey }
+    end
+
+    context 'with an opened connection' do
+      let(:connection) { double(:connection, open?: true) }
+      let(:broker) { double(:broker, connection: connection) }
+
+      it { expect(connected?).to be_truthy }
+    end
+  end
+
+  describe '#publish' do
+    let(:broker) { double(Hutch::Broker) }
+    let(:args) { ['test.key', 'message', { headers: { foo: 'bar' } }] }
+
+    before { allow(Hutch).to receive(:broker).and_return(broker) }
+
+    it 'delegates to Hutch::Broker#publish' do
+      expect(broker).to receive(:publish).with(*args)
+      Hutch.publish(*args)
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,42 @@
+require 'simplecov'
+if ENV['TRAVIS']
+  require 'coveralls'
+  SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+end
+
+SimpleCov.start do
+  add_filter '/spec/'
+  add_filter '/.bundle/'
+end
+
+require 'raven'
+require 'hutch'
+require 'logger'
+
+# set logger to be a null logger
+Hutch::Logging.logger = Logger.new(File::NULL)
+
+RSpec.configure do |config|
+  config.raise_errors_for_deprecations!
+
+  if defined?(JRUBY_VERSION)
+    config.filter_run_excluding adapter: :bunny
+  else
+    config.filter_run_excluding adapter: :march_hare
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+end
+
+# Constants (classes, etc) defined within a block passed to this method
+# will be removed from the global namespace after the block as run.
+def isolate_constants
+  existing_constants = Object.constants
+  yield
+ensure
+  (Object.constants - existing_constants).each do |constant|
+    Object.send(:remove_const, constant)
+  end
+end

data/templates/default/class/setup.rb

@@ -0,0 +1,4 @@
+def init
+  super
+  sections.push :settings
+end

data/templates/default/fulldoc/html/css/hutch.css

@@ -0,0 +1,13 @@
+.settings {
+  border-spacing: 2.5rem;
+  border-collapse: collapse;
+}
+
+.settings thead th {
+  text-align: left;
+}
+
+.settings thead th,
+.settings tbody td {
+  padding: .5em 1em;
+}

data/templates/default/layout/html/setup.rb

@@ -0,0 +1,7 @@
+def init
+  super
+end
+
+def stylesheets
+  super + %w(css/hutch.css)
+end

data/templates/default/method_details/html/settings.erb

@@ -0,0 +1,5 @@
+<% if object['custom_field'] %>
+<p>
+  <%= object['custom_field'] %>
+</p>
+<% end %>

data/templates/default/method_details/setup.rb

@@ -0,0 +1,4 @@
+def init
+  super
+  sections.last.place(:settings).after(:source)
+end

data/templates/default/module/html/settings.erb

@@ -0,0 +1,40 @@
+<% if object['setting_rows'] %>
+  <h2>
+    Configuration
+  </h2>
+
+  <div class="tags">
+    <table border="1" class="settings">
+      <thead>
+        <tr>
+          <th>
+            Setting name
+          </th>
+          <th>
+            Default value
+          </th>
+          <th>
+            Type
+          </th>
+          <th>
+            ENV variable
+          </th>
+          <th>
+            Description
+          </th>
+        </tr>
+      </thead>
+      <tbody>
+      <% for setting in object['setting_rows'] %>
+        <tr>
+          <td><tt><%= resolve_links "{Hutch::Config##{setting[:name]} #{setting[:name]}}" %></tt></td>
+          <td><%= setting[:default_value] %></td>
+          <td><%= setting[:type] %></td>
+          <td><tt>HUTCH_<%= setting[:name].upcase %></tt></td>
+          <td><%= html_markup_markdown setting[:first_line_of_description] %></td>
+        </tr>
+      <% end %>
+      </tbody>
+    </table>
+  </div>
+<% end %>

data/templates/default/module/setup.rb

@@ -0,0 +1,4 @@
+def init
+  super
+  sections.place(:settings).before(:children)
+end