fastly_nsq 0.6.0 → 0.7.0

data/spec/lib/fastly_nsq/rake_task_spec.rb

@@ -1,10 +1,15 @@
 require 'spec_helper'
 require 'fastly_nsq/rake_task'
 
-RSpec.describe MessageQueue::RakeTask do
+RSpec.describe FastlyNsq::RakeTask do
   before(:each) do
     Rake::Task.clear
-    allow_any_instance_of(MessageQueue::RakeTask).to receive(:output) { nil }
+    @original_logger = FastlyNsq.logger
+    FastlyNsq.logger = Logger.new(nil)
+  end
+
+  after do
+    FastlyNsq.logger = @original_logger
   end
 
   describe 'when defining tasks' do
@@ -12,7 +17,7 @@ RSpec.describe MessageQueue::RakeTask do
       it 'creates a task with the default name' do
         default_task_name = 'begin_listening'
 
-        MessageQueue::RakeTask.new
+        FastlyNsq::RakeTask.new
         defined_tasks = Rake::Task.tasks
         first_task_name = defined_tasks.first.name
 
@@ -24,7 +29,7 @@ RSpec.describe MessageQueue::RakeTask do
       it 'creates a task with the provided name' do
         task_name = 'test_name'
 
-        MessageQueue::RakeTask.new(task_name.to_sym)
+        FastlyNsq::RakeTask.new(task_name.to_sym)
         defined_tasks = Rake::Task.tasks
         first_task_name = defined_tasks.first.name
 
@@ -34,95 +39,103 @@ RSpec.describe MessageQueue::RakeTask do
   end
 
   describe 'when running tasks' do
-    context 'when multiple topics are defined' do
-      it 'creates a listener for each' do
-        channel = 'clown_generating_service'
-        topics = %w(customer_created customer_now_awesome)
-        allow(SampleMessageProcessor).to receive(:topics).and_return(topics)
-        message_queue_listener = double('listener', go: nil)
-        allow(MessageQueue::Listener).to receive(:new).
-          and_return(message_queue_listener)
-
-        MessageQueue::RakeTask.new(:begin_listening, [:channel])
-        Rake::Task['begin_listening'].execute(channel: channel)
-
-        topics.each do |topic|
-          expect(MessageQueue::Listener).to have_received(:new).
-            with(topic: topic, channel: channel)
-        end
+    context 'when no channel is provided' do
+      it 'raises an error' do
+        expect do
+          FastlyNsq::RakeTask.new(:begin_listening, [:channel])
+          Rake::Task['begin_listening'].execute
+        end.to raise_error(ArgumentError, /required.+channel/)
       end
     end
 
-    it 'listens to the command-line-provided channel' do
-      channel = 'salesforce'
-      topics = ['customer_created']
-      allow(SampleMessageProcessor).to receive(:topics).and_return(topics)
-
-      message_queue_listener = double('listener', go: nil)
-      expect(MessageQueue::Listener).to receive(:new).
-        with(topic: topics.first, channel: channel).
-        and_return(message_queue_listener)
+    context 'when no topics are provided' do
+      it 'raises an error' do
+        channel = 'best_server_number_1'
 
-      MessageQueue::RakeTask.new(:begin_listening, [:channel])
-      Rake::Task['begin_listening'].execute(channel: channel)
+        expect do
+          FastlyNsq::RakeTask.new(:begin_listening, [:channel])
+          Rake::Task['begin_listening'].execute(channel: channel)
+        end.to raise_error(ArgumentError, /required.+topics/)
+      end
     end
 
-    it 'runs with specified channel if a block is given' do
-      channel = 'send_new_customers_a_sticker_service'
-      topics = ['customer_created']
-      allow(SampleMessageProcessor).to receive(:topics).and_return(topics)
+    context 'when a channel and topics are defined' do
+      let(:channel)  { 'clown_generating_service' }
+      let(:topics)   { { customer_created: :fake_processor } }
+      let(:listener) { class_double FastlyNsq::Listener, listen_to: nil }
+
+      it 'configures via a block if one is given' do
+        FastlyNsq::RakeTask.new(:begin_listening, [:channel, :topics]) do |task|
+          task.channel  = channel
+          task.topics   = topics
+          task.listener = listener
+        end
 
