fastly_nsq 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7d55c09a395246d423966f21f8dc1d7ee1b29da7
-  data.tar.gz: d1499d0fee9093424f9134137e80637f0459c490
+  metadata.gz: 6b927006ea75538d36b77a9988c99f159327e72c
+  data.tar.gz: 0ba8e537719bcb36721c65292741d779f9d4da4c
 SHA512:
-  metadata.gz: 646415b3b22eca19dc1cf8882ec7dde9187baee661f802fa73703ef74638ee38c45561489aa747380d48e9357b83a20286c4d29d581b58700dd42848370bf653
-  data.tar.gz: 3549a0dfd59543708a28185358d36cd48a5880eb2695b1b0a99408822267b31139a2700e90964547d179386244d9184e3628f6de0df504665aafe2a0c6d21f12
+  metadata.gz: acaa3eb91200476a12e5f4099ef6515803293007f8643d49cd9651d5f786a6c9e2f36f39ff8086cff38a339a2767346ffada9131bb584db7d6155343d08788ed
+  data.tar.gz: 667ebee86054600dbd16e1f0450f51ce0186d759210c4c4c5e3fbac1f1d84e994124c4496cbcfce2ce6281da1398a5e3e0b8c22e45fdf3b1700511081be008bf

data/README.md

@@ -29,7 +29,7 @@ Please use [GitHub Issues] to report bugs.
 
 `fastly_nsq` is a Ruby Gem
 tested against Rails `>= 4.2`
-and Ruby `>= 2.3.0`.
+and Ruby `>= 2.1.8`.
 
 To get started,
 add `fastly_nsq` to your `Gemfile`
@@ -88,7 +88,7 @@ read messages off of the queue:
 consumer = MessageQueue::Consumer.new(
   topic: 'topic',
   channel: 'channel'
-).connection
+)
 
 consumer.size #=> 1
 message = consumer.pop

data/fastly_nsq.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |gem|
   gem.require_paths = ['lib']
 
   gem.add_development_dependency 'awesome_print', '~> 1.6'
-  gem.add_development_dependency 'bundler', '~> 1.11.2'
+  gem.add_development_dependency 'bundler', '~> 1.12'
   gem.add_development_dependency 'bundler-audit', '~> 0.5.0'
   gem.add_development_dependency 'overcommit', '~> 0.32.0'
   gem.add_development_dependency 'pry-byebug', '~> 3.3'

data/lib/fastly_nsq/fake_message_queue.rb

@@ -1,5 +1,7 @@
 module FakeMessageQueue
   @@logger = Logger.new(nil)
+  @@delay  = 0.5
+  @@queue  = []
 
   def self.queue
     @@queue
@@ -21,6 +23,14 @@ module FakeMessageQueue
     @@logger
   end
 
+  def self.delay
+    @@delay
+  end
+
+  def self.delay=(delay)
+    @@delay = delay
+  end
+
   class Producer
     def initialize(nsqd:, topic:, ssl_context: nil)
     end
@@ -42,22 +52,24 @@ module FakeMessageQueue
   end
 
   class Consumer
-    SECONDS_BETWEEN_QUEUE_CHECKS = 0.5
-
-    def initialize(nsqlookupd:, topic:, channel:, ssl_context: nil)
+    def initialize(nsqlookupd: nil, topic:, channel:, ssl_context: nil)
     end
 
-    def pop
+    def pop(delay = FakeMessageQueue.delay)
       message = nil
 
       until message
         message = queue.pop
-        sleep SECONDS_BETWEEN_QUEUE_CHECKS
+        sleep delay
       end
 
       message
     end
 
+    def pop_without_blocking
+      queue.pop
+    end
+
     def size
       queue.size
     end

data/lib/fastly_nsq/message_queue/consumer.rb

@@ -1,27 +1,27 @@
+require 'forwardable'
+
 class InvalidParameterError < StandardError; end
 
 module MessageQueue
   class Consumer
+    extend Forwardable
+    def_delegator :connection, :pop
+    def_delegator :connection, :pop_without_blocking
+    def_delegator :connection, :size
+    def_delegator :connection, :terminate
+
     def initialize(topic:, channel:, ssl_context: nil)
       @topic = topic
       @channel = channel
       @ssl_context = SSLContext.new(ssl_context)
     end
 
