fastly_nsq 1.16.0 → 1.18.0

data/spec/http/nsqd_spec.rb

@@ -1,77 +1,77 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-require 'fastly_nsq/http/nsqd'
+require "spec_helper"
+require "fastly_nsq/http/nsqd"
 
 RSpec.describe FastlyNsq::Http::Nsqd, :webmock do
-  let(:base_uri) { 'http://example.com' }
+  let(:base_uri) { "http://example.com" }
 
-  it 'makes simple get requests' do
+  it "makes simple get requests" do
     %w[ping info config/nsqlookupd_tcp_addresses].each do |api|
       url = "#{base_uri}/#{api}"
       stub_request(:get, url)
-      FastlyNsq::Http::Nsqd.send(api.tr('/', '_').to_sym, base_uri: base_uri)
+      FastlyNsq::Http::Nsqd.send(api.tr("/", "_").to_sym, base_uri: base_uri)
 
       expect(a_request(:get, url)).to have_been_requested
     end
   end
 
-  describe 'stats' do
-    it 'can fetch stats' do
+  describe "stats" do
+    it "can fetch stats" do
       url = "#{base_uri}/stats?topic=lol&channel=foo&format=json"
       stub_request(:get, url)
-      data = { topic: 'lol', channel: 'foo', format: 'json' }
+      data = {topic: "lol", channel: "foo", format: "json"}
 
-      FastlyNsq::Http::Nsqd.stats(topic: 'lol', channel: 'foo', base_uri: base_uri)
+      FastlyNsq::Http::Nsqd.stats(topic: "lol", channel: "foo", base_uri: base_uri)
 
       expect(a_request(:get, url).with(query: data)).to have_been_requested
     end
 
-    it 'raises InvaildFormatError if provided format is not in list' do
+    it "raises InvaildFormatError if provided format is not in list" do
       expect do
-        FastlyNsq::Http::Nsqd.stats(format: 'foo')
+        FastlyNsq::Http::Nsqd.stats(format: "foo")
       end.to raise_error(FastlyNsq::Http::Nsqd::InvalidFormatError)
     end
   end
 
-  it 'can publish messages' do
+  it "can publish messages" do
     url = "#{base_uri}/pub?topic=lol&defer=999"
     stub_request(:post, url)
-    data = { topic: 'lol', defer: 999 }
+    data = {topic: "lol", defer: 999}
 
-    FastlyNsq::Http::Nsqd.pub(topic: 'lol', defer: 999, message: 'SOMETHING', base_uri: base_uri)
+    FastlyNsq::Http::Nsqd.pub(topic: "lol", defer: 999, message: "SOMETHING", base_uri: base_uri)
 
-    expect(a_request(:post, url).with(query: data, body: 'SOMETHING')).to have_been_requested
+    expect(a_request(:post, url).with(query: data, body: "SOMETHING")).to have_been_requested
   end
 
-  it 'can publish multiple messages' do
+  it "can publish multiple messages" do
     url = "#{base_uri}/mpub?topic=lol&binary=false"
     stub_request(:post, url)
-    data = { topic: 'lol' }
+    data = {topic: "lol"}
     body = "ONE MESSAGE\nTWO MESSAGE\nRED MESSAGE\nBLUE MESSAGE"
 
-    FastlyNsq::Http::Nsqd.mpub(topic: 'lol', message: body, base_uri: base_uri)
+    FastlyNsq::Http::Nsqd.mpub(topic: "lol", message: body, base_uri: base_uri)
 
     expect(a_request(:post, url).with(query: data, body: body)).to have_been_requested
   end
 
-  it 'can create, delete, empty, pause and unpause topics and channels' do
+  it "can create, delete, empty, pause and unpause topics and channels" do
     verbs = %w[create delete empty pause unpause]
 
     verbs.each do |verb|
       url = "#{base_uri}/topic/#{verb}?topic=lol"
       stub_request(:post, url)
-      data = { topic: 'lol' }
+      data = {topic: "lol"}
 
