queue_worker 1.0.2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6ebdae0e3c3cca5415123d244b360243a9567440
-  data.tar.gz: d56d1a2a8e244f706db17075ec7b7fd02e44f837
+  metadata.gz: f626efd2e37e8b59b15ed2493d51a5ebc789bee3
+  data.tar.gz: 19e29f12f964ca7c94f036ac1d3b35e3fe10a16d
 SHA512:
-  metadata.gz: 6259ec0585962e44646031ef1c83c3eda99c4fc251ac81075cd5391c2dd3610f62847bfede00b56fbe6d7ec7a8dc462ef0b5c0769927f71cc321e0a99e498ad9
-  data.tar.gz: a67fe1b6db0358fe4d44000f6d5299783b7b60555700b7275ec02209f3864d2bc5d733ec217c608e6aab3675ee2475b083e7a34d1115bd6905e895df656356eb
+  metadata.gz: be5e1738bcc633ed4de448738b6cfb8b475ca88c002d58947253e31ef9f48759bcf21fc816403193e099ab9f9ac7dc35f9495002593a2ec44e26c2c447dc4f14
+  data.tar.gz: d1033af1039fcf89cc7347a34b2fa0c88ab555f6090f764d9c9655ac798598fafa9587276fd792588e64f9547acbd55adfecfcb31cd15500f2992a5f750d42f5

data/lib/queue_worker/version.rb

@@ -1,3 +1,3 @@
 class QueueWorker
-  VERSION = '1.0.2'
+  VERSION = '2.0.0'
 end

data/lib/queue_worker.rb

@@ -18,15 +18,16 @@ class QueueWorker
     end
   end
 
-  attr_writer :client
+  attr_writer :client, :log
   attr_accessor :queue, :handler
 
   # @param [String] queue_name the queue to pub/sub
-  # @param [Stomp::Client] client that can communicate with ActiveMQ
-  def initialize(queue_name = nil, client = nil)
+  # @param [#info, #warn, #error] log
+  # @param [Proc] block to handle the subscription callback
+  def initialize(queue_name = nil, log = nil, &block)
     @queue = queue_name
-    @client = client
-    @handler = proc { |args, message| load_handler_class(message.headers['destination']).new(args).call }
+    @log = log
+    @handler = block || proc { |body| Kernel.const_get(body[:class]).call(body[:args]) }
   end
 
   # = Publish one or more messages to a queue
@@ -68,11 +69,12 @@ class QueueWorker
 
   # = Subscribe (listen) to a queue
   #
+  # @param [String] queue_name specify the queue name
   # @param [Integer] size specify the number of messages the block may receive without sending +ack+
   # @param [Proc] block to handle the subscribe callback
-  def subscribe(size = 1, &block)
-    callback = block || method(:default_subscribe_callback)
-    client.subscribe("/queue/#{queue}", { :ack => 'client', 'activemq.prefetchSize' => size }, &callback)
+  def subscribe(queue_name = nil, size = 1, &block)
+    callback = block || method(:call)
+    client.subscribe("/queue/#{queue_name || queue}", { :ack => 'client', 'activemq.prefetchSize' => size }, &callback)
   end
 
   # = Subscribe to a queue for a limited time
@@ -82,7 +84,7 @@ class QueueWorker
   # @param [Proc] block to handle the subscribe callback
   def subscribe_with_timeout(duration, size = 1, &block)
     Timeout::timeout(duration) do
-      subscribe(size, &block)
+      subscribe(nil, size, &block)
       join
     end
   rescue Timeout::Error
@@ -90,13 +92,13 @@ class QueueWorker
   end
 
   # = Unsubscribe from the current queue
-  def unsubscribe
-    client.unsubscribe("/queue/#{queue}")
+  def unsubscribe(queue_name = nil)
+    client.unsubscribe("/queue/#{queue_name || queue}")
   end
 
   # = Unsubscribe from the current queue and close the connection
-  def quit
-    unsubscribe
+  def quit(queue_name = nil)
+    unsubscribe(queue_name)
     close
   end
 
@@ -109,34 +111,14 @@ class QueueWorker
   #
   # @param [Stomp::Message] message is the container object Stomp gives us for what is really a "frame" or package from the queue
   def call(message)
-    handler.call(JSON.parse(message.body, symbolize_names: true), message)
+    if message.command == 'MESSAGE'
+      handler.call(JSON.parse(message.body, symbolize_names: true), message)
+    end
   rescue => e
     log.error(e.message) { "\n#{e.backtrace.inspect}" }
   ensure
     ack(message)
-    log.info('Processed') { message }
-  end
-
-  #
-  # Private
-  #
-
-  def default_subscribe_callback(message)
-    if message.command == 'MESSAGE'
-      if message.body == 'UNSUBSCRIBE'
-        unsubscribe
-      else
-        call(message)
-      end
-    end
-  end
-
-  # = Converts the queue name to a constant
-  #
-  # @param [String] destination_queue
-  #
-  def load_handler_class(destination_queue)
-    destination_queue.gsub(%r!^/?queue/!, '').camelize.constantize
+    log.info('Processed') { "#{message.headers['message-id']} for #{message.headers['destination']}" }
   end
 
   def client

data/spec/lib/queue_worker_spec.rb