-    def connection
-      @connection ||= consumer.new(params)
-    end
-
-    def terminate
-      @connection.terminate
-    end
-
     private
 
     attr_reader :channel, :topic, :ssl_context
 
-    def consumer
-      Strategy.for_queue::Consumer
+    def connection
+      Strategy.for_queue::Consumer.new(params)
     end
 
     def params

data/lib/fastly_nsq/message_queue/listener.rb

@@ -1,8 +1,10 @@
 module MessageQueue
   class Listener
-    def initialize(topic:, channel:)
-      @topic = topic
-      @channel = channel
+    def initialize(topic:, channel:, processor: nil, consumer: nil)
+      @topic     = topic
+      @channel   = channel
+      @processor = processor || DEFAULT_PROCESSOR
+      @consumer  = consumer  || MessageQueue::Consumer.new(consumer_params)
     end
 
     def go
@@ -26,18 +28,15 @@ module MessageQueue
 
     private
 
-    attr_reader :channel, :topic
+    attr_reader :channel, :topic, :processor, :consumer
+    DEFAULT_PROCESSOR = ->(body, topic) { MessageProcessor.new(message_body: body, topic: topic).go }
 
     def process_one_message
       message = consumer.pop
-      MessageProcessor.new(message_body: message.body, topic: topic).go
+      processor.call(message.body, topic)
       message.finish
     end
 
-    def consumer
-      @consumer ||= MessageQueue::Consumer.new(consumer_params).connection
-    end
-
     def consumer_params
       { topic: topic, channel: channel }
     end

data/lib/fastly_nsq/version.rb

@@ -1,3 +1,3 @@
 module FastlyNsq
-  VERSION = '0.4.0'.freeze
+  VERSION = '0.5.0'.freeze
 end

data/spec/lib/fastly_nsq/fake_message_queue_spec.rb

@@ -88,65 +88,55 @@ RSpec.describe FakeMessageQueue::Message do
 end
 
 RSpec.describe FakeMessageQueue::Consumer do
+  let(:topic)    { 'death_star' }
+  let(:channel)  { 'star_killer_base' }
+  let(:consumer) { FakeMessageQueue::Consumer.new topic: topic, channel: channel }
+
   after do
     FakeMessageQueue.reset!
   end
 
-  describe '#size' do
-    it 'tells you how many messages are in the queue' do
-      FakeMessageQueue.queue = ['hello']
-      topic = 'death_star'
-      channel = 'star_killer_base'
+  describe 'when there are no messages on the queue' do
+    it 'tells you there are 0 messages in the queue' do
+      expect(consumer.size).to eq 0
+    end
 
-      consumer = FakeMessageQueue::Consumer.new(
-        nsqlookupd: ENV.fetch('NSQLOOKUPD_HTTP_ADDRESS'),
-        topic: topic,
-        channel: channel,
-      )
-      queue_size = consumer.size
+    it 'blocks forever (until timeout) from #pop' do
+      FakeMessageQueue.delay = 0.1
+      delay = FakeMessageQueue.delay + 0.1
+
+      expect do
+        Timeout.timeout(delay) do
+          consumer.pop
+        end
+      end.to raise_error(Timeout::Error)
+    end
+
+    it 'returns nil from #pop_without_blocking' do
+      popped_message = consumer.pop_without_blocking
 
-      expect(queue_size).to eq 1
+      expect(popped_message).to be_nil
     end
   end
 
-  describe '#pop' do
-    context 'when there is a message on the queue' do
-      it 'returns the last message off of the queue' do
-        message = FakeMessageQueue::Message.new('hello')
-        FakeMessageQueue.queue = [message]
-        topic = 'death_star'
-        channel = 'star_killer_base'
-
-        consumer = FakeMessageQueue::Consumer.new(
-          nsqlookupd: ENV.fetch('NSQLOOKUPD_HTTP_ADDRESS'),
-          topic: topic,
-          channel: channel,
-        )
-        popped_message = consumer.pop
-
-        expect(popped_message).to eq message
-      end
+  describe 'when there is a message on the queue' do
+    let(:message) { FakeMessageQueue::Message.new 'hello' }
+    before { FakeMessageQueue.queue = [message] }
+
+    it 'tells you there are messages in the queue' do
+      expect(consumer.size).to eq 1
     end
 