-      FastlyNsq::Http::Nsqd.send("topic_#{verb}".to_sym, topic: 'lol', base_uri: base_uri)
+      FastlyNsq::Http::Nsqd.send("topic_#{verb}".to_sym, topic: "lol", base_uri: base_uri)
 
       expect(a_request(:post, url).with(query: data)).to have_been_requested
 
       url = "#{base_uri}/channel/#{verb}?topic=lol&channel=foo"
       stub_request(:post, url)
-      data = { topic: 'lol', channel: 'foo' }
+      data = {topic: "lol", channel: "foo"}
 
-      FastlyNsq::Http::Nsqd.send("channel_#{verb}".to_sym, topic: 'lol', channel: 'foo', base_uri: base_uri)
+      FastlyNsq::Http::Nsqd.send("channel_#{verb}".to_sym, topic: "lol", channel: "foo", base_uri: base_uri)
 
       expect(a_request(:post, url).with(query: data)).to have_been_requested
     end

data/spec/http/nsqlookupd_spec.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-require 'fastly_nsq/http/nsqlookupd'
+require "spec_helper"
+require "fastly_nsq/http/nsqlookupd"
 
 RSpec.describe FastlyNsq::Http::Nsqlookupd, :webmock do
-  let(:base_uri) { 'http://example.com' }
+  let(:base_uri) { "http://example.com" }
 
-  it 'makes simple get requests' do
+  it "makes simple get requests" do
     %w[topics nodes ping info].each do |api|
       url = "#{base_uri}/#{api}"
       stub_request(:get, url)
@@ -16,52 +16,52 @@ RSpec.describe FastlyNsq::Http::Nsqlookupd, :webmock do
     end
   end
 
-  it 'can lookup producers for a topic' do
+  it "can lookup producers for a topic" do
     url = "#{base_uri}/lookup?topic=lol"
     stub_request(:get, url)
-    data = { topic: 'lol' }
+    data = {topic: "lol"}
 
-    FastlyNsq::Http::Nsqlookupd.lookup(topic: 'lol', base_uri: base_uri)
+    FastlyNsq::Http::Nsqlookupd.lookup(topic: "lol", base_uri: base_uri)
 
     expect(a_request(:get, url).with(query: data)).to have_been_requested
   end
 
-  it 'can lookup channels for a topic' do
+  it "can lookup channels for a topic" do
     url = "#{base_uri}/channels?topic=lol"
     stub_request(:get, url)
-    data = { topic: 'lol' }
+    data = {topic: "lol"}
 
-    FastlyNsq::Http::Nsqlookupd.channels(topic: 'lol', base_uri: base_uri)
+    FastlyNsq::Http::Nsqlookupd.channels(topic: "lol", base_uri: base_uri)
 
     expect(a_request(:get, url).with(query: data)).to have_been_requested
   end
 
-  it 'can delete a topic' do
+  it "can delete a topic" do
     url = "#{base_uri}/delete_topic?topic=lol"
     stub_request(:get, url)
-    data = { topic: 'lol' }
+    data = {topic: "lol"}
 
-    FastlyNsq::Http::Nsqlookupd.delete_topic(topic: 'lol', base_uri: base_uri)
+    FastlyNsq::Http::Nsqlookupd.delete_topic(topic: "lol", base_uri: base_uri)
 
     expect(a_request(:get, url).with(query: data)).to have_been_requested
   end
 
-  it 'can delete a channel' do
+  it "can delete a channel" do
     url = "#{base_uri}/delete_channel?topic=lol&channel=foo"
     stub_request(:get, url)
-    data = { topic: 'lol', channel: 'foo' }
+    data = {topic: "lol", channel: "foo"}
 
-    FastlyNsq::Http::Nsqlookupd.delete_channel(topic: 'lol', channel: 'foo', base_uri: base_uri)
+    FastlyNsq::Http::Nsqlookupd.delete_channel(topic: "lol", channel: "foo", base_uri: base_uri)
 
     expect(a_request(:get, url).with(query: data)).to have_been_requested
   end
 
-  it 'can tombstone a producer' do
+  it "can tombstone a producer" do
     url = "#{base_uri}/tombstone_topic_producer?topic=lol&node=localhost:8989"
     stub_request(:get, url)
-    data = { topic: 'lol', node: 'localhost:8989' }
+    data = {topic: "lol", node: "localhost:8989"}
 
