euston-rabbitmq 1.0.1 → 1.0.2

data/spec/euston/command_handler_binder_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path('../../spec_helper.rb', __FILE__)
+if jruby?
+
+module CommandHandlerBinderTesting
+  class AbcHandler
+  end
+end
+
+describe 'command handler binder', :rabbitmq do
+  include Euston::RabbitMq::Exchanges
+  include Euston::RabbitMq::Queues
+
+  let(:handler)           { CommandHandlerBinderTesting::AbcHandler }
+  let(:handler_finder)    { Euston::RabbitMq::HandlerFinder.new.tap { |f| f.namespaces.push 'CommandHandlerBinderTesting' } }
+  let(:binder)            { Euston::RabbitMq::CommandHandlerBinder.new handler_finder.find }
+  let(:bindings)          { @rabbitmqadmin.list_bindings AMQP_OPTS[:vhost] }
+
+  before { binder.ensure_bindings_exist }
+
+  subject { bindings }
+
+  it { should satisfy { |bindings| bindings.any? { |b| b[:routing_key] == 'commands.abc_handler' && b[:destination] == 'command_handlers' } } }
+end
+end

data/spec/euston/event_handler_binder_spec.rb

@@ -0,0 +1,36 @@
+require File.expand_path('../../spec_helper.rb', __FILE__)
+if jruby?
+
+module EventHandlerBinderTesting
+  class XyzHandler
+    include Euston::EventHandler
+
+    consumes :action_abc, 1 do |headers, event| end
+    consumes :action_xyz, 1 do |headers, event| end
+  end
+
+  class ZzzHandler
+    include Euston::EventHandler
+
+    consumes :action_abc, 1 do |headers, event| end
+  end
+end
+
+describe 'event handler binder', :rabbitmq do
+  include Euston::RabbitMq::Exchanges
+  include Euston::RabbitMq::Queues
+
+  let(:handler)           { EventHandlerBinderTesting::XyzHandler }
+  let(:handler_finder)    { Euston::RabbitMq::HandlerFinder.new.tap { |f| f.namespaces.push 'EventHandlerBinderTesting' } }
+  let(:binder)            { Euston::RabbitMq::EventHandlerBinder.new handler_finder.find }
+  let(:bindings)          { @rabbitmqadmin.list_bindings AMQP_OPTS[:vhost] }
+
+  before { binder.ensure_bindings_exist }
+
+  subject { bindings }
+
+  it { should satisfy { |bindings| bindings.any? { |b| b[:routing_key] == 'events.action_abc' && b[:destination] == 'xyz_handler' } } }
+  it { should satisfy { |bindings| bindings.any? { |b| b[:routing_key] == 'events.action_xyz' && b[:destination] == 'xyz_handler' } } }
+  it { should satisfy { |bindings| bindings.any? { |b| b[:routing_key] == 'events.action_abc' && b[:destination] == 'zzz_handler' } } }
+end
+end

data/spec/euston/exchanges_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path('../../spec_helper.rb', __FILE__)
+if jruby?
+
+describe 'exchanges', :rabbitmq do
+  include Euston::RabbitMq::Exchanges
+
+  context 'creating the commands exchange' do
+    subject { get_exchange @channel, :commands }
+    its(:name) { should == 'commands' }
+  end
+
+  context 'creating the events exchange' do
+    subject { get_exchange @channel, :events }
+    its(:name) { should == 'events' }
+  end
+
+  context 'obtaining the same exchange instance' do
+    let(:name)       { "exchange_#{Time.now.to_i}" }
+    let(:instance_1) { get_exchange @channel, name }
+    let(:instance_2) { get_exchange @channel, name }
+
+    subject { instance_1 }
+
+    it { should equal instance_2 }
+  end
+end
+end

data/spec/euston/queues_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path('../../spec_helper.rb', __FILE__)
+if jruby?
+
+describe 'queues', :rabbitmq do
+  include Euston::RabbitMq::Queues
+
+  let(:name) { "queue_#{Time.now.to_i}" }
+
+  context 'creating a queue' do
+    subject { get_queue @channel, name }
+
+    its(:name) { should == name }
+  end
+
+  context 'obtaining the same queue instance' do
+    let(:instance_1) { get_queue(@channel, name) }
+    let(:instance_2) { get_queue(@channel, name) }
+
+    subject { instance_1 }
+
+    it { should equal instance_2 }
+  end
+end
+end

data/spec/euston/retrying_subscription_spec.rb

