basquiat 1.1.1 → 1.2.0

data/lib/basquiat/errors.rb

@@ -0,0 +1,2 @@
+require 'basquiat/errors/subclass_responsibility'
+require 'basquiat/errors/strategy_not_registered'

data/lib/basquiat/errors/strategy_not_registered.rb

@@ -0,0 +1,14 @@
+module Basquiat
+  module Errors
+    class StrategyNotRegistered < StandardError
+      def initialize(symbol)
+        super()
+        @symbol = symbol
+      end
+
+      def message
+        "No matching requeue strategy registered as :#{@symbol}"
+      end
+    end
+  end
+end

data/lib/basquiat/errors/subclass_responsibility.rb

@@ -0,0 +1,9 @@
+module Basquiat
+  module Errors
+    class SubclassResponsibility < NoMethodError
+      def message
+        'This method should be implemented by a subclass tailored to the adapter'
+      end
+    end
+  end
+end

data/lib/basquiat/interfaces/base.rb

@@ -18,7 +18,6 @@ module Basquiat
       @adapter.adapter_options Basquiat.configuration.adapter_options
     end
 
-
     def event_adapter=(adapter)
       @adapter = adapter.new
     end

data/lib/basquiat/support/configuration.rb

@@ -3,6 +3,7 @@ require 'naught'
 require 'erb'
 
 module Basquiat
+  require 'logger'
   DefaultLogger = Naught.build { |config| config.mimic Logger }
 
   class Configuration
@@ -40,18 +41,17 @@ module Basquiat
     end
 
     def reload_classes
-      Basquiat::Base.descendants.each do |klass|
-        klass.reload_adapter_from_configuration
-      end
+      Basquiat::Base.descendants.each(&:reload_adapter_from_configuration)
     end
 
     private
+
     def config
       @yaml.fetch(environment)
     end
 
     def load_yaml(path)
-      @yaml     = YAML.load(ERB.new(IO.readlines(path).join).result).symbolize_keys
+      @yaml = YAML.load(ERB.new(IO.readlines(path).join).result).symbolize_keys
     end
 
     def setup_basic_options

data/lib/basquiat/support/hash_refinements.rb

@@ -10,12 +10,13 @@ module Basquiat
             self[key] = value
           end
         end
+        self
       end
 
       def symbolize_keys
         each_with_object({}) do |(key, value), new_hash|
           new_key = key.to_sym rescue key
-          new_value = (value.is_a? Hash) ? value.symbolize_keys : value
+          new_value         = (value.is_a? Hash) ? value.symbolize_keys : value
           new_hash[new_key] = new_value
         end
       end

data/lib/basquiat/version.rb

@@ -1,4 +1,4 @@
 # Version file
 module Basquiat
-  VERSION = '1.1.1'
+  VERSION = '1.2.0'
 end

data/spec/lib/adapters/base_adapter_spec.rb

@@ -1,11 +1,29 @@
 require 'spec_helper'
 
 # Sample class used for testing
-class SampleAdapter
-  include Basquiat::Adapters::Base
-end
-
 describe Basquiat::Adapters::Base do
-  subject { SampleAdapter.new }
-  it_behaves_like 'a Basquiat::Adapter'
+  subject(:adapter) { Basquiat::Adapters::Base.new }
+
+  [:disconnect, :subscribe_to, :publish].each do |meth|
+    it "raise a SubclassResponsibility error if #{meth} isn't implemented" do
+      expect { adapter.public_send(meth) }.to raise_error Basquiat::Errors::SubclassResponsibility
+    end
+  end
+
+  it 'raise error when using an unregistered strategy' do
+    # expect(adapter.use_strategy(:not_here)).to raise_error StrategyNotRegistered
+  end
+
+  it 'register a requeue strategy' do
+    class CoolStuff
+    end
+    adapter.class.register_strategy :cool_stuff, CoolStuff
+    expect(adapter.strategies).to have_key :cool_stuff
+  end
+
+  it 'merges the options with the default ones' do
+    opts = adapter.instance_variable_get(:@options)
+    adapter.adapter_options(nice_option: '127.0.0.2')
+    expect(opts[:nice_option]).to eq('127.0.0.2')
+  end
 end