-    FastlyNsq::Http::Nsqlookupd.tombstone_topic_producer(topic: 'lol', node: 'localhost:8989', base_uri: base_uri)
+    FastlyNsq::Http::Nsqlookupd.tombstone_topic_producer(topic: "lol", node: "localhost:8989", base_uri: base_uri)
 
     expect(a_request(:get, url).with(query: data)).to have_been_requested
   end

data/spec/http_spec.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-require 'fastly_nsq/http'
+require "spec_helper"
+require "fastly_nsq/http"
 
 RSpec.describe FastlyNsq::Http, :webmock do
-  let(:base_url) { 'http://example.com' }
-  describe 'get' do
-    it 'can make simple requests' do
+  let(:base_url) { "http://example.com" }
+  describe "get" do
+    it "can make simple requests" do
       url = "#{base_url}/boop"
       stub_request(:get, url)
 
@@ -16,9 +16,9 @@ RSpec.describe FastlyNsq::Http, :webmock do
       expect(a_request(:get, url)).to have_been_requested.twice
     end
 
-    it 'can make requests with params' do
+    it "can make requests with params" do
       url = "#{base_url}/boop?sloop=noop"
-      data = { sloop: 'noop' }
+      data = {sloop: "noop"}
       stub_request(:get, url)
 
       FastlyNsq::Http.new(uri: url).get(data)
@@ -27,11 +27,11 @@ RSpec.describe FastlyNsq::Http, :webmock do
     end
   end
 
-  describe 'post' do
-    it 'can make simple post requests' do
+  describe "post" do
+    it "can make simple post requests" do
       url = "#{base_url}/boop?sloop=noop"
       stub_request(:post, url)
-      data = { sloop: 'noop' }
+      data = {sloop: "noop"}
 
       FastlyNsq::Http.new(uri: URI.parse(url)).post(data)
       FastlyNsq::Http.new(uri: url).post(data)
@@ -39,11 +39,11 @@ RSpec.describe FastlyNsq::Http, :webmock do
       expect(a_request(:post, url)).to have_been_requested.twice
     end
 
-    it 'can make post requests with bodies' do
+    it "can make post requests with bodies" do
       url = "#{base_url}/boop?sloop=noop"
       stub_request(:post, url)
-      data = { sloop: 'noop' }
-      body = 'SOME MESSAGE'
+      data = {sloop: "noop"}
+      body = "SOME MESSAGE"
 
       FastlyNsq::Http.new(uri: url).post(data, body)
 
@@ -51,18 +51,18 @@ RSpec.describe FastlyNsq::Http, :webmock do
     end
   end
 
-  describe 'SSL' do
-    it 'can be asked to use SSL' do
-      ssl_url = 'https://example.com:80/boop'
+  describe "SSL" do
+    it "can be asked to use SSL" do
+      ssl_url = "https://example.com:80/boop"
       stub_request(:get, ssl_url)
 
-      cert_file = '/tmp/thing.cert'
-      key_file = '/tmp/thing.key'
+      cert_file = "/tmp/thing.cert"
+      key_file = "/tmp/thing.key"
 
-      allow(File).to receive(:read).with(cert_file).and_return('something')
-      allow(File).to receive(:read).with(key_file).and_return('something')
-      allow(OpenSSL::X509::Certificate).to receive(:new).with('something').and_return(true)
-      allow(OpenSSL::PKey::RSA).to receive(:new).with('something').and_return(true)
+      allow(File).to receive(:read).with(cert_file).and_return("something")
+      allow(File).to receive(:read).with(key_file).and_return("something")
+      allow(OpenSSL::X509::Certificate).to receive(:new).with("something").and_return(true)
+      allow(OpenSSL::PKey::RSA).to receive(:new).with("something").and_return(true)
 
       url = "#{base_url}/boop"
       http = FastlyNsq::Http.new(uri: url, cert_filename: cert_file, key_filename: key_file)

data/spec/integration_spec.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
-RSpec.describe 'integration' do
-  let!(:topic) { 'fnsq-topic' }
-  let!(:channel) { 'fnsq-channel' }
-  let!(:message) { { 'foo' => 'bar' } }
+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
+  it "processes jobs" do
     received = nil
     producer = FastlyNsq::Producer.new(topic: topic)
     FastlyNsq::Listener.new(topic: topic, channel: channel, processor: ->(m) { received = m })
