fastly_nsq 0.1.4 → 0.2.0

data/{test/lib/fastly_nsq/fastly_nsq_test.rb → spec/lib/fastly_nsq/fastly_nsq_spec.rb}

@@ -1,10 +1,10 @@
-require 'test_helper'
+require 'spec_helper'
 require 'fastly_nsq'
 
-describe FastlyNsq do
+RSpec.describe FastlyNsq do
   it 'has a version number' do
     version = FastlyNsq.const_get('VERSION')
 
-    assert(!version.empty?, 'should have a VERSION constant')
+    expect(version).not_to be_empty
   end
 end

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

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+RSpec.describe MessageQueue::Consumer do
+  describe '#connection' do
+    describe 'when using the real queue' do
+      it 'returns an instance of the queue consumer' do
+        use_real_connection do
+          allow(Nsq::Consumer).to receive(:new)
+          topic = 'death_star'
+          channel = 'star_killer_base'
+
+          MessageQueue::Consumer.new(topic: topic, channel: channel).connection
+
+          expect(Nsq::Consumer).to have_received(:new).
+            with(
+              nsqlookupd: ENV.fetch('NSQLOOKUPD_HTTP_ADDRESS'),
+              topic: topic,
+              channel: channel,
+          ).at_least(:once)
+        end
+      end
+    end
+
+    describe 'when using the fake queue' do
+      it 'returns an instance of the queue consumer' do
+        use_fake_connection do
+          allow(FakeMessageQueue::Consumer).to receive(:new)
+          topic = 'death_star'
+          channel = 'star_killer_base'
+
+          MessageQueue::Consumer.new(topic: topic, channel: channel).connection
+
+          expect(FakeMessageQueue::Consumer).to have_received(:new).
+            with(
+              nsqlookupd: ENV.fetch('NSQLOOKUPD_HTTP_ADDRESS'),
+              topic: topic,
+              channel: channel,
+          ).at_least(:once)
+        end
+      end
+    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'
+
+      consumer = MessageQueue::Consumer.new(topic: topic, channel: channel)
+
+      expect{ consumer.connection }.to raise_error(InvalidParameterError)
+    end
+  end
+
+  describe '#terminate' do
+    describe 'when using the real queue' do
+      it 'closes the connection' do
+        use_real_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
+
+          expect(consumer).to have_received(:terminate)
+        end
+      end
+    end
+
+    describe 'when using the fake queue' do
+      it 'closes the connection' do
+        use_fake_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 }
+
+          live_consumer = MessageQueue::Consumer.new(params)
+          live_consumer.connection
+          live_consumer.terminate
+
+          expect(consumer).to have_received(:terminate)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+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 = 'minitest'
+      channel = 'northstar'
+
+      MessageQueue::Listener.new(topic: topic, channel: channel).
+        process_next_message
+
+      expect(MessageQueue::Consumer).to have_received(:new).
+        with(topic: topic, channel: channel)
+    end
+
+    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 = 'minitest'
+      channel = 'northstar'
+
+      MessageQueue::Listener.new(topic: topic, channel: channel).
+        process_next_message
+
+      expect(MessageProcessor).to have_received(:new).with(message_body)
+      expect(process_message).to have_received(:go)
+    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 = 'minitest'
+      channel = 'northstar'
+
+      MessageQueue::Listener.new(topic: topic, channel: channel).
+        process_next_message
+
+      expect(message).to have_received(:finish)
+    end
+  end
+
+  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 = 'minitest'
+        channel = 'northstar'
+
+        pid = fork do
+          MessageQueue::Listener.new(topic: topic, channel: channel).go
+        end
+
+        Process.kill('TERM', pid)
+
+        # Success for this test is to expect it to complete
+        # Note: We are not testing the SIGINT case because it orphans the test
+        # Ruby process and is sort of meaningless as a test.
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+RSpec.describe MessageQueue::Producer do
+  describe '#connection' do
+    describe 'when using the real queue' do
+      it 'returns an instance of the queue producer' do
+        use_real_connection do
+          allow(Nsq::Producer).to receive(:new)
+          topic = 'death_star'
+
+          MessageQueue::Producer.new(topic: topic).connection
+
+          expect(Nsq::Producer).to have_received(:new).
+            with(
+              nsqd: ENV.fetch('NSQD_TCP_ADDRESS'),
+              topic: topic,
+          ).at_least(:once)
+        end
+      end
+    end
+
+    describe 'when using the fake queue' do
+      it 'returns an instance of the queue producer' do
+        use_fake_connection do
+          allow(FakeMessageQueue::Producer).to receive(:new)
+          topic = 'death_star'
+
+          MessageQueue::Producer.new(topic: topic).connection
+
+          expect(FakeMessageQueue::Producer).to have_received(:new).
+            with(
+              nsqd: ENV.fetch('NSQD_TCP_ADDRESS'),
+              topic: topic,
+          ).at_least(:once)
+        end
+      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'
+
+        producer = MessageQueue::Producer.new(topic: topic)
+
+        expect{ producer.connection }.to raise_error(InvalidParameterError)
+      end
+    end
+  end
+
+  describe '#terminate' do
+    describe 'when using the real queue' do
+      it 'closes the connection' do
+        use_real_connection do
+          producer = double('Producer', connection: nil, terminate: nil)
+          allow(Nsq::Producer).to receive(:new).and_return(producer)
+          topic = 'death_star'
+
+          live_producer = MessageQueue::Producer.new(topic: topic)
+          live_producer.connection
+          live_producer.terminate
+
+          expect(producer).to have_received(:terminate)
+        end
+      end
+    end
+
+    describe 'when using the fake queue' do
+      it 'closes the connection' do
+        use_fake_connection do
+          producer = double('Producer', connection: nil, terminate: nil)
+          allow(FakeMessageQueue::Producer).to receive(:new).and_return(producer)
+          topic = 'death_star'
+
+          live_producer = MessageQueue::Producer.new(topic: topic)
+          live_producer.connection
+          live_producer.terminate
+
+          expect(producer).to have_received(:terminate)
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,6 @@
-require 'test_helper'
+require 'spec_helper'
 
