fastly_nsq 0.13.2 → 1.0.2

data/spec/lib/fastly_nsq/fastly_nsq_spec.rb

@@ -1,10 +0,0 @@
-require 'spec_helper'
-require 'fastly_nsq'
-
-RSpec.describe FastlyNsq do
-  it 'has a version number' do
-    version = FastlyNsq.const_get('VERSION')
-
-    expect(version).not_to be_empty
-  end
-end

data/spec/lib/fastly_nsq/launcher_spec.rb

@@ -1,56 +0,0 @@
-require 'spec_helper'
-require 'fastly_nsq/launcher'
-
-RSpec.describe FastlyNsq::Launcher do
-  let(:launcher) { FastlyNsq::Launcher.new options }
-  let(:manager)  { instance_double 'Manager', start: nil, quiet: nil, stop: nil }
-  let(:thread)   { instance_double 'Thread' }
-  let(:options)  { { joe: 'biden', timeout: 9 } }
-
-  before do
-    allow(FastlyNsq::Manager).to receive(:new).and_return(manager)
-    allow(launcher).to receive(:safe_thread).and_return(thread)
-  end
-
-  it 'creates a manager with correct options' do
-    expect(FastlyNsq::Manager).to have_received(:new).with(options)
-  end
-
-  describe '#run' do
-    it 'creates a heartbeat thread' do
-      launcher.run
-      expect(launcher).to have_received(:safe_thread).with('heartbeat')
-      expect(launcher.stopping?).to eq false
-    end
-
-    it 'starts the setup manager' do
-      launcher.run
-      expect(manager).to have_received(:start)
-      expect(launcher.stopping?).to eq false
-    end
-  end
-
-  describe '#quiet' do
-    it 'quites the manager and sets done' do
-      expect(launcher.stopping?).to eq false
-      launcher.quiet
-      expect(manager).to have_received(:quiet)
-      expect(launcher.stopping?).to eq true
-    end
-  end
-
-  describe '#stop' do
-    it 'stops the manager within a deadline' do
-      now = Time.now
-      allow(Time).to receive(:now).and_return(now)
-      launcher.stop
-      expect(manager).to have_received(:stop).with(now + options[:timeout])
-    end
-
-    it 'quites the manager' do
-      launcher.stop
-      expect(manager).to have_received(:quiet)
-      expect(launcher.stopping?).to eq true
-    end
-  end
-end

data/spec/lib/fastly_nsq/listener_spec.rb

