fastly_nsq 0.13.2 → 1.0.2

data/spec/fastly_nsq_spec.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe FastlyNsq do
+  describe '#configure' do
+    specify { expect { |b| described_class.configure(&b) }.to yield_with_args(described_class) }
+  end
+
+  describe '#listen' do
+    let!(:default_channel) { subject.channel }
+    let!(:topic) { 'fnsq' }
+
+    before { subject.channel = 'fnsq' }
+    after { subject.channel = default_channel }
+
+    it 'creates a listener' do
+      expect { subject.listen topic, ->(*) {} }.to change { subject.manager.topics }.to([topic])
+    end
+
+    it 'creates a listener with a specific priority' do
+      listener = subject.listen topic, ->(*) {}, priority: 10
+      expect(listener.priority).to eq(10)
+    end
+  end
+
+  describe '#channel=' do
+    let!(:default_channel) { subject.channel }
+    after { subject.channel = default_channel }
+
+    it 'allows the channel to be set and retrieved' do
+      expect(subject.channel).to be_nil
+      subject.channel = 'foo'
+      expect(subject.channel).to eq('foo')
+    end
+  end
+
+  describe '#logger=' do
+    let!(:default_logger) { subject.logger }
+    after { subject.logger = default_logger }
+
+    it 'allows the logger to be set and retrieved' do
+      logger = Logger.new(STDOUT)
+      subject.logger = logger
+
+      expect(subject.logger).to eq logger
+    end
+  end
+
+  describe '#manager' do
+    it 'represents the active default manager' do
+      expect(subject.manager).not_to be_stopped
+    end
+  end
+
+  describe '#manager=' do
+    it 'transfers to specified manager' do
+      old_manager = subject.manager
+      new_manager = FastlyNsq::Manager.new
+
+      expect(old_manager).to receive(:transfer).with(new_manager)
+
+      subject.manager = new_manager
+    end
+  end
+
+  describe '#lookupd_http_addresses' do
+    it 'retreives NSQLOOKUPD_HTTP_ADDRESS' do
+      expect(subject.lookupd_http_addresses).to eq(ENV['NSQLOOKUPD_HTTP_ADDRESS'].split(','))
+    end
+  end
+end

data/spec/feeder_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe FastlyNsq::Feeder do
+  describe '#push' do
+    it 'sends message to processor with the specified priority' do
+      messages = []
+      processor = ->(m) { messages << m }
+      priority = 5
+      message = 'foo'
+
+      feeder = described_class.new(processor, priority)
+
+      expect(FastlyNsq.manager.pool).to receive(:post).with(priority).and_call_original
+
+      feeder.push(message)
+
+      expect { messages }.to eventually(contain_exactly(message)).within(2)
+    end
+  end
+end

data/spec/{lib/fastly_nsq/http → http}/nsqd_spec.rb

@@ -3,7 +3,7 @@
 require 'spec_helper'
 require 'fastly_nsq/http/nsqd'
 
-RSpec.describe FastlyNsq::Http::Nsqd do
+RSpec.describe FastlyNsq::Http::Nsqd, :webmock do
   let(:base_uri) { 'http://example.com' }
 
   it 'makes simple get requests' do

data/spec/{lib/fastly_nsq/http → http}/nsqlookupd_spec.rb

@@ -3,7 +3,7 @@
 require 'spec_helper'
 require 'fastly_nsq/http/nsqlookupd'
 
-RSpec.describe FastlyNsq::Http::Nsqlookupd do
+RSpec.describe FastlyNsq::Http::Nsqlookupd, :webmock do
   let(:base_uri) { 'http://example.com' }
 
   it 'makes simple get requests' do

data/spec/{lib/fastly_nsq/http_spec.rb → http_spec.rb}

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'fastly_nsq/http'
 
-RSpec.describe FastlyNsq::Http do
+RSpec.describe FastlyNsq::Http, :webmock do
   let(:base_url) { 'http://example.com' }
   describe 'get' do
     it 'can make simple requests' do