-      message_queue_listener = double('listener', go: nil)
-      expect(MessageQueue::Listener).to receive(:new).
-        with(topic: topics.first, channel: channel).
-        and_return(message_queue_listener)
+        Rake::Task['begin_listening'].execute
 
-      MessageQueue::RakeTask.new do |task|
-        task.channel = channel
+        expect(listener).to have_received(:listen_to).
+          with(hash_including(topic: :customer_created, channel: channel))
       end
-      Rake::Task['begin_listening'].execute(channel: channel)
-    end
 
-    it 'prefers inline channel definition over block assignments' do
-      default_channel = 'throw_a_huge_pizza_party_service'
-      new_channel = 'send_balloons_to_customer_service'
-      topics = ['customer_created']
-      allow(SampleMessageProcessor).to receive(:topics).and_return(topics)
+      it 'prefers inline channel definition over block assignments' do
+        new_channel = 'send_balloons_to_customer_service'
+
+        FastlyNsq::RakeTask.new(:begin_listening, [:channel, :topics]) do |task|
+          task.channel  = channel
+          task.topics   = topics
+          task.listener = listener
+        end
 
-      message_queue_listener = double('listener', go: nil)
-      expect(MessageQueue::Listener).to receive(:new).
-        with(topic: topics.first, channel: new_channel).
-        and_return(message_queue_listener)
+        Rake::Task['begin_listening'].execute(channel: new_channel, topics: topics, listener: listener)
 
-      MessageQueue::RakeTask.new(:begin_listening, [:channel]) do |task|
-        task.channel = default_channel
+        expect(listener).to have_received(:listen_to).
+          with(hash_including(topic: :customer_created, channel: channel))
       end
-      Rake::Task['begin_listening'].execute(channel: new_channel)
-    end
 
-    context 'when no channel is provided' do
-      it 'raises an error' do
-        topics = ['customer_created']
-        allow(SampleMessageProcessor).to receive(:topics).and_return(topics)
+      it 'configures a listener for each topic if there are multiple' do
+        topics = %w(foo bar baz quuz etc)
+
+        FastlyNsq::RakeTask.new(:begin_listening, [:channel, :topics, :listener])
+        Rake::Task['begin_listening'].execute(channel: channel, topics: topics, listener: listener)
+
+        topics.each do |(topic, processor)|
+          expect(listener).to have_received(:listen_to).
+            with(hash_including(topic: topic, channel: channel, processor: processor))
+        end
+      end
+
+      context 'and preprocessor is defined' do
+        it 'passes preprocessor to the listener' do
+          FastlyNsq::RakeTask.new(:begin_listening) do |task|
+            task.channel      = channel
+            task.topics       = topics
+            task.listener     = listener
+            task.preprocessor = :noop
+          end
 
-        expect do
-          MessageQueue::RakeTask.new(:begin_listening, [:channel])
           Rake::Task['begin_listening'].execute
-        end.to raise_error(ArgumentError, /channel is required/)
+
+          expect(listener).to have_received(:listen_to).
+            with(hash_including(preprocessor: :noop))
+        end
       end
-    end
 
-    context 'when MessageProcessor.topics is not defined' do
-      it 'raises an error' do
-        channel = 'best_server_number_1'
-        error_message = /MessageProcessor.topics is not defined/
-        allow(SampleMessageProcessor).to receive(:topics).
-          and_raise(NoMethodError, "undefined method `topics'")
+      context 'and logger is defined' do
+        let(:logger) { double 'Logger', info: nil }
 
-        expect do
-          MessageQueue::RakeTask.new(:begin_listening, [:channel])
-          Rake::Task['begin_listening'].execute(channel: channel)
-        end.to raise_error(ArgumentError, error_message)
+        it 'passes logger to the listener' do
+          FastlyNsq::RakeTask.new(:begin_listening) do |task|
+            task.channel  = channel
+            task.topics   = topics
+            task.listener = listener
+            task.logger   = logger
+          end
+
+          Rake::Task['begin_listening'].execute
+
+          expect(listener).to have_received(:listen_to).
+            with(hash_including(logger: logger))
+        end
       end
     end
   end