@@ -0,0 +1,74 @@
+require File.expand_path('../../spec_helper.rb', __FILE__)
+if jruby?
+
+describe 'retrying subscription', :rabbitmq do
+  include Euston::RabbitMq::Exchanges
+  include Euston::RabbitMq::Queues
+
+  let(:failing_queue_name)                    { :failing_handler }
+  let(:failing_message_queue_name)            { :failed_message_handler }
+  let(:events_exchange)                       { get_exchange @channel, :events }
+  let(:failing_handler_queue)                 { get_queue @channel, failing_queue_name }
+  let(:failed_message_handler_queue)          { get_queue @channel, failing_message_queue_name }
+  let(:failing_message_handler_queue_harness) { QueueSubscriptionThreadHarness.new failed_message_handler_queue }
+  let(:outcomes)                              { { :attempts_to_handle => 0, :failure => nil } }
+  let(:message)                               { { :x => 123 } }
+  let(:routing_key)                           { 'events.failing' }
+  let(:error)                                 { 'kablammo' }
+
+  before do
+    failing_handler_queue.bind        events_exchange, :routing_key => routing_key
+    failed_message_handler_queue.bind events_exchange, :routing_key => 'events.message_failed'
+
+    @thread = Thread.new(failing_queue_name, fail_limit, outcomes) do |name, fail_limit, outcomes|
+      channel = AMQP::Channel.new
+      subscription = Euston::RabbitMq::RetryingSubscription.new channel, name
+      subscription.when(:message_received => ->(body) { outcomes[:attempts_to_handle] += 1; raise error if outcomes[:attempts_to_handle] <= fail_limit })
+      subscription.subscribe
+    end
+
+    @thread.abort_on_exception = true
+    failing_message_handler_queue_harness.when(:message_received => ->(body) { outcomes[:failure] = body })
+    failing_message_handler_queue_harness.startup
+
+    events_exchange.publish ActiveSupport::JSON.encode(message), { :key => routing_key }
+
+    sleep 0.25
+  end
+
+  after do
+    failing_message_handler_queue_harness.shutdown
+    @thread.kill
+  end
+
+  subject { outcomes }
+
+  context 'when the message fails once but then succeeds on retry' do
+    let (:fail_limit)          { 1 }
+    its([:attempts_to_handle]) { should == 2 }
+  end
+
+  context 'when the message fails twice but then succeeds on retry' do
+    let (:fail_limit)          { 2 }
+    its([:attempts_to_handle]) { should == 3 }
+  end
+
+  context 'when the message fails 3 times' do
+    let (:fail_limit)          { 3 }
+    its([:attempts_to_handle]) { should == 3 }
+
+    describe 'message failure handler' do
+      subject { outcomes[:failure] }
+      it { should_not be_nil }
+
+      describe 'body' do
+        subject { outcomes[:failure][:body] }
+        its([:message])     { should == message }
+        its([:routing_key]) { should == routing_key }
+        its([:error])       { should == error }
+        its([:backtrace])   { should_not be_nil }
+      end
+    end
+  end
+end
+end

data/spec/rabbitmq_client/queue_spec.rb

@@ -0,0 +1,69 @@
+require File.expand_path('../../spec_helper.rb', __FILE__)
+if jruby?
+
+PUBLISH_OPTS = { :immediate => false,
+                 :mandatory => true,
+                 :persistent => true,
+                 :routing_key => 'messages.xyz' }
+
+describe 'queue', :rabbitmq do
+  let(:queue)    { @channel.queue "test-#{Time.now.to_i}", :durable => true, :nowait => false }
+
+  context 'queue api' do
+    subject { queue }
+
+    it { should respond_to(:safe_subscribe) }
+  end
+
+  describe 'subscription behaviour' do
+    def publish data
+       exchange.publish data, :immediate   => false,
+                              :mandatory   => true,
+                              :persistent  => true,
+                              :routing_key => 'messages.xyz'
+       sleep 0.25
+    end
+
+    let(:exchange) { @channel.topic "test-#{Time.now.to_i - 1}", :durable => true, :nowait => false }
+    let(:harness)  { QueueSubscriptionThreadHarness.new queue }
+
+    before do
+      queue.bind exchange, :routing_key => 'messages.#'
+
+      harness.when(:thread_starting       => ->{ Thread.current[:failures] = 0; Thread.current[:successes] = 0 },
+                   :message_decode_failed => ->(body, error)                   { Thread.current[:failures] += 1 },
+                   :message_failed        => ->(body, error, reactive_message) { Thread.current[:failures] += 1 },
+                   :message_received      => ->(body) { if body[:a] == 'oops'
+                                                          raise 'Something bad happened'
+                                                        else
+                                                          Thread.current[:successes] += 1
+                                                        end })
+      harness.startup
+    end
+
+    after { harness.shutdown }
+
+    subject { harness.thread }
+
+    context 'a non-json message is received' do
+      before { publish ' *897d- -' }
+
+      its([:failures]) { should == 1}
+    end
+
+    context 'a json message is received' do
+      context 'the message is processed successfully' do
+        before { publish JSON.generate({ :a => :b }) }
+
+        its([:successes]) { should == 1 }
+      end
+
+      context 'the message generated an error in the handler' do
+        before { publish JSON.generate({ :a => 'oops' }) }
+
+        its([:failures]) { should == 1 }
+      end
+    end
+  end
+end
+end

