rabbit_feed 0.3.1

data/spec/fixtures/configuration.yml

@@ -0,0 +1,14 @@
+test:
+  host: localhost
+  port: 5672
+  user: guest
+  password: guest
+  application: rabbit_feed
+  exchange: rabbit_feed_exchange
+  pool_size: 1
+  pool_timeout: 1
+  heartbeat: 60
+  connect_timeout: 1
+  network_recovery_interval: 0.1
+  auto_delete_queue: true
+  auto_delete_exchange: true

data/spec/lib/rabbit_feed/client_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+module RabbitFeed
+  describe Client do
+    let(:command)     { 'consume' }
+    let(:logfile)     { 'test.log' }
+    let(:pidfile)     { './test.pid' }
+    let(:config_file) { 'spec/fixtures/configuration.yml' }
+    let(:environment) { 'test' }
+    let(:require_file){ 'rabbit_feed.rb' }
+    let(:arguments) do
+      [
+        command,
+        '--environment',
+        environment,
+        '--config',
+        config_file,
+        '--logfile',
+        logfile,
+        '--pidfile',
+        pidfile,
+        '--require',
+        require_file,
+        '--daemon'
+      ]
+    end
+    before do
+      RabbitFeed.environment = nil
+      RabbitFeed.log = nil
+      RabbitFeed.configuration_file_path = nil
+    end
+    subject{ described_class.new arguments }
+
+    describe '.new' do
+
+      it { should be_valid }
+
+      it 'sets the environment' do
+        subject
+        expect(RabbitFeed.environment).to eq 'test'
+      end
+
+      it 'sets the logger' do
+        subject
+        expect(RabbitFeed.log).to be_a Logger
+      end
+
+      it 'sets the configuration' do
+        subject
+        expect(RabbitFeed.configuration).to be_a Configuration
+      end
+
+      context 'when the command is invalid' do
+        let(:command) { 'blah' }
+
+        it 'should be invalid' do
+          expect{subject}.to raise_error Error
+        end
+      end
+
+      context 'when the log file path is not present' do
+        let(:logfile) { '/blah/blah.log' }
+
+        it 'should be invalid' do
+          expect{subject}.to raise_error Error
+        end
+      end
+
+      context 'when the pid file path is not present' do
+        let(:pidfile) { '/blah/blah.pid' }
+
+        it 'should be invalid' do
+          expect{subject}.to raise_error Error
+        end
+      end
+
+      context 'when the config file is not present' do
+        let(:config_file) { '/blah/blah.yml' }
+
+        it 'should be invalid' do
+          expect{subject}.to raise_error Error
+        end
+      end
+
+      context 'when the environment is not present' do
+        let(:environment) { '' }
+        before do
+          ENV['RAILS_ENV'] = nil
+          ENV['RACK_ENV']  = nil
+        end
+
+        it 'should be invalid' do
+          expect{subject}.to raise_error Error
+        end
+
+        context 'when the RAILS_ENV is present' do
+          before { ENV['RAILS_ENV'] = 'test' }
+          after do
+            ENV['RAILS_ENV'] = nil
+            ENV['RACK_ENV']  = nil
+          end
+
+          it { should be_valid }
+        end
+      end
+
+      context 'when requiring a directory in a non rails app' do
+        let(:require_file) { './' }
+
+        it 'should be invalid' do
+          expect{subject}.to raise_error Error
+        end
+      end
+    end
+  end
+end