-    context 'when there no message on the queue' do
-      it 'blocks for longer than the queue check cycle' do
-        FakeMessageQueue.queue = []
-        topic = 'death_star'
-        channel = 'star_killer_base'
-        delay = FakeMessageQueue::Consumer::SECONDS_BETWEEN_QUEUE_CHECKS + 0.1
-
-        consumer = FakeMessageQueue::Consumer.new(
-          nsqlookupd: ENV.fetch('NSQLOOKUPD_HTTP_ADDRESS'),
-          topic: topic,
-          channel: channel,
-        )
-
-        expect do
-          Timeout.timeout(delay) do
-            consumer.pop
-          end
-        end.to raise_error(Timeout::Error)
-      end
+    it 'returns a message immediately from #pop' do
+      popped_message = consumer.pop
+
+      expect(popped_message).to eq message
+    end
+
+    it 'returns a message immediately from #pop_without_blocking' do
+      popped_message = consumer.pop_without_blocking
+
+      expect(popped_message).to eq message
     end
   end
 

data/spec/lib/fastly_nsq/message_queue/consumer_spec.rb

@@ -1,87 +1,65 @@
 require 'spec_helper'
 
 RSpec.describe MessageQueue::Consumer do
-  describe '#connection' do
-    describe 'when using the real queue', fake_queue: false do
-      it 'returns an instance of the queue consumer' do
-        allow(Nsq::Consumer).to receive(:new)
-        topic = 'death_star'
-        channel = 'star_killer_base'
+  let(:channel)  { 'star_killer_base' }
+  let(:topic)    { 'death_star' }
+  let(:consumer) { MessageQueue::Consumer.new(topic: topic, channel: channel) }
 
-        MessageQueue::Consumer.new(topic: topic, channel: channel).connection
+  def fake_consumer
+    double 'Consumer', connection: nil, terminate: nil, pop: :popped, size: 0
+  end
 
-        expect(Nsq::Consumer).to have_received(:new).
-          with(
-            nsqlookupd: ENV.fetch('NSQLOOKUPD_HTTP_ADDRESS'),
-            topic: topic,
-            channel: channel,
-            ssl_context: nil,
-          ).at_least(:once)
-      end
-    end
+  describe 'when the ENV is set incorrectly' do
+    it 'raises with a helpful error' do
+      allow(ENV).to receive(:[]).with('FAKE_QUEUE').and_return('taco')
 
-    describe 'when using the fake queue', fake_queue: true do
-      it 'returns an instance of the queue consumer' do
-        allow(FakeMessageQueue::Consumer).to receive(:new)
-        topic = 'death_star'
-        channel = 'star_killer_base'
+      expect { consumer.terminate }.to raise_error(InvalidParameterError)
+    end
+  end
 
-        MessageQueue::Consumer.new(topic: topic, channel: channel).connection
+  describe 'when using the real queue', fake_queue: false do
+    before(:example) do
+      @fake_consumer = fake_consumer
+      allow(Nsq::Consumer).to receive(:new).and_return(@fake_consumer)
+    end
 
-        expect(FakeMessageQueue::Consumer).to have_received(:new).
-          with(
-            nsqlookupd: ENV.fetch('NSQLOOKUPD_HTTP_ADDRESS'),
-            topic: topic,
-            channel: channel,
-            ssl_context: nil,
-          ).at_least(:once)
-      end
+    it 'forwards #pop to Nsq::Consumer' do
+      consumer.pop
+      expect(@fake_consumer).to have_received(:pop)
     end
-  end
 
-  describe 'when the ENV is set incorrectly' do
-    it 'raises with a helpful error' do
-      allow(ENV).to receive(:[]).with('FAKE_QUEUE').and_return('taco')
-      topic = 'death_star'
-      channel = 'star_killer_base'
+    it 'forwards #size to Nsq::Consumer' do
+      consumer.size
+      expect(@fake_consumer).to have_received(:size)
+    end
 