-describe Strategy do
+RSpec.describe Strategy do
   describe '.for_queue' do
     describe 'when using the fake queue' do
       it 'returns the strategy based on the ENV variable' do
@@ -9,7 +9,7 @@ describe Strategy do
 
           strategy = Strategy.for_queue
 
-          assert equal FakeMessageQueue, strategy
+          expect(strategy).to eq FakeMessageQueue
         end
       end
     end
@@ -21,7 +21,7 @@ describe Strategy do
 
           strategy = Strategy.for_queue
 
-          assert equal Nsq, strategy
+          expect(strategy).to eq Nsq
         end
       end
     end
@@ -30,9 +30,7 @@ describe Strategy do
       it 'raises with a helpful error' do
         allow(ENV).to receive(:[]).with('FAKE_QUEUE').and_return('taco')
 
-        assert_raises(InvalidParameterError) do
-          Strategy.for_queue
-        end
+        expect{ Strategy.for_queue }.to raise_error(InvalidParameterError)
       end
     end
   end

data/{test/lib/fastly_nsq/sample_message_processor_test.rb → spec/lib/fastly_nsq/sample_message_processor_spec.rb}

@@ -1,40 +1,27 @@
-require 'test_helper'
+require 'spec_helper'
 
-describe SampleMessageProcessor do
+RSpec.describe SampleMessageProcessor do
   describe '#start' do
     it 'enqueues the appropriate message processor' do
       data =  { 'key' => 'value' }
-      body = { 'event_type' => 'heartbeat', 'data' => data }.to_json
-      message = double('Message', body: body, finish: nil)
+      message_body = { 'event_type' => 'heartbeat', 'data' => data }.to_json
       allow(HeartbeatWorker).to receive(:perform_async)
 
-      SampleMessageProcessor.new(message).go
+      SampleMessageProcessor.new(message_body).go
 
       expect(HeartbeatWorker).to have_received(:perform_async).with(data)
     end
 
-    it 'finishes the message' do
-      data =  { 'key' => 'value' }
-      body = { 'event_type' => 'heartbeat', 'data' => data }.to_json
-      message = double('Message', body: body, finish: nil)
-      allow(HeartbeatWorker).to receive(:perform_async)
-
-      SampleMessageProcessor.new(message).go
-
-      expect(message).to have_received(:finish)
-    end
-
     describe 'when the message event_type is not known' do
       it 'uses the null object processor' do
         data = { 'sample_key' => 'sample value' }
-        body = {
+        message_body = {
           'event_type' => 'unregistered_message_type',
           'data' => data,
         }.to_json
-        message = double('Message', body: body, finish: nil)
         allow(UnknownMessageWorker).to receive(:perform_async)
 
-        SampleMessageProcessor.new(message).go
+        SampleMessageProcessor.new(message_body).go
 
         expect(UnknownMessageWorker).to have_received(:perform_async).with(data)
       end
@@ -43,14 +30,13 @@ describe SampleMessageProcessor do
     describe 'when the message lacks an event_type' do
       it 'uses the null object processor' do
         data = { 'sample_key' => 'sample value' }
-        body = {
+        message_body = {
           'not_the_event_type_key' => 'unregistered_message_type',
           'data' => data,
         }.to_json
-        message = double('Message', body: body, finish: nil)
         allow(UnknownMessageWorker).to receive(:perform_async)
 
-        SampleMessageProcessor.new(message).go
+        SampleMessageProcessor.new(message_body).go
 
         expect(UnknownMessageWorker).to have_received(:perform_async).with(data)
       end

data/spec/spec_helper.rb

@@ -0,0 +1,44 @@
+require 'fastly_nsq'
+require 'awesome_print'
+require 'pry-byebug'
+
+require_relative '../lib/fastly_nsq/sample_message_processor'
+require_relative 'support/env_helpers'
+
+MessageProcessor = SampleMessageProcessor
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.default_formatter = 'progress'
+  config.disable_monkey_patching!
+  config.example_status_persistence_file_path = 'spec/examples.txt'
+  config.filter_run :focus
+  config.order = :random
+  config.profile_examples = false
+  config.run_all_when_everything_filtered = true
+  Kernel.srand config.seed
+
+  if config.files_to_run.one?
+    config.default_formatter = 'doc'
+  end
+
+  config.before(:each) do
+    load_sample_environment_variables
+    FakeMessageQueue.reset!
+  end
+
+  def load_sample_environment_variables
+    env_file = File.open('env_configuration_for_local_gem_tests.yml')
+
+    YAML.load(env_file).each do |key, value|
+      ENV[key.to_s] = value
+    end
+  end
+end

data/spec/support/env_helpers.rb

@@ -0,0 +1,19 @@
+module EnvHelpers
+  def use_fake_connection
+    MessageQueue::TRUTHY_VALUES.each do |yes|
+      allow(ENV).to receive(:[]).with('FAKE_QUEUE').and_return(yes)
+      yield
+    end
+  end
+
+  def use_real_connection
+    MessageQueue::FALSY_VALUES.each do |no|
+      allow(ENV).to receive(:[]).with('FAKE_QUEUE').and_return(no)
+      yield
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include EnvHelpers
+end

data/test/lib/fastly_nsq/rake_task_test.rb

@@ -0,0 +1,68 @@
+require 'test_helper'
+require 'fastly_nsq/rake_task'
+
+describe MessageQueue::RakeTask do
+  before(:each) do
+    Rake::Task['begin_listening'].clear if Rake::Task.task_defined?('begin_listening')
+  end
+
+  describe 'defining tasks' do
+    it 'creates a begin_listening task' do
+      MessageQueue::RakeTask.new
+
+      allow_any_instance_of(MessageQueue::RakeTask).to receive(:output) { nil }
+      assert_equal true, Rake::Task.task_defined?(:begin_listening)
+    end
+
+    it 'creates a named task' do
+      MessageQueue::RakeTask.new(:test_name)
+
+      allow_any_instance_of(MessageQueue::RakeTask).to receive(:output) { nil }
+      assert_equal true, Rake::Task.task_defined?(:test_name)
+    end
+  end
+
+  describe 'running tasks' do
+    it 'runs with inline options defined' do
+      MessageQueue::RakeTask.new(:begin_listening, [:topic, :channel])
+
+      dbl = double('go', go: nil)
+      expect(MessageQueue::Listener).to receive(:new).
+        with(topic: 'dwarf', channel: 'star').
+        and_return(dbl)
+
+      allow_any_instance_of(MessageQueue::RakeTask).to receive(:output) { nil }
+      Rake::Task['begin_listening'].execute(topic: 'dwarf', channel: 'star')
+    end
+
+    it 'runs with specified options if a block is given' do
+      MessageQueue::RakeTask.new do |task|
+        task.topic   = 'dwarf'
+        task.channel = 'star'
+      end
+
+      dbl = double('go', go: nil)
+      expect(MessageQueue::Listener).to receive(:new).
+        with(topic: 'dwarf', channel: 'star').
+        and_return(dbl)
+
+      allow_any_instance_of(MessageQueue::RakeTask).to receive(:output) { nil }
+      Rake::Task['begin_listening'].execute(topic: 'dwarf', channel: 'star')
+    end
+
+    it 'uses inline over block' do
+      MessageQueue::RakeTask.new(:begin_listening, [:topic, :channel]) do |task|
+        task.topic   = 'loud'
+        task.channel = 'noise'
+      end
+
+      dbl = double('go', go: nil)
+      expect(MessageQueue::Listener).to receive(:new).
+        with(topic: 'dwarf', channel: 'star').
+        and_return(dbl)
+
+      allow_any_instance_of(MessageQueue::RakeTask).to receive(:output) { nil }
+      Rake::Task['begin_listening'].execute(topic: 'dwarf', channel: 'star')
+    end
+  end
+end