fastly_nsq 1.17.0 → 1.17.1

data/spec/listener_spec.rb

@@ -1,26 +1,26 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 RSpec.describe FastlyNsq::Listener do
-  let!(:topic) { 'fnsq' }
-  let!(:channel) { 'fnsq' }
+  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? }
+  after { subject.terminate if subject.connected? }
 
   subject { described_class.new(topic: topic, channel: channel, processor: processor) }
 
-  describe '#initialize' do
-    describe 'with FastlyNsq.max_attempts set' do
+  describe "#initialize" do
+    describe "with FastlyNsq.max_attempts set" do
       let!(:default_max_attempts) { FastlyNsq.max_attempts }
       before { FastlyNsq.max_attempts = 19 }
       after { FastlyNsq.max_attempts = default_max_attempts }
 
-      it 'defaults to FastlyNsq.max_attempts' do
+      it "defaults to FastlyNsq.max_attempts" do
         listener = described_class.new(topic: topic, processor: processor, channel: channel)
         expect(listener.max_attempts).to eq(FastlyNsq.max_attempts)
 
@@ -31,91 +31,91 @@ RSpec.describe FastlyNsq::Listener do
       end
     end
 
-    describe 'with FastlyNsq.channel set' do
+    describe "with FastlyNsq.channel set" do
       let!(:default_channel) { FastlyNsq.channel }
-      before { FastlyNsq.channel = 'fnsq' }
+      before { FastlyNsq.channel = "fnsq" }
       after { FastlyNsq.channel = default_channel }
 
-      it 'defaults to FastlyNsq.channel' do
+      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
+    describe "with FastlyNsq.preprocessor set" do
       let!(:default_preprocessor) { FastlyNsq.preprocessor }
-      before { FastlyNsq.preprocessor = 'fnsq' }
+      before { FastlyNsq.preprocessor = "fnsq" }
       after { FastlyNsq.preprocessor = default_preprocessor }
 
-      it 'defaults to FastlyNsq.preprocessor' do
+      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
+    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
+      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
+    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
+  describe "#priority" do
     specify { expect(subject.priority).to eq(described_class::DEFAULT_PRIORITY) }
   end
 
-  describe '#consumer' do
+  describe "#consumer" do
     specify { expect(subject.consumer).to be_a(FastlyNsq::Consumer) }
   end
 
-  describe 'connect_timeout' do
+  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'))
+  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'))
+  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))
+  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
+    describe "when the processor returns true" do
       let(:processor) { ->(_) { true } }
 
-      it 'finishes the message' do
-        message = spy('message', body: '{}')
+      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
+    describe "when the processor returns false" do
       let(:processor) { ->(_) { false } }
 
-      it 'finishes the message' do
-        message = spy('message', body: '{}')
+      it "finishes the message" do
+        message = spy("message", body: "{}")
         subject.call(message)
 
         expect(message).not_to have_received(:finish)
@@ -125,18 +125,18 @@ RSpec.describe FastlyNsq::Listener do
 
   it { should be_connected }
 
-  it 'should terminate' do
+  it "should terminate" do
     expect { subject.terminate }.to change(subject, :connected?).to(false)
   end
 
-  describe 'faking', :fake do
-    let!(:message) { JSON.dump('foo' => 'bar') }
+  describe "faking", :fake do
+    let!(:message) { JSON.dump("foo" => "bar") }
 
     before { subject }
 
     it { should be_connected }
 
-    it 'should terminate' do
+    it "should terminate" do
       expect { subject.terminate }.to change(subject, :connected?).to(false)
     end
 
@@ -149,49 +149,49 @@ RSpec.describe FastlyNsq::Listener do
       expect(test_message.raw_body).to eq(message)
     end
 
-    describe 'when the processor returns true' do
+    describe "when the processor returns true" do
       let(:processor) { ->(_) { true } }
 
-      it 'drains queued messages' do
+      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
+    describe "when the processor returns false" do
       let(:processor) { ->(_) { false } }
 