data/spec/{constant_loader_spec.rb → reflection/constant_loader_spec.rb}

@@ -1,4 +1,5 @@
-require File.expand_path('../spec_helper.rb', __FILE__)
+require File.expand_path('../../spec_helper.rb', __FILE__)
+if jruby?
 
 module ConstantLoaderTesting
   module SubNamespace
@@ -36,3 +37,4 @@ describe 'constant loader' do
     its([:miss]) { should == true }
   end
 end
+end

data/spec/{handler_finder_spec.rb → reflection/handler_finder_spec.rb}

@@ -1,4 +1,5 @@
-require File.expand_path('../spec_helper.rb', __FILE__)
+require File.expand_path('../../spec_helper.rb', __FILE__)
+if jruby?
 
 module HandlerFinderTesting
   module EmptyNamespace; end
@@ -46,3 +47,4 @@ describe 'handler finder' do
     it { should have(1).items }
   end
 end
+end

data/spec/spec_helper.rb

@@ -1,65 +1,32 @@
-AMQP_OPTS = { :user  => 'euston-rabbitmq-tester',
-              :pass  => 'password',
-              :host  => 'localhost',
-              :vhost => '/euston-rabbitmq-test' }
-
 require 'ap'
 require 'euston-rabbitmq'
-require 'evented-spec' unless RUBY_PLATFORM == 'java'
-require 'faker'
-require_rel 'support'
 
-def trim_array_ends array
-  array.shift
-  array.pop
-  array
+def jruby?
+  RUBY_PLATFORM.to_s == 'java'
 end
 
-module EustonRmqSpec
-  def self.included scope
-    unless RUBY_PLATFORM == 'java'
-      scope.send :include, EventedSpec::AMQPSpec
-      scope.send :default_options, AMQP_OPTS
-      scope.send :default_timeout, 60
-    end
-
-    scope.send :before, :each do
-      vhosts = `rabbitmqctl list_vhosts`.split("\n")
-      vhosts = trim_array_ends vhosts
-      vhost = '/euston-rabbitmq-test'
-
-      `rabbitmqctl delete_vhost #{vhost}` if vhosts.include? vhost
-      `rabbitmqctl add_vhost #{vhost}`
+Safely.configure do |config|
+  config.strategies = [ Safely::Strategy::Log ]
+end
 
-      users = `rabbitmqctl list_users`.split("\n")
-      users = trim_array_ends users
-      users = users.map { |u| u.split("\t").shift }
+if jruby?
+  require_rel 'support'
 
-      user, password = 'euston-rabbitmq-tester', 'password'
+  AMQP_OPTS = { :host  => 'localhost',
+                :pass  => 'password',
+                :user  => 'euston-rabbitmq-test',
+                :vhost => 'euston-rabbitmq-test' }
 
-      `rabbitmqctl delete_user #{user}` if users.include? user
-      `rabbitmqctl add_user #{user} #{password}`
-      `rabbitmqctl set_permissions -p #{vhost} #{user} ".*" ".*" ".*"`
-      `rabbitmqctl set_permissions -p #{vhost} guest ".*" ".*" ".*"` if users.include? 'guest'
-    end
+  RSpec.configure do |config|
+    config.treat_symbols_as_metadata_keys_with_true_values = true
 
-    scope.send :before, :each do
-      connection = Mongo::Connection.new('localhost', 27017)
-      db = connection.db('euston-rabbitmq-test-event-store')
-      db.collections.select { |c| c.name !~ /system/ }.each { |c| db.drop_collection c.name }
-      Euston::RabbitMq.event_store_mongodb = db
+    config.before(:each, :amqp) do
+      initialize_amqp
     end
 