data/spec/integration_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'integration' do
+  let!(:topic) { 'fnsq-topic' }
+  let!(:channel) { 'fnsq-channel' }
+  let!(:message) { { 'foo' => 'bar' } }
+
+  before { reset_topic(topic, channel: channel) }
+
+  it 'processes jobs' do
+    received = nil
+    producer = FastlyNsq::Producer.new(topic: topic)
+    FastlyNsq::Listener.new(topic: topic, channel: channel, processor: ->(m) { received = m })
+    producer.write JSON.dump(message)
+
+    expect { received&.body }.to eventually(eq(message)).within(2)
+  end
+
+  describe 'inline', :inline do
+    it 'processes job' do
+      received = nil
+      producer = FastlyNsq::Producer.new(topic: topic)
+      FastlyNsq::Listener.new(topic: topic, channel: channel, processor: ->(m) { received = m })
+      producer.write JSON.dump(message)
+
+      expect(received.body).to eq(message)
+    end
+  end
+
+  describe 'fake', :fake do
+    it 'stores jobs' do
+      received = nil
+      encoded_message = JSON.dump(message)
+      producer = FastlyNsq::Producer.new(topic: topic)
+      listener = FastlyNsq::Listener.new(topic: topic, channel: channel, processor: ->(m) { received = m })
+      expect { producer.write encoded_message }.to change { listener.messages.size }.by(1)
+
+      queued_message = listener.messages.shift
+      expect(queued_message.body).to eq(encoded_message)
+
+      listener.drain
+
+      expect(received.body).to eq(message)
+    end
+  end
+end

data/spec/launcher_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe FastlyNsq::Launcher do
+  let!(:options)  { { max_threads: 3, timeout: 9 } }
+  let!(:launcher) { FastlyNsq::Launcher.new options }
+  let!(:topic)    { 'fnsq' }
+  let!(:channel)  { 'fnsq' }
+  let(:listener)  { FastlyNsq::Listener.new(topic: topic, channel: channel, processor: ->(*) {}) }
+
+  before { reset_topic(topic, channel: channel) }
+  before { expect { listener }.to eventually(be_connected).within(5) }
+  after  { listener.terminate if listener.connected? }
+
+  let(:manager) { launcher.manager }
+
+  it 'creates a manager with correct options' do
+    expect(FastlyNsq.manager.pool.max_threads).to eq(3)
+  end
+
+  describe '#beat' do
+    let!(:logger)   { Logger.new(nil).tap { |l| l.level = Logger::DEBUG } }
+    let!(:launcher) { FastlyNsq::Launcher.new pulse: 0.01, logger: logger }
+
+    it 'creates a heartbeat thread' do
+      expect(logger).not_to receive(:error)
+      expect { launcher.beat }.to eventually_not(eq('dead')).pause_for(1)
+    end
+  end
+
+  describe '#stop_listeners' do
+    it 'stops listeners and sets done' do
+      expect(launcher).not_to be_stopping
+      expect(manager).to receive(:stop_listeners)
+      expect(manager).not_to receive(:terminate)
+
+      launcher.stop_listeners
+
+      expect(launcher).to be_stopping
+    end
+  end
+
+  describe '#stop' do
+    it 'stops the manager within a deadline' do
+      expect(manager).to receive(:terminate).with(options[:timeout])
+      launcher.stop
+    end
+  end
+end