-      consumer = MessageQueue::Consumer.new(topic: topic, channel: channel)
+    it 'forwards #terminate to Nsq::Consumer' do
+      consumer.terminate
 
-      expect { consumer.connection }.to raise_error(InvalidParameterError)
+      expect(@fake_consumer).to have_received(:terminate)
     end
   end
 
-  describe '#terminate' do
-    describe 'when using the real queue', fake_queue: false do
-      it 'closes the connection' do
-        consumer = double('Consumer', connection: nil, terminate: nil)
-        allow(Nsq::Consumer).to receive(:new).and_return(consumer)
-        topic = 'death_star'
-        channel = 'star_killer_base'
-        params = { topic: topic, channel: channel }
-
-        live_consumer = MessageQueue::Consumer.new(params)
-        live_consumer.connection
-        live_consumer.terminate
+  describe 'when using the fake queue', fake_queue: true do
+    before(:example) do
+      @fake_consumer = fake_consumer
+      allow(FakeMessageQueue::Consumer).to receive(:new).and_return(@fake_consumer)
+    end
 
-        expect(consumer).to have_received(:terminate)
-      end
+    it 'forwards #pop to FakeMessageQueue::Consumer' do
+      consumer.pop
+      expect(@fake_consumer).to have_received(:pop)
     end
 
-    describe 'when using the fake queue', fake_queue: true do
-      it 'closes the connection' do
-        consumer = double('Consumer', connection: nil, terminate: nil)
-        allow(FakeMessageQueue::Consumer).to receive(:new).and_return(consumer)
-        topic = 'death_star'
-        channel = 'star_killer_base'
-        params = { topic: topic, channel: channel }
+    it 'forwards #size to FakeMessageQueue::Consumer' do
+      consumer.size
+      expect(@fake_consumer).to have_received(:size)
+    end
 
-        live_consumer = MessageQueue::Consumer.new(params)
-        live_consumer.connection
-        live_consumer.terminate
+    it 'forwards #terminate to FakeMessageQueue::Consumer' do
+      consumer.terminate
 
-        expect(consumer).to have_received(:terminate)
-      end
+      expect(@fake_consumer).to have_received(:terminate)
     end
   end
 end

data/spec/lib/fastly_nsq/message_queue/listener_spec.rb

@@ -1,67 +1,87 @@
 require 'spec_helper'
 
 RSpec.describe MessageQueue::Listener do
-  describe '#process_next_message' do
-    it 'pass the topic and channel to the consumer' do
-      allow(SampleMessageProcessor).to receive_message_chain(:new, :go)
-      message = double('Message', finish: nil, body: nil)
-      connection = double('Connection', pop: message, terminate: nil)
-      consumer = double('Consumer', connection: connection)
-      allow(MessageQueue::Consumer).to receive(:new).and_return(consumer)
-      topic = 'testing_topic'
-      channel = 'testing_channel'
-
-      MessageQueue::Listener.new(topic: topic, channel: channel).
-        process_next_message
+  let(:topic)    { 'testing_topic' }
+  let(:channel)  { 'testing_channel' }
+  let(:consumer) { FakeMessageQueue::Consumer.new topic: topic, channel: channel }
+
+  module TestMessageProcessor
+    @@messages_processed = []
+    Message = Struct.new(:body, :topic) do
+      def finish
+        @did_finish = true
+      end
+    end
+
+    def self.call(body, topic)
+      @@messages_processed.push Message.new(body, topic)
+    end
+
+    def self.messages_processed
+      @@messages_processed
+    end
+
+    def self.clear
+      @@messages_processed = []
+    end
+  end
+
+  let(:listener) do
+    MessageQueue::Listener.new topic:     topic,
+                               channel:   channel,
+                               processor: TestMessageProcessor,
+                               consumer:  consumer
+  end
+
+  let(:message)            { TestMessageProcessor::Message.new 'this is message body', topic }
+  let(:messages_processed) { TestMessageProcessor.messages_processed }
+  let(:expected_message)   { TestMessageProcessor::Message.new('this is message body', topic) }
+  let(:expected_messages)  { [expected_message] }
+
+  describe 'instantiating without a consumer' do
+    it 'instantiates a consumer, passing the topic and channel' do
+      allow(MessageQueue::Consumer).to receive(:new)
+
+      MessageQueue::Listener.new topic:     topic,
+                                 channel:   channel,
+                                 processor: TestMessageProcessor,
+                                 consumer:  nil
 
       expect(MessageQueue::Consumer).to have_received(:new).
         with(topic: topic, channel: channel)
     end