data/spec/lib/fastly_nsq/ssl_context_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
-RSpec.describe SSLContext do
+RSpec.describe FastlyNsq::SSLContext do
   describe 'when SSL ENV variables are not set' do
     describe '.to_h' do
       it 'returns nil when initialized without parameters' do
-        context = SSLContext.new
+        context = FastlyNsq::SSLContext.new
 
         expect(context.to_h).to be_nil
       end
@@ -15,7 +15,7 @@ RSpec.describe SSLContext do
           certificate: 'certificate',
           ca_certificate: 'ca_certificate',
         }
-        context = SSLContext.new(ssl_context_hash)
+        context = FastlyNsq::SSLContext.new(ssl_context_hash)
 
         expect(context.to_h).to eq(ssl_context_hash)
       end
@@ -25,7 +25,7 @@ RSpec.describe SSLContext do
           key: 'key',
           certificate: 'certificate',
         }
-        context = SSLContext.new(ssl_context_hash)
+        context = FastlyNsq::SSLContext.new(ssl_context_hash)
         ca_certificate = context.to_h[:ca_certificate]
 
         expect(ca_certificate).to be_nil
@@ -53,7 +53,7 @@ RSpec.describe SSLContext do
           certificate: ENV['NSQ_SSL_CERTIFICATE'],
           ca_certificate: ENV['NSQ_SSL_CA_CERTIFICATE'],
         }
-        context = SSLContext.new
+        context = FastlyNsq::SSLContext.new
 
         expect(context.to_h).to eq(expected_hash)
       end
@@ -65,7 +65,7 @@ RSpec.describe SSLContext do
           certificate: passed_certificate,
           ca_certificate: ENV['NSQ_SSL_CA_CERTIFICATE'],
         }
-        context = SSLContext.new(certificate: passed_certificate)
+        context = FastlyNsq::SSLContext.new(certificate: passed_certificate)
 
         expect(context.to_h).to eq(expected_hash)
       end

data/spec/lib/fastly_nsq/{message_queue/strategy_spec.rb → strategy_spec.rb}

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
-RSpec.describe MessageQueue::Strategy do
+RSpec.describe FastlyNsq::Strategy do
   describe 'when FAKE_QUEUE is falsy' do
     it 'returns the strategy based on the ENV variable' do
       [false, 0, '0', 'false', 'FALSE', 'off', 'OFF', nil].each do |no|
         allow(ENV).to receive(:[]).with('FAKE_QUEUE').and_return(no)
 
-        strategy = MessageQueue::Strategy.for_queue
+        strategy = FastlyNsq::Strategy.for_queue
 
         expect(strategy).to eq Nsq
       end
@@ -18,9 +18,9 @@ RSpec.describe MessageQueue::Strategy do
       [true, 1, '1', 'true', 'TRUE', 'on', 'ON'].each do |yes|
         allow(ENV).to receive(:[]).with('FAKE_QUEUE').and_return(yes)
 
-        strategy = MessageQueue::Strategy.for_queue
+        strategy = FastlyNsq::Strategy.for_queue
 
-        expect(strategy).to eq FakeMessageQueue
+        expect(strategy).to eq FastlyNsq::FakeBackend
       end
     end
   end
@@ -29,7 +29,8 @@ RSpec.describe MessageQueue::Strategy do
     it 'raises with a helpful error' do
       allow(ENV).to receive(:[]).with('FAKE_QUEUE').and_return('taco')
 
-      expect { MessageQueue::Strategy.for_queue }.to raise_error(InvalidParameterError)
+      expect { FastlyNsq::Strategy.for_queue }.to \
+        raise_error(FastlyNsq::Strategy::InvalidParameterError)
     end
   end
 end

data/spec/lib/fastly_nsq_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+RSpec.describe FastlyNsq do
+  module TestStrategy; end
+
+  it 'allows the logger to be set and retrieved' do
+    logger = Logger.new(STDOUT)
+    FastlyNsq.logger = logger
+
+    expect(FastlyNsq.logger).to eq logger
+  end
+
+  it 'returns the current Strategy' do
+    allow(FastlyNsq::Strategy).to receive(:for_queue).and_return(TestStrategy)
+
+    expect(FastlyNsq.strategy).to eql(TestStrategy)
+  end
+end

data/spec/spec_helper.rb