-    if RUBY_PLATFORM == 'java'
-      scope.send :before, :each do
-        AMQP.settings.merge! AMQP_OPTS
-        @channel = AMQP::Channel.new
-      end
-    else
-      scope.send :amqp_before do
-        @channel = AMQP::Channel.new
-        @channel.should be_open
-      end
+    config.before(:each, :rabbitmq) do
+      initialize_rabbitmq
+      initialize_amqp
     end
   end
-end
+end

data/spec/support/filters.rb

@@ -0,0 +1,10 @@
+def initialize_amqp
+  AMQP.settings.merge! AMQP_OPTS
+  @channel = AMQP::Channel.new
+end
+
+def initialize_rabbitmq
+  @rabbitmqadmin = RabbitMqAdmin.new
+  @rabbitmqadmin.initialize_vhost AMQP_OPTS[:vhost]
+  @rabbitmqadmin.initialize_user  AMQP_OPTS[:vhost], AMQP_OPTS[:user], AMQP_OPTS[:pass]
+end

data/spec/support/queue_subscription_thread_harness.rb

@@ -0,0 +1,29 @@
+class QueueSubscriptionThreadHarness
+  include Hollywood
+
+  def initialize queue
+    @queue = queue
+  end
+
+  attr_reader :thread
+
+  def startup
+    cb = Hollywood.instance_method(:callback).bind self
+
+    @thread = Thread.new(cb, @queue) do |cb, queue|
+      cb.call :thread_starting
+
+      queue.when(:message_decode_failed => ->(body, error)                    { cb.call :message_decode_failed, body, error },
+                 :message_failed        => ->(body, error, reactive_message)  { cb.call :message_failed, body, error, reactive_message },
+                 :message_received      => ->(body)                           { cb.call :message_received, body })
+
+      queue.safe_subscribe
+    end
+
+    @thread.abort_on_exception = true
+  end
+
+  def shutdown
+    @thread.kill
+  end
+end

data/spec/support/rabbitmqadmin.rb

@@ -0,0 +1,74 @@
+class RabbitMqAdmin
+  def initialize admin_user = 'guest', admin_password = 'guest'
+    @admin_user     = admin_user
+    @admin_password = admin_password
+  end
+
+  def delete_exchanges
+    list_exchanges.each { |exchange| `#{run vhost} delete exchange name=#{exchange[:name]}` }
+  end
+
+  def delete_queues
+    list_queues.each { |queue| `#{run vhost} delete queue name=#{queue[:name]}` }
+  end
+
+  def initialize_user vhost, user, password, tags = ''
+    `#{run} delete user name=#{user}` if user_exists? user
+    `#{run} declare user name=#{user} password=#{password} tags=#{tags}`
+    add_user_to_vhost vhost, user
+  end
+
+  def initialize_vhost vhost
+    `#{run} delete vhost name=#{vhost}` if vhost_exists? vhost
+    `#{run} declare vhost name=#{vhost}`
+    add_user_to_vhost vhost, @admin_user
+  end
+
+  def run vhost = nil
+    vhost_arg = vhost.nil? ? '' : "-V #{vhost}"
+
+    "rabbitmqadmin -u #{@admin_user} -p #{@admin_password} -f raw_json #{vhost_arg}"
+  end
+
+  def list_bindings vhost
+    parse `#{run vhost} list bindings`
+  end
+
+  def list_exchanges vhost
+    parse `#{run vhost} list exchanges`
+  end
+
+  def list_queues vhost
+    parse `#{run vhost} list queues`
+  end
+
+  def list_users
+    parse `#{run} list users`
+  end
+
+  def list_vhosts
+    parse `#{run} list vhosts`
+  end
+
+  def purge_queues
+    list_queues.each { |queue| `#{run vhost} purge queue name=#{queue[:name]}` }
+  end
+
+  def user_exists? user
+    list_users.any? { |u| u[:name] == user }
+  end
+
+  def vhost_exists? vhost
+    list_vhosts.any? { |h| h[:name] == vhost }
+  end
+
+  private
+
+  def parse json
+    JSON.parse json, :symbolize_names => true
+  end
+
+  def add_user_to_vhost vhost, user
+    `#{run} -V #{vhost} declare permission vhost=#{vhost} user=#{user} configure=\"\.\*\" write=\"\.\*\" read=\"\.\*\"`
+  end
+end