data/spec/lib/adapters/base_message_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Basquiat::Adapters::BaseMessage do
+  subject(:message) { Basquiat::Adapters::BaseMessage.new({ data: 'everything is AWESOME!' }.to_json) }
+
+  it 'delegates calls to the JSON' do
+    expect(message.fetch(:data)).to eq('everything is AWESOME!')
+    expect { message.fetch(:error) }.to raise_error KeyError
+  end
+
+  [:ack?, :unack, :requeue, :delay_redelivery].each do |meth|
+    it "raise a SubclassResponsibility error if #{meth} isn't implemented" do
+      expect { message.public_send(meth) }.to raise_error Basquiat::Errors::SubclassResponsibility
+    end
+  end
+end

data/spec/lib/adapters/rabbitmq/configuration_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'basquiat/adapters/rabbitmq_adapter'
+
+class AwesomeStrategy < Basquiat::Adapters::RabbitMq::BaseStrategy
+  def self.session_options
+    { exchange: { options: { some_setting: 'awesomesauce' } } }
+  end
+end
+
+describe Basquiat::Adapters::RabbitMq::Configuration do
+  subject(:config) { Basquiat::Adapters::RabbitMq::Configuration.new }
+
+  # used by the Adapter::Base class
+  describe '#merge_user_options', focus: true do
+    it 'merges the user supplied options with the default ones' do
+      config.merge_user_options(queue: { name: 'config.test.queue' })
+      expect(config.base_options[:queue][:name]).to eq('config.test.queue')
+    end
+  end
+
+  it '#connection_options' do
+    expect(config.connection_options.keys).to contain_exactly(:servers, :auth, :failover)
+  end
+
+  it '#session_options' do
+    expect(config.session_options.keys).to contain_exactly(:exchange, :queue, :publisher)
+  end
+
+  context 'Strategies' do
+    it 'merges the strategy options with the session ones' do
+      Basquiat::Adapters::RabbitMq.register_strategy(:awesome, AwesomeStrategy)
+      config.merge_user_options(requeue: { enabled: true, strategy: 'awesome' })
+      expect(config.session_options[:exchange][:options]).to have_key(:some_setting)
+    end
+
+    it 'raises an error if trying to use a non-registered strategy' do
+      config.merge_user_options(requeue: { enabled: true, strategy: 'perfect' })
+      expect { config.strategy }.to raise_error Basquiat::Errors::StrategyNotRegistered
+    end
+
+    it 'deals with the requeue strategy options', focus: true do
+      Basquiat::Adapters::RabbitMq.register_strategy :dlx, Basquiat::Adapters::RabbitMq::DeadLettering
+      config.merge_user_options(requeue: { enabled: true, strategy: 'dlx', options: { exchange: 'dlx.topic' } })
+      expect(config.session_options[:queue][:options]).to include('x-dead-letter-exchange' => 'dlx.topic')
+    end
+  end
+end

data/spec/lib/adapters/rabbitmq/connection_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+require 'basquiat/adapters/rabbitmq_adapter'
+
+describe Basquiat::Adapters::RabbitMq::Connection do
+  subject(:connection) { Basquiat::Adapters::RabbitMq::Connection }
+
+  let(:servers) do
+    [{ host: ENV.fetch('BASQUIAT_RABBITMQ_1_PORT_5672_TCP_ADDR') { 'localhost' },
+       port: ENV.fetch('BASQUIAT_RABBITMQ_1_PORT_5672_TCP_PORT') { 5672 } }]
+  end
+
+  before(:each) do
+    Basquiat.configure { |c| c.logger = Logger.new('log/basquiat.log') }
+  end
+
+  it '#connected?' do
+    conn = connection.new(servers: servers)
+    expect(conn.connected?).to be_falsey
+    conn.start
+    expect(conn.connected?).to_not be_truthy
+    conn.disconnect
+  end
+
+  context 'failover' do
+    let(:failover) do
+      { default_timeout: 0.2, max_retries: 2, threaded: false }
+    end
+
+    before(:each) { servers.unshift(host: 'localhost', port: 1234) }
+
+    it 'tries a reconnection after a few seconds' do
+      conn = connection.new(servers:  [host: 'localhost', port: 1234],
+                            failover: { default_timeout: 0.2, max_retries: 1 })
+      expect { conn.start }.to raise_error(Bunny::TCPConnectionFailed)
+      conn.close
+    end
+
+    it 'uses another server after all retries on a single one' do
+      conn = connection.new(servers: servers, failover: failover)
+      expect { conn.start }.to_not raise_error
+      expect(conn.current_server_uri).to match "#{ENV.fetch('BASQUIAT_RABBITMQ_1_PORT_5672_TCP_PORT') { 5672 }}"
+      conn.close
+    end
+  end
+end