@@ -18,8 +18,8 @@ RSpec.describe 'integration' do
     expect { received&.body }.to eventually(eq(message)).within(2)
   end
 
-  describe 'inline', :inline do
-    it 'processes job' do
+  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 })
@@ -29,8 +29,8 @@ RSpec.describe 'integration' do
     end
   end
 
-  describe 'fake', :fake do
-    it 'stores jobs' do
+  describe "fake", :fake do
+    it "stores jobs" do
       received = nil
       encoded_message = JSON.dump(message)
       producer = FastlyNsq::Producer.new(topic: topic)

data/spec/launcher_spec.rb

@@ -1,40 +1,40 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 RSpec.describe FastlyNsq::Launcher do
-  let!(:channel)  { 'fnsq' }
-  let!(:options)  { { max_threads: 3, timeout: 9 } }
-  let!(:topic)    { 'fnsq' }
+  let!(:channel) { "fnsq" }
+  let!(:options) { {max_threads: 3, timeout: 9} }
+  let!(:topic) { "fnsq" }
 
-  let(:launcher) { FastlyNsq::Launcher.new options }
-  let(:listener)  { FastlyNsq::Listener.new(topic: topic, channel: channel, processor: ->(*) {}) }
+  let(:launcher) { FastlyNsq::Launcher.new(**options) }
+  let(:listener) { FastlyNsq::Listener.new(topic: topic, channel: channel, processor: ->(*) {}) }
   let(:manager) { launcher.manager }
 
   before { reset_topic(topic, channel: channel) }
   before { expect { listener }.to eventually(be_connected).within(5) }
-  after  { listener.terminate if listener.connected? }
+  after { listener.terminate if listener.connected? }
 
-  it 'creates a manager with correct options' do
+  it "creates a manager with correct options" do
     launcher
 
     expect(FastlyNsq.manager.pool.max_threads).to eq(3)
   end
 
-  describe '#beat' do
-    let!(:logger)   { Logger.new(nil).tap { |l| l.level = Logger::DEBUG } }
+  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
+    it "creates a heartbeat thread" do
       expect(logger).not_to receive(:error)
-      expect { launcher.beat }.to eventually_not(eq('dead')).pause_for(1)
+      expect { launcher.beat }.to eventually_not(eq("dead")).pause_for(1)
     end
   end
 
-  describe '#stop_listeners' do
+  describe "#stop_listeners" do
     before { launcher }
 
-    it 'stops listeners and sets done' 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)
@@ -45,20 +45,20 @@ RSpec.describe FastlyNsq::Launcher do
     end
   end
 
-  describe '#stop' do
+  describe "#stop" do
     before { launcher }
 
-    it 'stops the manager within a deadline' do
+    it "stops the manager within a deadline" do
       expect(manager).to receive(:terminate).with(options[:timeout])
       launcher.stop
     end
   end
 
-  describe 'callbacks' do
+  describe "callbacks" do
     before { FastlyNsq.events.each { |(_, v)| v.clear } }
-    after  { FastlyNsq.events.each { |(_, v)| v.clear } }
+    after { FastlyNsq.events.each { |(_, v)| v.clear } }
 
-    it 'fires :startup event on initialization' do
+    it "fires :startup event on initialization" do
       obj = spy
       block = -> { obj.start }
       FastlyNsq.on(:startup, &block)
@@ -67,7 +67,7 @@ RSpec.describe FastlyNsq::Launcher do
       expect(obj).to have_received(:start)
     end
 
-    it 'fires :shutdown event on #stop' do
+    it "fires :shutdown event on #stop" do
       launcher
 
       obj = spy
@@ -78,7 +78,7 @@ RSpec.describe FastlyNsq::Launcher do
       expect(obj).to have_received(:stop)
     end
 
-    it 'fires :heartbeat event on #heartbeat' do
+    it "fires :heartbeat event on #heartbeat" do
       obj = spy
       block = -> { obj.beat }
       FastlyNsq.on(:heartbeat, &block)

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), attempts: 1, id: 1)
       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: "{}", attempts: 1, id: 1)
         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: "{}", attempts: 1, id: 1)
         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