data/spec/lib/rabbit_feed/configuration_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+module RabbitFeed
+  describe Configuration do
+
+    describe '#queue' do
+      let(:options) do
+        {
+          application: 'rabbit_feed',
+          environment: 'test',
+        }
+      end
+      subject { (described_class.new options).queue }
+
+      it { should eq 'test.rabbit_feed' }
+    end
+
+    describe '.load' do
+      let(:file_path)   { 'spec/fixtures/configuration.yml' }
+      let(:environment) { 'test' }
+      subject { described_class.load file_path, environment }
+
+      context 'with missing configuration' do
+        let(:environment) { 'production' }
+
+        it 'should raise an error' do
+          expect{ subject }.to raise_error ConfigurationError
+        end
+      end
+
+      context 'with configuration' do
+
+        its(:host)                      { should eq 'localhost' }
+        its(:port)                      { should eq 5672 }
+        its(:user)                      { should eq 'guest' }
+        its(:password)                  { should eq 'guest' }
+        its(:application)               { should eq 'rabbit_feed' }
+        its(:environment)               { should eq 'test' }
+        its(:exchange)                  { should eq 'rabbit_feed_exchange' }
+        its(:pool_size)                 { should eq 1 }
+        its(:pool_timeout)              { should eq 1 }
+        its(:heartbeat)                 { should eq 60 }
+        its(:connect_timeout)           { should eq 1 }
+        its(:network_recovery_interval) { should eq 0.1 }
+        its(:auto_delete_queue)         { should be_true }
+        its(:auto_delete_exchange)      { should be_true }
+      end
+
+    end
+
+    describe '.new' do
+      let(:options) {{}}
+      subject { described_class.new options }
+
+      context 'with default options' do
+        let(:options) do
+          {
+            application: 'rabbit_feed',
+            environment: 'test',
+          }
+        end
+
+        its(:host)                      { should eq 'localhost' }
+        its(:port)                      { should eq 5672 }
+        its(:user)                      { should eq 'guest' }
+        its(:password)                  { should eq 'guest' }
+        its(:exchange)                  { should eq 'amq.topic' }
+        its(:pool_size)                 { should eq 1 }
+        its(:pool_timeout)              { should eq 5 }
+        its(:heartbeat)                 { should eq 5 }
+        its(:connect_timeout)           { should eq 10 }
+        its(:network_recovery_interval) { should eq 1 }
+        its(:auto_delete_queue)         { should be_false }
+        its(:auto_delete_exchange)      { should be_false }
+      end
+
+      context 'with provided options' do
+        let(:options) do
+          {
+            host:                      'host_name',
+            port:                      12345,
+            user:                      'user_name',
+            password:                  'password',
+            application:               'rabbit_feed',
+            environment:               'test',
+            exchange:                  'exchange_name',
+            pool_size:                 2,
+            pool_timeout:              6,
+            heartbeat:                 3,
+            connect_timeout:           4,
+            network_recovery_interval: 2,
+            auto_delete_queue:         'true',
+            auto_delete_exchange:      'false',
+          }
+        end
+
+        its(:host)                      { should eq 'host_name' }
+        its(:port)                      { should eq 12345 }
+        its(:user)                      { should eq 'user_name' }
+        its(:password)                  { should eq 'password' }
+        its(:application)               { should eq 'rabbit_feed' }
+        its(:environment)               { should eq 'test' }
+        its(:exchange)                  { should eq 'exchange_name' }
+        its(:pool_size)                 { should eq 2 }
+        its(:pool_timeout)              { should eq 6 }
+        its(:heartbeat)                 { should eq 3 }
+        its(:connect_timeout)           { should eq 4 }
+        its(:network_recovery_interval) { should eq 2 }
+        its(:auto_delete_queue)         { should be_true }
+        its(:auto_delete_exchange)      { should be_true }
+      end
+
+      context 'with empty options' do
+
+        it 'should raise an error' do
+          expect{ subject }.to raise_error ConfigurationError
+        end
+      end
+    end
+  end
+end

data/spec/lib/rabbit_feed/connection_concern_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+module RabbitFeed
+  describe ConnectionConcern do
+    let(:bunny_exchange)    { double(:bunny_exchange, on_return: nil) }
+    let(:connection_closed) { false }
+    let(:bunny_channel)     { double(:bunny_channel, exchange: bunny_exchange, id: 1) }
+    let(:bunny_connection)  { double(:bunny_connection, start: nil, closed?: connection_closed, close: nil, create_channel: bunny_channel) }
+    before { allow(Bunny).to receive(:new).and_return(bunny_connection) }
+    after do
+      subject.instance_variable_set(:@bunny_connection, nil)
+      subject.instance_variable_set(:@connection_pool, nil)
+    end
+    subject { RabbitFeed::ProducerConnection }
+
+    describe '.with_connection' do
+
+      it 'retries on exception' do
+        expect(subject).to receive(:retry_on_exception).and_call_original
+        subject.with_connection{|connection| connection }
+      end
+
+      it 'assigns the connection' do
+        subject.with_connection{|connection| connection }
+        expect(subject.instance_variable_get(:@bunny_connection)).to eq bunny_connection
+      end
+
+      it 'assigns the connection pool' do
+        subject.with_connection{|connection| connection }
+        expect(subject.instance_variable_get(:@connection_pool)).to be_a ConnectionPool
+      end
+
+      it 'provides an instance of the class' do
+        actual = subject.with_connection{|connection| connection }
+        expect(actual).to be_a subject
+      end
+    end
+
+    describe '.close' do
+
+      context 'when the connection is nil' do
+
+        it 'does not close the connection' do
+          expect(bunny_connection).not_to receive(:close)
+          subject.close
+        end
+      end
+
+      context 'when the connection is not nil' do
+        before do
+          subject.with_connection{|connection| connection }
+        end
+
+        context 'when the connection is closed' do
+          let(:connection_closed) { true }
+
+          it 'does not close the connection' do
+            expect(bunny_connection).not_to receive(:close)
+            subject.close
+          end
+        end
+
+        context 'when the connection is not closed' do
+          let(:connection_closed) { false }
+
+          it 'closes the connection' do
+            expect(bunny_connection).to receive(:close)
+            subject.close
+          end
+
+          context 'when closing raises an exception' do
+
+            it 'does not propogate the exception' do
+              allow(bunny_connection).to receive(:close).and_raise 'error'
+              expect{ subject.close }.not_to raise_error
+            end
+          end
+        end
+
+        it 'unsets the connection' do
+          subject.close
+          expect(subject.instance_variable_get(:@bunny_connection)).to be_nil
+        end
+
+        it 'unsets the connection pool' do
+          subject.close
+          expect(subject.instance_variable_get(:@connection_pool)).to be_nil
+        end
+      end
+    end
+
+    describe '.retry_on_exception' do
+      it_behaves_like 'an operation that retries on exception', :retry_on_exception, RuntimeError
+      it_behaves_like 'an operation that does not retry on exception', :retry_on_exception, Bunny::ConnectionClosedError
+    end
+
+    describe '.retry_on_closed_connection' do
+      before do
+        subject.with_connection{|connection| connection }
+      end
+
+      it_behaves_like 'an operation that retries on exception', :retry_on_closed_connection, Bunny::ConnectionClosedError
+      it_behaves_like 'an operation that does not retry on exception', :retry_on_closed_connection, RuntimeError
+
+      it 'unsets the connection' do
+        expect { subject.retry_on_closed_connection { raise Bunny::ConnectionClosedError.new 'blah' } }.to raise_error
+        expect(subject.instance_variable_get(:@bunny_connection)).to be_nil
+      end
+
+      it 'unsets the connection pool' do
+        expect { subject.retry_on_closed_connection { raise Bunny::ConnectionClosedError.new 'blah' } }.to raise_error
+        expect(subject.instance_variable_get(:@connection_pool)).to be_nil
+      end
+    end
+  end
+end