data/spec/lib/adapters/rabbitmq/events_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+require 'basquiat/adapters/rabbitmq_adapter'
+
+describe Basquiat::Adapters::RabbitMq::Events do
+  subject(:events) { Basquiat::Adapters::RabbitMq::Events.new }
+
+  context 'basic functionality' do
+    it 'raises a KeyError when no matching keys are found' do
+      expect { events['event'] }.to raise_error KeyError
+    end
+
+    it 'stores the key and value of the proc' do
+      proc                         = -> { 'equal awesome lambda' }
+      events['some.awesome.event'] = proc
+      expect(events['some.awesome.event']).to eq proc
+    end
+  end
+
+  context 'wildcard keys' do
+    let(:proc) { -> { 'Hello from the lambda! o/' } }
+    describe '*' do
+      let(:words) { %w(awesome lame dumb cool) }
+      context 'matches any ONE word' do
+        it 'at the end' do
+          events['some.event.*'] = proc
+          words.each do |word|
+            expect(events["some.event.#{word}"]).to eq proc
+          end
+        end
+
+        it 'in the middle of the name' do
+          events['some.*.event'] = proc
+          words.each do |word|
+            expect(events["some.#{word}.event"]).to eq proc
+          end
+        end
+
+        it 'at the start' do
+          events['*.some.event'] = proc
+          words.each do |word|
+            expect(events["#{word}.some.event"]).to eq proc
+          end
+        end
+
+        it 'in more than one place' do
+          events['some.*.bob.*'] = proc
+          words.each do |word|
+            expect(events["some.#{word}.bob.#{word}"]).to eq(proc)
+          end
+        end
+      end
+      context 'does not match more than ONE word' do
+        it 'some.* does not match some.event.dude' do
+          events['some.*'] = -> {}
+          expect { events['some.event.dude'] }.to raise_error KeyError
+        end
+      end
+    end
+    describe '#' do
+      context 'matches any number of words' do
+        it '# matches all events' do
+          events['#'] = proc
+          %w(some.cool.event event cool.event).each do |event|
+            expect(events[event]).to eq(proc)
+          end
+        end
+
+        it 'matches specific events' do
+          events['#.event'] = proc
+          %w(some.cool.event cool.event).each do |event|
+            expect(events[event]).to eq(proc)
+          end
+          expect { events['event']}.to raise_error KeyError
+        end
+      end
+    end
+  end
+end

data/spec/lib/adapters/rabbitmq/message_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'basquiat/adapters/rabbitmq_adapter'
+
+describe Basquiat::Adapters::RabbitMq::Message do
+  let(:json) do
+    { key: 'value', date: Date.new.iso8601 }.to_json
+  end
+  subject(:message) { Basquiat::Adapters::RabbitMq::Message.new(json) }
+
+  it 'delegates all calls to message hash' do
+    expect(message[:key]).to eq('value')
+  end
+
+  it 'can be JSONified' do
+    expect(MultiJson.dump(message)).to eq(json)
+  end
+
+  it 'exposes the delivery information' do
+    expect { message.di }.to_not raise_error
+    expect { message.delivery_info }.to_not raise_error
+  end
+
+  it 'exposes the properties of the message' do
+    expect { message.props }.to_not raise_error
+  end
+end

data/spec/lib/adapters/rabbitmq/requeue_strategies/basic_acknowledge_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'basquiat/adapters/rabbitmq_adapter'
+
+describe 'Requeue Strategies' do
+  let(:adapter) { Basquiat::Adapters::RabbitMq.new }
+  let(:base_options) do
+    { servers:   [{ host: ENV.fetch('BASQUIAT_RABBITMQ_1_PORT_5672_TCP_ADDR') { 'localhost' },
+                    port: ENV.fetch('BASQUIAT_RABBITMQ_1_PORT_5672_TCP_PORT') { 5672 } }],
+      publisher: { persistent: true } }
+  end
+
+  before(:each) { adapter.adapter_options(base_options) }
+  after(:each) { remove_queues_and_exchanges(adapter) }
+
+  describe 'BasickAcknowledge (aka the default)' do
+    it 'acks a message by default' do
+      adapter.subscribe_to('some.event', ->(_) { 'Everything is AWESOME!' })
+      adapter.listen(block: false)
+
+      adapter.publish('some.event', data: 'stupid message')
+      sleep 0.7 # Wait for the listening thread.
+
+      expect(adapter.session.queue.message_count).to eq(0)
+      expect(adapter.session.queue).to_not have_unacked_messages
+    end
+
+    it 'support declared acks' do
+      adapter.subscribe_to('some.event', ->(msg) { msg.ack })
+      adapter.listen(block: false)
+
+      adapter.publish('some.event', data: 'stupid message')
+      sleep 0.7 # Wait for the listening thread.
+
+      expect(adapter.session.queue.message_count).to eq(0)
+      expect(adapter.session.queue).to_not have_unacked_messages
+    end
+  end
+end