-      it 'does not remove messages' do
+      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) { JSON.dump('foo' => 'bar') }
+  describe "inline", :inline do
+    let!(:message) { JSON.dump("foo" => "bar") }
     let!(:processor) { ->(m) { messages << m.raw_body } }
 
     before { subject }
 
     it { should be_connected }
 
-    it 'should terminate' do
+    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
+    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
+    describe "when the processor returns false" do
       let(:processor) { ->(_) { false } }
 
-      it 'does not remove messages' do
+      it "does not remove messages" do
         FastlyNsq::Producer.new(topic: topic).write(message)
         expect { subject.drain }.not_to change { subject.messages.size }
       end

data/spec/manager_spec.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 RSpec.describe FastlyNsq::Manager do
-  let!(:topic) { 'fnsq' }
-  let!(:channel) { 'fnsq' }
+  let!(:topic) { "fnsq" }
+  let!(:channel) { "fnsq" }
 
   subject { FastlyNsq.manager }
 
@@ -14,33 +14,33 @@ RSpec.describe FastlyNsq::Manager do
 
   it { should_not be_stopped }
 
-  describe '#initialize' do
-    it 'allows max_threads to be specified' do
+  describe "#initialize" do
+    it "allows max_threads to be specified" do
       max_threads = FastlyNsq.max_processing_pool_threads * 2
       manager = described_class.new(max_threads: max_threads)
 
       expect(manager.pool.max_threads).to eq(max_threads)
     end
 
-    it 'defaults max_threads to FastlyNsq.max_processing_pool_threads' do
+    it "defaults max_threads to FastlyNsq.max_processing_pool_threads" do
       expect(subject.pool.max_threads).to eq(FastlyNsq.max_processing_pool_threads)
     end
 
-    it 'allows fallback_policy to be specified' do
+    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
+    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
+    it "defaults logger to FastlyNsq.logger" do
       expect(subject.logger).to eq(FastlyNsq.logger)
     end
 
-    it 'allows logger to be specified' do
+    it "allows logger to be specified" do
       logger = Logger.new(nil)
       manager = described_class.new(logger: logger)
 
@@ -48,39 +48,39 @@ RSpec.describe FastlyNsq::Manager do
     end
   end
 
-  context 'with a listener' do
+  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
+    it "tracks listener" do
       expect(subject.listeners).to contain_exactly(listener)
     end
 
-    it 'tracks topic listeners' do
+    it "tracks topic listeners" do
       expect(subject.topic_listeners).to eq(topic => listener)
     end
 
-    it 'tracks topics' do
+    it "tracks topics" do
       expect(subject.topics).to contain_exactly(topic)
     end
 
-    describe '#terminate' do
-      it 'terminates listeners' do
+    describe "#terminate" do
+      it "terminates listeners" do
         expect { subject.terminate(2) }.to change(listener, :connected?).to(false)
       end
 
-      it 'terminates the processing pool' do
+      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)
+      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
+      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
+        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)
@@ -89,19 +89,19 @@ RSpec.describe FastlyNsq::Manager do
     end
   end
 
-  it 'transfers' do
+  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 = 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)
+    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

data/spec/matchers/delegate.rb

@@ -9,22 +9,22 @@ RSpec::Matchers.define :delegate do |method|
     rescue NoMethodError
       raise "#{@delegator} does not respond to #{@to}!"
     end
-    allow(@delegator).to receive(@to).and_return(double('receiver', method => :called))
+    allow(@delegator).to receive(@to).and_return(double("receiver", method => :called))
     actual = (@delegator.send(@method) == :called)
     allow(@delegator).to receive(@to).and_call_original # unstub
     actual
   end
 
   description do
-    "delegate :#{@method} to its #{@to}#{@prefix ? ' with prefix' : ''}"
+    "delegate :#{@method} to its #{@to}#{@prefix ? " with prefix" : ""}"
   end
 
   failure_message do |_text|
-    "expected #{@delegator} to delegate :#{@method} to its #{@to}#{@prefix ? ' with prefix' : ''}"
+    "expected #{@delegator} to delegate :#{@method} to its #{@to}#{@prefix ? " with prefix" : ""}"
   end
 
   failure_message_when_negated do |_text|