+  end
+
+  describe 'when processing next message' do
+    before(:each) { TestMessageProcessor.clear }
+
+    it 'processes the next message' do
+      allow(consumer).to receive(:pop).and_return(message)
+      listener.process_next_message
 
-    it 'processes the message' do
-      process_message = double(go: nil)
-      allow(MessageProcessor).to receive(:new).and_return(process_message)
-      message_body = { data: 'value' }.to_json
-      message = double('Message', finish: nil, body: message_body)
-      connection = double('Connection', pop: message, terminate: nil)
-      consumer = double('Consumer', connection: connection)
-      allow(MessageQueue::Consumer).to receive(:new).and_return(consumer)
-      topic = 'testing_topic'
-      channel = 'testing_channel'
-
-      MessageQueue::Listener.new(topic: topic, channel: channel).
-        process_next_message
-
-      expect(MessageProcessor).to have_received(:new).
-        with(topic: topic, message_body: message_body)
-      expect(process_message).to have_received(:go)
+      expect(messages_processed).to eql(expected_messages)
     end
 
     it 'finishes the message' do
-      allow(SampleMessageProcessor).to receive_message_chain(:new, :go)
-      message = double('Message', finish: nil, body: nil)
-      connection = double('Connection', pop: message, terminate: nil)
-      consumer = double('Consumer', connection: connection)
-      allow(MessageQueue::Consumer).to receive(:new).and_return(consumer)
-      topic = 'testing_topic'
-      channel = 'testing_channel'
-
-      MessageQueue::Listener.new(topic: topic, channel: channel).
-        process_next_message
-
-      expect(message).to have_received(:finish)
+      allow(consumer).to receive(:pop).and_return(message)
+      allow(message).to receive(:finish)
+
+      listener.process_next_message
+
+      expect(message).to have_received(:finish).once
     end
 
     context 'when using the fake queue and it is empty', fake_queue: true do
+      before do
+        FakeMessageQueue.delay = 0.1
+      end
+
       it 'blocks on the process for longer than the check cycle' do
-        topic = 'testing_topic'
-        channel = 'testing_channel'
-        delay = FakeMessageQueue::Consumer::SECONDS_BETWEEN_QUEUE_CHECKS + 0.1
+        delay = FakeMessageQueue.delay + 0.1
 
         expect do
           Timeout.timeout(delay) do
-            MessageQueue::Listener.new(topic: topic, channel: channel).
-              process_next_message
+            listener.process_next_message
           end
         end.to raise_error(Timeout::Error)
       end
@@ -71,14 +91,6 @@ RSpec.describe MessageQueue::Listener do
   describe '#go' do
     describe 'when a SIGTERM is received' do
       it 'closes the consumer connection' do
-        allow(SampleMessageProcessor).to receive_message_chain(:new, :go)
-        message = double(finish: nil, body: nil)
-        connection = double('Connection', pop: message, terminate: nil)
-        consumer = double('Consumer', connection: connection)
-        allow(MessageQueue::Consumer).to receive(:new).and_return(consumer)
-        topic = 'testing_topic'
-        channel = 'testing_channel'
-
         pid = fork do
           MessageQueue::Listener.new(topic: topic, channel: channel).go
         end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fastly_nsq
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Tommy O'Neil
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-21 00:00:00.000000000 Z
+date: 2016-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: awesome_print
@@ -31,14 +31,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.11.2
+        version: '1.12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.11.2
+        version: '1.12'
 - !ruby/object:Gem::Dependency
   name: bundler-audit
   requirement: !ruby/object:Gem::Requirement