data/spec/lib/adapters/rabbitmq/requeue_strategies/dead_lettering_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+require 'basquiat/adapters/rabbitmq_adapter'
+
+describe Basquiat::Adapters::RabbitMq::DeadLettering do
+  let(:adapter) { Basquiat::Adapters::RabbitMq.new }
+  let(:base_options) do
+    { servers:   [{ host: ENV.fetch('BASQUIAT_RABBITMQ_1_PORT_5672_TCP_ADDR') { 'localhost' },
+                    port: ENV.fetch('BASQUIAT_RABBITMQ_1_PORT_5672_TCP_PORT') { 5672 } }],
+      publisher: { persistent: true } }
+  end
+
+  before(:each) do
+    adapter.adapter_options(base_options)
+    adapter.class.register_strategy :dlx, Basquiat::Adapters::RabbitMq::DeadLettering
+  end
+
+  after(:each) { remove_queues_and_exchanges(adapter) }
+
+  it 'creates the dead letter exchange' do
+    adapter.adapter_options(requeue: { enabled: true, strategy: 'dlx' })
+    adapter.strategy # initialize the strategy
+    channel = adapter.session.channel
+    expect(channel.exchanges.keys).to contain_exactly('my.test_exchange', 'basquiat.dlx')
+  end
+
+  it 'creates and binds a dead letter queue' do
+    # Initialize the strategy since we won't be listening to anything
+    adapter.adapter_options(requeue: { enabled: true, strategy: 'dlx' })
+    session = adapter.session
+    adapter.strategy
+
+    # Grabs the Bunny::Channel from the session for checks
+    channel = session.channel
+    expect(channel.queues.keys).to include('basquiat.dlq')
+    expect(channel.queues['basquiat.dlq'].arguments)
+        .to match(hash_including('x-dead-letter-exchange' => session.exchange.name, 'x-message-ttl' => 1000))
+    expect(session.queue.arguments).to match(hash_including('x-dead-letter-exchange' => 'basquiat.dlx'))
+
+    expect do
+      channel.exchanges['basquiat.dlx'].publish('some message', routing_key: 'some.event')
+      sleep 0.1
+    end.to change { channel.queues['basquiat.dlq'].message_count }.by(1)
+  end
+
+  context 'if it was the queue that unacked the message then' do
+    before(:each) do
+      adapter.adapter_options(requeue: { enabled: true, strategy: 'dlx' })
+      session = adapter.session
+      adapter.strategy # initialize strategy
+
+      queue = session.channel.queue('sample_queue', arguments: { 'x-dead-letter-exchange' => 'basquiat.dlx' })
+      queue.bind(session.exchange, routing_key: 'sample.message')
+
+      queue.subscribe(manual_ack: true, block: false) do |di, _, _|
+        adapter.session.channel.ack(di.delivery_tag)
+      end
+    end
+
+    it 'process the message' do
+      sample = 0
+      adapter.subscribe_to('sample.message', ->(msg) do
+        sample += 1
+        sample == 3 ? msg.ack : msg.unack
+      end)
+
+      adapter.listen(block: false)
+      adapter.publish('sample.message', key: 'message')
+
+      sleep 3
+      expect(sample).to eq(3)
+    end
+
+    it 'else drop the message' do
+      ack_count = 0
+      sample    = 0
+
+      other = Basquiat::Adapters::RabbitMq.new
+      other.adapter_options(base_options.merge(queue: { name: 'other_queue' }, requeue: { enabled: true, strategy: 'dlx' }))
+      other.subscribe_to('sample.message', ->(msg) do
+        ack_count += 1
+      end)
+
+      adapter.subscribe_to('sample.message', ->(msg) do
+        if sample == 3
+          msg.ack
+        else
+          sample += 1;
+          msg.unack
+        end
+      end)
+
+      other.listen(block: false)
+      adapter.listen(block: false)
+      adapter.publish('sample.message', key: 'message')
+
+      sleep 3
+      remove_queues_and_exchanges(other)
+      expect(ack_count).to eq(1)
+      expect(sample).to eq(3)
+    end
+  end
+end