-    "expected #{@delegator} not to delegate :#{@method} to its #{@to}#{@prefix ? ' with prefix' : ''}"
+    "expected #{@delegator} not to delegate :#{@method} to its #{@to}#{@prefix ? " with prefix" : ""}"
   end
 
   chain(:to) { |receiver| @to = receiver }

data/spec/message_spec.rb

@@ -1,35 +1,35 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-require 'json'
+require "spec_helper"
+require "json"
 
 RSpec.describe FastlyNsq::Message do
-  let(:nsq_message) { double 'Nsq::Message', body: json_body, attempts: 1, finish: nil, requeue: nil, touch: nil, timestamp: nil, id: nil }
-  let(:body)        { { 'data' => 'goes here', 'other_field' => 'is over here', 'meta' => 'meta stuff' } }
-  let(:json_body)   { body.to_json }
-  subject           { FastlyNsq::Message.new nsq_message }
+  let(:nsq_message) { double "Nsq::Message", body: json_body, attempts: 1, finish: nil, requeue: nil, touch: nil, timestamp: nil, id: nil }
+  let(:body) { {"data" => "goes here", "other_field" => "is over here", "meta" => "meta stuff"} }
+  let(:json_body) { body.to_json }
+  subject { FastlyNsq::Message.new nsq_message }
 
-  it 'preserves original message body as raw_body' do
+  it "preserves original message body as raw_body" do
     expect(subject.raw_body).to eq(json_body)
   end
 
-  it 'presents parsed message body as body' do
+  it "presents parsed message body as body" do
     expect(subject.body).to eq(body)
   end
 
-  it 'plucks data as data' do
-    expect(subject.data).to eq('goes here')
+  it "plucks data as data" do
+    expect(subject.data).to eq("goes here")
   end
 
-  it 'plucks meta as meta' do
-    expect(subject.meta).to eq(body['meta'])
+  it "plucks meta as meta" do
+    expect(subject.meta).to eq(body["meta"])
   end
 
-  it 'aliases raw_body to to_s' do
+  it "aliases raw_body to to_s" do
     expect(subject.to_s).to eq(json_body)
   end
 
-  it 'delegates methods to the nsq_message object' do
+  it "delegates methods to the nsq_message object" do
     %w[attempts finish requeue touch timestamp id].each do |method|
       subject = FastlyNsq::Message.new nsq_message
       expect(nsq_message).to receive(method)
@@ -38,7 +38,7 @@ RSpec.describe FastlyNsq::Message do
     end
   end
 
-  it 'does not finish if the message was requeued' do
+  it "does not finish if the message was requeued" do
     expect(nsq_message).to receive(:requeue).with(1000)
     expect(nsq_message).not_to receive(:finish)
 
@@ -48,7 +48,7 @@ RSpec.describe FastlyNsq::Message do
     expect(subject.managed).to eq(:requeued)
   end
 
-  it 'does not requeue if the message was finished' do
+  it "does not requeue if the message was finished" do
     expect(nsq_message).to receive(:finish)
     expect(nsq_message).not_to receive(:requeue)
 
@@ -58,19 +58,19 @@ RSpec.describe FastlyNsq::Message do
     expect(subject.managed).to eq(:finished)
   end
 
-  it 'uses the passed timeout for the requeue timeout' do
+  it "uses the passed timeout for the requeue timeout" do
     expect(nsq_message).to receive(:requeue).with(1000)
 
     subject.requeue(1000)
   end
 
-  it 'uses exponential backoff for timeout if none is given' do
+  it "uses exponential backoff for timeout if none is given" do
     expect(nsq_message).to receive(:requeue).with(46_000..166_000)
 
     subject.requeue
   end
 
-  it 'uses the FastlyNsq.max_req_timeout it timeout is larger than FastlyNsq.max_req_timeout' do
+  it "uses the FastlyNsq.max_req_timeout it timeout is larger than FastlyNsq.max_req_timeout" do
     expect(nsq_message).to receive(:requeue).with(60 * 60 * 1_000)
 
     subject.requeue(60 * 60 * 4 * 1_000)