data/spec/listener_spec.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe FastlyNsq::Listener do
+  let!(:topic) { 'fnsq' }
+  let!(:channel) { 'fnsq' }
+  let!(:messages) { [] }
+  let(:processor) { ->(m) { messages << m.body } }
+
+  before { reset_topic(topic, channel: channel) }
+  before { expect { subject }.to eventually(be_connected).within(5) }
+  after  { subject.terminate if subject.connected? }
+
+  subject { described_class.new(topic: topic, channel: channel, processor: processor) }
+
+  describe '#initialize' do
+    describe 'with FastlyNsq.channel set' do
+      let!(:default_channel) { FastlyNsq.channel }
+      before { FastlyNsq.channel = 'fnsq' }
+      after { FastlyNsq.channel = default_channel }
+
+      it 'defaults to FastlyNsq.channel' do
+        listener = described_class.new(topic: topic, processor: processor)
+        expect(listener.channel).to eq(FastlyNsq.channel)
+      end
+    end
+
+    describe 'with FastlyNsq.preprocessor set' do
+      let!(:default_preprocessor) { FastlyNsq.preprocessor }
+      before { FastlyNsq.preprocessor = 'fnsq' }
+      after { FastlyNsq.preprocessor = default_preprocessor }
+
+      it 'defaults to FastlyNsq.preprocessor' do
+        listener = described_class.new(topic: topic, processor: processor, channel: channel)
+        expect(listener.preprocessor).to eq(FastlyNsq.preprocessor)
+      end
+    end
+
+    describe 'with FastlyNsq.logger set' do
+      let!(:default_logger) { FastlyNsq.logger }
+      before { FastlyNsq.logger = Logger.new(nil) }
+      after { FastlyNsq.logger = default_logger }
+
+      it 'defaults to FastlyNsq.logger' do
+        listener = described_class.new(topic: topic, processor: processor, channel: channel)
+        expect(listener.logger).to eq(FastlyNsq.logger)
+      end
+    end
+
+    it 'warns when creating a listener for the same topic' do
+      expect(FastlyNsq.manager.logger).to receive(:warn).and_yield.and_return(match("#{topic} was added more than once"))
+
+      described_class.new(topic: topic, channel: channel, processor: processor)
+    end
+  end
+
+  describe '#priority' do
+    specify { expect(subject.priority).to eq(described_class::DEFAULT_PRIORITY) }
+  end
+
+  describe '#consumer' do
+    specify { expect(subject.consumer).to be_a(FastlyNsq::Consumer) }
+  end
+
+  describe 'connect_timeout' do
+    specify { expect(subject.consumer.connect_timeout).to eq(described_class::DEFAULT_CONNECTION_TIMEOUT) }
+  end
+
+  it 'requires processor to respond_to #call' do
+    expect { described_class.new(topic: topic, channel: channel, processor: 'foo') }.
+      to raise_error(ArgumentError, match('#call'))
+  end
+
+  it 'requires priority to be a Fixnum' do
+    expect { described_class.new(topic: topic, channel: channel, processor: ->(*) {}, priority: 'foo') }.
+      to raise_error(ArgumentError, match('Integer'))
+  end
+
+  describe '#call' do
+    it 'processes a message' do
+      body = { 'foo' => 'bar' }
+      message = spy('message', body: JSON.dump(body))
+      expect { subject.call(message) }.to change { messages }.to([body])
+    end
+
+    describe 'when the processor returns true' do
+      let(:processor) { ->(_) { true } }
+
+      it 'finishes the message' do
+        message = spy('message', body: '{}')
+        subject.call(message)
+
+        expect(message).to have_received(:finish)
+      end
+    end
+
+    describe 'when the processor returns false' do
+      let(:processor) { ->(_) { false } }
+
+      it 'finishes the message' do
+        message = spy('message', body: '{}')
+        subject.call(message)
+
+        expect(message).not_to have_received(:finish)
+      end
+    end
+  end
+
+  it { should be_connected }
+
+  it 'should terminate' do
+    expect { subject.terminate }.to change(subject, :connected?).to(false)
+  end
+
+  describe 'faking', :fake do
+    let!(:message) { { 'foo' => 'bar' } }
+
+    before { subject }
+
+    it { should be_connected }
+
+    it 'should terminate' do
+      expect { subject.terminate }.to change(subject, :connected?).to(false)
+    end
+
+    it "stores messages produced to the listener's topic" do
+      expect do
+        FastlyNsq::Producer.new(topic: topic).write(message)
+      end.to change { subject.messages.size }.by(1)
+
+      test_message = subject.messages.pop
+      expect(test_message.raw_body).to eq(message)
+    end
+
+    describe 'when the processor returns true' do
+      let(:processor) { ->(_) { true } }
+
+      it 'drains queued messages' do
+        FastlyNsq::Producer.new(topic: topic).write(message)
+        expect { subject.drain }.to change { subject.messages.size }.by(-1)
+      end
+    end
+
+    describe 'when the processor returns false' do
+      let(:processor) { ->(_) { false } }
+
+      it 'does not remove messages' do
+        FastlyNsq::Producer.new(topic: topic).write(message)
+        expect { subject.drain }.not_to change { subject.messages.size }
+      end
+    end
+  end
+
+  describe 'inline', :inline do
+    let!(:message) { { 'foo' => 'bar' } }
+    let!(:processor) { ->(m) { messages << m.raw_body } }
+
+    before { subject }
+
+    it { should be_connected }
+
+    it 'should terminate' do
+      expect { subject.terminate }.to change(subject, :connected?).to(false)
+    end
+
+    describe 'when the processor returns true' do
+      it 'processes and removes messages' do
+        expect { FastlyNsq::Producer.new(topic: topic).write(message) }.to change { messages.size }.by(1)
+        expect(messages).to contain_exactly(message)
+        expect(subject.messages).to be_empty
+      end
+    end
+
+    describe 'when the processor returns false' do
+      let(:processor) { ->(_) { false } }
+
+      it 'does not remove messages' do
+        FastlyNsq::Producer.new(topic: topic).write(message)
+        expect { subject.drain }.not_to change { subject.messages.size }
+      end
+    end
+  end
+end

data/spec/manager_spec.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe FastlyNsq::Manager do
+  let!(:topic) { 'fnsq' }
+  let!(:channel) { 'fnsq' }
+
+  subject { FastlyNsq.manager }
+
+  before { reset_topic(topic, channel: channel) }
+
+  after { subject.terminate(1) unless subject.stopped? }
+
+  it { should_not be_stopped }
+
+  describe '#initialize' do
+    it 'allows max_threads to be specified' do
+      max_threads = described_class::DEFAULT_POOL_SIZE * 2
+      manager = described_class.new(max_threads: max_threads)
+
+      expect(manager.pool.max_threads).to eq(max_threads)
+    end
+
+    it 'defaults max_threads to DEFAULT_POOL_SIZE' do
+      expect(subject.pool.max_threads).to eq(described_class::DEFAULT_POOL_SIZE)
+    end
+
+    it 'allows fallback_policy to be specified' do
+      manager = described_class.new(fallback_policy: :abort)
+
+      expect(manager.pool.fallback_policy).to eq(:abort)
+    end
+
+    it 'defaults fallback_policy to caller_runs' do
+      expect(subject.pool.fallback_policy).to eq(:caller_runs)
+    end
+
+    it 'defaults logger to FastlyNsq.logger' do
+      expect(subject.logger).to eq(FastlyNsq.logger)
+    end
+
+    it 'allows logger to be specified' do
+      logger = Logger.new(nil)
+      manager = described_class.new(logger: logger)
+
+      expect(manager.logger).to eq(logger)
+    end
+  end
+
+  context 'with a listener' do
+    let!(:listener) { FastlyNsq::Listener.new(topic: topic, channel: channel, processor: ->(*) {}) }
+    before { expect { listener }.to eventually(be_connected).within(5) }
+
+    it 'tracks listener' do
+      expect(subject.listeners).to contain_exactly(listener)
+    end
+
+    it 'tracks topic listeners' do
+      expect(subject.topic_listeners).to eq(topic => listener)
+    end
+
+    it 'tracks topics' do
+      expect(subject.topics).to contain_exactly(topic)
+    end
+
+    describe '#terminate' do
+      it 'terminates listeners' do
+        expect { subject.terminate(2) }.to change(listener, :connected?).to(false)
+      end
+
+      it 'terminates the processing pool' do
+        expect { subject.terminate(2) }.to change(subject.pool, :shutdown?).to(true)
+      end
+
+      it 'stops' do
+        expect { subject.terminate(2) } .to change(subject, :stopped?).from(false).to(true)
+      end
+
+      context 'when the pool does not terminate within a the specified timeframe' do
+        before { expect(subject.pool).to receive(:shutdown).and_return(false) }
+
+        it 'kills the pool' do
+          expect(subject.pool).to receive(:kill).once.and_call_original
+
+          expect { subject.terminate(0.1) }.to change(subject.pool, :shutdown?).to(true)
+        end
+      end
+    end
+  end
+
+  it 'transfers' do
+    manager = described_class.new
+
+    listener = nil
+    # register listener with default manager
+    expect { listener = FastlyNsq::Listener.new(topic: topic, channel: channel, processor: ->(*) {}) }.
+      to change { FastlyNsq.manager.listeners.size }.by(1)
+    expect { listener }.to eventually(be_connected).within(5)
+
+    # transfer listener to new manager
+    expect { FastlyNsq.manager.transfer(manager) }.
+      to change { manager.listeners.size }.by(1).
+      and change { FastlyNsq.manager.listeners.size }.by(-1)
+
+    # old manager processing is disabled
+    expect(FastlyNsq.manager.pool).to be_shutdown
+    # listener is still connected
+    expect(listener).to be_connected
+  end
+end