data/spec/lib/rabbit_feed/consumer_connection_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+module RabbitFeed
+  describe ConsumerConnection do
+    let(:bunny_queue)      { double(:bunny_queue, bind: nil, subscribe: nil)}
+    let(:bunny_channel)    { double(:bunny_channel, prefetch: nil, nack: nil, ack: nil, queue: bunny_queue, id: 1)}
+    let(:bunny_connection) { double(:bunny_connection, start: nil, closed?: false, close: nil, create_channel: bunny_channel) }
+    before do
+      allow(Bunny).to receive(:new).and_return(bunny_connection)
+      allow(bunny_queue).to receive(:channel).and_return(bunny_channel)
+    end
+    subject{ described_class.new bunny_channel }
+
+    describe '#new' do
+      before do
+        EventRouting do
+          accept_from('rabbit_feed') do
+            event('test') {|event|}
+          end
+        end
+      end
+
+      it 'binds the queue to the exchange' do
+        expect(bunny_queue).to receive(:bind).with('rabbit_feed_exchange', { routing_key: 'test.rabbit_feed.test'})
+        subject
+      end
+
+      it 'assigns the queue' do
+        expect(subject.queue).to eq bunny_queue
+      end
+
+      it 'preserves message order' do
+        expect(bunny_channel).to receive(:prefetch).with(1)
+        subject
+      end
+    end
+
+    describe '#connection_options' do
+
+      it 'uses a threaded connection' do
+        expect(described_class.connection_options).to include(threaded: true)
+      end
+    end
+
+    describe '#consume' do
+      before do
+        allow(bunny_queue).to receive(:subscribe).and_yield(double(:delivery_info, delivery_tag: :tag), 'properties', 'payload')
+        allow_any_instance_of(described_class).to receive(:sleep)
+      end
+
+      it 'yields the payload' do
+        subject.consume { |payload| payload.should eq 'payload'}
+      end
+
+      it 'acknowledges the message' do
+        expect(bunny_channel).to receive(:ack)
+        subject.consume { }
+      end
+
+      context 'when an exception is raised' do
+
+        context 'when Airbrake is defined' do
+          before do
+            stub_const('Airbrake', double(:airbrake, configuration: airbrake_configuration))
+          end
+
+          context 'and the Airbrake configuration is public' do
+            let(:airbrake_configuration) { double(:airbrake_configuration, public?: true) }
+
+            it 'notifies airbrake' do
+              expect(Airbrake).to receive(:notify_or_ignore).with(an_instance_of RuntimeError)
+
+              expect{ subject.consume { raise 'Consuming time' } }.not_to raise_error
+            end
+          end
+        end
+
+        it 'negatively acknowledges the message' do
+          expect(bunny_channel).to receive(:nack)
+          subject.consume { raise 'Consuming time' }
+        end
+      end
+    end
+  end
+end