@@ -2,7 +2,6 @@ require 'fastly_nsq'
 require 'awesome_print'
 require 'pry-byebug'
 
-require_relative '../lib/fastly_nsq/sample_message_processor'
 require_relative 'support/env_helpers'
 
 RSpec.configure do |config|
@@ -27,13 +26,9 @@ RSpec.configure do |config|
     config.default_formatter = 'doc'
   end
 
-  config.before(:suite) do
-    MessageProcessor = SampleMessageProcessor
-  end
-
   config.before(:each) do
     load_sample_environment_variables
-    FakeMessageQueue.reset!
+    FastlyNsq::FakeBackend.reset!
   end
 
   config.around(:each, fake_queue: true) do |example|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fastly_nsq
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Tommy O'Neil
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-13 00:00:00.000000000 Z
+date: 2016-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: awesome_print
@@ -195,26 +195,25 @@ files:
 - examples/Rakefile
 - fastly_nsq.gemspec
 - lib/fastly_nsq.rb
-- lib/fastly_nsq/fake_message_queue.rb
-- lib/fastly_nsq/message_queue.rb
-- lib/fastly_nsq/message_queue/consumer.rb
-- lib/fastly_nsq/message_queue/listener.rb
-- lib/fastly_nsq/message_queue/producer.rb
-- lib/fastly_nsq/message_queue/strategy.rb
+- lib/fastly_nsq/consumer.rb
+- lib/fastly_nsq/fake_backend.rb
+- lib/fastly_nsq/listener.rb
+- lib/fastly_nsq/message.rb
+- lib/fastly_nsq/producer.rb
 - lib/fastly_nsq/rake_task.rb
-- lib/fastly_nsq/sample_message_processor.rb
 - lib/fastly_nsq/ssl_context.rb
+- lib/fastly_nsq/strategy.rb
 - lib/fastly_nsq/version.rb
-- spec/lib/fastly_nsq/fake_message_queue_spec.rb
+- spec/lib/fastly_nsq/consumer_spec.rb
+- spec/lib/fastly_nsq/fake_backend_spec.rb
 - spec/lib/fastly_nsq/fastly_nsq_spec.rb
-- spec/lib/fastly_nsq/message_queue/consumer_spec.rb
-- spec/lib/fastly_nsq/message_queue/listener_spec.rb
-- spec/lib/fastly_nsq/message_queue/producer_spec.rb
-- spec/lib/fastly_nsq/message_queue/strategy_spec.rb
-- spec/lib/fastly_nsq/message_queue_spec.rb
+- spec/lib/fastly_nsq/listener_spec.rb
+- spec/lib/fastly_nsq/message_spec.rb
+- spec/lib/fastly_nsq/producer_spec.rb
 - spec/lib/fastly_nsq/rake_task_spec.rb
-- spec/lib/fastly_nsq/sample_message_processor_spec.rb
 - spec/lib/fastly_nsq/ssl_context_spec.rb
+- spec/lib/fastly_nsq/strategy_spec.rb
+- spec/lib/fastly_nsq_spec.rb
 - spec/spec_helper.rb
 - spec/support/env_helpers.rb
 homepage: https://github.com/fastly/fastly-nsq

data/lib/fastly_nsq/fake_message_queue.rb

@@ -1,98 +0,0 @@
-module FakeMessageQueue
-  @@logger = Logger.new(nil)
-  @@delay  = 0.5
-  @@queue  = []
-
-  def self.queue
-    @@queue
-  end
-
-  def self.queue=(message)
-    @@queue = message
-  end
-
-  def self.reset!
-    self.queue = []
-  end
-
-  def self.logger=(logger)
-    @@logger = logger
-  end
-
-  def self.logger
-    @@logger
-  end
-
-  def self.delay
-    @@delay
-  end
-
-  def self.delay=(delay)
-    @@delay = delay
-  end
-
-  class Producer
-    def initialize(topic:, nsqd: nil, ssl_context: nil)
-    end
-
-    def write(string)
-      message = Message.new(string)
-      queue.push(message)
-    end
-
-    def terminate
-      # noop
-    end
-
-    private
-
-    def queue
-      FakeMessageQueue.queue
-    end
-  end
-
-  class Consumer
-    def initialize(nsqlookupd: nil, topic:, channel:, ssl_context: nil)
-    end
-
-    def pop(delay = FakeMessageQueue.delay)
-      message = nil
-
-      until message
-        message = queue.pop
-        sleep delay
-      end
-
-      message
-    end
-
-    def pop_without_blocking
-      queue.pop
-    end
-
-    def size
-      queue.size
-    end
-
-    def terminate
-      # noop
-    end
-
-    private
-
-    def queue
-      FakeMessageQueue.queue
-    end
-  end
-
-  class Message
-    attr_reader :body
-
-    def initialize(body)
-      @body = body
-    end
-
-    def finish
-    end
-  end
-end