@@ -2,8 +2,11 @@ require 'spec_helper'
 
 describe QueueWorker, slow: true do
   let(:queue_name) { 'queue_foo' }
+  let(:log) { Logger.new(STDOUT).tap { |x| x.level = Logger::ERROR } }
 
-  subject { described_class.new(queue_name, double(Stomp::Client)) }
+  subject { described_class.new(queue_name, log) }
+
+  before { allow(subject).to receive(:client).and_return(double(Stomp::Client)) }
 
   describe '.publish' do
     let(:message) { { id: 101 } }
@@ -37,40 +40,42 @@ describe QueueWorker, slow: true do
   end
 
   describe '#subscribe' do
-    let(:headers) { { :ack => 'client', 'activemq.prefetchSize' => 1 } }
-
-    context "when message command is not 'MESSAGE'" do
-      let(:message) { Struct.new(:command).new('PING') }
+    let(:size) { 1 }
+    let(:headers) { { :ack => 'client', 'activemq.prefetchSize' => size } }
+    let(:message) { Struct.new(:command, :body).new('MESSAGE', '{}') }
+
+    it 'pass the -message- to +call+' do
+      expect(subject.client).to receive(:subscribe).with("/queue/#{queue_name}", headers).and_yield(message)
+      expect(subject).to receive(:call).with(message)
+      subject.subscribe
+    end
 
-      it 'does nothing' do
-        expect(subject.client).to receive(:subscribe).with("/queue/#{queue_name}", headers).and_yield(message)
-        expect(subject).to_not receive(:unsubscribe)
-        expect(subject).to_not receive(:call)
-        subject.subscribe
+    context 'when -queue_name- is given' do
+      it 'subscribes to the specified queue' do
+        expect(subject.client).to receive(:subscribe).with("/queue/test", headers).and_yield(message)
+        expect(subject).to receive(:call).with(message)
+        subject.subscribe('test')
       end
     end
 
-    context "when message command is 'MESSAGE'" do
-      let(:message) { Struct.new(:command, :body).new('MESSAGE', nil) }
-
-      context "when message body is 'UNSUBSCRIBE'" do
-        before { message.body = 'UNSUBSCRIBE' }
+    context 'when -size- is given' do
+      let(:size) { 5 }
 
-        it 'unsubscribes from the -queue-' do
-          expect(subject.client).to receive(:subscribe).with("/queue/#{queue_name}", headers).and_yield(message)
-          expect(subject).to receive(:unsubscribe)
-          subject.subscribe
-        end
+      it 'fetches the specified number of messages' do
+        expect(subject.client).to receive(:subscribe).with("/queue/#{queue_name}", headers).and_yield(message)
+        expect(subject).to receive(:call).with(message)
+        subject.subscribe(nil, size)
       end
+    end
 
-      context "when message body is JSON" do
-        before { message.body = '{}' }
+    context 'when a block is given' do
+      let(:handler_double) { double('Handler block') }
 
-        it 'pass the -message- to +call+' do
-          expect(subject.client).to receive(:subscribe).with("/queue/#{queue_name}", headers).and_yield(message)
-          expect(subject).to receive(:call).with(message)
-          subject.subscribe
-        end
+      it 'yields the given block instead of calling +call+' do
+        expect(subject.client).to receive(:subscribe).with("/queue/#{queue_name}", headers).and_yield(message)
+        expect(handler_double).to receive(:call).with(message)
+        expect(subject).to_not receive(:call)
+        subject.subscribe { |message| handler_double.call(message) }
       end
     end
   end
@@ -83,12 +88,31 @@ describe QueueWorker, slow: true do
   end
 
   describe '#call' do
-    let(:message) { double("Stomp::Message", body: %({"name":"trip_advisor"}), headers: { 'destination' => '/queue/null' }) }
+    let(:message) { double("Stomp::Message", body: %({"class":"QueueWorker", "args": [101]}), command: 'MESSAGE', headers: { 'destination' => '/queue/null' }) }
 
-    it 'acknowledges the message and passes it along to the handler class' do
-      expect(subject.handler).to receive(:call).with({ name: 'trip_advisor' }, message)
-      expect(subject).to receive(:ack).with(message)
-      subject.call(message)
+    context "when message command is 'MESSAGE'" do
+      it 'acknowledges the message and passes it along to the handler' do
+        expect(subject.handler).to receive(:call).with({ class: 'QueueWorker', args: [101] }, message)
+        expect(subject).to receive(:ack).with(message)
+        subject.call(message)
+      end
+    end
+
+    context "when message command is not 'MESSAGE'" do
+      let(:message) { Struct.new(:command).new('PING') }
+
+      it 'does nothing' do
+        expect(subject.handler).to_not receive(:call)
+        expect(subject).to receive(:ack).with(message)
+        subject.call(message)
+      end
+    end
+
+    context 'default handler' do
+      it 'loads the :class and calls it with the message body' do
+        expect(QueueWorker).to receive(:call).with([101])
+        subject.handler.call(JSON.parse(message.body, symbolize_names: true))
+      end
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: queue_worker
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 2.0.0
 platform: ruby
 authors:
 - Ryan Buckley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-29 00:00:00.000000000 Z
+date: 2014-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler