fastly_nsq 0.6.0 → 0.7.0

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

@@ -1,60 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe MessageQueue::Consumer do
-  let(:channel)  { 'star_killer_base' }
-  let(:topic)    { 'death_star' }
-  let(:consumer) { MessageQueue::Consumer.new topic: topic, channel: channel }
-  let(:backend)  { double 'Consumer' }
-
-  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')
-
-      expect { consumer.terminate }.to raise_error(InvalidParameterError)
-    end
-  end
-
-  describe 'when connector connects to a backend Consumer' do
-    let(:consumer) do
-      MessageQueue::Consumer.new topic: topic, channel: channel, connector: ->(_) { backend }
-    end
-
-    it 'forwards #pop' do
-      expect(backend).to receive(:pop)
-      consumer.pop
-    end
-
-    it 'forwards #pop_without_blocking' do
-      expect(backend).to receive(:pop_without_blocking)
-      consumer.pop_without_blocking
-    end
-
-    it 'forwards #size' do
-      expect(backend).to receive(:size)
-      consumer.size
-    end
-
-    it 'forwards #terminate' do
-      expect(backend).to receive(:terminate)
-      consumer.terminate
-    end
-  end
-
-  describe 'using the default connector' do
-    module TestStrategy
-      module Consumer
-        def self.new(*_); end
-      end
-    end
-
-    before do
-      allow(MessageQueue).to receive(:strategy).and_return(TestStrategy)
-    end
-
-    it 'instantiates a consumer via Strategy' do
-      allow(backend).to receive(:terminate)
-      expect(TestStrategy::Consumer).to receive(:new).and_return(backend)
-      consumer.terminate
-    end
-  end
-end

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

@@ -1,90 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe MessageQueue::Listener do
-  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
-
-      expect(messages_processed).to eql(expected_messages)
-    end
-
-    it 'finishes the message' do
-      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
-        delay = FakeMessageQueue.delay + 0.1
-
-        expect do
-          Timeout.timeout(delay) do
-            listener.process_next_message
-          end
-        end.to raise_error(Timeout::Error)
-      end
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe MessageQueue::Producer do
-  let(:topic)    { 'death_star' }
-  let(:producer) { MessageQueue::Producer.new(topic: topic) }
-  let(:backend)  { double 'Producer' }
-
-  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')
-
-      expect { producer.terminate }.to raise_error(InvalidParameterError)
-    end
-  end
-
-  describe 'when connector connects to a backend Producer' do
-    let(:producer) do
-      MessageQueue::Producer.new topic: topic, connector: ->(_) { backend }
-    end
-
-    it 'forwards #write' do
-      expect(backend).to receive(:write).with("it's a message")
-      producer.write "it's a message"
-    end
-
-    it 'forwards #terminate' do
-      expect(backend).to receive(:terminate)
-      producer.terminate
-    end
-  end
-
-  describe 'using the default connector' do
-    module TestStrategy
-      module Producer
-        def self.new(*_); end
-      end
-    end
-
-    before do
-      allow(MessageQueue).to receive(:strategy).and_return(TestStrategy)
-    end
-
-    it 'instantiates a producer via Strategy' do
-      allow(backend).to receive(:terminate)
-      expect(TestStrategy::Producer).to receive(:new).and_return(backend)
-      producer.terminate
-    end
-  end
-end

data/spec/lib/fastly_nsq/message_queue_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe MessageQueue do
-  module TestStrategy; end
-
-  it 'allows the logger to be set and retrieved' do
-    logger = Logger.new(STDOUT)
-    MessageQueue.logger = logger
-
-    expect(MessageQueue.logger).to eq logger
-  end
-
-  it 'returns the current Strategy' do
-    allow(MessageQueue::Strategy).to receive(:for_queue).and_return(TestStrategy)
-
-    expect(MessageQueue.strategy).to eql(TestStrategy)
-  end
-
-  describe '.logger' do
-    describe 'when using the fake queue', fake_queue: true do
-    end
-
-    describe 'when using the real queue, fake_queue: false' do
-      it 'allows the logger to be set and retrieved' do
-        logger = Logger.new(STDOUT)
-        MessageQueue.logger = logger
-
-        expect(MessageQueue.logger).to eq logger
-      end
-    end
-  end
-end

data/spec/lib/fastly_nsq/sample_message_processor_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SampleMessageProcessor do
-  describe '.topics' do
-    it 'specifies the array of topics to listen to' do
-      topics = SampleMessageProcessor.topics
-
-      expect(topics).to be_an Array
-      expect(topics.first).to be_a String
-    end
-  end
-
-  describe '#go' do
-    it 'enqueues the appropriate message processor' do
-      data = { 'key' => 'value' }
-      message_body = { 'data' => data }.to_json
-      allow(HeartbeatWorker).to receive(:perform_async)
-      topic = 'heartbeat'
-
-      SampleMessageProcessor.new(message_body: message_body, topic: topic).go
-
-      expect(HeartbeatWorker).to have_received(:perform_async).with(data)
-    end
-
-    describe 'when the message topic is not known' do
-      it 'uses the null object processor' do
-        data = { 'sample_key' => 'sample value' }
-        message_body = { 'data' => data }.to_json
-        allow(UnknownMessageWorker).to receive(:perform_async)
-        topic = 'unknown_topic'
-
-        SampleMessageProcessor.new(message_body: message_body, topic: topic).go
-
-        expect(UnknownMessageWorker).to have_received(:perform_async).with(data)
-      end
-    end
-  end
-end