data/lib/fastly_nsq/message_queue/listener.rb

@@ -1,49 +0,0 @@
-module MessageQueue
-  class Listener
-    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
-      Signal.trap('INT') do
-        shutdown
-      end
-
-      Signal.trap('TERM') do
-        shutdown
-      end
-
-      loop do
-        process_one_message
-      end
-    end
-
-    def process_next_message
-      process_one_message
-      consumer.terminate
-    end
-
-    private
-
-    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
-      processor.call(message.body, topic)
-      message.finish
-    end
-
-    def consumer_params
-      { topic: topic, channel: channel }
-    end
-
-    def shutdown
-      consumer.terminate
-      exit
-    end
-  end
-end

data/lib/fastly_nsq/message_queue/strategy.rb

@@ -1,34 +0,0 @@
-module MessageQueue::Strategy
-  module_function
-
-  def for_queue
-    real_queue || fake_queue || error
-  end
-
-  private_class_method
-
-  ERR_MESSAGE = "You must set ENV['FAKE_QUEUE'] to either true or false".freeze
-
-  def error
-    raise InvalidParameterError, ERR_MESSAGE
-  end
-
-  FALSY_VALUES  = [false, 0, '0', 'false', 'FALSE', 'off', 'OFF', nil].freeze
-  TRUTHY_VALUES = [true, 1, '1', 'true', 'TRUE', 'on', 'ON'].freeze
-
-  def fake_queue
-    FakeMessageQueue if should_use_fake_queue?
-  end
-
-  def should_use_real_queue?
-    FALSY_VALUES.include? ENV['FAKE_QUEUE']
-  end
-
-  def real_queue
-    Nsq if should_use_real_queue?
-  end
-
-  def should_use_fake_queue?
-    TRUTHY_VALUES.include? ENV['FAKE_QUEUE']
-  end
-end

data/lib/fastly_nsq/message_queue.rb

@@ -1,21 +0,0 @@
-require 'nsq'
-require_relative 'fake_message_queue'
-require_relative 'message_queue/listener'
-require_relative 'message_queue/producer'
-require_relative 'message_queue/consumer'
-require_relative 'message_queue/strategy'
-require_relative 'ssl_context'
-
-module MessageQueue
-  def self.logger=(logger)
-    strategy.logger = logger
-  end
-
-  def self.logger
-    strategy.logger
-  end
-
-  def self.strategy
-    Strategy.for_queue
-  end
-end

data/lib/fastly_nsq/sample_message_processor.rb

@@ -1,50 +0,0 @@
-class HeartbeatWorker
-  def self.perform_async(_data)
-    # noop
-  end
-end
-
-class UnknownMessageWorker
-  def self.perform_async(_data)
-    # noop
-  end
-end
-
-class SampleMessageProcessor
-  TOPIC_TO_WORKER_MAP = {
-    'heartbeat' => HeartbeatWorker,
-  }.freeze
-
-  def self.topics
-    TOPIC_TO_WORKER_MAP.keys
-  end
-
-  def initialize(message_body:, topic:)
-    @message_body = message_body
-    @topic = topic
-  end
-
-  def go
-    process_message_body
-  end
-
-  private
-
-  attr_reader :message_body, :topic
-
-  def process_message_body
-    message_processor.perform_async(message_data)
-  end
-
-  def message_processor
-    TOPIC_TO_WORKER_MAP.fetch(topic, UnknownMessageWorker)
-  end
-
-  def message_data
-    parsed_message_body['data']
-  end
-
-  def parsed_message_body
-    JSON.parse(message_body)
-  end
-end