@@ -1,213 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe FastlyNsq::Listener do
-  let(:topic)    { 'testing_topic' }
-  let(:channel)  { 'testing_channel' }
-  let(:consumer) { FastlyNsq::FakeBackend::Consumer.new topic: topic, channel: channel }
-  let(:logger)   { double 'Logger', info: nil, debug: nil, error: nil }
-
-  module TestMessageProcessor
-    @@messages_processed = []
-    Message = Struct.new(:body, :topic) do
-      def finish
-        @did_finish = true
-      end
-    end
-
-    def self.process(incoming_message)
-      @@messages_processed.push Message.new(incoming_message.to_s)
-    end
-
-    def self.messages_processed
-      @@messages_processed
-    end
-
-    def self.clear
-      @@messages_processed = []
-    end
-  end
-
-  let(:listener) do
-    FastlyNsq::Listener.new topic:     topic,
-                            processor: TestMessageProcessor,
-                            consumer:  consumer,
-                            logger:    logger
-  end
-
-  let(:message)            { TestMessageProcessor::Message.new 'this is message body' }
-  let(:messages_processed) { TestMessageProcessor.messages_processed }
-  let(:expected_message)   { TestMessageProcessor::Message.new 'this is message body' }
-  let(:expected_messages)  { [expected_message] }
-
-  describe 'instantiating without a consumer' do
-    it 'instantiates a consumer, passing the topic and channel' do
-      allow(FastlyNsq::Consumer).to receive(:new)
-
-      FastlyNsq::Listener.new topic:     topic,
-                              channel:   channel,
-                              processor: TestMessageProcessor,
-                              consumer:  nil
-
-      expect(FastlyNsq::Consumer).to have_received(:new).
-        with(topic: topic, channel: channel)
-    end
-  end
-
-  context 'when not passed a manager' do
-    it 'creates a blank manager' do
-      expect(listener.identity[:manager]).to_not be_nil
-    end
-  end
-
-  context 'when using the fake queue and it is empty', fake_queue: true do
-    before do
-      TestMessageProcessor.clear
-      FastlyNsq::FakeBackend.delay = 0.1
-    end
-
-    it 'blocks on the process for longer than the check cycle' do
-      delay = FastlyNsq::FakeBackend.delay + 0.1
-
-      expect do
-        Timeout.timeout(delay) do
-          listener.go run_once: true
-        end
-      end.to raise_error(Timeout::Error)
-    end
-  end
-
-  describe 'when processing next message' do
-    before(:each) do
-      TestMessageProcessor.clear
-      allow(consumer).to receive(:pop).and_return(message)
-    end
-
-    it 'processes the next message' do
-      listener.go run_once: true
-
-      expect(messages_processed).to eql(expected_messages)
-    end
-
-    it 'finishes the message' do
-      allow(message).to receive(:finish)
-
-      listener.go run_once: true
-
-      expect(message).to have_received(:finish).once
-    end
-
-    it 'logs info for the message body' do
-      allow(logger).to receive(:info)
-      listener.go run_once: true
-
-      expect(logger).to have_received(:info).once.with(/\[NSQ\] Message received on topic \[#{topic}\]: #{message.body}/)
-    end
-
-    context 'when preprocessor is provided' do
-      it 'calls the preprocessor' do
-        preprocessor_was_called = false
-        preprocessor = ->(*_args) { preprocessor_was_called = true }
-
-        listener = FastlyNsq::Listener.new topic:        topic,
-                                           processor:    TestMessageProcessor,
-                                           consumer:     consumer,
-                                           logger:       logger,
-                                           preprocessor: preprocessor
-
-        listener.go run_once: true
-        expect(preprocessor_was_called).to be_truthy
-      end
-    end
-
-    context 'when running as a thread' do
-      let(:manager) { double 'Manager', listener_stopped: nil, listener_killed: nil }
-      let(:thread)  { double 'FakeThread', raise: nil, kill: nil, status: 'fake_thread' }
-      let(:listener) do
-        FastlyNsq::Listener.new topic:     topic,
-                                processor: TestMessageProcessor,
-                                logger:    logger,
-                                consumer:  consumer,
-                                manager:   manager
-      end
-
-      describe 'shutdown' do
-        it 'informs the manager of a shutdown when run once' do
-          listener.go run_once: true
-
-          expect(manager).to have_received(:listener_stopped).with(listener)
-        end
-      end
-
-      before do
-        allow(listener).to receive(:safe_thread).and_return(thread)
-      end
-
-      it 'starts and provide status' do
-        listener.start
-        expect(logger).to have_received(:info)
-        expect(listener.status).to eq 'fake_thread'
-      end
-
-      it 'can describe itself' do
-        id = listener.identity
-        expect(id[:consumer]).to_not be_nil
-        expect(id[:manager]).to be manager
-        expect(id[:preprocessor]).to be_nil
-        expect(id[:processor]).to_not be_nil
-        expect(id[:topic]).to_not be_nil
-      end
-
-      it 'can be cleanly duplicated' do
-        new_listener = listener.reset_then_dup
-
-        expect(listener.identity).to eq new_listener.identity
-      end
-
-      it 'can be terminated' do
-        listener.start
-        state = listener.instance_variable_get(:@done)
-        expect(state).to eq false
-        consumer = listener.instance_variable_get(:@consumer)
-        allow(consumer).to receive(:terminate)
-        listener.terminate
-
-        state = listener.instance_variable_get(:@done)
-        expect(logger).to have_received(:info).thrice
-        expect(consumer).to have_received(:terminate)
-        expect(state).to eq true
-      end
-
-      it 'raise in terminate to interupt blocking on an empty queue' do
-        listener.start
-        listener.terminate
-
-        expect(consumer.empty?).to be true
-        expect(thread).to have_received(:raise)
-      end
-
-      it 'terminate allows messages to be completed' do
-        100.times { FastlyNsq::Messenger.deliver(on_topic: topic, message: 'test_message') }
-        listener.start
-        listener.terminate
-
-        expect(consumer.empty?).to be false
-        expect(thread).to_not have_received(:raise)
-      end
-
-      it 'can be killed' do
-        listener.start
-        state = listener.instance_variable_get(:@done)
-        expect(state).to eq false
-        consumer = listener.instance_variable_get(:@consumer)
-        allow(consumer).to receive(:terminate)
-        listener.kill
-
-        state = listener.instance_variable_get(:@done)
-        expect(logger).to have_received(:info).thrice
-        expect(consumer).to have_received(:terminate)
-        expect(thread).to have_received(:raise).with(FastlyNsq::Shutdown)
-        expect(state).to eq true
-      end
-    end
-  end
-end

data/spec/lib/fastly_nsq/manager_spec.rb

@@ -1,127 +0,0 @@
-require 'spec_helper'
-require 'fastly_nsq/manager'
-
-RSpec.describe FastlyNsq::Manager do
-  class TestProcessor
-    def self.process(message)
-      FastlyNsq.logger.info("IN PROCESS: #{message}")
-    end
-  end
-
-  let(:listener_1)   { instance_double 'Listener1', new: nil, start: nil, terminate: nil, kill: nil, reset_then_dup: listener_dup }
-  let(:listener_2)   { instance_double 'Listener2', new: nil, start: nil, terminate: nil, kill: nil, reset_then_dup: listener_dup }
-  let(:listener_dup) { instance_double 'ListenerDup', start: nil }
-  let(:manager)      { FastlyNsq::Manager.new options }
-  let(:options)      { { joe: 'biden' } }
-
-  let(:configed_topics) do
-    [
-      { topic: 'warm_topic', klass: TestProcessor },
-      { topic: 'cool_topic', klass: TestProcessor },
-    ]
-  end
-
-  before do
-    logger = Logger.new(STDOUT)
-    logger.level = Logger::FATAL
-
-    FastlyNsq.configure do |config|
-      config.channel = 'william'
-      config.logger = logger
-      config.listener_config do |lc|
-        configed_topics.each do |t|
-          lc.add_topic t[:topic], t[:klass]
-        end
-      end
-    end
-
-    allow(FastlyNsq::Listener).to receive(:new).and_return(listener_1, listener_2)
-    manager.start
-  end
-
-  after do
-    FastlyNsq.reset_config
-  end
-
-  describe '#start' do
-    it 'sets up each configured listener' do
-      configed_topics.each do |t|
-        expect(FastlyNsq::Listener).to have_received(:new).with(
-          channel:      FastlyNsq.channel,
-          manager:      manager,
-          preprocessor: FastlyNsq.preprocessor,
-          processor:    t[:klass],
-          topic:        t[:topic],
-        )
-      end
-    end
-
-    it 'starts all listeners' do
-      expect(listener_1).to have_received(:start)
-      expect(listener_2).to have_received(:start)
-    end
-
-    it 'populates @listeners with all created listeners' do
-      expect(manager.listeners).to eq Set.new([listener_1, listener_2])
-    end
-  end
-
-  describe '#quiet' do
-    it 'does nothing if stopping' do
-      manager.instance_variable_set(:@done, true)
-      manager.quiet
-      expect(listener_1).to_not have_received(:terminate)
-      expect(listener_2).to_not have_received(:terminate)
-    end
-
-    it 'terminates all listeners' do
-      manager.quiet
-      expect(listener_1).to have_received(:terminate)
-      expect(listener_2).to have_received(:terminate)
-    end
-  end
-
-  describe '#stop' do
-    it 'does nothing if no listeners exist post quiet' do
-      allow(manager).to receive(:quiet)
-      allow(manager).to receive(:hard_shutdown)
-      manager.instance_variable_set(:@listeners, Set.new)
-
-      manager.stop(Time.now)
-
-      expect(manager).to have_received(:quiet)
-      expect(manager).to_not have_received(:hard_shutdown)
-    end
-
-    it 'forces shutdown if listeners remain after deadline' do
-      allow(manager).to receive(:hard_shutdown).and_call_original
-
-      manager.stop(Time.now)
-
-      expect(manager).to have_received(:hard_shutdown)
-      expect(listener_1).to have_received(:kill)
-      expect(listener_2).to have_received(:kill)
-    end
-  end
-
-  describe '#listener_stopped' do
-    it 'removes listeners from set of listeners' do
-      manager.listener_stopped(listener_1)
-      expect(manager.listeners).to eq Set.new([listener_2])
-    end
-  end
-
-  describe '#listener_killed' do
-    it 'removes listeners from set of listeners' do
-      manager.quiet # mark for stopping
-      manager.listener_killed(listener_1)
-      expect(manager.listeners).to eq Set.new([listener_2])
-    end
-
-    it 'creates and starts replacements if not stopping' do
-      manager.listener_killed(listener_1)
-      expect(manager.listeners).to eq Set.new([listener_dup, listener_2])
-      expect(listener_dup).to have_received(:start)
-    end
-  end
-end

data/spec/lib/fastly_nsq/producer_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe FastlyNsq::Producer do
-  let(:topic)    { 'death_star' }
-  let(:producer) { FastlyNsq::Producer.new(topic: topic) }
-
-  describe 'when connector connects to a backend Producer' do
-    let(:backend)   { instance_double FastlyNsq::FakeBackend::Producer, write: nil, terminate: nil, connected?: true }
-    let(:connector) { double 'Connector', new: backend }
-    let(:producer) do
-      FastlyNsq::Producer.new topic: topic, connector: connector
-    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
-        @@never_terminated = true
-
-        module_function
-
-        def new(*_)
-          self
-        end
-
-        def connected?
-          true
-        end
-
-        def terminate
-          raise 'Already terminated once' unless @@never_terminated
-          @@never_terminated = false
-        end
-
-        def was_terminated
-          !@@never_terminated
-        end
-      end
-    end
-
-    before do
-      allow(FastlyNsq).to receive(:strategy).and_return(TestStrategy)
-    end
-
-    it 'instantiates a producer via Strategy' do
-      producer.terminate
-      expect(TestStrategy::Producer.was_terminated).to be_truthy
-    end
-  end
-end